diff options
| author | julian <julian@FreeBSD.org> | 2001-09-12 08:38:13 +0000 |
|---|---|---|
| committer | julian <julian@FreeBSD.org> | 2001-09-12 08:38:13 +0000 |
| commit | 5596676e6c6c1e81e899cd0531f9b1c28a292669 (patch) | |
| tree | b1a19fcdf05759281fab0d89efb13f0fdf42102e | |
| parent | 83e00d4274950d2b531c24692cd123538ffbddb9 (diff) | |
| download | FreeBSD-src-5596676e6c6c1e81e899cd0531f9b1c28a292669.zip FreeBSD-src-5596676e6c6c1e81e899cd0531f9b1c28a292669.tar.gz | |
KSE Milestone 2
Note ALL MODULES MUST BE RECOMPILED
make the kernel aware that there are smaller units of scheduling than the
process. (but only allow one thread per process at this time).
This is functionally equivalent to teh previousl -current except
that there is a thread associated with each process.
Sorry john! (your next MFC will be a doosie!)
Reviewed by: peter@freebsd.org, dillon@freebsd.org
X-MFC after: ha ha ha ha
782 files changed, 15917 insertions, 13909 deletions
diff --git a/bin/ps/print.c b/bin/ps/print.c index 2750db3..471f3fe 100644 --- a/bin/ps/print.c +++ b/bin/ps/print.c @@ -169,7 +169,7 @@ state(k, ve) KINFO *k; VARENT *ve; { - int flag, sflag; + int flag, sflag, tdflags; char *cp; VAR *v; char buf[16]; @@ -177,6 +177,7 @@ state(k, ve) v = ve->var; flag = k->ki_p->ki_flag; sflag = k->ki_p->ki_sflag; + tdflags = k->ki_p->ki_tdflags; /* XXXKSE */ cp = buf; switch (k->ki_p->ki_stat) { @@ -186,7 +187,7 @@ state(k, ve) break; case SSLEEP: - if (sflag & PS_SINTR) /* interruptable (long) */ + if (tdflags & TDF_SINTR) /* interruptable (long) */ *cp = k->ki_p->ki_slptime >= MAXSLP ? 'I' : 'S'; else *cp = 'D'; diff --git a/gnu/usr.bin/binutils/gdb/i386/freebsd-nat.c b/gnu/usr.bin/binutils/gdb/i386/freebsd-nat.c index 386f522..45beee1 100644 --- a/gnu/usr.bin/binutils/gdb/i386/freebsd-nat.c +++ b/gnu/usr.bin/binutils/gdb/i386/freebsd-nat.c @@ -104,21 +104,21 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr) register int addr; int bad_reg = -1; int offset; - struct user *tmp_uaddr; + struct pcb *tmp_pcbaddr; /* * First get virtual address of user structure. Then calculate offset. */ - memcpy(&tmp_uaddr, - &((struct user *) core_reg_sect)->u_kproc.ki_addr, - sizeof(tmp_uaddr)); - offset = -reg_addr - (int) tmp_uaddr; + memcpy(&tmp_pcbaddr, + &((struct user *) core_reg_sect)->u_kproc.ki_pcb, + sizeof(tmp_pcbaddr)); + offset = -reg_addr - (int) tmp_pcbaddr; for (regno = 0; regno < NUM_REGS; regno++) { cregno = tregmap[regno]; if (cregno == tGS) - addr = offsetof (struct user, u_pcb) + offsetof (struct pcb, pcb_gs); + addr = offsetof (struct pcb, pcb_gs); else addr = offset + 4 * cregno; if (addr < 0 || addr >= core_reg_size) @@ -136,11 +136,7 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr) error ("Register %s not found in core file.", gdb_register_names[bad_reg]); } -#if __FreeBSD_version >= 500022 - addr = offsetof (struct user, u_pcb) + offsetof (struct pcb, pcb_save); -#else - addr = offsetof (struct user, u_pcb) + offsetof (struct pcb, pcb_savefpu); -#endif + addr = offsetof (struct pcb, pcb_save); memcpy (&pcb_savefpu, core_reg_sect + addr, sizeof pcb_savefpu); } @@ -170,11 +166,6 @@ extern void print_387_control_word (); /* i387-tdep.h */ extern void print_387_status_word (); #define fpstate save87 -#if __FreeBSD_version >= 500022 -#define U_FPSTATE(u) u.u_pcb.pcb_save.sv_87 -#else -#define U_FPSTATE(u) u.u_pcb.pcb_savefpu -#endif static void i387_to_double (from, to) @@ -344,15 +335,13 @@ i386_float_info () /* fpstate defined in <sys/user.h> */ struct fpstate *fpstatep; char buf[sizeof (struct fpstate) + 2 * sizeof (int)]; - unsigned int uaddr; char fpvalid; unsigned int rounded_addr; unsigned int rounded_size; /*extern int corechan;*/ int skip; extern int inferior_pid; - - uaddr = (char *)&U_FPSTATE(u) - (char *)&u; + if (inferior_pid != 0 && core_bfd == NULL) { int pid = inferior_pid & ((1 << 17) - 1); /* XXX extract pid from tid */ diff --git a/gnu/usr.bin/binutils/gdb/i386/kvm-fbsd.c b/gnu/usr.bin/binutils/gdb/i386/kvm-fbsd.c index fdfc6a3..8a91d97 100644 --- a/gnu/usr.bin/binutils/gdb/i386/kvm-fbsd.c +++ b/gnu/usr.bin/binutils/gdb/i386/kvm-fbsd.c @@ -201,8 +201,12 @@ static struct proc * curProc () { struct proc *p; - CORE_ADDR addr = pcpu + PCPU_OFFSET (curproc); + struct thread *td; + CORE_ADDR addr = pcpu + PCPU_OFFSET (curthread); + if (kvread (addr, &td)) + error ("cannot read thread pointer at %x\n", addr); + addr = (CORE_ADDR)td->td_proc; if (kvread (addr, &p)) error ("cannot read proc pointer at %x\n", addr); return p; @@ -380,13 +384,13 @@ static void get_kcore_registers (regno) int regno; { - struct user *uaddr; + struct pcb *pcbaddr; /* find the pcb for the current process */ - if (cur_proc == NULL || kvread (&cur_proc->p_addr, &uaddr)) + if (cur_proc == NULL || kvread (&cur_proc->p_thread.td_pcb, &pcbaddr)) /* XXXKSE */ error ("cannot read u area ptr for proc at %#x", cur_proc); - if (read_pcb (core_kd, (CORE_ADDR)&uaddr->u_pcb) < 0) - error ("cannot read pcb at %#x", &uaddr->u_pcb); + if (read_pcb (core_kd, (CORE_ADDR)pcbaddr) < 0) + error ("cannot read pcb at %#x", pcbaddr); } static void diff --git a/gnu/usr.bin/binutils/gdb/kvm-fbsd.c b/gnu/usr.bin/binutils/gdb/kvm-fbsd.c index fdfc6a3..8a91d97 100644 --- a/gnu/usr.bin/binutils/gdb/kvm-fbsd.c +++ b/gnu/usr.bin/binutils/gdb/kvm-fbsd.c @@ -201,8 +201,12 @@ static struct proc * curProc () { struct proc *p; - CORE_ADDR addr = pcpu + PCPU_OFFSET (curproc); + struct thread *td; + CORE_ADDR addr = pcpu + PCPU_OFFSET (curthread); + if (kvread (addr, &td)) + error ("cannot read thread pointer at %x\n", addr); + addr = (CORE_ADDR)td->td_proc; if (kvread (addr, &p)) error ("cannot read proc pointer at %x\n", addr); return p; @@ -380,13 +384,13 @@ static void get_kcore_registers (regno) int regno; { - struct user *uaddr; + struct pcb *pcbaddr; /* find the pcb for the current process */ - if (cur_proc == NULL || kvread (&cur_proc->p_addr, &uaddr)) + if (cur_proc == NULL || kvread (&cur_proc->p_thread.td_pcb, &pcbaddr)) /* XXXKSE */ error ("cannot read u area ptr for proc at %#x", cur_proc); - if (read_pcb (core_kd, (CORE_ADDR)&uaddr->u_pcb) < 0) - error ("cannot read pcb at %#x", &uaddr->u_pcb); + if (read_pcb (core_kd, (CORE_ADDR)pcbaddr) < 0) + error ("cannot read pcb at %#x", pcbaddr); } static void diff --git a/lib/libkvm/kvm_proc.c b/lib/libkvm/kvm_proc.c index b779284..815382c 100644 --- a/lib/libkvm/kvm_proc.c +++ b/lib/libkvm/kvm_proc.c @@ -168,7 +168,8 @@ kvm_proclist(kd, what, arg, p, bp, maxcnt) * gather kinfo_proc */ kp->ki_paddr = p; - kp->ki_addr = proc.p_addr; + kp->ki_addr = proc.p_uarea; + /* kp->ki_kstack = proc.p_thread.td_kstack; XXXKSE */ kp->ki_args = proc.p_args; kp->ki_tracep = proc.p_tracep; kp->ki_textvp = proc.p_textvp; @@ -258,8 +259,8 @@ kvm_proclist(kd, what, arg, p, bp, maxcnt) nopgrp: kp->ki_tdev = NODEV; } - if (proc.p_wmesg) - (void)kvm_read(kd, (u_long)proc.p_wmesg, + if (proc.p_thread.td_wmesg) /* XXXKSE */ + (void)kvm_read(kd, (u_long)proc.p_thread.td_wmesg, kp->ki_wmesg, WMESGLEN); #ifdef sparc @@ -297,10 +298,10 @@ nopgrp: strncpy(kp->ki_comm, proc.p_comm, MAXCOMLEN); kp->ki_comm[MAXCOMLEN] = 0; } - if (proc.p_blocked != 0) { + if (proc.p_thread.td_blocked != 0) { /* XXXKSE */ kp->ki_kiflag |= KI_MTXBLOCK; - if (proc.p_mtxname) - (void)kvm_read(kd, (u_long)proc.p_mtxname, + if (proc.p_thread.td_mtxname) /* XXXKSE */ + (void)kvm_read(kd, (u_long)proc.p_thread.td_mtxname, kp->ki_mtxname, MTXNAMELEN); kp->ki_mtxname[MTXNAMELEN] = 0; } @@ -310,21 +311,21 @@ nopgrp: kp->ki_sigmask = proc.p_sigmask; kp->ki_xstat = proc.p_xstat; kp->ki_acflag = proc.p_acflag; - kp->ki_pctcpu = proc.p_pctcpu; - kp->ki_estcpu = proc.p_estcpu; - kp->ki_slptime = proc.p_slptime; + kp->ki_pctcpu = proc.p_kse.ke_pctcpu; /* XXXKSE */ + kp->ki_estcpu = proc.p_ksegrp.kg_estcpu; /* XXXKSE */ + kp->ki_slptime = proc.p_kse.ke_slptime; /* XXXKSE */ kp->ki_swtime = proc.p_swtime; kp->ki_flag = proc.p_flag; kp->ki_sflag = proc.p_sflag; - kp->ki_wchan = proc.p_wchan; + kp->ki_wchan = proc.p_thread.td_wchan; /* XXXKSE */ kp->ki_traceflag = proc.p_traceflag; kp->ki_stat = proc.p_stat; - kp->ki_pri = proc.p_pri; - kp->ki_nice = proc.p_nice; + kp->ki_pri = proc.p_ksegrp.kg_pri; /* XXXKSE */ + kp->ki_nice = proc.p_ksegrp.kg_nice; /* XXXKSE */ kp->ki_lock = proc.p_lock; - kp->ki_rqindex = proc.p_rqindex; - kp->ki_oncpu = proc.p_oncpu; - kp->ki_lastcpu = proc.p_lastcpu; + kp->ki_rqindex = proc.p_kse.ke_rqindex; /* XXXKSE */ + kp->ki_oncpu = proc.p_kse.ke_oncpu; /* XXXKSE */ + kp->ki_lastcpu = proc.p_thread.td_lastcpu; /* XXXKSE */ bcopy(&kinfo_proc, bp, sizeof(kinfo_proc)); ++bp; ++cnt; 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); diff --git a/sys/amd64/amd64/apic_vector.S b/sys/amd64/amd64/apic_vector.S index 5c68f81..8096d3c 100644 --- a/sys/amd64/amd64/apic_vector.S +++ b/sys/amd64/amd64/apic_vector.S @@ -48,10 +48,10 @@ IDTVEC(vec_name) ; \ movl $KPSEL,%eax ; \ mov %ax,%fs ; \ FAKE_MCOUNT(13*4(%esp)) ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ pushl intr_unit + (irq_num) * 4 ; \ - call *intr_handler + (irq_num) * 4 ; /* do the work ASAP */ \ + call *intr_handler + (irq_num) * 4 ; /* do the work ASAP */ \ addl $4, %esp ; \ movl $0, lapic+LA_EOI ; \ lock ; \ @@ -59,7 +59,7 @@ IDTVEC(vec_name) ; \ movl intr_countp + (irq_num) * 4, %eax ; \ lock ; \ incl (%eax) ; \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ jmp doreti @@ -152,8 +152,8 @@ IDTVEC(vec_name) ; \ MASK_LEVEL_IRQ(irq_num) ; \ EOI_IRQ(irq_num) ; \ 0: ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ ; \ /* entry point used by doreti_unpend for HWIs. */ \ __CONCAT(Xresume,irq_num): ; \ @@ -162,7 +162,7 @@ __CONCAT(Xresume,irq_num): ; \ call sched_ithd ; \ addl $4, %esp ; /* discard the parameter */ \ ; \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ jmp doreti @@ -227,10 +227,10 @@ Xhardclock: movl $0, lapic+LA_EOI /* End Of Interrupt to APIC */ - movl PCPU(CURPROC),%ebx - incl P_INTR_NESTING_LEVEL(%ebx) + movl PCPU(CURTHREAD),%ebx + incl TD_INTR_NESTING_LEVEL(%ebx) call forwarded_hardclock - decl P_INTR_NESTING_LEVEL(%ebx) + decl TD_INTR_NESTING_LEVEL(%ebx) MEXITCOUNT jmp doreti @@ -252,10 +252,10 @@ Xstatclock: movl $0, lapic+LA_EOI /* End Of Interrupt to APIC */ FAKE_MCOUNT(13*4(%esp)) - movl PCPU(CURPROC),%ebx - incl P_INTR_NESTING_LEVEL(%ebx) + movl PCPU(CURTHREAD),%ebx + incl TD_INTR_NESTING_LEVEL(%ebx) call forwarded_statclock - decl P_INTR_NESTING_LEVEL(%ebx) + decl TD_INTR_NESTING_LEVEL(%ebx) MEXITCOUNT jmp doreti diff --git a/sys/amd64/amd64/cpu_switch.S b/sys/amd64/amd64/cpu_switch.S index 0f2f7a8..075aa36 100644 --- a/sys/amd64/amd64/cpu_switch.S +++ b/sys/amd64/amd64/cpu_switch.S @@ -77,17 +77,17 @@ ENTRY(cpu_throw) ENTRY(cpu_switch) /* switch to new process. first, save context as needed */ - movl PCPU(CURPROC),%ecx + movl PCPU(CURTHREAD),%ecx /* if no process to save, don't bother */ testl %ecx,%ecx jz sw1 - - movl P_VMSPACE(%ecx), %edx + movl TD_PROC(%ecx), %eax + movl P_VMSPACE(%eax), %edx movl PCPU(CPUID), %eax btrl %eax, VM_PMAP+PM_ACTIVE(%edx) - movl P_ADDR(%ecx),%edx + movl TD_PCB(%ecx),%edx movl (%esp),%eax /* Hardware registers */ movl %eax,PCB_EIP(%edx) @@ -124,7 +124,7 @@ ENTRY(cpu_switch) #ifdef DEV_NPX /* have we used fp, and need a save? */ - cmpl %ecx,PCPU(NPXPROC) + cmpl %ecx,PCPU(NPXTHREAD) jne 1f addl $PCB_SAVEFPU,%edx /* h/w bugs make saving complicated */ pushl %edx @@ -133,7 +133,11 @@ ENTRY(cpu_switch) 1: #endif /* DEV_NPX */ +/*##########################################################################*/ +/*##########################################################################*/ +/*##########################################################################*/ /* save is done, now choose a new process */ + /* But still trashing space above the old "Top Of Stack".. */ sw1: #ifdef SMP @@ -143,17 +147,17 @@ sw1: cmpl $0,PCPU(CPUID) je 1f - movl PCPU(IDLEPROC), %eax - jmp sw1b + movl PCPU(IDLETHREAD), %eax + jmp sw1b /* Idle thread can run on any kernel context */ 1: #endif /* - * Choose a new process to schedule. chooseproc() returns idleproc + * Choose a new process to schedule. choosethread() returns idleproc * if it cannot find another process to run. */ sw1a: - call chooseproc /* trash ecx, edx, ret eax*/ + call choosethread /* trash ecx, edx, ret eax*/ #ifdef INVARIANTS testl %eax,%eax /* no process? */ @@ -163,15 +167,20 @@ sw1b: movl %eax,%ecx #ifdef INVARIANTS - cmpb $SRUN,P_STAT(%ecx) + movl TD_PROC(%ecx), %eax /* XXXKSE */ + cmpb $SRUN,P_STAT(%eax) jne badsw2 #endif - movl P_ADDR(%ecx),%edx + movl TD_PCB(%ecx),%edx #if defined(SWTCH_OPTIM_STATS) incl swtch_optim_stats #endif + +/*##########################################################################*/ +/*##########################################################################*/ +/*##########################################################################*/ /* switch address space */ movl %cr3,%ebx cmpl PCB_CR3(%edx),%ebx @@ -181,9 +190,8 @@ sw1b: incl tlb_flush_count #endif movl PCB_CR3(%edx),%ebx - movl %ebx,%cr3 + movl %ebx,%cr3 /* LOAD NEW PAGE TABLES */ 4: - movl PCPU(CPUID), %esi cmpl $0, PCB_EXT(%edx) /* has pcb extension? */ je 1f @@ -191,12 +199,9 @@ sw1b: movl PCB_EXT(%edx), %edi /* new tss descriptor */ jmp 2f 1: - /* update common_tss.tss_esp0 pointer */ - movl %edx, %ebx /* pcb */ - addl $(UPAGES * PAGE_SIZE - 16), %ebx - movl %ebx, PCPU(COMMON_TSS) + TSS_ESP0 - + /* esp points to base of usable stack */ + movl %edx, PCPU(COMMON_TSS) + TSS_ESP0 /* stack is below pcb */ btrl %esi, private_tss jae 3f PCPU_ADDR(COMMON_TSSD, %edi) @@ -210,7 +215,9 @@ sw1b: movl $GPROC0_SEL*8, %esi /* GSEL(entry, SEL_KPL) */ ltr %si 3: - movl P_VMSPACE(%ecx), %ebx + /* note in a vmspace that this cpu is using it */ + movl TD_PROC(%ecx),%eax /* get proc from thread XXXKSE */ + movl P_VMSPACE(%eax), %ebx /* get vmspace of proc */ movl PCPU(CPUID), %eax btsl %eax, VM_PMAP+PM_ACTIVE(%ebx) @@ -233,22 +240,23 @@ sw1b: #endif /** GRAB_LOPRIO */ #endif /* SMP */ movl %edx, PCPU(CURPCB) - movl %ecx, PCPU(CURPROC) /* into next process */ + movl %ecx, PCPU(CURTHREAD) /* into next process */ #ifdef SMP /* XXX FIXME: we should be restoring the local APIC TPR */ #endif /* SMP */ - cmpl $0, PCB_USERLDT(%edx) - jnz 1f - movl _default_ldt,%eax - cmpl PCPU(CURRENTLDT),%eax - je 2f - lldt _default_ldt - movl %eax,PCPU(CURRENTLDT) + cmpl $0, PCB_USERLDT(%edx) /* if there is one */ + jnz 1f /* then use it */ + movl _default_ldt,%eax /* We will use the default */ + cmpl PCPU(CURRENTLDT),%eax /* check to see if already loaded */ + je 2f /* if so skip reload */ + lldt _default_ldt /* load the default... we trust it. */ + movl %eax,PCPU(CURRENTLDT) /* store what we have */ jmp 2f -1: pushl %edx - call set_user_ldt + +1: pushl %edx /* call a non-trusting routine */ + call set_user_ldt /* to check and load the ldt */ popl %edx 2: @@ -275,7 +283,7 @@ cpu_switch_load_gs: andl $0x0000fc00,%eax /* reserved bits */ pushl %ebx movl PCB_DR7(%edx),%ebx - andl $~0x0000fc00,%ebx + andl $~0x0000fc00,%ebx /* re-enable the restored watchpoints */ orl %ebx,%eax popl %ebx movl %eax,%dr7 @@ -322,25 +330,25 @@ ENTRY(savectx) #ifdef DEV_NPX /* - * If npxproc == NULL, then the npx h/w state is irrelevant and the + * If npxthread == NULL, then the npx h/w state is irrelevant and the * state had better already be in the pcb. This is true for forks * but not for dumps (the old book-keeping with FP flags in the pcb * always lost for dumps because the dump pcb has 0 flags). * - * If npxproc != NULL, then we have to save the npx h/w state to - * npxproc's pcb and copy it to the requested pcb, or save to the + * If npxthread != NULL, then we have to save the npx h/w state to + * npxthread's pcb and copy it to the requested pcb, or save to the * requested pcb and reload. Copying is easier because we would * have to handle h/w bugs for reloading. We used to lose the * parent's npx state for forks by forgetting to reload. */ pushfl cli - movl PCPU(NPXPROC),%eax + movl PCPU(NPXTHREAD),%eax testl %eax,%eax je 1f pushl %ecx - movl P_ADDR(%eax),%eax + movl TD_PCB(%eax),%eax leal PCB_SAVEFPU(%eax),%eax pushl %eax pushl %eax diff --git a/sys/amd64/amd64/db_interface.c b/sys/amd64/amd64/db_interface.c index a2e5018..7e78088 100644 --- a/sys/amd64/amd64/db_interface.c +++ b/sys/amd64/amd64/db_interface.c @@ -351,23 +351,24 @@ DB_SHOW_COMMAND(pcpu, db_show_pcpu) gd = GLOBALDATA; #endif db_printf("cpuid = %d\n", gd->gd_cpuid); - 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("npxproc = "); - if (gd->gd_npxproc != NULL) - db_printf("%p: pid %d \"%s\"\n", gd->gd_npxproc, - gd->gd_npxproc->p_pid, gd->gd_npxproc->p_comm); + db_printf("npxthread = "); + if (gd->gd_npxthread != NULL) + db_printf("%p: pid %d \"%s\"\n", gd->gd_npxthread, + gd->gd_npxthread->td_proc->p_pid, gd->gd_npxthread->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/amd64/amd64/db_trace.c b/sys/amd64/amd64/db_trace.c index dc1e2f0..3a07050 100644 --- a/sys/amd64/amd64/db_trace.c +++ b/sys/amd64/amd64/db_trace.c @@ -291,13 +291,15 @@ db_stack_trace_cmd(addr, have_addr, count, modif) boolean_t first; struct pcb *pcb; struct proc *p; + struct thread *td; pid_t pid; if (count == -1) count = 1024; if (!have_addr) { - p = curproc; + td = curthread; + p = td->td_proc; frame = (struct i386_frame *)ddb_regs.tf_ebp; if (frame == NULL) frame = (struct i386_frame *)(ddb_regs.tf_esp - 4); @@ -310,8 +312,9 @@ db_stack_trace_cmd(addr, have_addr, count, modif) * 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; frame = (struct i386_frame *)ddb_regs.tf_ebp; if (frame == NULL) frame = (struct i386_frame *) @@ -333,7 +336,7 @@ db_stack_trace_cmd(addr, have_addr, count, modif) db_printf("pid %d swapped out\n", pid); return; } - pcb = &p->p_addr->u_pcb; + pcb = p->p_thread.td_pcb; /* XXXKSE */ frame = (struct i386_frame *)pcb->pcb_ebp; if (frame == NULL) frame = (struct i386_frame *) diff --git a/sys/amd64/amd64/fpu.c b/sys/amd64/amd64/fpu.c index 4fe3d04..84534ea 100644 --- a/sys/amd64/amd64/fpu.c +++ b/sys/amd64/amd64/fpu.c @@ -128,23 +128,23 @@ void stop_emulating __P((void)); #endif /* __GNUC__ */ #ifdef CPU_ENABLE_SSE -#define GET_FPU_CW(proc) \ +#define GET_FPU_CW(thread) \ (cpu_fxsr ? \ - (proc)->p_addr->u_pcb.pcb_save.sv_xmm.sv_env.en_cw : \ - (proc)->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_cw) -#define GET_FPU_SW(proc) \ + (thread)->td_pcb->pcb_save.sv_xmm.sv_env.en_cw : \ + (thread)->td_pcb->pcb_save.sv_87.sv_env.en_cw) +#define GET_FPU_SW(thread) \ (cpu_fxsr ? \ - (proc)->p_addr->u_pcb.pcb_save.sv_xmm.sv_env.en_sw : \ - (proc)->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_sw) + (thread)->td_pcb->pcb_save.sv_xmm.sv_env.en_sw : \ + (thread)->td_pcb->pcb_save.sv_87.sv_env.en_sw) #define GET_FPU_EXSW_PTR(pcb) \ (cpu_fxsr ? \ &(pcb)->pcb_save.sv_xmm.sv_ex_sw : \ &(pcb)->pcb_save.sv_87.sv_ex_sw) #else /* CPU_ENABLE_SSE */ -#define GET_FPU_CW(proc) \ - (proc->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_cw) -#define GET_FPU_SW(proc) \ - (proc->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_sw) +#define GET_FPU_CW(thread) \ + (thread->td_pcb->pcb_save.sv_87.sv_env.en_cw) +#define GET_FPU_SW(thread) \ + (thread->td_pcb->pcb_save.sv_87.sv_env.en_sw) #define GET_FPU_EXSW_PTR(pcb) \ (&(pcb)->pcb_save.sv_87.sv_ex_sw) #endif /* CPU_ENABLE_SSE */ @@ -241,7 +241,7 @@ static void npx_intr(dummy) void *dummy; { - struct proc *p; + struct thread *td; /* * The BUSY# latch must be cleared in all cases so that the next @@ -250,22 +250,22 @@ npx_intr(dummy) outb(0xf0, 0); /* - * npxproc is normally non-null here. In that case, schedule an + * npxthread is normally non-null here. In that case, schedule an * AST to finish the exception handling in the correct context - * (this interrupt may occur after the process has entered the + * (this interrupt may occur after the thread has entered the * kernel via a syscall or an interrupt). Otherwise, the npx - * state of the process that caused this interrupt must have been - * pushed to the process' pcb, and clearing of the busy latch + * state of the thread that caused this interrupt must have been + * pushed to the thread' pcb, and clearing of the busy latch * above has finished the (essentially null) handling of this * interrupt. Control will eventually return to the instruction * that caused it and it will repeat. We will eventually (usually * soon) win the race to handle the interrupt properly. */ - p = PCPU_GET(npxproc); - if (p != NULL) { - p->p_addr->u_pcb.pcb_flags |= PCB_NPXTRAP; + td = PCPU_GET(npxthread); + if (td != NULL) { + td->td_pcb->pcb_flags |= PCB_NPXTRAP; mtx_lock_spin(&sched_lock); - p->p_sflag |= PS_ASTPENDING; + td->td_kse->ke_flags |= KEF_ASTPENDING; mtx_unlock_spin(&sched_lock); } } @@ -570,7 +570,7 @@ npxinit(control) /* * fninit has the same h/w bugs as fnsave. Use the detoxified * fnsave to throw away any junk in the fpu. npxsave() initializes - * the fpu and sets npxproc = NULL as important side effects. + * the fpu and sets npxthread = NULL as important side effects. */ savecrit = critical_enter(); npxsave(&dummy); @@ -586,13 +586,13 @@ npxinit(control) * Free coprocessor (if we have it). */ void -npxexit(p) - struct proc *p; +npxexit(td) + struct thread *td; { critical_t savecrit; savecrit = critical_enter(); - if (p == PCPU_GET(npxproc)) + if (td == PCPU_GET(npxthread)) npxsave(&PCPU_GET(curpcb)->pcb_save); critical_exit(savecrit); #ifdef NPX_DEBUG @@ -607,8 +607,9 @@ npxexit(p) */ if (masked_exceptions & 0x0d) log(LOG_ERR, - "pid %d (%s) exited with masked floating point exceptions 0x%02x\n", - p->p_pid, p->p_comm, masked_exceptions); + "pid %d (%s) exited with masked floating" + " point exceptions 0x%02x\n", + td->td_proc->p_pid, td->td_proc->p_comm, masked_exceptions); } #endif } @@ -809,8 +810,8 @@ npxtrap() u_long *exstat; if (!npx_exists) { - printf("npxtrap: npxproc = %p, curproc = %p, npx_exists = %d\n", - PCPU_GET(npxproc), curproc, npx_exists); + printf("npxtrap: npxthread = %p, curthread = %p, npx_exists = %d\n", + PCPU_GET(npxthread), curthread, npx_exists); panic("npxtrap from nowhere"); } savecrit = critical_enter(); @@ -820,18 +821,18 @@ npxtrap() * state to memory. Fetch the relevant parts of the state from * wherever they are. */ - if (PCPU_GET(npxproc) != curproc) { - control = GET_FPU_CW(curproc); - status = GET_FPU_SW(curproc); + if (PCPU_GET(npxthread) != curthread) { + control = GET_FPU_CW(curthread); + status = GET_FPU_SW(curthread); } else { fnstcw(&control); fnstsw(&status); } - exstat = GET_FPU_EXSW_PTR(&curproc->p_addr->u_pcb); + exstat = GET_FPU_EXSW_PTR(curthread->td_pcb); *exstat = status; - if (PCPU_GET(npxproc) != curproc) - GET_FPU_SW(curproc) &= ~0x80bf; + if (PCPU_GET(npxthread) != curthread) + GET_FPU_SW(curthread) &= ~0x80bf; else fnclex(); critical_exit(savecrit); @@ -841,7 +842,7 @@ npxtrap() /* * Implement device not available (DNA) exception * - * It would be better to switch FP context here (if curproc != npxproc) + * It would be better to switch FP context here (if curthread != npxthread) * and not necessarily for every context switch, but it is too hard to * access foreign pcb's. */ @@ -853,9 +854,9 @@ npxdna() if (!npx_exists) return (0); - if (PCPU_GET(npxproc) != NULL) { - printf("npxdna: npxproc = %p, curproc = %p\n", - PCPU_GET(npxproc), curproc); + if (PCPU_GET(npxthread) != NULL) { + printf("npxdna: npxthread = %p, curthread = %p\n", + PCPU_GET(npxthread), curthread); panic("npxdna"); } s = critical_enter(); @@ -863,7 +864,7 @@ npxdna() /* * Record new context early in case frstor causes an IRQ13. */ - PCPU_SET(npxproc, CURPROC); + PCPU_SET(npxthread, curthread); exstat = GET_FPU_EXSW_PTR(PCPU_GET(curpcb)); *exstat = 0; @@ -895,13 +896,13 @@ npxdna() * after the process has entered the kernel. It may even be delivered after * the fnsave here completes. A spurious IRQ13 for the fnsave is handled in * the same way as a very-late-arriving non-spurious IRQ13 from user mode: - * it is normally ignored at first because we set npxproc to NULL; it is + * it is normally ignored at first because we set npxthread to NULL; it is * normally retriggered in npxdna() after return to user mode. * * npxsave() must be called with interrupts disabled, so that it clears - * npxproc atomically with saving the state. We require callers to do the + * npxthread atomically with saving the state. We require callers to do the * disabling, since most callers need to disable interrupts anyway to call - * npxsave() atomically with checking npxproc. + * npxsave() atomically with checking npxthread. * * A previous version of npxsave() went to great lengths to excecute fnsave * with interrupts enabled in case executing it froze the CPU. This case @@ -917,7 +918,7 @@ npxsave(addr) fpusave(addr); start_emulating(); - PCPU_SET(npxproc, NULL); + PCPU_SET(npxthread, NULL); } static void diff --git a/sys/amd64/amd64/genassym.c b/sys/amd64/amd64/genassym.c index 0704db7..8f4be92 100644 --- a/sys/amd64/amd64/genassym.c +++ b/sys/amd64/amd64/genassym.c @@ -37,7 +37,7 @@ * $FreeBSD$ */ -#include "opt_upages.h" +#include "opt_kstack_pages.h" #include <sys/param.h> #include <sys/systm.h> @@ -50,6 +50,7 @@ #include <sys/mutex.h> #include <sys/socket.h> #include <sys/resourcevar.h> +#include <sys/user.h> /* XXX */ #ifdef KTR_PERCPU #include <sys/ktr.h> @@ -79,21 +80,31 @@ ASSYM(P_VMSPACE, offsetof(struct proc, p_vmspace)); ASSYM(VM_PMAP, offsetof(struct vmspace, vm_pmap)); ASSYM(PM_ACTIVE, offsetof(struct pmap, pm_active)); -ASSYM(P_ADDR, offsetof(struct proc, p_addr)); -ASSYM(P_INTR_NESTING_LEVEL, offsetof(struct proc, p_intr_nesting_level)); ASSYM(P_SFLAG, offsetof(struct proc, p_sflag)); ASSYM(P_STAT, offsetof(struct proc, p_stat)); -ASSYM(P_WCHAN, offsetof(struct proc, p_wchan)); +ASSYM(P_UAREA, offsetof(struct proc, p_uarea)); + +/*ASSYM(TD_STAT, offsetof(struct thread, td__stat));*/ +ASSYM(TD_FLAGS, offsetof(struct thread, td_flags)); +ASSYM(TD_WCHAN, offsetof(struct thread, td_wchan)); +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_INTR_NESTING_LEVEL, offsetof(struct thread, td_intr_nesting_level)); + +ASSYM(KE_FLAGS, offsetof(struct kse, ke_flags)); -ASSYM(PS_ASTPENDING, PS_ASTPENDING); -ASSYM(PS_NEEDRESCHED, PS_NEEDRESCHED); +ASSYM(KEF_ASTPENDING, KEF_ASTPENDING); +ASSYM(KEF_NEEDRESCHED, KEF_NEEDRESCHED); ASSYM(SSLEEP, SSLEEP); ASSYM(SRUN, SRUN); ASSYM(V_TRAP, offsetof(struct vmmeter, v_trap)); ASSYM(V_SYSCALL, offsetof(struct vmmeter, v_syscall)); ASSYM(V_INTR, offsetof(struct vmmeter, v_intr)); -ASSYM(UPAGES, UPAGES); +/* ASSYM(UPAGES, UPAGES);*/ +ASSYM(UAREA_PAGES, UAREA_PAGES); +ASSYM(KSTACK_PAGES, KSTACK_PAGES); ASSYM(PAGE_SIZE, PAGE_SIZE); ASSYM(NPTEPG, NPTEPG); ASSYM(NPDEPG, NPDEPG); @@ -133,9 +144,7 @@ ASSYM(PCB_SAVEFPU_SIZE, sizeof(union savefpu)); ASSYM(PCB_SAVE87_SIZE, sizeof(struct save87)); ASSYM(PCB_ONFAULT, offsetof(struct pcb, pcb_onfault)); -#ifdef SMP ASSYM(PCB_SIZE, sizeof(struct pcb)); -#endif ASSYM(TF_TRAPNO, offsetof(struct trapframe, tf_trapno)); ASSYM(TF_ERR, offsetof(struct trapframe, tf_err)); @@ -166,9 +175,9 @@ ASSYM(BI_ESYMTAB, offsetof(struct bootinfo, bi_esymtab)); ASSYM(BI_KERNEND, offsetof(struct bootinfo, bi_kernend)); ASSYM(GD_SIZEOF, sizeof(struct globaldata)); ASSYM(GD_PRVSPACE, offsetof(struct globaldata, gd_prvspace)); -ASSYM(GD_CURPROC, offsetof(struct globaldata, gd_curproc)); -ASSYM(GD_NPXPROC, offsetof(struct globaldata, gd_npxproc)); -ASSYM(GD_IDLEPROC, offsetof(struct globaldata, gd_idleproc)); +ASSYM(GD_CURTHREAD, offsetof(struct globaldata, gd_curthread)); +ASSYM(GD_NPXTHREAD, offsetof(struct globaldata, gd_npxthread)); +ASSYM(GD_IDLETHREAD, offsetof(struct globaldata, gd_idlethread)); ASSYM(GD_CURPCB, offsetof(struct globaldata, gd_curpcb)); ASSYM(GD_COMMON_TSS, offsetof(struct globaldata, gd_common_tss)); ASSYM(GD_SWITCHTIME, offsetof(struct globaldata, gd_switchtime)); diff --git a/sys/amd64/amd64/locore.S b/sys/amd64/amd64/locore.S index 97a1e16..ab3dad5 100644 --- a/sys/amd64/amd64/locore.S +++ b/sys/amd64/amd64/locore.S @@ -147,9 +147,11 @@ IdlePTD: .long 0 /* phys addr of kernel PTD */ #endif KPTphys: .long 0 /* phys addr of kernel page tables */ - .globl proc0paddr -proc0paddr: .long 0 /* address of proc 0 address space */ -p0upa: .long 0 /* phys addr of proc0's UPAGES */ + .globl proc0uarea, proc0kstack +proc0uarea: .long 0 /* address of proc 0 uarea space */ +proc0kstack: .long 0 /* address of proc 0 kstack space */ +p0upa: .long 0 /* phys addr of proc0's UAREA */ +p0kpa: .long 0 /* phys addr of proc0's STACK */ vm86phystk: .long 0 /* PA of vm86/bios stack */ @@ -369,13 +371,14 @@ NON_GPROF_ENTRY(btext) /* now running relocated at KERNBASE where the system is linked to run */ begin: /* set up bootstrap stack */ - movl proc0paddr,%eax /* location of in-kernel pages */ - leal UPAGES*PAGE_SIZE(%eax),%esp /* bootstrap stack end location */ + movl proc0kstack,%eax /* location of in-kernel stack */ + /* bootstrap stack end location */ + leal (KSTACK_PAGES*PAGE_SIZE-PCB_SIZE)(%eax),%esp xorl %ebp,%ebp /* mark end of frames */ movl IdlePTD,%esi - movl %esi,PCB_CR3(%eax) + movl %esi,(KSTACK_PAGES*PAGE_SIZE-PCB_SIZE+PCB_CR3)(%eax) testl $CPUID_PGE, R(cpu_feature) jz 1f @@ -762,10 +765,15 @@ no_kernend: movl %esi,R(IdlePTD) /* Allocate UPAGES */ - ALLOCPAGES(UPAGES) + ALLOCPAGES(UAREA_PAGES) movl %esi,R(p0upa) addl $KERNBASE, %esi - movl %esi, R(proc0paddr) + movl %esi, R(proc0uarea) + + ALLOCPAGES(KSTACK_PAGES) + movl %esi,R(p0kpa) + addl $KERNBASE, %esi + movl %esi, R(proc0kstack) ALLOCPAGES(1) /* vm86/bios stack */ movl %esi,R(vm86phystk) @@ -833,7 +841,12 @@ map_read_write: /* Map proc0's UPAGES in the physical way ... */ movl R(p0upa), %eax - movl $UPAGES, %ecx + movl $(UAREA_PAGES), %ecx + fillkptphys($PG_RW) + +/* Map proc0's KSTACK in the physical way ... */ + movl R(p0kpa), %eax + movl $(KSTACK_PAGES), %ecx fillkptphys($PG_RW) /* Map ISA hole */ diff --git a/sys/amd64/amd64/locore.s b/sys/amd64/amd64/locore.s index 97a1e16..ab3dad5 100644 --- a/sys/amd64/amd64/locore.s +++ b/sys/amd64/amd64/locore.s @@ -147,9 +147,11 @@ IdlePTD: .long 0 /* phys addr of kernel PTD */ #endif KPTphys: .long 0 /* phys addr of kernel page tables */ - .globl proc0paddr -proc0paddr: .long 0 /* address of proc 0 address space */ -p0upa: .long 0 /* phys addr of proc0's UPAGES */ + .globl proc0uarea, proc0kstack +proc0uarea: .long 0 /* address of proc 0 uarea space */ +proc0kstack: .long 0 /* address of proc 0 kstack space */ +p0upa: .long 0 /* phys addr of proc0's UAREA */ +p0kpa: .long 0 /* phys addr of proc0's STACK */ vm86phystk: .long 0 /* PA of vm86/bios stack */ @@ -369,13 +371,14 @@ NON_GPROF_ENTRY(btext) /* now running relocated at KERNBASE where the system is linked to run */ begin: /* set up bootstrap stack */ - movl proc0paddr,%eax /* location of in-kernel pages */ - leal UPAGES*PAGE_SIZE(%eax),%esp /* bootstrap stack end location */ + movl proc0kstack,%eax /* location of in-kernel stack */ + /* bootstrap stack end location */ + leal (KSTACK_PAGES*PAGE_SIZE-PCB_SIZE)(%eax),%esp xorl %ebp,%ebp /* mark end of frames */ movl IdlePTD,%esi - movl %esi,PCB_CR3(%eax) + movl %esi,(KSTACK_PAGES*PAGE_SIZE-PCB_SIZE+PCB_CR3)(%eax) testl $CPUID_PGE, R(cpu_feature) jz 1f @@ -762,10 +765,15 @@ no_kernend: movl %esi,R(IdlePTD) /* Allocate UPAGES */ - ALLOCPAGES(UPAGES) + ALLOCPAGES(UAREA_PAGES) movl %esi,R(p0upa) addl $KERNBASE, %esi - movl %esi, R(proc0paddr) + movl %esi, R(proc0uarea) + + ALLOCPAGES(KSTACK_PAGES) + movl %esi,R(p0kpa) + addl $KERNBASE, %esi + movl %esi, R(proc0kstack) ALLOCPAGES(1) /* vm86/bios stack */ movl %esi,R(vm86phystk) @@ -833,7 +841,12 @@ map_read_write: /* Map proc0's UPAGES in the physical way ... */ movl R(p0upa), %eax - movl $UPAGES, %ecx + movl $(UAREA_PAGES), %ecx + fillkptphys($PG_RW) + +/* Map proc0's KSTACK in the physical way ... */ + movl R(p0kpa), %eax + movl $(KSTACK_PAGES), %ecx fillkptphys($PG_RW) /* Map ISA hole */ diff --git a/sys/amd64/amd64/machdep.c b/sys/amd64/amd64/machdep.c index e0dade2..6711515 100644 --- a/sys/amd64/amd64/machdep.c +++ b/sys/amd64/amd64/machdep.c @@ -49,7 +49,7 @@ #include "opt_msgbuf.h" #include "opt_npx.h" #include "opt_perfmon.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" /* #include "opt_userconfig.h" */ #include <sys/param.h> @@ -289,14 +289,16 @@ osendsig(catcher, sig, mask, code) struct osigframe sf; struct osigframe *fp; struct proc *p; + struct thread *td; struct sigacts *psp; struct trapframe *regs; int oonstack; - p = curproc; + td = curthread; + p = td->td_proc; PROC_LOCK_ASSERT(p, MA_OWNED); psp = p->p_sigacts; - regs = p->p_frame; + regs = td->td_frame; oonstack = sigonstack(regs->tf_esp); /* Allocate and validate space for the signal handler context. */ @@ -386,7 +388,7 @@ osendsig(catcher, sig, mask, code) if (regs->tf_eflags & PSL_VM) { /* XXX confusing names: `tf' isn't a trapframe; `regs' is. */ struct trapframe_vm86 *tf = (struct trapframe_vm86 *)regs; - struct vm86_kernel *vm86 = &p->p_addr->u_pcb.pcb_ext->ext_vm86; + struct vm86_kernel *vm86 = &td->td_pcb->pcb_ext->ext_vm86; sf.sf_siginfo.si_sc.sc_gs = tf->tf_vm86_gs; sf.sf_siginfo.si_sc.sc_fs = tf->tf_vm86_fs; @@ -409,7 +411,7 @@ osendsig(catcher, sig, mask, code) * ...Kill the process. */ PROC_LOCK(p); - sigexit(p, SIGILL); + sigexit(td, SIGILL); /* NOTREACHED */ } @@ -434,12 +436,14 @@ sendsig(catcher, sig, mask, code) { struct sigframe sf; struct proc *p; + struct thread *td; struct sigacts *psp; struct trapframe *regs; struct sigframe *sfp; int oonstack; - p = curproc; + td = curthread; + p = td->td_proc; PROC_LOCK_ASSERT(p, MA_OWNED); psp = p->p_sigacts; #ifdef COMPAT_43 @@ -448,7 +452,7 @@ sendsig(catcher, sig, mask, code) return; } #endif - regs = p->p_frame; + regs = td->td_frame; oonstack = sigonstack(regs->tf_esp); /* Save user context. */ @@ -528,7 +532,7 @@ sendsig(catcher, sig, mask, code) */ if (regs->tf_eflags & PSL_VM) { struct trapframe_vm86 *tf = (struct trapframe_vm86 *)regs; - struct vm86_kernel *vm86 = &p->p_addr->u_pcb.pcb_ext->ext_vm86; + struct vm86_kernel *vm86 = &td->td_pcb->pcb_ext->ext_vm86; sf.sf_uc.uc_mcontext.mc_gs = tf->tf_vm86_gs; sf.sf_uc.uc_mcontext.mc_fs = tf->tf_vm86_fs; @@ -561,7 +565,7 @@ sendsig(catcher, sig, mask, code) * ...Kill the process. */ PROC_LOCK(p); - sigexit(p, SIGILL); + sigexit(td, SIGILL); /* NOTREACHED */ } @@ -586,17 +590,18 @@ sendsig(catcher, sig, mask, code) */ #ifdef COMPAT_43 int -osigreturn(p, uap) - struct proc *p; +osigreturn(td, uap) + struct thread *td; struct osigreturn_args /* { struct osigcontext *sigcntxp; } */ *uap; { struct trapframe *regs; struct osigcontext *scp; + struct proc *p = td->td_proc; int eflags; - regs = p->p_frame; + regs = td->td_frame; scp = uap->sigcntxp; if (!useracc((caddr_t)scp, sizeof(*scp), VM_PROT_READ)) return (EFAULT); @@ -609,9 +614,9 @@ osigreturn(p, uap) * if pcb_ext == 0 or vm86_inited == 0, the user hasn't * set up the vm86 area, and we can't enter vm86 mode. */ - if (p->p_addr->u_pcb.pcb_ext == 0) + if (td->td_pcb->pcb_ext == 0) return (EINVAL); - vm86 = &p->p_addr->u_pcb.pcb_ext->ext_vm86; + vm86 = &td->td_pcb->pcb_ext->ext_vm86; if (vm86->vm86_inited == 0) return (EINVAL); @@ -697,12 +702,13 @@ osigreturn(p, uap) #endif int -sigreturn(p, uap) - struct proc *p; +sigreturn(td, uap) + struct thread *td; struct sigreturn_args /* { ucontext_t *sigcntxp; } */ *uap; { + struct proc *p = td->td_proc; struct trapframe *regs; ucontext_t *ucp; int cs, eflags; @@ -712,7 +718,7 @@ sigreturn(p, uap) if (!useracc((caddr_t)ucp, sizeof(struct osigcontext), VM_PROT_READ)) return (EFAULT); if (((struct osigcontext *)ucp)->sc_trapno == 0x01d516) - return (osigreturn(p, (struct osigreturn_args *)uap)); + return (osigreturn(td, (struct osigreturn_args *)uap)); /* * Since ucp is not an osigcontext but a ucontext_t, we have to * check again if all of it is accessible. A ucontext_t is @@ -724,7 +730,7 @@ sigreturn(p, uap) if (!useracc((caddr_t)ucp, sizeof(*ucp), VM_PROT_READ)) return (EFAULT); - regs = p->p_frame; + regs = td->td_frame; eflags = ucp->uc_mcontext.mc_eflags; if (eflags & PSL_VM) { struct trapframe_vm86 *tf = (struct trapframe_vm86 *)regs; @@ -734,9 +740,9 @@ sigreturn(p, uap) * if pcb_ext == 0 or vm86_inited == 0, the user hasn't * set up the vm86 area, and we can't enter vm86 mode. */ - if (p->p_addr->u_pcb.pcb_ext == 0) + if (td->td_pcb->pcb_ext == 0) return (EINVAL); - vm86 = &p->p_addr->u_pcb.pcb_ext->ext_vm86; + vm86 = &td->td_pcb->pcb_ext->ext_vm86; if (vm86->vm86_inited == 0) return (EINVAL); @@ -865,14 +871,14 @@ cpu_idle(void) * Clear registers on exec */ void -setregs(p, entry, stack, ps_strings) - struct proc *p; +setregs(td, entry, stack, ps_strings) + struct thread *td; u_long entry; u_long stack; u_long ps_strings; { - struct trapframe *regs = p->p_frame; - struct pcb *pcb = &p->p_addr->u_pcb; + struct trapframe *regs = td->td_frame; + struct pcb *pcb = td->td_pcb; if (pcb->pcb_ldt) user_ldt_free(pcb); @@ -925,7 +931,7 @@ setregs(p, entry, stack, ps_strings) * traps to the emulator (if it is done at all) mainly because * emulators don't provide an entry point for initialization. */ - p->p_addr->u_pcb.pcb_flags &= ~FP_SOFTFP; + td->td_pcb->pcb_flags &= ~FP_SOFTFP; /* * Arrange to trap the next npx or `fwait' instruction (see npx.c @@ -948,7 +954,7 @@ setregs(p, entry, stack, ps_strings) * Make sure sure edx is 0x0 on entry. Linux binaries depend * on it. */ - p->p_retval[1] = 0; + td->td_retval[1] = 0; } void @@ -1016,7 +1022,8 @@ extern int has_f00f_bug; static struct i386tss dblfault_tss; static char dblfault_stack[PAGE_SIZE]; -extern struct user *proc0paddr; +extern struct user *proc0uarea; +extern vm_offset_t proc0kstack; /* software prototypes -- in more palatable form */ @@ -1661,8 +1668,12 @@ init386(first) struct region_descriptor r_gdt, r_idt; #endif - proc0.p_addr = proc0paddr; - + proc_linkup(&proc0); + 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; atdevbase = ISA_HOLE_START + KERNBASE; metadata_missing = 0; @@ -1721,10 +1732,11 @@ init386(first) lgdt(&r_gdt); /* setup curproc so that mutexes work */ - PCPU_SET(curproc, &proc0); + + PCPU_SET(curthread, thread0); PCPU_SET(spinlocks, NULL); - LIST_INIT(&proc0.p_contested); + LIST_INIT(&thread0->td_contested); /* * Initialize mutexes. @@ -1828,8 +1840,9 @@ init386(first) initializecpu(); /* Initialize CPU registers */ /* make an initial tss so cpu can get interrupt stack on syscall! */ - PCPU_SET(common_tss.tss_esp0, - (int) proc0.p_addr + UPAGES*PAGE_SIZE - 16); + /* Note: -16 is so we can grow the trapframe if we came from vm86 */ + PCPU_SET(common_tss.tss_esp0, thread0->td_kstack + + KSTACK_PAGES * PAGE_SIZE - sizeof(struct pcb) - 16); PCPU_SET(common_tss.tss_ss0, GSEL(GDATA_SEL, SEL_KPL)); gsel_tss = GSEL(GPROC0_SEL, SEL_KPL); private_tss = 0; @@ -1884,10 +1897,10 @@ init386(first) _udatasel = LSEL(LUDATA_SEL, SEL_UPL); /* setup proc 0's pcb */ - proc0.p_addr->u_pcb.pcb_flags = 0; - proc0.p_addr->u_pcb.pcb_cr3 = (int)IdlePTD; - proc0.p_addr->u_pcb.pcb_ext = 0; - proc0.p_frame = &proc0_tf; + thread0->td_pcb->pcb_flags = 0; /* XXXKSE */ + thread0->td_pcb->pcb_cr3 = (int)IdlePTD; + thread0->td_pcb->pcb_ext = 0; + thread0->td_frame = &proc0_tf; } #if defined(I586_CPU) && !defined(NO_F00F_HACK) @@ -1930,31 +1943,26 @@ f00f_hack(void *unused) { #endif /* defined(I586_CPU) && !NO_F00F_HACK */ int -ptrace_set_pc(p, addr) - struct proc *p; - unsigned long addr; +ptrace_set_pc(struct thread *td, unsigned long addr) { - p->p_frame->tf_eip = addr; + td->td_frame->tf_eip = addr; return (0); } int -ptrace_single_step(p) - struct proc *p; +ptrace_single_step(struct thread *td) { - p->p_frame->tf_eflags |= PSL_T; + td->td_frame->tf_eflags |= PSL_T; return (0); } int -fill_regs(p, regs) - struct proc *p; - struct reg *regs; +fill_regs(struct thread *td, struct reg *regs) { struct pcb *pcb; struct trapframe *tp; - tp = p->p_frame; + tp = td->td_frame; regs->r_fs = tp->tf_fs; regs->r_es = tp->tf_es; regs->r_ds = tp->tf_ds; @@ -1970,20 +1978,18 @@ fill_regs(p, regs) regs->r_eflags = tp->tf_eflags; regs->r_esp = tp->tf_esp; regs->r_ss = tp->tf_ss; - pcb = &p->p_addr->u_pcb; + pcb = td->td_pcb; regs->r_gs = pcb->pcb_gs; return (0); } int -set_regs(p, regs) - struct proc *p; - struct reg *regs; +set_regs(struct thread *td, struct reg *regs) { struct pcb *pcb; struct trapframe *tp; - tp = p->p_frame; + tp = td->td_frame; if (!EFL_SECURE(regs->r_eflags, tp->tf_eflags) || !CS_SECURE(regs->r_cs)) return (EINVAL); @@ -2002,7 +2008,7 @@ set_regs(p, regs) tp->tf_eflags = regs->r_eflags; tp->tf_esp = regs->r_esp; tp->tf_ss = regs->r_ss; - pcb = &p->p_addr->u_pcb; + pcb = td->td_pcb; pcb->pcb_gs = regs->r_gs; return (0); } @@ -2062,45 +2068,39 @@ set_fpregs_xmm(sv_87, sv_xmm) #endif /* CPU_ENABLE_SSE */ int -fill_fpregs(p, fpregs) - struct proc *p; - struct fpreg *fpregs; +fill_fpregs(struct thread *td, struct fpreg *fpregs) { #ifdef CPU_ENABLE_SSE if (cpu_fxsr) { - fill_fpregs_xmm(&p->p_addr->u_pcb.pcb_save.sv_xmm, + fill_fpregs_xmm(&td->td_pcb->pcb_save.sv_xmm, (struct save87 *)fpregs); return (0); } #endif /* CPU_ENABLE_SSE */ - bcopy(&p->p_addr->u_pcb.pcb_save.sv_87, fpregs, sizeof *fpregs); + bcopy(&td->td_pcb->pcb_save.sv_87, fpregs, sizeof *fpregs); return (0); } int -set_fpregs(p, fpregs) - struct proc *p; - struct fpreg *fpregs; +set_fpregs(struct thread *td, struct fpreg *fpregs) { #ifdef CPU_ENABLE_SSE if (cpu_fxsr) { set_fpregs_xmm((struct save87 *)fpregs, - &p->p_addr->u_pcb.pcb_save.sv_xmm); + &td->td_pcb->pcb_save.sv_xmm); return (0); } #endif /* CPU_ENABLE_SSE */ - bcopy(fpregs, &p->p_addr->u_pcb.pcb_save.sv_87, sizeof *fpregs); + bcopy(fpregs, &td->td_pcb->pcb_save.sv_87, sizeof *fpregs); return (0); } int -fill_dbregs(p, dbregs) - struct proc *p; - struct dbreg *dbregs; +fill_dbregs(struct thread *td, struct dbreg *dbregs) { struct pcb *pcb; - if (p == NULL) { + if (td == NULL) { dbregs->dr0 = rdr0(); dbregs->dr1 = rdr1(); dbregs->dr2 = rdr2(); @@ -2109,9 +2109,8 @@ fill_dbregs(p, dbregs) dbregs->dr5 = rdr5(); dbregs->dr6 = rdr6(); dbregs->dr7 = rdr7(); - } - else { - pcb = &p->p_addr->u_pcb; + } else { + pcb = td->td_pcb; dbregs->dr0 = pcb->pcb_dr0; dbregs->dr1 = pcb->pcb_dr1; dbregs->dr2 = pcb->pcb_dr2; @@ -2125,15 +2124,13 @@ fill_dbregs(p, dbregs) } int -set_dbregs(p, dbregs) - struct proc *p; - struct dbreg *dbregs; +set_dbregs(struct thread *td, struct dbreg *dbregs) { struct pcb *pcb; int i; u_int32_t mask1, mask2; - if (p == NULL) { + if (td == NULL) { load_dr0(dbregs->dr0); load_dr1(dbregs->dr1); load_dr2(dbregs->dr2); @@ -2142,8 +2139,7 @@ set_dbregs(p, dbregs) load_dr5(dbregs->dr5); load_dr6(dbregs->dr6); load_dr7(dbregs->dr7); - } - else { + } else { /* * Don't let an illegal value for dr7 get set. Specifically, * check for undefined settings. Setting these bit patterns @@ -2155,7 +2151,7 @@ set_dbregs(p, dbregs) if ((dbregs->dr7 & mask1) == mask2) return (EINVAL); - pcb = &p->p_addr->u_pcb; + pcb = td->td_pcb; /* * Don't let a process set a breakpoint that is not within the @@ -2172,7 +2168,7 @@ set_dbregs(p, dbregs) * from within kernel mode? */ - if (suser(p) != 0) { + if (suser_td(td) != 0) { if (dbregs->dr7 & 0x3) { /* dr0 is enabled */ if (dbregs->dr0 >= VM_MAXUSER_ADDRESS) diff --git a/sys/amd64/amd64/mem.c b/sys/amd64/amd64/mem.c index 5eded32..48ecff8 100644 --- a/sys/amd64/amd64/mem.c +++ b/sys/amd64/amd64/mem.c @@ -98,17 +98,17 @@ MALLOC_DEFINE(M_MEMDESC, "memdesc", "memory range descriptors"); 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)) { case 14: - p->p_frame->tf_eflags &= ~PSL_IOPL; + td->td_frame->tf_eflags &= ~PSL_IOPL; } return (0); } static int -mmopen(dev_t dev, int flags, int fmt, struct proc *p) +mmopen(dev_t dev, int flags, int fmt, struct thread *td) { int error; @@ -119,12 +119,12 @@ mmopen(dev_t dev, int flags, int fmt, struct proc *p) return (EPERM); break; case 14: - error = suser(p); + error = suser_td(td); if (error != 0) return (error); if (securelevel > 0) return (EPERM); - p->p_frame->tf_eflags |= PSL_IOPL; + td->td_frame->tf_eflags |= PSL_IOPL; break; } return (0); @@ -235,7 +235,7 @@ memmmap(dev_t dev, vm_offset_t offset, int prot) * and mem_range_attr_set. */ static int -mmioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +mmioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td) { int nd, error = 0; struct mem_range_op *mo = (struct mem_range_op *)data; diff --git a/sys/amd64/amd64/mp_machdep.c b/sys/amd64/amd64/mp_machdep.c index d912e0c..f558524 100644 --- a/sys/amd64/amd64/mp_machdep.c +++ b/sys/amd64/amd64/mp_machdep.c @@ -26,7 +26,7 @@ */ #include "opt_cpu.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" #ifdef SMP #include <machine/smptests.h> @@ -1960,8 +1960,8 @@ start_all_aps(u_int boot_addr) SMPpt[pg] = (pt_entry_t)(PG_V | PG_RW | vtophys(gd)); /* allocate and set up an idle stack data page */ - stack = (char *)kmem_alloc(kernel_map, UPAGES*PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); /* XXXKSE */ + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[pg + 1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -1977,7 +1977,7 @@ start_all_aps(u_int boot_addr) outb(CMOS_DATA, BIOS_WARM); /* 'warm-start' */ #endif - bootSTK = &SMP_prvspace[x].idlestack[UPAGES*PAGE_SIZE]; + bootSTK = &SMP_prvspace[x].idlekstack[KSTACK_PAGES * PAGE_SIZE]; bootAP = x; /* attempt to start the Application Processor */ @@ -2019,8 +2019,8 @@ start_all_aps(u_int boot_addr) */ /* Allocate and setup BSP idle stack */ - stack = (char *)kmem_alloc(kernel_map, UPAGES * PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -2241,7 +2241,7 @@ ap_init(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); /* lock against other AP's that are waking up */ @@ -2323,7 +2323,7 @@ forwarded_statclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - statclock_process(curproc, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); + statclock_process(curthread->td_kse, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } @@ -2354,7 +2354,7 @@ forwarded_hardclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - hardclock_process(curproc, TRAPF_USERMODE(&frame)); + hardclock_process(curthread, TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } diff --git a/sys/amd64/amd64/mptable.c b/sys/amd64/amd64/mptable.c index d912e0c..f558524 100644 --- a/sys/amd64/amd64/mptable.c +++ b/sys/amd64/amd64/mptable.c @@ -26,7 +26,7 @@ */ #include "opt_cpu.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" #ifdef SMP #include <machine/smptests.h> @@ -1960,8 +1960,8 @@ start_all_aps(u_int boot_addr) SMPpt[pg] = (pt_entry_t)(PG_V | PG_RW | vtophys(gd)); /* allocate and set up an idle stack data page */ - stack = (char *)kmem_alloc(kernel_map, UPAGES*PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); /* XXXKSE */ + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[pg + 1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -1977,7 +1977,7 @@ start_all_aps(u_int boot_addr) outb(CMOS_DATA, BIOS_WARM); /* 'warm-start' */ #endif - bootSTK = &SMP_prvspace[x].idlestack[UPAGES*PAGE_SIZE]; + bootSTK = &SMP_prvspace[x].idlekstack[KSTACK_PAGES * PAGE_SIZE]; bootAP = x; /* attempt to start the Application Processor */ @@ -2019,8 +2019,8 @@ start_all_aps(u_int boot_addr) */ /* Allocate and setup BSP idle stack */ - stack = (char *)kmem_alloc(kernel_map, UPAGES * PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -2241,7 +2241,7 @@ ap_init(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); /* lock against other AP's that are waking up */ @@ -2323,7 +2323,7 @@ forwarded_statclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - statclock_process(curproc, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); + statclock_process(curthread->td_kse, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } @@ -2354,7 +2354,7 @@ forwarded_hardclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - hardclock_process(curproc, TRAPF_USERMODE(&frame)); + hardclock_process(curthread, TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } diff --git a/sys/amd64/amd64/pmap.c b/sys/amd64/amd64/pmap.c index 3ce91ab..b41b11f 100644 --- a/sys/amd64/amd64/pmap.c +++ b/sys/amd64/amd64/pmap.c @@ -71,7 +71,7 @@ #include "opt_disable_pse.h" #include "opt_pmap.h" #include "opt_msgbuf.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" #include <sys/param.h> #include <sys/systm.h> @@ -171,7 +171,7 @@ vm_offset_t kernel_vm_end; 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; @@ -183,7 +183,7 @@ static pt_entry_t *CMAP2, *ptmmap; caddr_t CADDR1 = 0, ptvmmap = 0; static caddr_t CADDR2; static pt_entry_t *msgbufmap; -struct msgbuf *msgbufp=0; +struct msgbuf *msgbufp = 0; /* * Crashdump maps. @@ -819,7 +819,7 @@ retry: } /* - * Create the UPAGES for a new process. + * Create the Uarea stack for a new process. * This routine directly affects the fork perf for a process. */ void @@ -840,22 +840,22 @@ pmap_new_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; + /* get a kernel virtual address for the U area for this proc */ + 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 = (unsigned *)vtopte(up); - for (i = 0; i < UPAGES; i++) { + for (i = 0; i < UAREA_PAGES; i++) { /* * Get a kernel stack page */ @@ -892,7 +892,7 @@ pmap_new_proc(p) } /* - * Dispose the UPAGES for a process that has exited. + * Dispose the U-Area for a process that has exited. * This routine directly impacts the exit perf of a process. */ void @@ -906,9 +906,9 @@ pmap_dispose_proc(p) unsigned *ptek, oldpte; upobj = p->p_upages_obj; - up = (vm_offset_t)p->p_addr; + up = (vm_offset_t)p->p_uarea; ptek = (unsigned *)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?"); @@ -927,7 +927,7 @@ pmap_dispose_proc(p) } /* - * Allow the UPAGES for a process to be prejudicially paged out. + * Allow the U_AREA for a process to be prejudicially paged out. */ void pmap_swapout_proc(p) @@ -939,8 +939,8 @@ pmap_swapout_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_lookup(upobj, i); if (m == NULL) panic("pmap_swapout_proc: upage already missing?"); @@ -951,7 +951,7 @@ pmap_swapout_proc(p) } /* - * Bring the UPAGES for a specified process back in. + * Bring the U-Area for a specified process back in. */ void pmap_swapin_proc(p) @@ -963,8 +963,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) { @@ -980,6 +980,191 @@ pmap_swapin_proc(p) } } +/* + * Create the kernel stack (including pcb for i386) for a new thread. + * This routine directly affects the fork perf for a process and + * create performance for a thread. + */ +void +pmap_new_thread(td) + struct thread *td; +{ +#ifdef I386_CPU + int updateneeded = 0; +#endif + int i; + vm_object_t ksobj; + vm_page_t m; + vm_offset_t ks; + unsigned *ptek, oldpte; + + /* + * allocate object for the kstack + */ + 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 proc */ + ks = (vm_offset_t)td->td_kstack; + if (ks == 0) { + ks = kmem_alloc_nofault(kernel_map, + (KSTACK_PAGES + 1) * PAGE_SIZE); + if (ks == 0) + panic("pmap_new_thread: kstack allocation failed"); + ks += PAGE_SIZE; + td->td_kstack = ks; + } + + ptek = (unsigned *)vtopte(ks - PAGE_SIZE); + oldpte = *ptek; + *ptek = 0; + if (oldpte) { +#ifdef I386_CPU + updateneeded = 1; +#else + invlpg(ks - PAGE_SIZE); +#endif + } + ptek++; +#else + /* get a kernel virtual address for the kstack for this proc */ + ks = (vm_offset_t)td->td_kstack; + if (ks == 0) { + ks = kmem_alloc_nofault(kernel_map, KSTACK_PAGES * PAGE_SIZE); + if (ks == 0) + panic("pmap_new_thread: kstack allocation failed"); + td->td_kstack = 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) = VM_PAGE_TO_PHYS(m) | PG_RW | PG_V | pgeflag; + if (oldpte) { +#ifdef I386_CPU + updateneeded = 1; +#else + invlpg(ks + i * PAGE_SIZE); +#endif + } + + 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; + } +#ifdef I386_CPU + if (updateneeded) + invltlb(); +#endif +} + +/* + * Dispose the kernel stack for a thread that has exited. + * This routine directly impacts the exit perf of a process and thread. + */ +void +pmap_dispose_thread(td) + struct thread *td; +{ + int i; + vm_object_t ksobj; + vm_offset_t ks; + vm_page_t m; + unsigned *ptek, oldpte; + + ksobj = td->td_kstack_obj; + ks = td->td_kstack; + ptek = (unsigned *)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; +#ifndef I386_CPU + invlpg(ks + i * PAGE_SIZE); +#endif + vm_page_unwire(m, 0); + vm_page_free(m); + } +#ifdef I386_CPU + invltlb(); +#endif +} + +/* + * 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; + + 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); + } +} + /*************************************************** * Page table page management routines..... ***************************************************/ @@ -1517,7 +1702,7 @@ pmap_collect() { int i; vm_page_t m; - static int warningdone=0; + static int warningdone = 0; if (pmap_pagedaemon_waken == 0) return; @@ -2333,7 +2518,7 @@ retry: pmap->pm_stats.resident_count += size >> PAGE_SHIFT; npdes = size >> PDRSHIFT; - for(i=0;i<npdes;i++) { + for(i = 0; i < npdes; i++) { pmap->pm_pdir[ptepindex] = (pd_entry_t) (ptepa | PG_U | PG_RW | PG_V | PG_PS); ptepa += NBPDR; @@ -2444,7 +2629,7 @@ pmap_prefault(pmap, addra, entry) vm_page_t m, mpte; vm_object_t object; - if (!curproc || (pmap != vmspace_pmap(curproc->p_vmspace))) + if (!curthread || (pmap != vmspace_pmap(curthread->td_proc->p_vmspace))) return; object = entry->object.vm_object; @@ -2561,6 +2746,7 @@ pmap_copy(dst_pmap, src_pmap, dst_addr, len, src_addr) vm_offset_t pdnxt; unsigned src_frame, dst_frame; vm_page_t m; + pd_entry_t saved_pde; if (dst_addr != src_addr) return; @@ -2580,7 +2766,7 @@ pmap_copy(dst_pmap, src_pmap, dst_addr, len, src_addr) invltlb(); #endif } - + saved_pde = (pd_entry_t)((u_int32_t)APTDpde & (PG_FRAME|PG_RW | PG_V)); for(addr = src_addr; addr < end_addr; addr = pdnxt) { unsigned *src_pte, *dst_pte; vm_page_t dstmpte, srcmpte; @@ -2637,6 +2823,16 @@ pmap_copy(dst_pmap, src_pmap, dst_addr, len, src_addr) * block. */ dstmpte = pmap_allocpte(dst_pmap, addr); + if (((u_int32_t)APTDpde & PG_FRAME) != + ((u_int32_t)saved_pde & PG_FRAME)) { + APTDpde = saved_pde; +printf ("IT HAPPENNED!"); +#if defined(SMP) + cpu_invltlb(); +#else + invltlb(); +#endif + } if ((*dst_pte == 0) && (ptetemp = *src_pte)) { /* * Clear the modified and @@ -2831,7 +3027,7 @@ pmap_remove_pages(pmap, sva, eva) vm_page_t m; #ifdef PMAP_REMOVE_PAGES_CURPROC_ONLY - if (!curproc || (pmap != vmspace_pmap(curproc->p_vmspace))) { + if (!curthread || (pmap != vmspace_pmap(curthread->td_proc->p_vmspace))) { printf("warning: pmap_remove_pages called with non-current pmap\n"); return; } @@ -2839,8 +3035,8 @@ pmap_remove_pages(pmap, sva, eva) s = splvm(); for(pv = TAILQ_FIRST(&pmap->pm_pvlist); - pv; - pv = npv) { + pv; + pv = npv) { if (pv->pv_va >= eva || pv->pv_va < sva) { npv = TAILQ_NEXT(pv, pv_plist); @@ -2854,6 +3050,12 @@ pmap_remove_pages(pmap, sva, eva) #endif tpte = *pte; + if (tpte == 0) { + printf("TPTE at %p IS ZERO @ VA %08x\n", + pte, pv->pv_va); + panic("bad pte"); + } + /* * We cannot remove wired pages from a process' mapping at this time */ @@ -2861,15 +3063,19 @@ pmap_remove_pages(pmap, sva, eva) npv = TAILQ_NEXT(pv, pv_plist); continue; } - *pte = 0; m = PHYS_TO_VM_PAGE(tpte); + KASSERT(m->phys_addr == (tpte & PG_FRAME), + ("vm_page_t %p phys_addr mismatch %08x %08x", + m, m->phys_addr, tpte)); KASSERT(m < &vm_page_array[vm_page_array_size], ("pmap_remove_pages: bad tpte %x", tpte)); pv->pv_pmap->pm_stats.resident_count--; + *pte = 0; + /* * Update the vm_page_t clean and reference bits. */ @@ -2877,7 +3083,6 @@ pmap_remove_pages(pmap, sva, eva) vm_page_dirty(m); } - npv = TAILQ_NEXT(pv, pv_plist); TAILQ_REMOVE(&pv->pv_pmap->pm_pvlist, pv, pv_plist); @@ -3255,11 +3460,13 @@ pmap_mincore(pmap, addr) } void -pmap_activate(struct proc *p) +pmap_activate(struct thread *td) { + struct proc *p = td->td_proc; pmap_t pmap; + u_int32_t cr3; - pmap = vmspace_pmap(p->p_vmspace); + pmap = vmspace_pmap(td->td_proc->p_vmspace); #if defined(SMP) pmap->pm_active |= 1 << PCPU_GET(cpuid); #else @@ -3268,7 +3475,20 @@ pmap_activate(struct proc *p) #if defined(SWTCH_OPTIM_STATS) tlb_flush_count++; #endif - load_cr3(p->p_addr->u_pcb.pcb_cr3 = vtophys(pmap->pm_pdir)); + cr3 = vtophys(pmap->pm_pdir); + /* XXXKSE this is wrong. + * pmap_activate is for the current thread on the current cpu + */ + if (p->p_flag & P_KSES) { + /* Make sure all other cr3 entries are updated. */ + /* what if they are running? XXXKSE (maybe abort them) */ + FOREACH_THREAD_IN_PROC(p, td) { + td->td_pcb->pcb_cr3 = cr3; + } + } else { + td->td_pcb->pcb_cr3 = cr3; + } + load_cr3(cr3); } vm_offset_t @@ -3301,14 +3521,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; unsigned *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/amd64/amd64/support.S b/sys/amd64/amd64/support.S index 55bc29c..81181cc 100644 --- a/sys/amd64/amd64/support.S +++ b/sys/amd64/amd64/support.S @@ -216,8 +216,8 @@ ENTRY(i586_bzero) * complicated since we avoid it if possible at all levels. We * want to localize the complications even when that increases them. * Here the extra work involves preserving CR0_TS in TS. - * `npxproc != NULL' is supposed to be the condition that all the - * FPU resources belong to an application, but npxproc and CR0_TS + * `npxthread != NULL' is supposed to be the condition that all the + * FPU resources belong to an application, but npxthread and CR0_TS * aren't set atomically enough for this condition to work in * interrupt handlers. * @@ -241,7 +241,7 @@ ENTRY(i586_bzero) * method. CR0_TS must be preserved although it is very likely to * always end up as clear. */ - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bz1 /* @@ -303,7 +303,7 @@ fpureg_i586_bzero_loop: cmpl $8,%ecx jae fpureg_i586_bzero_loop - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bz3 /* XXX check that the condition for cases 1-2 stayed false. */ @@ -517,7 +517,7 @@ ENTRY(i586_bcopy) sarb $1,kernel_fpu_lock jc small_i586_bcopy - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bc1 /* XXX turn off handling of cases 1-2, as above. */ @@ -593,7 +593,7 @@ large_i586_bcopy_loop: cmpl $64,%ecx jae 4b - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bc2 /* XXX check that the condition for cases 1-2 stayed false. */ @@ -991,14 +991,14 @@ ENTRY(fastmove) /* XXX grab FPU context atomically. */ cli -/* if (npxproc != NULL) { */ - cmpl $0,PCPU(NPXPROC) +/* if (npxthread != NULL) { */ + cmpl $0,PCPU(NPXTHREAD) je 6f /* fnsave(&curpcb->pcb_savefpu); */ movl PCPU(CURPCB),%eax fnsave PCB_SAVEFPU(%eax) -/* npxproc = NULL; */ - movl $0,PCPU(NPXPROC) +/* NPXTHREAD = NULL; */ + movl $0,PCPU(NPXTHREAD) /* } */ 6: /* now we own the FPU. */ @@ -1026,9 +1026,9 @@ ENTRY(fastmove) movl -4(%ebp),%edi /* stop_emulating(); */ clts -/* npxproc = curproc; */ - movl PCPU(CURPROC),%eax - movl %eax,PCPU(NPXPROC) +/* npxthread = curthread; */ + movl PCPU(CURTHREAD),%eax + movl %eax,PCPU(NPXTHREAD) movl PCPU(CURPCB),%eax /* XXX end of atomic FPU context grab. */ @@ -1113,8 +1113,8 @@ fastmove_loop: smsw %ax orb $CR0_TS,%al lmsw %ax -/* npxproc = NULL; */ - movl $0,PCPU(NPXPROC) +/* npxthread = NULL; */ + movl $0,PCPU(NPXTHREAD) /* XXX end of atomic FPU context ungrab. */ sti @@ -1154,7 +1154,7 @@ fastmove_fault: smsw %ax orb $CR0_TS,%al lmsw %ax - movl $0,PCPU(NPXPROC) + movl $0,PCPU(NPXTHREAD) /* XXX end of atomic FPU context ungrab. */ sti diff --git a/sys/amd64/amd64/support.s b/sys/amd64/amd64/support.s index 55bc29c..81181cc 100644 --- a/sys/amd64/amd64/support.s +++ b/sys/amd64/amd64/support.s @@ -216,8 +216,8 @@ ENTRY(i586_bzero) * complicated since we avoid it if possible at all levels. We * want to localize the complications even when that increases them. * Here the extra work involves preserving CR0_TS in TS. - * `npxproc != NULL' is supposed to be the condition that all the - * FPU resources belong to an application, but npxproc and CR0_TS + * `npxthread != NULL' is supposed to be the condition that all the + * FPU resources belong to an application, but npxthread and CR0_TS * aren't set atomically enough for this condition to work in * interrupt handlers. * @@ -241,7 +241,7 @@ ENTRY(i586_bzero) * method. CR0_TS must be preserved although it is very likely to * always end up as clear. */ - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bz1 /* @@ -303,7 +303,7 @@ fpureg_i586_bzero_loop: cmpl $8,%ecx jae fpureg_i586_bzero_loop - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bz3 /* XXX check that the condition for cases 1-2 stayed false. */ @@ -517,7 +517,7 @@ ENTRY(i586_bcopy) sarb $1,kernel_fpu_lock jc small_i586_bcopy - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bc1 /* XXX turn off handling of cases 1-2, as above. */ @@ -593,7 +593,7 @@ large_i586_bcopy_loop: cmpl $64,%ecx jae 4b - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bc2 /* XXX check that the condition for cases 1-2 stayed false. */ @@ -991,14 +991,14 @@ ENTRY(fastmove) /* XXX grab FPU context atomically. */ cli -/* if (npxproc != NULL) { */ - cmpl $0,PCPU(NPXPROC) +/* if (npxthread != NULL) { */ + cmpl $0,PCPU(NPXTHREAD) je 6f /* fnsave(&curpcb->pcb_savefpu); */ movl PCPU(CURPCB),%eax fnsave PCB_SAVEFPU(%eax) -/* npxproc = NULL; */ - movl $0,PCPU(NPXPROC) +/* NPXTHREAD = NULL; */ + movl $0,PCPU(NPXTHREAD) /* } */ 6: /* now we own the FPU. */ @@ -1026,9 +1026,9 @@ ENTRY(fastmove) movl -4(%ebp),%edi /* stop_emulating(); */ clts -/* npxproc = curproc; */ - movl PCPU(CURPROC),%eax - movl %eax,PCPU(NPXPROC) +/* npxthread = curthread; */ + movl PCPU(CURTHREAD),%eax + movl %eax,PCPU(NPXTHREAD) movl PCPU(CURPCB),%eax /* XXX end of atomic FPU context grab. */ @@ -1113,8 +1113,8 @@ fastmove_loop: smsw %ax orb $CR0_TS,%al lmsw %ax -/* npxproc = NULL; */ - movl $0,PCPU(NPXPROC) +/* npxthread = NULL; */ + movl $0,PCPU(NPXTHREAD) /* XXX end of atomic FPU context ungrab. */ sti @@ -1154,7 +1154,7 @@ fastmove_fault: smsw %ax orb $CR0_TS,%al lmsw %ax - movl $0,PCPU(NPXPROC) + movl $0,PCPU(NPXTHREAD) /* XXX end of atomic FPU context ungrab. */ sti diff --git a/sys/amd64/amd64/swtch.s b/sys/amd64/amd64/swtch.s index 0f2f7a8..075aa36 100644 --- a/sys/amd64/amd64/swtch.s +++ b/sys/amd64/amd64/swtch.s @@ -77,17 +77,17 @@ ENTRY(cpu_throw) ENTRY(cpu_switch) /* switch to new process. first, save context as needed */ - movl PCPU(CURPROC),%ecx + movl PCPU(CURTHREAD),%ecx /* if no process to save, don't bother */ testl %ecx,%ecx jz sw1 - - movl P_VMSPACE(%ecx), %edx + movl TD_PROC(%ecx), %eax + movl P_VMSPACE(%eax), %edx movl PCPU(CPUID), %eax btrl %eax, VM_PMAP+PM_ACTIVE(%edx) - movl P_ADDR(%ecx),%edx + movl TD_PCB(%ecx),%edx movl (%esp),%eax /* Hardware registers */ movl %eax,PCB_EIP(%edx) @@ -124,7 +124,7 @@ ENTRY(cpu_switch) #ifdef DEV_NPX /* have we used fp, and need a save? */ - cmpl %ecx,PCPU(NPXPROC) + cmpl %ecx,PCPU(NPXTHREAD) jne 1f addl $PCB_SAVEFPU,%edx /* h/w bugs make saving complicated */ pushl %edx @@ -133,7 +133,11 @@ ENTRY(cpu_switch) 1: #endif /* DEV_NPX */ +/*##########################################################################*/ +/*##########################################################################*/ +/*##########################################################################*/ /* save is done, now choose a new process */ + /* But still trashing space above the old "Top Of Stack".. */ sw1: #ifdef SMP @@ -143,17 +147,17 @@ sw1: cmpl $0,PCPU(CPUID) je 1f - movl PCPU(IDLEPROC), %eax - jmp sw1b + movl PCPU(IDLETHREAD), %eax + jmp sw1b /* Idle thread can run on any kernel context */ 1: #endif /* - * Choose a new process to schedule. chooseproc() returns idleproc + * Choose a new process to schedule. choosethread() returns idleproc * if it cannot find another process to run. */ sw1a: - call chooseproc /* trash ecx, edx, ret eax*/ + call choosethread /* trash ecx, edx, ret eax*/ #ifdef INVARIANTS testl %eax,%eax /* no process? */ @@ -163,15 +167,20 @@ sw1b: movl %eax,%ecx #ifdef INVARIANTS - cmpb $SRUN,P_STAT(%ecx) + movl TD_PROC(%ecx), %eax /* XXXKSE */ + cmpb $SRUN,P_STAT(%eax) jne badsw2 #endif - movl P_ADDR(%ecx),%edx + movl TD_PCB(%ecx),%edx #if defined(SWTCH_OPTIM_STATS) incl swtch_optim_stats #endif + +/*##########################################################################*/ +/*##########################################################################*/ +/*##########################################################################*/ /* switch address space */ movl %cr3,%ebx cmpl PCB_CR3(%edx),%ebx @@ -181,9 +190,8 @@ sw1b: incl tlb_flush_count #endif movl PCB_CR3(%edx),%ebx - movl %ebx,%cr3 + movl %ebx,%cr3 /* LOAD NEW PAGE TABLES */ 4: - movl PCPU(CPUID), %esi cmpl $0, PCB_EXT(%edx) /* has pcb extension? */ je 1f @@ -191,12 +199,9 @@ sw1b: movl PCB_EXT(%edx), %edi /* new tss descriptor */ jmp 2f 1: - /* update common_tss.tss_esp0 pointer */ - movl %edx, %ebx /* pcb */ - addl $(UPAGES * PAGE_SIZE - 16), %ebx - movl %ebx, PCPU(COMMON_TSS) + TSS_ESP0 - + /* esp points to base of usable stack */ + movl %edx, PCPU(COMMON_TSS) + TSS_ESP0 /* stack is below pcb */ btrl %esi, private_tss jae 3f PCPU_ADDR(COMMON_TSSD, %edi) @@ -210,7 +215,9 @@ sw1b: movl $GPROC0_SEL*8, %esi /* GSEL(entry, SEL_KPL) */ ltr %si 3: - movl P_VMSPACE(%ecx), %ebx + /* note in a vmspace that this cpu is using it */ + movl TD_PROC(%ecx),%eax /* get proc from thread XXXKSE */ + movl P_VMSPACE(%eax), %ebx /* get vmspace of proc */ movl PCPU(CPUID), %eax btsl %eax, VM_PMAP+PM_ACTIVE(%ebx) @@ -233,22 +240,23 @@ sw1b: #endif /** GRAB_LOPRIO */ #endif /* SMP */ movl %edx, PCPU(CURPCB) - movl %ecx, PCPU(CURPROC) /* into next process */ + movl %ecx, PCPU(CURTHREAD) /* into next process */ #ifdef SMP /* XXX FIXME: we should be restoring the local APIC TPR */ #endif /* SMP */ - cmpl $0, PCB_USERLDT(%edx) - jnz 1f - movl _default_ldt,%eax - cmpl PCPU(CURRENTLDT),%eax - je 2f - lldt _default_ldt - movl %eax,PCPU(CURRENTLDT) + cmpl $0, PCB_USERLDT(%edx) /* if there is one */ + jnz 1f /* then use it */ + movl _default_ldt,%eax /* We will use the default */ + cmpl PCPU(CURRENTLDT),%eax /* check to see if already loaded */ + je 2f /* if so skip reload */ + lldt _default_ldt /* load the default... we trust it. */ + movl %eax,PCPU(CURRENTLDT) /* store what we have */ jmp 2f -1: pushl %edx - call set_user_ldt + +1: pushl %edx /* call a non-trusting routine */ + call set_user_ldt /* to check and load the ldt */ popl %edx 2: @@ -275,7 +283,7 @@ cpu_switch_load_gs: andl $0x0000fc00,%eax /* reserved bits */ pushl %ebx movl PCB_DR7(%edx),%ebx - andl $~0x0000fc00,%ebx + andl $~0x0000fc00,%ebx /* re-enable the restored watchpoints */ orl %ebx,%eax popl %ebx movl %eax,%dr7 @@ -322,25 +330,25 @@ ENTRY(savectx) #ifdef DEV_NPX /* - * If npxproc == NULL, then the npx h/w state is irrelevant and the + * If npxthread == NULL, then the npx h/w state is irrelevant and the * state had better already be in the pcb. This is true for forks * but not for dumps (the old book-keeping with FP flags in the pcb * always lost for dumps because the dump pcb has 0 flags). * - * If npxproc != NULL, then we have to save the npx h/w state to - * npxproc's pcb and copy it to the requested pcb, or save to the + * If npxthread != NULL, then we have to save the npx h/w state to + * npxthread's pcb and copy it to the requested pcb, or save to the * requested pcb and reload. Copying is easier because we would * have to handle h/w bugs for reloading. We used to lose the * parent's npx state for forks by forgetting to reload. */ pushfl cli - movl PCPU(NPXPROC),%eax + movl PCPU(NPXTHREAD),%eax testl %eax,%eax je 1f pushl %ecx - movl P_ADDR(%eax),%eax + movl TD_PCB(%eax),%eax leal PCB_SAVEFPU(%eax),%eax pushl %eax pushl %eax diff --git a/sys/amd64/amd64/sys_machdep.c b/sys/amd64/amd64/sys_machdep.c index 23c1cdd..acca4e7 100644 --- a/sys/amd64/amd64/sys_machdep.c +++ b/sys/amd64/amd64/sys_machdep.c @@ -35,7 +35,7 @@ * */ -#include "opt_upages.h" +#include "opt_kstack_pages.h" #include <sys/param.h> #include <sys/systm.h> @@ -65,10 +65,10 @@ -static int i386_get_ldt __P((struct proc *, char *)); -static int i386_set_ldt __P((struct proc *, char *)); -static int i386_get_ioperm __P((struct proc *, char *)); -static int i386_set_ioperm __P((struct proc *, char *)); +static int i386_get_ldt __P((struct thread *, char *)); +static int i386_set_ldt __P((struct thread *, char *)); +static int i386_get_ioperm __P((struct thread *, char *)); +static int i386_set_ioperm __P((struct thread *, char *)); #ifdef SMP static void set_user_ldt_rv __P((struct pcb *)); #endif @@ -81,28 +81,28 @@ struct sysarch_args { #endif int -sysarch(p, uap) - struct proc *p; +sysarch(td, uap) + struct thread *td; register struct sysarch_args *uap; { int error = 0; switch(uap->op) { case I386_GET_LDT: - error = i386_get_ldt(p, uap->parms); + error = i386_get_ldt(td, uap->parms); break; case I386_SET_LDT: - error = i386_set_ldt(p, uap->parms); + error = i386_set_ldt(td, uap->parms); break; case I386_GET_IOPERM: - error = i386_get_ioperm(p, uap->parms); + error = i386_get_ioperm(td, uap->parms); break; case I386_SET_IOPERM: - error = i386_set_ioperm(p, uap->parms); + error = i386_set_ioperm(td, uap->parms); break; case I386_VM86: - error = vm86_sysarch(p, uap->parms); + error = vm86_sysarch(td, uap->parms); break; default: error = EOPNOTSUPP; @@ -112,7 +112,7 @@ sysarch(p, uap) } int -i386_extend_pcb(struct proc *p) +i386_extend_pcb(struct thread *td) { int i, offset; u_long *addr; @@ -127,12 +127,18 @@ i386_extend_pcb(struct proc *p) 0, /* default 32 size */ 0 /* granularity */ }; + struct proc *p = td->td_proc; + if (td->td_proc->p_flag & P_KSES) + return (EINVAL); /* XXXKSE */ +/* XXXKSE All the code below only works in 1:1 needs changing */ ext = (struct pcb_ext *)kmem_alloc(kernel_map, ctob(IOPAGES+1)); if (ext == 0) return (ENOMEM); bzero(ext, sizeof(struct pcb_ext)); - ext->ext_tss.tss_esp0 = (unsigned)p->p_addr + ctob(UPAGES) - 16; + /* -16 is so we can convert a trapframe into vm86trapframe inplace */ + ext->ext_tss.tss_esp0 = td->td_kstack + ctob(KSTACK_PAGES) - + sizeof(struct pcb) - 16; ext->ext_tss.tss_ss0 = GSEL(GDATA_SEL, SEL_KPL); /* * The last byte of the i/o map must be followed by an 0xff byte. @@ -153,21 +159,21 @@ i386_extend_pcb(struct proc *p) ssd.ssd_limit -= ((unsigned)&ext->ext_tss - (unsigned)ext); ssdtosd(&ssd, &ext->ext_tssd); - KASSERT(p == curproc, ("giving a TSS to non-curproc")); - KASSERT(p->p_addr->u_pcb.pcb_ext == 0, ("already have a TSS!")); + KASSERT(p == curthread->td_proc, ("giving a TSS to non-curproc")); + KASSERT(td->td_pcb->pcb_ext == 0, ("already have a TSS!")); mtx_lock_spin(&sched_lock); - p->p_addr->u_pcb.pcb_ext = ext; + td->td_pcb->pcb_ext = ext; /* switch to the new TSS after syscall completes */ - p->p_sflag |= PS_NEEDRESCHED; + td->td_kse->ke_flags |= KEF_NEEDRESCHED; mtx_unlock_spin(&sched_lock); return 0; } static int -i386_set_ioperm(p, args) - struct proc *p; +i386_set_ioperm(td, args) + struct thread *td; char *args; { int i, error; @@ -177,7 +183,7 @@ i386_set_ioperm(p, args) if ((error = copyin(args, &ua, sizeof(struct i386_ioperm_args))) != 0) return (error); - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) return (error); if (securelevel > 0) return (EPERM); @@ -188,10 +194,10 @@ i386_set_ioperm(p, args) * cause confusion. This probably requires a global 'usage registry'. */ - if (p->p_addr->u_pcb.pcb_ext == 0) - if ((error = i386_extend_pcb(p)) != 0) + if (td->td_pcb->pcb_ext == 0) + if ((error = i386_extend_pcb(td)) != 0) return (error); - iomap = (char *)p->p_addr->u_pcb.pcb_ext->ext_iomap; + iomap = (char *)td->td_pcb->pcb_ext->ext_iomap; if (ua.start + ua.length > IOPAGES * PAGE_SIZE * NBBY) return (EINVAL); @@ -206,8 +212,8 @@ i386_set_ioperm(p, args) } static int -i386_get_ioperm(p, args) - struct proc *p; +i386_get_ioperm(td, args) + struct thread *td; char *args; { int i, state, error; @@ -219,12 +225,12 @@ i386_get_ioperm(p, args) if (ua.start >= IOPAGES * PAGE_SIZE * NBBY) return (EINVAL); - if (p->p_addr->u_pcb.pcb_ext == 0) { + if (td->td_pcb->pcb_ext == 0) { ua.length = 0; goto done; } - iomap = (char *)p->p_addr->u_pcb.pcb_ext->ext_iomap; + iomap = (char *)td->td_pcb->pcb_ext->ext_iomap; i = ua.start; state = (iomap[i >> 3] >> (i & 7)) & 1; @@ -351,12 +357,12 @@ user_ldt_free(struct pcb *pcb) } static int -i386_get_ldt(p, args) - struct proc *p; +i386_get_ldt(td, args) + struct thread *td; char *args; { int error = 0; - struct pcb *pcb = &p->p_addr->u_pcb; + struct pcb *pcb = td->td_pcb; struct pcb_ldt *pcb_ldt = pcb->pcb_ldt; int nldt, num; union descriptor *lp; @@ -388,19 +394,19 @@ i386_get_ldt(p, args) error = copyout(lp, uap->descs, num * sizeof(union descriptor)); if (!error) - p->p_retval[0] = num; + td->td_retval[0] = num; return(error); } static int -i386_set_ldt(p, args) - struct proc *p; +i386_set_ldt(td, args) + struct thread *td; char *args; { int error = 0, i, n; int largest_ld; - struct pcb *pcb = &p->p_addr->u_pcb; + struct pcb *pcb = td->td_pcb; struct pcb_ldt *pcb_ldt = pcb->pcb_ldt; struct i386_ldt_args ua, *uap = &ua; caddr_t old_ldt_base; @@ -530,7 +536,7 @@ i386_set_ldt(p, args) &((union descriptor *)(pcb_ldt->ldt_base))[uap->start], uap->num * sizeof(union descriptor)); if (!error) - p->p_retval[0] = uap->start; + td->td_retval[0] = uap->start; critical_exit(savecrit); return(error); diff --git a/sys/amd64/amd64/trap.c b/sys/amd64/amd64/trap.c index 4e72f9b..ee036c2 100644 --- a/sys/amd64/amd64/trap.c +++ b/sys/amd64/amd64/trap.c @@ -173,7 +173,8 @@ void trap(frame) struct trapframe frame; { - struct proc *p = curproc; + struct thread *td = curthread; + struct proc *p = td->td_proc; u_int sticks = 0; int i = 0, ucode = 0, type, code; vm_offset_t eva; @@ -225,8 +226,8 @@ restart: ((frame.tf_eflags & PSL_VM) && !in_vm86call)) { /* user trap */ - sticks = p->p_sticks; - p->p_frame = &frame; + sticks = td->td_kse->ke_sticks; + td->td_frame = &frame; switch (type) { case T_PRIVINFLT: /* privileged instruction fault */ @@ -444,7 +445,7 @@ restart: if (in_vm86call) break; - if (p->p_intr_nesting_level != 0) + if (td->td_intr_nesting_level != 0) break; /* @@ -620,7 +621,7 @@ restart: #endif user: - userret(p, &frame, sticks); + userret(td, &frame, sticks); if (mtx_owned(&Giant)) /* XXX why would Giant be owned here? */ mtx_unlock(&Giant); out: @@ -660,7 +661,7 @@ trap_pfault(frame, usermode, eva) if (p == NULL || (!usermode && va < VM_MAXUSER_ADDRESS && - (p->p_intr_nesting_level != 0 || + (td->td_intr_nesting_level != 0 || PCPU_GET(curpcb) == NULL || PCPU_GET(curpcb)->pcb_onfault == NULL))) { trap_fatal(frame, eva); @@ -696,7 +697,7 @@ trap_pfault(frame, usermode, eva) * a growable stack region, or if the stack * growth succeeded. */ - if (!grow_stack (p, va)) + if (!grow_stack (td, va)) rv = KERN_FAILURE; else /* Fault in the user page: */ @@ -728,7 +729,7 @@ trap_pfault(frame, usermode, eva) return (0); nogo: if (!usermode) { - if (p->p_intr_nesting_level == 0 && + if (td->td_intr_nesting_level == 0 && PCPU_GET(curpcb) != NULL && PCPU_GET(curpcb)->pcb_onfault != NULL) { frame->tf_eip = (int)PCPU_GET(curpcb)->pcb_onfault; @@ -756,7 +757,8 @@ trap_pfault(frame, usermode, eva) vm_map_t map = 0; int rv = 0; vm_prot_t ftype; - struct proc *p = curproc; + struct thread *td = curthread; + struct proc *p = td->td_proc; va = trunc_page(eva); if (va >= KERNBASE) { @@ -839,7 +841,7 @@ trap_pfault(frame, usermode, eva) return (0); nogo: if (!usermode) { - if (p->p_intr_nesting_level == 0 && + if (td->td_intr_nesting_level == 0 && PCPU_GET(curpcb) != NULL && PCPU_GET(curpcb)->pcb_onfault != NULL) { frame->tf_eip = (int)PCPU_GET(curpcb)->pcb_onfault; @@ -972,6 +974,7 @@ dblfault_handler() int trapwrite(addr) unsigned addr; { + struct thread *td; struct proc *p; vm_offset_t va; struct vmspace *vm; @@ -984,7 +987,8 @@ int trapwrite(addr) if (va >= VM_MAXUSER_ADDRESS) return (1); - p = curproc; + td = curthread; + p = td->td_proc; vm = p->p_vmspace; PROC_LOCK(p); @@ -1021,7 +1025,8 @@ syscall(frame) caddr_t params; int i; struct sysent *callp; - struct proc *p = curproc; + struct thread *td = curthread; + struct proc *p = td->td_proc; u_int sticks; int error; int narg; @@ -1039,8 +1044,8 @@ syscall(frame) } #endif - sticks = p->p_sticks; - p->p_frame = &frame; + sticks = td->td_kse->ke_sticks; + td->td_frame = &frame; params = (caddr_t)frame.tf_esp + sizeof(int); code = frame.tf_eax; @@ -1109,17 +1114,17 @@ syscall(frame) ktrsyscall(p->p_tracep, code, narg, args); } #endif - p->p_retval[0] = 0; - p->p_retval[1] = frame.tf_edx; + td->td_retval[0] = 0; + td->td_retval[1] = frame.tf_edx; STOPEVENT(p, S_SCE, narg); - error = (*callp->sy_call)(p, args); + error = (*callp->sy_call)(td, args); switch (error) { case 0: - frame.tf_eax = p->p_retval[0]; - frame.tf_edx = p->p_retval[1]; + frame.tf_eax = td->td_retval[0]; + frame.tf_edx = td->td_retval[1]; frame.tf_eflags &= ~PSL_C; break; @@ -1158,11 +1163,11 @@ bad: /* * Handle reschedule and other end-of-syscall issues */ - userret(p, &frame, sticks); + userret(td, &frame, 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 @@ -1183,7 +1188,7 @@ bad: 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]); } diff --git a/sys/amd64/amd64/vm_machdep.c b/sys/amd64/amd64/vm_machdep.c index 53cedff..83ddc21 100644 --- a/sys/amd64/amd64/vm_machdep.c +++ b/sys/amd64/amd64/vm_machdep.c @@ -47,7 +47,7 @@ #endif #include "opt_reset.h" #include "opt_isa.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" #include <sys/param.h> #include <sys/systm.h> @@ -117,19 +117,24 @@ 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; { + register struct proc *p1; + struct thread *td2; struct pcb *pcb2; #ifdef DEV_NPX int savecrit; #endif + p1 = td1->td_proc; + td2 = &p2->p_thread; if ((flags & RFPROC) == 0) { if ((flags & RFMEM) == 0) { /* unshare user LDT */ - struct pcb *pcb1 = &p1->p_addr->u_pcb; + struct pcb *pcb1 = td1->td_pcb; struct pcb_ldt *pcb_ldt = pcb1->pcb_ldt; if (pcb_ldt && pcb_ldt->ldt_refcnt > 1) { pcb_ldt = user_ldt_alloc(pcb1,pcb_ldt->ldt_len); @@ -145,30 +150,32 @@ cpu_fork(p1, p2, flags) /* Ensure that p1's pcb is up to date. */ #ifdef DEV_NPX - if (p1 == curproc) - p1->p_addr->u_pcb.pcb_gs = rgs(); + if (td1 == curthread) + td1->td_pcb->pcb_gs = rgs(); savecrit = critical_enter(); - if (PCPU_GET(npxproc) == p1) - npxsave(&p1->p_addr->u_pcb.pcb_save); + if (PCPU_GET(npxthread) == td1) + npxsave(&td1->td_pcb->pcb_save); critical_exit(savecrit); #endif + /* Point the pcb to the top of the stack */ + pcb2 = (struct pcb *)(td2->td_kstack + KSTACK_PAGES * PAGE_SIZE) - 1; + td2->td_pcb = pcb2; + /* Copy p1's pcb. */ - p2->p_addr->u_pcb = p1->p_addr->u_pcb; - pcb2 = &p2->p_addr->u_pcb; + bcopy(td1->td_pcb, pcb2, sizeof(*pcb2)); /* * Create a new fresh stack for the new process. * Copy the trap frame for the return to user mode as if from a * syscall. This copies most of the user mode register values. */ - p2->p_frame = (struct trapframe *) - ((int)p2->p_addr + UPAGES * PAGE_SIZE - 16) - 1; - 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)); - p2->p_frame->tf_eax = 0; /* Child returns zero */ - p2->p_frame->tf_eflags &= ~PSL_C; /* success */ - p2->p_frame->tf_edx = 1; + td2->td_frame->tf_eax = 0; /* Child returns zero */ + td2->td_frame->tf_eflags &= ~PSL_C; /* success */ + td2->td_frame->tf_edx = 1; /* * Set registers for trampoline to user mode. Leave space for the @@ -178,8 +185,8 @@ cpu_fork(p1, p2, flags) pcb2->pcb_edi = 0; pcb2->pcb_esi = (int)fork_return; /* fork_trampoline argument */ pcb2->pcb_ebp = 0; - pcb2->pcb_esp = (int)p2->p_frame - sizeof(void *); - pcb2->pcb_ebx = (int)p2; /* fork_trampoline argument */ + pcb2->pcb_esp = (int)td2->td_frame - sizeof(void *); + pcb2->pcb_ebx = (int)td2; /* fork_trampoline argument */ pcb2->pcb_eip = (int)fork_trampoline; /*- * pcb2->pcb_dr*: cloned above. @@ -228,8 +235,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; { @@ -237,18 +244,18 @@ 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_esi = (int) func; /* function */ - p->p_addr->u_pcb.pcb_ebx = (int) arg; /* first arg */ + td->td_pcb->pcb_esi = (int) func; /* function */ + td->td_pcb->pcb_ebx = (int) arg; /* first arg */ } void -cpu_exit(p) - register struct proc *p; +cpu_exit(td) + register struct thread *td; { - struct pcb *pcb = &p->p_addr->u_pcb; + struct pcb *pcb = td->td_pcb; #ifdef DEV_NPX - npxexit(p); + npxexit(td); #endif if (pcb->pcb_ext != 0) { /* @@ -280,25 +287,29 @@ 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; { + struct proc *p = td->td_proc; int error; caddr_t tempuser; - tempuser = malloc(ctob(UPAGES), M_TEMP, M_WAITOK | M_ZERO); + tempuser = malloc(ctob(UAREA_PAGES + KSTACK_PAGES), M_TEMP, M_WAITOK | M_ZERO); if (!tempuser) return EINVAL; - bcopy(p->p_addr, tempuser, sizeof(struct user)); - bcopy(p->p_frame, - tempuser + ((caddr_t) p->p_frame - (caddr_t) p->p_addr), + bcopy(p->p_uarea, tempuser, sizeof(struct user)); +#if 0 /* XXXKSE - broken, fixme!!!!! td_frame is in kstack! */ + bcopy(td->td_frame, + tempuser + ((caddr_t) td->td_frame - (caddr_t) p->p_uarea), sizeof(struct trapframe)); +#endif - error = vn_rdwr(UIO_WRITE, vp, (caddr_t) tempuser, ctob(UPAGES), - (off_t)0, UIO_SYSSPACE, IO_UNIT, cred, (int *)NULL, p); + error = vn_rdwr(UIO_WRITE, vp, (caddr_t) tempuser, + ctob(UAREA_PAGES + KSTACK_PAGES), + (off_t)0, UIO_SYSSPACE, IO_UNIT, cred, (int *)NULL, td); free(tempuser, M_TEMP); diff --git a/sys/amd64/include/cpu.h b/sys/amd64/include/cpu.h index 04ef7a0..a7783a0 100644 --- a/sys/amd64/include/cpu.h +++ b/sys/amd64/include/cpu.h @@ -56,8 +56,8 @@ #define cpu_exec(p) /* nothing */ #define cpu_swapin(p) /* nothing */ -#define cpu_getstack(p) ((p)->p_frame->tf_esp) -#define cpu_setstack(p, ap) ((p)->p_frame->tf_esp = (ap)) +#define cpu_getstack(td) ((td)->td_frame->tf_esp) +#define cpu_setstack(td, ap) ((td)->td_frame->tf_esp = (ap)) #define TRAPF_USERMODE(framep) \ ((ISPL((framep)->tf_cs) == SEL_UPL) || ((framep)->tf_eflags & PSL_VM)) diff --git a/sys/amd64/include/fpu.h b/sys/amd64/include/fpu.h index 67ce661..589a4be 100644 --- a/sys/amd64/include/fpu.h +++ b/sys/amd64/include/fpu.h @@ -142,7 +142,7 @@ union savefpu { #ifdef _KERNEL int npxdna __P((void)); -void npxexit __P((struct proc *p)); +void npxexit __P((struct thread *td)); void npxinit __P((int control)); void npxsave __P((union savefpu *addr)); int npxtrap __P((void)); diff --git a/sys/amd64/include/md_var.h b/sys/amd64/include/md_var.h index bc9cb75..c3564c2 100644 --- a/sys/amd64/include/md_var.h +++ b/sys/amd64/include/md_var.h @@ -61,7 +61,7 @@ extern char sigcode[]; extern int szsigcode, szosigcode; typedef void alias_for_inthand_t __P((u_int cs, u_int ef, u_int esp, u_int ss)); -struct proc; +struct thread; struct reg; struct fpreg; struct dbreg; @@ -80,9 +80,9 @@ void doreti_popl_es __P((void)) __asm(__STRING(doreti_popl_es)); void doreti_popl_es_fault __P((void)) __asm(__STRING(doreti_popl_es_fault)); void doreti_popl_fs __P((void)) __asm(__STRING(doreti_popl_fs)); void doreti_popl_fs_fault __P((void)) __asm(__STRING(doreti_popl_fs_fault)); -int fill_fpregs __P((struct proc *, struct fpreg *)); -int fill_regs __P((struct proc *p, struct reg *regs)); -int fill_dbregs __P((struct proc *p, struct dbreg *dbregs)); +int fill_fpregs __P((struct thread *, struct fpreg *)); +int fill_regs __P((struct thread *p, struct reg *regs)); +int fill_dbregs __P((struct thread *p, struct dbreg *dbregs)); void fillw __P((int /*u_short*/ pat, void *base, size_t cnt)); void i486_bzero __P((void *buf, size_t len)); void i586_bcopy __P((const void *from, void *to, size_t len)); diff --git a/sys/amd64/include/mptable.h b/sys/amd64/include/mptable.h index d912e0c..f558524 100644 --- a/sys/amd64/include/mptable.h +++ b/sys/amd64/include/mptable.h @@ -26,7 +26,7 @@ */ #include "opt_cpu.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" #ifdef SMP #include <machine/smptests.h> @@ -1960,8 +1960,8 @@ start_all_aps(u_int boot_addr) SMPpt[pg] = (pt_entry_t)(PG_V | PG_RW | vtophys(gd)); /* allocate and set up an idle stack data page */ - stack = (char *)kmem_alloc(kernel_map, UPAGES*PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); /* XXXKSE */ + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[pg + 1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -1977,7 +1977,7 @@ start_all_aps(u_int boot_addr) outb(CMOS_DATA, BIOS_WARM); /* 'warm-start' */ #endif - bootSTK = &SMP_prvspace[x].idlestack[UPAGES*PAGE_SIZE]; + bootSTK = &SMP_prvspace[x].idlekstack[KSTACK_PAGES * PAGE_SIZE]; bootAP = x; /* attempt to start the Application Processor */ @@ -2019,8 +2019,8 @@ start_all_aps(u_int boot_addr) */ /* Allocate and setup BSP idle stack */ - stack = (char *)kmem_alloc(kernel_map, UPAGES * PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -2241,7 +2241,7 @@ ap_init(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); /* lock against other AP's that are waking up */ @@ -2323,7 +2323,7 @@ forwarded_statclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - statclock_process(curproc, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); + statclock_process(curthread->td_kse, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } @@ -2354,7 +2354,7 @@ forwarded_hardclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - hardclock_process(curproc, TRAPF_USERMODE(&frame)); + hardclock_process(curthread, TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } diff --git a/sys/amd64/include/mutex.h b/sys/amd64/include/mutex.h index b0fe512..ae37b23 100644 --- a/sys/amd64/include/mutex.h +++ b/sys/amd64/include/mutex.h @@ -250,7 +250,7 @@ extern struct mtx clock_lock; pushl %ecx ; \ pushl %ebx ; \ movl $(MTX_UNOWNED) , %eax ; \ - movl PCPU(CURPROC), %ebx ; \ + movl PCPU(CURTHREAD), %ebx ; \ pushfl ; \ popl %ecx ; \ cli ; \ diff --git a/sys/amd64/include/npx.h b/sys/amd64/include/npx.h index 67ce661..589a4be 100644 --- a/sys/amd64/include/npx.h +++ b/sys/amd64/include/npx.h @@ -142,7 +142,7 @@ union savefpu { #ifdef _KERNEL int npxdna __P((void)); -void npxexit __P((struct proc *p)); +void npxexit __P((struct thread *td)); void npxinit __P((int control)); void npxsave __P((union savefpu *addr)); int npxtrap __P((void)); diff --git a/sys/amd64/include/pcb_ext.h b/sys/amd64/include/pcb_ext.h index 7d6fb08..c6f9fc0 100644 --- a/sys/amd64/include/pcb_ext.h +++ b/sys/amd64/include/pcb_ext.h @@ -53,7 +53,7 @@ struct pcb_ldt { #ifdef _KERNEL -int i386_extend_pcb __P((struct proc *)); +int i386_extend_pcb __P((struct thread *)); void set_user_ldt __P((struct pcb *)); struct pcb_ldt *user_ldt_alloc __P((struct pcb *, int)); void user_ldt_free __P((struct pcb *)); diff --git a/sys/amd64/include/pcpu.h b/sys/amd64/include/pcpu.h index 37388aa..f02354d 100644 --- a/sys/amd64/include/pcpu.h +++ b/sys/amd64/include/pcpu.h @@ -52,19 +52,19 @@ * other processors" */ struct globaldata { - struct globaldata *gd_prvspace; /* self-reference */ - struct proc *gd_curproc; /* current process */ - struct proc *gd_idleproc; /* idle process */ - struct proc *gd_npxproc; - struct pcb *gd_curpcb; /* current pcb */ - struct timeval gd_switchtime; - struct i386tss gd_common_tss; - int gd_switchticks; - struct segment_descriptor gd_common_tssd; - struct segment_descriptor *gd_tss_gdt; - int gd_currentldt; - u_int gd_cpuid; /* this cpu number */ - u_int gd_other_cpus; /* all other cpus */ + struct globaldata *gd_prvspace; /* self-reference */ + struct thread *gd_curthread; + struct thread *gd_npxthread; + struct pcb *gd_curpcb; + struct thread *gd_idlethread; + struct timeval gd_switchtime; + struct i386tss gd_common_tss; + int gd_switchticks; + struct segment_descriptor gd_common_tssd; + struct segment_descriptor *gd_tss_gdt; + int gd_currentldt; + u_int gd_cpuid; + u_int gd_other_cpus; SLIST_ENTRY(globaldata) gd_allcpu; struct lock_list_entry *gd_spinlocks; #ifdef KTR_PERCPU diff --git a/sys/amd64/include/proc.h b/sys/amd64/include/proc.h index 4217c4f..9e9e449 100644 --- a/sys/amd64/include/proc.h +++ b/sys/amd64/include/proc.h @@ -42,6 +42,9 @@ /* * Machine-dependent part of the proc structure for i386. */ +struct mdthread { +}; + struct mdproc { }; diff --git a/sys/amd64/include/reg.h b/sys/amd64/include/reg.h index 47856a3..f4c6ae5 100644 --- a/sys/amd64/include/reg.h +++ b/sys/amd64/include/reg.h @@ -143,10 +143,10 @@ struct dbreg { /* * XXX these interfaces are MI, so they should be declared in a MI place. */ -int set_fpregs __P((struct proc *, struct fpreg *)); -int set_regs __P((struct proc *p, struct reg *regs)); -void setregs __P((struct proc *, u_long, u_long, u_long)); -int set_dbregs __P((struct proc *p, struct dbreg *dbregs)); +int set_fpregs __P((struct thread *, struct fpreg *)); +int set_regs __P((struct thread *p, struct reg *regs)); +void setregs __P((struct thread *, u_long, u_long, u_long)); +int set_dbregs __P((struct thread *p, struct dbreg *dbregs)); #endif #endif /* !_MACHINE_REG_H_ */ diff --git a/sys/amd64/isa/atpic_vector.S b/sys/amd64/isa/atpic_vector.S index 6b48737..3a42af4 100644 --- a/sys/amd64/isa/atpic_vector.S +++ b/sys/amd64/isa/atpic_vector.S @@ -61,8 +61,8 @@ IDTVEC(vec_name) ; \ mov $KPSEL,%ax ; \ mov %ax,%fs ; \ FAKE_MCOUNT((12+ACTUALLY_PUSHED)*4(%esp)) ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ pushl intr_unit + (irq_num) * 4 ; \ call *intr_handler + (irq_num) * 4 ; /* do the work ASAP */ \ enable_icus ; /* (re)enable ASAP (helps edge trigger?) */ \ @@ -70,7 +70,7 @@ IDTVEC(vec_name) ; \ incl cnt+V_INTR ; /* book-keeping can wait */ \ movl intr_countp + (irq_num) * 4,%eax ; \ incl (%eax) ; \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ jmp doreti @@ -104,14 +104,14 @@ IDTVEC(vec_name) ; \ movb %al,imen + IRQ_BYTE(irq_num) ; \ outb %al,$icu+ICU_IMR_OFFSET ; \ enable_icus ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ __CONCAT(Xresume,irq_num): ; \ FAKE_MCOUNT(13*4(%esp)) ; /* XXX late to avoid double count */ \ pushl $irq_num; /* pass the IRQ */ \ call sched_ithd ; \ addl $4, %esp ; /* discard the parameter */ \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ /* We could usually avoid the following jmp by inlining some of */ \ /* doreti, but it's probably better to use less cache. */ \ diff --git a/sys/amd64/isa/icu_vector.S b/sys/amd64/isa/icu_vector.S index 6b48737..3a42af4 100644 --- a/sys/amd64/isa/icu_vector.S +++ b/sys/amd64/isa/icu_vector.S @@ -61,8 +61,8 @@ IDTVEC(vec_name) ; \ mov $KPSEL,%ax ; \ mov %ax,%fs ; \ FAKE_MCOUNT((12+ACTUALLY_PUSHED)*4(%esp)) ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ pushl intr_unit + (irq_num) * 4 ; \ call *intr_handler + (irq_num) * 4 ; /* do the work ASAP */ \ enable_icus ; /* (re)enable ASAP (helps edge trigger?) */ \ @@ -70,7 +70,7 @@ IDTVEC(vec_name) ; \ incl cnt+V_INTR ; /* book-keeping can wait */ \ movl intr_countp + (irq_num) * 4,%eax ; \ incl (%eax) ; \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ jmp doreti @@ -104,14 +104,14 @@ IDTVEC(vec_name) ; \ movb %al,imen + IRQ_BYTE(irq_num) ; \ outb %al,$icu+ICU_IMR_OFFSET ; \ enable_icus ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ __CONCAT(Xresume,irq_num): ; \ FAKE_MCOUNT(13*4(%esp)) ; /* XXX late to avoid double count */ \ pushl $irq_num; /* pass the IRQ */ \ call sched_ithd ; \ addl $4, %esp ; /* discard the parameter */ \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ /* We could usually avoid the following jmp by inlining some of */ \ /* doreti, but it's probably better to use less cache. */ \ diff --git a/sys/amd64/isa/icu_vector.s b/sys/amd64/isa/icu_vector.s index 6b48737..3a42af4 100644 --- a/sys/amd64/isa/icu_vector.s +++ b/sys/amd64/isa/icu_vector.s @@ -61,8 +61,8 @@ IDTVEC(vec_name) ; \ mov $KPSEL,%ax ; \ mov %ax,%fs ; \ FAKE_MCOUNT((12+ACTUALLY_PUSHED)*4(%esp)) ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ pushl intr_unit + (irq_num) * 4 ; \ call *intr_handler + (irq_num) * 4 ; /* do the work ASAP */ \ enable_icus ; /* (re)enable ASAP (helps edge trigger?) */ \ @@ -70,7 +70,7 @@ IDTVEC(vec_name) ; \ incl cnt+V_INTR ; /* book-keeping can wait */ \ movl intr_countp + (irq_num) * 4,%eax ; \ incl (%eax) ; \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ jmp doreti @@ -104,14 +104,14 @@ IDTVEC(vec_name) ; \ movb %al,imen + IRQ_BYTE(irq_num) ; \ outb %al,$icu+ICU_IMR_OFFSET ; \ enable_icus ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ __CONCAT(Xresume,irq_num): ; \ FAKE_MCOUNT(13*4(%esp)) ; /* XXX late to avoid double count */ \ pushl $irq_num; /* pass the IRQ */ \ call sched_ithd ; \ addl $4, %esp ; /* discard the parameter */ \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ /* We could usually avoid the following jmp by inlining some of */ \ /* doreti, but it's probably better to use less cache. */ \ diff --git a/sys/amd64/isa/npx.c b/sys/amd64/isa/npx.c index 4fe3d04..84534ea 100644 --- a/sys/amd64/isa/npx.c +++ b/sys/amd64/isa/npx.c @@ -128,23 +128,23 @@ void stop_emulating __P((void)); #endif /* __GNUC__ */ #ifdef CPU_ENABLE_SSE -#define GET_FPU_CW(proc) \ +#define GET_FPU_CW(thread) \ (cpu_fxsr ? \ - (proc)->p_addr->u_pcb.pcb_save.sv_xmm.sv_env.en_cw : \ - (proc)->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_cw) -#define GET_FPU_SW(proc) \ + (thread)->td_pcb->pcb_save.sv_xmm.sv_env.en_cw : \ + (thread)->td_pcb->pcb_save.sv_87.sv_env.en_cw) +#define GET_FPU_SW(thread) \ (cpu_fxsr ? \ - (proc)->p_addr->u_pcb.pcb_save.sv_xmm.sv_env.en_sw : \ - (proc)->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_sw) + (thread)->td_pcb->pcb_save.sv_xmm.sv_env.en_sw : \ + (thread)->td_pcb->pcb_save.sv_87.sv_env.en_sw) #define GET_FPU_EXSW_PTR(pcb) \ (cpu_fxsr ? \ &(pcb)->pcb_save.sv_xmm.sv_ex_sw : \ &(pcb)->pcb_save.sv_87.sv_ex_sw) #else /* CPU_ENABLE_SSE */ -#define GET_FPU_CW(proc) \ - (proc->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_cw) -#define GET_FPU_SW(proc) \ - (proc->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_sw) +#define GET_FPU_CW(thread) \ + (thread->td_pcb->pcb_save.sv_87.sv_env.en_cw) +#define GET_FPU_SW(thread) \ + (thread->td_pcb->pcb_save.sv_87.sv_env.en_sw) #define GET_FPU_EXSW_PTR(pcb) \ (&(pcb)->pcb_save.sv_87.sv_ex_sw) #endif /* CPU_ENABLE_SSE */ @@ -241,7 +241,7 @@ static void npx_intr(dummy) void *dummy; { - struct proc *p; + struct thread *td; /* * The BUSY# latch must be cleared in all cases so that the next @@ -250,22 +250,22 @@ npx_intr(dummy) outb(0xf0, 0); /* - * npxproc is normally non-null here. In that case, schedule an + * npxthread is normally non-null here. In that case, schedule an * AST to finish the exception handling in the correct context - * (this interrupt may occur after the process has entered the + * (this interrupt may occur after the thread has entered the * kernel via a syscall or an interrupt). Otherwise, the npx - * state of the process that caused this interrupt must have been - * pushed to the process' pcb, and clearing of the busy latch + * state of the thread that caused this interrupt must have been + * pushed to the thread' pcb, and clearing of the busy latch * above has finished the (essentially null) handling of this * interrupt. Control will eventually return to the instruction * that caused it and it will repeat. We will eventually (usually * soon) win the race to handle the interrupt properly. */ - p = PCPU_GET(npxproc); - if (p != NULL) { - p->p_addr->u_pcb.pcb_flags |= PCB_NPXTRAP; + td = PCPU_GET(npxthread); + if (td != NULL) { + td->td_pcb->pcb_flags |= PCB_NPXTRAP; mtx_lock_spin(&sched_lock); - p->p_sflag |= PS_ASTPENDING; + td->td_kse->ke_flags |= KEF_ASTPENDING; mtx_unlock_spin(&sched_lock); } } @@ -570,7 +570,7 @@ npxinit(control) /* * fninit has the same h/w bugs as fnsave. Use the detoxified * fnsave to throw away any junk in the fpu. npxsave() initializes - * the fpu and sets npxproc = NULL as important side effects. + * the fpu and sets npxthread = NULL as important side effects. */ savecrit = critical_enter(); npxsave(&dummy); @@ -586,13 +586,13 @@ npxinit(control) * Free coprocessor (if we have it). */ void -npxexit(p) - struct proc *p; +npxexit(td) + struct thread *td; { critical_t savecrit; savecrit = critical_enter(); - if (p == PCPU_GET(npxproc)) + if (td == PCPU_GET(npxthread)) npxsave(&PCPU_GET(curpcb)->pcb_save); critical_exit(savecrit); #ifdef NPX_DEBUG @@ -607,8 +607,9 @@ npxexit(p) */ if (masked_exceptions & 0x0d) log(LOG_ERR, - "pid %d (%s) exited with masked floating point exceptions 0x%02x\n", - p->p_pid, p->p_comm, masked_exceptions); + "pid %d (%s) exited with masked floating" + " point exceptions 0x%02x\n", + td->td_proc->p_pid, td->td_proc->p_comm, masked_exceptions); } #endif } @@ -809,8 +810,8 @@ npxtrap() u_long *exstat; if (!npx_exists) { - printf("npxtrap: npxproc = %p, curproc = %p, npx_exists = %d\n", - PCPU_GET(npxproc), curproc, npx_exists); + printf("npxtrap: npxthread = %p, curthread = %p, npx_exists = %d\n", + PCPU_GET(npxthread), curthread, npx_exists); panic("npxtrap from nowhere"); } savecrit = critical_enter(); @@ -820,18 +821,18 @@ npxtrap() * state to memory. Fetch the relevant parts of the state from * wherever they are. */ - if (PCPU_GET(npxproc) != curproc) { - control = GET_FPU_CW(curproc); - status = GET_FPU_SW(curproc); + if (PCPU_GET(npxthread) != curthread) { + control = GET_FPU_CW(curthread); + status = GET_FPU_SW(curthread); } else { fnstcw(&control); fnstsw(&status); } - exstat = GET_FPU_EXSW_PTR(&curproc->p_addr->u_pcb); + exstat = GET_FPU_EXSW_PTR(curthread->td_pcb); *exstat = status; - if (PCPU_GET(npxproc) != curproc) - GET_FPU_SW(curproc) &= ~0x80bf; + if (PCPU_GET(npxthread) != curthread) + GET_FPU_SW(curthread) &= ~0x80bf; else fnclex(); critical_exit(savecrit); @@ -841,7 +842,7 @@ npxtrap() /* * Implement device not available (DNA) exception * - * It would be better to switch FP context here (if curproc != npxproc) + * It would be better to switch FP context here (if curthread != npxthread) * and not necessarily for every context switch, but it is too hard to * access foreign pcb's. */ @@ -853,9 +854,9 @@ npxdna() if (!npx_exists) return (0); - if (PCPU_GET(npxproc) != NULL) { - printf("npxdna: npxproc = %p, curproc = %p\n", - PCPU_GET(npxproc), curproc); + if (PCPU_GET(npxthread) != NULL) { + printf("npxdna: npxthread = %p, curthread = %p\n", + PCPU_GET(npxthread), curthread); panic("npxdna"); } s = critical_enter(); @@ -863,7 +864,7 @@ npxdna() /* * Record new context early in case frstor causes an IRQ13. */ - PCPU_SET(npxproc, CURPROC); + PCPU_SET(npxthread, curthread); exstat = GET_FPU_EXSW_PTR(PCPU_GET(curpcb)); *exstat = 0; @@ -895,13 +896,13 @@ npxdna() * after the process has entered the kernel. It may even be delivered after * the fnsave here completes. A spurious IRQ13 for the fnsave is handled in * the same way as a very-late-arriving non-spurious IRQ13 from user mode: - * it is normally ignored at first because we set npxproc to NULL; it is + * it is normally ignored at first because we set npxthread to NULL; it is * normally retriggered in npxdna() after return to user mode. * * npxsave() must be called with interrupts disabled, so that it clears - * npxproc atomically with saving the state. We require callers to do the + * npxthread atomically with saving the state. We require callers to do the * disabling, since most callers need to disable interrupts anyway to call - * npxsave() atomically with checking npxproc. + * npxsave() atomically with checking npxthread. * * A previous version of npxsave() went to great lengths to excecute fnsave * with interrupts enabled in case executing it froze the CPU. This case @@ -917,7 +918,7 @@ npxsave(addr) fpusave(addr); start_emulating(); - PCPU_SET(npxproc, NULL); + PCPU_SET(npxthread, NULL); } static void diff --git a/sys/cam/cam_xpt.c b/sys/cam/cam_xpt.c index 9d5ee8f..b3a31fd 100644 --- a/sys/cam/cam_xpt.c +++ b/sys/cam/cam_xpt.c @@ -909,7 +909,7 @@ xptdone(struct cam_periph *periph, union ccb *done_ccb) } static int -xptopen(dev_t dev, int flags, int fmt, struct proc *p) +xptopen(dev_t dev, int flags, int fmt, struct thread *td) { int unit; @@ -946,7 +946,7 @@ xptopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -xptclose(dev_t dev, int flag, int fmt, struct proc *p) +xptclose(dev_t dev, int flag, int fmt, struct thread *td) { int unit; @@ -969,7 +969,7 @@ xptclose(dev_t dev, int flag, int fmt, struct proc *p) } static int -xptioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +xptioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { int unit, error; diff --git a/sys/cam/scsi/scsi_cd.c b/sys/cam/scsi/scsi_cd.c index 923b4bd..09fe6a8 100644 --- a/sys/cam/scsi/scsi_cd.c +++ b/sys/cam/scsi/scsi_cd.c @@ -873,7 +873,7 @@ cdregisterexit: } static int -cdopen(dev_t dev, int flags, int fmt, struct proc *p) +cdopen(dev_t dev, int flags, int fmt, struct thread *td) { struct disklabel *label; struct cam_periph *periph; @@ -985,7 +985,7 @@ cdopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -cdclose(dev_t dev, int flag, int fmt, struct proc *p) +cdclose(dev_t dev, int flag, int fmt, struct thread *td) { struct cam_periph *periph; struct cd_softc *softc; @@ -1806,7 +1806,7 @@ cddone(struct cam_periph *periph, union ccb *done_ccb) } static int -cdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +cdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct cam_periph *periph; diff --git a/sys/cam/scsi/scsi_ch.c b/sys/cam/scsi/scsi_ch.c index 7d9bba3..2e6a40d 100644 --- a/sys/cam/scsi/scsi_ch.c +++ b/sys/cam/scsi/scsi_ch.c @@ -424,7 +424,7 @@ chregister(struct cam_periph *periph, void *arg) } static int -chopen(dev_t dev, int flags, int fmt, struct proc *p) +chopen(dev_t dev, int flags, int fmt, struct thread *td) { struct cam_periph *periph; struct ch_softc *softc; @@ -474,7 +474,7 @@ chopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -chclose(dev_t dev, int flag, int fmt, struct proc *p) +chclose(dev_t dev, int flag, int fmt, struct thread *td) { struct cam_periph *periph; struct ch_softc *softc; @@ -724,7 +724,7 @@ cherror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags) } static int -chioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +chioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct cam_periph *periph; struct ch_softc *softc; diff --git a/sys/cam/scsi/scsi_da.c b/sys/cam/scsi/scsi_da.c index a402ec0..104cff5 100644 --- a/sys/cam/scsi/scsi_da.c +++ b/sys/cam/scsi/scsi_da.c @@ -378,7 +378,7 @@ static SLIST_HEAD(,da_softc) softc_list; static struct extend_array *daperiphs; static int -daopen(dev_t dev, int flags, int fmt, struct proc *p) +daopen(dev_t dev, int flags, int fmt, struct thread *td) { struct cam_periph *periph; struct da_softc *softc; @@ -501,7 +501,7 @@ daopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -daclose(dev_t dev, int flag, int fmt, struct proc *p) +daclose(dev_t dev, int flag, int fmt, struct thread *td) { struct cam_periph *periph; struct da_softc *softc; @@ -651,7 +651,7 @@ dastrategy(struct bio *bp) #endif static int -daioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +daioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct cam_periph *periph; struct da_softc *softc; diff --git a/sys/cam/scsi/scsi_pass.c b/sys/cam/scsi/scsi_pass.c index c6ed554..e81de98 100644 --- a/sys/cam/scsi/scsi_pass.c +++ b/sys/cam/scsi/scsi_pass.c @@ -341,7 +341,7 @@ passregister(struct cam_periph *periph, void *arg) } static int -passopen(dev_t dev, int flags, int fmt, struct proc *p) +passopen(dev_t dev, int flags, int fmt, struct thread *td) { struct cam_periph *periph; struct pass_softc *softc; @@ -412,7 +412,7 @@ passopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -passclose(dev_t dev, int flag, int fmt, struct proc *p) +passclose(dev_t dev, int flag, int fmt, struct thread *td) { struct cam_periph *periph; struct pass_softc *softc; @@ -478,7 +478,7 @@ passdone(struct cam_periph *periph, union ccb *done_ccb) } static int -passioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +passioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct cam_periph *periph; struct pass_softc *softc; diff --git a/sys/cam/scsi/scsi_pt.c b/sys/cam/scsi/scsi_pt.c index 0211d4d..4e62bc2 100644 --- a/sys/cam/scsi/scsi_pt.c +++ b/sys/cam/scsi/scsi_pt.c @@ -141,7 +141,7 @@ static struct extend_array *ptperiphs; #endif static int -ptopen(dev_t dev, int flags, int fmt, struct proc *p) +ptopen(dev_t dev, int flags, int fmt, struct thread *td) { struct cam_periph *periph; struct pt_softc *softc; @@ -185,7 +185,7 @@ ptopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -ptclose(dev_t dev, int flag, int fmt, struct proc *p) +ptclose(dev_t dev, int flag, int fmt, struct thread *td) { struct cam_periph *periph; struct pt_softc *softc; @@ -678,7 +678,7 @@ pterror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags) } static int -ptioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +ptioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct cam_periph *periph; struct pt_softc *softc; diff --git a/sys/cam/scsi/scsi_sa.c b/sys/cam/scsi/scsi_sa.c index 51edca1..ede582c 100644 --- a/sys/cam/scsi/scsi_sa.c +++ b/sys/cam/scsi/scsi_sa.c @@ -440,7 +440,7 @@ static struct cdevsw sa_cdevsw = { static struct extend_array *saperiphs; static int -saopen(dev_t dev, int flags, int fmt, struct proc *p) +saopen(dev_t dev, int flags, int fmt, struct thread *td) { struct cam_periph *periph; struct sa_softc *softc; @@ -504,7 +504,7 @@ saopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -saclose(dev_t dev, int flag, int fmt, struct proc *p) +saclose(dev_t dev, int flag, int fmt, struct thread *td) { struct cam_periph *periph; struct sa_softc *softc; @@ -761,7 +761,7 @@ sastrategy(struct bio *bp) } static int -saioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *p) +saioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct thread *td) { struct cam_periph *periph; struct sa_softc *softc; diff --git a/sys/cam/scsi/scsi_ses.c b/sys/cam/scsi/scsi_ses.c index 635556e..62d2092 100644 --- a/sys/cam/scsi/scsi_ses.c +++ b/sys/cam/scsi/scsi_ses.c @@ -426,7 +426,7 @@ sesregister(struct cam_periph *periph, void *arg) } static int -sesopen(dev_t dev, int flags, int fmt, struct proc *p) +sesopen(dev_t dev, int flags, int fmt, struct thread *td) { struct cam_periph *periph; struct ses_softc *softc; @@ -482,7 +482,7 @@ out: } static int -sesclose(dev_t dev, int flag, int fmt, struct proc *p) +sesclose(dev_t dev, int flag, int fmt, struct thread *td) { struct cam_periph *periph; struct ses_softc *softc; @@ -539,7 +539,7 @@ seserror(union ccb *ccb, u_int32_t cflags, u_int32_t sflags) } static int -sesioctl(dev_t dev, u_long cmd, caddr_t arg_addr, int flag, struct proc *p) +sesioctl(dev_t dev, u_long cmd, caddr_t arg_addr, int flag, struct thread *td) { struct cam_periph *periph; ses_encstat tmp; diff --git a/sys/cam/scsi/scsi_target.c b/sys/cam/scsi/scsi_target.c index d7370ee..6945678 100644 --- a/sys/cam/scsi/scsi_target.c +++ b/sys/cam/scsi/scsi_target.c @@ -551,7 +551,7 @@ targdtor(struct cam_periph *periph) } static int -targopen(dev_t dev, int flags, int fmt, struct proc *p) +targopen(dev_t dev, int flags, int fmt, struct thread *td) { struct cam_periph *periph; struct targ_softc *softc; @@ -610,7 +610,7 @@ targopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -targclose(dev_t dev, int flag, int fmt, struct proc *p) +targclose(dev_t dev, int flag, int fmt, struct thread *td) { struct cam_periph *periph; struct targ_softc *softc; @@ -807,7 +807,7 @@ fail: } static int -targioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +targioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct cam_periph *periph; struct targ_softc *softc; @@ -1080,7 +1080,7 @@ targsendccb(struct cam_periph *periph, union ccb *ccb, union ccb *inccb) static int -targpoll(dev_t dev, int poll_events, struct proc *p) +targpoll(dev_t dev, int poll_events, struct thread *td) { struct cam_periph *periph; struct targ_softc *softc; @@ -1117,9 +1117,9 @@ targpoll(dev_t dev, int poll_events, struct proc *p) if (revents == 0) { if (poll_events & (POLLOUT | POLLWRNORM)) - selrecord(p, &softc->rcv_select); + selrecord(td, &softc->rcv_select); if (poll_events & (POLLIN | POLLRDNORM)) - selrecord(p, &softc->snd_select); + selrecord(td, &softc->snd_select); } splx(s); return (revents); diff --git a/sys/coda/coda_psdev.c b/sys/coda/coda_psdev.c index 0d8560f..2346c7c 100644 --- a/sys/coda/coda_psdev.c +++ b/sys/coda/coda_psdev.c @@ -117,11 +117,11 @@ vcodaattach(n) } int -vc_nb_open(dev, flag, mode, p) +vc_nb_open(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; /* NetBSD only */ + struct thread *td; /* NetBSD only */ { register struct vcomm *vcp; @@ -149,11 +149,11 @@ vc_nb_open(dev, flag, mode, p) } int -vc_nb_close (dev, flag, mode, p) +vc_nb_close (dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { register struct vcomm *vcp; register struct vmsg *vmp, *nvmp = NULL; @@ -225,7 +225,7 @@ vc_nb_close (dev, flag, mode, p) #endif } - err = dounmount(mi->mi_vfsp, flag, p); + err = dounmount(mi->mi_vfsp, flag, td); if (err) myprintf(("Error %d unmounting vfs in vcclose(%d)\n", err, minor(dev))); @@ -387,12 +387,12 @@ vc_nb_write(dev, uiop, flag) } int -vc_nb_ioctl(dev, cmd, addr, flag, p) +vc_nb_ioctl(dev, cmd, addr, flag, td) dev_t dev; u_long cmd; caddr_t addr; int flag; - struct proc *p; + struct thread *td; { ENTRY; @@ -441,10 +441,10 @@ vc_nb_ioctl(dev, cmd, addr, flag, p) } int -vc_nb_poll(dev, events, p) +vc_nb_poll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { register struct vcomm *vcp; int event_msk = 0; @@ -463,7 +463,7 @@ vc_nb_poll(dev, events, p) if (!EMPTY(vcp->vc_requests)) return(events & (POLLIN|POLLRDNORM)); - selrecord(p, &(vcp->vc_selproc)); + selrecord(curthread, &(vcp->vc_selproc)); return(0); } @@ -490,7 +490,8 @@ coda_call(mntinfo, inSize, outSize, buffer) struct vmsg *vmp; int error; #ifdef CTL_C - struct proc *p = curproc; + struct thread *td = curthread; + struct proc *p = td->td_proc; sigset_t psig_omask; sigset_t tempset; int i; diff --git a/sys/coda/coda_psdev.h b/sys/coda/coda_psdev.h index c6276f3..c6ecf7f 100644 --- a/sys/coda/coda_psdev.h +++ b/sys/coda/coda_psdev.h @@ -31,9 +31,9 @@ * */ -int vc_nb_open(dev_t dev, int flag, int mode, struct proc *p); -int vc_nb_close (dev_t dev, int flag, int mode, struct proc *p); +int vc_nb_open(dev_t dev, int flag, int mode, struct thread *p); +int vc_nb_close (dev_t dev, int flag, int mode, struct thread *p); int vc_nb_read(dev_t dev, struct uio *uiop, int flag); int vc_nb_write(dev_t dev, struct uio *uiop, int flag); -int vc_nb_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p); -int vc_nb_poll(dev_t dev, int events, struct proc *p); +int vc_nb_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *p); +int vc_nb_poll(dev_t dev, int events, struct thread *p); diff --git a/sys/coda/coda_vfsops.c b/sys/coda/coda_vfsops.c index 8bcd36f..d01d5a7 100644 --- a/sys/coda/coda_vfsops.c +++ b/sys/coda/coda_vfsops.c @@ -83,7 +83,7 @@ struct coda_op_stats coda_vfsopstats[CODA_VFSOPS_SIZE]; #define MRAK_INT_GEN(op) (coda_vfsopstats[op].gen_intrn++) extern int coda_nc_initialized; /* Set if cache has been initialized */ -extern int vc_nb_open __P((dev_t, int, int, struct proc *)); +extern int vc_nb_open __P((dev_t, int, int, struct thread *)); int coda_vfsopstats_init(void) @@ -107,12 +107,12 @@ coda_vfsopstats_init(void) */ /*ARGSUSED*/ int -coda_mount(vfsp, path, data, ndp, p) +coda_mount(vfsp, path, data, ndp, td) struct mount *vfsp; /* Allocated and initialized by mount(2) */ char *path; /* path covered: ignored by the fs-layer */ caddr_t data; /* Need to define a data type for this in netbsd? */ struct nameidata *ndp; /* Clobber this to lookup the device name */ - struct proc *p; /* The ever-famous proc pointer */ + struct thread *td; /* The ever-famous proc pointer */ { struct vnode *dvp; struct cnode *cp; @@ -135,7 +135,7 @@ coda_mount(vfsp, path, data, ndp, p) } /* Validate mount device. Similar to getmdev(). */ - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, data, p); + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, data, td); error = namei(ndp); dvp = ndp->ni_vp; @@ -233,10 +233,10 @@ coda_mount(vfsp, path, data, ndp, p) } int -coda_unmount(vfsp, mntflags, p) +coda_unmount(vfsp, mntflags, td) struct mount *vfsp; int mntflags; - struct proc *p; + struct thread *td; { struct coda_mntinfo *mi = vftomi(vfsp); int active, error = 0; @@ -292,8 +292,12 @@ coda_root(vfsp, vpp) struct coda_mntinfo *mi = vftomi(vfsp); struct vnode **result; int error; - struct proc *p = curproc; /* XXX - bnoble */ + struct thread *td = curthread; /* XXX - bnoble */ + struct proc *p = td->td_proc; ViceFid VFid; + + ENTRY; + ENTRY; MARK_ENTRY(CODA_ROOT_STATS); @@ -308,9 +312,9 @@ coda_root(vfsp, vpp) /* On Mach, this is vref. On NetBSD, VOP_LOCK */ #if 1 vref(*vpp); - vn_lock(*vpp, LK_EXCLUSIVE, p); + vn_lock(*vpp, LK_EXCLUSIVE, td); #else - vget(*vpp, LK_EXCLUSIVE, p); + vget(*vpp, LK_EXCLUSIVE, td); #endif MARK_INT_SAT(CODA_ROOT_STATS); return(0); @@ -331,9 +335,9 @@ coda_root(vfsp, vpp) *vpp = mi->mi_rootvp; #if 1 vref(*vpp); - vn_lock(*vpp, LK_EXCLUSIVE, p); + vn_lock(*vpp, LK_EXCLUSIVE, td); #else - vget(*vpp, LK_EXCLUSIVE, p); + vget(*vpp, LK_EXCLUSIVE, td); #endif MARK_INT_SAT(CODA_ROOT_STATS); @@ -351,9 +355,9 @@ coda_root(vfsp, vpp) *vpp = mi->mi_rootvp; #if 1 vref(*vpp); - vn_lock(*vpp, LK_EXCLUSIVE, p); + vn_lock(*vpp, LK_EXCLUSIVE, td); #else - vget(*vpp, LK_EXCLUSIVE, p); + vget(*vpp, LK_EXCLUSIVE, td); #endif MARK_INT_FAIL(CODA_ROOT_STATS); @@ -374,10 +378,10 @@ coda_root(vfsp, vpp) * Get file system statistics. */ int -coda_nb_statfs(vfsp, sbp, p) +coda_nb_statfs(vfsp, sbp, td) register struct mount *vfsp; struct statfs *sbp; - struct proc *p; + struct thread *td; { ENTRY; /* MARK_ENTRY(CODA_STATFS_STATS); */ @@ -412,11 +416,11 @@ coda_nb_statfs(vfsp, sbp, p) * Flush any pending I/O. */ int -coda_sync(vfsp, waitfor, cred, p) +coda_sync(vfsp, waitfor, cred, td) struct mount *vfsp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { ENTRY; MARK_ENTRY(CODA_SYNC_STATS); @@ -441,7 +445,8 @@ coda_fhtovp(vfsp, fhp, nam, vpp, exflagsp, creadanonp) struct cfid *cfid = (struct cfid *)fhp; struct cnode *cp = 0; int error; - struct proc *p = curproc; /* XXX -mach */ + struct thread *td = curthread; /* XXX -mach */ + struct proc *p = td->td_proc; ViceFid VFid; int vtype; diff --git a/sys/coda/coda_vfsops.h b/sys/coda/coda_vfsops.h index 7fc9adf..57b9a5a 100644 --- a/sys/coda/coda_vfsops.h +++ b/sys/coda/coda_vfsops.h @@ -48,13 +48,13 @@ struct mount; int coda_vfsopstats_init(void); int coda_mount(struct mount *, char *, caddr_t, struct nameidata *, - struct proc *); -int coda_start(struct mount *, int, struct proc *); -int coda_unmount(struct mount *, int, struct proc *); + struct thread *); +int coda_start(struct mount *, int, struct thread *); +int coda_unmount(struct mount *, int, struct thread *); int coda_root(struct mount *, struct vnode **); -int coda_quotactl(struct mount *, int, uid_t, caddr_t, struct proc *); -int coda_nb_statfs(struct mount *, struct statfs *, struct proc *); -int coda_sync(struct mount *, int, struct ucred *, struct proc *); +int coda_quotactl(struct mount *, int, uid_t, caddr_t, struct thread *); +int coda_nb_statfs(struct mount *, struct statfs *, struct thread *); +int coda_sync(struct mount *, int, struct ucred *, struct thread *); int coda_vget(struct mount *, ino_t, struct vnode **); int coda_fhtovp(struct mount *, struct fid *, struct mbuf *, struct vnode **, int *, struct ucred **); diff --git a/sys/coda/coda_vnops.c b/sys/coda/coda_vnops.c index dd0a96e..8fd7170d 100644 --- a/sys/coda/coda_vnops.c +++ b/sys/coda/coda_vnops.c @@ -235,7 +235,7 @@ coda_open(v) struct cnode *cp = VTOC(*vpp); int flag = ap->a_mode & (~O_EXCL); struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; struct vnode *vp; @@ -256,7 +256,7 @@ coda_open(v) return(0); } - error = venus_open(vtomi((*vpp)), &cp->c_fid, flag, cred, p, &dev, &inode); + error = venus_open(vtomi((*vpp)), &cp->c_fid, flag, cred, td->td_proc, &dev, &inode); if (error) return (error); if (!error) { @@ -272,7 +272,7 @@ coda_open(v) return (error); /* We get the vnode back locked. Needs unlocked */ - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); /* Keep a reference until the close comes in. */ vref(*vpp); @@ -297,14 +297,14 @@ coda_open(v) cp->c_inode = inode; /* Open the cache file. */ - error = VOP_OPEN(vp, flag, cred, p); + error = VOP_OPEN(vp, flag, cred, td); if (error) { printf("coda_open: VOP_OPEN on container failed %d\n", error); return (error); } /* grab (above) does this when it calls newvnode unless it's in the cache*/ if (vp->v_type == VREG) { - error = vfs_object_create(vp, p, cred); + error = vfs_object_create(vp, td, cred); if (error != 0) { printf("coda_open: vfs_object_create() returns %d\n", error); vput(vp); @@ -327,7 +327,7 @@ coda_close(v) struct cnode *cp = VTOC(vp); int flag = ap->a_fflag; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; @@ -348,7 +348,7 @@ coda_close(v) #ifdef hmm vgone(cp->c_ovp); #else - VOP_CLOSE(cp->c_ovp, flag, cred, p); /* Do errors matter here? */ + VOP_CLOSE(cp->c_ovp, flag, cred, td); /* Do errors matter here? */ vrele(cp->c_ovp); #endif } else { @@ -358,7 +358,7 @@ coda_close(v) } return ENODEV; } else { - VOP_CLOSE(cp->c_ovp, flag, cred, p); /* Do errors matter here? */ + VOP_CLOSE(cp->c_ovp, flag, cred, td); /* Do errors matter here? */ vrele(cp->c_ovp); } @@ -368,7 +368,7 @@ coda_close(v) if (flag & FWRITE) /* file was opened for write */ --cp->c_owrite; - error = venus_close(vtomi(vp), &cp->c_fid, flag, cred, p); + error = venus_close(vtomi(vp), &cp->c_fid, flag, cred, td->td_proc); vrele(CTOV(cp)); CODADEBUG(CODA_CLOSE, myprintf(("close: result %d\n",error)); ) @@ -383,7 +383,7 @@ coda_read(v) ENTRY; return(coda_rdwr(ap->a_vp, ap->a_uio, UIO_READ, - ap->a_ioflag, ap->a_cred, ap->a_uio->uio_procp)); + ap->a_ioflag, ap->a_cred, ap->a_uio->uio_td)); } int @@ -394,24 +394,25 @@ coda_write(v) ENTRY; return(coda_rdwr(ap->a_vp, ap->a_uio, UIO_WRITE, - ap->a_ioflag, ap->a_cred, ap->a_uio->uio_procp)); + ap->a_ioflag, ap->a_cred, ap->a_uio->uio_td)); } int -coda_rdwr(vp, uiop, rw, ioflag, cred, p) +coda_rdwr(vp, uiop, rw, ioflag, cred, td) struct vnode *vp; struct uio *uiop; enum uio_rw rw; int ioflag; struct ucred *cred; - struct proc *p; + struct thread *td; { /* upcall decl */ /* NOTE: container file operation!!! */ /* locals */ struct cnode *cp = VTOC(vp); struct vnode *cfvp = cp->c_ovp; - struct proc *lp = p; + struct proc *p = td->td_proc; + struct thread *ltd = td; int igot_internally = 0; int opened_internally = 0; int error = 0; @@ -448,7 +449,7 @@ coda_rdwr(vp, uiop, rw, ioflag, cred, p) PROC_UNLOCK(p); } else - lp = curproc; + ltd = curthread; if (cp->c_inode != 0 && !iscore) { igot_internally = 1; @@ -458,23 +459,23 @@ coda_rdwr(vp, uiop, rw, ioflag, cred, p) return(error); } /* - * We get the vnode back locked by curproc in both Mach and + * We get the vnode back locked by curthread in both Mach and * NetBSD. Needs unlocked */ - VOP_UNLOCK(cfvp, 0, lp); + VOP_UNLOCK(cfvp, 0, ltd); } else { opened_internally = 1; MARK_INT_GEN(CODA_OPEN_STATS); error = VOP_OPEN(vp, (rw == UIO_READ ? FREAD : FWRITE), - cred, p); + cred, td); printf("coda_rdwr: Internally Opening %p\n", vp); if (error) { printf("coda_rdwr: VOP_OPEN on container failed %d\n", error); return (error); } if (vp->v_type == VREG) { - error = vfs_object_create(vp, p, cred); + error = vfs_object_create(vp, td, cred); if (error != 0) { printf("coda_rdwr: vfs_object_create() returns %d\n", error); vput(vp); @@ -501,7 +502,7 @@ printf("coda_rdwr: Internally Opening %p\n", vp); { struct vattr attr; - if (VOP_GETATTR(cfvp, &attr, cred, p) == 0) { + if (VOP_GETATTR(cfvp, &attr, cred, td) == 0) { vnode_pager_setsize(vp, attr.va_size); } } @@ -515,7 +516,7 @@ printf("coda_rdwr: Internally Opening %p\n", vp); /* Do an internal close if necessary. */ if (opened_internally) { MARK_INT_GEN(CODA_CLOSE_STATS); - (void)VOP_CLOSE(vp, (rw == UIO_READ ? FREAD : FWRITE), cred, p); + (void)VOP_CLOSE(vp, (rw == UIO_READ ? FREAD : FWRITE), cred, td); } /* Invalidate cached attributes if writing. */ @@ -537,7 +538,7 @@ coda_ioctl(v) caddr_t data = ap->a_data; int flag = ap->a_fflag; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; struct vnode *tvp; @@ -562,7 +563,7 @@ coda_ioctl(v) /* Should we use the name cache here? It would get it from lookupname sooner or later anyway, right? */ - NDINIT(&ndp, LOOKUP, (iap->follow ? FOLLOW : NOFOLLOW), UIO_USERSPACE, iap->path, p); + NDINIT(&ndp, LOOKUP, (iap->follow ? FOLLOW : NOFOLLOW), UIO_USERSPACE, iap->path, td); error = namei(&ndp); tvp = ndp.ni_vp; @@ -591,7 +592,7 @@ coda_ioctl(v) NDFREE(&ndp, 0); return(EINVAL); } - error = venus_ioctl(vtomi(tvp), &((VTOC(tvp))->c_fid), com, flag, data, cred, p); + error = venus_ioctl(vtomi(tvp), &((VTOC(tvp))->c_fid), com, flag, data, cred, td->td_proc); if (error) MARK_INT_FAIL(CODA_IOCTL_STATS); @@ -622,7 +623,7 @@ coda_getattr(v) struct cnode *cp = VTOC(vp); struct vattr *vap = ap->a_vap; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; @@ -651,7 +652,7 @@ coda_getattr(v) return(0); } - error = venus_getattr(vtomi(vp), &cp->c_fid, cred, p, vap); + error = venus_getattr(vtomi(vp), &cp->c_fid, cred, td->td_proc, vap); if (!error) { CODADEBUG(CODA_GETATTR, myprintf(("getattr miss (%lx.%lx.%lx): result %d\n", @@ -689,7 +690,7 @@ coda_setattr(v) struct cnode *cp = VTOC(vp); register struct vattr *vap = ap->a_vap; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; @@ -704,7 +705,7 @@ coda_setattr(v) if (codadebug & CODADBGMSK(CODA_SETATTR)) { print_vattr(vap); } - error = venus_setattr(vtomi(vp), &cp->c_fid, vap, cred, p); + error = venus_setattr(vtomi(vp), &cp->c_fid, vap, cred, td->td_proc); if (!error) cp->c_flags &= ~C_VATTR; @@ -729,7 +730,7 @@ coda_access(v) struct cnode *cp = VTOC(vp); int mode = ap->a_mode; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; @@ -758,7 +759,7 @@ coda_access(v) } } - error = venus_access(vtomi(vp), &cp->c_fid, mode, cred, p); + error = venus_access(vtomi(vp), &cp->c_fid, mode, cred, td->td_proc); return(error); } @@ -773,7 +774,7 @@ coda_readlink(v) struct cnode *cp = VTOC(vp); struct uio *uiop = ap->a_uio; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_uio->uio_procp; + struct thread *td = ap->a_uio->uio_td; /* locals */ int error; char *str; @@ -797,7 +798,7 @@ coda_readlink(v) return(error); } - error = venus_readlink(vtomi(vp), &cp->c_fid, cred, p, &str, &len); + error = venus_readlink(vtomi(vp), &cp->c_fid, cred, td->td_proc, &str, &len); if (!error) { uiop->uio_rw = UIO_READ; @@ -824,7 +825,7 @@ coda_fsync(v) struct vnode *vp = ap->a_vp; struct cnode *cp = VTOC(vp); struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ struct vnode *convp = cp->c_ovp; int error; @@ -847,7 +848,7 @@ coda_fsync(v) } if (convp) - VOP_FSYNC(convp, cred, MNT_WAIT, p); + VOP_FSYNC(convp, cred, MNT_WAIT, td); /* * We see fsyncs with usecount == 1 then usecount == 0. @@ -873,7 +874,7 @@ coda_fsync(v) /* needs research */ return 0; - error = venus_fsync(vtomi(vp), &cp->c_fid, cred, p); + error = venus_fsync(vtomi(vp), &cp->c_fid, cred, td->td_proc); CODADEBUG(CODA_FSYNC, myprintf(("in fsync result %d\n",error)); ); return(error); @@ -890,7 +891,7 @@ coda_inactive(v) struct vnode *vp = ap->a_vp; struct cnode *cp = VTOC(vp); struct ucred *cred __attribute__((unused)) = NULL; - struct proc *p __attribute__((unused)) = curproc; + struct thread *td __attribute__((unused)) = curthread; /* upcall decl */ /* locals */ @@ -930,7 +931,7 @@ coda_inactive(v) printf("coda_inactive: cp->ovp != NULL use %d: vp %p, cp %p\n", vp->v_usecount, vp, cp); #endif - lockmgr(&cp->c_lock, LK_RELEASE, &vp->v_interlock, p); + lockmgr(&cp->c_lock, LK_RELEASE, &vp->v_interlock, td); } else { #ifdef OLD_DIAGNOSTIC if (CTOV(cp)->v_usecount) { @@ -940,7 +941,7 @@ coda_inactive(v) panic("coda_inactive: cp->ovp != NULL"); } #endif - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vgone(vp); } @@ -972,7 +973,7 @@ coda_lookup(v) */ struct componentname *cnp = ap->a_cnp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* locals */ struct cnode *cp; const char *nm = cnp->cn_nameptr; @@ -1015,7 +1016,7 @@ coda_lookup(v) } else { /* The name wasn't cached, so we need to contact Venus */ - error = venus_lookup(vtomi(dvp), &dcp->c_fid, nm, len, cred, p, &VFid, &vtype); + error = venus_lookup(vtomi(dvp), &dcp->c_fid, nm, len, cred, td->td_proc, &VFid, &vtype); if (error) { MARK_INT_FAIL(CODA_LOOKUP_STATS); @@ -1086,7 +1087,7 @@ coda_lookup(v) */ if (!error || (error == EJUSTRETURN)) { if (!(cnp->cn_flags & LOCKPARENT) || !(cnp->cn_flags & ISLASTCN)) { - if ((error = VOP_UNLOCK(dvp, 0, p))) { + if ((error = VOP_UNLOCK(dvp, 0, td))) { return error; } /* @@ -1094,7 +1095,7 @@ coda_lookup(v) * lock it without bothering to check anything else. */ if (*ap->a_vpp) { - if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, p))) { + if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, td))) { printf("coda_lookup: "); panic("unlocked parent but couldn't lock child"); } @@ -1103,7 +1104,7 @@ coda_lookup(v) /* The parent is locked, and may be the same as the child */ if (*ap->a_vpp && (*ap->a_vpp != dvp)) { /* Different, go ahead and lock it. */ - if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, p))) { + if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, td))) { printf("coda_lookup: "); panic("unlocked parent but couldn't lock child"); } @@ -1132,7 +1133,7 @@ coda_create(v) struct vnode **vpp = ap->a_vpp; struct componentname *cnp = ap->a_cnp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* locals */ int error; struct cnode *cp; @@ -1153,7 +1154,7 @@ coda_create(v) return(EACCES); } - error = venus_create(vtomi(dvp), &dcp->c_fid, nm, len, exclusive, mode, va, cred, p, &VFid, &attr); + error = venus_create(vtomi(dvp), &dcp->c_fid, nm, len, exclusive, mode, va, cred, td->td_proc, &VFid, &attr); if (!error) { @@ -1192,7 +1193,7 @@ coda_create(v) if (!error) { if (cnp->cn_flags & LOCKLEAF) { - if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, p))) { + if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, td))) { printf("coda_create: "); panic("unlocked parent but couldn't lock child"); } @@ -1216,7 +1217,7 @@ coda_remove(v) struct cnode *cp = VTOC(dvp); struct componentname *cnp = ap->a_cnp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* locals */ int error; const char *nm = cnp->cn_nameptr; @@ -1259,7 +1260,7 @@ coda_remove(v) return(ENOENT); } - error = venus_remove(vtomi(dvp), &cp->c_fid, nm, len, cred, p); + error = venus_remove(vtomi(dvp), &cp->c_fid, nm, len, cred, td->td_proc); CODADEBUG(CODA_REMOVE, myprintf(("in remove result %d\n",error)); ) @@ -1278,7 +1279,7 @@ coda_link(v) struct cnode *tdcp = VTOC(tdvp); struct componentname *cnp = ap->a_cnp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* locals */ int error; const char *nm = cnp->cn_nameptr; @@ -1308,7 +1309,7 @@ coda_link(v) return(EACCES); } - error = venus_link(vtomi(vp), &cp->c_fid, &tdcp->c_fid, nm, len, cred, p); + error = venus_link(vtomi(vp), &cp->c_fid, &tdcp->c_fid, nm, len, cred, td->td_proc); /* Invalidate the parent's attr cache, the modification time has changed */ VTOC(tdvp)->c_flags &= ~C_VATTR; @@ -1332,7 +1333,7 @@ coda_rename(v) struct cnode *ndcp = VTOC(ndvp); struct componentname *tcnp = ap->a_tcnp; struct ucred *cred = fcnp->cn_cred; - struct proc *p = fcnp->cn_proc; + struct thread *td = fcnp->cn_thread; /* true args */ int error; const char *fnm = fcnp->cn_nameptr; @@ -1346,7 +1347,7 @@ coda_rename(v) This could be Bad. XXX */ #ifdef OLD_DIAGNOSTIC if ((fcnp->cn_cred != tcnp->cn_cred) - || (fcnp->cn_proc != tcnp->cn_proc)) + || (fcnp->cn_thread != tcnp->cn_thread)) { panic("coda_rename: component names don't agree"); } @@ -1389,7 +1390,7 @@ coda_rename(v) goto exit; } - error = venus_rename(vtomi(odvp), &odcp->c_fid, &ndcp->c_fid, fnm, flen, tnm, tlen, cred, p); + error = venus_rename(vtomi(odvp), &odcp->c_fid, &ndcp->c_fid, fnm, flen, tnm, tlen, cred, td->td_proc); exit: CODADEBUG(CODA_RENAME, myprintf(("in rename result %d\n",error));) @@ -1426,7 +1427,7 @@ coda_mkdir(v) register struct vattr *va = ap->a_vap; struct vnode **vpp = ap->a_vpp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* locals */ int error; const char *nm = cnp->cn_nameptr; @@ -1450,7 +1451,7 @@ coda_mkdir(v) return(EACCES); } - error = venus_mkdir(vtomi(dvp), &dcp->c_fid, nm, len, va, cred, p, &VFid, &ova); + error = venus_mkdir(vtomi(dvp), &dcp->c_fid, nm, len, va, cred, td->td_proc, &VFid, &ova); if (!error) { if (coda_find(&VFid) != NULL) @@ -1495,7 +1496,7 @@ coda_rmdir(v) struct cnode *dcp = VTOC(dvp); struct componentname *cnp = ap->a_cnp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* true args */ int error; const char *nm = cnp->cn_nameptr; @@ -1527,7 +1528,7 @@ coda_rmdir(v) /* Invalidate the parent's attr cache, the modification time has changed */ dcp->c_flags &= ~C_VATTR; - error = venus_rmdir(vtomi(dvp), &dcp->c_fid, nm, len, cred, p); + error = venus_rmdir(vtomi(dvp), &dcp->c_fid, nm, len, cred, td->td_proc); CODADEBUG(CODA_RMDIR, myprintf(("in rmdir result %d\n", error)); ) @@ -1546,7 +1547,7 @@ coda_symlink(v) struct vattr *tva = ap->a_vap; char *path = ap->a_target; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct vnode **vpp = ap->a_vpp; /* locals */ int error; @@ -1589,7 +1590,7 @@ coda_symlink(v) goto exit; } - error = venus_symlink(vtomi(tdvp), &tdcp->c_fid, path, plen, nm, len, tva, cred, p); + error = venus_symlink(vtomi(tdvp), &tdcp->c_fid, path, plen, nm, len, tva, cred, td->td_proc); /* Invalidate the parent's attr cache, the modification time has changed */ tdcp->c_flags &= ~C_VATTR; @@ -1618,7 +1619,7 @@ coda_readdir(v) int *eofflag = ap->a_eofflag; u_long **cookies = ap->a_cookies; int *ncookies = ap->a_ncookies; - struct proc *p = ap->a_uio->uio_procp; + struct thread *td = ap->a_uio->uio_td; /* upcall decl */ /* locals */ int error = 0; @@ -1643,14 +1644,14 @@ coda_readdir(v) if (cp->c_ovp == NULL) { opened_internally = 1; MARK_INT_GEN(CODA_OPEN_STATS); - error = VOP_OPEN(vp, FREAD, cred, p); + error = VOP_OPEN(vp, FREAD, cred, td); printf("coda_readdir: Internally Opening %p\n", vp); if (error) { printf("coda_readdir: VOP_OPEN on container failed %d\n", error); return (error); } if (vp->v_type == VREG) { - error = vfs_object_create(vp, p, cred); + error = vfs_object_create(vp, td, cred); if (error != 0) { printf("coda_readdir: vfs_object_create() returns %d\n", error); vput(vp); @@ -1672,7 +1673,7 @@ printf("coda_readdir: Internally Opening %p\n", vp); /* Do an "internal close" if necessary. */ if (opened_internally) { MARK_INT_GEN(CODA_CLOSE_STATS); - (void)VOP_CLOSE(vp, FREAD, cred, p); + (void)VOP_CLOSE(vp, FREAD, cred, td); } } @@ -1693,7 +1694,7 @@ coda_bmap(v) daddr_t bn __attribute__((unused)) = ap->a_bn; /* fs block number */ struct vnode **vpp = ap->a_vpp; /* RETURN vp of device */ daddr_t *bnp __attribute__((unused)) = ap->a_bnp; /* RETURN device block number */ - struct proc *p __attribute__((unused)) = curproc; + struct thread *td __attribute__((unused)) = curthread; /* upcall decl */ /* locals */ @@ -1731,7 +1732,7 @@ coda_strategy(v) /* true args */ struct vop_strategy_args *ap = v; register struct buf *bp __attribute__((unused)) = ap->a_bp; - struct proc *p __attribute__((unused)) = curproc; + struct thread *td __attribute__((unused)) = curthread; /* upcall decl */ /* locals */ @@ -1786,7 +1787,7 @@ coda_lock(v) struct vop_lock_args *ap = v; struct vnode *vp = ap->a_vp; struct cnode *cp = VTOC(vp); - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* upcall decl */ /* locals */ @@ -1798,9 +1799,9 @@ coda_lock(v) } #ifndef DEBUG_LOCKS - return (lockmgr(&cp->c_lock, ap->a_flags, &vp->v_interlock, p)); + return (lockmgr(&cp->c_lock, ap->a_flags, &vp->v_interlock, td)); #else - return (debuglockmgr(&cp->c_lock, ap->a_flags, &vp->v_interlock, p, + return (debuglockmgr(&cp->c_lock, ap->a_flags, &vp->v_interlock, td, "coda_lock", vp->filename, vp->line)); #endif } @@ -1813,7 +1814,7 @@ coda_unlock(v) struct vop_unlock_args *ap = v; struct vnode *vp = ap->a_vp; struct cnode *cp = VTOC(vp); - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* upcall decl */ /* locals */ @@ -1823,7 +1824,7 @@ coda_unlock(v) cp->c_fid.Volume, cp->c_fid.Vnode, cp->c_fid.Unique)); } - return (lockmgr(&cp->c_lock, ap->a_flags | LK_RELEASE, &vp->v_interlock, p)); + return (lockmgr(&cp->c_lock, ap->a_flags | LK_RELEASE, &vp->v_interlock, td)); } int @@ -1835,7 +1836,7 @@ coda_islocked(v) struct cnode *cp = VTOC(ap->a_vp); ENTRY; - return (lockstatus(&cp->c_lock, ap->a_p)); + return (lockstatus(&cp->c_lock, ap->a_td)); } /* How one looks up a vnode given a device/inode pair: */ diff --git a/sys/coda/coda_vnops.h b/sys/coda/coda_vnops.h index 9fcd978..663d357 100644 --- a/sys/coda/coda_vnops.h +++ b/sys/coda/coda_vnops.h @@ -82,7 +82,7 @@ int coda_fbsd_getpages __P((void *)); int (**coda_vnodeop_p)(void *); int coda_rdwr(struct vnode *vp, struct uio *uiop, enum uio_rw rw, - int ioflag, struct ucred *cred, struct proc *p); + int ioflag, struct ucred *cred, struct thread *td); int coda_grab_vnode(dev_t dev, ino_t ino, struct vnode **vpp); void print_vattr(struct vattr *attr); void print_cred(struct ucred *cred); diff --git a/sys/compat/linprocfs/linprocfs.c b/sys/compat/linprocfs/linprocfs.c index f41d536..987588a 100644 --- a/sys/compat/linprocfs/linprocfs.c +++ b/sys/compat/linprocfs/linprocfs.c @@ -376,8 +376,8 @@ linprocfs_doversion(PFS_FILL_ARGS) sbuf_printf(sb, "%s version %s (des@freebsd.org) (gcc version " __VERSION__ ")" " #4 Sun Dec 18 04:30:00 CET 1977\n", - linux_get_osname(curp), - linux_get_osrelease(curp)); + linux_get_osname(td->td_proc), + linux_get_osrelease(td->td_proc)); return (0); } @@ -581,7 +581,7 @@ linprocfs_doprocstatus(PFS_FILL_ARGS) static int linprocfs_doselflink(PFS_FILL_ARGS) { - sbuf_printf(sb, "%ld", (long)curp->p_pid); + sbuf_printf(sb, "%ld", (long)td->td_proc->p_pid); return (0); } @@ -604,9 +604,9 @@ linprocfs_doproccmdline(PFS_FILL_ARGS) * Linux behaviour is to return zero-length in this case. */ - if (p->p_args && (ps_argsopen || !p_cansee(curp, p))) { + if (p->p_args && (ps_argsopen || !p_cansee(td->td_proc, p))) { sbuf_bcpy(sb, p->p_args->ar_args, p->p_args->ar_length); - } else if (p != curp) { + } else if (p != td->td_proc) { sbuf_printf(sb, "%.*s", MAXCOMLEN, p->p_comm); } else { error = copyin((void*)PS_STRINGS, &pstr, sizeof(pstr)); @@ -663,8 +663,8 @@ linprocfs_donetdev(PFS_FILL_ARGS) sbuf_printf(sb, "%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu " "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n", - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0); + 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, + 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L); } return (0); diff --git a/sys/compat/linux/linux_file.c b/sys/compat/linux/linux_file.c index 3d16a94..f1cba52 100644 --- a/sys/compat/linux/linux_file.c +++ b/sys/compat/linux/linux_file.c @@ -56,7 +56,7 @@ #ifndef __alpha__ int -linux_creat(struct proc *p, struct linux_creat_args *args) +linux_creat(struct thread *td, struct linux_creat_args *args) { struct open_args /* { char *path; @@ -66,7 +66,7 @@ linux_creat(struct proc *p, struct linux_creat_args *args) caddr_t sg; sg = stackgap_init(); - CHECKALTCREAT(p, &sg, args->path); + CHECKALTCREAT(td, &sg, args->path); #ifdef DEBUG if (ldebug(creat)) @@ -75,27 +75,28 @@ linux_creat(struct proc *p, struct linux_creat_args *args) bsd_open_args.path = args->path; bsd_open_args.mode = args->mode; bsd_open_args.flags = O_WRONLY | O_CREAT | O_TRUNC; - return open(p, &bsd_open_args); + return open(td, &bsd_open_args); } #endif /*!__alpha__*/ int -linux_open(struct proc *p, struct linux_open_args *args) +linux_open(struct thread *td, struct linux_open_args *args) { struct open_args /* { char *path; int flags; int mode; } */ bsd_open_args; + struct proc *p = td->td_proc; int error; caddr_t sg; sg = stackgap_init(); if (args->flags & LINUX_O_CREAT) - CHECKALTCREAT(p, &sg, args->path); + CHECKALTCREAT(td, &sg, args->path); else - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(open)) @@ -130,16 +131,16 @@ linux_open(struct proc *p, struct linux_open_args *args) bsd_open_args.path = args->path; bsd_open_args.mode = args->mode; - error = open(p, &bsd_open_args); + error = open(td, &bsd_open_args); PROC_LOCK(p); if (!error && !(bsd_open_args.flags & O_NOCTTY) && SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) { struct filedesc *fdp = p->p_fd; - struct file *fp = fdp->fd_ofiles[p->p_retval[0]]; + struct file *fp = fdp->fd_ofiles[td->td_retval[0]]; PROC_UNLOCK(p); if (fp->f_type == DTYPE_VNODE) - fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, p); + fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, td); } else PROC_UNLOCK(p); #ifdef DEBUG @@ -150,7 +151,7 @@ linux_open(struct proc *p, struct linux_open_args *args) } int -linux_lseek(struct proc *p, struct linux_lseek_args *args) +linux_lseek(struct thread *td, struct linux_lseek_args *args) { struct lseek_args /* { @@ -169,13 +170,13 @@ linux_lseek(struct proc *p, struct linux_lseek_args *args) tmp_args.fd = args->fdes; tmp_args.offset = (off_t)args->off; tmp_args.whence = args->whence; - error = lseek(p, &tmp_args); + error = lseek(td, &tmp_args); return error; } #ifndef __alpha__ int -linux_llseek(struct proc *p, struct linux_llseek_args *args) +linux_llseek(struct thread *td, struct linux_llseek_args *args) { struct lseek_args bsd_args; int error; @@ -192,27 +193,27 @@ linux_llseek(struct proc *p, struct linux_llseek_args *args) bsd_args.offset = off; bsd_args.whence = args->whence; - if ((error = lseek(p, &bsd_args))) + if ((error = lseek(td, &bsd_args))) return error; - if ((error = copyout(p->p_retval, (caddr_t)args->res, sizeof (off_t)))) + if ((error = copyout(td->td_retval, (caddr_t)args->res, sizeof (off_t)))) return error; - p->p_retval[0] = 0; + td->td_retval[0] = 0; return 0; } #endif /*!__alpha__*/ #ifndef __alpha__ int -linux_readdir(struct proc *p, struct linux_readdir_args *args) +linux_readdir(struct thread *td, struct linux_readdir_args *args) { struct linux_getdents_args lda; lda.fd = args->fd; lda.dent = args->dent; lda.count = 1; - return linux_getdents(p, &lda); + return linux_getdents(td, &lda); } #endif /*!__alpha__*/ @@ -246,7 +247,7 @@ struct l_dirent64 { #define LINUX_DIRBLKSIZ 512 static int -getdents_common(struct proc *p, struct linux_getdents64_args *args, +getdents_common(struct thread *td, struct linux_getdents64_args *args, int is64bit) { register struct dirent *bdp; @@ -266,7 +267,7 @@ getdents_common(struct proc *p, struct linux_getdents64_args *args, u_long *cookies = NULL, *cookiep; int ncookies; - if ((error = getvnode(p->p_fd, args->fd, &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, args->fd, &fp)) != 0) return (error); if ((fp->f_flag & FREAD) == 0) @@ -276,7 +277,7 @@ getdents_common(struct proc *p, struct linux_getdents64_args *args, if (vp->v_type != VDIR) return (EINVAL); - if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p))) + if ((error = VOP_GETATTR(vp, &va, td->td_proc->p_ucred, td))) return (error); nbytes = args->count; @@ -294,7 +295,7 @@ getdents_common(struct proc *p, struct linux_getdents64_args *args, buflen = max(LINUX_DIRBLKSIZ, nbytes); buflen = min(buflen, MAXBSIZE); buf = malloc(buflen, M_TEMP, M_WAITOK); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); again: aiov.iov_base = buf; @@ -303,7 +304,7 @@ again: auio.uio_iovcnt = 1; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_resid = buflen; auio.uio_offset = off; @@ -427,19 +428,19 @@ again: nbytes = resid + linuxreclen; eof: - p->p_retval[0] = nbytes - resid; + td->td_retval[0] = nbytes - resid; out: if (cookies) free(cookies, M_TEMP); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); free(buf, M_TEMP); return (error); } int -linux_getdents(struct proc *p, struct linux_getdents_args *args) +linux_getdents(struct thread *td, struct linux_getdents_args *args) { #ifdef DEBUG @@ -447,11 +448,11 @@ linux_getdents(struct proc *p, struct linux_getdents_args *args) printf(ARGS(getdents, "%d, *, %d"), args->fd, args->count); #endif - return (getdents_common(p, (struct linux_getdents64_args*)args, 0)); + return (getdents_common(td, (struct linux_getdents64_args*)args, 0)); } int -linux_getdents64(struct proc *p, struct linux_getdents64_args *args) +linux_getdents64(struct thread *td, struct linux_getdents64_args *args) { #ifdef DEBUG @@ -459,7 +460,7 @@ linux_getdents64(struct proc *p, struct linux_getdents64_args *args) printf(ARGS(getdents64, "%d, *, %d"), args->fd, args->count); #endif - return (getdents_common(p, args, 1)); + return (getdents_common(td, args, 1)); } /* @@ -467,13 +468,13 @@ linux_getdents64(struct proc *p, struct linux_getdents64_args *args) */ int -linux_access(struct proc *p, struct linux_access_args *args) +linux_access(struct thread *td, struct linux_access_args *args) { struct access_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(access)) @@ -482,17 +483,17 @@ linux_access(struct proc *p, struct linux_access_args *args) bsd.path = args->path; bsd.flags = args->flags; - return access(p, &bsd); + return access(td, &bsd); } int -linux_unlink(struct proc *p, struct linux_unlink_args *args) +linux_unlink(struct thread *td, struct linux_unlink_args *args) { struct unlink_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(unlink)) @@ -500,17 +501,17 @@ linux_unlink(struct proc *p, struct linux_unlink_args *args) #endif bsd.path = args->path; - return unlink(p, &bsd); + return unlink(td, &bsd); } int -linux_chdir(struct proc *p, struct linux_chdir_args *args) +linux_chdir(struct thread *td, struct linux_chdir_args *args) { struct chdir_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(chdir)) @@ -518,17 +519,17 @@ linux_chdir(struct proc *p, struct linux_chdir_args *args) #endif bsd.path = args->path; - return chdir(p, &bsd); + return chdir(td, &bsd); } int -linux_chmod(struct proc *p, struct linux_chmod_args *args) +linux_chmod(struct thread *td, struct linux_chmod_args *args) { struct chmod_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(chmod)) @@ -537,17 +538,17 @@ linux_chmod(struct proc *p, struct linux_chmod_args *args) bsd.path = args->path; bsd.mode = args->mode; - return chmod(p, &bsd); + return chmod(td, &bsd); } int -linux_mkdir(struct proc *p, struct linux_mkdir_args *args) +linux_mkdir(struct thread *td, struct linux_mkdir_args *args) { struct mkdir_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTCREAT(p, &sg, args->path); + CHECKALTCREAT(td, &sg, args->path); #ifdef DEBUG if (ldebug(mkdir)) @@ -556,17 +557,17 @@ linux_mkdir(struct proc *p, struct linux_mkdir_args *args) bsd.path = args->path; bsd.mode = args->mode; - return mkdir(p, &bsd); + return mkdir(td, &bsd); } int -linux_rmdir(struct proc *p, struct linux_rmdir_args *args) +linux_rmdir(struct thread *td, struct linux_rmdir_args *args) { struct rmdir_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(rmdir)) @@ -574,18 +575,18 @@ linux_rmdir(struct proc *p, struct linux_rmdir_args *args) #endif bsd.path = args->path; - return rmdir(p, &bsd); + return rmdir(td, &bsd); } int -linux_rename(struct proc *p, struct linux_rename_args *args) +linux_rename(struct thread *td, struct linux_rename_args *args) { struct rename_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->from); - CHECKALTCREAT(p, &sg, args->to); + CHECKALTEXIST(td, &sg, args->from); + CHECKALTCREAT(td, &sg, args->to); #ifdef DEBUG if (ldebug(rename)) @@ -594,18 +595,18 @@ linux_rename(struct proc *p, struct linux_rename_args *args) bsd.from = args->from; bsd.to = args->to; - return rename(p, &bsd); + return rename(td, &bsd); } int -linux_symlink(struct proc *p, struct linux_symlink_args *args) +linux_symlink(struct thread *td, struct linux_symlink_args *args) { struct symlink_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); - CHECKALTCREAT(p, &sg, args->to); + CHECKALTEXIST(td, &sg, args->path); + CHECKALTCREAT(td, &sg, args->to); #ifdef DEBUG if (ldebug(symlink)) @@ -614,17 +615,17 @@ linux_symlink(struct proc *p, struct linux_symlink_args *args) bsd.path = args->path; bsd.link = args->to; - return symlink(p, &bsd); + return symlink(td, &bsd); } int -linux_readlink(struct proc *p, struct linux_readlink_args *args) +linux_readlink(struct thread *td, struct linux_readlink_args *args) { struct readlink_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->name); + CHECKALTEXIST(td, &sg, args->name); #ifdef DEBUG if (ldebug(readlink)) @@ -635,17 +636,17 @@ linux_readlink(struct proc *p, struct linux_readlink_args *args) bsd.buf = args->buf; bsd.count = args->count; - return readlink(p, &bsd); + return readlink(td, &bsd); } int -linux_truncate(struct proc *p, struct linux_truncate_args *args) +linux_truncate(struct thread *td, struct linux_truncate_args *args) { struct truncate_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(truncate)) @@ -655,18 +656,18 @@ linux_truncate(struct proc *p, struct linux_truncate_args *args) bsd.path = args->path; bsd.length = args->length; - return truncate(p, &bsd); + return truncate(td, &bsd); } int -linux_link(struct proc *p, struct linux_link_args *args) +linux_link(struct thread *td, struct linux_link_args *args) { struct link_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); - CHECKALTCREAT(p, &sg, args->to); + CHECKALTEXIST(td, &sg, args->path); + CHECKALTCREAT(td, &sg, args->to); #ifdef DEBUG if (ldebug(link)) @@ -676,25 +677,25 @@ linux_link(struct proc *p, struct linux_link_args *args) bsd.path = args->path; bsd.link = args->to; - return link(p, &bsd); + return link(td, &bsd); } #ifndef __alpha__ int -linux_fdatasync(p, uap) - struct proc *p; +linux_fdatasync(td, uap) + struct thread *td; struct linux_fdatasync_args *uap; { struct fsync_args bsd; bsd.fd = uap->fd; - return fsync(p, &bsd); + return fsync(td, &bsd); } #endif /*!__alpha__*/ int -linux_pread(p, uap) - struct proc *p; +linux_pread(td, uap) + struct thread *td; struct linux_pread_args *uap; { struct pread_args bsd; @@ -703,12 +704,12 @@ linux_pread(p, uap) bsd.buf = uap->buf; bsd.nbyte = uap->nbyte; bsd.offset = uap->offset; - return pread(p, &bsd); + return pread(td, &bsd); } int -linux_pwrite(p, uap) - struct proc *p; +linux_pwrite(td, uap) + struct thread *td; struct linux_pwrite_args *uap; { struct pwrite_args bsd; @@ -717,11 +718,11 @@ linux_pwrite(p, uap) bsd.buf = uap->buf; bsd.nbyte = uap->nbyte; bsd.offset = uap->offset; - return pwrite(p, &bsd); + return pwrite(td, &bsd); } int -linux_mount(struct proc *p, struct linux_mount_args *args) +linux_mount(struct thread *td, struct linux_mount_args *args) { struct ufs_args ufs; char fstypename[MFSNAMELEN]; @@ -782,27 +783,27 @@ linux_mount(struct proc *p, struct linux_mount_args *args) fsflags |= MNT_UPDATE; } - return (vfs_mount(p, fstype, mntonname, fsflags, fsdata)); + return (vfs_mount(td, fstype, mntonname, fsflags, fsdata)); } int -linux_oldumount(struct proc *p, struct linux_oldumount_args *args) +linux_oldumount(struct thread *td, struct linux_oldumount_args *args) { struct linux_umount_args args2; args2.path = args->path; args2.flags = 0; - return (linux_umount(p, &args2)); + return (linux_umount(td, &args2)); } int -linux_umount(struct proc *p, struct linux_umount_args *args) +linux_umount(struct thread *td, struct linux_umount_args *args) { struct unmount_args bsd; bsd.path = args->path; bsd.flags = args->flags; /* XXX correct? */ - return (unmount(p, &bsd)); + return (unmount(td, &bsd)); } /* @@ -918,7 +919,7 @@ bsd_to_linux_flock64(struct flock *bsd_flock, struct l_flock64 *linux_flock) #endif static int -fcntl_common(struct proc *p, struct linux_fcntl64_args *args) +fcntl_common(struct thread *td, struct linux_fcntl64_args *args) { struct fcntl_args fcntl_args; struct filedesc *fdp; @@ -931,36 +932,36 @@ fcntl_common(struct proc *p, struct linux_fcntl64_args *args) case LINUX_F_DUPFD: fcntl_args.cmd = F_DUPFD; fcntl_args.arg = args->arg; - return (fcntl(p, &fcntl_args)); + return (fcntl(td, &fcntl_args)); case LINUX_F_GETFD: fcntl_args.cmd = F_GETFD; - return (fcntl(p, &fcntl_args)); + return (fcntl(td, &fcntl_args)); case LINUX_F_SETFD: fcntl_args.cmd = F_SETFD; fcntl_args.arg = args->arg; - return (fcntl(p, &fcntl_args)); + return (fcntl(td, &fcntl_args)); case LINUX_F_GETFL: fcntl_args.cmd = F_GETFL; - error = fcntl(p, &fcntl_args); - result = p->p_retval[0]; - p->p_retval[0] = 0; + error = fcntl(td, &fcntl_args); + result = td->td_retval[0]; + td->td_retval[0] = 0; if (result & O_RDONLY) - p->p_retval[0] |= LINUX_O_RDONLY; + td->td_retval[0] |= LINUX_O_RDONLY; if (result & O_WRONLY) - p->p_retval[0] |= LINUX_O_WRONLY; + td->td_retval[0] |= LINUX_O_WRONLY; if (result & O_RDWR) - p->p_retval[0] |= LINUX_O_RDWR; + td->td_retval[0] |= LINUX_O_RDWR; if (result & O_NDELAY) - p->p_retval[0] |= LINUX_O_NONBLOCK; + td->td_retval[0] |= LINUX_O_NONBLOCK; if (result & O_APPEND) - p->p_retval[0] |= LINUX_O_APPEND; + td->td_retval[0] |= LINUX_O_APPEND; if (result & O_FSYNC) - p->p_retval[0] |= LINUX_O_SYNC; + td->td_retval[0] |= LINUX_O_SYNC; if (result & O_ASYNC) - p->p_retval[0] |= LINUX_FASYNC; + td->td_retval[0] |= LINUX_FASYNC; return (error); case LINUX_F_SETFL: @@ -974,11 +975,11 @@ fcntl_common(struct proc *p, struct linux_fcntl64_args *args) if (args->arg & LINUX_FASYNC) fcntl_args.arg |= O_ASYNC; fcntl_args.cmd = F_SETFL; - return (fcntl(p, &fcntl_args)); + return (fcntl(td, &fcntl_args)); case LINUX_F_GETOWN: fcntl_args.cmd = F_GETOWN; - return (fcntl(p, &fcntl_args)); + return (fcntl(td, &fcntl_args)); case LINUX_F_SETOWN: /* @@ -986,7 +987,7 @@ fcntl_common(struct proc *p, struct linux_fcntl64_args *args) * significant effect for pipes (SIGIO is not delivered for * pipes under Linux-2.2.35 at least). */ - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if ((u_int)args->fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[args->fd]) == NULL) return (EBADF); @@ -995,14 +996,14 @@ fcntl_common(struct proc *p, struct linux_fcntl64_args *args) fcntl_args.cmd = F_SETOWN; fcntl_args.arg = args->arg; - return (fcntl(p, &fcntl_args)); + return (fcntl(td, &fcntl_args)); } return (EINVAL); } int -linux_fcntl(struct proc *p, struct linux_fcntl_args *args) +linux_fcntl(struct thread *td, struct linux_fcntl_args *args) { struct linux_fcntl64_args args64; struct fcntl_args fcntl_args; @@ -1029,7 +1030,7 @@ linux_fcntl(struct proc *p, struct linux_fcntl_args *args) fcntl_args.fd = args->fd; fcntl_args.cmd = F_GETLK; fcntl_args.arg = (long)bsd_flock; - error = fcntl(p, &fcntl_args); + error = fcntl(td, &fcntl_args); if (error) return (error); bsd_to_linux_flock(bsd_flock, &linux_flock); @@ -1045,7 +1046,7 @@ linux_fcntl(struct proc *p, struct linux_fcntl_args *args) fcntl_args.fd = args->fd; fcntl_args.cmd = F_SETLK; fcntl_args.arg = (long)bsd_flock; - return (fcntl(p, &fcntl_args)); + return (fcntl(td, &fcntl_args)); case LINUX_F_SETLKW: error = copyin((caddr_t)args->arg, &linux_flock, @@ -1056,18 +1057,18 @@ linux_fcntl(struct proc *p, struct linux_fcntl_args *args) fcntl_args.fd = args->fd; fcntl_args.cmd = F_SETLKW; fcntl_args.arg = (long)bsd_flock; - return (fcntl(p, &fcntl_args)); + return (fcntl(td, &fcntl_args)); } args64.fd = args->fd; args64.cmd = args->cmd; args64.arg = args->arg; - return (fcntl_common(p, &args64)); + return (fcntl_common(td, &args64)); } #if defined(__i386__) int -linux_fcntl64(struct proc *p, struct linux_fcntl64_args *args) +linux_fcntl64(struct thread *td, struct linux_fcntl64_args *args) { struct fcntl_args fcntl_args; struct l_flock64 linux_flock; @@ -1093,7 +1094,7 @@ linux_fcntl64(struct proc *p, struct linux_fcntl64_args *args) fcntl_args.fd = args->fd; fcntl_args.cmd = F_GETLK; fcntl_args.arg = (long)bsd_flock; - error = fcntl(p, &fcntl_args); + error = fcntl(td, &fcntl_args); if (error) return (error); bsd_to_linux_flock64(bsd_flock, &linux_flock); @@ -1109,7 +1110,7 @@ linux_fcntl64(struct proc *p, struct linux_fcntl64_args *args) fcntl_args.fd = args->fd; fcntl_args.cmd = F_SETLK; fcntl_args.arg = (long)bsd_flock; - return (fcntl(p, &fcntl_args)); + return (fcntl(td, &fcntl_args)); case LINUX_F_SETLKW: error = copyin((caddr_t)args->arg, &linux_flock, @@ -1120,9 +1121,9 @@ linux_fcntl64(struct proc *p, struct linux_fcntl64_args *args) fcntl_args.fd = args->fd; fcntl_args.cmd = F_SETLKW; fcntl_args.arg = (long)bsd_flock; - return (fcntl(p, &fcntl_args)); + return (fcntl(td, &fcntl_args)); } - return (fcntl_common(p, args)); + return (fcntl_common(td, args)); } #endif /* __i386__ */ diff --git a/sys/compat/linux/linux_getcwd.c b/sys/compat/linux/linux_getcwd.c index 2231f82..f08163b 100644 --- a/sys/compat/linux/linux_getcwd.c +++ b/sys/compat/linux/linux_getcwd.c @@ -61,10 +61,10 @@ static int linux_getcwd_scandir __P((struct vnode **, struct vnode **, - char **, char *, struct proc *)); + char **, char *, struct thread *)); static int linux_getcwd_common __P((struct vnode *, struct vnode *, - char **, char *, int, int, struct proc *)); + char **, char *, int, int, struct thread *)); #define DIRENT_MINSIZE (sizeof(struct dirent) - (MAXNAMLEN+1) + 4) @@ -104,12 +104,12 @@ linux_getcwd_common __P((struct vnode *, struct vnode *, * On exit, *uvpp is either NULL or is a locked vnode reference. */ static int -linux_getcwd_scandir(lvpp, uvpp, bpp, bufp, p) +linux_getcwd_scandir(lvpp, uvpp, bpp, bufp, td) struct vnode **lvpp; struct vnode **uvpp; char **bpp; char *bufp; - struct proc *p; + struct thread *td; { int error = 0; int eofflag; @@ -132,7 +132,7 @@ linux_getcwd_scandir(lvpp, uvpp, bpp, bufp, p) * current directory is still locked. */ if (bufp != NULL) { - error = VOP_GETATTR(lvp, &va, p->p_ucred, p); + error = VOP_GETATTR(lvp, &va, td->td_proc->p_ucred, td); if (error) { vput(lvp); *lvpp = NULL; @@ -147,8 +147,8 @@ linux_getcwd_scandir(lvpp, uvpp, bpp, bufp, p) */ cn.cn_nameiop = LOOKUP; cn.cn_flags = ISLASTCN | ISDOTDOT | RDONLY; - cn.cn_proc = p; - cn.cn_cred = p->p_ucred; + cn.cn_thread = td; + cn.cn_cred = td->td_proc->p_ucred; cn.cn_pnbuf = NULL; cn.cn_nameptr = ".."; cn.cn_namelen = 2; @@ -196,11 +196,11 @@ unionread: uio.uio_resid = dirbuflen; uio.uio_segflg = UIO_SYSSPACE; uio.uio_rw = UIO_READ; - uio.uio_procp = p; + uio.uio_td = td; eofflag = 0; - error = VOP_READDIR(uvp, &uio, p->p_ucred, &eofflag, 0, 0); + error = VOP_READDIR(uvp, &uio, td->td_proc->p_ucred, &eofflag, 0, 0); off = uio.uio_offset; @@ -274,16 +274,16 @@ out: #define GETCWD_CHECK_ACCESS 0x0001 static int -linux_getcwd_common (lvp, rvp, bpp, bufp, limit, flags, p) +linux_getcwd_common (lvp, rvp, bpp, bufp, limit, flags, td) struct vnode *lvp; struct vnode *rvp; char **bpp; char *bufp; int limit; int flags; - struct proc *p; + struct thread *td; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct vnode *uvp = NULL; char *bp = NULL; int error; @@ -305,7 +305,7 @@ linux_getcwd_common (lvp, rvp, bpp, bufp, limit, flags, p) * uvp is either NULL, or locked and held. */ - error = vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY, p); + error = vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY, td); if (error) { vrele(lvp); lvp = NULL; @@ -335,7 +335,7 @@ linux_getcwd_common (lvp, rvp, bpp, bufp, limit, flags, p) * whether or not caller cares. */ if (flags & GETCWD_CHECK_ACCESS) { - error = VOP_ACCESS(lvp, perms, p->p_ucred, p); + error = VOP_ACCESS(lvp, perms, td->td_proc->p_ucred, td); if (error) goto out; perms = VEXEC|VREAD; @@ -361,14 +361,14 @@ linux_getcwd_common (lvp, rvp, bpp, bufp, limit, flags, p) goto out; } VREF(lvp); - error = vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY, p); + error = vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY, td); if (error != 0) { vrele(lvp); lvp = NULL; goto out; } } - error = linux_getcwd_scandir(&lvp, &uvp, &bp, bufp, p); + error = linux_getcwd_scandir(&lvp, &uvp, &bp, bufp, td); if (error) goto out; #if DIAGNOSTIC @@ -405,25 +405,25 @@ out: */ int -linux_getcwd(struct proc *p, struct linux_getcwd_args *args) +linux_getcwd(struct thread *td, struct linux_getcwd_args *args) { struct __getcwd_args bsd; caddr_t sg, bp, bend, path; int error, len, lenused; #ifdef DEBUG - printf("Linux-emul(%ld): getcwd(%p, %ld)\n", (long)p->p_pid, + printf("Linux-emul(%ld): getcwd(%p, %ld)\n", (long)td->td_proc->p_pid, args->buf, args->bufsize); #endif sg = stackgap_init(); bsd.buf = stackgap_alloc(&sg, SPARE_USRSPACE); bsd.buflen = SPARE_USRSPACE; - error = __getcwd(p, &bsd); + error = __getcwd(td, &bsd); if (!error) { lenused = strlen(bsd.buf) + 1; if (lenused <= args->bufsize) { - p->p_retval[0] = lenused; + td->td_retval[0] = lenused; error = copyout(bsd.buf, args->buf, lenused); } else @@ -448,13 +448,13 @@ linux_getcwd(struct proc *p, struct linux_getcwd_args *args) * limit it to N/2 vnodes for an N byte buffer. */ - error = linux_getcwd_common (p->p_fd->fd_cdir, NULL, - &bp, path, len/2, GETCWD_CHECK_ACCESS, p); + error = linux_getcwd_common (td->td_proc->p_fd->fd_cdir, NULL, + &bp, path, len/2, GETCWD_CHECK_ACCESS, td); if (error) goto out; lenused = bend - bp; - p->p_retval[0] = lenused; + td->td_retval[0] = lenused; /* put the result into user buffer */ error = copyout(bp, args->buf, lenused); diff --git a/sys/compat/linux/linux_ioctl.c b/sys/compat/linux/linux_ioctl.c index b4fc8ce..ab80494 100644 --- a/sys/compat/linux/linux_ioctl.c +++ b/sys/compat/linux/linux_ioctl.c @@ -91,7 +91,7 @@ DATA_SET(linux_ioctl_handler_set, termio_handler); struct handler_element { TAILQ_ENTRY(handler_element) list; - int (*func)(struct proc *, struct linux_ioctl_args *); + int (*func)(struct thread *, struct linux_ioctl_args *); int low, high, span; }; @@ -99,15 +99,15 @@ static TAILQ_HEAD(, handler_element) handlers = TAILQ_HEAD_INITIALIZER(handlers); static int -linux_ioctl_disk(struct proc *p, struct linux_ioctl_args *args) +linux_ioctl_disk(struct thread *td, struct linux_ioctl_args *args) { - struct file *fp = p->p_fd->fd_ofiles[args->fd]; + struct file *fp = td->td_proc->p_fd->fd_ofiles[args->fd]; int error; struct disklabel dl; switch (args->cmd & 0xffff) { case LINUX_BLKGETSIZE: - error = fo_ioctl(fp, DIOCGDINFO, (caddr_t)&dl, p); + error = fo_ioctl(fp, DIOCGDINFO, (caddr_t)&dl, td); if (error) return (error); return (copyout(&(dl.d_secperunit), (caddr_t)args->arg, @@ -511,18 +511,18 @@ linux_to_bsd_termio(struct linux_termio *lio, struct termios *bios) } static int -linux_ioctl_termio(struct proc *p, struct linux_ioctl_args *args) +linux_ioctl_termio(struct thread *td, struct linux_ioctl_args *args) { struct termios bios; struct linux_termios lios; struct linux_termio lio; - struct file *fp = p->p_fd->fd_ofiles[args->fd]; + struct file *fp = td->td_proc->p_fd->fd_ofiles[args->fd]; int error; switch (args->cmd & 0xffff) { case LINUX_TCGETS: - error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, p); + error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td); if (error) return (error); bsd_to_linux_termios(&bios, &lios); @@ -533,24 +533,24 @@ linux_ioctl_termio(struct proc *p, struct linux_ioctl_args *args) if (error) return (error); linux_to_bsd_termios(&lios, &bios); - return (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, p)); + return (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td)); case LINUX_TCSETSW: error = copyin((caddr_t)args->arg, &lios, sizeof(lios)); if (error) return (error); linux_to_bsd_termios(&lios, &bios); - return (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, p)); + return (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td)); case LINUX_TCSETSF: error = copyin((caddr_t)args->arg, &lios, sizeof(lios)); if (error) return (error); linux_to_bsd_termios(&lios, &bios); - return (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, p)); + return (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td)); case LINUX_TCGETA: - error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, p); + error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td); if (error) return (error); bsd_to_linux_termio(&bios, &lio); @@ -561,21 +561,21 @@ linux_ioctl_termio(struct proc *p, struct linux_ioctl_args *args) if (error) return (error); linux_to_bsd_termio(&lio, &bios); - return (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, p)); + return (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td)); case LINUX_TCSETAW: error = copyin((caddr_t)args->arg, &lio, sizeof(lio)); if (error) return (error); linux_to_bsd_termio(&lio, &bios); - return (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, p)); + return (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td)); case LINUX_TCSETAF: error = copyin((caddr_t)args->arg, &lio, sizeof(lio)); if (error) return (error); linux_to_bsd_termio(&lio, &bios); - return (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, p)); + return (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td)); /* LINUX_TCSBRK */ @@ -591,7 +591,7 @@ linux_ioctl_termio(struct proc *p, struct linux_ioctl_args *args) case LINUX_TCION: { int c; struct write_args wr; - error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, p); + error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td); if (error) return (error); c = (args->arg == LINUX_TCIOFF) ? VSTOP : VSTART; @@ -600,7 +600,7 @@ linux_ioctl_termio(struct proc *p, struct linux_ioctl_args *args) wr.fd = args->fd; wr.buf = &c; wr.nbyte = sizeof(c); - return (write(p, &wr)); + return (write(td, &wr)); } else return (0); } @@ -608,7 +608,7 @@ linux_ioctl_termio(struct proc *p, struct linux_ioctl_args *args) return (EINVAL); } args->arg = 0; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); } case LINUX_TCFLSH: { @@ -626,66 +626,66 @@ linux_ioctl_termio(struct proc *p, struct linux_ioctl_args *args) default: return (EINVAL); } - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); } case LINUX_TIOCEXCL: args->cmd = TIOCEXCL; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_TIOCNXCL: args->cmd = TIOCNXCL; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); /* LINUX_TIOCSCTTY */ case LINUX_TIOCGPGRP: args->cmd = TIOCGPGRP; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_TIOCSPGRP: args->cmd = TIOCSPGRP; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); /* LINUX_TIOCOUTQ */ /* LINUX_TIOCSTI */ case LINUX_TIOCGWINSZ: args->cmd = TIOCGWINSZ; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_TIOCSWINSZ: args->cmd = TIOCSWINSZ; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_TIOCMGET: args->cmd = TIOCMGET; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_TIOCMBIS: args->cmd = TIOCMBIS; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_TIOCMBIC: args->cmd = TIOCMBIC; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_TIOCMSET: args->cmd = TIOCMSET; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); /* TIOCGSOFTCAR */ /* TIOCSSOFTCAR */ case LINUX_FIONREAD: /* LINUX_TIOCINQ */ args->cmd = FIONREAD; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); /* LINUX_TIOCLINUX */ case LINUX_TIOCCONS: args->cmd = TIOCCONS; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_TIOCGSERIAL: { struct linux_serial_struct lss; @@ -710,11 +710,11 @@ linux_ioctl_termio(struct proc *p, struct linux_ioctl_args *args) case LINUX_FIONBIO: args->cmd = FIONBIO; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_TIOCNOTTY: args->cmd = TIOCNOTTY; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_TIOCSETD: { int line; @@ -731,13 +731,13 @@ linux_ioctl_termio(struct proc *p, struct linux_ioctl_args *args) default: return (EINVAL); } - return (fo_ioctl(fp, TIOCSETD, (caddr_t)&line, p)); + return (fo_ioctl(fp, TIOCSETD, (caddr_t)&line, td)); } case LINUX_TIOCGETD: { int linux_line; int bsd_line = TTYDISC; - error = fo_ioctl(fp, TIOCGETD, (caddr_t)&bsd_line, p); + error = fo_ioctl(fp, TIOCGETD, (caddr_t)&bsd_line, td); if (error) return (error); switch (bsd_line) { @@ -761,15 +761,15 @@ linux_ioctl_termio(struct proc *p, struct linux_ioctl_args *args) case LINUX_FIONCLEX: args->cmd = FIONCLEX; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_FIOCLEX: args->cmd = FIOCLEX; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_FIOASYNC: args->cmd = FIOASYNC; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); /* LINUX_TIOCSERCONFIG */ /* LINUX_TIOCSERGWILD */ @@ -860,33 +860,33 @@ set_linux_cdrom_addr(union linux_cdrom_addr *addr, int format, int lba) } static int -linux_ioctl_cdrom(struct proc *p, struct linux_ioctl_args *args) +linux_ioctl_cdrom(struct thread *td, struct linux_ioctl_args *args) { - struct file *fp = p->p_fd->fd_ofiles[args->fd]; + struct file *fp = td->td_proc->p_fd->fd_ofiles[args->fd]; int error; switch (args->cmd & 0xffff) { case LINUX_CDROMPAUSE: args->cmd = CDIOCPAUSE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_CDROMRESUME: args->cmd = CDIOCRESUME; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_CDROMPLAYMSF: args->cmd = CDIOCPLAYMSF; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_CDROMPLAYTRKIND: args->cmd = CDIOCPLAYTRACKS; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_CDROMREADTOCHDR: { struct ioc_toc_header th; struct linux_cdrom_tochdr lth; - error = fo_ioctl(fp, CDIOREADTOCHEADER, (caddr_t)&th, p); + error = fo_ioctl(fp, CDIOREADTOCHEADER, (caddr_t)&th, td); if (!error) { lth.cdth_trk0 = th.starting_track; lth.cdth_trk1 = th.ending_track; @@ -901,7 +901,7 @@ linux_ioctl_cdrom(struct proc *p, struct linux_ioctl_args *args) struct ioc_read_toc_single_entry irtse; irtse.address_format = ltep->cdte_format; irtse.track = ltep->cdte_track; - error = fo_ioctl(fp, CDIOREADTOCENTRY, (caddr_t)&irtse, p); + error = fo_ioctl(fp, CDIOREADTOCENTRY, (caddr_t)&irtse, td); if (!error) { lte = *ltep; lte.cdte_ctrl = irtse.entry.control; @@ -915,15 +915,15 @@ linux_ioctl_cdrom(struct proc *p, struct linux_ioctl_args *args) case LINUX_CDROMSTOP: args->cmd = CDIOCSTOP; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_CDROMSTART: args->cmd = CDIOCSTART; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_CDROMEJECT: args->cmd = CDIOCEJECT; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); /* LINUX_CDROMVOLCTRL */ @@ -939,7 +939,7 @@ linux_ioctl_cdrom(struct proc *p, struct linux_ioctl_args *args) bsdsc.track = 0; bsdsc.data_len = sizeof(struct cd_sub_channel_info); bsdsc.data = bsdinfo; - error = fo_ioctl(fp, CDIOCREADSUBCHANNEL, (caddr_t)&bsdsc, p); + error = fo_ioctl(fp, CDIOCREADSUBCHANNEL, (caddr_t)&bsdsc, td); if (error) return (error); error = copyin((caddr_t)args->arg, &sc, @@ -969,7 +969,7 @@ linux_ioctl_cdrom(struct proc *p, struct linux_ioctl_args *args) case LINUX_CDROMRESET: args->cmd = CDIOCRESET; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); /* LINUX_CDROMVOLREAD */ /* LINUX_CDROMREADRAW */ @@ -994,227 +994,227 @@ static u_int32_t dirbits[4] = { IOC_VOID, IOC_IN, IOC_OUT, IOC_INOUT }; #define SETDIR(c) (((c) & ~IOC_DIRMASK) | dirbits[args->cmd >> 30]) static int -linux_ioctl_sound(struct proc *p, struct linux_ioctl_args *args) +linux_ioctl_sound(struct thread *td, struct linux_ioctl_args *args) { switch (args->cmd & 0xffff) { case LINUX_SOUND_MIXER_WRITE_VOLUME: args->cmd = SETDIR(SOUND_MIXER_WRITE_VOLUME); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_BASS: args->cmd = SETDIR(SOUND_MIXER_WRITE_BASS); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_TREBLE: args->cmd = SETDIR(SOUND_MIXER_WRITE_TREBLE); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_SYNTH: args->cmd = SETDIR(SOUND_MIXER_WRITE_SYNTH); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_PCM: args->cmd = SETDIR(SOUND_MIXER_WRITE_PCM); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_SPEAKER: args->cmd = SETDIR(SOUND_MIXER_WRITE_SPEAKER); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_LINE: args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_MIC: args->cmd = SETDIR(SOUND_MIXER_WRITE_MIC); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_CD: args->cmd = SETDIR(SOUND_MIXER_WRITE_CD); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_IMIX: args->cmd = SETDIR(SOUND_MIXER_WRITE_IMIX); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_ALTPCM: args->cmd = SETDIR(SOUND_MIXER_WRITE_ALTPCM); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_RECLEV: args->cmd = SETDIR(SOUND_MIXER_WRITE_RECLEV); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_IGAIN: args->cmd = SETDIR(SOUND_MIXER_WRITE_IGAIN); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_OGAIN: args->cmd = SETDIR(SOUND_MIXER_WRITE_OGAIN); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_LINE1: args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE1); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_LINE2: args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE2); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_MIXER_WRITE_LINE3: args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE3); - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_OSS_GETVERSION: { - int version = linux_get_oss_version(p); + int version = linux_get_oss_version(td->td_proc); return (copyout(&version, (caddr_t)args->arg, sizeof(int))); } case LINUX_SOUND_MIXER_READ_DEVMASK: args->cmd = SOUND_MIXER_READ_DEVMASK; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_RESET: args->cmd = SNDCTL_DSP_RESET; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_SYNC: args->cmd = SNDCTL_DSP_SYNC; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_SPEED: args->cmd = SNDCTL_DSP_SPEED; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_STEREO: args->cmd = SNDCTL_DSP_STEREO; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_GETBLKSIZE: /* LINUX_SNDCTL_DSP_SETBLKSIZE */ args->cmd = SNDCTL_DSP_GETBLKSIZE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_SETFMT: args->cmd = SNDCTL_DSP_SETFMT; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_PCM_WRITE_CHANNELS: args->cmd = SOUND_PCM_WRITE_CHANNELS; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SOUND_PCM_WRITE_FILTER: args->cmd = SOUND_PCM_WRITE_FILTER; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_POST: args->cmd = SNDCTL_DSP_POST; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_SUBDIVIDE: args->cmd = SNDCTL_DSP_SUBDIVIDE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_SETFRAGMENT: args->cmd = SNDCTL_DSP_SETFRAGMENT; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_GETFMTS: args->cmd = SNDCTL_DSP_GETFMTS; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_GETOSPACE: args->cmd = SNDCTL_DSP_GETOSPACE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_GETISPACE: args->cmd = SNDCTL_DSP_GETISPACE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_NONBLOCK: args->cmd = SNDCTL_DSP_NONBLOCK; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_GETCAPS: args->cmd = SNDCTL_DSP_GETCAPS; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_SETTRIGGER: /* LINUX_SNDCTL_GETTRIGGER */ args->cmd = SNDCTL_DSP_SETTRIGGER; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_GETIPTR: args->cmd = SNDCTL_DSP_GETIPTR; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_GETOPTR: args->cmd = SNDCTL_DSP_GETOPTR; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_DSP_GETODELAY: args->cmd = SNDCTL_DSP_GETODELAY; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SEQ_RESET: args->cmd = SNDCTL_SEQ_RESET; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SEQ_SYNC: args->cmd = SNDCTL_SEQ_SYNC; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SYNTH_INFO: args->cmd = SNDCTL_SYNTH_INFO; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SEQ_CTRLRATE: args->cmd = SNDCTL_SEQ_CTRLRATE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SEQ_GETOUTCOUNT: args->cmd = SNDCTL_SEQ_GETOUTCOUNT; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SEQ_GETINCOUNT: args->cmd = SNDCTL_SEQ_GETINCOUNT; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SEQ_PERCMODE: args->cmd = SNDCTL_SEQ_PERCMODE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_FM_LOAD_INSTR: args->cmd = SNDCTL_FM_LOAD_INSTR; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SEQ_TESTMIDI: args->cmd = SNDCTL_SEQ_TESTMIDI; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SEQ_RESETSAMPLES: args->cmd = SNDCTL_SEQ_RESETSAMPLES; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SEQ_NRSYNTHS: args->cmd = SNDCTL_SEQ_NRSYNTHS; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SEQ_NRMIDIS: args->cmd = SNDCTL_SEQ_NRMIDIS; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_MIDI_INFO: args->cmd = SNDCTL_MIDI_INFO; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SEQ_TRESHOLD: args->cmd = SNDCTL_SEQ_TRESHOLD; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SNDCTL_SYNTH_MEMAVL: args->cmd = SNDCTL_SYNTH_MEMAVL; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); } @@ -1228,39 +1228,39 @@ linux_ioctl_sound(struct proc *p, struct linux_ioctl_args *args) #define ISSIGVALID(sig) ((sig) > 0 && (sig) < NSIG) static int -linux_ioctl_console(struct proc *p, struct linux_ioctl_args *args) +linux_ioctl_console(struct thread *td, struct linux_ioctl_args *args) { - struct file *fp = p->p_fd->fd_ofiles[args->fd]; + struct file *fp = td->td_proc->p_fd->fd_ofiles[args->fd]; switch (args->cmd & 0xffff) { case LINUX_KIOCSOUND: args->cmd = KIOCSOUND; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_KDMKTONE: args->cmd = KDMKTONE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_KDGETLED: args->cmd = KDGETLED; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_KDSETLED: args->cmd = KDSETLED; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_KDSETMODE: args->cmd = KDSETMODE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_KDGETMODE: args->cmd = KDGETMODE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_KDGKBMODE: args->cmd = KDGKBMODE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_KDSKBMODE: { int kbdmode; @@ -1277,16 +1277,16 @@ linux_ioctl_console(struct proc *p, struct linux_ioctl_args *args) default: return (EINVAL); } - return (fo_ioctl(fp, KDSKBMODE, (caddr_t)&kbdmode, p)); + return (fo_ioctl(fp, KDSKBMODE, (caddr_t)&kbdmode, td)); } case LINUX_VT_OPENQRY: args->cmd = VT_OPENQRY; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_VT_GETMODE: args->cmd = VT_GETMODE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_VT_SETMODE: { struct vt_mode *mode; @@ -1294,24 +1294,24 @@ linux_ioctl_console(struct proc *p, struct linux_ioctl_args *args) mode = (struct vt_mode *)args->arg; if (!ISSIGVALID(mode->frsig) && ISSIGVALID(mode->acqsig)) mode->frsig = mode->acqsig; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); } case LINUX_VT_GETSTATE: args->cmd = VT_GETACTIVE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_VT_RELDISP: args->cmd = VT_RELDISP; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_VT_ACTIVATE: args->cmd = VT_ACTIVATE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_VT_WAITACTIVE: args->cmd = VT_WAITACTIVE; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); } @@ -1323,56 +1323,56 @@ linux_ioctl_console(struct proc *p, struct linux_ioctl_args *args) */ static int -linux_ioctl_socket(struct proc *p, struct linux_ioctl_args *args) +linux_ioctl_socket(struct thread *td, struct linux_ioctl_args *args) { switch (args->cmd & 0xffff) { case LINUX_FIOSETOWN: args->cmd = FIOSETOWN; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SIOCSPGRP: args->cmd = SIOCSPGRP; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_FIOGETOWN: args->cmd = FIOGETOWN; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SIOCGPGRP: args->cmd = SIOCGPGRP; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SIOCATMARK: args->cmd = SIOCATMARK; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); /* LINUX_SIOCGSTAMP */ case LINUX_SIOCGIFCONF: args->cmd = OSIOCGIFCONF; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SIOCGIFFLAGS: args->cmd = SIOCGIFFLAGS; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SIOCGIFADDR: args->cmd = OSIOCGIFADDR; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SIOCGIFDSTADDR: args->cmd = OSIOCGIFDSTADDR; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SIOCGIFBRDADDR: args->cmd = OSIOCGIFBRDADDR; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SIOCGIFNETMASK: args->cmd = OSIOCGIFNETMASK; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SIOCGIFHWADDR: { int ifn; @@ -1406,11 +1406,11 @@ linux_ioctl_socket(struct proc *p, struct linux_ioctl_args *args) case LINUX_SIOCADDMULTI: args->cmd = SIOCADDMULTI; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); case LINUX_SIOCDELMULTI: args->cmd = SIOCDELMULTI; - return (ioctl(p, (struct ioctl_args *)args)); + return (ioctl(td, (struct ioctl_args *)args)); } @@ -1422,7 +1422,7 @@ linux_ioctl_socket(struct proc *p, struct linux_ioctl_args *args) */ int -linux_ioctl(struct proc *p, struct linux_ioctl_args *args) +linux_ioctl(struct thread *td, struct linux_ioctl_args *args) { struct filedesc *fdp; struct file *fp; @@ -1434,7 +1434,7 @@ linux_ioctl(struct proc *p, struct linux_ioctl_args *args) printf(ARGS(ioctl, "%d, %04lx, *"), args->fd, args->cmd); #endif - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if ((unsigned)args->fd >= fdp->fd_nfiles) return (EBADF); fp = fdp->fd_ofiles[args->fd]; @@ -1445,7 +1445,7 @@ linux_ioctl(struct proc *p, struct linux_ioctl_args *args) cmd = args->cmd & 0xffff; TAILQ_FOREACH(he, &handlers, list) { if (cmd >= he->low && cmd <= he->high) { - error = (*he->func)(p, args); + error = (*he->func)(td, args); if (error != ENOIOCTL) return (error); } diff --git a/sys/compat/linux/linux_ipc.c b/sys/compat/linux/linux_ipc.c index de9b47a..9053efc 100644 --- a/sys/compat/linux/linux_ipc.c +++ b/sys/compat/linux/linux_ipc.c @@ -149,7 +149,7 @@ bsd_to_linux_shmid_ds(struct shmid_ds *bsp, struct l_shmid_ds *lsp) } int -linux_semop(struct proc *p, struct linux_semop_args *args) +linux_semop(struct thread *td, struct linux_semop_args *args) { struct semop_args /* { int semid; @@ -160,11 +160,11 @@ linux_semop(struct proc *p, struct linux_semop_args *args) bsd_args.semid = args->semid; bsd_args.sops = (struct sembuf *)args->tsops; bsd_args.nsops = args->nsops; - return semop(p, &bsd_args); + return semop(td, &bsd_args); } int -linux_semget(struct proc *p, struct linux_semget_args *args) +linux_semget(struct thread *td, struct linux_semget_args *args) { struct semget_args /* { key_t key; @@ -175,11 +175,11 @@ linux_semget(struct proc *p, struct linux_semget_args *args) bsd_args.key = args->key; bsd_args.nsems = args->nsems; bsd_args.semflg = args->semflg; - return semget(p, &bsd_args); + return semget(td, &bsd_args); } int -linux_semctl(struct proc *p, struct linux_semctl_args *args) +linux_semctl(struct thread *td, struct linux_semctl_args *args) { struct l_semid_ds linux_semid; struct __semctl_args /* { @@ -226,13 +226,13 @@ linux_semctl(struct proc *p, struct linux_semctl_args *args) unptr->buf = stackgap_alloc(&sg, sizeof(struct semid_ds)); linux_to_bsd_semid_ds(&linux_semid, unptr->buf); bsd_args.arg = unptr; - return __semctl(p, &bsd_args); + return __semctl(td, &bsd_args); case LINUX_IPC_STAT: bsd_args.cmd = IPC_STAT; unptr = stackgap_alloc(&sg, sizeof(union semun)); unptr->buf = stackgap_alloc(&sg, sizeof(struct semid_ds)); bsd_args.arg = unptr; - error = __semctl(p, &bsd_args); + error = __semctl(td, &bsd_args); if (error) return error; bsd_to_linux_semid_ds(unptr->buf, &linux_semid); @@ -246,11 +246,11 @@ linux_semctl(struct proc *p, struct linux_semctl_args *args) uprintf("linux: 'ipc' typ=%d not implemented\n", args->cmd); return EINVAL; } - return __semctl(p, &bsd_args); + return __semctl(td, &bsd_args); } int -linux_msgsnd(struct proc *p, struct linux_msgsnd_args *args) +linux_msgsnd(struct thread *td, struct linux_msgsnd_args *args) { struct msgsnd_args /* { int msqid; @@ -263,11 +263,11 @@ linux_msgsnd(struct proc *p, struct linux_msgsnd_args *args) bsd_args.msgp = args->msgp; bsd_args.msgsz = args->msgsz; bsd_args.msgflg = args->msgflg; - return msgsnd(p, &bsd_args); + return msgsnd(td, &bsd_args); } int -linux_msgrcv(struct proc *p, struct linux_msgrcv_args *args) +linux_msgrcv(struct thread *td, struct linux_msgrcv_args *args) { struct msgrcv_args /* { int msqid; @@ -282,11 +282,11 @@ linux_msgrcv(struct proc *p, struct linux_msgrcv_args *args) bsd_args.msgsz = args->msgsz; bsd_args.msgtyp = 0; /* XXX - args->msgtyp; */ bsd_args.msgflg = args->msgflg; - return msgrcv(p, &bsd_args); + return msgrcv(td, &bsd_args); } int -linux_msgget(struct proc *p, struct linux_msgget_args *args) +linux_msgget(struct thread *td, struct linux_msgget_args *args) { struct msgget_args /* { key_t key; @@ -295,11 +295,11 @@ linux_msgget(struct proc *p, struct linux_msgget_args *args) bsd_args.key = args->key; bsd_args.msgflg = args->msgflg; - return msgget(p, &bsd_args); + return msgget(td, &bsd_args); } int -linux_msgctl(struct proc *p, struct linux_msgctl_args *args) +linux_msgctl(struct thread *td, struct linux_msgctl_args *args) { struct msgctl_args /* { int msqid; @@ -311,12 +311,12 @@ linux_msgctl(struct proc *p, struct linux_msgctl_args *args) bsd_args.msqid = args->msqid; bsd_args.cmd = args->cmd; bsd_args.buf = (struct msqid_ds *)args->buf; - error = msgctl(p, &bsd_args); + error = msgctl(td, &bsd_args); return ((args->cmd == LINUX_IPC_RMID && error == EINVAL) ? 0 : error); } int -linux_shmat(struct proc *p, struct linux_shmat_args *args) +linux_shmat(struct thread *td, struct linux_shmat_args *args) { struct shmat_args /* { int shmid; @@ -328,29 +328,29 @@ linux_shmat(struct proc *p, struct linux_shmat_args *args) bsd_args.shmid = args->shmid; bsd_args.shmaddr = args->shmaddr; bsd_args.shmflg = args->shmflg; - if ((error = shmat(p, &bsd_args))) + if ((error = shmat(td, &bsd_args))) return error; #ifdef __i386__ - if ((error = copyout(p->p_retval, (caddr_t)args->raddr, sizeof(l_ulong)))) + if ((error = copyout(td->td_retval, (caddr_t)args->raddr, sizeof(l_ulong)))) return error; - p->p_retval[0] = 0; + td->td_retval[0] = 0; #endif return 0; } int -linux_shmdt(struct proc *p, struct linux_shmdt_args *args) +linux_shmdt(struct thread *td, struct linux_shmdt_args *args) { struct shmdt_args /* { void *shmaddr; } */ bsd_args; bsd_args.shmaddr = args->shmaddr; - return shmdt(p, &bsd_args); + return shmdt(td, &bsd_args); } int -linux_shmget(struct proc *p, struct linux_shmget_args *args) +linux_shmget(struct thread *td, struct linux_shmget_args *args) { struct shmget_args /* { key_t key; @@ -361,11 +361,11 @@ linux_shmget(struct proc *p, struct linux_shmget_args *args) bsd_args.key = args->key; bsd_args.size = args->size; bsd_args.shmflg = args->shmflg; - return shmget(p, &bsd_args); + return shmget(td, &bsd_args); } int -linux_shmctl(struct proc *p, struct linux_shmctl_args *args) +linux_shmctl(struct thread *td, struct linux_shmctl_args *args) { struct l_shmid_ds linux_shmid; struct shmctl_args /* { @@ -381,7 +381,7 @@ linux_shmctl(struct proc *p, struct linux_shmctl_args *args) bsd_args.shmid = args->shmid; bsd_args.cmd = IPC_STAT; bsd_args.buf = (struct shmid_ds*)stackgap_alloc(&sg, sizeof(struct shmid_ds)); - if ((error = shmctl(p, &bsd_args))) + if ((error = shmctl(td, &bsd_args))) return error; bsd_to_linux_shmid_ds(bsd_args.buf, &linux_shmid); return copyout(&linux_shmid, (caddr_t)args->buf, sizeof(linux_shmid)); @@ -394,7 +394,7 @@ linux_shmctl(struct proc *p, struct linux_shmctl_args *args) linux_to_bsd_shmid_ds(&linux_shmid, bsd_args.buf); bsd_args.shmid = args->shmid; bsd_args.cmd = IPC_SET; - return shmctl(p, &bsd_args); + return shmctl(td, &bsd_args); case LINUX_IPC_RMID: bsd_args.shmid = args->shmid; @@ -408,7 +408,7 @@ linux_shmctl(struct proc *p, struct linux_shmctl_args *args) bsd_args.buf = (struct shmid_ds*)stackgap_alloc(&sg, sizeof(struct shmid_ds)); linux_to_bsd_shmid_ds(&linux_shmid, bsd_args.buf); } - return shmctl(p, &bsd_args); + return shmctl(td, &bsd_args); case LINUX_IPC_INFO: case LINUX_SHM_STAT: diff --git a/sys/compat/linux/linux_ipc.h b/sys/compat/linux/linux_ipc.h index d0db461..a647b4b 100644 --- a/sys/compat/linux/linux_ipc.h +++ b/sys/compat/linux/linux_ipc.h @@ -112,19 +112,19 @@ struct linux_shmget_args l_int shmflg; }; -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_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_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_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 *)); #endif /* __i386__ */ diff --git a/sys/compat/linux/linux_misc.c b/sys/compat/linux/linux_misc.c index a717d81..7acea9f 100644 --- a/sys/compat/linux/linux_misc.c +++ b/sys/compat/linux/linux_misc.c @@ -108,7 +108,7 @@ struct l_sysinfo { }; #ifndef __alpha__ int -linux_sysinfo(struct proc *p, struct linux_sysinfo_args *args) +linux_sysinfo(struct thread *td, struct linux_sysinfo_args *args) { struct l_sysinfo sysinfo; vm_object_t object; @@ -164,7 +164,7 @@ linux_sysinfo(struct proc *p, struct linux_sysinfo_args *args) #ifndef __alpha__ int -linux_alarm(struct proc *p, struct linux_alarm_args *args) +linux_alarm(struct thread *td, struct linux_alarm_args *args) { struct itimerval it, old_it; struct timeval tv; @@ -183,31 +183,31 @@ linux_alarm(struct proc *p, struct linux_alarm_args *args) it.it_interval.tv_sec = 0; it.it_interval.tv_usec = 0; s = splsoftclock(); - old_it = p->p_realtimer; + old_it = td->td_proc->p_realtimer; getmicrouptime(&tv); if (timevalisset(&old_it.it_value)) - callout_stop(&p->p_itcallout); + callout_stop(&td->td_proc->p_itcallout); if (it.it_value.tv_sec != 0) { - callout_reset(&p->p_itcallout, tvtohz(&it.it_value), - realitexpire, p); + callout_reset(&td->td_proc->p_itcallout, tvtohz(&it.it_value), + realitexpire, td); timevaladd(&it.it_value, &tv); } - p->p_realtimer = it; + td->td_proc->p_realtimer = it; splx(s); if (timevalcmp(&old_it.it_value, &tv, >)) { timevalsub(&old_it.it_value, &tv); if (old_it.it_value.tv_usec != 0) old_it.it_value.tv_sec++; - p->p_retval[0] = old_it.it_value.tv_sec; + td->td_retval[0] = old_it.it_value.tv_sec; } return 0; } #endif /*!__alpha__*/ int -linux_brk(struct proc *p, struct linux_brk_args *args) +linux_brk(struct thread *td, struct linux_brk_args *args) { - struct vmspace *vm = p->p_vmspace; + struct vmspace *vm = td->td_proc->p_vmspace; vm_offset_t new, old; struct obreak_args /* { char * nsize; @@ -220,16 +220,16 @@ linux_brk(struct proc *p, struct linux_brk_args *args) old = (vm_offset_t)vm->vm_daddr + ctob(vm->vm_dsize); new = (vm_offset_t)args->dsend; tmp.nsize = (char *) new; - if (((caddr_t)new > vm->vm_daddr) && !obreak(p, &tmp)) - p->p_retval[0] = (long)new; + if (((caddr_t)new > vm->vm_daddr) && !obreak(td, &tmp)) + td->td_retval[0] = (long)new; else - p->p_retval[0] = (long)old; + td->td_retval[0] = (long)old; return 0; } int -linux_uselib(struct proc *p, struct linux_uselib_args *args) +linux_uselib(struct thread *td, struct linux_uselib_args *args) { struct nameidata ni; struct vnode *vp; @@ -244,7 +244,7 @@ linux_uselib(struct proc *p, struct linux_uselib_args *args) int locked; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->library); + CHECKALTEXIST(td, &sg, args->library); #ifdef DEBUG if (ldebug(uselib)) @@ -255,7 +255,7 @@ linux_uselib(struct proc *p, struct linux_uselib_args *args) locked = 0; vp = NULL; - NDINIT(&ni, LOOKUP, FOLLOW|LOCKLEAF, UIO_USERSPACE, args->library, p); + NDINIT(&ni, LOOKUP, FOLLOW|LOCKLEAF, UIO_USERSPACE, args->library, td); error = namei(&ni); if (error) goto cleanup; @@ -283,7 +283,7 @@ linux_uselib(struct proc *p, struct linux_uselib_args *args) } /* Executable? */ - error = VOP_GETATTR(vp, &attr, p->p_ucred, p); + error = VOP_GETATTR(vp, &attr, td->td_proc->p_ucred, td); if (error) goto cleanup; @@ -300,18 +300,18 @@ linux_uselib(struct proc *p, struct linux_uselib_args *args) } /* Can we access it? */ - error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); + error = VOP_ACCESS(vp, VEXEC, td->td_proc->p_ucred, td); if (error) goto cleanup; - error = VOP_OPEN(vp, FREAD, p->p_ucred, p); + error = VOP_OPEN(vp, FREAD, td->td_proc->p_ucred, td); if (error) goto cleanup; /* * Lock no longer needed */ - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); locked = 0; /* Pull in executable header into kernel_map */ @@ -357,7 +357,7 @@ linux_uselib(struct proc *p, struct linux_uselib_args *args) goto cleanup; } - /* To protect p->p_rlimit in the if condition. */ + /* To protect td->td_proc->p_rlimit in the if condition. */ mtx_assert(&Giant, MA_OWNED); /* @@ -366,7 +366,8 @@ linux_uselib(struct proc *p, struct linux_uselib_args *args) * the resources needed by this library. */ if (a_out->a_text > MAXTSIZ || - a_out->a_data + bss_size > p->p_rlimit[RLIMIT_DATA].rlim_cur) { + a_out->a_data + bss_size > + td->td_proc->p_rlimit[RLIMIT_DATA].rlim_cur) { error = ENOMEM; goto cleanup; } @@ -389,8 +390,8 @@ linux_uselib(struct proc *p, struct linux_uselib_args *args) vmaddr = trunc_page(a_out->a_entry); /* get anon user mapping, read+write+execute */ - error = vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &vmaddr, - a_out->a_text + a_out->a_data, FALSE, VM_PROT_ALL, + error = vm_map_find(&td->td_proc->p_vmspace->vm_map, NULL, 0, + &vmaddr, a_out->a_text + a_out->a_data, FALSE, VM_PROT_ALL, VM_PROT_ALL, 0); if (error) goto cleanup; @@ -427,7 +428,7 @@ linux_uselib(struct proc *p, struct linux_uselib_args *args) * Map it all into the process's space as a single * copy-on-write "data" segment. */ - error = vm_mmap(&p->p_vmspace->vm_map, &vmaddr, + error = vm_mmap(&td->td_proc->p_vmspace->vm_map, &vmaddr, a_out->a_text + a_out->a_data, VM_PROT_ALL, VM_PROT_ALL, MAP_PRIVATE | MAP_FIXED, (caddr_t)vp, file_offset); if (error) @@ -443,8 +444,8 @@ linux_uselib(struct proc *p, struct linux_uselib_args *args) a_out->a_data; /* allocate some 'anon' space */ - error = vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &vmaddr, - bss_size, FALSE, VM_PROT_ALL, VM_PROT_ALL, 0); + error = vm_map_find(&td->td_proc->p_vmspace->vm_map, NULL, 0, + &vmaddr, bss_size, FALSE, VM_PROT_ALL, VM_PROT_ALL, 0); if (error) goto cleanup; } @@ -452,7 +453,7 @@ linux_uselib(struct proc *p, struct linux_uselib_args *args) cleanup: /* Unlock vnode if needed */ if (locked) - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); /* Release the kernel mapping. */ if (a_out) @@ -463,7 +464,7 @@ cleanup: } int -linux_select(struct proc *p, struct linux_select_args *args) +linux_select(struct thread *td, struct linux_select_args *args) { struct select_args bsa; struct timeval tv0, tv1, utv, *tvp; @@ -520,7 +521,7 @@ linux_select(struct proc *p, struct linux_select_args *args) microtime(&tv0); } - error = select(p, &bsa); + error = select(td, &bsa); #ifdef DEBUG if (ldebug(select)) printf(LMSG("real select returns %d"), error); @@ -536,7 +537,7 @@ linux_select(struct proc *p, struct linux_select_args *args) } if (args->timeout) { - if (p->p_retval[0]) { + if (td->td_retval[0]) { /* * Compute how much time was left of the timeout, * by subtracting the current time and the time @@ -569,7 +570,7 @@ select_out: } int -linux_getpgid(struct proc *p, struct linux_getpgid_args *args) +linux_getpgid(struct thread *td, struct linux_getpgid_args *args) { struct proc *curp; @@ -578,19 +579,19 @@ linux_getpgid(struct proc *p, struct linux_getpgid_args *args) printf(ARGS(getpgid, "%d"), args->pid); #endif - if (args->pid != p->p_pid) { + if (args->pid != td->td_proc->p_pid) { if (!(curp = pfind(args->pid))) return ESRCH; - p->p_retval[0] = curp->p_pgid; + td->td_retval[0] = curp->p_pgid; PROC_UNLOCK(curp); } else - p->p_retval[0] = p->p_pgid; + td->td_retval[0] = td->td_proc->p_pgid; return 0; } int -linux_mremap(struct proc *p, struct linux_mremap_args *args) +linux_mremap(struct thread *td, struct linux_mremap_args *args) { struct munmap_args /* { void *addr; @@ -610,22 +611,22 @@ linux_mremap(struct proc *p, struct linux_mremap_args *args) args->old_len = round_page(args->old_len); if (args->new_len > args->old_len) { - p->p_retval[0] = 0; + td->td_retval[0] = 0; return ENOMEM; } if (args->new_len < args->old_len) { bsd_args.addr = (caddr_t)(args->addr + args->new_len); bsd_args.len = args->old_len - args->new_len; - error = munmap(p, &bsd_args); + error = munmap(td, &bsd_args); } - p->p_retval[0] = error ? 0 : (u_long)args->addr; + td->td_retval[0] = error ? 0 : (u_long)args->addr; return error; } int -linux_msync(struct proc *p, struct linux_msync_args *args) +linux_msync(struct thread *td, struct linux_msync_args *args) { struct msync_args bsd_args; @@ -633,12 +634,12 @@ linux_msync(struct proc *p, struct linux_msync_args *args) bsd_args.len = args->len; bsd_args.flags = 0; /* XXX ignore */ - return msync(p, &bsd_args); + return msync(td, &bsd_args); } #ifndef __alpha__ int -linux_time(struct proc *p, struct linux_time_args *args) +linux_time(struct thread *td, struct linux_time_args *args) { struct timeval tv; l_time_t tm; @@ -653,7 +654,7 @@ linux_time(struct proc *p, struct linux_time_args *args) tm = tv.tv_sec; if (args->tm && (error = copyout(&tm, (caddr_t)args->tm, sizeof(tm)))) return error; - p->p_retval[0] = tm; + td->td_retval[0] = tm; return 0; } #endif /*!__alpha__*/ @@ -674,7 +675,7 @@ struct l_times_argv { #define CONVTCK(r) (r.tv_sec * CLK_TCK + r.tv_usec / (1000000 / CLK_TCK)) int -linux_times(struct proc *p, struct linux_times_args *args) +linux_times(struct thread *td, struct linux_times_args *args) { struct timeval tv; struct l_times_argv tms; @@ -687,25 +688,25 @@ linux_times(struct proc *p, struct linux_times_args *args) #endif mtx_lock_spin(&sched_lock); - calcru(p, &ru.ru_utime, &ru.ru_stime, NULL); + calcru(td->td_proc, &ru.ru_utime, &ru.ru_stime, NULL); mtx_unlock_spin(&sched_lock); tms.tms_utime = CONVTCK(ru.ru_utime); tms.tms_stime = CONVTCK(ru.ru_stime); - tms.tms_cutime = CONVTCK(p->p_stats->p_cru.ru_utime); - tms.tms_cstime = CONVTCK(p->p_stats->p_cru.ru_stime); + tms.tms_cutime = CONVTCK(td->td_proc->p_stats->p_cru.ru_utime); + tms.tms_cstime = CONVTCK(td->td_proc->p_stats->p_cru.ru_stime); if ((error = copyout(&tms, (caddr_t)args->buf, sizeof(tms)))) return error; microuptime(&tv); - p->p_retval[0] = (int)CONVTCK(tv); + td->td_retval[0] = (int)CONVTCK(tv); return 0; } int -linux_newuname(struct proc *p, struct linux_newuname_args *args) +linux_newuname(struct thread *td, struct linux_newuname_args *args) { struct l_new_utsname utsname; char *osrelease, *osname; @@ -715,8 +716,8 @@ linux_newuname(struct proc *p, struct linux_newuname_args *args) printf(ARGS(newuname, "*")); #endif - osname = linux_get_osname(p); - osrelease = linux_get_osrelease(p); + osname = linux_get_osname(td->td_proc); + osrelease = linux_get_osrelease(td->td_proc); bzero(&utsname, sizeof(utsname)); strncpy(utsname.sysname, osname, LINUX_MAX_UTSNAME-1); @@ -736,7 +737,7 @@ struct l_utimbuf { }; int -linux_utime(struct proc *p, struct linux_utime_args *args) +linux_utime(struct thread *td, struct linux_utime_args *args) { struct utimes_args /* { char *path; @@ -748,7 +749,7 @@ linux_utime(struct proc *p, struct linux_utime_args *args) caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->fname); + CHECKALTEXIST(td, &sg, args->fname); #ifdef DEBUG if (ldebug(utime)) @@ -773,7 +774,7 @@ linux_utime(struct proc *p, struct linux_utime_args *args) bsdutimes.tptr = NULL; bsdutimes.path = args->fname; - return utimes(p, &bsdutimes); + return utimes(td, &bsdutimes); } #endif /* __i386__ */ @@ -781,7 +782,7 @@ linux_utime(struct proc *p, struct linux_utime_args *args) #ifndef __alpha__ int -linux_waitpid(struct proc *p, struct linux_waitpid_args *args) +linux_waitpid(struct thread *td, struct linux_waitpid_args *args) { struct wait_args /* { int pid; @@ -805,7 +806,7 @@ linux_waitpid(struct proc *p, struct linux_waitpid_args *args) tmp.options |= WLINUXCLONE; tmp.rusage = NULL; - if ((error = wait4(p, &tmp)) != 0) + if ((error = wait4(td, &tmp)) != 0) return error; if (args->status) { @@ -827,7 +828,7 @@ linux_waitpid(struct proc *p, struct linux_waitpid_args *args) #endif /*!__alpha__*/ int -linux_wait4(struct proc *p, struct linux_wait4_args *args) +linux_wait4(struct thread *td, struct linux_wait4_args *args) { struct wait_args /* { int pid; @@ -852,10 +853,10 @@ linux_wait4(struct proc *p, struct linux_wait4_args *args) tmp.options |= WLINUXCLONE; tmp.rusage = (struct rusage *)args->rusage; - if ((error = wait4(p, &tmp)) != 0) + if ((error = wait4(td, &tmp)) != 0) return error; - SIGDELSET(p->p_siglist, SIGCHLD); + SIGDELSET(td->td_proc->p_siglist, SIGCHLD); if (args->status) { if ((error = copyin((caddr_t)args->status, &tmpstat, @@ -875,7 +876,7 @@ linux_wait4(struct proc *p, struct linux_wait4_args *args) } int -linux_mknod(struct proc *p, struct linux_mknod_args *args) +linux_mknod(struct thread *td, struct linux_mknod_args *args) { caddr_t sg; struct mknod_args bsd_mknod; @@ -883,7 +884,7 @@ linux_mknod(struct proc *p, struct linux_mknod_args *args) sg = stackgap_init(); - CHECKALTCREAT(p, &sg, args->path); + CHECKALTCREAT(td, &sg, args->path); #ifdef DEBUG if (ldebug(mknod)) @@ -894,12 +895,12 @@ linux_mknod(struct proc *p, struct linux_mknod_args *args) if (args->mode & S_IFIFO) { bsd_mkfifo.path = args->path; bsd_mkfifo.mode = args->mode; - return mkfifo(p, &bsd_mkfifo); + return mkfifo(td, &bsd_mkfifo); } else { bsd_mknod.path = args->path; bsd_mknod.mode = args->mode; bsd_mknod.dev = args->dev; - return mknod(p, &bsd_mknod); + return mknod(td, &bsd_mknod); } } @@ -907,7 +908,7 @@ linux_mknod(struct proc *p, struct linux_mknod_args *args) * UGH! This is just about the dumbest idea I've ever heard!! */ int -linux_personality(struct proc *p, struct linux_personality_args *args) +linux_personality(struct thread *td, struct linux_personality_args *args) { #ifdef DEBUG if (ldebug(personality)) @@ -919,7 +920,7 @@ linux_personality(struct proc *p, struct linux_personality_args *args) #endif /* Yes Jim, it's still a Linux... */ - p->p_retval[0] = 0; + td->td_retval[0] = 0; return 0; } @@ -927,7 +928,7 @@ linux_personality(struct proc *p, struct linux_personality_args *args) * Wrappers for get/setitimer for debugging.. */ int -linux_setitimer(struct proc *p, struct linux_setitimer_args *args) +linux_setitimer(struct thread *td, struct linux_setitimer_args *args) { struct setitimer_args bsa; struct itimerval foo; @@ -953,11 +954,11 @@ linux_setitimer(struct proc *p, struct linux_setitimer_args *args) } #endif } - return setitimer(p, &bsa); + return setitimer(td, &bsa); } int -linux_getitimer(struct proc *p, struct linux_getitimer_args *args) +linux_getitimer(struct thread *td, struct linux_getitimer_args *args) { struct getitimer_args bsa; #ifdef DEBUG @@ -966,24 +967,24 @@ linux_getitimer(struct proc *p, struct linux_getitimer_args *args) #endif bsa.which = args->which; bsa.itv = (struct itimerval *)args->itv; - return getitimer(p, &bsa); + return getitimer(td, &bsa); } #ifndef __alpha__ int -linux_nice(struct proc *p, struct linux_nice_args *args) +linux_nice(struct thread *td, struct linux_nice_args *args) { struct setpriority_args bsd_args; bsd_args.which = PRIO_PROCESS; bsd_args.who = 0; /* current process */ bsd_args.prio = args->inc; - return setpriority(p, &bsd_args); + return setpriority(td, &bsd_args); } #endif /*!__alpha__*/ int -linux_setgroups(struct proc *p, struct linux_setgroups_args *args) +linux_setgroups(struct thread *td, struct linux_setgroups_args *args) { struct ucred *newcred, *oldcred; l_gid_t linux_gidset[NGROUPS]; @@ -991,7 +992,7 @@ linux_setgroups(struct proc *p, struct linux_setgroups_args *args) int ngrp, error; ngrp = args->gidsetsize; - oldcred = p->p_ucred; + oldcred = td->td_proc->p_ucred; /* * cr_groups[0] holds egid. Setting the whole set from @@ -1024,21 +1025,21 @@ linux_setgroups(struct proc *p, struct linux_setgroups_args *args) else newcred->cr_ngroups = 1; - setsugid(p); - p->p_ucred = newcred; + setsugid(td->td_proc); + td->td_proc->p_ucred = newcred; crfree(oldcred); return (0); } int -linux_getgroups(struct proc *p, struct linux_getgroups_args *args) +linux_getgroups(struct thread *td, struct linux_getgroups_args *args) { struct ucred *cred; l_gid_t linux_gidset[NGROUPS]; gid_t *bsd_gidset; int bsd_gidsetsz, ngrp, error; - cred = p->p_ucred; + cred = td->td_proc->p_ucred; bsd_gidset = cred->cr_groups; bsd_gidsetsz = cred->cr_ngroups - 1; @@ -1049,7 +1050,7 @@ linux_getgroups(struct proc *p, struct linux_getgroups_args *args) */ if ((ngrp = args->gidsetsize) == 0) { - p->p_retval[0] = bsd_gidsetsz; + td->td_retval[0] = bsd_gidsetsz; return (0); } @@ -1066,13 +1067,13 @@ linux_getgroups(struct proc *p, struct linux_getgroups_args *args) ngrp * sizeof(l_gid_t)))) return (error); - p->p_retval[0] = ngrp; + td->td_retval[0] = ngrp; return (0); } #ifndef __alpha__ int -linux_setrlimit(struct proc *p, struct linux_setrlimit_args *args) +linux_setrlimit(struct thread *td, struct linux_setrlimit_args *args) { struct __setrlimit_args bsd; struct l_rlimit rlim; @@ -1099,11 +1100,11 @@ linux_setrlimit(struct proc *p, struct linux_setrlimit_args *args) bsd.rlp = stackgap_alloc(&sg, sizeof(struct rlimit)); bsd.rlp->rlim_cur = (rlim_t)rlim.rlim_cur; bsd.rlp->rlim_max = (rlim_t)rlim.rlim_max; - return (setrlimit(p, &bsd)); + return (setrlimit(td, &bsd)); } int -linux_old_getrlimit(struct proc *p, struct linux_old_getrlimit_args *args) +linux_old_getrlimit(struct thread *td, struct linux_old_getrlimit_args *args) { struct __getrlimit_args bsd; struct l_rlimit rlim; @@ -1124,7 +1125,7 @@ linux_old_getrlimit(struct proc *p, struct linux_old_getrlimit_args *args) return (EINVAL); bsd.rlp = stackgap_alloc(&sg, sizeof(struct rlimit)); - error = getrlimit(p, &bsd); + error = getrlimit(td, &bsd); if (error) return (error); @@ -1138,7 +1139,7 @@ linux_old_getrlimit(struct proc *p, struct linux_old_getrlimit_args *args) } int -linux_getrlimit(struct proc *p, struct linux_getrlimit_args *args) +linux_getrlimit(struct thread *td, struct linux_getrlimit_args *args) { struct __getrlimit_args bsd; struct l_rlimit rlim; @@ -1159,7 +1160,7 @@ linux_getrlimit(struct proc *p, struct linux_getrlimit_args *args) return (EINVAL); bsd.rlp = stackgap_alloc(&sg, sizeof(struct rlimit)); - error = getrlimit(p, &bsd); + error = getrlimit(td, &bsd); if (error) return (error); @@ -1170,7 +1171,7 @@ linux_getrlimit(struct proc *p, struct linux_getrlimit_args *args) #endif /*!__alpha__*/ int -linux_sched_setscheduler(struct proc *p, +linux_sched_setscheduler(struct thread *td, struct linux_sched_setscheduler_args *args) { struct sched_setscheduler_args bsd; @@ -1197,11 +1198,11 @@ linux_sched_setscheduler(struct proc *p, bsd.pid = args->pid; bsd.param = (struct sched_param *)args->param; - return sched_setscheduler(p, &bsd); + return sched_setscheduler(td, &bsd); } int -linux_sched_getscheduler(struct proc *p, +linux_sched_getscheduler(struct thread *td, struct linux_sched_getscheduler_args *args) { struct sched_getscheduler_args bsd; @@ -1213,17 +1214,17 @@ linux_sched_getscheduler(struct proc *p, #endif bsd.pid = args->pid; - error = sched_getscheduler(p, &bsd); + error = sched_getscheduler(td, &bsd); - switch (p->p_retval[0]) { + switch (td->td_retval[0]) { case SCHED_OTHER: - p->p_retval[0] = LINUX_SCHED_OTHER; + td->td_retval[0] = LINUX_SCHED_OTHER; break; case SCHED_FIFO: - p->p_retval[0] = LINUX_SCHED_FIFO; + td->td_retval[0] = LINUX_SCHED_FIFO; break; case SCHED_RR: - p->p_retval[0] = LINUX_SCHED_RR; + td->td_retval[0] = LINUX_SCHED_RR; break; } @@ -1231,7 +1232,7 @@ linux_sched_getscheduler(struct proc *p, } int -linux_sched_get_priority_max(struct proc *p, +linux_sched_get_priority_max(struct thread *td, struct linux_sched_get_priority_max_args *args) { struct sched_get_priority_max_args bsd; @@ -1254,11 +1255,11 @@ linux_sched_get_priority_max(struct proc *p, default: return EINVAL; } - return sched_get_priority_max(p, &bsd); + return sched_get_priority_max(td, &bsd); } int -linux_sched_get_priority_min(struct proc *p, +linux_sched_get_priority_min(struct thread *td, struct linux_sched_get_priority_min_args *args) { struct sched_get_priority_min_args bsd; @@ -1281,7 +1282,7 @@ linux_sched_get_priority_min(struct proc *p, default: return EINVAL; } - return sched_get_priority_min(p, &bsd); + return sched_get_priority_min(td, &bsd); } #define REBOOT_CAD_ON 0x89abcdef @@ -1289,7 +1290,7 @@ linux_sched_get_priority_min(struct proc *p, #define REBOOT_HALT 0xcdef0123 int -linux_reboot(struct proc *p, struct linux_reboot_args *args) +linux_reboot(struct thread *td, struct linux_reboot_args *args) { struct reboot_args bsd_args; @@ -1300,12 +1301,12 @@ linux_reboot(struct proc *p, struct linux_reboot_args *args) if (args->cmd == REBOOT_CAD_ON || args->cmd == REBOOT_CAD_OFF) return (0); bsd_args.opt = (args->cmd == REBOOT_HALT) ? RB_HALT : 0; - return (reboot(p, &bsd_args)); + return (reboot(td, &bsd_args)); } /* * The FreeBSD native getpid(2), getgid(2) and getuid(2) also modify - * p->p_retval[1] when COMPAT_43 or COMPAT_SUNOS is defined. This + * td->td_retval[1] when COMPAT_43 or COMPAT_SUNOS is defined. This * globbers registers that are assumed to be preserved. The following * lightweight syscalls fixes this. See also linux_getgid16() and * linux_getuid16() in linux_uid16.c. @@ -1316,22 +1317,25 @@ linux_reboot(struct proc *p, struct linux_reboot_args *args) */ int -linux_getpid(struct proc *p, struct linux_getpid_args *args) +linux_getpid(struct thread *td, struct linux_getpid_args *args) { - p->p_retval[0] = p->p_pid; + + td->td_retval[0] = td->td_proc->p_pid; return (0); } int -linux_getgid(struct proc *p, struct linux_getgid_args *args) +linux_getgid(struct thread *td, struct linux_getgid_args *args) { - p->p_retval[0] = p->p_ucred->cr_rgid; + + td->td_retval[0] = td->td_proc->p_ucred->cr_rgid; return (0); } int -linux_getuid(struct proc *p, struct linux_getuid_args *args) +linux_getuid(struct thread *td, struct linux_getuid_args *args) { - p->p_retval[0] = p->p_ucred->cr_ruid; + + td->td_retval[0] = td->td_proc->p_ucred->cr_ruid; return (0); } diff --git a/sys/compat/linux/linux_signal.c b/sys/compat/linux/linux_signal.c index 24a540f..ccc30f0 100644 --- a/sys/compat/linux/linux_signal.c +++ b/sys/compat/linux/linux_signal.c @@ -131,7 +131,7 @@ bsd_to_linux_sigaction(struct sigaction *bsa, l_sigaction_t *lsa) } int -linux_do_sigaction(struct proc *p, int linux_sig, l_sigaction_t *linux_nsa, +linux_do_sigaction(struct thread *td, int linux_sig, l_sigaction_t *linux_nsa, l_sigaction_t *linux_osa) { struct sigaction *nsa, *osa; @@ -163,7 +163,7 @@ linux_do_sigaction(struct proc *p, int linux_sig, l_sigaction_t *linux_nsa, sa_args.act = nsa; sa_args.oact = osa; - error = sigaction(p, &sa_args); + error = sigaction(td, &sa_args); if (error) return (error); @@ -176,7 +176,7 @@ linux_do_sigaction(struct proc *p, int linux_sig, l_sigaction_t *linux_nsa, #ifndef __alpha__ int -linux_signal(struct proc *p, struct linux_signal_args *args) +linux_signal(struct thread *td, struct linux_signal_args *args) { l_sigaction_t nsa, osa; int error; @@ -191,15 +191,15 @@ linux_signal(struct proc *p, struct linux_signal_args *args) nsa.lsa_flags = LINUX_SA_ONESHOT | LINUX_SA_NOMASK; LINUX_SIGEMPTYSET(nsa.lsa_mask); - error = linux_do_sigaction(p, args->sig, &nsa, &osa); - p->p_retval[0] = (int)osa.lsa_handler; + error = linux_do_sigaction(td, args->sig, &nsa, &osa); + td->td_retval[0] = (int)osa.lsa_handler; return (error); } #endif /*!__alpha__*/ int -linux_rt_sigaction(struct proc *p, struct linux_rt_sigaction_args *args) +linux_rt_sigaction(struct thread *td, struct linux_rt_sigaction_args *args) { l_sigaction_t nsa, osa; int error; @@ -220,7 +220,7 @@ linux_rt_sigaction(struct proc *p, struct linux_rt_sigaction_args *args) return (error); } - error = linux_do_sigaction(p, args->sig, + error = linux_do_sigaction(td, args->sig, args->act ? &nsa : NULL, args->oact ? &osa : NULL); @@ -232,14 +232,15 @@ linux_rt_sigaction(struct proc *p, struct linux_rt_sigaction_args *args) } static int -linux_do_sigprocmask(struct proc *p, int how, l_sigset_t *new, +linux_do_sigprocmask(struct thread *td, int how, l_sigset_t *new, l_sigset_t *old) { int error; sigset_t mask; + struct proc *p = td->td_proc; error = 0; - p->p_retval[0] = 0; + td->td_retval[0] = 0; PROC_LOCK(p); if (old != NULL) @@ -272,7 +273,7 @@ linux_do_sigprocmask(struct proc *p, int how, l_sigset_t *new, #ifndef __alpha__ int -linux_sigprocmask(struct proc *p, struct linux_sigprocmask_args *args) +linux_sigprocmask(struct thread *td, struct linux_sigprocmask_args *args) { l_osigset_t mask; l_sigset_t set, oset; @@ -291,7 +292,7 @@ linux_sigprocmask(struct proc *p, struct linux_sigprocmask_args *args) set.__bits[0] = mask; } - error = linux_do_sigprocmask(p, args->how, + error = linux_do_sigprocmask(td, args->how, args->mask ? &set : NULL, args->omask ? &oset : NULL); @@ -305,7 +306,7 @@ linux_sigprocmask(struct proc *p, struct linux_sigprocmask_args *args) #endif /*!__alpha__*/ int -linux_rt_sigprocmask(struct proc *p, struct linux_rt_sigprocmask_args *args) +linux_rt_sigprocmask(struct thread *td, struct linux_rt_sigprocmask_args *args) { l_sigset_t set, oset; int error; @@ -326,7 +327,7 @@ linux_rt_sigprocmask(struct proc *p, struct linux_rt_sigprocmask_args *args) return (error); } - error = linux_do_sigprocmask(p, args->how, + error = linux_do_sigprocmask(td, args->how, args->mask ? &set : NULL, args->omask ? &oset : NULL); @@ -339,8 +340,9 @@ linux_rt_sigprocmask(struct proc *p, struct linux_rt_sigprocmask_args *args) #ifndef __alpha__ int -linux_sgetmask(struct proc *p, struct linux_sgetmask_args *args) +linux_sgetmask(struct thread *td, struct linux_sgetmask_args *args) { + struct proc *p = td->td_proc; l_sigset_t mask; #ifdef DEBUG @@ -351,13 +353,14 @@ linux_sgetmask(struct proc *p, struct linux_sgetmask_args *args) PROC_LOCK(p); bsd_to_linux_sigset(&p->p_sigmask, &mask); PROC_UNLOCK(p); - p->p_retval[0] = mask.__bits[0]; + td->td_retval[0] = mask.__bits[0]; return (0); } int -linux_ssetmask(struct proc *p, struct linux_ssetmask_args *args) +linux_ssetmask(struct thread *td, struct linux_ssetmask_args *args) { + struct proc *p = td->td_proc; l_sigset_t lset; sigset_t bset; @@ -368,7 +371,7 @@ linux_ssetmask(struct proc *p, struct linux_ssetmask_args *args) PROC_LOCK(p); bsd_to_linux_sigset(&p->p_sigmask, &lset); - p->p_retval[0] = lset.__bits[0]; + td->td_retval[0] = lset.__bits[0]; LINUX_SIGEMPTYSET(lset); lset.__bits[0] = args->mask; linux_to_bsd_sigset(&lset, &bset); @@ -379,8 +382,9 @@ linux_ssetmask(struct proc *p, struct linux_ssetmask_args *args) } int -linux_sigpending(struct proc *p, struct linux_sigpending_args *args) +linux_sigpending(struct thread *td, struct linux_sigpending_args *args) { + struct proc *p = td->td_proc; sigset_t bset; l_sigset_t lset; l_osigset_t mask; @@ -401,7 +405,7 @@ linux_sigpending(struct proc *p, struct linux_sigpending_args *args) #endif /*!__alpha__*/ int -linux_kill(struct proc *p, struct linux_kill_args *args) +linux_kill(struct thread *td, struct linux_kill_args *args) { struct kill_args /* { int pid; @@ -427,5 +431,5 @@ linux_kill(struct proc *p, struct linux_kill_args *args) tmp.signum = args->signum; tmp.pid = args->pid; - return (kill(p, &tmp)); + return (kill(td, &tmp)); } diff --git a/sys/compat/linux/linux_signal.h b/sys/compat/linux/linux_signal.h index e9dcec0..8d0825b 100644 --- a/sys/compat/linux/linux_signal.h +++ b/sys/compat/linux/linux_signal.h @@ -33,7 +33,7 @@ void linux_to_bsd_sigset __P((l_sigset_t *, sigset_t *)); void bsd_to_linux_sigset __P((sigset_t *, l_sigset_t *)); -int linux_do_sigaction __P((struct proc *, int, l_sigaction_t *, +int linux_do_sigaction __P((struct thread *, int, l_sigaction_t *, l_sigaction_t *)); #endif /* _LINUX_SIGNAL_H_ */ diff --git a/sys/compat/linux/linux_socket.c b/sys/compat/linux/linux_socket.c index ac73dde..de74054 100644 --- a/sys/compat/linux/linux_socket.c +++ b/sys/compat/linux/linux_socket.c @@ -187,7 +187,7 @@ linux_to_bsd_msg_flags(int flags) /* Return 0 if IP_HDRINCL is set for the given socket. */ static int -linux_check_hdrincl(struct proc *p, int s) +linux_check_hdrincl(struct thread *td, int s) { struct getsockopt_args /* { int s; @@ -213,7 +213,7 @@ linux_check_hdrincl(struct proc *p, int s) bsd_args.name = IP_HDRINCL; bsd_args.val = val; bsd_args.avalsize = (int *)valsize; - if ((error = getsockopt(p, &bsd_args))) + if ((error = getsockopt(td, &bsd_args))) return (error); if ((error = copyin(val, &optval, sizeof(optval)))) @@ -227,7 +227,7 @@ linux_check_hdrincl(struct proc *p, int s) * tweak endian-dependent fields in the IP packet. */ static int -linux_sendto_hdrincl(struct proc *p, struct sendto_args *bsd_args) +linux_sendto_hdrincl(struct thread *td, struct sendto_args *bsd_args) { /* * linux_ip_copysize defines how many bytes we should copy @@ -288,7 +288,7 @@ linux_sendto_hdrincl(struct proc *p, struct sendto_args *bsd_args) sendmsg_args.s = bsd_args->s; sendmsg_args.msg = (caddr_t)msg; sendmsg_args.flags = bsd_args->flags; - return (sendmsg(p, &sendmsg_args)); + return (sendmsg(td, &sendmsg_args)); } struct linux_socket_args { @@ -298,7 +298,7 @@ struct linux_socket_args { }; static int -linux_socket(struct proc *p, struct linux_socket_args *args) +linux_socket(struct thread *td, struct linux_socket_args *args) { struct linux_socket_args linux_args; struct socket_args /* { @@ -318,7 +318,7 @@ linux_socket(struct proc *p, struct linux_socket_args *args) if (bsd_args.domain == -1) return (EINVAL); - retval_socket = socket(p, &bsd_args); + retval_socket = socket(td, &bsd_args); if (bsd_args.type == SOCK_RAW && (bsd_args.protocol == IPPROTO_RAW || bsd_args.protocol == 0) && bsd_args.domain == AF_INET @@ -337,15 +337,15 @@ linux_socket(struct proc *p, struct linux_socket_args *args) sg = stackgap_init(); hdrincl = (int *)stackgap_alloc(&sg, sizeof(*hdrincl)); *hdrincl = 1; - bsd_setsockopt_args.s = p->p_retval[0]; + bsd_setsockopt_args.s = td->td_retval[0]; bsd_setsockopt_args.level = IPPROTO_IP; bsd_setsockopt_args.name = IP_HDRINCL; bsd_setsockopt_args.val = (caddr_t)hdrincl; bsd_setsockopt_args.valsize = sizeof(*hdrincl); /* We ignore any error returned by setsockopt() */ - setsockopt(p, &bsd_setsockopt_args); + setsockopt(td, &bsd_setsockopt_args); /* Copy back the return value from socket() */ - p->p_retval[0] = bsd_setsockopt_args.s; + td->td_retval[0] = bsd_setsockopt_args.s; } return (retval_socket); @@ -358,7 +358,7 @@ struct linux_bind_args { }; static int -linux_bind(struct proc *p, struct linux_bind_args *args) +linux_bind(struct thread *td, struct linux_bind_args *args) { struct linux_bind_args linux_args; struct bind_args /* { @@ -374,7 +374,7 @@ linux_bind(struct proc *p, struct linux_bind_args *args) bsd_args.s = linux_args.s; bsd_args.name = (caddr_t)linux_args.name; bsd_args.namelen = linux_args.namelen; - return (bind(p, &bsd_args)); + return (bind(td, &bsd_args)); } struct linux_connect_args { @@ -382,11 +382,11 @@ struct linux_connect_args { struct sockaddr * name; int namelen; }; -int linux_connect(struct proc *, struct linux_connect_args *); +int linux_connect(struct thread *, struct linux_connect_args *); #endif /* !__alpha__*/ int -linux_connect(struct proc *p, struct linux_connect_args *args) +linux_connect(struct thread *td, struct linux_connect_args *args) { struct linux_connect_args linux_args; struct connect_args /* { @@ -408,7 +408,7 @@ linux_connect(struct proc *p, struct linux_connect_args *args) bsd_args.s = linux_args.s; bsd_args.name = (caddr_t)linux_args.name; bsd_args.namelen = linux_args.namelen; - error = connect(p, &bsd_args); + error = connect(td, &bsd_args); if (error != EISCONN) return (error); @@ -417,7 +417,7 @@ linux_connect(struct proc *p, struct linux_connect_args *args) * when on a non-blocking socket. Instead it returns the * error getsockopt(SOL_SOCKET, SO_ERROR) would return on BSD. */ - error = holdsock(p->p_fd, linux_args.s, &fp); + error = holdsock(td->td_proc->p_fd, linux_args.s, &fp); if (error) return (error); error = EISCONN; @@ -427,7 +427,7 @@ linux_connect(struct proc *p, struct linux_connect_args *args) error = so->so_error; so->so_emuldata = (void *)1; } - fdrop(fp, p); + fdrop(fp, td); return (error); } @@ -439,7 +439,7 @@ struct linux_listen_args { }; static int -linux_listen(struct proc *p, struct linux_listen_args *args) +linux_listen(struct thread *td, struct linux_listen_args *args) { struct linux_listen_args linux_args; struct listen_args /* { @@ -453,7 +453,7 @@ linux_listen(struct proc *p, struct linux_listen_args *args) bsd_args.s = linux_args.s; bsd_args.backlog = linux_args.backlog; - return (listen(p, &bsd_args)); + return (listen(td, &bsd_args)); } struct linux_accept_args { @@ -463,7 +463,7 @@ struct linux_accept_args { }; static int -linux_accept(struct proc *p, struct linux_accept_args *args) +linux_accept(struct thread *td, struct linux_accept_args *args) { struct linux_accept_args linux_args; struct accept_args /* { @@ -484,7 +484,7 @@ linux_accept(struct proc *p, struct linux_accept_args *args) bsd_args.s = linux_args.s; bsd_args.name = (caddr_t)linux_args.addr; bsd_args.anamelen = linux_args.namelen; - error = oaccept(p, &bsd_args); + error = oaccept(td, &bsd_args); if (error) return (error); @@ -493,11 +493,11 @@ linux_accept(struct proc *p, struct linux_accept_args *args) * accepted one, so we must clear the flags in the new descriptor. * Ignore any errors, because we already have an open fd. */ - f_args.fd = p->p_retval[0]; + f_args.fd = td->td_retval[0]; f_args.cmd = F_SETFL; f_args.arg = 0; - (void)fcntl(p, &f_args); - p->p_retval[0] = f_args.fd; + (void)fcntl(td, &f_args); + td->td_retval[0] = f_args.fd; return (0); } @@ -508,7 +508,7 @@ struct linux_getsockname_args { }; static int -linux_getsockname(struct proc *p, struct linux_getsockname_args *args) +linux_getsockname(struct thread *td, struct linux_getsockname_args *args) { struct linux_getsockname_args linux_args; struct getsockname_args /* { @@ -524,7 +524,7 @@ linux_getsockname(struct proc *p, struct linux_getsockname_args *args) bsd_args.fdes = linux_args.s; bsd_args.asa = (caddr_t) linux_args.addr; bsd_args.alen = linux_args.namelen; - return (ogetsockname(p, &bsd_args)); + return (ogetsockname(td, &bsd_args)); } struct linux_getpeername_args { @@ -534,7 +534,7 @@ struct linux_getpeername_args { }; static int -linux_getpeername(struct proc *p, struct linux_getpeername_args *args) +linux_getpeername(struct thread *td, struct linux_getpeername_args *args) { struct linux_getpeername_args linux_args; struct ogetpeername_args /* { @@ -550,7 +550,7 @@ linux_getpeername(struct proc *p, struct linux_getpeername_args *args) bsd_args.fdes = linux_args.s; bsd_args.asa = (caddr_t) linux_args.addr; bsd_args.alen = linux_args.namelen; - return (ogetpeername(p, &bsd_args)); + return (ogetpeername(td, &bsd_args)); } struct linux_socketpair_args { @@ -561,7 +561,7 @@ struct linux_socketpair_args { }; static int -linux_socketpair(struct proc *p, struct linux_socketpair_args *args) +linux_socketpair(struct thread *td, struct linux_socketpair_args *args) { struct linux_socketpair_args linux_args; struct socketpair_args /* { @@ -582,7 +582,7 @@ linux_socketpair(struct proc *p, struct linux_socketpair_args *args) bsd_args.type = linux_args.type; bsd_args.protocol = linux_args.protocol; bsd_args.rsv = linux_args.rsv; - return (socketpair(p, &bsd_args)); + return (socketpair(td, &bsd_args)); } struct linux_send_args { @@ -593,7 +593,7 @@ struct linux_send_args { }; static int -linux_send(struct proc *p, struct linux_send_args *args) +linux_send(struct thread *td, struct linux_send_args *args) { struct linux_send_args linux_args; struct osend_args /* { @@ -611,7 +611,7 @@ linux_send(struct proc *p, struct linux_send_args *args) bsd_args.buf = linux_args.msg; bsd_args.len = linux_args.len; bsd_args.flags = linux_args.flags; - return (osend(p, &bsd_args)); + return (osend(td, &bsd_args)); } struct linux_recv_args { @@ -622,7 +622,7 @@ struct linux_recv_args { }; static int -linux_recv(struct proc *p, struct linux_recv_args *args) +linux_recv(struct thread *td, struct linux_recv_args *args) { struct linux_recv_args linux_args; struct orecv_args /* { @@ -640,7 +640,7 @@ linux_recv(struct proc *p, struct linux_recv_args *args) bsd_args.buf = linux_args.msg; bsd_args.len = linux_args.len; bsd_args.flags = linux_args.flags; - return (orecv(p, &bsd_args)); + return (orecv(td, &bsd_args)); } struct linux_sendto_args { @@ -653,7 +653,7 @@ struct linux_sendto_args { }; static int -linux_sendto(struct proc *p, struct linux_sendto_args *args) +linux_sendto(struct thread *td, struct linux_sendto_args *args) { struct linux_sendto_args linux_args; struct sendto_args /* { @@ -676,11 +676,11 @@ linux_sendto(struct proc *p, struct linux_sendto_args *args) bsd_args.to = linux_args.to; bsd_args.tolen = linux_args.tolen; - if (linux_check_hdrincl(p, linux_args.s) == 0) + if (linux_check_hdrincl(td, linux_args.s) == 0) /* IP_HDRINCL set, tweak the packet before sending */ - return (linux_sendto_hdrincl(p, &bsd_args)); + return (linux_sendto_hdrincl(td, &bsd_args)); - return (sendto(p, &bsd_args)); + return (sendto(td, &bsd_args)); } struct linux_recvfrom_args { @@ -693,7 +693,7 @@ struct linux_recvfrom_args { }; static int -linux_recvfrom(struct proc *p, struct linux_recvfrom_args *args) +linux_recvfrom(struct thread *td, struct linux_recvfrom_args *args) { struct linux_recvfrom_args linux_args; struct recvfrom_args /* { @@ -715,7 +715,7 @@ linux_recvfrom(struct proc *p, struct linux_recvfrom_args *args) bsd_args.flags = linux_to_bsd_msg_flags(linux_args.flags); bsd_args.from = linux_args.from; bsd_args.fromlenaddr = linux_args.fromlen; - return (orecvfrom(p, &bsd_args)); + return (orecvfrom(td, &bsd_args)); } struct linux_recvmsg_args { @@ -725,7 +725,7 @@ struct linux_recvmsg_args { }; static int -linux_recvmsg(struct proc *p, struct linux_recvmsg_args *args) +linux_recvmsg(struct thread *td, struct linux_recvmsg_args *args) { struct linux_recvmsg_args linux_args; struct recvmsg_args /* { @@ -741,7 +741,7 @@ linux_recvmsg(struct proc *p, struct linux_recvmsg_args *args) bsd_args.s = linux_args.s; bsd_args.msg = linux_args.msg; bsd_args.flags = linux_to_bsd_msg_flags(linux_args.flags); - return (recvmsg(p, &bsd_args)); + return (recvmsg(td, &bsd_args)); } struct linux_shutdown_args { @@ -750,7 +750,7 @@ struct linux_shutdown_args { }; static int -linux_shutdown(struct proc *p, struct linux_shutdown_args *args) +linux_shutdown(struct thread *td, struct linux_shutdown_args *args) { struct linux_shutdown_args linux_args; struct shutdown_args /* { @@ -764,7 +764,7 @@ linux_shutdown(struct proc *p, struct linux_shutdown_args *args) bsd_args.s = linux_args.s; bsd_args.how = linux_args.how; - return (shutdown(p, &bsd_args)); + return (shutdown(td, &bsd_args)); } struct linux_setsockopt_args { @@ -776,7 +776,7 @@ struct linux_setsockopt_args { }; static int -linux_setsockopt(struct proc *p, struct linux_setsockopt_args *args) +linux_setsockopt(struct thread *td, struct linux_setsockopt_args *args) { struct linux_setsockopt_args linux_args; struct setsockopt_args /* { @@ -814,7 +814,7 @@ linux_setsockopt(struct proc *p, struct linux_setsockopt_args *args) bsd_args.name = name; bsd_args.val = linux_args.optval; bsd_args.valsize = linux_args.optlen; - return (setsockopt(p, &bsd_args)); + return (setsockopt(td, &bsd_args)); } struct linux_getsockopt_args { @@ -826,7 +826,7 @@ struct linux_getsockopt_args { }; static int -linux_getsockopt(struct proc *p, struct linux_getsockopt_args *args) +linux_getsockopt(struct thread *td, struct linux_getsockopt_args *args) { struct linux_getsockopt_args linux_args; struct getsockopt_args /* { @@ -864,45 +864,45 @@ linux_getsockopt(struct proc *p, struct linux_getsockopt_args *args) bsd_args.name = name; bsd_args.val = linux_args.optval; bsd_args.avalsize = linux_args.optlen; - return (getsockopt(p, &bsd_args)); + return (getsockopt(td, &bsd_args)); } int -linux_socketcall(struct proc *p, struct linux_socketcall_args *args) +linux_socketcall(struct thread *td, struct linux_socketcall_args *args) { void *arg = (void *)args->args; switch (args->what) { case LINUX_SOCKET: - return (linux_socket(p, arg)); + return (linux_socket(td, arg)); case LINUX_BIND: - return (linux_bind(p, arg)); + return (linux_bind(td, arg)); case LINUX_CONNECT: - return (linux_connect(p, arg)); + return (linux_connect(td, arg)); case LINUX_LISTEN: - return (linux_listen(p, arg)); + return (linux_listen(td, arg)); case LINUX_ACCEPT: - return (linux_accept(p, arg)); + return (linux_accept(td, arg)); case LINUX_GETSOCKNAME: - return (linux_getsockname(p, arg)); + return (linux_getsockname(td, arg)); case LINUX_GETPEERNAME: - return (linux_getpeername(p, arg)); + return (linux_getpeername(td, arg)); case LINUX_SOCKETPAIR: - return (linux_socketpair(p, arg)); + return (linux_socketpair(td, arg)); case LINUX_SEND: - return (linux_send(p, arg)); + return (linux_send(td, arg)); case LINUX_RECV: - return (linux_recv(p, arg)); + return (linux_recv(td, arg)); case LINUX_SENDTO: - return (linux_sendto(p, arg)); + return (linux_sendto(td, arg)); case LINUX_RECVFROM: - return (linux_recvfrom(p, arg)); + return (linux_recvfrom(td, arg)); case LINUX_SHUTDOWN: - return (linux_shutdown(p, arg)); + return (linux_shutdown(td, arg)); case LINUX_SETSOCKOPT: - return (linux_setsockopt(p, arg)); + return (linux_setsockopt(td, arg)); case LINUX_GETSOCKOPT: - return (linux_getsockopt(p, arg)); + return (linux_getsockopt(td, arg)); case LINUX_SENDMSG: do { int error; @@ -940,10 +940,10 @@ linux_socketcall(struct proc *p, struct linux_socketcall_args *args) return (error); } done: - return (sendmsg(p, arg)); + return (sendmsg(td, arg)); } while (0); case LINUX_RECVMSG: - return (linux_recvmsg(p, arg)); + return (linux_recvmsg(td, arg)); } uprintf("LINUX: 'socket' typ=%d not implemented\n", args->what); diff --git a/sys/compat/linux/linux_stats.c b/sys/compat/linux/linux_stats.c index 5d1572b..d0c8ea2 100644 --- a/sys/compat/linux/linux_stats.c +++ b/sys/compat/linux/linux_stats.c @@ -87,7 +87,7 @@ newstat_copyout(struct stat *buf, void *ubuf) } int -linux_newstat(struct proc *p, struct linux_newstat_args *args) +linux_newstat(struct thread *td, struct linux_newstat_args *args) { struct stat buf; struct nameidata nd; @@ -95,7 +95,7 @@ linux_newstat(struct proc *p, struct linux_newstat_args *args) caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(newstat)) @@ -103,13 +103,13 @@ linux_newstat(struct proc *p, struct linux_newstat_args *args) #endif NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - args->path, p); + args->path, td); error = namei(&nd); if (error) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = vn_stat(nd.ni_vp, &buf, p); + error = vn_stat(nd.ni_vp, &buf, td); vput(nd.ni_vp); if (error) return (error); @@ -118,7 +118,7 @@ linux_newstat(struct proc *p, struct linux_newstat_args *args) } int -linux_newlstat(struct proc *p, struct linux_newlstat_args *args) +linux_newlstat(struct thread *td, struct linux_newlstat_args *args) { int error; struct stat sb; @@ -126,7 +126,7 @@ linux_newlstat(struct proc *p, struct linux_newlstat_args *args) caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(newlstat)) @@ -134,13 +134,13 @@ linux_newlstat(struct proc *p, struct linux_newlstat_args *args) #endif NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - args->path, p); + args->path, td); error = namei(&nd); if (error) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = vn_stat(nd.ni_vp, &sb, p); + error = vn_stat(nd.ni_vp, &sb, td); vput(nd.ni_vp); if (error) return (error); @@ -149,7 +149,7 @@ linux_newlstat(struct proc *p, struct linux_newlstat_args *args) } int -linux_newfstat(struct proc *p, struct linux_newfstat_args *args) +linux_newfstat(struct thread *td, struct linux_newfstat_args *args) { struct filedesc *fdp; struct file *fp; @@ -161,12 +161,12 @@ linux_newfstat(struct proc *p, struct linux_newfstat_args *args) printf(ARGS(newfstat, "%d, *"), args->fd); #endif - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if ((unsigned)args->fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[args->fd]) == NULL) return (EBADF); - error = fo_stat(fp, &buf, p); + error = fo_stat(fp, &buf, td); if (!error) error = newstat_copyout(&buf, args->buf); @@ -235,7 +235,7 @@ bsd_to_linux_ftype(int tag) } int -linux_statfs(struct proc *p, struct linux_statfs_args *args) +linux_statfs(struct thread *td, struct linux_statfs_args *args) { struct mount *mp; struct nameidata *ndp; @@ -246,14 +246,14 @@ linux_statfs(struct proc *p, struct linux_statfs_args *args) caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(statfs)) printf(ARGS(statfs, "%s, *"), args->path); #endif ndp = &nd; - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args->path, curproc); + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args->path, curthread); error = namei(ndp); if (error) return error; @@ -261,7 +261,7 @@ linux_statfs(struct proc *p, struct linux_statfs_args *args) mp = ndp->ni_vp->v_mount; bsd_statfs = &mp->mnt_stat; vrele(ndp->ni_vp); - error = VFS_STATFS(mp, bsd_statfs, p); + error = VFS_STATFS(mp, bsd_statfs, td); if (error) return error; bsd_statfs->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; @@ -280,7 +280,7 @@ linux_statfs(struct proc *p, struct linux_statfs_args *args) } int -linux_fstatfs(struct proc *p, struct linux_fstatfs_args *args) +linux_fstatfs(struct thread *td, struct linux_fstatfs_args *args) { struct file *fp; struct mount *mp; @@ -292,12 +292,12 @@ linux_fstatfs(struct proc *p, struct linux_fstatfs_args *args) if (ldebug(fstatfs)) printf(ARGS(fstatfs, "%d, *"), args->fd); #endif - error = getvnode(p->p_fd, args->fd, &fp); + error = getvnode(td->td_proc->p_fd, args->fd, &fp); if (error) return error; mp = ((struct vnode *)fp->f_data)->v_mount; bsd_statfs = &mp->mnt_stat; - error = VFS_STATFS(mp, bsd_statfs, p); + error = VFS_STATFS(mp, bsd_statfs, td); if (error) return error; bsd_statfs->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; @@ -324,7 +324,7 @@ struct l_ustat }; int -linux_ustat(struct proc *p, struct linux_ustat_args *args) +linux_ustat(struct thread *td, struct linux_ustat_args *args) { struct l_ustat lu; dev_t dev; @@ -355,7 +355,7 @@ linux_ustat(struct proc *p, struct linux_ustat_args *args) if (vp->v_mount == NULL) return (EINVAL); stat = &(vp->v_mount->mnt_stat); - error = VFS_STATFS(vp->v_mount, stat, p); + error = VFS_STATFS(vp->v_mount, stat, td); if (error) return (error); @@ -400,7 +400,7 @@ stat64_copyout(struct stat *buf, void *ubuf) } int -linux_stat64(struct proc *p, struct linux_stat64_args *args) +linux_stat64(struct thread *td, struct linux_stat64_args *args) { struct stat buf; struct nameidata nd; @@ -408,7 +408,7 @@ linux_stat64(struct proc *p, struct linux_stat64_args *args) caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->filename); + CHECKALTEXIST(td, &sg, args->filename); #ifdef DEBUG if (ldebug(stat64)) @@ -416,13 +416,13 @@ linux_stat64(struct proc *p, struct linux_stat64_args *args) #endif NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - args->filename, p); + args->filename, td); error = namei(&nd); if (error) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = vn_stat(nd.ni_vp, &buf, p); + error = vn_stat(nd.ni_vp, &buf, td); vput(nd.ni_vp); if (error) return (error); @@ -431,7 +431,7 @@ linux_stat64(struct proc *p, struct linux_stat64_args *args) } int -linux_lstat64(struct proc *p, struct linux_lstat64_args *args) +linux_lstat64(struct thread *td, struct linux_lstat64_args *args) { int error; struct stat sb; @@ -439,7 +439,7 @@ linux_lstat64(struct proc *p, struct linux_lstat64_args *args) caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->filename); + CHECKALTEXIST(td, &sg, args->filename); #ifdef DEBUG if (ldebug(lstat64)) @@ -447,13 +447,13 @@ linux_lstat64(struct proc *p, struct linux_lstat64_args *args) #endif NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - args->filename, p); + args->filename, td); error = namei(&nd); if (error) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = vn_stat(nd.ni_vp, &sb, p); + error = vn_stat(nd.ni_vp, &sb, td); vput(nd.ni_vp); if (error) return (error); @@ -462,7 +462,7 @@ linux_lstat64(struct proc *p, struct linux_lstat64_args *args) } int -linux_fstat64(struct proc *p, struct linux_fstat64_args *args) +linux_fstat64(struct thread *td, struct linux_fstat64_args *args) { struct filedesc *fdp; struct file *fp; @@ -474,12 +474,12 @@ linux_fstat64(struct proc *p, struct linux_fstat64_args *args) printf(ARGS(fstat64, "%d, *"), args->fd); #endif - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if ((unsigned)args->fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[args->fd]) == NULL) return (EBADF); - error = fo_stat(fp, &buf, p); + error = fo_stat(fp, &buf, td); if (!error) error = stat64_copyout(&buf, args->statbuf); diff --git a/sys/compat/linux/linux_sysctl.c b/sys/compat/linux/linux_sysctl.c index 14c5a6f..98dab20 100644 --- a/sys/compat/linux/linux_sysctl.c +++ b/sys/compat/linux/linux_sysctl.c @@ -75,7 +75,7 @@ handle_string(struct l___sysctl_args *la, char *value) } int -linux_sysctl(struct proc *p, struct linux_sysctl_args *args) +linux_sysctl(struct thread *td, struct linux_sysctl_args *args) { struct l___sysctl_args la; l_int *mib; diff --git a/sys/compat/linux/linux_uid16.c b/sys/compat/linux/linux_uid16.c index c6a1c12..80e5763 100644 --- a/sys/compat/linux/linux_uid16.c +++ b/sys/compat/linux/linux_uid16.c @@ -43,13 +43,13 @@ DUMMY(getresuid16); DUMMY(getresgid16); int -linux_chown16(struct proc *p, struct linux_chown16_args *args) +linux_chown16(struct thread *td, struct linux_chown16_args *args) { struct chown_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(chown16)) @@ -60,17 +60,17 @@ linux_chown16(struct proc *p, struct linux_chown16_args *args) bsd.path = args->path; bsd.uid = args->uid; bsd.gid = args->gid; - return (chown(p, &bsd)); + return (chown(td, &bsd)); } int -linux_lchown16(struct proc *p, struct linux_lchown16_args *args) +linux_lchown16(struct thread *td, struct linux_lchown16_args *args) { struct lchown_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(lchown16)) @@ -81,11 +81,11 @@ linux_lchown16(struct proc *p, struct linux_lchown16_args *args) bsd.path = args->path; bsd.uid = args->uid; bsd.gid = args->gid; - return (lchown(p, &bsd)); + return (lchown(td, &bsd)); } int -linux_setgroups16(struct proc *p, struct linux_setgroups16_args *args) +linux_setgroups16(struct thread *td, struct linux_setgroups16_args *args) { struct ucred *newcred, *oldcred; l_gid16_t linux_gidset[NGROUPS]; @@ -98,7 +98,7 @@ linux_setgroups16(struct proc *p, struct linux_setgroups16_args *args) #endif ngrp = args->gidsetsize; - oldcred = p->p_ucred; + oldcred = td->td_proc->p_ucred; /* * cr_groups[0] holds egid. Setting the whole set from @@ -131,14 +131,14 @@ linux_setgroups16(struct proc *p, struct linux_setgroups16_args *args) else newcred->cr_ngroups = 1; - setsugid(p); - p->p_ucred = newcred; + setsugid(td->td_proc); + td->td_proc->p_ucred = newcred; crfree(oldcred); return (0); } int -linux_getgroups16(struct proc *p, struct linux_getgroups16_args *args) +linux_getgroups16(struct thread *td, struct linux_getgroups16_args *args) { struct ucred *cred; l_gid16_t linux_gidset[NGROUPS]; @@ -150,7 +150,7 @@ linux_getgroups16(struct proc *p, struct linux_getgroups16_args *args) printf(ARGS(getgroups16, "%d, *"), args->gidsetsize); #endif - cred = p->p_ucred; + cred = td->td_proc->p_ucred; bsd_gidset = cred->cr_groups; bsd_gidsetsz = cred->cr_ngroups - 1; @@ -161,7 +161,7 @@ linux_getgroups16(struct proc *p, struct linux_getgroups16_args *args) */ if ((ngrp = args->gidsetsize) == 0) { - p->p_retval[0] = bsd_gidsetsz; + td->td_retval[0] = bsd_gidsetsz; return (0); } @@ -179,12 +179,12 @@ linux_getgroups16(struct proc *p, struct linux_getgroups16_args *args) if (error) return (error); - p->p_retval[0] = ngrp; + td->td_retval[0] = ngrp; return (0); } /* - * The FreeBSD native getgid(2) and getuid(2) also modify p->p_retval[1] + * The FreeBSD native getgid(2) and getuid(2) also modify td->td_retval[1] * when COMPAT_43 or COMPAT_SUNOS is defined. This globbers registers that * are assumed to be preserved. The following lightweight syscalls fixes * this. See also linux_getpid(2), linux_getgid(2) and linux_getuid(2) in @@ -195,91 +195,93 @@ linux_getgroups16(struct proc *p, struct linux_getgroups16_args *args) */ int -linux_getgid16(struct proc *p, struct linux_getgid16_args *args) +linux_getgid16(struct thread *td, struct linux_getgid16_args *args) { - p->p_retval[0] = p->p_ucred->cr_rgid; + + td->td_retval[0] = td->td_proc->p_ucred->cr_rgid; return (0); } int -linux_getuid16(struct proc *p, struct linux_getuid16_args *args) +linux_getuid16(struct thread *td, struct linux_getuid16_args *args) { - p->p_retval[0] = p->p_ucred->cr_ruid; + + td->td_retval[0] = td->td_proc->p_ucred->cr_ruid; return (0); } int -linux_getegid16(struct proc *p, struct linux_getegid16_args *args) +linux_getegid16(struct thread *td, struct linux_getegid16_args *args) { struct getegid_args bsd; - return (getegid(p, &bsd)); + return (getegid(td, &bsd)); } int -linux_geteuid16(struct proc *p, struct linux_geteuid16_args *args) +linux_geteuid16(struct thread *td, struct linux_geteuid16_args *args) { struct geteuid_args bsd; - return (geteuid(p, &bsd)); + return (geteuid(td, &bsd)); } int -linux_setgid16(struct proc *p, struct linux_setgid16_args *args) +linux_setgid16(struct thread *td, struct linux_setgid16_args *args) { struct setgid_args bsd; bsd.gid = args->gid; - return (setgid(p, &bsd)); + return (setgid(td, &bsd)); } int -linux_setuid16(struct proc *p, struct linux_setuid16_args *args) +linux_setuid16(struct thread *td, struct linux_setuid16_args *args) { struct setuid_args bsd; bsd.uid = args->uid; - return (setuid(p, &bsd)); + return (setuid(td, &bsd)); } int -linux_setregid16(struct proc *p, struct linux_setregid16_args *args) +linux_setregid16(struct thread *td, struct linux_setregid16_args *args) { struct setregid_args bsd; bsd.rgid = args->rgid; bsd.egid = args->egid; - return (setregid(p, &bsd)); + return (setregid(td, &bsd)); } int -linux_setreuid16(struct proc *p, struct linux_setreuid16_args *args) +linux_setreuid16(struct thread *td, struct linux_setreuid16_args *args) { struct setreuid_args bsd; bsd.ruid = args->ruid; bsd.euid = args->euid; - return (setreuid(p, &bsd)); + return (setreuid(td, &bsd)); } int -linux_setresgid16(struct proc *p, struct linux_setresgid16_args *args) +linux_setresgid16(struct thread *td, struct linux_setresgid16_args *args) { struct setresgid_args bsd; bsd.rgid = args->rgid; bsd.egid = args->egid; bsd.sgid = args->sgid; - return (setresgid(p, &bsd)); + return (setresgid(td, &bsd)); } int -linux_setresuid16(struct proc *p, struct linux_setresuid16_args *args) +linux_setresuid16(struct thread *td, struct linux_setresuid16_args *args) { struct setresuid_args bsd; bsd.ruid = args->ruid; bsd.euid = args->euid; bsd.suid = args->suid; - return (setresuid(p, &bsd)); + return (setresuid(td, &bsd)); } diff --git a/sys/compat/linux/linux_util.c b/sys/compat/linux/linux_util.c index 6e14080..45c85b6 100644 --- a/sys/compat/linux/linux_util.c +++ b/sys/compat/linux/linux_util.c @@ -50,8 +50,8 @@ const char linux_emul_path[] = "/compat/linux"; * be in exists. */ int -linux_emul_find(p, sgp, prefix, path, pbuf, cflag) - struct proc *p; +linux_emul_find(td, sgp, prefix, path, pbuf, cflag) + struct thread *td; caddr_t *sgp; /* Pointer to stackgap memory */ const char *prefix; char *path; @@ -104,7 +104,7 @@ linux_emul_find(p, sgp, prefix, path, pbuf, cflag) for (cp = &ptr[len] - 1; *cp != '/'; cp--); *cp = '\0'; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, td); if ((error = namei(&nd)) != 0) { free(buf, M_TEMP); @@ -114,7 +114,7 @@ linux_emul_find(p, sgp, prefix, path, pbuf, cflag) *cp = '/'; } else { - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, td); if ((error = namei(&nd)) != 0) { free(buf, M_TEMP); @@ -130,7 +130,7 @@ linux_emul_find(p, sgp, prefix, path, pbuf, cflag) * to the emulation root directory. This is expensive :-( */ NDINIT(&ndroot, LOOKUP, FOLLOW, UIO_SYSSPACE, linux_emul_path, - p); + td); if ((error = namei(&ndroot)) != 0) { /* Cannot happen! */ @@ -140,11 +140,11 @@ linux_emul_find(p, sgp, prefix, path, pbuf, cflag) return error; } - if ((error = VOP_GETATTR(nd.ni_vp, &vat, p->p_ucred, p)) != 0) { + if ((error = VOP_GETATTR(nd.ni_vp, &vat, td->td_proc->p_ucred, td)) != 0) { goto bad; } - if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, p->p_ucred, p)) + if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, td->td_proc->p_ucred, td)) != 0) { goto bad; } diff --git a/sys/compat/linux/linux_util.h b/sys/compat/linux/linux_util.h index 81bacc2..b79b5b6 100644 --- a/sys/compat/linux/linux_util.h +++ b/sys/compat/linux/linux_util.h @@ -52,7 +52,7 @@ static __inline caddr_t stackgap_init(void); static __inline void *stackgap_alloc(caddr_t *, size_t); -#define szsigcode (*(curproc->p_sysent->sv_szsigcode)) +#define szsigcode (*(curthread->td_proc->p_sysent->sv_szsigcode)) static __inline caddr_t stackgap_init() @@ -76,7 +76,7 @@ stackgap_alloc(sgp, sz) extern const char linux_emul_path[]; -int linux_emul_find __P((struct proc *, caddr_t *, const char *, char *, +int linux_emul_find __P((struct thread *, caddr_t *, const char *, char *, char **, int)); #define CHECKALT(p, sgp, path, i) \ @@ -94,18 +94,18 @@ int linux_emul_find __P((struct proc *, caddr_t *, const char *, char *, #define DUMMY(s) \ int \ -linux_ ## s(struct proc *p, struct linux_ ## s ## _args *args) \ +linux_ ## s(struct thread *p, struct linux_ ## s ## _args *args) \ { \ return (unsupported_msg(p, #s)); \ } \ struct __hack static __inline int -unsupported_msg(struct proc *p, const char *fname) +unsupported_msg(struct thread *td, const char *fname) { printf("linux: syscall %s is obsoleted or not implemented (pid=%ld)\n", - fname, (long)p->p_pid); + fname, (long)td->td_proc->p_pid); return (ENOSYS); } diff --git a/sys/compat/pecoff/imgact_pecoff.c b/sys/compat/pecoff/imgact_pecoff.c index 9d08513..3d6db4f 100644 --- a/sys/compat/pecoff/imgact_pecoff.c +++ b/sys/compat/pecoff/imgact_pecoff.c @@ -84,7 +84,7 @@ #define PECOFF_PE_SIGNATURE "PE\0\0" static int pecoff_fixup(register_t **, struct image_params *); static int -pecoff_coredump(register struct proc *, register struct vnode *, +pecoff_coredump(register struct thread *, register struct vnode *, off_t); #ifndef PECOFF_DEBUG #define DPRINTF(a) @@ -131,10 +131,10 @@ static int exec_pecoff_coff_makecmds(struct image_params *, struct coff_filehdr *, int); -static int pecoff_signature(struct proc *, struct vnode *, const struct pecoff_dos_filehdr *); -static int pecoff_read_from(struct proc *, struct vnode *, int, caddr_t, int); +static int pecoff_signature(struct thread *, struct vnode *, const struct pecoff_dos_filehdr *); +static int pecoff_read_from(struct thread *, struct vnode *, int, caddr_t, int); static int -pecoff_load_section(struct proc * p, +pecoff_load_section(struct thread * td, struct vmspace * vmspace, struct vnode * vp, vm_offset_t offset, caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot); @@ -160,11 +160,11 @@ pecoff_fixup(register_t ** stack_base, struct image_params * imgp) static int -pecoff_coredump(register struct proc * p, register struct vnode * vp, +pecoff_coredump(register struct thread * td, register struct vnode * vp, off_t limit) { - register struct ucred *cred = p->p_ucred; - register struct vmspace *vm = p->p_vmspace; + register struct ucred *cred = td->td_proc->p_ucred; + register struct vmspace *vm = td->td_proc->p_vmspace; int error; #ifdef PECOFF_DEBUG struct vm_map *map; @@ -172,12 +172,12 @@ pecoff_coredump(register struct proc * p, register struct vnode * vp, struct reg regs; #endif - if (ctob(UPAGES + vm->vm_dsize + vm->vm_ssize) >= limit) + if (ctob((UAREA_PAGES+KSTACK_PAGES) + vm->vm_dsize + vm->vm_ssize) >= limit) return (EFAULT); - fill_kinfo_proc(p, &p->p_addr->u_kproc); + fill_kinfo_proc(td->td_proc, &td->td_proc->p_uarea->u_kproc); #if PECOFF_DEBUG - fill_regs(p, ®s); + fill_regs(td, ®s); printf("EIP%x\n", regs.r_eip); printf("EAX%x EBX%x ECX%x EDI%x\n", regs.r_eax, regs.r_ebx, regs.r_ecx, regs.r_edi); @@ -185,23 +185,25 @@ pecoff_coredump(register struct proc * p, register struct vnode * vp, ent = &map->header; printf("%p %p %p\n", ent, ent->prev, ent->next); #endif - error = cpu_coredump(p, vp, cred); + error = cpu_coredump(td, vp, cred); if (error == 0) error = vn_rdwr_inchunks(UIO_WRITE, vp, vm->vm_daddr, - (int) ctob(vm->vm_dsize), (off_t) ctob(UPAGES), UIO_USERSPACE, - IO_UNIT, cred, (int *) NULL, p); + (int)ctob(vm->vm_dsize), + (off_t)ctob((UAREA_PAGES+KSTACK_PAGES)), + UIO_USERSPACE, IO_UNIT, cred, (int *)NULL, td); if (error == 0) error = vn_rdwr_inchunks(UIO_WRITE, vp, - (caddr_t) trunc_page(USRSTACK - ctob(vm->vm_ssize)), - round_page(ctob(vm->vm_ssize)), - (off_t) ctob(UPAGES) + ctob(vm->vm_dsize), UIO_USERSPACE, - IO_UNIT, cred, (int *) NULL, p); + (caddr_t)trunc_page(USRSTACK - ctob(vm->vm_ssize)), + round_page(ctob(vm->vm_ssize)), + (off_t)ctob((UAREA_PAGES+KSTACK_PAGES)) + + ctob(vm->vm_dsize), + UIO_USERSPACE, IO_UNIT, cred, (int *)NULL, td); return (error); } static int -pecoff_load_section(struct proc * p, struct vmspace * vmspace, struct vnode * vp, vm_offset_t offset, caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot) +pecoff_load_section(struct thread * td, struct vmspace * vmspace, struct vnode * vp, vm_offset_t offset, caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot) { size_t map_len; vm_offset_t map_addr; @@ -318,7 +320,7 @@ pecoff_load_section(struct proc * p, struct vmspace * vmspace, struct vnode * vp } static int -pecoff_load_file(struct proc * p, const char *file, u_long * addr, u_long * entry, u_long * ldexport) +pecoff_load_file(struct thread * td, const char *file, u_long * addr, u_long * entry, u_long * ldexport) { struct nameidata nd; @@ -327,7 +329,7 @@ pecoff_load_file(struct proc * p, const char *file, u_long * addr, u_long * entr struct coff_aouthdr *ap; struct pecoff_opthdr *wp; struct coff_scnhdr *sh = 0; - struct vmspace *vmspace = p->p_vmspace; + struct vmspace *vmspace = td->td_proc->p_vmspace; struct vattr attr; struct image_params image_params, *imgp; int peofs; @@ -337,12 +339,12 @@ pecoff_load_file(struct proc * p, const char *file, u_long * addr, u_long * entr /* * Initialize part of the common data */ - imgp->proc = p; + imgp->proc = td->td_proc; imgp->uap = NULL; imgp->attr = &attr; imgp->firstpage = NULL; - NDINIT(&nd, LOOKUP, LOCKLEAF | FOLLOW, UIO_SYSSPACE, file, p); + NDINIT(&nd, LOOKUP, LOCKLEAF | FOLLOW, UIO_SYSSPACE, file, td); if ((error = namei(&nd)) != 0) { nd.ni_vp = NULL; @@ -356,19 +358,19 @@ pecoff_load_file(struct proc * p, const char *file, u_long * addr, u_long * entr */ error = exec_check_permissions(imgp); if (error) { - VOP_UNLOCK(nd.ni_vp, 0, p); + VOP_UNLOCK(nd.ni_vp, 0, td); goto fail; } - VOP_UNLOCK(nd.ni_vp, 0, p); + VOP_UNLOCK(nd.ni_vp, 0, td); if (error) goto fail; - if ((error = pecoff_read_from(p, imgp->vp, 0, (caddr_t) & dh, sizeof(dh))) != 0) + if ((error = pecoff_read_from(td, imgp->vp, 0, (caddr_t) & dh, sizeof(dh))) != 0) goto fail; - if ((error = pecoff_signature(p, imgp->vp, &dh) != 0)) + if ((error = pecoff_signature(td, imgp->vp, &dh) != 0)) goto fail; fp = malloc(PECOFF_HDR_SIZE, M_TEMP, M_WAITOK); peofs = dh.d_peofs + sizeof(signature) - 1; - if ((error = pecoff_read_from(p, imgp->vp, peofs, (caddr_t) fp, PECOFF_HDR_SIZE) != 0)) + if ((error = pecoff_read_from(td, imgp->vp, peofs, (caddr_t) fp, PECOFF_HDR_SIZE) != 0)) goto fail; if (COFF_BADMAG(fp)) { error = ENOEXEC; @@ -379,7 +381,7 @@ pecoff_load_file(struct proc * p, const char *file, u_long * addr, u_long * entr /* read section header */ scnsiz = sizeof(struct coff_scnhdr) * fp->f_nscns; sh = malloc(scnsiz, M_TEMP, M_WAITOK); - if ((error = pecoff_read_from(p, imgp->vp, peofs + PECOFF_HDR_SIZE, + if ((error = pecoff_read_from(td, imgp->vp, peofs + PECOFF_HDR_SIZE, (caddr_t) sh, scnsiz)) != 0) goto fail; @@ -404,7 +406,7 @@ pecoff_load_file(struct proc * p, const char *file, u_long * addr, u_long * entr prot |= (sh[i].s_flags & COFF_STYP_EXEC) ? VM_PROT_EXECUTE : 0; sh[i].s_vaddr += wp->w_base; /* RVA --> VA */ - if ((error = pecoff_load_section(p, vmspace, imgp->vp, sh[i].s_scnptr + if ((error = pecoff_load_section(td, vmspace, imgp->vp, sh[i].s_scnptr ,(caddr_t) sh[i].s_vaddr, sh[i].s_paddr, sh[i].s_size ,prot)) != 0) @@ -457,7 +459,7 @@ exec_pecoff_coff_prep_zmagic(struct image_params * imgp, sh = malloc(scnsiz, M_TEMP, M_WAITOK); wp = (void *) ((char *) ap + sizeof(struct coff_aouthdr)); - error = pecoff_read_from(imgp->proc, imgp->vp, peofs + PECOFF_HDR_SIZE, + error = pecoff_read_from(&imgp->proc->p_thread, imgp->vp, peofs + PECOFF_HDR_SIZE, (caddr_t) sh, scnsiz); if ((error = exec_extract_strings(imgp)) != 0) goto fail; @@ -473,7 +475,7 @@ exec_pecoff_coff_prep_zmagic(struct image_params * imgp, continue; if ((sh[i].s_flags & COFF_STYP_TEXT) != 0) { - error = pecoff_load_section(imgp->proc, vmspace, + error = pecoff_load_section(&imgp->proc->p_thread, vmspace, imgp->vp, sh[i].s_scnptr ,(caddr_t) sh[i].s_vaddr, sh[i].s_paddr, sh[i].s_size ,prot); @@ -485,7 +487,7 @@ exec_pecoff_coff_prep_zmagic(struct image_params * imgp, } if ((sh[i].s_flags & (COFF_STYP_DATA|COFF_STYP_BSS)) != 0) { - if (pecoff_load_section(imgp->proc, + if (pecoff_load_section(&imgp->proc->p_thread, vmspace, imgp->vp, sh[i].s_scnptr ,(caddr_t) sh[i].s_vaddr, sh[i].s_paddr, sh[i].s_size, prot) != 0) @@ -510,7 +512,7 @@ exec_pecoff_coff_prep_zmagic(struct image_params * imgp, argp->a_entry = wp->w_base + ap->a_entry; argp->a_end = data_addr + data_size; argp->a_subsystem = wp->w_subvers; - error = pecoff_load_file(imgp->proc, "/usr/libexec/ld.so.dll", &ldbase, &imgp->entry_addr, &ldexport); + error = pecoff_load_file(&imgp->proc->p_thread, "/usr/libexec/ld.so.dll", &ldbase, &imgp->entry_addr, &ldexport); if (error) goto fail; @@ -570,8 +572,8 @@ exec_pecoff_coff_makecmds(struct image_params * imgp, } static int -pecoff_signature(p, vp, dp) - struct proc *p; +pecoff_signature(td, vp, dp) + struct thread *td; struct vnode *vp; const struct pecoff_dos_filehdr *dp; { @@ -581,7 +583,7 @@ pecoff_signature(p, vp, dp) if (DOS_BADMAG(dp)) { return ENOEXEC; } - error = pecoff_read_from(p, vp, dp->d_peofs, buf, sizeof(buf)); + error = pecoff_read_from(td, vp, dp->d_peofs, buf, sizeof(buf)); if (error) { return error; } @@ -592,8 +594,8 @@ pecoff_signature(p, vp, dp) return EFTYPE; } int -pecoff_read_from(p, vp, pos, buf, siz) - struct proc *p; +pecoff_read_from(td, vp, pos, buf, siz) + struct thread *td; struct vnode *vp; int pos; caddr_t buf; @@ -603,8 +605,8 @@ pecoff_read_from(p, vp, pos, buf, siz) size_t resid; error = vn_rdwr(UIO_READ, vp, buf, siz, pos, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, - &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, td->td_proc->p_ucred, + &resid, td); if (error) return error; @@ -621,13 +623,13 @@ imgact_pecoff(struct image_params * imgp) imgp->image_header; struct coff_filehdr *fp; int error, peofs; - error = pecoff_signature(imgp->proc, imgp->vp, dp); + error = pecoff_signature(&imgp->proc->p_thread, imgp->vp, dp); if (error) { return -1; } peofs = dp->d_peofs + sizeof(signature) - 1; fp = malloc(PECOFF_HDR_SIZE, M_TEMP, M_WAITOK); - error = pecoff_read_from(imgp->proc, imgp->vp, peofs, (caddr_t) fp, + error = pecoff_read_from(&imgp->proc->p_thread, imgp->vp, peofs, (caddr_t) fp, PECOFF_HDR_SIZE); if (error) { free(fp, M_TEMP); diff --git a/sys/compat/svr4/Makefile b/sys/compat/svr4/Makefile index 00f8264..6de19bc 100644 --- a/sys/compat/svr4/Makefile +++ b/sys/compat/svr4/Makefile @@ -5,14 +5,15 @@ MAINTAINER= newton@freebsd.org all: - @echo "make sysent only" + @echo "make syscallnames only" -syscallnames: svr4_sysent.c svr4_syscall.h svr4_proto.h +sysent: svr4_sysent.c svr4_syscall.h svr4_proto.h svr4_syscallnames.c svr4_sysent.c svr4_syscall.h svr4_proto.h: \ - ../kern/makesyscalls.sh syscalls.master syscalls.conf + ../../kern/makesyscalls.sh syscalls.master syscalls.conf -mv -f svr4_syscallnames.c svr4_syscallnames.c.bak -mv -f svr4_sysent.c svr4_sysent.c.bak -mv -f svr4_syscall.h svr4_syscall.h.bak -mv -f svr4_proto.h svr4_proto.h.bak - sh ../kern/makesyscalls.sh syscalls.master syscalls.conf + sh ../../kern/makesyscalls.sh syscalls.master syscalls.conf + diff --git a/sys/compat/svr4/svr4_exec.h b/sys/compat/svr4/svr4_exec.h index 716dad1..f15211b 100644 --- a/sys/compat/svr4/svr4_exec.h +++ b/sys/compat/svr4/svr4_exec.h @@ -65,6 +65,6 @@ #endif #endif -/*void svr4_setregs __P((struct proc *, struct exec_package *, u_long));*/ +/*void svr4_setregs __P((struct thread *, struct exec_package *, u_long));*/ #endif /* !_SVR4_EXEC_H_ */ diff --git a/sys/compat/svr4/svr4_fcntl.c b/sys/compat/svr4/svr4_fcntl.c index afa62b7..465bae5 100644 --- a/sys/compat/svr4/svr4_fcntl.c +++ b/sys/compat/svr4/svr4_fcntl.c @@ -55,8 +55,8 @@ static int svr4_to_bsd_flags __P((int)); static u_long svr4_to_bsd_cmd __P((u_long)); -static int fd_revoke __P((struct proc *, int)); -static int fd_truncate __P((struct proc *, int, struct flock *)); +static int fd_revoke __P((struct thread *, int)); +static int fd_truncate __P((struct thread *, int, struct flock *)); static int bsd_to_svr4_flags __P((int)); static void bsd_to_svr4_flock __P((struct flock *, struct svr4_flock *)); static void svr4_to_bsd_flock __P((struct svr4_flock *, struct flock *)); @@ -242,18 +242,18 @@ svr4_to_bsd_flock64(iflp, oflp) static int -fd_revoke(p, fd) - struct proc *p; +fd_revoke(td, fd) + struct thread *td; int fd; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct file *fp; struct vnode *vp; struct mount *mp; struct vattr vattr; int error, *retval; - retval = p->p_retval; + retval = td->td_retval; if ((u_int)fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL) return EBADF; @@ -267,11 +267,11 @@ fd_revoke(p, fd) goto out; } - if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) != 0) + if ((error = VOP_GETATTR(vp, &vattr, td->td_proc->p_ucred, td)) != 0) goto out; - if (p->p_ucred->cr_uid != vattr.va_uid && - (error = suser(p)) != 0) + if (td->td_proc->p_ucred->cr_uid != vattr.va_uid && + (error = suser_td(td)) != 0) goto out; if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) @@ -286,12 +286,12 @@ out: static int -fd_truncate(p, fd, flp) - struct proc *p; +fd_truncate(td, fd, flp) + struct thread *td; int fd; struct flock *flp; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct file *fp; off_t start, length; struct vnode *vp; @@ -299,7 +299,7 @@ fd_truncate(p, fd, flp) int error, *retval; struct ftruncate_args ft; - retval = p->p_retval; + retval = td->td_retval; /* * We only support truncating the file. @@ -311,7 +311,7 @@ fd_truncate(p, fd, flp) if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) return ESPIPE; - if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) != 0) + if ((error = VOP_GETATTR(vp, &vattr, td->td_proc->p_ucred, td)) != 0) return error; length = vattr.va_size; @@ -341,24 +341,25 @@ fd_truncate(p, fd, flp) SCARG(&ft, fd) = fd; SCARG(&ft, length) = start; - return ftruncate(p, &ft); + return ftruncate(td, &ft); } int -svr4_sys_open(p, uap) - register struct proc *p; +svr4_sys_open(td, uap) + register struct thread *td; struct svr4_sys_open_args *uap; { + struct proc *p = td->td_proc; int error, retval; struct open_args cup; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); (&cup)->path = uap->path; (&cup)->flags = svr4_to_bsd_flags(uap->flags); (&cup)->mode = uap->mode; - error = open(p, &cup); + error = open(td, &cup); if (error) { /* uprintf("svr4_open(%s, 0x%0x, 0%o): %d\n", uap->path, @@ -366,19 +367,19 @@ svr4_sys_open(p, uap) return error; } - retval = p->p_retval[0]; + retval = td->td_retval[0]; PROC_LOCK(p); if (!(SCARG(&cup, flags) & O_NOCTTY) && SESS_LEADER(p) && - !(p->p_flag & P_CONTROLT)) { + !(td->td_proc->p_flag & P_CONTROLT)) { #if defined(NOTYET) - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct file *fp = fdp->fd_ofiles[retval]; PROC_UNLOCK(p); /* ignore any error, just give it a try */ if (fp->f_type == DTYPE_VNODE) - fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, p); + fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, td); } else PROC_UNLOCK(p); #else @@ -389,41 +390,41 @@ svr4_sys_open(p, uap) } int -svr4_sys_open64(p, uap) - register struct proc *p; +svr4_sys_open64(td, uap) + register struct thread *td; struct svr4_sys_open64_args *uap; { - return svr4_sys_open(p, (struct svr4_sys_open_args *)uap); + return svr4_sys_open(td, (struct svr4_sys_open_args *)uap); } int -svr4_sys_creat(p, uap) - register struct proc *p; +svr4_sys_creat(td, uap) + register struct thread *td; struct svr4_sys_creat_args *uap; { struct open_args cup; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, mode) = SCARG(uap, mode); SCARG(&cup, flags) = O_WRONLY | O_CREAT | O_TRUNC; - return open(p, &cup); + return open(td, &cup); } int -svr4_sys_creat64(p, uap) - register struct proc *p; +svr4_sys_creat64(td, uap) + register struct thread *td; struct svr4_sys_creat64_args *uap; { - return svr4_sys_creat(p, (struct svr4_sys_creat_args *)uap); + return svr4_sys_creat(td, (struct svr4_sys_creat_args *)uap); } int -svr4_sys_llseek(p, uap) - register struct proc *p; +svr4_sys_llseek(td, uap) + register struct thread *td; struct svr4_sys_llseek_args *uap; { struct lseek_args ap; @@ -439,32 +440,32 @@ svr4_sys_llseek(p, uap) #endif SCARG(&ap, whence) = SCARG(uap, whence); - return lseek(p, &ap); + return lseek(td, &ap); } int -svr4_sys_access(p, uap) - register struct proc *p; +svr4_sys_access(td, uap) + register struct thread *td; struct svr4_sys_access_args *uap; { struct access_args cup; int *retval; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); - retval = p->p_retval; + retval = td->td_retval; SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, flags) = SCARG(uap, flags); - return access(p, &cup); + return access(td, &cup); } #if defined(NOTYET) int -svr4_sys_pread(p, uap) - register struct proc *p; +svr4_sys_pread(td, uap) + register struct thread *td; struct svr4_sys_pread_args *uap; { struct pread_args pra; @@ -478,14 +479,14 @@ svr4_sys_pread(p, uap) SCARG(&pra, nbyte) = SCARG(uap, nbyte); SCARG(&pra, offset) = SCARG(uap, off); - return pread(p, &pra); + return pread(td, &pra); } #endif #if defined(NOTYET) int -svr4_sys_pread64(p, v, retval) - register struct proc *p; +svr4_sys_pread64(td, v, retval) + register struct thread *td; void *v; register_t *retval; { @@ -502,14 +503,14 @@ svr4_sys_pread64(p, v, retval) SCARG(&pra, nbyte) = SCARG(uap, nbyte); SCARG(&pra, offset) = SCARG(uap, off); - return (sys_pread(p, &pra, retval)); + return (sys_pread(td, &pra, retval)); } #endif /* NOTYET */ #if defined(NOTYET) int -svr4_sys_pwrite(p, uap) - register struct proc *p; +svr4_sys_pwrite(td, uap) + register struct thread *td; struct svr4_sys_pwrite_args *uap; { struct pwrite_args pwa; @@ -523,14 +524,14 @@ svr4_sys_pwrite(p, uap) SCARG(&pwa, nbyte) = SCARG(uap, nbyte); SCARG(&pwa, offset) = SCARG(uap, off); - return pwrite(p, &pwa); + return pwrite(td, &pwa); } #endif #if defined(NOTYET) int -svr4_sys_pwrite64(p, v, retval) - register struct proc *p; +svr4_sys_pwrite64(td, v, retval) + register struct thread *td; void *v; register_t *retval; { @@ -546,20 +547,20 @@ svr4_sys_pwrite64(p, v, retval) SCARG(&pwa, nbyte) = SCARG(uap, nbyte); SCARG(&pwa, offset) = SCARG(uap, off); - return (sys_pwrite(p, &pwa, retval)); + return (sys_pwrite(td, &pwa, retval)); } #endif /* NOTYET */ int -svr4_sys_fcntl(p, uap) - register struct proc *p; +svr4_sys_fcntl(td, uap) + register struct thread *td; struct svr4_sys_fcntl_args *uap; { int error; struct fcntl_args fa; int *retval; - retval = p->p_retval; + retval = td->td_retval; SCARG(&fa, fd) = SCARG(uap, fd); SCARG(&fa, cmd) = svr4_to_bsd_cmd(SCARG(uap, cmd)); @@ -569,11 +570,11 @@ svr4_sys_fcntl(p, uap) case F_GETFD: case F_SETFD: SCARG(&fa, arg) = (long) SCARG(uap, arg); - return fcntl(p, &fa); + return fcntl(td, &fa); case F_GETFL: SCARG(&fa, arg) = (long) SCARG(uap, arg); - error = fcntl(p, &fa); + error = fcntl(td, &fa); if (error) return error; *retval = bsd_to_svr4_flags(*retval); @@ -592,14 +593,14 @@ svr4_sys_fcntl(p, uap) cmd = SCARG(&fa, cmd); /* save it for a while */ SCARG(&fa, cmd) = F_GETFL; - if ((error = fcntl(p, &fa)) != 0) + if ((error = fcntl(td, &fa)) != 0) return error; flags = *retval; flags &= O_ASYNC; flags |= svr4_to_bsd_flags((u_long) SCARG(uap, arg)); SCARG(&fa, cmd) = cmd; SCARG(&fa, arg) = (long) flags; - return fcntl(p, &fa); + return fcntl(td, &fa); } case F_GETLK: @@ -623,7 +624,7 @@ svr4_sys_fcntl(p, uap) if (error) return error; - error = fcntl(p, &fa); + error = fcntl(td, &fa); if (error || SCARG(&fa, cmd) != F_GETLK) return error; @@ -643,7 +644,7 @@ svr4_sys_fcntl(p, uap) SCARG(&du, from) = SCARG(uap, fd); SCARG(&du, to) = (int)SCARG(uap, arg); - error = dup2(p, &du); + error = dup2(td, &du); if (error) return error; *retval = SCARG(&du, to); @@ -660,7 +661,7 @@ svr4_sys_fcntl(p, uap) if (error) return error; svr4_to_bsd_flock(&ifl, &fl); - return fd_truncate(p, SCARG(uap, fd), &fl); + return fd_truncate(td, SCARG(uap, fd), &fl); } case SVR4_F_GETLK64: @@ -685,7 +686,7 @@ svr4_sys_fcntl(p, uap) if (error) return error; - error = fcntl(p, &fa); + error = fcntl(td, &fa); if (error || SCARG(&fa, cmd) != F_GETLK) return error; @@ -709,11 +710,11 @@ svr4_sys_fcntl(p, uap) if (error) return error; svr4_to_bsd_flock64(&ifl, &fl); - return fd_truncate(p, SCARG(uap, fd), &fl); + return fd_truncate(td, SCARG(uap, fd), &fl); } case SVR4_F_REVOKE: - return fd_revoke(p, SCARG(uap, fd)); + return fd_revoke(td, SCARG(uap, fd)); default: return ENOSYS; diff --git a/sys/compat/svr4/svr4_filio.c b/sys/compat/svr4/svr4_filio.c index c467dad..8d24788 100644 --- a/sys/compat/svr4/svr4_filio.c +++ b/sys/compat/svr4/svr4_filio.c @@ -51,8 +51,8 @@ /*#define GROTTY_READ_HACK*/ int -svr4_sys_poll(p, uap) - struct proc *p; +svr4_sys_poll(td, uap) + struct thread *td; struct svr4_sys_poll_args *uap; { int error; @@ -68,7 +68,7 @@ svr4_sys_poll(p, uap) siz = SCARG(uap, nfds) * sizeof(struct pollfd); pfd = (struct pollfd *)malloc(siz, M_TEMP, M_WAITOK); - error = poll(p, (struct poll_args *)uap); + error = poll(td, (struct poll_args *)uap); if ((cerr = copyin(SCARG(uap, fds), pfd, siz)) != 0) { error = cerr; @@ -92,12 +92,12 @@ done: #if defined(READ_TEST) int -svr4_sys_read(p, uap) - struct proc *p; +svr4_sys_read(td, uap) + struct thread *td; struct svr4_sys_read_args *uap; { struct read_args ra; - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct file *fp; struct socket *so = NULL; int so_state; @@ -126,15 +126,15 @@ svr4_sys_read(p, uap) #endif } - rv = read(p, &ra); + rv = read(td, &ra); DPRINTF(("svr4_read(%d, 0x%0x, %d) = %d\n", SCARG(uap, fd), SCARG(uap, buf), SCARG(uap, nbyte), rv)); if (rv == EAGAIN) { - DPRINTF(("sigmask = 0x%x\n", p->p_sigmask)); - DPRINTF(("sigignore = 0x%x\n", p->p_sigignore)); - DPRINTF(("sigcaught = 0x%x\n", p->p_sigcatch)); - DPRINTF(("siglist = 0x%x\n", p->p_siglist)); + DPRINTF(("sigmask = 0x%x\n", td->td_proc->p_sigmask)); + DPRINTF(("sigignore = 0x%x\n", td->td_proc->p_sigignore)); + DPRINTF(("sigcaught = 0x%x\n", td->td_proc->p_sigcatch)); + DPRINTF(("siglist = 0x%x\n", td->td_proc->p_siglist)); } #if defined(GROTTY_READ_HACK) @@ -149,8 +149,8 @@ svr4_sys_read(p, uap) #if defined(BOGUS) int -svr4_sys_write(p, uap) - struct proc *p; +svr4_sys_write(td, uap) + struct thread *td; struct svr4_sys_write_args *uap; { struct write_args wa; @@ -162,7 +162,7 @@ svr4_sys_write(p, uap) SCARG(&wa, buf) = SCARG(uap, buf); SCARG(&wa, nbyte) = SCARG(uap, nbyte); - rv = write(p, &wa); + rv = write(td, &wa); DPRINTF(("svr4_write(%d, 0x%0x, %d) = %d\n", SCARG(uap, fd), SCARG(uap, buf), SCARG(uap, nbyte), rv)); @@ -172,9 +172,9 @@ svr4_sys_write(p, uap) #endif /* BOGUS */ int -svr4_fil_ioctl(fp, p, retval, fd, cmd, data) +svr4_fil_ioctl(fp, td, retval, fd, cmd, data) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -182,7 +182,7 @@ svr4_fil_ioctl(fp, p, retval, fd, cmd, data) { int error; int num; - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; *retval = 0; @@ -214,7 +214,7 @@ svr4_fil_ioctl(fp, p, retval, fd, cmd, data) #ifdef SVR4_DEBUG if (cmd == FIOASYNC) DPRINTF(("FIOASYNC\n")); #endif - error = fo_ioctl(fp, cmd, (caddr_t) &num, p); + error = fo_ioctl(fp, cmd, (caddr_t) &num, td); if (error) return error; diff --git a/sys/compat/svr4/svr4_ioctl.c b/sys/compat/svr4/svr4_ioctl.c index d93e2b8..e153713 100644 --- a/sys/compat/svr4/svr4_ioctl.c +++ b/sys/compat/svr4/svr4_ioctl.c @@ -78,15 +78,15 @@ svr4_decode_cmd(cmd, dir, c, num, argsiz) #endif int -svr4_sys_ioctl(p, uap) - register struct proc *p; +svr4_sys_ioctl(td, uap) + register struct thread *td; struct svr4_sys_ioctl_args *uap; { int *retval; struct file *fp; struct filedesc *fdp; u_long cmd; - int (*fun) __P((struct file *, struct proc *, register_t *, + int (*fun) __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); #ifdef DEBUG_SVR4 char dir[4]; @@ -99,8 +99,8 @@ svr4_sys_ioctl(p, uap) DPRINTF(("svr4_ioctl[%lx](%d, _IO%s(%c, %d, %d), %p);\n", SCARG(uap, com), SCARG(uap, fd), dir, c, num, argsiz, SCARG(uap, data))); #endif - retval = p->p_retval; - fdp = p->p_fd; + retval = td->td_retval; + fdp = td->td_proc->p_fd; cmd = SCARG(uap, com); if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles || @@ -157,5 +157,5 @@ svr4_sys_ioctl(p, uap) DPRINTF((">>> OUT: so_state = 0x%x\n", so->so_state)); } #endif - return (*fun)(fp, p, retval, SCARG(uap, fd), cmd, SCARG(uap, data)); + return (*fun)(fp, td, retval, SCARG(uap, fd), cmd, SCARG(uap, data)); } diff --git a/sys/compat/svr4/svr4_ioctl.h b/sys/compat/svr4/svr4_ioctl.h index a5c6a53..2d7e136 100644 --- a/sys/compat/svr4/svr4_ioctl.h +++ b/sys/compat/svr4/svr4_ioctl.h @@ -46,17 +46,17 @@ #define SVR4_IOW(g,n,t) SVR4_IOC(SVR4_IOC_IN, (g), (n), sizeof(t)) #define SVR4_IOWR(g,n,t) SVR4_IOC(SVR4_IOC_INOUT,(g), (n), sizeof(t)) -int svr4_stream_ti_ioctl __P((struct file *, struct proc *, register_t *, +int svr4_stream_ti_ioctl __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); -int svr4_stream_ioctl __P((struct file *, struct proc *, register_t *, +int svr4_stream_ioctl __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); -int svr4_term_ioctl __P((struct file *, struct proc *, register_t *, +int svr4_term_ioctl __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); -int svr4_ttold_ioctl __P((struct file *, struct proc *, register_t *, +int svr4_ttold_ioctl __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); -int svr4_fil_ioctl __P((struct file *, struct proc *, register_t *, +int svr4_fil_ioctl __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); -int svr4_sock_ioctl __P((struct file *, struct proc *, register_t *, +int svr4_sock_ioctl __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); #endif /* !_SVR4_IOCTL_H_ */ diff --git a/sys/compat/svr4/svr4_misc.c b/sys/compat/svr4/svr4_misc.c index 6865880..fd6c472 100644 --- a/sys/compat/svr4/svr4_misc.c +++ b/sys/compat/svr4/svr4_misc.c @@ -95,14 +95,14 @@ #define BSD_DIRENT(cp) ((struct dirent *)(cp)) -static int svr4_mknod __P((struct proc *, register_t *, char *, +static int svr4_mknod __P((struct thread *, register_t *, char *, svr4_mode_t, svr4_dev_t)); static __inline clock_t timeval_to_clock_t __P((struct timeval *)); static int svr4_setinfo __P((struct proc *, int, svr4_siginfo_t *)); struct svr4_hrtcntl_args; -static int svr4_hrtcntl __P((struct proc *, struct svr4_hrtcntl_args *, +static int svr4_hrtcntl __P((struct thread *, struct svr4_hrtcntl_args *, register_t *)); static void bsd_statfs_to_svr4_statvfs __P((const struct statfs *, struct svr4_statvfs *)); @@ -113,22 +113,22 @@ static struct proc *svr4_pfind __P((pid_t pid)); /* BOGUS noop */ #if defined(BOGUS) int -svr4_sys_setitimer(p, uap) - register struct proc *p; +svr4_sys_setitimer(td, uap) + register struct thread *td; struct svr4_sys_setitimer_args *uap; { - p->p_retval[0] = 0; + td->td_retval[0] = 0; return 0; } #endif int -svr4_sys_wait(p, uap) - struct proc *p; +svr4_sys_wait(td, uap) + struct thread *td; struct svr4_sys_wait_args *uap; { struct wait_args w4; - int error, *retval = p->p_retval, st, sig; + int error, *retval = td->td_retval, st, sig; size_t sz = sizeof(*SCARG(&w4, status)); SCARG(&w4, rusage) = NULL; @@ -144,7 +144,7 @@ svr4_sys_wait(p, uap) SCARG(&w4, pid) = WAIT_ANY; - if ((error = wait4(p, &w4)) != 0) + if ((error = wait4(td, &w4)) != 0) return error; if ((error = copyin(SCARG(&w4, status), &st, sizeof(st))) != 0) @@ -174,44 +174,44 @@ svr4_sys_wait(p, uap) } int -svr4_sys_execv(p, uap) - struct proc *p; +svr4_sys_execv(td, uap) + struct thread *td; struct svr4_sys_execv_args *uap; { struct execve_args ap; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&ap, fname) = SCARG(uap, path); SCARG(&ap, argv) = SCARG(uap, argp); SCARG(&ap, envv) = NULL; - return execve(p, &ap); + return execve(td, &ap); } int -svr4_sys_execve(p, uap) - struct proc *p; +svr4_sys_execve(td, uap) + struct thread *td; struct svr4_sys_execve_args *uap; { struct execve_args ap; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, uap->path); + CHECKALTEXIST(td, &sg, uap->path); SCARG(&ap, fname) = SCARG(uap, path); SCARG(&ap, argv) = SCARG(uap, argp); SCARG(&ap, envv) = SCARG(uap, envp); - return execve(p, &ap); + return execve(td, &ap); } int -svr4_sys_time(p, v) - struct proc *p; +svr4_sys_time(td, v) + struct thread *td; struct svr4_sys_time_args *v; { struct svr4_sys_time_args *uap = v; @@ -222,7 +222,7 @@ svr4_sys_time(p, v) if (SCARG(uap, t)) error = copyout(&tv.tv_sec, SCARG(uap, t), sizeof(*(SCARG(uap, t)))); - p->p_retval[0] = (int) tv.tv_sec; + td->td_retval[0] = (int) tv.tv_sec; return error; } @@ -237,8 +237,8 @@ svr4_sys_time(p, v) * to adapt the NetBSD version. */ int -svr4_sys_getdents64(p, uap) - struct proc *p; +svr4_sys_getdents64(td, uap) + struct thread *td; struct svr4_sys_getdents64_args *uap; { register struct dirent *bdp; @@ -258,8 +258,8 @@ svr4_sys_getdents64(p, uap) int ncookies; DPRINTF(("svr4_sys_getdents64(%d, *, %d)\n", - p->p_pid, SCARG(uap, fd), SCARG(uap, nbytes))); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) { + td->td_proc->p_pid, SCARG(uap, fd), SCARG(uap, nbytes))); + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) { return (error); } @@ -271,7 +271,7 @@ svr4_sys_getdents64(p, uap) if (vp->v_type != VDIR) return (EINVAL); - if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p))) { + if ((error = VOP_GETATTR(vp, &va, td->td_proc->p_ucred, td))) { return error; } @@ -288,7 +288,7 @@ svr4_sys_getdents64(p, uap) buflen = max(DIRBLKSIZ, nbytes); buflen = min(buflen, MAXBSIZE); buf = malloc(buflen, M_TEMP, M_WAITOK); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); again: aiov.iov_base = buf; aiov.iov_len = buflen; @@ -296,7 +296,7 @@ again: auio.uio_iovcnt = 1; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_resid = buflen; auio.uio_offset = off; @@ -398,19 +398,19 @@ again: nbytes = resid + svr4reclen; eof: - p->p_retval[0] = nbytes - resid; + td->td_retval[0] = nbytes - resid; out: if (cookies) free(cookies, M_TEMP); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); free(buf, M_TEMP); return error; } int -svr4_sys_getdents(p, uap) - struct proc *p; +svr4_sys_getdents(td, uap) + struct thread *td; struct svr4_sys_getdents_args *uap; { struct dirent *bdp; @@ -426,9 +426,9 @@ svr4_sys_getdents(p, uap) off_t off; /* true file offset */ int buflen, error, eofflag; u_long *cookiebuf = NULL, *cookie; - int ncookies = 0, *retval = p->p_retval; + int ncookies = 0, *retval = td->td_retval; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); if ((fp->f_flag & FREAD) == 0) @@ -440,7 +440,7 @@ svr4_sys_getdents(p, uap) buflen = min(MAXBSIZE, SCARG(uap, nbytes)); buf = malloc(buflen, M_TEMP, M_WAITOK); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); off = fp->f_offset; again: aiov.iov_base = buf; @@ -449,7 +449,7 @@ again: auio.uio_iovcnt = 1; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_resid = buflen; auio.uio_offset = off; /* @@ -514,7 +514,7 @@ again: eof: *retval = SCARG(uap, nbytes) - resid; out: - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (cookiebuf) free(cookiebuf, M_TEMP); free(buf, M_TEMP); @@ -523,14 +523,14 @@ out: int -svr4_sys_mmap(p, uap) - struct proc *p; +svr4_sys_mmap(td, uap) + struct thread *td; struct svr4_sys_mmap_args *uap; { struct mmap_args mm; int *retval; - retval = p->p_retval; + retval = td->td_retval; #define _MAP_NEW 0x80000000 /* * Verify the arguments. @@ -548,12 +548,12 @@ svr4_sys_mmap(p, uap) SCARG(&mm, addr) = SCARG(uap, addr); SCARG(&mm, pos) = SCARG(uap, pos); - return mmap(p, &mm); + return mmap(td, &mm); } int -svr4_sys_mmap64(p, uap) - struct proc *p; +svr4_sys_mmap64(td, uap) + struct thread *td; struct svr4_sys_mmap64_args *uap; { struct mmap_args mm; @@ -576,36 +576,36 @@ svr4_sys_mmap64(p, uap) SCARG(&mm, addr) = SCARG(uap, addr); SCARG(&mm, pos) = SCARG(uap, pos); - rp = (void *) round_page((vm_offset_t)(p->p_vmspace->vm_daddr + MAXDSIZ)); + rp = (void *) round_page((vm_offset_t)(td->td_proc->p_vmspace->vm_daddr + MAXDSIZ)); if ((SCARG(&mm, flags) & MAP_FIXED) == 0 && SCARG(&mm, addr) != 0 && (void *)SCARG(&mm, addr) < rp) SCARG(&mm, addr) = rp; - return mmap(p, &mm); + return mmap(td, &mm); } int -svr4_sys_fchroot(p, uap) - struct proc *p; +svr4_sys_fchroot(td, uap) + struct thread *td; struct svr4_sys_fchroot_args *uap; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct vnode *vp; struct file *fp; int error; - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) return error; if ((error = getvnode(fdp, SCARG(uap, fd), &fp)) != 0) return error; vp = (struct vnode *) fp->f_data; - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (vp->v_type != VDIR) error = ENOTDIR; else - error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + error = VOP_ACCESS(vp, VEXEC, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); if (error) return error; VREF(vp); @@ -617,8 +617,8 @@ svr4_sys_fchroot(p, uap) static int -svr4_mknod(p, retval, path, mode, dev) - struct proc *p; +svr4_mknod(td, retval, path, mode, dev) + struct thread *td; register_t *retval; char *path; svr4_mode_t mode; @@ -626,50 +626,50 @@ svr4_mknod(p, retval, path, mode, dev) { caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, path); + CHECKALTEXIST(td, &sg, path); if (S_ISFIFO(mode)) { struct mkfifo_args ap; SCARG(&ap, path) = path; SCARG(&ap, mode) = mode; - return mkfifo(p, &ap); + return mkfifo(td, &ap); } else { struct mknod_args ap; SCARG(&ap, path) = path; SCARG(&ap, mode) = mode; SCARG(&ap, dev) = dev; - return mknod(p, &ap); + return mknod(td, &ap); } } int -svr4_sys_mknod(p, uap) - register struct proc *p; +svr4_sys_mknod(td, uap) + register struct thread *td; struct svr4_sys_mknod_args *uap; { - int *retval = p->p_retval; - return svr4_mknod(p, retval, + int *retval = td->td_retval; + return svr4_mknod(td, retval, SCARG(uap, path), SCARG(uap, mode), (svr4_dev_t)svr4_to_bsd_odev_t(SCARG(uap, dev))); } int -svr4_sys_xmknod(p, uap) - struct proc *p; +svr4_sys_xmknod(td, uap) + struct thread *td; struct svr4_sys_xmknod_args *uap; { - int *retval = p->p_retval; - return svr4_mknod(p, retval, + int *retval = td->td_retval; + return svr4_mknod(td, retval, SCARG(uap, path), SCARG(uap, mode), (svr4_dev_t)svr4_to_bsd_dev_t(SCARG(uap, dev))); } int -svr4_sys_vhangup(p, uap) - struct proc *p; +svr4_sys_vhangup(td, uap) + struct thread *td; struct svr4_sys_vhangup_args *uap; { return 0; @@ -677,13 +677,13 @@ svr4_sys_vhangup(p, uap) int -svr4_sys_sysconfig(p, uap) - struct proc *p; +svr4_sys_sysconfig(td, uap) + struct thread *td; struct svr4_sys_sysconfig_args *uap; { int *retval; - retval = &(p->p_retval[0]); + retval = &(td->td_retval[0]); switch (SCARG(uap, name)) { case SVR4_CONFIG_UNUSED: @@ -779,11 +779,11 @@ extern int swap_pager_full; /* ARGSUSED */ int -svr4_sys_break(p, uap) - struct proc *p; +svr4_sys_break(td, uap) + struct thread *td; struct svr4_sys_break_args *uap; { - struct vmspace *vm = p->p_vmspace; + struct vmspace *vm = td->td_proc->p_vmspace; vm_offset_t new, old, base, ns; int rv; @@ -793,7 +793,7 @@ svr4_sys_break(p, uap) /* For p_rlimit. */ mtx_assert(&Giant, MA_OWNED); if (new > base) { - if ((new - base) > (unsigned) p->p_rlimit[RLIMIT_DATA].rlim_cur) { + if ((new - base) > (unsigned) td->td_proc->p_rlimit[RLIMIT_DATA].rlim_cur) { return ENOMEM; } if (new >= VM_MAXUSER_ADDRESS) { @@ -842,11 +842,11 @@ timeval_to_clock_t(tv) int -svr4_sys_times(p, uap) - struct proc *p; +svr4_sys_times(td, uap) + struct thread *td; struct svr4_sys_times_args *uap; { - int error, *retval = p->p_retval; + int error, *retval = td->td_retval; struct tms tms; struct timeval t; struct rusage *ru; @@ -859,7 +859,7 @@ svr4_sys_times(p, uap) SCARG(&ga, who) = RUSAGE_SELF; SCARG(&ga, rusage) = ru; - error = getrusage(p, &ga); + error = getrusage(td, &ga); if (error) return error; @@ -870,7 +870,7 @@ svr4_sys_times(p, uap) tms.tms_stime = timeval_to_clock_t(&r.ru_stime); SCARG(&ga, who) = RUSAGE_CHILDREN; - error = getrusage(p, &ga); + error = getrusage(td, &ga); if (error) return error; @@ -888,17 +888,17 @@ svr4_sys_times(p, uap) int -svr4_sys_ulimit(p, uap) - struct proc *p; +svr4_sys_ulimit(td, uap) + struct thread *td; struct svr4_sys_ulimit_args *uap; { - int *retval = p->p_retval; + int *retval = td->td_retval; switch (SCARG(uap, cmd)) { case SVR4_GFILLIM: /* For p_rlimit below. */ mtx_assert(&Giant, MA_OWNED); - *retval = p->p_rlimit[RLIMIT_FSIZE].rlim_cur / 512; + *retval = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur / 512; if (*retval == -1) *retval = 0x7fffffff; return 0; @@ -914,7 +914,7 @@ svr4_sys_ulimit(p, uap) krl.rlim_cur = SCARG(uap, newlimit) * 512; mtx_assert(&Giant, MA_OWNED); - krl.rlim_max = p->p_rlimit[RLIMIT_FSIZE].rlim_max; + krl.rlim_max = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_max; error = copyout(&krl, url, sizeof(*url)); if (error) @@ -923,12 +923,12 @@ svr4_sys_ulimit(p, uap) SCARG(&srl, which) = RLIMIT_FSIZE; SCARG(&srl, rlp) = url; - error = setrlimit(p, &srl); + error = setrlimit(td, &srl); if (error) return error; mtx_assert(&Giant, MA_OWNED); - *retval = p->p_rlimit[RLIMIT_FSIZE].rlim_cur; + *retval = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur; if (*retval == -1) *retval = 0x7fffffff; return 0; @@ -936,11 +936,11 @@ svr4_sys_ulimit(p, uap) case SVR4_GMEMLIM: { - struct vmspace *vm = p->p_vmspace; + struct vmspace *vm = td->td_proc->p_vmspace; register_t r; mtx_assert(&Giant, MA_OWNED); - r = p->p_rlimit[RLIMIT_DATA].rlim_cur; + r = td->td_proc->p_rlimit[RLIMIT_DATA].rlim_cur; if (r == -1) r = 0x7fffffff; @@ -953,7 +953,7 @@ svr4_sys_ulimit(p, uap) case SVR4_GDESLIM: mtx_assert(&Giant, MA_OWNED); - *retval = p->p_rlimit[RLIMIT_NOFILE].rlim_cur; + *retval = td->td_proc->p_rlimit[RLIMIT_NOFILE].rlim_cur; if (*retval == -1) *retval = 0x7fffffff; return 0; @@ -979,11 +979,12 @@ svr4_pfind(pid) int -svr4_sys_pgrpsys(p, uap) - struct proc *p; +svr4_sys_pgrpsys(td, uap) + struct thread *td; struct svr4_sys_pgrpsys_args *uap; { - int *retval = p->p_retval; + int *retval = td->td_retval; + struct proc *p = td->td_proc; switch (SCARG(uap, cmd)) { case 1: /* setpgrp() */ @@ -994,7 +995,7 @@ svr4_sys_pgrpsys(p, uap) * setsid() for SVR4. (Under BSD, the difference is that * a setpgid(0,0) will not create a new session.) */ - setsid(p, NULL); + setsid(td, NULL); /*FALLTHROUGH*/ case 0: /* getpgrp() */ @@ -1014,7 +1015,7 @@ svr4_sys_pgrpsys(p, uap) return 0; case 3: /* setsid() */ - return setsid(p, NULL); + return setsid(td, NULL); case 4: /* getpgid(pid) */ @@ -1032,7 +1033,7 @@ svr4_sys_pgrpsys(p, uap) SCARG(&sa, pid) = SCARG(uap, pid); SCARG(&sa, pgid) = SCARG(uap, pgid); - return setpgid(p, &sa); + return setpgid(td, &sa); } default: @@ -1052,8 +1053,8 @@ struct svr4_hrtcntl_args { static int -svr4_hrtcntl(p, uap, retval) - struct proc *p; +svr4_hrtcntl(td, uap, retval) + struct thread *td; struct svr4_hrtcntl_args *uap; register_t *retval; { @@ -1098,15 +1099,15 @@ svr4_hrtcntl(p, uap, retval) int -svr4_sys_hrtsys(p, uap) - struct proc *p; +svr4_sys_hrtsys(td, uap) + struct thread *td; struct svr4_sys_hrtsys_args *uap; { - int *retval = p->p_retval; + int *retval = td->td_retval; switch (SCARG(uap, cmd)) { case SVR4_HRT_CNTL: - return svr4_hrtcntl(p, (struct svr4_hrtcntl_args *) uap, + return svr4_hrtcntl(td, (struct svr4_hrtcntl_args *) uap, retval); case SVR4_HRT_ALRM: @@ -1187,12 +1188,12 @@ svr4_setinfo(p, st, s) int -svr4_sys_waitsys(p, uap) - struct proc *p; +svr4_sys_waitsys(td, uap) + struct thread *td; struct svr4_sys_waitsys_args *uap; { int nfound; - int error, *retval = p->p_retval; + int error, *retval = td->td_retval; struct proc *q, *t; @@ -1201,7 +1202,7 @@ svr4_sys_waitsys(p, uap) break; case SVR4_P_PGID: - SCARG(uap, id) = -p->p_pgid; + SCARG(uap, id) = -td->td_proc->p_pgid; break; case SVR4_P_ALL: @@ -1219,7 +1220,7 @@ svr4_sys_waitsys(p, uap) loop: nfound = 0; sx_slock(&proctree_lock); - LIST_FOREACH(q, &p->p_children, p_sibling) { + LIST_FOREACH(q, &td->td_proc->p_children, p_sibling) { if (SCARG(uap, id) != WAIT_ANY && q->p_pid != SCARG(uap, id) && q->p_pgid != -SCARG(uap, id)) { @@ -1276,7 +1277,7 @@ loop: PROC_UNLOCK(q); sx_xunlock(&proctree_lock); q->p_xstat = 0; - ruadd(&p->p_stats->p_cru, q->p_ru); + ruadd(&td->td_proc->p_stats->p_cru, q->p_ru); FREE(q->p_ru, M_ZOMBIE); q->p_ru = 0; @@ -1320,7 +1321,7 @@ loop: PROC_LOCK(q); if (--q->p_procsig->ps_refcnt == 0) { - if (q->p_sigacts != &q->p_addr->u_sigacts) + if (q->p_sigacts != &q->p_uarea->u_sigacts) FREE(q->p_sigacts, M_SUBPROC); FREE(q->p_procsig, M_SUBPROC); q->p_procsig = NULL; @@ -1369,7 +1370,7 @@ loop: return 0; } - if ((error = tsleep((caddr_t)p, PWAIT | PCATCH, "svr4_wait", 0)) != 0) + if ((error = tsleep((caddr_t)td->td_proc, PWAIT | PCATCH, "svr4_wait", 0)) != 0) return error; goto loop; } @@ -1428,8 +1429,8 @@ bsd_statfs_to_svr4_statvfs64(bfs, sfs) int -svr4_sys_statvfs(p, uap) - struct proc *p; +svr4_sys_statvfs(td, uap) + struct thread *td; struct svr4_sys_statvfs_args *uap; { struct statfs_args fs_args; @@ -1439,11 +1440,11 @@ svr4_sys_statvfs(p, uap) struct svr4_statvfs sfs; int error; - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&fs_args, path) = SCARG(uap, path); SCARG(&fs_args, buf) = fs; - if ((error = statfs(p, &fs_args)) != 0) + if ((error = statfs(td, &fs_args)) != 0) return error; if ((error = copyin(fs, &bfs, sizeof(bfs))) != 0) @@ -1456,8 +1457,8 @@ svr4_sys_statvfs(p, uap) int -svr4_sys_fstatvfs(p, uap) - struct proc *p; +svr4_sys_fstatvfs(td, uap) + struct thread *td; struct svr4_sys_fstatvfs_args *uap; { struct fstatfs_args fs_args; @@ -1470,7 +1471,7 @@ svr4_sys_fstatvfs(p, uap) SCARG(&fs_args, fd) = SCARG(uap, fd); SCARG(&fs_args, buf) = fs; - if ((error = fstatfs(p, &fs_args)) != 0) + if ((error = fstatfs(td, &fs_args)) != 0) return error; if ((error = copyin(fs, &bfs, sizeof(bfs))) != 0) @@ -1483,8 +1484,8 @@ svr4_sys_fstatvfs(p, uap) int -svr4_sys_statvfs64(p, uap) - struct proc *p; +svr4_sys_statvfs64(td, uap) + struct thread *td; struct svr4_sys_statvfs64_args *uap; { struct statfs_args fs_args; @@ -1494,11 +1495,11 @@ svr4_sys_statvfs64(p, uap) struct svr4_statvfs64 sfs; int error; - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&fs_args, path) = SCARG(uap, path); SCARG(&fs_args, buf) = fs; - if ((error = statfs(p, &fs_args)) != 0) + if ((error = statfs(td, &fs_args)) != 0) return error; if ((error = copyin(fs, &bfs, sizeof(bfs))) != 0) @@ -1511,8 +1512,8 @@ svr4_sys_statvfs64(p, uap) int -svr4_sys_fstatvfs64(p, uap) - struct proc *p; +svr4_sys_fstatvfs64(td, uap) + struct thread *td; struct svr4_sys_fstatvfs64_args *uap; { struct fstatfs_args fs_args; @@ -1525,7 +1526,7 @@ svr4_sys_fstatvfs64(p, uap) SCARG(&fs_args, fd) = SCARG(uap, fd); SCARG(&fs_args, buf) = fs; - if ((error = fstatfs(p, &fs_args)) != 0) + if ((error = fstatfs(td, &fs_args)) != 0) return error; if ((error = copyin(fs, &bfs, sizeof(bfs))) != 0) @@ -1537,8 +1538,8 @@ svr4_sys_fstatvfs64(p, uap) } int -svr4_sys_alarm(p, uap) - struct proc *p; +svr4_sys_alarm(td, uap) + struct thread *td; struct svr4_sys_alarm_args *uap; { int error; @@ -1555,19 +1556,19 @@ svr4_sys_alarm(p, uap) SCARG(&sa, which) = ITIMER_REAL; SCARG(&sa, itv) = itp; SCARG(&sa, oitv) = oitp; - error = setitimer(p, &sa); + error = setitimer(td, &sa); if (error) return error; if (oitp->it_value.tv_usec) oitp->it_value.tv_sec++; - p->p_retval[0] = oitp->it_value.tv_sec; + td->td_retval[0] = oitp->it_value.tv_sec; return 0; } int -svr4_sys_gettimeofday(p, uap) - struct proc *p; +svr4_sys_gettimeofday(td, uap) + struct thread *td; struct svr4_sys_gettimeofday_args *uap; { if (SCARG(uap, tp)) { @@ -1581,13 +1582,13 @@ svr4_sys_gettimeofday(p, uap) } int -svr4_sys_facl(p, uap) - struct proc *p; +svr4_sys_facl(td, uap) + struct thread *td; struct svr4_sys_facl_args *uap; { int *retval; - retval = p->p_retval; + retval = td->td_retval; *retval = 0; switch (SCARG(uap, cmd)) { @@ -1609,17 +1610,17 @@ svr4_sys_facl(p, uap) int -svr4_sys_acl(p, uap) - struct proc *p; +svr4_sys_acl(td, uap) + struct thread *td; struct svr4_sys_acl_args *uap; { /* XXX: for now the same */ - return svr4_sys_facl(p, (struct svr4_sys_facl_args *)uap); + return svr4_sys_facl(td, (struct svr4_sys_facl_args *)uap); } int -svr4_sys_auditsys(p, uap) - struct proc *p; +svr4_sys_auditsys(td, uap) + struct thread *td; struct svr4_sys_auditsys_args *uap; { /* @@ -1629,8 +1630,8 @@ svr4_sys_auditsys(p, uap) } int -svr4_sys_memcntl(p, uap) - struct proc *p; +svr4_sys_memcntl(td, uap) + struct thread *td; struct svr4_sys_memcntl_args *uap; { switch (SCARG(uap, cmd)) { @@ -1642,7 +1643,7 @@ svr4_sys_memcntl(p, uap) SCARG(&msa, len) = SCARG(uap, len); SCARG(&msa, flags) = (int)SCARG(uap, arg); - return msync(p, &msa); + return msync(td, &msa); } case SVR4_MC_ADVISE: { @@ -1652,7 +1653,7 @@ svr4_sys_memcntl(p, uap) SCARG(&maa, len) = SCARG(uap, len); SCARG(&maa, behav) = (int)SCARG(uap, arg); - return madvise(p, &maa); + return madvise(td, &maa); } case SVR4_MC_LOCK: case SVR4_MC_UNLOCK: @@ -1666,8 +1667,8 @@ svr4_sys_memcntl(p, uap) int -svr4_sys_nice(p, uap) - struct proc *p; +svr4_sys_nice(td, uap) + struct thread *td; struct svr4_sys_nice_args *uap; { struct setpriority_args ap; @@ -1677,26 +1678,26 @@ svr4_sys_nice(p, uap) SCARG(&ap, who) = 0; SCARG(&ap, prio) = SCARG(uap, prio); - if ((error = setpriority(p, &ap)) != 0) + if ((error = setpriority(td, &ap)) != 0) return error; /* the cast is stupid, but the structures are the same */ - if ((error = getpriority(p, (struct getpriority_args *)&ap)) != 0) + if ((error = getpriority(td, (struct getpriority_args *)&ap)) != 0) return error; return 0; } int -svr4_sys_resolvepath(p, uap) - struct proc *p; +svr4_sys_resolvepath(td, uap) + struct thread *td; struct svr4_sys_resolvepath_args *uap; { struct nameidata nd; - int error, *retval = p->p_retval; + int error, *retval = td->td_retval; NDINIT(&nd, LOOKUP, NOFOLLOW | SAVENAME, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return error; diff --git a/sys/compat/svr4/svr4_proto.h b/sys/compat/svr4/svr4_proto.h index 95a0ae7..d2a862f 100644 --- a/sys/compat/svr4/svr4_proto.h +++ b/sys/compat/svr4/svr4_proto.h @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/svr4/syscalls.master,v 1.10 2000/07/29 10:05:24 peter Exp + * created from FreeBSD: src/sys/compat/svr4/syscalls.master,v 1.11 2000/08/31 22:54:05 obrien Exp */ #ifndef _SVR4_SYSPROTO_H_ @@ -15,6 +15,8 @@ struct proc; +struct thread; + #define PAD_(t) (sizeof(register_t) <= sizeof(t) ? \ 0 : sizeof(register_t) - sizeof(t)) @@ -381,86 +383,86 @@ struct svr4_sys_sendto_args { struct sockaddr * to; char to_[PAD_(struct sockaddr *)]; int tolen; char tolen_[PAD_(int)]; }; -int svr4_sys_open __P((struct proc *, struct svr4_sys_open_args *)); -int svr4_sys_wait __P((struct proc *, struct svr4_sys_wait_args *)); -int svr4_sys_creat __P((struct proc *, struct svr4_sys_creat_args *)); -int svr4_sys_execv __P((struct proc *, struct svr4_sys_execv_args *)); -int svr4_sys_time __P((struct proc *, struct svr4_sys_time_args *)); -int svr4_sys_mknod __P((struct proc *, struct svr4_sys_mknod_args *)); -int svr4_sys_break __P((struct proc *, struct svr4_sys_break_args *)); -int svr4_sys_stat __P((struct proc *, struct svr4_sys_stat_args *)); -int svr4_sys_alarm __P((struct proc *, struct svr4_sys_alarm_args *)); -int svr4_sys_fstat __P((struct proc *, struct svr4_sys_fstat_args *)); -int svr4_sys_pause __P((struct proc *, struct svr4_sys_pause_args *)); -int svr4_sys_utime __P((struct proc *, struct svr4_sys_utime_args *)); -int svr4_sys_access __P((struct proc *, struct svr4_sys_access_args *)); -int svr4_sys_nice __P((struct proc *, struct svr4_sys_nice_args *)); -int svr4_sys_kill __P((struct proc *, struct svr4_sys_kill_args *)); -int svr4_sys_pgrpsys __P((struct proc *, struct svr4_sys_pgrpsys_args *)); -int svr4_sys_times __P((struct proc *, struct svr4_sys_times_args *)); -int svr4_sys_signal __P((struct proc *, struct svr4_sys_signal_args *)); +int svr4_sys_open __P((struct thread *, struct svr4_sys_open_args *)); +int svr4_sys_wait __P((struct thread *, struct svr4_sys_wait_args *)); +int svr4_sys_creat __P((struct thread *, struct svr4_sys_creat_args *)); +int svr4_sys_execv __P((struct thread *, struct svr4_sys_execv_args *)); +int svr4_sys_time __P((struct thread *, struct svr4_sys_time_args *)); +int svr4_sys_mknod __P((struct thread *, struct svr4_sys_mknod_args *)); +int svr4_sys_break __P((struct thread *, struct svr4_sys_break_args *)); +int svr4_sys_stat __P((struct thread *, struct svr4_sys_stat_args *)); +int svr4_sys_alarm __P((struct thread *, struct svr4_sys_alarm_args *)); +int svr4_sys_fstat __P((struct thread *, struct svr4_sys_fstat_args *)); +int svr4_sys_pause __P((struct thread *, struct svr4_sys_pause_args *)); +int svr4_sys_utime __P((struct thread *, struct svr4_sys_utime_args *)); +int svr4_sys_access __P((struct thread *, struct svr4_sys_access_args *)); +int svr4_sys_nice __P((struct thread *, struct svr4_sys_nice_args *)); +int svr4_sys_kill __P((struct thread *, struct svr4_sys_kill_args *)); +int svr4_sys_pgrpsys __P((struct thread *, struct svr4_sys_pgrpsys_args *)); +int svr4_sys_times __P((struct thread *, struct svr4_sys_times_args *)); +int svr4_sys_signal __P((struct thread *, struct svr4_sys_signal_args *)); #if defined(NOTYET) -int svr4_sys_msgsys __P((struct proc *, struct svr4_sys_msgsys_args *)); +int svr4_sys_msgsys __P((struct thread *, struct svr4_sys_msgsys_args *)); #else #endif -int svr4_sys_sysarch __P((struct proc *, struct svr4_sys_sysarch_args *)); -int svr4_sys_ioctl __P((struct proc *, struct svr4_sys_ioctl_args *)); -int svr4_sys_utssys __P((struct proc *, struct svr4_sys_utssys_args *)); -int svr4_sys_execve __P((struct proc *, struct svr4_sys_execve_args *)); -int svr4_sys_fcntl __P((struct proc *, struct svr4_sys_fcntl_args *)); -int svr4_sys_ulimit __P((struct proc *, struct svr4_sys_ulimit_args *)); -int svr4_sys_getdents __P((struct proc *, struct svr4_sys_getdents_args *)); -int svr4_sys_getmsg __P((struct proc *, struct svr4_sys_getmsg_args *)); -int svr4_sys_putmsg __P((struct proc *, struct svr4_sys_putmsg_args *)); -int svr4_sys_poll __P((struct proc *, struct svr4_sys_poll_args *)); -int svr4_sys_lstat __P((struct proc *, struct svr4_sys_lstat_args *)); -int svr4_sys_sigprocmask __P((struct proc *, struct svr4_sys_sigprocmask_args *)); -int svr4_sys_sigsuspend __P((struct proc *, struct svr4_sys_sigsuspend_args *)); -int svr4_sys_sigaltstack __P((struct proc *, struct svr4_sys_sigaltstack_args *)); -int svr4_sys_sigaction __P((struct proc *, struct svr4_sys_sigaction_args *)); -int svr4_sys_sigpending __P((struct proc *, struct svr4_sys_sigpending_args *)); -int svr4_sys_context __P((struct proc *, struct svr4_sys_context_args *)); -int svr4_sys_statvfs __P((struct proc *, struct svr4_sys_statvfs_args *)); -int svr4_sys_fstatvfs __P((struct proc *, struct svr4_sys_fstatvfs_args *)); -int svr4_sys_waitsys __P((struct proc *, struct svr4_sys_waitsys_args *)); -int svr4_sys_hrtsys __P((struct proc *, struct svr4_sys_hrtsys_args *)); -int svr4_sys_pathconf __P((struct proc *, struct svr4_sys_pathconf_args *)); -int svr4_sys_mmap __P((struct proc *, struct svr4_sys_mmap_args *)); -int svr4_sys_fpathconf __P((struct proc *, struct svr4_sys_fpathconf_args *)); -int svr4_sys_xstat __P((struct proc *, struct svr4_sys_xstat_args *)); -int svr4_sys_lxstat __P((struct proc *, struct svr4_sys_lxstat_args *)); -int svr4_sys_fxstat __P((struct proc *, struct svr4_sys_fxstat_args *)); -int svr4_sys_xmknod __P((struct proc *, struct svr4_sys_xmknod_args *)); -int svr4_sys_setrlimit __P((struct proc *, struct svr4_sys_setrlimit_args *)); -int svr4_sys_getrlimit __P((struct proc *, struct svr4_sys_getrlimit_args *)); -int svr4_sys_memcntl __P((struct proc *, struct svr4_sys_memcntl_args *)); -int svr4_sys_uname __P((struct proc *, struct svr4_sys_uname_args *)); -int svr4_sys_sysconfig __P((struct proc *, struct svr4_sys_sysconfig_args *)); -int svr4_sys_systeminfo __P((struct proc *, struct svr4_sys_systeminfo_args *)); -int svr4_sys_fchroot __P((struct proc *, struct svr4_sys_fchroot_args *)); -int svr4_sys_utimes __P((struct proc *, struct svr4_sys_utimes_args *)); -int svr4_sys_vhangup __P((struct proc *, struct svr4_sys_vhangup_args *)); -int svr4_sys_gettimeofday __P((struct proc *, struct svr4_sys_gettimeofday_args *)); -int svr4_sys_llseek __P((struct proc *, struct svr4_sys_llseek_args *)); -int svr4_sys_acl __P((struct proc *, struct svr4_sys_acl_args *)); -int svr4_sys_auditsys __P((struct proc *, struct svr4_sys_auditsys_args *)); -int svr4_sys_facl __P((struct proc *, struct svr4_sys_facl_args *)); -int svr4_sys_resolvepath __P((struct proc *, struct svr4_sys_resolvepath_args *)); -int svr4_sys_getdents64 __P((struct proc *, struct svr4_sys_getdents64_args *)); -int svr4_sys_mmap64 __P((struct proc *, struct svr4_sys_mmap64_args *)); -int svr4_sys_stat64 __P((struct proc *, struct svr4_sys_stat64_args *)); -int svr4_sys_lstat64 __P((struct proc *, struct svr4_sys_lstat64_args *)); -int svr4_sys_fstat64 __P((struct proc *, struct svr4_sys_fstat64_args *)); -int svr4_sys_statvfs64 __P((struct proc *, struct svr4_sys_statvfs64_args *)); -int svr4_sys_fstatvfs64 __P((struct proc *, struct svr4_sys_fstatvfs64_args *)); -int svr4_sys_setrlimit64 __P((struct proc *, struct svr4_sys_setrlimit64_args *)); -int svr4_sys_getrlimit64 __P((struct proc *, struct svr4_sys_getrlimit64_args *)); -int svr4_sys_creat64 __P((struct proc *, struct svr4_sys_creat64_args *)); -int svr4_sys_open64 __P((struct proc *, struct svr4_sys_open64_args *)); -int svr4_sys_socket __P((struct proc *, struct svr4_sys_socket_args *)); -int svr4_sys_recv __P((struct proc *, struct svr4_sys_recv_args *)); -int svr4_sys_send __P((struct proc *, struct svr4_sys_send_args *)); -int svr4_sys_sendto __P((struct proc *, struct svr4_sys_sendto_args *)); +int svr4_sys_sysarch __P((struct thread *, struct svr4_sys_sysarch_args *)); +int svr4_sys_ioctl __P((struct thread *, struct svr4_sys_ioctl_args *)); +int svr4_sys_utssys __P((struct thread *, struct svr4_sys_utssys_args *)); +int svr4_sys_execve __P((struct thread *, struct svr4_sys_execve_args *)); +int svr4_sys_fcntl __P((struct thread *, struct svr4_sys_fcntl_args *)); +int svr4_sys_ulimit __P((struct thread *, struct svr4_sys_ulimit_args *)); +int svr4_sys_getdents __P((struct thread *, struct svr4_sys_getdents_args *)); +int svr4_sys_getmsg __P((struct thread *, struct svr4_sys_getmsg_args *)); +int svr4_sys_putmsg __P((struct thread *, struct svr4_sys_putmsg_args *)); +int svr4_sys_poll __P((struct thread *, struct svr4_sys_poll_args *)); +int svr4_sys_lstat __P((struct thread *, struct svr4_sys_lstat_args *)); +int svr4_sys_sigprocmask __P((struct thread *, struct svr4_sys_sigprocmask_args *)); +int svr4_sys_sigsuspend __P((struct thread *, struct svr4_sys_sigsuspend_args *)); +int svr4_sys_sigaltstack __P((struct thread *, struct svr4_sys_sigaltstack_args *)); +int svr4_sys_sigaction __P((struct thread *, struct svr4_sys_sigaction_args *)); +int svr4_sys_sigpending __P((struct thread *, struct svr4_sys_sigpending_args *)); +int svr4_sys_context __P((struct thread *, struct svr4_sys_context_args *)); +int svr4_sys_statvfs __P((struct thread *, struct svr4_sys_statvfs_args *)); +int svr4_sys_fstatvfs __P((struct thread *, struct svr4_sys_fstatvfs_args *)); +int svr4_sys_waitsys __P((struct thread *, struct svr4_sys_waitsys_args *)); +int svr4_sys_hrtsys __P((struct thread *, struct svr4_sys_hrtsys_args *)); +int svr4_sys_pathconf __P((struct thread *, struct svr4_sys_pathconf_args *)); +int svr4_sys_mmap __P((struct thread *, struct svr4_sys_mmap_args *)); +int svr4_sys_fpathconf __P((struct thread *, struct svr4_sys_fpathconf_args *)); +int svr4_sys_xstat __P((struct thread *, struct svr4_sys_xstat_args *)); +int svr4_sys_lxstat __P((struct thread *, struct svr4_sys_lxstat_args *)); +int svr4_sys_fxstat __P((struct thread *, struct svr4_sys_fxstat_args *)); +int svr4_sys_xmknod __P((struct thread *, struct svr4_sys_xmknod_args *)); +int svr4_sys_setrlimit __P((struct thread *, struct svr4_sys_setrlimit_args *)); +int svr4_sys_getrlimit __P((struct thread *, struct svr4_sys_getrlimit_args *)); +int svr4_sys_memcntl __P((struct thread *, struct svr4_sys_memcntl_args *)); +int svr4_sys_uname __P((struct thread *, struct svr4_sys_uname_args *)); +int svr4_sys_sysconfig __P((struct thread *, struct svr4_sys_sysconfig_args *)); +int svr4_sys_systeminfo __P((struct thread *, struct svr4_sys_systeminfo_args *)); +int svr4_sys_fchroot __P((struct thread *, struct svr4_sys_fchroot_args *)); +int svr4_sys_utimes __P((struct thread *, struct svr4_sys_utimes_args *)); +int svr4_sys_vhangup __P((struct thread *, struct svr4_sys_vhangup_args *)); +int svr4_sys_gettimeofday __P((struct thread *, struct svr4_sys_gettimeofday_args *)); +int svr4_sys_llseek __P((struct thread *, struct svr4_sys_llseek_args *)); +int svr4_sys_acl __P((struct thread *, struct svr4_sys_acl_args *)); +int svr4_sys_auditsys __P((struct thread *, struct svr4_sys_auditsys_args *)); +int svr4_sys_facl __P((struct thread *, struct svr4_sys_facl_args *)); +int svr4_sys_resolvepath __P((struct thread *, struct svr4_sys_resolvepath_args *)); +int svr4_sys_getdents64 __P((struct thread *, struct svr4_sys_getdents64_args *)); +int svr4_sys_mmap64 __P((struct thread *, struct svr4_sys_mmap64_args *)); +int svr4_sys_stat64 __P((struct thread *, struct svr4_sys_stat64_args *)); +int svr4_sys_lstat64 __P((struct thread *, struct svr4_sys_lstat64_args *)); +int svr4_sys_fstat64 __P((struct thread *, struct svr4_sys_fstat64_args *)); +int svr4_sys_statvfs64 __P((struct thread *, struct svr4_sys_statvfs64_args *)); +int svr4_sys_fstatvfs64 __P((struct thread *, struct svr4_sys_fstatvfs64_args *)); +int svr4_sys_setrlimit64 __P((struct thread *, struct svr4_sys_setrlimit64_args *)); +int svr4_sys_getrlimit64 __P((struct thread *, struct svr4_sys_getrlimit64_args *)); +int svr4_sys_creat64 __P((struct thread *, struct svr4_sys_creat64_args *)); +int svr4_sys_open64 __P((struct thread *, struct svr4_sys_open64_args *)); +int svr4_sys_socket __P((struct thread *, struct svr4_sys_socket_args *)); +int svr4_sys_recv __P((struct thread *, struct svr4_sys_recv_args *)); +int svr4_sys_send __P((struct thread *, struct svr4_sys_send_args *)); +int svr4_sys_sendto __P((struct thread *, struct svr4_sys_sendto_args *)); #ifdef COMPAT_43 diff --git a/sys/compat/svr4/svr4_resource.c b/sys/compat/svr4/svr4_resource.c index 2b52140..976475d 100644 --- a/sys/compat/svr4/svr4_resource.c +++ b/sys/compat/svr4/svr4_resource.c @@ -128,8 +128,8 @@ svr4_to_native_rl(rl) ((svr4_rlim64_t)(l)) != SVR4_RLIM64_SAVED_MAX) int -svr4_sys_getrlimit(p, uap) - register struct proc *p; +svr4_sys_getrlimit(td, uap) + register struct thread *td; struct svr4_sys_getrlimit_args *uap; { int rl = svr4_to_native_rl(SCARG(uap, which)); @@ -141,7 +141,7 @@ svr4_sys_getrlimit(p, uap) /* For p_rlimit. */ mtx_assert(&Giant, MA_OWNED); - blim = p->p_rlimit[rl]; + blim = td->td_proc->p_rlimit[rl]; /* * Our infinity, is their maxfiles. @@ -175,8 +175,8 @@ svr4_sys_getrlimit(p, uap) int -svr4_sys_setrlimit(p, uap) - register struct proc *p; +svr4_sys_setrlimit(td, uap) + register struct thread *td; struct svr4_sys_setrlimit_args *uap; { int rl = svr4_to_native_rl(SCARG(uap, which)); @@ -189,7 +189,7 @@ svr4_sys_setrlimit(p, uap) /* For p_rlimit. */ mtx_assert(&Giant, MA_OWNED); - limp = &p->p_rlimit[rl]; + limp = &td->td_proc->p_rlimit[rl]; if ((error = copyin(SCARG(uap, rlp), &slim, sizeof(slim))) != 0) return error; @@ -221,13 +221,13 @@ svr4_sys_setrlimit(p, uap) else if (slim.rlim_cur == SVR4_RLIM_SAVED_CUR) blim.rlim_cur = limp->rlim_cur; - return dosetrlimit(p, rl, &blim); + return dosetrlimit(td, rl, &blim); } int -svr4_sys_getrlimit64(p, uap) - register struct proc *p; +svr4_sys_getrlimit64(td, uap) + register struct thread *td; struct svr4_sys_getrlimit64_args *uap; { int rl = svr4_to_native_rl(SCARG(uap, which)); @@ -239,7 +239,7 @@ svr4_sys_getrlimit64(p, uap) /* For p_rlimit. */ mtx_assert(&Giant, MA_OWNED); - blim = p->p_rlimit[rl]; + blim = td->td_proc->p_rlimit[rl]; /* * Our infinity, is their maxfiles. @@ -273,8 +273,8 @@ svr4_sys_getrlimit64(p, uap) int -svr4_sys_setrlimit64(p, uap) - register struct proc *p; +svr4_sys_setrlimit64(td, uap) + register struct thread *td; struct svr4_sys_setrlimit64_args *uap; { int rl = svr4_to_native_rl(SCARG(uap, which)); @@ -287,7 +287,7 @@ svr4_sys_setrlimit64(p, uap) /* For p_rlimit. */ mtx_assert(&Giant, MA_OWNED); - limp = &p->p_rlimit[rl]; + limp = &td->td_proc->p_rlimit[rl]; if ((error = copyin(SCARG(uap, rlp), &slim, sizeof(slim))) != 0) return error; @@ -319,5 +319,5 @@ svr4_sys_setrlimit64(p, uap) else if (slim.rlim_cur == SVR4_RLIM64_SAVED_CUR) blim.rlim_cur = limp->rlim_cur; - return dosetrlimit(p, rl, &blim); + return dosetrlimit(td, rl, &blim); } diff --git a/sys/compat/svr4/svr4_signal.c b/sys/compat/svr4/svr4_signal.c index 0273a7a..d4bf8e9 100644 --- a/sys/compat/svr4/svr4_signal.c +++ b/sys/compat/svr4/svr4_signal.c @@ -260,8 +260,8 @@ bsd_to_svr4_sigaltstack(bss, sss) } int -svr4_sys_sigaction(p, uap) - register struct proc *p; +svr4_sys_sigaction(td, uap) + register struct thread *td; struct svr4_sys_sigaction_args *uap; { struct svr4_sigaction *nisa, *oisa, tmpisa; @@ -270,7 +270,7 @@ svr4_sys_sigaction(p, uap) caddr_t sg; int error; - DPRINTF(("@@@ svr4_sys_sigaction(%d, %d, %d)\n", p->p_pid, + DPRINTF(("@@@ svr4_sys_sigaction(%d, %d, %d)\n", td->td_proc->p_pid, SCARG(uap, signum), SVR4_SVR42BSD_SIG(SCARG(uap, signum)))); @@ -307,7 +307,7 @@ svr4_sys_sigaction(p, uap) SCARG(&sa, act) = nbsa; SCARG(&sa, oact) = obsa; - if ((error = sigaction(p, &sa)) != 0) + if ((error = sigaction(td, &sa)) != 0) return error; if (oisa != NULL) { @@ -322,8 +322,8 @@ svr4_sys_sigaction(p, uap) } int -svr4_sys_sigaltstack(p, uap) - register struct proc *p; +svr4_sys_sigaltstack(td, uap) + register struct thread *td; struct svr4_sys_sigaltstack_args *uap; { struct svr4_sigaltstack *nsss, *osss, tmpsss; @@ -332,7 +332,7 @@ svr4_sys_sigaltstack(p, uap) caddr_t sg; int error, *retval; - retval = p->p_retval; + retval = td->td_retval; sg = stackgap_init(); nsss = SCARG(uap, nss); osss = SCARG(uap, oss); @@ -355,7 +355,7 @@ svr4_sys_sigaltstack(p, uap) SCARG(&sa, ss) = nbss; SCARG(&sa, oss) = obss; - if ((error = sigaltstack(p, &sa)) != 0) + if ((error = sigaltstack(td, &sa)) != 0) return error; if (obss != NULL) { @@ -373,15 +373,15 @@ svr4_sys_sigaltstack(p, uap) * Stolen from the ibcs2 one */ int -svr4_sys_signal(p, uap) - register struct proc *p; +svr4_sys_signal(td, uap) + register struct thread *td; struct svr4_sys_signal_args *uap; { int signum; - int error, *retval = p->p_retval; + int error, *retval = td->td_retval; caddr_t sg = stackgap_init(); - DPRINTF(("@@@ svr4_sys_signal(%d)\n", p->p_pid)); + DPRINTF(("@@@ svr4_sys_signal(%d)\n", td->td_proc->p_pid)); signum = SVR4_SVR42BSD_SIG(SVR4_SIGNO(SCARG(uap, signum))); if (signum <= 0 || signum > SVR4_NSIG) @@ -413,7 +413,7 @@ svr4_sys_signal(p, uap) if ((error = copyout(&sa, nbsa, sizeof(sa))) != 0) return error; - if ((error = sigaction(p, &sa_args)) != 0) { + if ((error = sigaction(td, &sa_args)) != 0) { DPRINTF(("signal: sigaction failed: %d\n", error)); *retval = (int)SVR4_SIG_ERR; @@ -437,7 +437,7 @@ sighold: SCARG(&sa, how) = SIG_BLOCK; SCARG(&sa, set) = set; SCARG(&sa, oset) = NULL; - return sigprocmask(p, &sa); + return sigprocmask(td, &sa); } case SVR4_SIGRELSE_MASK: @@ -451,7 +451,7 @@ sighold: SCARG(&sa, how) = SIG_UNBLOCK; SCARG(&sa, set) = set; SCARG(&sa, oset) = NULL; - return sigprocmask(p, &sa); + return sigprocmask(td, &sa); } case SVR4_SIGIGNORE_MASK: @@ -469,7 +469,7 @@ sighold: sa.sa_flags = 0; if ((error = copyout(&sa, bsa, sizeof(sa))) != 0) return error; - if ((error = sigaction(p, &sa_args)) != 0) { + if ((error = sigaction(td, &sa_args)) != 0) { DPRINTF(("sigignore: sigaction failed\n")); return error; } @@ -482,12 +482,12 @@ sighold: sigset_t *set; set = stackgap_alloc(&sg, sizeof(sigset_t)); - PROC_LOCK(p); - *set = p->p_sigmask; - PROC_UNLOCK(p); + PROC_LOCK(td->td_proc); + *set = td->td_proc->p_sigmask; + PROC_UNLOCK(td->td_proc); SIGDELSET(*set, signum); SCARG(&sa, sigmask) = set; - return sigsuspend(p, &sa); + return sigsuspend(td, &sa); } default: @@ -497,20 +497,20 @@ sighold: int -svr4_sys_sigprocmask(p, uap) - struct proc *p; +svr4_sys_sigprocmask(td, uap) + struct thread *td; struct svr4_sys_sigprocmask_args *uap; { svr4_sigset_t sss; sigset_t bss; int error = 0, *retval; - retval = p->p_retval; + retval = td->td_retval; if (SCARG(uap, oset) != NULL) { /* Fix the return value first if needed */ - PROC_LOCK(p); - bsd_to_svr4_sigset(&p->p_sigmask, &sss); - PROC_UNLOCK(p); + PROC_LOCK(td->td_proc); + bsd_to_svr4_sigset(&td->td_proc->p_sigmask, &sss); + PROC_UNLOCK(td->td_proc); if ((error = copyout(&sss, SCARG(uap, oset), sizeof(sss))) != 0) return error; } @@ -524,50 +524,50 @@ svr4_sys_sigprocmask(p, uap) svr4_to_bsd_sigset(&sss, &bss); - PROC_LOCK(p); + PROC_LOCK(td->td_proc); switch (SCARG(uap, how)) { case SVR4_SIG_BLOCK: - SIGSETOR(p->p_sigmask, bss); - SIG_CANTMASK(p->p_sigmask); + SIGSETOR(td->td_proc->p_sigmask, bss); + SIG_CANTMASK(td->td_proc->p_sigmask); break; case SVR4_SIG_UNBLOCK: - SIGSETNAND(p->p_sigmask, bss); + SIGSETNAND(td->td_proc->p_sigmask, bss); break; case SVR4_SIG_SETMASK: - p->p_sigmask = bss; - SIG_CANTMASK(p->p_sigmask); + td->td_proc->p_sigmask = bss; + SIG_CANTMASK(td->td_proc->p_sigmask); break; default: error = EINVAL; break; } - PROC_UNLOCK(p); + PROC_UNLOCK(td->td_proc); return error; } int -svr4_sys_sigpending(p, uap) - struct proc *p; +svr4_sys_sigpending(td, uap) + struct thread *td; struct svr4_sys_sigpending_args *uap; { sigset_t bss; int *retval; svr4_sigset_t sss; - DPRINTF(("@@@ svr4_sys_sigpending(%d)\n", p->p_pid)); - retval = p->p_retval; + DPRINTF(("@@@ svr4_sys_sigpending(%d)\n", td->td_proc->p_pid)); + retval = td->td_retval; switch (SCARG(uap, what)) { case 1: /* sigpending */ if (SCARG(uap, mask) == NULL) return 0; - PROC_LOCK(p); - bss = p->p_siglist; - SIGSETAND(bss, p->p_sigmask); - PROC_UNLOCK(p); + PROC_LOCK(td->td_proc); + bss = td->td_proc->p_siglist; + SIGSETAND(bss, td->td_proc->p_sigmask); + PROC_UNLOCK(td->td_proc); bsd_to_svr4_sigset(&bss, &sss); break; @@ -590,8 +590,8 @@ svr4_sys_sigpending(p, uap) } int -svr4_sys_sigsuspend(p, uap) - register struct proc *p; +svr4_sys_sigsuspend(td, uap) + register struct thread *td; struct svr4_sys_sigsuspend_args *uap; { svr4_sigset_t sss; @@ -607,26 +607,26 @@ svr4_sys_sigsuspend(p, uap) svr4_to_bsd_sigset(&sss, bss); SCARG(&sa, sigmask) = bss; - return sigsuspend(p, &sa); + return sigsuspend(td, &sa); } int -svr4_sys_kill(p, uap) - register struct proc *p; +svr4_sys_kill(td, uap) + register struct thread *td; struct svr4_sys_kill_args *uap; { struct kill_args ka; SCARG(&ka, pid) = SCARG(uap, pid); SCARG(&ka, signum) = SVR4_SVR42BSD_SIG(SCARG(uap, signum)); - return kill(p, &ka); + return kill(td, &ka); } int -svr4_sys_context(p, uap) - register struct proc *p; +svr4_sys_context(td, uap) + register struct thread *td; struct svr4_sys_context_args *uap; { struct svr4_ucontext uc; @@ -634,11 +634,11 @@ svr4_sys_context(p, uap) switch (uap->func) { case 0: - PROC_LOCK(p); + PROC_LOCK(td->td_proc); DPRINTF(("getcontext(%p)\n", uap->uc)); - svr4_getcontext(p, &uc, &p->p_sigmask, - sigonstack(cpu_getstack(p))); - PROC_UNLOCK(p); + svr4_getcontext(td, &uc, &td->td_proc->p_sigmask, + sigonstack(cpu_getstack(td))); + PROC_UNLOCK(td->td_proc); return copyout(&uc, uap->uc, sizeof(uc)); case 1: @@ -654,7 +654,7 @@ svr4_sys_context(p, uap) uc.uc_sigmask.bits[i])); } #endif - return svr4_setcontext(p, &uc); + return svr4_setcontext(td, &uc); default: DPRINTF(("context(%d, %p)\n", uap->func, @@ -665,12 +665,12 @@ svr4_sys_context(p, uap) } int -svr4_sys_pause(p, uap) - register struct proc *p; +svr4_sys_pause(td, uap) + register struct thread *td; struct svr4_sys_pause_args *uap; { struct sigsuspend_args bsa; - SCARG(&bsa, sigmask) = &p->p_sigmask; - return sigsuspend(p, &bsa); + SCARG(&bsa, sigmask) = &td->td_proc->p_sigmask; + return sigsuspend(td, &bsa); } diff --git a/sys/compat/svr4/svr4_socket.c b/sys/compat/svr4/svr4_socket.c index bd14556..b4f2b55 100644 --- a/sys/compat/svr4/svr4_socket.c +++ b/sys/compat/svr4/svr4_socket.c @@ -75,8 +75,8 @@ extern TAILQ_HEAD(svr4_sockcache_head, svr4_sockcache_entry) svr4_head; extern int svr4_str_initialized; struct sockaddr_un * -svr4_find_socket(p, fp, dev, ino) - struct proc *p; +svr4_find_socket(td, fp, dev, ino) + struct thread *td; struct file *fp; udev_t dev; ino_t ino; @@ -87,7 +87,7 @@ svr4_find_socket(p, fp, dev, ino) if (svr4_str_initialized != 2) { if (atomic_cmpset_acq_int(&svr4_str_initialized, 0, 1)) { DPRINTF(("svr4_find_socket: uninitialized [%p,%d,%d]\n", - p, dev, ino)); + td, dev, ino)); TAILQ_INIT(&svr4_head); atomic_store_rel_int(&svr4_str_initialized, 2); } @@ -95,9 +95,9 @@ svr4_find_socket(p, fp, dev, ino) } - DPRINTF(("svr4_find_socket: [%p,%d,%d]: ", p, dev, ino)); + DPRINTF(("svr4_find_socket: [%p,%d,%d]: ", td, dev, ino)); TAILQ_FOREACH(e, &svr4_head, entries) - if (e->p == p && e->dev == dev && e->ino == ino) { + if (e->p == td->td_proc && e->dev == dev && e->ino == ino) { #ifdef DIAGNOSTIC if (e->cookie != NULL && e->cookie != cookie) panic("svr4 socket cookie mismatch"); @@ -117,8 +117,8 @@ svr4_find_socket(p, fp, dev, ino) * the streams "soo_close()" routine). */ int -svr4_add_socket(p, path, st) - struct proc *p; +svr4_add_socket(td, path, st) + struct thread *td; const char *path; struct stat *st; { @@ -142,7 +142,7 @@ svr4_add_socket(p, path, st) e->cookie = NULL; e->dev = st->st_dev; e->ino = st->st_ino; - e->p = p; + e->p = td->td_proc; if ((error = copyinstr(path, e->sock.sun_path, sizeof(e->sock.sun_path), &len)) != 0) { @@ -156,14 +156,14 @@ svr4_add_socket(p, path, st) TAILQ_INSERT_HEAD(&svr4_head, e, entries); DPRINTF(("svr4_add_socket: %s [%p,%d,%d]\n", e->sock.sun_path, - p, e->dev, e->ino)); + td->td_proc, e->dev, e->ino)); return 0; } int -svr4_sys_socket(p, uap) - struct proc *p; +svr4_sys_socket(td, uap) + struct thread *td; struct svr4_sys_socket_args *uap; { switch (SCARG(uap, type)) { @@ -189,5 +189,5 @@ svr4_sys_socket(p, uap) default: return EINVAL; } - return socket(p, (struct socket_args *)uap); + return socket(td, (struct socket_args *)uap); } diff --git a/sys/compat/svr4/svr4_socket.h b/sys/compat/svr4/svr4_socket.h index 96e3582..e860392 100644 --- a/sys/compat/svr4/svr4_socket.h +++ b/sys/compat/svr4/svr4_socket.h @@ -38,6 +38,7 @@ struct sockaddr_un; struct proc; +struct thread; struct file; struct svr4_sockaddr_in { @@ -47,9 +48,9 @@ struct svr4_sockaddr_in { u_char sin_zero[8]; }; -struct sockaddr_un *svr4_find_socket __P((struct proc *, struct file *, +struct sockaddr_un *svr4_find_socket __P((struct thread *, struct file *, udev_t, ino_t)); void svr4_delete_socket __P((struct proc *, struct file *)); -int svr4_add_socket __P((struct proc *, const char *, struct stat *)); +int svr4_add_socket __P((struct thread *, const char *, struct stat *)); #endif /* _SVR4_SOCKET_H_ */ diff --git a/sys/compat/svr4/svr4_sockio.c b/sys/compat/svr4/svr4_sockio.c index b96be4d..65cf49a 100644 --- a/sys/compat/svr4/svr4_sockio.c +++ b/sys/compat/svr4/svr4_sockio.c @@ -70,9 +70,9 @@ bsd_to_svr4_flags(bf) } int -svr4_sock_ioctl(fp, p, retval, fd, cmd, data) +svr4_sock_ioctl(fp, td, retval, fd, cmd, data) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -125,7 +125,7 @@ svr4_sock_ioctl(fp, p, retval, fd, cmd, data) (void) strncpy(br.ifr_name, sr.svr4_ifr_name, sizeof(br.ifr_name)); if ((error = fo_ioctl(fp, SIOCGIFFLAGS, - (caddr_t) &br, p)) != 0) { + (caddr_t) &br, td)) != 0) { DPRINTF(("SIOCGIFFLAGS (%s) %s: error %d\n", br.ifr_name, sr.svr4_ifr_name, error)); return error; @@ -149,7 +149,7 @@ svr4_sock_ioctl(fp, p, retval, fd, cmd, data) sc.svr4_ifc_len)); if ((error = fo_ioctl(fp, OSIOCGIFCONF, - (caddr_t) &sc, p)) != 0) + (caddr_t) &sc, td)) != 0) return error; DPRINTF(("SIOCGIFCONF\n")); diff --git a/sys/compat/svr4/svr4_stat.c b/sys/compat/svr4/svr4_stat.c index a3f22c8..d44a51b 100644 --- a/sys/compat/svr4/svr4_stat.c +++ b/sys/compat/svr4/svr4_stat.c @@ -73,7 +73,7 @@ struct svr4_ustat_args { static void bsd_to_svr4_xstat __P((struct stat *, struct svr4_xstat *)); static void bsd_to_svr4_stat64 __P((struct stat *, struct svr4_stat64 *)); -int svr4_ustat __P((struct proc *, struct svr4_ustat_args *)); +int svr4_ustat __P((struct thread *, struct svr4_ustat_args *)); static int svr4_to_bsd_pathconf __P((int)); /* @@ -153,8 +153,8 @@ bsd_to_svr4_stat64(st, st4) } int -svr4_sys_stat(p, uap) - struct proc *p; +svr4_sys_stat(td, uap) + struct thread *td; struct svr4_sys_stat_args *uap; { struct stat st; @@ -163,13 +163,13 @@ svr4_sys_stat(p, uap) int error; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat)); - if ((error = stat(p, &cup)) != 0) + if ((error = stat(td, &cup)) != 0) return error; if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0) @@ -178,7 +178,7 @@ svr4_sys_stat(p, uap) bsd_to_svr4_stat(&st, &svr4_st); if (S_ISSOCK(st.st_mode)) - (void) svr4_add_socket(p, SCARG(uap, path), &st); + (void) svr4_add_socket(td, SCARG(uap, path), &st); if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0) return error; @@ -188,8 +188,8 @@ svr4_sys_stat(p, uap) int -svr4_sys_lstat(p, uap) - register struct proc *p; +svr4_sys_lstat(td, uap) + register struct thread *td; struct svr4_sys_lstat_args *uap; { struct stat st; @@ -198,12 +198,12 @@ svr4_sys_lstat(p, uap) int error; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat)); - if ((error = lstat(p, &cup)) != 0) + if ((error = lstat(td, &cup)) != 0) return error; if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0) @@ -212,7 +212,7 @@ svr4_sys_lstat(p, uap) bsd_to_svr4_stat(&st, &svr4_st); if (S_ISSOCK(st.st_mode)) - (void) svr4_add_socket(p, SCARG(uap, path), &st); + (void) svr4_add_socket(td, SCARG(uap, path), &st); if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0) return error; @@ -222,8 +222,8 @@ svr4_sys_lstat(p, uap) int -svr4_sys_fstat(p, uap) - register struct proc *p; +svr4_sys_fstat(td, uap) + register struct thread *td; struct svr4_sys_fstat_args *uap; { struct stat st; @@ -235,7 +235,7 @@ svr4_sys_fstat(p, uap) SCARG(&cup, fd) = SCARG(uap, fd); SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat)); - if ((error = fstat(p, &cup)) != 0) + if ((error = fstat(td, &cup)) != 0) return error; if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0) @@ -251,8 +251,8 @@ svr4_sys_fstat(p, uap) int -svr4_sys_xstat(p, uap) - register struct proc *p; +svr4_sys_xstat(td, uap) + register struct thread *td; struct svr4_sys_xstat_args *uap; { struct stat st; @@ -261,12 +261,12 @@ svr4_sys_xstat(p, uap) int error; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat)); - if ((error = stat(p, &cup)) != 0) + if ((error = stat(td, &cup)) != 0) return error; if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0) @@ -276,7 +276,7 @@ svr4_sys_xstat(p, uap) #if defined(SOCKET_NOTYET) if (S_ISSOCK(st.st_mode)) - (void) svr4_add_socket(p, SCARG(uap, path), &st); + (void) svr4_add_socket(td, SCARG(uap, path), &st); #endif if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0) @@ -286,8 +286,8 @@ svr4_sys_xstat(p, uap) } int -svr4_sys_lxstat(p, uap) - register struct proc *p; +svr4_sys_lxstat(td, uap) + register struct thread *td; struct svr4_sys_lxstat_args *uap; { struct stat st; @@ -295,12 +295,12 @@ svr4_sys_lxstat(p, uap) struct lstat_args cup; int error; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat)); - if ((error = lstat(p, &cup)) != 0) + if ((error = lstat(td, &cup)) != 0) return error; if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0) @@ -310,7 +310,7 @@ svr4_sys_lxstat(p, uap) #if defined(SOCKET_NOTYET) if (S_ISSOCK(st.st_mode)) - (void) svr4_add_socket(p, SCARG(uap, path), &st); + (void) svr4_add_socket(td, SCARG(uap, path), &st); #endif if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0) return error; @@ -320,8 +320,8 @@ svr4_sys_lxstat(p, uap) int -svr4_sys_fxstat(p, uap) - register struct proc *p; +svr4_sys_fxstat(td, uap) + register struct thread *td; struct svr4_sys_fxstat_args *uap; { struct stat st; @@ -334,7 +334,7 @@ svr4_sys_fxstat(p, uap) SCARG(&cup, fd) = SCARG(uap, fd); SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat)); - if ((error = fstat(p, &cup)) != 0) + if ((error = fstat(td, &cup)) != 0) return error; if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0) @@ -349,8 +349,8 @@ svr4_sys_fxstat(p, uap) } int -svr4_sys_stat64(p, uap) - register struct proc *p; +svr4_sys_stat64(td, uap) + register struct thread *td; struct svr4_sys_stat64_args *uap; { struct stat st; @@ -359,12 +359,12 @@ svr4_sys_stat64(p, uap) int error; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat)); - if ((error = stat(p, &cup)) != 0) + if ((error = stat(td, &cup)) != 0) return error; if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0) @@ -373,7 +373,7 @@ svr4_sys_stat64(p, uap) bsd_to_svr4_stat64(&st, &svr4_st); if (S_ISSOCK(st.st_mode)) - (void) svr4_add_socket(p, SCARG(uap, path), &st); + (void) svr4_add_socket(td, SCARG(uap, path), &st); if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0) return error; @@ -383,8 +383,8 @@ svr4_sys_stat64(p, uap) int -svr4_sys_lstat64(p, uap) - register struct proc *p; +svr4_sys_lstat64(td, uap) + register struct thread *td; struct svr4_sys_lstat64_args *uap; { struct stat st; @@ -393,12 +393,12 @@ svr4_sys_lstat64(p, uap) int error; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, (char *) SCARG(uap, path)); + CHECKALTEXIST(td, &sg, (char *) SCARG(uap, path)); SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat)); - if ((error = lstat(p, (struct lstat_args *)&cup)) != 0) + if ((error = lstat(td, (struct lstat_args *)&cup)) != 0) return error; if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0) @@ -407,7 +407,7 @@ svr4_sys_lstat64(p, uap) bsd_to_svr4_stat64(&st, &svr4_st); if (S_ISSOCK(st.st_mode)) - (void) svr4_add_socket(p, SCARG(uap, path), &st); + (void) svr4_add_socket(td, SCARG(uap, path), &st); if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0) return error; @@ -417,8 +417,8 @@ svr4_sys_lstat64(p, uap) int -svr4_sys_fstat64(p, uap) - register struct proc *p; +svr4_sys_fstat64(td, uap) + register struct thread *td; struct svr4_sys_fstat64_args *uap; { struct stat st; @@ -430,7 +430,7 @@ svr4_sys_fstat64(p, uap) SCARG(&cup, fd) = SCARG(uap, fd); SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat)); - if ((error = fstat(p, &cup)) != 0) + if ((error = fstat(td, &cup)) != 0) return error; if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0) @@ -446,8 +446,8 @@ svr4_sys_fstat64(p, uap) int -svr4_ustat(p, uap) - register struct proc *p; +svr4_ustat(td, uap) + register struct thread *td; struct svr4_ustat_args *uap; { struct svr4_ustat us; @@ -468,8 +468,8 @@ svr4_ustat(p, uap) /*extern char ostype[], hostname[], osrelease[], version[], machine[];*/ int -svr4_sys_uname(p, uap) - register struct proc *p; +svr4_sys_uname(td, uap) + register struct thread *td; struct svr4_sys_uname_args *uap; { struct svr4_utsname sut; @@ -497,13 +497,13 @@ svr4_sys_uname(p, uap) } int -svr4_sys_systeminfo(p, uap) - struct proc *p; +svr4_sys_systeminfo(td, uap) + struct thread *td; struct svr4_sys_systeminfo_args *uap; { char *str = NULL; int error = 0; - register_t *retval = p->p_retval; + register_t *retval = td->td_retval; size_t len = 0; char buf[1]; /* XXX NetBSD uses 256, but that seems like awfully excessive kstack usage @@ -563,13 +563,13 @@ svr4_sys_systeminfo(p, uap) if ((error = suser(p)) != 0) return error; name = KERN_HOSTNAME; - return kern_sysctl(&name, 1, 0, 0, SCARG(uap, buf), rlen, p); + return kern_sysctl(&name, 1, 0, 0, SCARG(uap, buf), rlen, td); case SVR4_SI_SET_SRPC_DOMAIN: if ((error = suser(p)) != 0) return error; name = KERN_NISDOMAINNAME; - return kern_sysctl(&name, 1, 0, 0, SCARG(uap, buf), rlen, p); + return kern_sysctl(&name, 1, 0, 0, SCARG(uap, buf), rlen, td); #else case SVR4_SI_SET_HOSTNAME: case SVR4_SI_SET_SRPC_DOMAIN: @@ -607,8 +607,8 @@ svr4_sys_systeminfo(p, uap) } int -svr4_sys_utssys(p, uap) - register struct proc *p; +svr4_sys_utssys(td, uap) + register struct thread *td; struct svr4_sys_utssys_args *uap; { switch (SCARG(uap, sel)) { @@ -616,7 +616,7 @@ svr4_sys_utssys(p, uap) { struct svr4_sys_uname_args ua; SCARG(&ua, name) = SCARG(uap, a1); - return svr4_sys_uname(p, &ua); + return svr4_sys_uname(td, &ua); } case 2: /* ustat(2) */ @@ -624,7 +624,7 @@ svr4_sys_utssys(p, uap) struct svr4_ustat_args ua; SCARG(&ua, dev) = (svr4_dev_t) SCARG(uap, a2); SCARG(&ua, name) = SCARG(uap, a1); - return svr4_ustat(p, &ua); + return svr4_ustat(td, &ua); } case 3: /* fusers(2) */ @@ -638,8 +638,8 @@ svr4_sys_utssys(p, uap) int -svr4_sys_utime(p, uap) - register struct proc *p; +svr4_sys_utime(td, uap) + register struct thread *td; struct svr4_sys_utime_args *uap; { struct svr4_utimbuf ub; @@ -649,7 +649,7 @@ svr4_sys_utime(p, uap) caddr_t sg = stackgap_init(); void *ttp; - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&ap, path) = SCARG(uap, path); if (SCARG(uap, ubuf) != NULL) { if ((error = copyin(SCARG(uap, ubuf), &ub, sizeof(ub))) != 0) @@ -666,18 +666,18 @@ svr4_sys_utime(p, uap) } else SCARG(&ap, tptr) = NULL; - return utimes(p, &ap); + return utimes(td, &ap); } int -svr4_sys_utimes(p, uap) - register struct proc *p; +svr4_sys_utimes(td, uap) + register struct thread *td; struct svr4_sys_utimes_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); - return utimes(p, (struct utimes_args *)uap); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); + return utimes(td, (struct utimes_args *)uap); } static int @@ -730,14 +730,14 @@ svr4_to_bsd_pathconf(name) int -svr4_sys_pathconf(p, uap) - register struct proc *p; +svr4_sys_pathconf(td, uap) + register struct thread *td; struct svr4_sys_pathconf_args *uap; { caddr_t sg = stackgap_init(); - register_t *retval = p->p_retval; + register_t *retval = td->td_retval; - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(uap, name) = svr4_to_bsd_pathconf(SCARG(uap, name)); @@ -749,17 +749,17 @@ svr4_sys_pathconf(p, uap) *retval = 0; return 0; default: - return pathconf(p, (struct pathconf_args *)uap); + return pathconf(td, (struct pathconf_args *)uap); } } int -svr4_sys_fpathconf(p, uap) - register struct proc *p; +svr4_sys_fpathconf(td, uap) + register struct thread *td; struct svr4_sys_fpathconf_args *uap; { - register_t *retval = p->p_retval; + register_t *retval = td->td_retval; SCARG(uap, name) = svr4_to_bsd_pathconf(SCARG(uap, name)); @@ -771,6 +771,6 @@ svr4_sys_fpathconf(p, uap) *retval = 0; return 0; default: - return fpathconf(p, (struct fpathconf_args *)uap); + return fpathconf(td, (struct fpathconf_args *)uap); } } diff --git a/sys/compat/svr4/svr4_stream.c b/sys/compat/svr4/svr4_stream.c index 45a2a5e..cb19305 100644 --- a/sys/compat/svr4/svr4_stream.c +++ b/sys/compat/svr4/svr4_stream.c @@ -75,7 +75,7 @@ #include <compat/svr4/svr4_socket.h> /* Utils */ -static int clean_pipe __P((struct proc *, const char *)); +static int clean_pipe __P((struct thread *, const char *)); static void getparm __P((struct file *, struct svr4_si_sockparms *)); /* Address Conversions */ @@ -89,48 +89,48 @@ static void netaddr_to_sockaddr_un __P((struct sockaddr_un *, const struct svr4_strmcmd *)); /* stream ioctls */ -static int i_nread __P((struct file *, struct proc *, register_t *, int, +static int i_nread __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); -static int i_fdinsert __P((struct file *, struct proc *, register_t *, int, +static int i_fdinsert __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); -static int i_str __P((struct file *, struct proc *, register_t *, int, +static int i_str __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); -static int i_setsig __P((struct file *, struct proc *, register_t *, int, +static int i_setsig __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); -static int i_getsig __P((struct file *, struct proc *, register_t *, int, +static int i_getsig __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); -static int _i_bind_rsvd __P((struct file *, struct proc *, register_t *, int, +static int _i_bind_rsvd __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); -static int _i_rele_rsvd __P((struct file *, struct proc *, register_t *, int, +static int _i_rele_rsvd __P((struct file *, struct thread *, register_t *, int, u_long, caddr_t)); /* i_str sockmod calls */ static int sockmod __P((struct file *, int, struct svr4_strioctl *, - struct proc *)); + struct thread *)); static int si_listen __P((struct file *, int, struct svr4_strioctl *, - struct proc *)); + struct thread *)); static int si_ogetudata __P((struct file *, int, struct svr4_strioctl *, - struct proc *)); + struct thread *)); static int si_sockparams __P((struct file *, int, struct svr4_strioctl *, - struct proc *)); + struct thread *)); static int si_shutdown __P((struct file *, int, struct svr4_strioctl *, - struct proc *)); + struct thread *)); static int si_getudata __P((struct file *, int, struct svr4_strioctl *, - struct proc *)); + struct thread *)); /* i_str timod calls */ static int timod __P((struct file *, int, struct svr4_strioctl *, - struct proc *)); + struct thread *)); static int ti_getinfo __P((struct file *, int, struct svr4_strioctl *, - struct proc *)); + struct thread *)); static int ti_bind __P((struct file *, int, struct svr4_strioctl *, - struct proc *)); + struct thread *)); /* infrastructure */ -static int svr4_sendit __P((struct proc *p, int s, struct msghdr *mp, +static int svr4_sendit __P((struct thread *td, int s, struct msghdr *mp, int flags)); -static int svr4_recvit __P((struct proc *p, int s, struct msghdr *mp, +static int svr4_recvit __P((struct thread *td, int s, struct msghdr *mp, caddr_t namelenp)); /* <sigh> Ok, so we shouldn't use sendit() in uipc_syscalls.c because @@ -144,8 +144,8 @@ static int svr4_recvit __P((struct proc *p, int s, struct msghdr *mp, * I will take out all the #ifdef COMPAT_OLDSOCK gumph, though. */ static int -svr4_sendit(p, s, mp, flags) - register struct proc *p; +svr4_sendit(td, s, mp, flags) + register struct thread *td; int s; register struct msghdr *mp; int flags; @@ -163,27 +163,27 @@ svr4_sendit(p, s, mp, flags) struct uio ktruio; #endif - error = holdsock(p->p_fd, s, &fp); + error = holdsock(td->td_proc->p_fd, s, &fp); if (error) return (error); auio.uio_iov = mp->msg_iov; auio.uio_iovcnt = mp->msg_iovlen; auio.uio_segflg = UIO_USERSPACE; auio.uio_rw = UIO_WRITE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; /* XXX */ auio.uio_resid = 0; iov = mp->msg_iov; for (i = 0; i < mp->msg_iovlen; i++, iov++) { if ((auio.uio_resid += iov->iov_len) < 0) { - fdrop(fp, p); + fdrop(fp, td); return (EINVAL); } } if (mp->msg_name) { error = getsockaddr(&to, mp->msg_name, mp->msg_namelen); if (error) { - fdrop(fp, p); + fdrop(fp, td); return (error); } } else { @@ -202,7 +202,7 @@ svr4_sendit(p, s, mp, flags) control = 0; } #ifdef KTRACE - if (KTRPOINT(p, KTR_GENIO)) { + if (KTRPOINT(td->td_proc, KTR_GENIO)) { int iovlen = auio.uio_iovcnt * sizeof (struct iovec); MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); @@ -213,25 +213,25 @@ svr4_sendit(p, s, mp, flags) len = auio.uio_resid; so = (struct socket *)fp->f_data; error = so->so_proto->pr_usrreqs->pru_sosend(so, to, &auio, 0, control, - flags, p); + flags, td); if (error) { if (auio.uio_resid != len && (error == ERESTART || error == EINTR || error == EWOULDBLOCK)) error = 0; if (error == EPIPE) { - PROC_LOCK(p); - psignal(p, SIGPIPE); - PROC_UNLOCK(p); + PROC_LOCK(td->td_proc); + psignal(td->td_proc, SIGPIPE); + PROC_UNLOCK(td->td_proc); } } if (error == 0) - p->p_retval[0] = len - auio.uio_resid; + td->td_retval[0] = len - auio.uio_resid; #ifdef KTRACE if (ktriov != NULL) { if (error == 0) { ktruio.uio_iov = ktriov; - ktruio.uio_resid = p->p_retval[0]; - ktrgenio(p->p_tracep, s, UIO_WRITE, &ktruio, error); + ktruio.uio_resid = td->td_retval[0]; + ktrgenio(td->td_proc->p_tracep, s, UIO_WRITE, &ktruio, error); } FREE(ktriov, M_TEMP); } @@ -239,13 +239,13 @@ svr4_sendit(p, s, mp, flags) bad: if (to) FREE(to, M_SONAME); - fdrop(fp, p); + fdrop(fp, td); return (error); } static int -svr4_recvit(p, s, mp, namelenp) - register struct proc *p; +svr4_recvit(td, s, mp, namelenp) + register struct thread *td; int s; register struct msghdr *mp; caddr_t namelenp; @@ -264,25 +264,25 @@ svr4_recvit(p, s, mp, namelenp) struct uio ktruio; #endif - error = holdsock(p->p_fd, s, &fp); + error = holdsock(td->td_proc->p_fd, s, &fp); if (error) return (error); auio.uio_iov = mp->msg_iov; auio.uio_iovcnt = mp->msg_iovlen; auio.uio_segflg = UIO_USERSPACE; auio.uio_rw = UIO_READ; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; /* XXX */ auio.uio_resid = 0; iov = mp->msg_iov; for (i = 0; i < mp->msg_iovlen; i++, iov++) { if ((auio.uio_resid += iov->iov_len) < 0) { - fdrop(fp, p); + fdrop(fp, td); return (EINVAL); } } #ifdef KTRACE - if (KTRPOINT(p, KTR_GENIO)) { + if (KTRPOINT(td->td_proc, KTR_GENIO)) { int iovlen = auio.uio_iovcnt * sizeof (struct iovec); MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); @@ -305,14 +305,14 @@ svr4_recvit(p, s, mp, namelenp) if (error == 0) { ktruio.uio_iov = ktriov; ktruio.uio_resid = len - auio.uio_resid; - ktrgenio(p->p_tracep, s, UIO_READ, &ktruio, error); + ktrgenio(td->td_proc->p_tracep, s, UIO_READ, &ktruio, error); } FREE(ktriov, M_TEMP); } #endif if (error) goto out; - p->p_retval[0] = len - auio.uio_resid; + td->td_retval[0] = len - auio.uio_resid; if (mp->msg_name) { len = mp->msg_namelen; if (len <= 0 || fromsa == 0) @@ -365,7 +365,7 @@ out: FREE(fromsa, M_SONAME); if (control) m_freem(control); - fdrop(fp, p); + fdrop(fp, td); return (error); } @@ -499,8 +499,8 @@ show_msg(str, fd, ctl, dat, flags) * to avoid code duplication. */ static int -clean_pipe(p, path) - struct proc *p; +clean_pipe(td, path) + struct thread *td; const char *path; { struct lstat_args la; @@ -519,7 +519,7 @@ clean_pipe(p, path) SCARG(&la, path) = tpath; - if ((error = lstat(p, &la)) != 0) + if ((error = lstat(td, &la)) != 0) return 0; if ((error = copyin(SCARG(&la, ub), &st, sizeof(st))) != 0) @@ -536,7 +536,7 @@ clean_pipe(p, path) SCARG(&ua, path) = SCARG(&la, path); - if ((error = unlink(p, &ua)) != 0) { + if ((error = unlink(td, &ua)) != 0) { DPRINTF(("clean_pipe: unlink failed %d\n", error)); return error; } @@ -662,11 +662,11 @@ getparm(fp, pa) static int -si_ogetudata(fp, fd, ioc, p) +si_ogetudata(fp, fd, ioc, td) struct file *fp; int fd; struct svr4_strioctl *ioc; - struct proc *p; + struct thread *td; { int error; struct svr4_si_oudata ud; @@ -719,11 +719,11 @@ si_ogetudata(fp, fd, ioc, p) static int -si_sockparams(fp, fd, ioc, p) +si_sockparams(fp, fd, ioc, td) struct file *fp; int fd; struct svr4_strioctl *ioc; - struct proc *p; + struct thread *td; { struct svr4_si_sockparms pa; @@ -733,11 +733,11 @@ si_sockparams(fp, fd, ioc, p) static int -si_listen(fp, fd, ioc, p) +si_listen(fp, fd, ioc, td) struct file *fp; int fd; struct svr4_strioctl *ioc; - struct proc *p; + struct thread *td; { int error; struct svr4_strm *st = svr4_stream_get(fp); @@ -762,7 +762,7 @@ si_listen(fp, fd, ioc, p) DPRINTF(("SI_LISTEN: fileno %d backlog = %d\n", fd, 5)); SCARG(&la, backlog) = 5; - if ((error = listen(p, &la)) != 0) { + if ((error = listen(td, &la)) != 0) { DPRINTF(("SI_LISTEN: listen failed %d\n", error)); return error; } @@ -797,11 +797,11 @@ si_listen(fp, fd, ioc, p) static int -si_getudata(fp, fd, ioc, p) +si_getudata(fp, fd, ioc, td) struct file *fp; int fd; struct svr4_strioctl *ioc; - struct proc *p; + struct thread *td; { int error; struct svr4_si_udata ud; @@ -856,11 +856,11 @@ si_getudata(fp, fd, ioc, p) static int -si_shutdown(fp, fd, ioc, p) +si_shutdown(fp, fd, ioc, td) struct file *fp; int fd; struct svr4_strioctl *ioc; - struct proc *p; + struct thread *td; { int error; struct shutdown_args ap; @@ -876,29 +876,29 @@ si_shutdown(fp, fd, ioc, p) SCARG(&ap, s) = fd; - return shutdown(p, &ap); + return shutdown(td, &ap); } static int -sockmod(fp, fd, ioc, p) +sockmod(fp, fd, ioc, td) struct file *fp; int fd; struct svr4_strioctl *ioc; - struct proc *p; + struct thread *td; { switch (ioc->cmd) { case SVR4_SI_OGETUDATA: DPRINTF(("SI_OGETUDATA\n")); - return si_ogetudata(fp, fd, ioc, p); + return si_ogetudata(fp, fd, ioc, td); case SVR4_SI_SHUTDOWN: DPRINTF(("SI_SHUTDOWN\n")); - return si_shutdown(fp, fd, ioc, p); + return si_shutdown(fp, fd, ioc, td); case SVR4_SI_LISTEN: DPRINTF(("SI_LISTEN\n")); - return si_listen(fp, fd, ioc, p); + return si_listen(fp, fd, ioc, td); case SVR4_SI_SETMYNAME: DPRINTF(("SI_SETMYNAME\n")); @@ -922,11 +922,11 @@ sockmod(fp, fd, ioc, p) case SVR4_SI_SOCKPARAMS: DPRINTF(("SI_SOCKPARAMS\n")); - return si_sockparams(fp, fd, ioc, p); + return si_sockparams(fp, fd, ioc, td); case SVR4_SI_GETUDATA: DPRINTF(("SI_GETUDATA\n")); - return si_getudata(fp, fd, ioc, p); + return si_getudata(fp, fd, ioc, td); default: DPRINTF(("Unknown sockmod ioctl %lx\n", ioc->cmd)); @@ -937,11 +937,11 @@ sockmod(fp, fd, ioc, p) static int -ti_getinfo(fp, fd, ioc, p) +ti_getinfo(fp, fd, ioc, td) struct file *fp; int fd; struct svr4_strioctl *ioc; - struct proc *p; + struct thread *td; { int error; struct svr4_infocmd info; @@ -975,11 +975,11 @@ ti_getinfo(fp, fd, ioc, p) static int -ti_bind(fp, fd, ioc, p) +ti_bind(fp, fd, ioc, td) struct file *fp; int fd; struct svr4_strioctl *ioc; - struct proc *p; + struct thread *td; { int error; struct svr4_strm *st = svr4_stream_get(fp); @@ -1033,7 +1033,7 @@ ti_bind(fp, fd, ioc, p) DPRINTF(("TI_BIND: fam %d, path %s\n", saun.sun_family, saun.sun_path)); - if ((error = clean_pipe(p, saun.sun_path)) != 0) + if ((error = clean_pipe(td, saun.sun_path)) != 0) return error; bnd.pad[28] = 0x00001000; /* magic again */ @@ -1056,7 +1056,7 @@ ti_bind(fp, fd, ioc, p) SCARG(&ba, name) = (void *) sup; SCARG(&ba, namelen) = sasize; - if ((error = bind(p, &ba)) != 0) { + if ((error = bind(td, &ba)) != 0) { DPRINTF(("TI_BIND: bind failed %d\n", error)); return error; } @@ -1078,16 +1078,16 @@ reply: static int -timod(fp, fd, ioc, p) +timod(fp, fd, ioc, td) struct file *fp; int fd; struct svr4_strioctl *ioc; - struct proc *p; + struct thread *td; { switch (ioc->cmd) { case SVR4_TI_GETINFO: DPRINTF(("TI_GETINFO\n")); - return ti_getinfo(fp, fd, ioc, p); + return ti_getinfo(fp, fd, ioc, td); case SVR4_TI_OPTMGMT: DPRINTF(("TI_OPTMGMT\n")); @@ -1095,7 +1095,7 @@ timod(fp, fd, ioc, p) case SVR4_TI_BIND: DPRINTF(("TI_BIND\n")); - return ti_bind(fp, fd, ioc, p); + return ti_bind(fp, fd, ioc, td); case SVR4_TI_UNBIND: DPRINTF(("TI_UNBIND\n")); @@ -1109,9 +1109,9 @@ timod(fp, fd, ioc, p) int -svr4_stream_ti_ioctl(fp, p, retval, fd, cmd, dat) +svr4_stream_ti_ioctl(fp, td, retval, fd, cmd, dat) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -1174,7 +1174,7 @@ svr4_stream_ti_ioctl(fp, p, retval, fd, cmd, dat) SCARG(&ap, fdes) = fd; SCARG(&ap, asa) = sup; SCARG(&ap, alen) = lenp; - if ((error = getsockname(p, &ap)) != 0) { + if ((error = getsockname(td, &ap)) != 0) { DPRINTF(("ti_ioctl: getsockname error\n")); return error; } @@ -1188,7 +1188,7 @@ svr4_stream_ti_ioctl(fp, p, retval, fd, cmd, dat) SCARG(&ap, fdes) = fd; SCARG(&ap, asa) = sup; SCARG(&ap, alen) = lenp; - if ((error = getpeername(p, &ap)) != 0) { + if ((error = getpeername(td, &ap)) != 0) { DPRINTF(("ti_ioctl: getpeername error\n")); return error; } @@ -1251,9 +1251,9 @@ svr4_stream_ti_ioctl(fp, p, retval, fd, cmd, dat) static int -i_nread(fp, p, retval, fd, cmd, dat) +i_nread(fp, td, retval, fd, cmd, dat) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -1269,7 +1269,7 @@ i_nread(fp, p, retval, fd, cmd, dat) * for us, and if we do, then we assume that we have at least one * message waiting for us. */ - if ((error = fo_ioctl(fp, FIONREAD, (caddr_t) &nread, p)) != 0) + if ((error = fo_ioctl(fp, FIONREAD, (caddr_t) &nread, td)) != 0) return error; if (nread != 0) @@ -1281,9 +1281,9 @@ i_nread(fp, p, retval, fd, cmd, dat) } static int -i_fdinsert(fp, p, retval, fd, cmd, dat) +i_fdinsert(fp, td, retval, fd, cmd, dat) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -1321,7 +1321,7 @@ i_fdinsert(fp, p, retval, fd, cmd, dat) SCARG(&d2p, from) = st->s_afd; SCARG(&d2p, to) = fdi.fd; - if ((error = dup2(p, &d2p)) != 0) { + if ((error = dup2(td, &d2p)) != 0) { DPRINTF(("fdinsert: dup2(%d, %d) failed %d\n", st->s_afd, fdi.fd, error)); return error; @@ -1329,7 +1329,7 @@ i_fdinsert(fp, p, retval, fd, cmd, dat) SCARG(&clp, fd) = st->s_afd; - if ((error = close(p, &clp)) != 0) { + if ((error = close(td, &clp)) != 0) { DPRINTF(("fdinsert: close(%d) failed %d\n", st->s_afd, error)); return error; @@ -1343,9 +1343,9 @@ i_fdinsert(fp, p, retval, fd, cmd, dat) static int -_i_bind_rsvd(fp, p, retval, fd, cmd, dat) +_i_bind_rsvd(fp, td, retval, fd, cmd, dat) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -1363,13 +1363,13 @@ _i_bind_rsvd(fp, p, retval, fd, cmd, dat) SCARG(&ap, path) = dat; SCARG(&ap, mode) = S_IFIFO; - return mkfifo(p, &ap); + return mkfifo(td, &ap); } static int -_i_rele_rsvd(fp, p, retval, fd, cmd, dat) +_i_rele_rsvd(fp, td, retval, fd, cmd, dat) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -1383,13 +1383,13 @@ _i_rele_rsvd(fp, p, retval, fd, cmd, dat) */ SCARG(&ap, path) = dat; - return unlink(p, &ap); + return unlink(td, &ap); } static int -i_str(fp, p, retval, fd, cmd, dat) +i_str(fp, td, retval, fd, cmd, dat) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -1408,12 +1408,12 @@ i_str(fp, p, retval, fd, cmd, dat) switch (ioc.cmd & 0xff00) { case SVR4_SIMOD: - if ((error = sockmod(fp, fd, &ioc, p)) != 0) + if ((error = sockmod(fp, fd, &ioc, td)) != 0) return error; break; case SVR4_TIMOD: - if ((error = timod(fp, fd, &ioc, p)) != 0) + if ((error = timod(fp, fd, &ioc, td)) != 0) return error; break; @@ -1431,9 +1431,9 @@ i_str(fp, p, retval, fd, cmd, dat) } static int -i_setsig(fp, p, retval, fd, cmd, dat) +i_setsig(fp, td, retval, fd, cmd, dat) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -1459,10 +1459,10 @@ i_setsig(fp, p, retval, fd, cmd, dat) /* get old status flags */ SCARG(&fa, fd) = fd; SCARG(&fa, cmd) = F_GETFL; - if ((error = fcntl(p, &fa)) != 0) + if ((error = fcntl(td, &fa)) != 0) return error; - oflags = p->p_retval[0]; + oflags = td->td_retval[0]; /* update the flags */ if (dat != NULL) { @@ -1488,24 +1488,24 @@ i_setsig(fp, p, retval, fd, cmd, dat) if (flags != oflags) { SCARG(&fa, cmd) = F_SETFL; SCARG(&fa, arg) = (long) flags; - if ((error = fcntl(p, &fa)) != 0) + if ((error = fcntl(td, &fa)) != 0) return error; - flags = p->p_retval[0]; + flags = td->td_retval[0]; } /* set up SIGIO receiver if needed */ if (dat != NULL) { SCARG(&fa, cmd) = F_SETOWN; - SCARG(&fa, arg) = (long) p->p_pid; - return fcntl(p, &fa); + SCARG(&fa, arg) = (long) td->td_proc->p_pid; + return fcntl(td, &fa); } return 0; } static int -i_getsig(fp, p, retval, fd, cmd, dat) +i_getsig(fp, td, retval, fd, cmd, dat) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -1530,9 +1530,9 @@ i_getsig(fp, p, retval, fd, cmd, dat) } int -svr4_stream_ioctl(fp, p, retval, fd, cmd, dat) +svr4_stream_ioctl(fp, td, retval, fd, cmd, dat) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -1546,7 +1546,7 @@ svr4_stream_ioctl(fp, p, retval, fd, cmd, dat) switch (cmd) { case SVR4_I_NREAD: DPRINTF(("I_NREAD\n")); - return i_nread(fp, p, retval, fd, cmd, dat); + return i_nread(fp, td, retval, fd, cmd, dat); case SVR4_I_PUSH: DPRINTF(("I_PUSH %p\n", dat)); @@ -1577,15 +1577,15 @@ svr4_stream_ioctl(fp, p, retval, fd, cmd, dat) case SVR4_I_STR: DPRINTF(("I_STR\n")); - return i_str(fp, p, retval, fd, cmd, dat); + return i_str(fp, td, retval, fd, cmd, dat); case SVR4_I_SETSIG: DPRINTF(("I_SETSIG\n")); - return i_setsig(fp, p, retval, fd, cmd, dat); + return i_setsig(fp, td, retval, fd, cmd, dat); case SVR4_I_GETSIG: DPRINTF(("I_GETSIG\n")); - return i_getsig(fp, p, retval, fd, cmd, dat); + return i_getsig(fp, td, retval, fd, cmd, dat); case SVR4_I_FIND: DPRINTF(("I_FIND\n")); @@ -1614,7 +1614,7 @@ svr4_stream_ioctl(fp, p, retval, fd, cmd, dat) case SVR4_I_FDINSERT: DPRINTF(("I_FDINSERT\n")); - return i_fdinsert(fp, p, retval, fd, cmd, dat); + return i_fdinsert(fp, td, retval, fd, cmd, dat); case SVR4_I_SENDFD: DPRINTF(("I_SENDFD\n")); @@ -1690,11 +1690,11 @@ svr4_stream_ioctl(fp, p, retval, fd, cmd, dat) case SVR4__I_BIND_RSVD: DPRINTF(("_I_BIND_RSVD\n")); - return _i_bind_rsvd(fp, p, retval, fd, cmd, dat); + return _i_bind_rsvd(fp, td, retval, fd, cmd, dat); case SVR4__I_RELE_RSVD: DPRINTF(("_I_RELE_RSVD\n")); - return _i_rele_rsvd(fp, p, retval, fd, cmd, dat); + return _i_rele_rsvd(fp, td, retval, fd, cmd, dat); default: DPRINTF(("unimpl cmd = %lx\n", cmd)); @@ -1707,11 +1707,11 @@ svr4_stream_ioctl(fp, p, retval, fd, cmd, dat) int -svr4_sys_putmsg(p, uap) - register struct proc *p; +svr4_sys_putmsg(td, uap) + register struct thread *td; struct svr4_sys_putmsg_args *uap; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct file *fp; struct svr4_strbuf dat, ctl; struct svr4_strmcmd sc; @@ -1723,7 +1723,7 @@ svr4_sys_putmsg(p, uap) int error; caddr_t sg; - retval = p->p_retval; + retval = td->td_retval; fp = fdp->fd_ofiles[SCARG(uap, fd)]; if (((u_int)SCARG(uap, fd) >= fdp->fd_nfiles) || (fp == NULL)) { @@ -1802,7 +1802,7 @@ svr4_sys_putmsg(p, uap) SCARG(&wa, fd) = SCARG(uap, fd); SCARG(&wa, buf) = dat.buf; SCARG(&wa, nbyte) = dat.len; - return write(p, &wa); + return write(td, &wa); } DPRINTF(("putmsg: Invalid inet length %ld\n", sc.len)); return EINVAL; @@ -1824,7 +1824,7 @@ svr4_sys_putmsg(p, uap) /* Maybe we've been given a device/inode pair */ udev_t *dev = SVR4_ADDROF(&sc); ino_t *ino = (ino_t *) &dev[1]; - skp = svr4_find_socket(p, fp, *dev, *ino); + skp = svr4_find_socket(td, fp, *dev, *ino); if (skp == NULL) { skp = &saun; /* I guess we have it by name */ @@ -1855,7 +1855,7 @@ svr4_sys_putmsg(p, uap) SCARG(&co, name) = (void *) sup; SCARG(&co, namelen) = (int) sasize; - return connect(p, &co); + return connect(td, &co); } case SVR4_TI_SENDTO_REQUEST: /* sendto */ @@ -1873,9 +1873,9 @@ svr4_sys_putmsg(p, uap) aiov.iov_len = dat.len; #if 0 error = so->so_proto->pr_usrreqs->pru_sosend(so, 0, - uio, 0, 0, 0, uio->uio_procp); + uio, 0, 0, 0, uio->uio_td); #endif - error = svr4_sendit(p, SCARG(uap, fd), &msg, + error = svr4_sendit(td, SCARG(uap, fd), &msg, SCARG(uap, flags)); DPRINTF(("sendto_request error: %d\n", error)); *retval = 0; @@ -1889,11 +1889,11 @@ svr4_sys_putmsg(p, uap) } int -svr4_sys_getmsg(p, uap) - register struct proc *p; +svr4_sys_getmsg(td, uap) + register struct thread *td; struct svr4_sys_getmsg_args *uap; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct file *fp; struct getpeername_args ga; struct accept_args aa; @@ -1911,7 +1911,7 @@ svr4_sys_getmsg(p, uap) int fl; caddr_t sg; - retval = p->p_retval; + retval = td->td_retval; fp = fdp->fd_ofiles[SCARG(uap, fd)]; if (((u_int)SCARG(uap, fd) >= fdp->fd_nfiles) || (fp == NULL)) @@ -2010,7 +2010,7 @@ svr4_sys_getmsg(p, uap) SCARG(&ga, asa) = (void *) sup; SCARG(&ga, alen) = flen; - if ((error = getpeername(p, &ga)) != 0) { + if ((error = getpeername(td, &ga)) != 0) { DPRINTF(("getmsg: getpeername failed %d\n", error)); return error; } @@ -2069,7 +2069,7 @@ svr4_sys_getmsg(p, uap) SCARG(&aa, name) = (void *) sup; SCARG(&aa, anamelen) = flen; - if ((error = accept(p, &aa)) != 0) { + if ((error = accept(td, &aa)) != 0) { DPRINTF(("getmsg: accept failed %d\n", error)); return error; } @@ -2140,7 +2140,7 @@ svr4_sys_getmsg(p, uap) aiov.iov_len = dat.maxlen; msg.msg_flags = 0; - error = svr4_recvit(p, SCARG(uap, fd), &msg, (caddr_t) flen); + error = svr4_recvit(td, SCARG(uap, fd), &msg, (caddr_t) flen); if (error) { DPRINTF(("getmsg: recvit failed %d\n", error)); @@ -2191,7 +2191,7 @@ svr4_sys_getmsg(p, uap) SCARG(&ra, fd) = SCARG(uap, fd); SCARG(&ra, buf) = dat.buf; SCARG(&ra, nbyte) = dat.maxlen; - if ((error = read(p, &ra)) != 0) { + if ((error = read(td, &ra)) != 0) { return error; } dat.len = *retval; @@ -2231,8 +2231,8 @@ svr4_sys_getmsg(p, uap) return error; } -int svr4_sys_send(p, uap) - struct proc *p; +int svr4_sys_send(td, uap) + struct thread *td; struct svr4_sys_send_args *uap; { struct osend_args osa; @@ -2240,11 +2240,11 @@ int svr4_sys_send(p, uap) SCARG(&osa, buf) = SCARG(uap, buf); SCARG(&osa, len) = SCARG(uap, len); SCARG(&osa, flags) = SCARG(uap, flags); - return osend(p, &osa); + return osend(td, &osa); } -int svr4_sys_recv(p, uap) - struct proc *p; +int svr4_sys_recv(td, uap) + struct thread *td; struct svr4_sys_recv_args *uap; { struct orecv_args ora; @@ -2252,7 +2252,7 @@ int svr4_sys_recv(p, uap) SCARG(&ora, buf) = SCARG(uap, buf); SCARG(&ora, len) = SCARG(uap, len); SCARG(&ora, flags) = SCARG(uap, flags); - return orecv(p, &ora); + return orecv(td, &ora); } /* @@ -2260,8 +2260,8 @@ int svr4_sys_recv(p, uap) * sendto(). Let's leave it here for now... */ int -svr4_sys_sendto(p, uap) - struct proc *p; +svr4_sys_sendto(td, uap) + struct thread *td; struct svr4_sys_sendto_args *uap; { struct sendto_args sa; @@ -2274,6 +2274,6 @@ svr4_sys_sendto(p, uap) SCARG(&sa, tolen) = SCARG(uap, tolen); DPRINTF(("calling sendto()\n")); - return sendto(p, &sa); + return sendto(td, &sa); } diff --git a/sys/compat/svr4/svr4_syscall.h b/sys/compat/svr4/svr4_syscall.h index 9d25526..b1898b5 100644 --- a/sys/compat/svr4/svr4_syscall.h +++ b/sys/compat/svr4/svr4_syscall.h @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/svr4/syscalls.master,v 1.10 2000/07/29 10:05:24 peter Exp + * created from FreeBSD: src/sys/compat/svr4/syscalls.master,v 1.11 2000/08/31 22:54:05 obrien Exp */ #define SVR4_SYS_exit 1 diff --git a/sys/compat/svr4/svr4_syscallnames.c b/sys/compat/svr4/svr4_syscallnames.c index 479a6b7..1f9add4 100644 --- a/sys/compat/svr4/svr4_syscallnames.c +++ b/sys/compat/svr4/svr4_syscallnames.c @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/svr4/syscalls.master,v 1.10 2000/07/29 10:05:24 peter Exp + * created from FreeBSD: src/sys/compat/svr4/syscalls.master,v 1.11 2000/08/31 22:54:05 obrien Exp */ char *svr4_syscallnames[] = { diff --git a/sys/compat/svr4/svr4_sysent.c b/sys/compat/svr4/svr4_sysent.c index bad9e4e..2bb003e 100644 --- a/sys/compat/svr4/svr4_sysent.c +++ b/sys/compat/svr4/svr4_sysent.c @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/svr4/syscalls.master,v 1.10 2000/07/29 10:05:24 peter Exp + * created from FreeBSD: src/sys/compat/svr4/syscalls.master,v 1.11 2000/08/31 22:54:05 obrien Exp */ #include <sys/types.h> diff --git a/sys/compat/svr4/svr4_sysvec.c b/sys/compat/svr4/svr4_sysvec.c index 9137e0c..39aa904 100644 --- a/sys/compat/svr4/svr4_sysvec.c +++ b/sys/compat/svr4/svr4_sysvec.c @@ -238,14 +238,15 @@ svr4_fixup(register_t **stack_base, struct image_params *imgp) * Code shamelessly stolen by Mark Newton from IBCS2 emulation code. */ int -svr4_emul_find(p, sgp, prefix, path, pbuf, cflag) - struct proc *p; +svr4_emul_find(td, sgp, prefix, path, pbuf, cflag) + struct thread *td; caddr_t *sgp; /* Pointer to stackgap memory */ const char *prefix; char *path; char **pbuf; int cflag; { + struct proc *p = td->td_proc; struct nameidata nd; struct nameidata ndroot; struct vattr vat; @@ -292,7 +293,7 @@ svr4_emul_find(p, sgp, prefix, path, pbuf, cflag) for (cp = &ptr[len] - 1; *cp != '/'; cp--); *cp = '\0'; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, td); if ((error = namei(&nd)) != 0) { free(buf, M_TEMP); @@ -303,7 +304,7 @@ svr4_emul_find(p, sgp, prefix, path, pbuf, cflag) *cp = '/'; } else { - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, td); if ((error = namei(&nd)) != 0) { free(buf, M_TEMP); @@ -320,7 +321,7 @@ svr4_emul_find(p, sgp, prefix, path, pbuf, cflag) * to the emulation root directory. This is expensive :-( */ NDINIT(&ndroot, LOOKUP, FOLLOW, UIO_SYSSPACE, svr4_emul_path, - p); + td); if ((error = namei(&ndroot)) != 0) { /* Cannot happen! */ @@ -330,11 +331,11 @@ svr4_emul_find(p, sgp, prefix, path, pbuf, cflag) } NDFREE(&ndroot, NDF_ONLY_PNBUF); - if ((error = VOP_GETATTR(nd.ni_vp, &vat, p->p_ucred, p)) != 0) { + if ((error = VOP_GETATTR(nd.ni_vp, &vat, p->p_ucred, td)) != 0) { goto done; } - if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, p->p_ucred, p)) + if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, p->p_ucred, td)) != 0) { goto done; } diff --git a/sys/compat/svr4/svr4_termios.c b/sys/compat/svr4/svr4_termios.c index d50f97f..981aef8 100644 --- a/sys/compat/svr4/svr4_termios.c +++ b/sys/compat/svr4/svr4_termios.c @@ -478,9 +478,9 @@ svr4_termios_to_termio(ts, t) } int -svr4_term_ioctl(fp, p, retval, fd, cmd, data) +svr4_term_ioctl(fp, td, retval, fd, cmd, data) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -499,7 +499,7 @@ svr4_term_ioctl(fp, p, retval, fd, cmd, data) case SVR4_TCGETA: case SVR4_TCGETS: DPRINTF(("ioctl(TCGET%c);\n", cmd == SVR4_TCGETA ? 'A' : 'S')); - if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t) &bt, p)) != 0) + if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t) &bt, td)) != 0) return error; memset(&st, 0, sizeof(st)); @@ -526,7 +526,7 @@ svr4_term_ioctl(fp, p, retval, fd, cmd, data) case SVR4_TCSETSF: DPRINTF(("TCSET{A,S,AW,SW,AF,SF}\n")); /* get full BSD termios so we don't lose information */ - if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t) &bt, p)) != 0) + if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t) &bt, td)) != 0) return error; switch (cmd) { @@ -577,14 +577,14 @@ svr4_term_ioctl(fp, p, retval, fd, cmd, data) print_svr4_termios(&st); #endif /* DEBUG_SVR4 */ - return fo_ioctl(fp, cmd, (caddr_t) &bt, p); + return fo_ioctl(fp, cmd, (caddr_t) &bt, td); case SVR4_TIOCGWINSZ: DPRINTF(("TIOCGWINSZ\n")); { struct svr4_winsize ws; - error = fo_ioctl(fp, TIOCGWINSZ, (caddr_t) &ws, p); + error = fo_ioctl(fp, TIOCGWINSZ, (caddr_t) &ws, td); if (error) return error; return copyout(&ws, data, sizeof(ws)); @@ -597,11 +597,11 @@ svr4_term_ioctl(fp, p, retval, fd, cmd, data) if ((error = copyin(data, &ws, sizeof(ws))) != 0) return error; - return fo_ioctl(fp, TIOCSWINSZ, (caddr_t) &ws, p); + return fo_ioctl(fp, TIOCSWINSZ, (caddr_t) &ws, td); } default: DPRINTF(("teleport to STREAMS ioctls...\n")); - return svr4_stream_ti_ioctl(fp, p, retval, fd, cmd, data); + return svr4_stream_ti_ioctl(fp, td, retval, fd, cmd, data); } } diff --git a/sys/compat/svr4/svr4_ttold.c b/sys/compat/svr4/svr4_ttold.c index e139016..90cdae1 100644 --- a/sys/compat/svr4/svr4_ttold.c +++ b/sys/compat/svr4/svr4_ttold.c @@ -175,9 +175,9 @@ bsd_ltchars_to_svr4_ltchars(bl, sl) int -svr4_ttold_ioctl(fp, p, retval, fd, cmd, data) +svr4_ttold_ioctl(fp, td, retval, fd, cmd, data) struct file *fp; - struct proc *p; + struct thread *td; register_t *retval; int fd; u_long cmd; @@ -192,7 +192,7 @@ svr4_ttold_ioctl(fp, p, retval, fd, cmd, data) { pid_t pid; - if ((error = fo_ioctl(fp, TIOCGPGRP, (caddr_t) &pid, p)) != 0) + if ((error = fo_ioctl(fp, TIOCGPGRP, (caddr_t) &pid, td)) != 0) return error; DPRINTF(("TIOCGPGRP %d\n", pid)); @@ -211,21 +211,21 @@ svr4_ttold_ioctl(fp, p, retval, fd, cmd, data) DPRINTF(("TIOCSPGRP %d\n", pid)); - return fo_ioctl(fp, TIOCSPGRP, (caddr_t) &pid, p); + return fo_ioctl(fp, TIOCSPGRP, (caddr_t) &pid, td); } case SVR4_TIOCGSID: { #if defined(TIOCGSID) pid_t pid; - if ((error = fo_ioctl(fp, TIOCGSID, (caddr_t) &pid, p)) != 0) + if ((error = fo_ioctl(fp, TIOCGSID, (caddr_t) &pid, td)) != 0) return error; DPRINTF(("TIOCGSID %d\n", pid)); return copyout(&pid, data, sizeof(pid)); #else - uprintf("ioctl(TIOCGSID) for pid %d unsupported\n", p->p_pid); + uprintf("ioctl(TIOCGSID) for pid %d unsupported\n", td->td_proc->p_pid); return EINVAL; #endif } @@ -235,7 +235,7 @@ svr4_ttold_ioctl(fp, p, retval, fd, cmd, data) struct sgttyb bs; struct svr4_sgttyb ss; - error = fo_ioctl(fp, TIOCGETP, (caddr_t) &bs, p); + error = fo_ioctl(fp, TIOCGETP, (caddr_t) &bs, td); if (error) return error; @@ -260,7 +260,7 @@ svr4_ttold_ioctl(fp, p, retval, fd, cmd, data) print_svr4_sgttyb("SVR4_TIOCSET{P,N}", &ss); #endif /* DEBUG_SVR4 */ cmd = (cmd == SVR4_TIOCSETP) ? TIOCSETP : TIOCSETN; - return fo_ioctl(fp, cmd, (caddr_t) &bs, p); + return fo_ioctl(fp, cmd, (caddr_t) &bs, td); } case SVR4_TIOCGETC: @@ -268,7 +268,7 @@ svr4_ttold_ioctl(fp, p, retval, fd, cmd, data) struct tchars bt; struct svr4_tchars st; - error = fo_ioctl(fp, TIOCGETC, (caddr_t) &bt, p); + error = fo_ioctl(fp, TIOCGETC, (caddr_t) &bt, td); if (error) return error; @@ -291,7 +291,7 @@ svr4_ttold_ioctl(fp, p, retval, fd, cmd, data) #ifdef DEBUG_SVR4 print_svr4_tchars("SVR4_TIOCSETC", &st); #endif /* DEBUG_SVR4 */ - return fo_ioctl(fp, TIOCSETC, (caddr_t) &bt, p); + return fo_ioctl(fp, TIOCSETC, (caddr_t) &bt, td); } case SVR4_TIOCGLTC: @@ -299,7 +299,7 @@ svr4_ttold_ioctl(fp, p, retval, fd, cmd, data) struct ltchars bl; struct svr4_ltchars sl; - error = fo_ioctl(fp, TIOCGLTC, (caddr_t) &bl, p); + error = fo_ioctl(fp, TIOCGLTC, (caddr_t) &bl, td); if (error) return error; @@ -322,13 +322,13 @@ svr4_ttold_ioctl(fp, p, retval, fd, cmd, data) #ifdef DEBUG_SVR4 print_svr4_ltchars("SVR4_TIOCSLTC", &sl); #endif /* DEBUG_SVR4 */ - return fo_ioctl(fp, TIOCSLTC, (caddr_t) &bl, p); + return fo_ioctl(fp, TIOCSLTC, (caddr_t) &bl, td); } case SVR4_TIOCLGET: { int flags; - if ((error = fo_ioctl(fp, TIOCLGET, (caddr_t) &flags, p)) != 0) + if ((error = fo_ioctl(fp, TIOCLGET, (caddr_t) &flags, td)) != 0) return error; DPRINTF(("SVR4_TIOCLGET %o\n", flags)); return copyout(&flags, data, sizeof(flags)); @@ -356,7 +356,7 @@ svr4_ttold_ioctl(fp, p, retval, fd, cmd, data) } DPRINTF(("SVR4_TIOCL{SET,BIS,BIC} %o\n", flags)); - return fo_ioctl(fp, cmd, (caddr_t) &flags, p); + return fo_ioctl(fp, cmd, (caddr_t) &flags, td); } default: diff --git a/sys/compat/svr4/svr4_util.h b/sys/compat/svr4/svr4_util.h index 629edd6..9429c0f 100644 --- a/sys/compat/svr4/svr4_util.h +++ b/sys/compat/svr4/svr4_util.h @@ -53,7 +53,7 @@ static __inline void *stackgap_alloc(caddr_t *, size_t); static __inline caddr_t stackgap_init() { -#define szsigcode (*(curproc->p_sysent->sv_szsigcode)) +#define szsigcode (*(curthread->td_proc->p_sysent->sv_szsigcode)) return (caddr_t)(((caddr_t)PS_STRINGS) - szsigcode - SPARE_USRSPACE); } @@ -68,7 +68,7 @@ stackgap_alloc(sgp, sz) } extern const char svr4_emul_path[]; -int svr4_emul_find __P((struct proc *, caddr_t *, const char *, char *, +int svr4_emul_find __P((struct thread *, caddr_t *, const char *, char *, char **, int)); #define CHECKALT(p, sgp, path, i) \ diff --git a/sys/conf/NOTES b/sys/conf/NOTES index 83bf89a..a707b0f 100644 --- a/sys/conf/NOTES +++ b/sys/conf/NOTES @@ -84,7 +84,7 @@ options BLKDEV_IOSIZE=8192 # Options for the VM subsystem options PQ_CACHESIZE=512 # color for 512k/16k cache -options UPAGES=3 # number of 4k stack pages per process +options KSTACK_PAGES=3 # number of 4k stack pages per process # Deprecated options supported for backwards compatibility #options PQ_NOOPT # No coloring #options PQ_LARGECACHE # color for 512k/16k cache @@ -442,7 +442,7 @@ options IPX #IPX/SPX communications protocols options IPXIP #IPX in IP encapsulation (not available) options IPTUNNEL #IP in IPX encapsulation (not available) -options NCP #NetWare Core protocol +#options NCP #NetWare Core protocol options NETATALK #Appletalk communications protocols options NETATALKDEBUG #Appletalk debugging @@ -692,7 +692,7 @@ options HPFS #OS/2 File system options MSDOSFS #MS DOS File System (FAT, FAT32) options NTFS #NT File System options NULLFS #NULL filesystem -options NWFS #NetWare filesystem +#options NWFS #NetWare filesystem options PORTALFS #Portal filesystem options PROCFS #Process filesystem options PSEUDOFS #Pseudo-filesystem framework diff --git a/sys/conf/options.i386 b/sys/conf/options.i386 index 8f89b01..dc83994 100644 --- a/sys/conf/options.i386 +++ b/sys/conf/options.i386 @@ -20,7 +20,7 @@ WLCACHE opt_wavelan.h WLDEBUG opt_wavelan.h COMPAT_OLDISA BROKEN_KEYBOARD_RESET opt_reset.h -UPAGES +KSTACK_PAGES # Options for emulators. These should only be used at config time, so # they are handled like options for static file systems diff --git a/sys/conf/options.pc98 b/sys/conf/options.pc98 index 10909f8..8114e8d 100644 --- a/sys/conf/options.pc98 +++ b/sys/conf/options.pc98 @@ -21,7 +21,7 @@ WLCACHE opt_wavelan.h WLDEBUG opt_wavelan.h COMPAT_OLDISA BROKEN_KEYBOARD_RESET opt_reset.h -UPAGES +KSTACK_PAGES # Options for emulators. These should only be used at config time, so # they are handled like options for static file systems diff --git a/sys/contrib/dev/fla/fla.c b/sys/contrib/dev/fla/fla.c index 6f758de..7298244 100644 --- a/sys/contrib/dev/fla/fla.c +++ b/sys/contrib/dev/fla/fla.c @@ -112,7 +112,7 @@ static struct fla_s { } softc[8]; static int -flaopen(dev_t dev, int flag, int fmt, struct proc *p) +flaopen(dev_t dev, int flag, int fmt, struct thread *td) { struct fla_s *sc; int error; @@ -120,7 +120,7 @@ flaopen(dev_t dev, int flag, int fmt, struct proc *p) if (fla_debug) printf("flaopen(%s %x %x %p)\n", - devtoname(dev), flag, fmt, p); + devtoname(dev), flag, fmt, td); sc = dev->si_drv1; @@ -142,14 +142,14 @@ flaopen(dev_t dev, int flag, int fmt, struct proc *p) } static int -flaclose(dev_t dev, int flags, int fmt, struct proc *p) +flaclose(dev_t dev, int flags, int fmt, struct thread *td) { int error; struct fla_s *sc; if (fla_debug) printf("flaclose(%s %x %x %p)\n", - devtoname(dev), flags, fmt, p); + devtoname(dev), flags, fmt, td); sc = dev->si_drv1; @@ -162,12 +162,12 @@ flaclose(dev_t dev, int flags, int fmt, struct proc *p) } static int -flaioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) +flaioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) { if (fla_debug) printf("flaioctl(%s %lx %p %x %p)\n", - devtoname(dev), cmd, addr, flags, p); + devtoname(dev), cmd, addr, flags, td); return (ENOIOCTL); } diff --git a/sys/contrib/ipfilter/netinet/ip_fil.c b/sys/contrib/ipfilter/netinet/ip_fil.c index 82778db..149d0c7 100644 --- a/sys/contrib/ipfilter/netinet/ip_fil.c +++ b/sys/contrib/ipfilter/netinet/ip_fil.c @@ -469,8 +469,8 @@ int IPL_EXTERN(ioctl)(dev, cmd, data, mode # if (defined(_KERNEL) && ((_BSDI_VERSION >= 199510) || (BSD >= 199506) || \ (NetBSD >= 199511) || (__FreeBSD_version >= 220000) || \ defined(__OpenBSD__))) -, p) -struct proc *p; +, td) +struct thread *td; # else ) # endif @@ -903,9 +903,9 @@ int IPL_EXTERN(open)(dev_t dev, int flags) int IPL_EXTERN(open)(dev, flags # if ((_BSDI_VERSION >= 199510) || (BSD >= 199506) || (NetBSD >= 199511) || \ (__FreeBSD_version >= 220000) || defined(__OpenBSD__)) && defined(_KERNEL) -, devtype, p) +, devtype, td) int devtype; -struct proc *p; +struct thread *td; # else ) # endif @@ -933,9 +933,9 @@ int IPL_EXTERN(close)(dev_t dev, int flags, int devtype, cred_t *cp) int IPL_EXTERN(close)(dev, flags # if ((_BSDI_VERSION >= 199510) || (BSD >= 199506) || (NetBSD >= 199511) || \ (__FreeBSD_version >= 220000) || defined(__OpenBSD__)) && defined(_KERNEL) -, devtype, p) +, devtype, td) int devtype; -struct proc *p; +struct thread *td; # else ) # endif diff --git a/sys/contrib/ipfilter/netinet/ip_fil.h b/sys/contrib/ipfilter/netinet/ip_fil.h index e53c65e..2934f7d 100644 --- a/sys/contrib/ipfilter/netinet/ip_fil.h +++ b/sys/contrib/ipfilter/netinet/ip_fil.h @@ -558,12 +558,12 @@ extern int iplidentify __P((char *)); (NetBSD >= 199511) || defined(__OpenBSD__) # if defined(__NetBSD__) || (_BSDI_VERSION >= 199701) || \ defined(__OpenBSD__) || (__FreeBSD_version >= 300000) -extern int iplioctl __P((dev_t, u_long, caddr_t, int, struct proc *)); +extern int iplioctl __P((dev_t, u_long, caddr_t, int, struct thread *)); # else -extern int iplioctl __P((dev_t, int, caddr_t, int, struct proc *)); +extern int iplioctl __P((dev_t, int, caddr_t, int, struct thread *)); # endif -extern int iplopen __P((dev_t, int, int, struct proc *)); -extern int iplclose __P((dev_t, int, int, struct proc *)); +extern int iplopen __P((dev_t, int, int, struct thread *)); +extern int iplclose __P((dev_t, int, int, struct thread *)); # else # ifndef linux extern int iplopen __P((dev_t, int)); diff --git a/sys/ddb/db_ps.c b/sys/ddb/db_ps.c index cbedb1e..92e0fe6 100644 --- a/sys/ddb/db_ps.c +++ b/sys/ddb/db_ps.c @@ -94,16 +94,38 @@ db_ps(dummy1, dummy2, dummy3, dummy4) pp = p; db_printf("%5d %8p %8p %4d %5d %5d %06x %d", - p->p_pid, (volatile void *)p, (void *)p->p_addr, - p->p_ucred ? p->p_ucred->cr_ruid : 0, pp->p_pid, - p->p_pgrp ? p->p_pgrp->pg_id : 0, p->p_flag, p->p_stat); - if (p->p_wchan) { - db_printf(" %6s %8p", p->p_wmesg, (void *)p->p_wchan); + p->p_pid, + (volatile void *)p, + (void *)p->p_uarea, + p->p_ucred ? p->p_ucred->cr_ruid : 0, + pp->p_pid, + p->p_pgrp ? p->p_pgrp->pg_id : 0, + p->p_flag, + p->p_stat); + if (p->p_flag & P_KSES) { + struct thread *td; + db_printf("(threaded) %s\n", + p->p_comm ? p->p_comm : ""); + FOREACH_THREAD_IN_PROC(p, td) { + db_printf( ". . . . . . . " + ". . . . . . . . "); + if (td->td_wchan) { + db_printf("%6s %8p", + td->td_wmesg, (void *)td->td_wchan); + } else { + db_printf("--not blocked--"); + } + } } else { - db_printf(" "); + if (p->p_thread.td_wchan) { + db_printf(" %6s %8p", + p->p_thread.td_wmesg, + (void *)p->p_thread.td_wchan); + } else { + db_printf(" "); + } + db_printf(" %s\n", p->p_comm ? p->p_comm : ""); } - db_printf(" %s\n", p->p_comm ? p->p_comm : ""); - p = LIST_NEXT(p, p_list); if (p == NULL && np > 0) p = LIST_FIRST(&zombproc); diff --git a/sys/dev/aac/aac.c b/sys/dev/aac/aac.c index 5f0ef28..4eef4e7 100644 --- a/sys/dev/aac/aac.c +++ b/sys/dev/aac/aac.c @@ -2058,7 +2058,7 @@ aac_describe_code(struct aac_code_lookup *table, u_int32_t code) */ static int -aac_open(dev_t dev, int flags, int fmt, struct proc *p) +aac_open(dev_t dev, int flags, int fmt, struct thread *td) { struct aac_softc *sc; @@ -2076,7 +2076,7 @@ aac_open(dev_t dev, int flags, int fmt, struct proc *p) } static int -aac_close(dev_t dev, int flags, int fmt, struct proc *p) +aac_close(dev_t dev, int flags, int fmt, struct thread *td) { struct aac_softc *sc; @@ -2091,7 +2091,7 @@ aac_close(dev_t dev, int flags, int fmt, struct proc *p) } static int -aac_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *p) +aac_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct thread *td) { union aac_statrequest *as; struct aac_softc *sc; @@ -2427,20 +2427,20 @@ SYSUNINIT(aac_unregister, SI_SUB_KLD, SI_ORDER_MIDDLE, MODULE_DEPEND(aac, linux, 1, 1, 1); static int -aac_linux_ioctl(struct proc *p, struct linux_ioctl_args *args) +aac_linux_ioctl(struct thread *td, struct linux_ioctl_args *args) { struct file *fp; u_long cmd; debug_called(2); - fp = p->p_fd->fd_ofiles[args->fd]; + fp = td->td_proc->p_fd->fd_ofiles[args->fd]; cmd = args->cmd; /* * Pass the ioctl off to our standard handler. */ - return(fo_ioctl(fp, cmd, (caddr_t)args->arg, p)); + return(fo_ioctl(fp, cmd, (caddr_t)args->arg, td)); } #endif diff --git a/sys/dev/aac/aac_disk.c b/sys/dev/aac/aac_disk.c index 3917fa1..77f8469 100644 --- a/sys/dev/aac/aac_disk.c +++ b/sys/dev/aac/aac_disk.c @@ -127,7 +127,7 @@ SYSCTL_UINT(_hw_aac, OID_AUTO, iosize_max, CTLFLAG_RD, &aac_iosize_max, 0, * basic device geometry paramters. */ static int -aac_disk_open(dev_t dev, int flags, int fmt, struct proc *p) +aac_disk_open(dev_t dev, int flags, int fmt, struct thread *td) { struct aac_disk *sc; struct disklabel *label; @@ -162,7 +162,7 @@ aac_disk_open(dev_t dev, int flags, int fmt, struct proc *p) * Handle last close of the disk device. */ static int -aac_disk_close(dev_t dev, int flags, int fmt, struct proc *p) +aac_disk_close(dev_t dev, int flags, int fmt, struct thread *td) { struct aac_disk *sc; diff --git a/sys/dev/acpica/acpi.c b/sys/dev/acpica/acpi.c index 49c6266..3edd3f8 100644 --- a/sys/dev/acpica/acpi.c +++ b/sys/dev/acpica/acpi.c @@ -1590,19 +1590,19 @@ acpi_deregister_ioctl(u_long cmd, int (* fn)(u_long cmd, caddr_t addr, void *arg } static int -acpiopen(dev_t dev, int flag, int fmt, struct proc *p) +acpiopen(dev_t dev, int flag, int fmt, struct thread *td) { return(0); } static int -acpiclose(dev_t dev, int flag, int fmt, struct proc *p) +acpiclose(dev_t dev, int flag, int fmt, struct thread *td) { return(0); } static int -acpiioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +acpiioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct acpi_softc *sc; struct acpi_ioctl_hook *hp; diff --git a/sys/dev/agp/agp.c b/sys/dev/agp/agp.c index 333c4c8..138fe45 100644 --- a/sys/dev/agp/agp.c +++ b/sys/dev/agp/agp.c @@ -270,7 +270,7 @@ agp_generic_detach(device_t dev) { struct agp_softc *sc = device_get_softc(dev); bus_release_resource(dev, SYS_RES_MEMORY, AGP_APBASE, sc->as_aperture); - lockmgr(&sc->as_lock, LK_DRAIN, 0, curproc); + lockmgr(&sc->as_lock, LK_DRAIN, 0, curthread); lockdestroy(&sc->as_lock); destroy_dev(sc->as_devnode); agp_flush_cache(); @@ -389,7 +389,7 @@ agp_generic_bind_memory(device_t dev, struct agp_memory *mem, vm_page_t m; int error; - lockmgr(&sc->as_lock, LK_EXCLUSIVE, 0, curproc); + lockmgr(&sc->as_lock, LK_EXCLUSIVE, 0, curthread); if (mem->am_is_bound) { device_printf(dev, "memory already bound\n"); @@ -450,7 +450,7 @@ agp_generic_bind_memory(device_t dev, struct agp_memory *mem, OFF_TO_IDX(k)); vm_page_unwire(m, 0); } - lockmgr(&sc->as_lock, LK_RELEASE, 0, curproc); + lockmgr(&sc->as_lock, LK_RELEASE, 0, curthread); return error; } } @@ -471,7 +471,7 @@ agp_generic_bind_memory(device_t dev, struct agp_memory *mem, mem->am_offset = offset; mem->am_is_bound = 1; - lockmgr(&sc->as_lock, LK_RELEASE, 0, curproc); + lockmgr(&sc->as_lock, LK_RELEASE, 0, curthread); return 0; } @@ -483,7 +483,7 @@ agp_generic_unbind_memory(device_t dev, struct agp_memory *mem) vm_page_t m; int i; - lockmgr(&sc->as_lock, LK_EXCLUSIVE, 0, curproc); + lockmgr(&sc->as_lock, LK_EXCLUSIVE, 0, curthread); if (!mem->am_is_bound) { device_printf(dev, "memory is not bound\n"); @@ -508,7 +508,7 @@ agp_generic_unbind_memory(device_t dev, struct agp_memory *mem) mem->am_offset = 0; mem->am_is_bound = 0; - lockmgr(&sc->as_lock, LK_RELEASE, 0, curproc); + lockmgr(&sc->as_lock, LK_RELEASE, 0, curthread); return 0; } @@ -645,7 +645,7 @@ agp_unbind_user(device_t dev, agp_unbind *unbind) } static int -agp_open(dev_t kdev, int oflags, int devtype, struct proc *p) +agp_open(dev_t kdev, int oflags, int devtype, struct thread *td) { device_t dev = KDEV2DEV(kdev); struct agp_softc *sc = device_get_softc(dev); @@ -659,7 +659,7 @@ agp_open(dev_t kdev, int oflags, int devtype, struct proc *p) } static int -agp_close(dev_t kdev, int fflag, int devtype, struct proc *p) +agp_close(dev_t kdev, int fflag, int devtype, struct thread *td) { device_t dev = KDEV2DEV(kdev); struct agp_softc *sc = device_get_softc(dev); @@ -676,7 +676,7 @@ agp_close(dev_t kdev, int fflag, int devtype, struct proc *p) } static int -agp_ioctl(dev_t kdev, u_long cmd, caddr_t data, int fflag, struct proc *p) +agp_ioctl(dev_t kdev, u_long cmd, caddr_t data, int fflag, struct thread *td) { device_t dev = KDEV2DEV(kdev); diff --git a/sys/dev/amr/amr.c b/sys/dev/amr/amr.c index a8be136..2b5eca1 100644 --- a/sys/dev/amr/amr.c +++ b/sys/dev/amr/amr.c @@ -340,7 +340,7 @@ amr_submit_bio(struct amr_softc *sc, struct bio *bio) * Accept an open operation on the control device. */ int -amr_open(dev_t dev, int flags, int fmt, struct proc *p) +amr_open(dev_t dev, int flags, int fmt, struct thread *td) { int unit = minor(dev); struct amr_softc *sc = devclass_get_softc(amr_devclass, unit); @@ -355,7 +355,7 @@ amr_open(dev_t dev, int flags, int fmt, struct proc *p) * Accept the last close on the control device. */ int -amr_close(dev_t dev, int flags, int fmt, struct proc *p) +amr_close(dev_t dev, int flags, int fmt, struct thread *td) { int unit = minor(dev); struct amr_softc *sc = devclass_get_softc(amr_devclass, unit); @@ -370,7 +370,7 @@ amr_close(dev_t dev, int flags, int fmt, struct proc *p) * Handle controller-specific control operations. */ int -amr_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct proc *p) +amr_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *td) { struct amr_softc *sc = (struct amr_softc *)dev->si_drv1; int *arg = (int *)addr; diff --git a/sys/dev/amr/amr_disk.c b/sys/dev/amr/amr_disk.c index e6f016a..38784d3 100644 --- a/sys/dev/amr/amr_disk.c +++ b/sys/dev/amr/amr_disk.c @@ -100,7 +100,7 @@ static driver_t amrd_driver = { DRIVER_MODULE(amrd, amr, amrd_driver, amrd_devclass, 0, 0); static int -amrd_open(dev_t dev, int flags, int fmt, struct proc *p) +amrd_open(dev_t dev, int flags, int fmt, struct thread *td) { struct amrd_softc *sc = (struct amrd_softc *)dev->si_drv1; struct disklabel *label; @@ -129,7 +129,7 @@ amrd_open(dev_t dev, int flags, int fmt, struct proc *p) } static int -amrd_close(dev_t dev, int flags, int fmt, struct proc *p) +amrd_close(dev_t dev, int flags, int fmt, struct thread *td) { struct amrd_softc *sc = (struct amrd_softc *)dev->si_drv1; @@ -142,7 +142,7 @@ amrd_close(dev_t dev, int flags, int fmt, struct proc *p) } static int -amrd_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct proc *p) +amrd_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *td) { return (ENOTTY); diff --git a/sys/dev/an/if_an.c b/sys/dev/an/if_an.c index 87ad7b1..ed34c4a 100644 --- a/sys/dev/an/if_an.c +++ b/sys/dev/an/if_an.c @@ -94,6 +94,7 @@ #include <sys/systm.h> #include <sys/sockio.h> #include <sys/mbuf.h> +#include <sys/proc.h> #include <sys/kernel.h> #include <sys/socket.h> #ifdef ANCACHE diff --git a/sys/dev/asr/asr.c b/sys/dev/asr/asr.c index f755c54..32062a0 100644 --- a/sys/dev/asr/asr.c +++ b/sys/dev/asr/asr.c @@ -216,6 +216,7 @@ static dpt_sig_S ASR_sig = { #include <sys/malloc.h> #include <sys/conf.h> #include <sys/disklabel.h> +#include <sys/proc.h> #include <sys/bus.h> #include <machine/resource.h> #include <machine/bus.h> @@ -457,17 +458,17 @@ STATIC int asr_ioctl __P(( IN u_long cmd, INOUT caddr_t data, int flag, - struct proc * proc)); + struct thread * td)); STATIC int asr_open __P(( IN dev_t dev, int32_t flags, int32_t ifmt, - IN struct proc * proc)); + IN struct thread * td)); STATIC int asr_close __P(( dev_t dev, int flags, int ifmt, - struct proc * proc)); + struct thread * td)); STATIC int asr_intr __P(( IN Asr_softc_t * sc)); STATIC void asr_timeout __P(( @@ -3863,7 +3864,7 @@ asr_open( IN dev_t dev, int32_t flags, int32_t ifmt, - IN struct proc * proc) + IN struct thread * td) { int s; OUT int error; @@ -3876,7 +3877,7 @@ asr_open( s = splcam (); if (ASR_ctlr_held) { error = EBUSY; - } else if ((error = suser(proc)) == 0) { + } else if ((error = suser(td->td_proc)) == 0) { ++ASR_ctlr_held; } splx(s); @@ -3888,12 +3889,12 @@ asr_close( dev_t dev, int flags, int ifmt, - struct proc * proc) + struct thread * td) { UNREFERENCED_PARAMETER(dev); UNREFERENCED_PARAMETER(flags); UNREFERENCED_PARAMETER(ifmt); - UNREFERENCED_PARAMETER(proc); + UNREFERENCED_PARAMETER(td); ASR_ctlr_held = 0; return (0); @@ -4387,13 +4388,13 @@ asr_ioctl( IN u_long cmd, INOUT caddr_t data, int flag, - struct proc * proc) + struct thread * td) { int i, j; OUT int error = 0; Asr_softc_t * sc = ASR_get_sc (dev); UNREFERENCED_PARAMETER(flag); - UNREFERENCED_PARAMETER(proc); + UNREFERENCED_PARAMETER(td); if (sc != (Asr_softc_t *)NULL) switch(cmd) { diff --git a/sys/dev/ata/ata-all.c b/sys/dev/ata/ata-all.c index b6544d8..50a59c3 100644 --- a/sys/dev/ata/ata-all.c +++ b/sys/dev/ata/ata-all.c @@ -285,7 +285,7 @@ ata_resume(device_t dev) } static int -ataioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct proc *p) +ataioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *td) { struct ata_cmd *iocmd = (struct ata_cmd *)addr; device_t device; diff --git a/sys/dev/ata/ata-disk.c b/sys/dev/ata/ata-disk.c index 59aa250..7e5470a 100644 --- a/sys/dev/ata/ata-disk.c +++ b/sys/dev/ata/ata-disk.c @@ -252,7 +252,7 @@ ad_detach(struct ad_softc *adp, int flush) } static int -adopen(dev_t dev, int flags, int fmt, struct proc *p) +adopen(dev_t dev, int flags, int fmt, struct thread *td) { struct ad_softc *adp = dev->si_drv1; @@ -262,7 +262,7 @@ adopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -adclose(dev_t dev, int flags, int fmt, struct proc *p) +adclose(dev_t dev, int flags, int fmt, struct thread *td) { struct ad_softc *adp = dev->si_drv1; diff --git a/sys/dev/ata/ata-raid.c b/sys/dev/ata/ata-raid.c index 161d6b8..121110f 100644 --- a/sys/dev/ata/ata-raid.c +++ b/sys/dev/ata/ata-raid.c @@ -137,7 +137,7 @@ ar_attach(struct ar_softc *raid) } static int -aropen(dev_t dev, int flags, int fmt, struct proc *p) +aropen(dev_t dev, int flags, int fmt, struct thread *td) { struct ar_softc *rdp = dev->si_drv1; struct disklabel *dl; diff --git a/sys/dev/ata/atapi-cd.c b/sys/dev/ata/atapi-cd.c index 31d86e9..f69e7e7 100644 --- a/sys/dev/ata/atapi-cd.c +++ b/sys/dev/ata/atapi-cd.c @@ -33,6 +33,7 @@ #include <sys/ata.h> #include <sys/kernel.h> #include <sys/malloc.h> +#include <sys/proc.h> #include <sys/bio.h> #include <sys/bus.h> #include <sys/disklabel.h> @@ -499,7 +500,7 @@ msf2lba(u_int8_t m, u_int8_t s, u_int8_t f) } static int -acdopen(dev_t dev, int flags, int fmt, struct proc *p) +acdopen(dev_t dev, int flags, int fmt, struct thread *td) { struct acd_softc *cdp = dev->si_drv1; @@ -523,7 +524,7 @@ acdopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -acdclose(dev_t dev, int flags, int fmt, struct proc *p) +acdclose(dev_t dev, int flags, int fmt, struct thread *td) { struct acd_softc *cdp = dev->si_drv1; @@ -542,7 +543,7 @@ acdclose(dev_t dev, int flags, int fmt, struct proc *p) } static int -acdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) +acdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) { struct acd_softc *cdp = dev->si_drv1; int error = 0; @@ -595,7 +596,7 @@ acdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) break; case CDIOCRESET: - error = suser(p); + error = suser(td->td_proc); if (error) break; error = atapi_test_ready(cdp->atp); diff --git a/sys/dev/ata/atapi-fd.c b/sys/dev/ata/atapi-fd.c index a419d2b..ba47781 100644 --- a/sys/dev/ata/atapi-fd.c +++ b/sys/dev/ata/atapi-fd.c @@ -239,7 +239,7 @@ afd_describe(struct afd_softc *fdp) } static int -afdopen(dev_t dev, int flags, int fmt, struct proc *p) +afdopen(dev_t dev, int flags, int fmt, struct thread *td) { struct afd_softc *fdp = dev->si_drv1; struct disklabel *label = &fdp->disk.d_label; @@ -266,7 +266,7 @@ afdopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -afdclose(dev_t dev, int flags, int fmt, struct proc *p) +afdclose(dev_t dev, int flags, int fmt, struct thread *td) { struct afd_softc *fdp = dev->si_drv1; @@ -276,7 +276,7 @@ afdclose(dev_t dev, int flags, int fmt, struct proc *p) } static int -afdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +afdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct afd_softc *fdp = dev->si_drv1; diff --git a/sys/dev/ata/atapi-tape.c b/sys/dev/ata/atapi-tape.c index 98114c3..cb8b893 100644 --- a/sys/dev/ata/atapi-tape.c +++ b/sys/dev/ata/atapi-tape.c @@ -255,7 +255,7 @@ ast_describe(struct ast_softc *stp) } static int -astopen(dev_t dev, int flags, int fmt, struct proc *p) +astopen(dev_t dev, int flags, int fmt, struct thread *td) { struct ast_softc *stp = dev->si_drv1; @@ -281,7 +281,7 @@ astopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -astclose(dev_t dev, int flags, int fmt, struct proc *p) +astclose(dev_t dev, int flags, int fmt, struct thread *td) { struct ast_softc *stp = dev->si_drv1; @@ -310,7 +310,7 @@ astclose(dev_t dev, int flags, int fmt, struct proc *p) } static int -astioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +astioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct ast_softc *stp = dev->si_drv1; int error = 0; diff --git a/sys/dev/atkbdc/psm.c b/sys/dev/atkbdc/psm.c index 1bb5b71..1fb37ea 100644 --- a/sys/dev/atkbdc/psm.c +++ b/sys/dev/atkbdc/psm.c @@ -1164,7 +1164,7 @@ psmdetach(device_t dev) } static int -psmopen(dev_t dev, int flag, int fmt, struct proc *p) +psmopen(dev_t dev, int flag, int fmt, struct thread *td) { int unit = PSM_UNIT(dev); struct psm_softc *sc; @@ -1248,7 +1248,7 @@ psmopen(dev_t dev, int flag, int fmt, struct proc *p) } static int -psmclose(dev_t dev, int flag, int fmt, struct proc *p) +psmclose(dev_t dev, int flag, int fmt, struct thread *td) { int unit = PSM_UNIT(dev); struct psm_softc *sc = PSM_SOFTC(unit); @@ -1516,7 +1516,7 @@ unblock_mouse_data(struct psm_softc *sc, int c) } static int -psmioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +psmioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct psm_softc *sc = PSM_SOFTC(PSM_UNIT(dev)); mousemode_t mode; @@ -2237,7 +2237,7 @@ psmintr(void *arg) } static int -psmpoll(dev_t dev, int events, struct proc *p) +psmpoll(dev_t dev, int events, struct thread *td) { struct psm_softc *sc = PSM_SOFTC(PSM_UNIT(dev)); int s; @@ -2249,7 +2249,7 @@ psmpoll(dev_t dev, int events, struct proc *p) if (sc->queue.count > 0) revents |= events & (POLLIN | POLLRDNORM); else - selrecord(p, &sc->rsel); + selrecord(td, &sc->rsel); } splx(s); diff --git a/sys/dev/awi/awi.c b/sys/dev/awi/awi.c index 17c58ba..ab76ea0 100644 --- a/sys/dev/awi/awi.c +++ b/sys/dev/awi/awi.c @@ -99,6 +99,7 @@ #include <sys/systm.h> #include <sys/kernel.h> #include <sys/mbuf.h> +#include <sys/proc.h> #include <sys/malloc.h> #include <sys/socket.h> #include <sys/sockio.h> diff --git a/sys/dev/awi/awi_wep.c b/sys/dev/awi/awi_wep.c index d826d32..f9347c5 100644 --- a/sys/dev/awi/awi_wep.c +++ b/sys/dev/awi/awi_wep.c @@ -54,6 +54,7 @@ #include <sys/systm.h> #include <sys/kernel.h> #include <sys/mbuf.h> +#include <sys/proc.h> #include <sys/malloc.h> #include <sys/socket.h> #include <sys/errno.h> diff --git a/sys/dev/awi/awi_wicfg.c b/sys/dev/awi/awi_wicfg.c index e0554d7..97f9fce 100644 --- a/sys/dev/awi/awi_wicfg.c +++ b/sys/dev/awi/awi_wicfg.c @@ -45,6 +45,7 @@ #include <sys/systm.h> #include <sys/kernel.h> #include <sys/mbuf.h> +#include <sys/proc.h> #include <sys/malloc.h> #include <sys/socket.h> #include <sys/errno.h> diff --git a/sys/dev/bktr/bktr_core.c b/sys/dev/bktr/bktr_core.c index 50e8511..528f09a 100644 --- a/sys/dev/bktr/bktr_core.c +++ b/sys/dev/bktr/bktr_core.c @@ -1277,7 +1277,7 @@ vbi_read(bktr_ptr_t bktr, struct uio *uio, int ioflag) * video ioctls */ int -video_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct proc* pr ) +video_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct thread* td ) { volatile u_char c_temp; unsigned int temp; @@ -1565,7 +1565,7 @@ video_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct pro break; } bktr->signal = *(int *) arg; - bktr->proc = pr; + bktr->proc = td->td_proc; break; case METEORGSIGNAL: @@ -1886,7 +1886,7 @@ video_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct pro * tuner ioctls */ int -tuner_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct proc* pr ) +tuner_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct thread* td ) { int tmp_int; unsigned int temp, temp1; diff --git a/sys/dev/bktr/bktr_core.h b/sys/dev/bktr/bktr_core.h index bf41a99..5948ab6 100644 --- a/sys/dev/bktr/bktr_core.h +++ b/sys/dev/bktr/bktr_core.h @@ -82,13 +82,13 @@ int video_open( bktr_ptr_t bktr ); int video_close( bktr_ptr_t bktr ); int video_read( bktr_ptr_t bktr, int unit, dev_t dev, struct uio *uio ); int video_ioctl( bktr_ptr_t bktr, int unit, - ioctl_cmd_t cmd, caddr_t arg, struct proc* pr ); + ioctl_cmd_t cmd, caddr_t arg, struct thread* pr ); int tuner_open( bktr_ptr_t bktr ); int tuner_close( bktr_ptr_t bktr ); int tuner_ioctl( bktr_ptr_t bktr, int unit, - ioctl_cmd_t cmd, caddr_t arg, struct proc* pr ); + ioctl_cmd_t cmd, caddr_t arg, struct thread* pr ); int vbi_open( bktr_ptr_t bktr ); int vbi_close( bktr_ptr_t bktr ); diff --git a/sys/dev/bktr/bktr_os.c b/sys/dev/bktr/bktr_os.c index f916864..cc79745 100644 --- a/sys/dev/bktr/bktr_os.c +++ b/sys/dev/bktr/bktr_os.c @@ -559,7 +559,7 @@ get_bktr_mem( int unit, unsigned size ) * */ int -bktr_open( dev_t dev, int flags, int fmt, struct proc *p ) +bktr_open( dev_t dev, int flags, int fmt, struct thread *td ) { bktr_ptr_t bktr; int unit; @@ -639,7 +639,7 @@ bktr_open( dev_t dev, int flags, int fmt, struct proc *p ) * */ int -bktr_close( dev_t dev, int flags, int fmt, struct proc *p ) +bktr_close( dev_t dev, int flags, int fmt, struct thread *td ) { bktr_ptr_t bktr; int unit; @@ -716,7 +716,7 @@ bktr_write( dev_t dev, struct uio *uio, int ioflag ) * */ int -bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr ) +bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct thread *td ) { bktr_ptr_t bktr; int unit; @@ -735,9 +735,9 @@ bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr ) switch ( FUNCTION( minor(dev) ) ) { case VIDEO_DEV: - return( video_ioctl( bktr, unit, cmd, arg, pr ) ); + return( video_ioctl( bktr, unit, cmd, arg, td ) ); case TUNER_DEV: - return( tuner_ioctl( bktr, unit, cmd, arg, pr ) ); + return( tuner_ioctl( bktr, unit, cmd, arg, td ) ); } return( ENXIO ); @@ -777,7 +777,7 @@ bktr_mmap( dev_t dev, vm_offset_t offset, int nprot ) return( atop(vtophys(bktr->bigbuf) + offset) ); } -int bktr_poll( dev_t dev, int events, struct proc *p) +int bktr_poll( dev_t dev, int events, struct thread *td) { int unit; bktr_ptr_t bktr; @@ -800,7 +800,7 @@ int bktr_poll( dev_t dev, int events, struct proc *p) switch ( FUNCTION( minor(dev) ) ) { case VBI_DEV: if(bktr->vbisize == 0) - selrecord(p, &bktr->vbi_select); + selrecord(td, &bktr->vbi_select); else revents |= events & (POLLIN | POLLRDNORM); break; @@ -1064,7 +1064,7 @@ get_bktr_mem( int unit, unsigned size ) * */ int -bktr_open( dev_t dev, int flags, int fmt, struct proc *p ) +bktr_open( dev_t dev, int flags, int fmt, struct thread *td ) { bktr_ptr_t bktr; int unit; @@ -1127,7 +1127,7 @@ bktr_open( dev_t dev, int flags, int fmt, struct proc *p ) * */ int -bktr_close( dev_t dev, int flags, int fmt, struct proc *p ) +bktr_close( dev_t dev, int flags, int fmt, struct thread *td ) { bktr_ptr_t bktr; int unit; @@ -1188,7 +1188,7 @@ bktr_write( dev_t dev, struct uio *uio, int ioflag ) * */ int -bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr ) +bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct thread *td ) { bktr_ptr_t bktr; int unit; @@ -1204,9 +1204,9 @@ bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr ) switch ( FUNCTION( minor(dev) ) ) { case VIDEO_DEV: - return( video_ioctl( bktr, unit, cmd, arg, pr ) ); + return( video_ioctl( bktr, unit, cmd, arg, td ) ); case TUNER_DEV: - return( tuner_ioctl( bktr, unit, cmd, arg, pr ) ); + return( tuner_ioctl( bktr, unit, cmd, arg, td ) ); } return( ENXIO ); @@ -1242,7 +1242,7 @@ int bktr_mmap( dev_t dev, vm_offset_t offset, int nprot ) return( i386_btop(vtophys(bktr->bigbuf) + offset) ); } -int bktr_poll( dev_t dev, int events, struct proc *p) +int bktr_poll( dev_t dev, int events, struct thread *td) { int unit; bktr_ptr_t bktr; @@ -1605,7 +1605,7 @@ free_bktr_mem(bktr, dmap, kva) * */ int -bktr_open(dev_t dev, int flags, int fmt, struct proc *p) +bktr_open(dev_t dev, int flags, int fmt, struct thread *td) { bktr_ptr_t bktr; int unit; @@ -1638,7 +1638,7 @@ bktr_open(dev_t dev, int flags, int fmt, struct proc *p) * */ int -bktr_close(dev_t dev, int flags, int fmt, struct proc *p) +bktr_close(dev_t dev, int flags, int fmt, struct thread *td) { bktr_ptr_t bktr; int unit; @@ -1697,7 +1697,7 @@ bktr_write(dev_t dev, struct uio *uio, int ioflag) * */ int -bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr) +bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct thread *td) { bktr_ptr_t bktr; int unit; diff --git a/sys/dev/ccd/ccd.c b/sys/dev/ccd/ccd.c index 68df08e..090087b 100644 --- a/sys/dev/ccd/ccd.c +++ b/sys/dev/ccd/ccd.c @@ -202,8 +202,8 @@ static void ccdiodone(struct bio *bp); static void ccdstart(struct ccd_s *, struct bio *); static void ccdinterleave(struct ccd_s *, int); static void ccdintr(struct ccd_s *, struct bio *); -static int ccdinit(struct ccd_s *, char **, struct proc *); -static int ccdlookup(char *, struct proc *p, struct vnode **); +static int ccdinit(struct ccd_s *, char **, struct thread *); +static int ccdlookup(char *, struct thread *p, struct vnode **); static void ccdbuffer(struct ccdbuf **ret, struct ccd_s *, struct bio *, daddr_t, caddr_t, long); static void ccdgetdisklabel(dev_t); @@ -381,7 +381,7 @@ ccd_modevent(module_t mod, int type, void *data) DEV_MODULE(ccd, ccd_modevent, NULL); static int -ccdinit(struct ccd_s *cs, char **cpaths, struct proc *p) +ccdinit(struct ccd_s *cs, char **cpaths, struct thread *td) { struct ccdcinfo *ci = NULL; /* XXX */ size_t size; @@ -438,7 +438,7 @@ ccdinit(struct ccd_s *cs, char **cpaths, struct proc *p) * Get partition information for the component. */ if ((error = VOP_IOCTL(vp, DIOCGPART, (caddr_t)&dpart, - FREAD, p->p_ucred, p)) != 0) { + FREAD, td->td_proc->p_ucred, td)) != 0) { #ifdef DEBUG if (ccddebug & (CCDB_FOLLOW|CCDB_INIT)) printf("ccd%d: %s: ioctl failed, error = %d\n", @@ -701,7 +701,7 @@ ccdinterleave(struct ccd_s *cs, int unit) /* ARGSUSED */ static int -ccdopen(dev_t dev, int flags, int fmt, struct proc *p) +ccdopen(dev_t dev, int flags, int fmt, struct thread *td) { int unit = ccdunit(dev); struct ccd_s *cs; @@ -746,7 +746,7 @@ ccdopen(dev_t dev, int flags, int fmt, struct proc *p) /* ARGSUSED */ static int -ccdclose(dev_t dev, int flags, int fmt, struct proc *p) +ccdclose(dev_t dev, int flags, int fmt, struct thread *td) { int unit = ccdunit(dev); struct ccd_s *cs; @@ -770,7 +770,7 @@ ccdclose(dev_t dev, int flags, int fmt, struct proc *p) cs->sc_openmask &= ~(1 << part); /* collect "garbage" if possible */ if (!IS_INITED(cs) && (cs->sc_flags & CCDF_WANTED) == 0) - ccddestroy(cs, p); + ccddestroy(cs, td->td_proc); else ccdunlock(cs); return (0); @@ -1238,7 +1238,7 @@ ccdiodone(struct bio *ibp) } static int -ccdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +ccdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int unit = ccdunit(dev); int i, j, lookedup = 0, error = 0; @@ -1317,10 +1317,10 @@ ccdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) if (ccddebug & CCDB_INIT) printf("ccdioctl: lookedup = %d\n", lookedup); #endif - if ((error = ccdlookup(cpp[i], p, &vpp[i])) != 0) { + if ((error = ccdlookup(cpp[i], td, &vpp[i])) != 0) { for (j = 0; j < lookedup; ++j) (void)vn_close(vpp[j], FREAD|FWRITE, - p->p_ucred, p); + td->td_proc->p_ucred, td); free(vpp, M_DEVBUF); free(cpp, M_DEVBUF); ccdunlock(cs); @@ -1334,10 +1334,10 @@ ccdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) /* * Initialize the ccd. Fills in the softc for us. */ - if ((error = ccdinit(cs, cpp, p)) != 0) { + if ((error = ccdinit(cs, cpp, td)) != 0) { for (j = 0; j < lookedup; ++j) (void)vn_close(vpp[j], FREAD|FWRITE, - p->p_ucred, p); + td->td_proc->p_ucred, td); /* * We can't ccddestroy() cs just yet, because nothing * prevents user-level app to do another ioctl() @@ -1398,7 +1398,7 @@ ccdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) cs->sc_cinfo[i].ci_vp); #endif (void)vn_close(cs->sc_cinfo[i].ci_vp, FREAD|FWRITE, - p->p_ucred, p); + td->td_proc->p_ucred, td); free(cs->sc_cinfo[i].ci_path, M_DEVBUF); } @@ -1557,7 +1557,7 @@ ccdsize(dev_t dev) struct ccd_s *cs; int part, size; - if (ccdopen(dev, 0, S_IFCHR, curproc)) + if (ccdopen(dev, 0, S_IFCHR, curthread)) return (-1); cs = ccdfind(ccdunit(dev)); @@ -1571,7 +1571,7 @@ ccdsize(dev_t dev) else size = cs->sc_label.d_partitions[part].p_size; - if (ccdclose(dev, 0, S_IFCHR, curproc)) + if (ccdclose(dev, 0, S_IFCHR, curthread)) return (-1); return (size); @@ -1591,13 +1591,13 @@ ccddump(dev_t dev) * set *vpp to the file's vnode. */ static int -ccdlookup(char *path, struct proc *p, struct vnode **vpp) +ccdlookup(char *path, struct thread *td, struct vnode **vpp) { struct nameidata nd; struct vnode *vp; int error, flags; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, path, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, path, td); flags = FREAD | FWRITE; if ((error = vn_open(&nd, &flags, 0)) != 0) { #ifdef DEBUG @@ -1621,15 +1621,15 @@ ccdlookup(char *path, struct proc *p, struct vnode **vpp) vprint("ccdlookup: vnode info", vp); #endif - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); NDFREE(&nd, NDF_ONLY_PNBUF); *vpp = vp; return (0); bad: - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); NDFREE(&nd, NDF_ONLY_PNBUF); /* vn_close does vrele() for vp */ - (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p); + (void)vn_close(vp, FREAD|FWRITE, td->td_proc->p_ucred, td); return (error); } diff --git a/sys/dev/cy/cy.c b/sys/dev/cy/cy.c index 9d6f2bb..728ea0a 100644 --- a/sys/dev/cy/cy.c +++ b/sys/dev/cy/cy.c @@ -662,11 +662,11 @@ cyattach_common(cy_iobase, cy_align) } static int -sioopen(dev, flag, mode, p) +sioopen(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct com_s *com; int error; @@ -718,7 +718,7 @@ open_top: } } if (tp->t_state & TS_XCLUDE && - suser(p)) { + suser_td(td)) { error = EBUSY; goto out; } @@ -847,11 +847,11 @@ out: } static int -sioclose(dev, flag, mode, p) +sioclose(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct com_s *com; int mynor; @@ -1605,12 +1605,12 @@ siointr1(com) #endif static int -sioioctl(dev, cmd, data, flag, p) +sioioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct com_s *com; int error; @@ -1639,7 +1639,7 @@ sioioctl(dev, cmd, data, flag, p) } switch (cmd) { case TIOCSETA: - error = suser(p); + error = suser_td(td); if (error != 0) return (error); *ct = *(struct termios *)data; @@ -1689,7 +1689,7 @@ sioioctl(dev, cmd, data, flag, p) if (lt->c_ospeed != 0) dt->c_ospeed = tp->t_ospeed; } - 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); s = spltty(); @@ -1738,7 +1738,7 @@ sioioctl(dev, cmd, data, flag, p) break; case TIOCMSDTRWAIT: /* must be root since the wait applies to following logins */ - error = suser(p); + error = suser_td(td); if (error != 0) { splx(s); return (error); diff --git a/sys/dev/cy/cy_isa.c b/sys/dev/cy/cy_isa.c index 9d6f2bb..728ea0a 100644 --- a/sys/dev/cy/cy_isa.c +++ b/sys/dev/cy/cy_isa.c @@ -662,11 +662,11 @@ cyattach_common(cy_iobase, cy_align) } static int -sioopen(dev, flag, mode, p) +sioopen(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct com_s *com; int error; @@ -718,7 +718,7 @@ open_top: } } if (tp->t_state & TS_XCLUDE && - suser(p)) { + suser_td(td)) { error = EBUSY; goto out; } @@ -847,11 +847,11 @@ out: } static int -sioclose(dev, flag, mode, p) +sioclose(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct com_s *com; int mynor; @@ -1605,12 +1605,12 @@ siointr1(com) #endif static int -sioioctl(dev, cmd, data, flag, p) +sioioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct com_s *com; int error; @@ -1639,7 +1639,7 @@ sioioctl(dev, cmd, data, flag, p) } switch (cmd) { case TIOCSETA: - error = suser(p); + error = suser_td(td); if (error != 0) return (error); *ct = *(struct termios *)data; @@ -1689,7 +1689,7 @@ sioioctl(dev, cmd, data, flag, p) if (lt->c_ospeed != 0) dt->c_ospeed = tp->t_ospeed; } - 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); s = spltty(); @@ -1738,7 +1738,7 @@ sioioctl(dev, cmd, data, flag, p) break; case TIOCMSDTRWAIT: /* must be root since the wait applies to following logins */ - error = suser(p); + error = suser_td(td); if (error != 0) { splx(s); return (error); diff --git a/sys/dev/dgb/dgb.c b/sys/dev/dgb/dgb.c index c675485..fa27d31 100644 --- a/sys/dev/dgb/dgb.c +++ b/sys/dev/dgb/dgb.c @@ -959,11 +959,11 @@ load_fep: /* ARGSUSED */ static int -dgbopen(dev, flag, mode, p) +dgbopen(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct dgb_softc *sc; struct tty *tp; @@ -1049,7 +1049,7 @@ open_top: } } if (tp->t_state & TS_XCLUDE && - suser(p)) { + suser_td(td)) { error = EBUSY; goto out; } @@ -1139,11 +1139,11 @@ out: /*ARGSUSED*/ static int -dgbclose(dev, flag, mode, p) +dgbclose(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { int mynor; struct tty *tp; @@ -1499,12 +1499,12 @@ dgbpoll(unit_c) } static int -dgbioctl(dev, cmd, data, flag, p) +dgbioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct dgb_softc *sc; int unit, pnum; @@ -1547,7 +1547,7 @@ dgbioctl(dev, cmd, data, flag, p) } switch (cmd) { case TIOCSETA: - error = suser(p); + error = suser_td(td); if (error != 0) return (error); *ct = *(struct termios *)data; @@ -1622,7 +1622,7 @@ dgbioctl(dev, cmd, data, flag, p) if(cmd==TIOCSETAW || cmd==TIOCSETAF) port->mustdrain=1; - 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; s = spltty(); @@ -1769,7 +1769,7 @@ dgbioctl(dev, cmd, data, flag, p) break; case TIOCMSDTRWAIT: /* must be root since the wait applies to following logins */ - error = suser(p); + error = suser_td(td); if (error != 0) { splx(s); return (error); diff --git a/sys/dev/digi/digi.c b/sys/dev/digi/digi.c index 6b29a5a..cab0a17 100644 --- a/sys/dev/digi/digi.c +++ b/sys/dev/digi/digi.c @@ -723,7 +723,7 @@ digi_disc_optim(struct tty *tp, struct termios *t, struct digi_p *port) } int -digiopen(dev_t dev, int flag, int mode, struct proc *p) +digiopen(dev_t dev, int flag, int mode, struct thread *td) { struct digi_softc *sc; struct tty *tp; @@ -801,7 +801,7 @@ open_top: } goto open_top; } - if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0) { + if (tp->t_state & TS_XCLUDE && td->td_proc->p_ucred->cr_uid != 0) { error = EBUSY; goto out; } @@ -888,7 +888,7 @@ out: } int -digiclose(dev_t dev, int flag, int mode, struct proc *p) +digiclose(dev_t dev, int flag, int mode, struct thread *td) { int mynor; struct tty *tp; @@ -1090,7 +1090,7 @@ digi_loadmoduledata(struct digi_softc *sc) } static int -digiioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +digiioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int unit, pnum, mynor, error, s; struct digi_softc *sc; @@ -1164,7 +1164,7 @@ digiioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) switch (cmd) { case TIOCSETA: - error = suser(p); + error = suser_td(td); if (error != 0) return (error); *ct = *(struct termios *)data; @@ -1285,7 +1285,7 @@ digiioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) if (lt->c_ospeed != 0) dt->c_ospeed = tp->t_ospeed; } - 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 == 0 && cmd == TIOCGETA) ((struct termios *)data)->c_iflag |= port->c_iflag; @@ -1335,7 +1335,7 @@ digiioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) *(int *)data = digimctl(port, 0, DMGET); break; case TIOCMSDTRWAIT: - error = suser(p); + error = suser_td(td); if (error != 0) { splx(s); return (error); diff --git a/sys/dev/fb/fb.c b/sys/dev/fb/fb.c index 75d9b44..5bfd303 100644 --- a/sys/dev/fb/fb.c +++ b/sys/dev/fb/fb.c @@ -439,7 +439,7 @@ fb_detach(dev_t dev, video_adapter_t *adp, struct cdevsw *cdevsw) } static int -fbopen(dev_t dev, int flag, int mode, struct proc *p) +fbopen(dev_t dev, int flag, int mode, struct thread *td) { int unit; @@ -449,11 +449,11 @@ fbopen(dev_t dev, int flag, int mode, struct proc *p) if (vidcdevsw[unit] == NULL) return ENXIO; return (*vidcdevsw[unit]->d_open)(makedev(0, adapter[unit]->va_minor), - flag, mode, p); + flag, mode, td); } static int -fbclose(dev_t dev, int flag, int mode, struct proc *p) +fbclose(dev_t dev, int flag, int mode, struct thread *td) { int unit; @@ -461,7 +461,7 @@ fbclose(dev_t dev, int flag, int mode, struct proc *p) if (vidcdevsw[unit] == NULL) return ENXIO; return (*vidcdevsw[unit]->d_close)(makedev(0, adapter[unit]->va_minor), - flag, mode, p); + flag, mode, td); } static int @@ -489,7 +489,7 @@ fbwrite(dev_t dev, struct uio *uio, int flag) } static int -fbioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *p) +fbioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct thread *td) { int unit; @@ -497,7 +497,7 @@ fbioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *p) if (vidcdevsw[unit] == NULL) return ENXIO; return (*vidcdevsw[unit]->d_ioctl)(makedev(0, adapter[unit]->va_minor), - cmd, arg, flag, p); + cmd, arg, flag, td); } static int @@ -523,7 +523,7 @@ DEV_DRIVER_MODULE(fb, ???, fb_driver, fb_devclass, fb_cdevsw, 0, 0); */ int genfbopen(genfb_softc_t *sc, video_adapter_t *adp, int flag, int mode, - struct proc *p) + struct thread *td) { int s; @@ -535,7 +535,7 @@ int genfbopen(genfb_softc_t *sc, video_adapter_t *adp, int flag, int mode, } int genfbclose(genfb_softc_t *sc, video_adapter_t *adp, int flag, int mode, - struct proc *p) + struct thread *td) { int s; @@ -578,7 +578,7 @@ int genfbwrite(genfb_softc_t *sc, video_adapter_t *adp, struct uio *uio, } int genfbioctl(genfb_softc_t *sc, video_adapter_t *adp, u_long cmd, - caddr_t arg, int flag, struct proc *p) + caddr_t arg, int flag, struct thread *td) { int error; diff --git a/sys/dev/fb/fbreg.h b/sys/dev/fb/fbreg.h index e8a8513..1fcaf13 100644 --- a/sys/dev/fb/fbreg.h +++ b/sys/dev/fb/fbreg.h @@ -184,15 +184,15 @@ typedef struct genfb_softc { } genfb_softc_t; int genfbopen(genfb_softc_t *sc, video_adapter_t *adp, - int flag, int mode, struct proc *p); + int flag, int mode, struct thread *td); int genfbclose(genfb_softc_t *sc, video_adapter_t *adp, - int flag, int mode, struct proc *p); + int flag, int mode, struct thread *td); int genfbread(genfb_softc_t *sc, video_adapter_t *adp, struct uio *uio, int flag); int genfbwrite(genfb_softc_t *sc, video_adapter_t *adp, struct uio *uio, int flag); int genfbioctl(genfb_softc_t *sc, video_adapter_t *adp, - u_long cmd, caddr_t arg, int flag, struct proc *p); + u_long cmd, caddr_t arg, int flag, struct thread *td); int genfbmmap(genfb_softc_t *sc, video_adapter_t *adp, vm_offset_t offset, int prot); diff --git a/sys/dev/fb/vga.c b/sys/dev/fb/vga.c index 838228b..19d6f1f 100644 --- a/sys/dev/fb/vga.c +++ b/sys/dev/fb/vga.c @@ -96,20 +96,20 @@ vga_attach_unit(int unit, vga_softc_t *sc, int flags) #ifdef FB_INSTALL_CDEV int -vga_open(dev_t dev, vga_softc_t *sc, int flag, int mode, struct proc *p) +vga_open(dev_t dev, vga_softc_t *sc, int flag, int mode, struct thread *td) { if (sc == NULL) return ENXIO; if (mode & (O_CREAT | O_APPEND | O_TRUNC)) return ENODEV; - return genfbopen(&sc->gensc, sc->adp, flag, mode, p); + return genfbopen(&sc->gensc, sc->adp, flag, mode, td); } int -vga_close(dev_t dev, vga_softc_t *sc, int flag, int mode, struct proc *p) +vga_close(dev_t dev, vga_softc_t *sc, int flag, int mode, struct thread *td) { - return genfbclose(&sc->gensc, sc->adp, flag, mode, p); + return genfbclose(&sc->gensc, sc->adp, flag, mode, td); } int @@ -126,9 +126,9 @@ vga_write(dev_t dev, vga_softc_t *sc, struct uio *uio, int flag) int vga_ioctl(dev_t dev, vga_softc_t *sc, u_long cmd, caddr_t arg, int flag, - struct proc *p) + struct thread *td) { - return genfbioctl(&sc->gensc, sc->adp, cmd, arg, flag, p); + return genfbioctl(&sc->gensc, sc->adp, cmd, arg, flag, td); } int diff --git a/sys/dev/fb/vgareg.h b/sys/dev/fb/vgareg.h index d50e5f2..f59c7ee 100644 --- a/sys/dev/fb/vgareg.h +++ b/sys/dev/fb/vgareg.h @@ -79,13 +79,13 @@ int vga_attach_unit(int unit, vga_softc_t *sc, int flags); #ifdef FB_INSTALL_CDEV int vga_open(dev_t dev, vga_softc_t *sc, int flag, int mode, - struct proc *p); + struct thread *td); int vga_close(dev_t dev, vga_softc_t *sc, int flag, int mode, - struct proc *p); + struct thread *td); int vga_read(dev_t dev, vga_softc_t *sc, struct uio *uio, int flag); int vga_write(dev_t dev, vga_softc_t *sc, struct uio *uio, int flag); int vga_ioctl(dev_t dev, vga_softc_t *sc, u_long cmd, caddr_t arg, - int flag, struct proc *p); + int flag, struct thread *td); int vga_mmap(dev_t dev, vga_softc_t *sc, vm_offset_t offset, int prot); #endif diff --git a/sys/dev/fdc/fdc.c b/sys/dev/fdc/fdc.c index f896b33..845f520 100644 --- a/sys/dev/fdc/fdc.c +++ b/sys/dev/fdc/fdc.c @@ -1519,7 +1519,7 @@ out_fdc(struct fdc_data *fdc, int x) * auxiliary functions). */ int -Fdopen(dev_t dev, int flags, int mode, struct proc *p) +Fdopen(dev_t dev, int flags, int mode, struct thread *td) { fdu_t fdu = FDUNIT(minor(dev)); int type = FDTYPE(minor(dev)); @@ -1614,7 +1614,7 @@ Fdopen(dev_t dev, int flags, int mode, struct proc *p) } int -fdclose(dev_t dev, int flags, int mode, struct proc *p) +fdclose(dev_t dev, int flags, int mode, struct thread *td) { fdu_t fdu = FDUNIT(minor(dev)); struct fd_data *fd; @@ -2473,7 +2473,7 @@ fdmisccmd(dev_t dev, u_int cmd, void *data) } static int -fdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +fdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { fdu_t fdu; fd_p fd; @@ -2545,7 +2545,7 @@ fdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) case FD_STYPE: /* set drive type */ /* this is considered harmful; only allow for superuser */ - if (suser(p) != 0) + if (suser_td(td) != 0) return (EPERM); *fd->ft = *(struct fd_type *)addr; break; @@ -2569,7 +2569,7 @@ fdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) #endif case FD_CLRERR: - if (suser(p) != 0) + if (suser_td(td) != 0) return (EPERM); fd->fdc->fdc_errs = 0; break; diff --git a/sys/dev/ida/ida_disk.c b/sys/dev/ida/ida_disk.c index 5358e5d..a545cf2 100644 --- a/sys/dev/ida/ida_disk.c +++ b/sys/dev/ida/ida_disk.c @@ -110,7 +110,7 @@ idad_getsoftc(dev_t dev) } static int -idad_open(dev_t dev, int flags, int fmt, struct proc *p) +idad_open(dev_t dev, int flags, int fmt, struct thread *td) { struct idad_softc *drv; struct disklabel *label; @@ -133,7 +133,7 @@ idad_open(dev_t dev, int flags, int fmt, struct proc *p) } static int -idad_close(dev_t dev, int flags, int fmt, struct proc *p) +idad_close(dev_t dev, int flags, int fmt, struct thread *td) { struct idad_softc *drv; diff --git a/sys/dev/iicbus/iic.c b/sys/dev/iicbus/iic.c index 1f07f25..42c3ee0 100644 --- a/sys/dev/iicbus/iic.c +++ b/sys/dev/iicbus/iic.c @@ -133,7 +133,7 @@ iic_attach(device_t dev) } static int -iicopen (dev_t dev, int flags, int fmt, struct proc *p) +iicopen (dev_t dev, int flags, int fmt, struct thread *td) { struct iic_softc *sc = IIC_SOFTC(minor(dev)); @@ -149,7 +149,7 @@ iicopen (dev_t dev, int flags, int fmt, struct proc *p) } static int -iicclose(dev_t dev, int flags, int fmt, struct proc *p) +iicclose(dev_t dev, int flags, int fmt, struct thread *td) { struct iic_softc *sc = IIC_SOFTC(minor(dev)); @@ -227,7 +227,7 @@ iicread(dev_t dev, struct uio * uio, int ioflag) } static int -iicioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +iicioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td) { device_t iicdev = IIC_DEVICE(minor(dev)); struct iic_softc *sc = IIC_SOFTC(minor(dev)); diff --git a/sys/dev/isp/isp_freebsd.c b/sys/dev/isp/isp_freebsd.c index 4a92a01..32e0151 100644 --- a/sys/dev/isp/isp_freebsd.c +++ b/sys/dev/isp/isp_freebsd.c @@ -233,7 +233,7 @@ isp_attach(struct ispsoftc *isp) } static int -ispioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) +ispioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) { struct ispsoftc *isp; int retval = ENOTTY; diff --git a/sys/dev/joy/joy.c b/sys/dev/joy/joy.c index beda4de..0f3f11d 100644 --- a/sys/dev/joy/joy.c +++ b/sys/dev/joy/joy.c @@ -159,7 +159,7 @@ DRIVER_MODULE(joy, isa, joy_isa_driver, joy_devclass, 0, 0); DRIVER_MODULE(joy, acpi, joy_isa_driver, joy_devclass, 0, 0); static int -joyopen(dev_t dev, int flags, int fmt, struct proc *p) +joyopen(dev_t dev, int flags, int fmt, struct thread *td) { int i = joypart (dev); struct joy_softc *joy = JOY_SOFTC(UNIT(dev)); @@ -172,7 +172,7 @@ joyopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -joyclose(dev_t dev, int flags, int fmt, struct proc *p) +joyclose(dev_t dev, int flags, int fmt, struct thread *td) { int i = joypart (dev); struct joy_softc *joy = JOY_SOFTC(UNIT(dev)); @@ -240,7 +240,7 @@ joyread(dev_t dev, struct uio *uio, int flag) } static int -joyioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +joyioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { struct joy_softc *joy = JOY_SOFTC(UNIT(dev)); int i = joypart (dev); diff --git a/sys/dev/kbd/kbd.c b/sys/dev/kbd/kbd.c index e53015b..1a1c132 100644 --- a/sys/dev/kbd/kbd.c +++ b/sys/dev/kbd/kbd.c @@ -491,7 +491,7 @@ kbd_detach(keyboard_t *kbd) static kbd_callback_func_t genkbd_event; static int -genkbdopen(dev_t dev, int mode, int flag, struct proc *p) +genkbdopen(dev_t dev, int mode, int flag, struct thread *td) { keyboard_t *kbd; genkbd_softc_t *sc; @@ -531,7 +531,7 @@ genkbdopen(dev_t dev, int mode, int flag, struct proc *p) } static int -genkbdclose(dev_t dev, int mode, int flag, struct proc *p) +genkbdclose(dev_t dev, int mode, int flag, struct thread *td) { keyboard_t *kbd; genkbd_softc_t *sc; @@ -621,7 +621,7 @@ genkbdwrite(dev_t dev, struct uio *uio, int flag) } static int -genkbdioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *p) +genkbdioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct thread *td) { keyboard_t *kbd; int error; @@ -636,7 +636,7 @@ genkbdioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *p) } static int -genkbdpoll(dev_t dev, int events, struct proc *p) +genkbdpoll(dev_t dev, int events, struct thread *td) { keyboard_t *kbd; genkbd_softc_t *sc; @@ -653,7 +653,7 @@ genkbdpoll(dev_t dev, int events, struct proc *p) if (sc->gkb_q.c_cc > 0) revents = events & (POLLIN | POLLRDNORM); else - selrecord(p, &sc->gkb_rsel); + selrecord(td, &sc->gkb_rsel); } splx(s); return revents; diff --git a/sys/dev/mcd/mcd.c b/sys/dev/mcd/mcd.c index 6f8c0f7..f295a43 100644 --- a/sys/dev/mcd/mcd.c +++ b/sys/dev/mcd/mcd.c @@ -270,7 +270,7 @@ int mcd_attach(struct isa_device *dev) return 1; } -int mcdopen(dev_t dev, int flags, int fmt, struct proc *p) +int mcdopen(dev_t dev, int flags, int fmt, struct thread *td) { int unit,part,phys,r,retry; struct mcd_data *cd; @@ -362,7 +362,7 @@ MCD_TRACE("open: partition=%d, disksize = %ld, blksize=%d\n", return ENXIO; } -int mcdclose(dev_t dev, int flags, int fmt, struct proc *p) +int mcdclose(dev_t dev, int flags, int fmt, struct thread *td) { int unit,part; struct mcd_data *cd; @@ -504,7 +504,7 @@ static void mcd_start(int unit) return; } -int mcdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) +int mcdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) { struct mcd_data *cd; int unit,part,retry,r; diff --git a/sys/dev/md/md.c b/sys/dev/md/md.c index 3f16777..9666ef3 100644 --- a/sys/dev/md/md.c +++ b/sys/dev/md/md.c @@ -180,14 +180,14 @@ struct md_s { }; static int -mdopen(dev_t dev, int flag, int fmt, struct proc *p) +mdopen(dev_t dev, int flag, int fmt, struct thread *td) { struct md_s *sc; struct disklabel *dl; if (md_debug) printf("mdopen(%s %x %x %p)\n", - devtoname(dev), flag, fmt, p); + devtoname(dev), flag, fmt, td->td_proc); sc = dev->si_drv1; @@ -204,7 +204,7 @@ mdopen(dev_t dev, int flag, int fmt, struct proc *p) } static int -mdclose(dev_t dev, int flags, int fmt, struct proc *p) +mdclose(dev_t dev, int flags, int fmt, struct thread *td) { struct md_s *sc = dev->si_drv1; @@ -213,12 +213,12 @@ mdclose(dev_t dev, int flags, int fmt, struct proc *p) } static int -mdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) +mdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) { if (md_debug) printf("mdioctl(%s %lx %p %x %p)\n", - devtoname(dev), cmd, addr, flags, p); + devtoname(dev), cmd, addr, flags, td); return (ENOIOCTL); } @@ -385,19 +385,19 @@ mdstart_vnode(struct md_s *sc) else auio.uio_rw = UIO_WRITE; auio.uio_resid = bp->bio_bcount; - auio.uio_procp = curproc; + auio.uio_td = curthread; if (VOP_ISLOCKED(sc->vnode, NULL)) vprint("unexpected md driver lock", sc->vnode); if (bp->bio_cmd == BIO_READ) { - vn_lock(sc->vnode, LK_EXCLUSIVE | LK_RETRY, curproc); + vn_lock(sc->vnode, LK_EXCLUSIVE | LK_RETRY, curthread); error = VOP_READ(sc->vnode, &auio, 0, sc->cred); } else { (void) vn_start_write(sc->vnode, &mp, V_WAIT); - vn_lock(sc->vnode, LK_EXCLUSIVE | LK_RETRY, curproc); + vn_lock(sc->vnode, LK_EXCLUSIVE | LK_RETRY, curthread); error = VOP_WRITE(sc->vnode, &auio, 0, sc->cred); vn_finished_write(mp); } - VOP_UNLOCK(sc->vnode, 0, curproc); + VOP_UNLOCK(sc->vnode, 0, curthread); bp->bio_resid = auio.uio_resid; biofinish(bp, &sc->stats, error); } @@ -633,17 +633,18 @@ mdsetcred(struct md_s *sc, struct ucred *cred) auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; auio.uio_resid = aiov.iov_len; - vn_lock(sc->vnode, LK_EXCLUSIVE | LK_RETRY, curproc); + vn_lock(sc->vnode, LK_EXCLUSIVE | LK_RETRY, curthread); error = VOP_READ(sc->vnode, &auio, 0, sc->cred); - VOP_UNLOCK(sc->vnode, 0, curproc); + VOP_UNLOCK(sc->vnode, 0, curthread); free(tmpbuf, M_TEMP); } return (error); } static int -mdcreate_vnode(struct md_ioctl *mdio, struct proc *p) +mdcreate_vnode(struct md_ioctl *mdio, struct thread *td) { + struct proc *p = td->td_proc; struct md_s *sc; struct vattr vattr; struct nameidata nd; @@ -662,26 +663,26 @@ mdcreate_vnode(struct md_ioctl *mdio, struct proc *p) sc->flags = mdio->md_options & MD_FORCE; flags = FREAD|FWRITE; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, mdio->md_file, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, mdio->md_file, td); error = vn_open(&nd, &flags, 0); if (error) { if (error != EACCES && error != EPERM && error != EROFS) return (error); flags &= ~FWRITE; sc->flags |= MD_READONLY; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, mdio->md_file, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, mdio->md_file, td); error = vn_open(&nd, &flags, 0); if (error) return (error); } NDFREE(&nd, NDF_ONLY_PNBUF); if (nd.ni_vp->v_type != VREG || - (error = VOP_GETATTR(nd.ni_vp, &vattr, p->p_ucred, p))) { - VOP_UNLOCK(nd.ni_vp, 0, p); - (void) vn_close(nd.ni_vp, flags, p->p_ucred, p); + (error = VOP_GETATTR(nd.ni_vp, &vattr, p->p_ucred, td))) { + VOP_UNLOCK(nd.ni_vp, 0, td); + (void) vn_close(nd.ni_vp, flags, p->p_ucred, td); return (error ? error : EINVAL); } - VOP_UNLOCK(nd.ni_vp, 0, p); + VOP_UNLOCK(nd.ni_vp, 0, td); sc->secsize = DEV_BSIZE; sc->vnode = nd.ni_vp; @@ -693,12 +694,12 @@ mdcreate_vnode(struct md_ioctl *mdio, struct proc *p) else sc->nsect = vattr.va_size / sc->secsize; /* XXX: round up ? */ if (sc->nsect == 0) { - (void) vn_close(nd.ni_vp, flags, p->p_ucred, p); + (void) vn_close(nd.ni_vp, flags, p->p_ucred, td); return (EINVAL); } error = mdsetcred(sc, p->p_ucred); if (error) { - (void) vn_close(nd.ni_vp, flags, p->p_ucred, p); + (void) vn_close(nd.ni_vp, flags, p->p_ucred, td); return (error); } mdinit(sc); @@ -706,7 +707,7 @@ mdcreate_vnode(struct md_ioctl *mdio, struct proc *p) } static int -mddestroy(struct md_s *sc, struct proc *p) +mddestroy(struct md_s *sc, struct thread *td) { unsigned u; @@ -718,7 +719,7 @@ mddestroy(struct md_s *sc, struct proc *p) } if (sc->vnode != NULL) (void)vn_close(sc->vnode, sc->flags & MD_READONLY ? - FREAD : (FREAD|FWRITE), sc->cred, p); + FREAD : (FREAD|FWRITE), sc->cred, td); if (sc->cred != NULL) crfree(sc->cred); if (sc->object != NULL) { @@ -739,7 +740,7 @@ mddestroy(struct md_s *sc, struct proc *p) } static int -mdcreate_swap(struct md_ioctl *mdio, struct proc *p) +mdcreate_swap(struct md_ioctl *mdio, struct thread *td) { int error; struct md_s *sc; @@ -763,7 +764,7 @@ mdcreate_swap(struct md_ioctl *mdio, struct proc *p) */ if (mdio->md_size == 0) { - mddestroy(sc, p); + mddestroy(sc, td); return (EDOM); } @@ -784,20 +785,20 @@ mdcreate_swap(struct md_ioctl *mdio, struct proc *p) if (swap_pager_reserve(sc->object, 0, sc->nsect) < 0) { vm_pager_deallocate(sc->object); sc->object = NULL; - mddestroy(sc, p); + mddestroy(sc, td); return (EDOM); } } - error = mdsetcred(sc, p->p_ucred); + error = mdsetcred(sc, td->td_proc->p_ucred); if (error) - mddestroy(sc, p); + mddestroy(sc, td); else mdinit(sc); return (error); } static int -mddetach(int unit, struct proc *p) +mddetach(int unit, struct thread *td) { struct md_s *sc; @@ -811,21 +812,21 @@ mddetach(int unit, struct proc *p) case MD_SWAP: case MD_MALLOC: case MD_PRELOAD: - return (mddestroy(sc, p)); + return (mddestroy(sc, td)); default: return (EOPNOTSUPP); } } static int -mdctlioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) +mdctlioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) { struct md_ioctl *mdio; struct md_s *sc; if (md_debug) printf("mdctlioctl(%s %lx %p %x %p)\n", - devtoname(dev), cmd, addr, flags, p); + devtoname(dev), cmd, addr, flags, td); mdio = (struct md_ioctl *)addr; switch (cmd) { @@ -836,9 +837,9 @@ mdctlioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) case MD_PRELOAD: return (mdcreate_preload(mdio)); case MD_VNODE: - return (mdcreate_vnode(mdio, p)); + return (mdcreate_vnode(mdio, td)); case MD_SWAP: - return (mdcreate_swap(mdio, p)); + return (mdcreate_swap(mdio, td)); default: return (EINVAL); } @@ -846,7 +847,7 @@ mdctlioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) if (mdio->md_file != NULL || mdio->md_size != 0 || mdio->md_options != 0) return (EINVAL); - return (mddetach(mdio->md_unit, p)); + return (mddetach(mdio->md_unit, td)); case MDIOCQUERY: sc = mdfind(mdio->md_unit); if (sc == NULL) @@ -941,7 +942,7 @@ md_modevent(module_t mod, int type, void *data) break; case MOD_UNLOAD: LIST_FOREACH(sc, &md_softc_list, list) { - error = mddetach(sc->unit, curproc); + error = mddetach(sc->unit, curthread); if (error != 0) return (error); } diff --git a/sys/dev/mlx/mlx.c b/sys/dev/mlx/mlx.c index b6ff7ea..c5c2392 100644 --- a/sys/dev/mlx/mlx.c +++ b/sys/dev/mlx/mlx.c @@ -714,7 +714,7 @@ mlx_submit_buf(struct mlx_softc *sc, mlx_bio *bp) * Accept an open operation on the control device. */ int -mlx_open(dev_t dev, int flags, int fmt, struct proc *p) +mlx_open(dev_t dev, int flags, int fmt, struct thread *td) { int unit = minor(dev); struct mlx_softc *sc = devclass_get_softc(mlx_devclass, unit); @@ -727,7 +727,7 @@ mlx_open(dev_t dev, int flags, int fmt, struct proc *p) * Accept the last close on the control device. */ int -mlx_close(dev_t dev, int flags, int fmt, struct proc *p) +mlx_close(dev_t dev, int flags, int fmt, struct thread *td) { int unit = minor(dev); struct mlx_softc *sc = devclass_get_softc(mlx_devclass, unit); @@ -740,7 +740,7 @@ mlx_close(dev_t dev, int flags, int fmt, struct proc *p) * Handle controller-specific control operations. */ int -mlx_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct proc *p) +mlx_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *td) { int unit = minor(dev); struct mlx_softc *sc = devclass_get_softc(mlx_devclass, unit); @@ -927,7 +927,7 @@ mlx_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct proc *p) */ int mlx_submit_ioctl(struct mlx_softc *sc, struct mlx_sysdrive *drive, u_long cmd, - caddr_t addr, int32_t flag, struct proc *p) + caddr_t addr, int32_t flag, struct thread *td) { int *arg = (int *)addr; int error, result; diff --git a/sys/dev/mlx/mlx_disk.c b/sys/dev/mlx/mlx_disk.c index 40c7263..49005b1 100644 --- a/sys/dev/mlx/mlx_disk.c +++ b/sys/dev/mlx/mlx_disk.c @@ -95,7 +95,7 @@ static driver_t mlxd_driver = { DRIVER_MODULE(mlxd, mlx, mlxd_driver, mlxd_devclass, 0, 0); static int -mlxd_open(dev_t dev, int flags, int fmt, struct proc *p) +mlxd_open(dev_t dev, int flags, int fmt, struct thread *td) { struct mlxd_softc *sc = (struct mlxd_softc *)dev->si_drv1; struct disklabel *label; @@ -124,7 +124,7 @@ mlxd_open(dev_t dev, int flags, int fmt, struct proc *p) } static int -mlxd_close(dev_t dev, int flags, int fmt, struct proc *p) +mlxd_close(dev_t dev, int flags, int fmt, struct thread *td) { struct mlxd_softc *sc = (struct mlxd_softc *)dev->si_drv1; @@ -137,7 +137,7 @@ mlxd_close(dev_t dev, int flags, int fmt, struct proc *p) } static int -mlxd_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct proc *p) +mlxd_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *td) { struct mlxd_softc *sc = (struct mlxd_softc *)dev->si_drv1; int error; @@ -147,7 +147,7 @@ mlxd_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct proc *p) if (sc == NULL) return (ENXIO); - if ((error = mlx_submit_ioctl(sc->mlxd_controller, sc->mlxd_drive, cmd, addr, flag, p)) != ENOIOCTL) { + if ((error = mlx_submit_ioctl(sc->mlxd_controller, sc->mlxd_drive, cmd, addr, flag, td)) != ENOIOCTL) { debug(0, "mlx_submit_ioctl returned %d\n", error); return(error); } diff --git a/sys/dev/mlx/mlxvar.h b/sys/dev/mlx/mlxvar.h index a4de085..58c7a4b 100644 --- a/sys/dev/mlx/mlxvar.h +++ b/sys/dev/mlx/mlxvar.h @@ -240,8 +240,9 @@ struct mlxd_softc * Interface between driver core and disk driver (should be using a bus?) */ extern int mlx_submit_buf(struct mlx_softc *sc, mlx_bio *bp); -extern int mlx_submit_ioctl(struct mlx_softc *sc, struct mlx_sysdrive *drive, u_long cmd, - caddr_t addr, int32_t flag, struct proc *p); +extern int mlx_submit_ioctl(struct mlx_softc *sc, + struct mlx_sysdrive *drive, u_long cmd, + caddr_t addr, int32_t flag, struct thread *td); extern void mlxd_intr(void *data); diff --git a/sys/dev/mly/mly.c b/sys/dev/mly/mly.c index 78e41e3..9063cce 100644 --- a/sys/dev/mly/mly.c +++ b/sys/dev/mly/mly.c @@ -2790,7 +2790,7 @@ mly_print_controller(int controller) * Accept an open operation on the control device. */ static int -mly_user_open(dev_t dev, int flags, int fmt, struct proc *p) +mly_user_open(dev_t dev, int flags, int fmt, struct thread *td) { int unit = minor(dev); struct mly_softc *sc = devclass_get_softc(devclass_find("mly"), unit); @@ -2803,7 +2803,7 @@ mly_user_open(dev_t dev, int flags, int fmt, struct proc *p) * Accept the last close on the control device. */ static int -mly_user_close(dev_t dev, int flags, int fmt, struct proc *p) +mly_user_close(dev_t dev, int flags, int fmt, struct thread *td) { int unit = minor(dev); struct mly_softc *sc = devclass_get_softc(devclass_find("mly"), unit); @@ -2816,7 +2816,8 @@ mly_user_close(dev_t dev, int flags, int fmt, struct proc *p) * Handle controller-specific control operations. */ static int -mly_user_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct proc *p) +mly_user_ioctl(dev_t dev, u_long cmd, caddr_t addr, + int32_t flag, struct thread *td) { struct mly_softc *sc = (struct mly_softc *)dev->si_drv1; struct mly_user_command *uc = (struct mly_user_command *)addr; diff --git a/sys/dev/mse/mse.c b/sys/dev/mse/mse.c index 073ea7a..915bc3f 100644 --- a/sys/dev/mse/mse.c +++ b/sys/dev/mse/mse.c @@ -394,11 +394,11 @@ mse_detach(dev) * Exclusive open the mouse, initialize it and enable interrupts. */ static int -mseopen(dev, flags, fmt, p) +mseopen(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { mse_softc_t *sc; int s; @@ -434,11 +434,11 @@ mseopen(dev, flags, fmt, p) * mseclose: just turn off mouse innterrupts. */ static int -mseclose(dev, flags, fmt, p) +mseclose(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { mse_softc_t *sc = devclass_get_softc(mse_devclass, MSE_UNIT(dev)); int s; @@ -525,12 +525,12 @@ mseread(dev, uio, ioflag) * mseioctl: process ioctl commands. */ static int -mseioctl(dev, cmd, addr, flag, p) +mseioctl(dev, cmd, addr, flag, td) dev_t dev; u_long cmd; caddr_t addr; int flag; - struct proc *p; + struct thread *td; { mse_softc_t *sc = devclass_get_softc(mse_devclass, MSE_UNIT(dev)); mousestatus_t status; @@ -642,10 +642,10 @@ mseioctl(dev, cmd, addr, flag, p) * msepoll: check for mouse input to be processed. */ static int -msepoll(dev, events, p) +msepoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { mse_softc_t *sc = devclass_get_softc(mse_devclass, MSE_UNIT(dev)); int s; @@ -662,7 +662,7 @@ msepoll(dev, events, p) * Since this is an exclusive open device, any previous * proc pointer is trash now, so we can just assign it. */ - selrecord(p, &sc->sc_selp); + selrecord(td, &sc->sc_selp); } } splx(s); diff --git a/sys/dev/nmdm/nmdm.c b/sys/dev/nmdm/nmdm.c index c705e06..743a9dd 100644 --- a/sys/dev/nmdm/nmdm.c +++ b/sys/dev/nmdm/nmdm.c @@ -152,10 +152,10 @@ nmdminit(n) /*ARGSUSED*/ static int -nmdmopen(dev, flag, devtype, p) +nmdmopen(dev, flag, devtype, td) dev_t dev; int flag, devtype; - struct proc *p; + struct thread *td; { register struct tty *tp, *tp2; int error; @@ -203,9 +203,9 @@ nmdmopen(dev, flag, devtype, p) tp->t_lflag = TTYDEF_LFLAG; tp->t_cflag = TTYDEF_CFLAG; tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; - } else if (tp->t_state & TS_XCLUDE && suser(p)) { + } else if (tp->t_state & TS_XCLUDE && suser_td(td)) { return (EBUSY); - } else if (pti->pt_prison != p->p_ucred->cr_prison) { + } else if (pti->pt_prison != td->td_proc->p_ucred->cr_prison) { return (EBUSY); } @@ -255,10 +255,10 @@ nmdmopen(dev, flag, devtype, p) } static int -nmdmclose(dev, flag, mode, p) +nmdmclose(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { register struct tty *tp, *tp2; int err; @@ -485,12 +485,12 @@ nmdmstop(tp, flush) /*ARGSUSED*/ static int -nmdmioctl(dev, cmd, data, flag, p) +nmdmioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { register struct tty *tp = dev->si_tty; struct nm_softc *pti = dev->si_drv1; @@ -502,7 +502,7 @@ nmdmioctl(dev, cmd, data, flag, p) GETPARTS(tp, ourpart, otherpart); tp2 = &otherpart->nm_tty; - 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) error = ttioctl(tp, cmd, data, flag); if (error == ENOIOCTL) { diff --git a/sys/dev/ofw/ofw_console.c b/sys/dev/ofw/ofw_console.c index ff5bd3f..282a442 100644 --- a/sys/dev/ofw/ofw_console.c +++ b/sys/dev/ofw/ofw_console.c @@ -86,7 +86,7 @@ static int stdin; static int stdout; static int -ofw_dev_open(dev_t dev, int flag, int mode, struct proc *p) +ofw_dev_open(dev_t dev, int flag, int mode, struct thread *td) { struct tty *tp; int unit; @@ -114,7 +114,7 @@ ofw_dev_open(dev_t dev, int flag, int mode, struct proc *p) ttsetwater(tp); setuptimeout = 1; - } else if ((tp->t_state & TS_XCLUDE) && suser(p)) { + } else if ((tp->t_state & TS_XCLUDE) && suser_td(td)) { return (EBUSY); } @@ -133,7 +133,7 @@ ofw_dev_open(dev_t dev, int flag, int mode, struct proc *p) } static int -ofw_dev_close(dev_t dev, int flag, int mode, struct proc *p) +ofw_dev_close(dev_t dev, int flag, int mode, struct thread *td) { int unit; struct tty *tp; @@ -152,7 +152,7 @@ ofw_dev_close(dev_t dev, int flag, int mode, struct proc *p) } static int -ofw_dev_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +ofw_dev_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int unit; struct tty *tp; @@ -165,7 +165,7 @@ ofw_dev_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) 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); } diff --git a/sys/dev/pci/pci_user.c b/sys/dev/pci/pci_user.c index d8debc3..6968241 100644 --- a/sys/dev/pci/pci_user.c +++ b/sys/dev/pci/pci_user.c @@ -60,11 +60,11 @@ * This is the user interface to PCI configuration space. */ -static int pci_open(dev_t dev, int oflags, int devtype, struct proc *p); -static int pci_close(dev_t dev, int flag, int devtype, struct proc *p); +static d_open_t pci_open; +static d_close_t pci_close; static int pci_conf_match(struct pci_match_conf *matches, int num_matches, struct pci_conf *match_buf); -static int pci_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p); +static d_ioctl_t pci_ioctl; #define PCI_CDEV 78 @@ -85,7 +85,7 @@ struct cdevsw pcicdev = { }; static int -pci_open(dev_t dev, int oflags, int devtype, struct proc *p) +pci_open(dev_t dev, int oflags, int devtype, struct thread *td) { if ((oflags & FWRITE) && securelevel > 0) { return EPERM; @@ -94,7 +94,7 @@ pci_open(dev_t dev, int oflags, int devtype, struct proc *p) } static int -pci_close(dev_t dev, int flag, int devtype, struct proc *p) +pci_close(dev_t dev, int flag, int devtype, struct thread *td) { return 0; } @@ -167,7 +167,7 @@ pci_conf_match(struct pci_match_conf *matches, int num_matches, } static int -pci_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +pci_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { device_t pci, pcib; struct pci_io *io; diff --git a/sys/dev/ppbus/lpt.c b/sys/dev/ppbus/lpt.c index 20fc816..ef0fe1e 100644 --- a/sys/dev/ppbus/lpt.c +++ b/sys/dev/ppbus/lpt.c @@ -455,7 +455,7 @@ lptout(void *arg) */ static int -lptopen(dev_t dev, int flags, int fmt, struct proc *p) +lptopen(dev_t dev, int flags, int fmt, struct thread *td) { int s; int trys, err; @@ -575,7 +575,7 @@ lptopen(dev_t dev, int flags, int fmt, struct proc *p) */ static int -lptclose(dev_t dev, int flags, int fmt, struct proc *p) +lptclose(dev_t dev, int flags, int fmt, struct thread *td) { u_int unit = LPTUNIT(minor(dev)); struct lpt_data *sc = UNITOSOFTC(unit); @@ -897,7 +897,7 @@ lptintr(device_t dev) } static int -lptioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +lptioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td) { int error = 0; u_int unit = LPTUNIT(minor(dev)); diff --git a/sys/dev/ppbus/pcfclock.c b/sys/dev/ppbus/pcfclock.c index c0e6275..d7af2ae 100644 --- a/sys/dev/ppbus/pcfclock.c +++ b/sys/dev/ppbus/pcfclock.c @@ -153,7 +153,7 @@ pcfclock_attach(device_t dev) } static int -pcfclock_open(dev_t dev, int flag, int fms, struct proc *p) +pcfclock_open(dev_t dev, int flag, int fms, struct thread *td) { u_int unit = minor(dev); struct pcfclock_data *sc = UNITOSOFTC(unit); @@ -174,7 +174,7 @@ pcfclock_open(dev_t dev, int flag, int fms, struct proc *p) } static int -pcfclock_close(dev_t dev, int flags, int fmt, struct proc *p) +pcfclock_close(dev_t dev, int flags, int fmt, struct thread *td) { u_int unit = minor(dev); struct pcfclock_data *sc = UNITOSOFTC(unit); diff --git a/sys/dev/ppbus/ppi.c b/sys/dev/ppbus/ppi.c index 5e851f0..d4e4968 100644 --- a/sys/dev/ppbus/ppi.c +++ b/sys/dev/ppbus/ppi.c @@ -255,7 +255,7 @@ ppiintr(void *arg) #endif /* PERIPH_1284 */ static int -ppiopen(dev_t dev, int flags, int fmt, struct proc *p) +ppiopen(dev_t dev, int flags, int fmt, struct thread *td) { u_int unit = minor(dev); struct ppi_data *ppi = UNITOSOFTC(unit); @@ -288,7 +288,7 @@ ppiopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -ppiclose(dev_t dev, int flags, int fmt, struct proc *p) +ppiclose(dev_t dev, int flags, int fmt, struct thread *td) { u_int unit = minor(dev); struct ppi_data *ppi = UNITOSOFTC(unit); @@ -501,7 +501,7 @@ error: } static int -ppiioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +ppiioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td) { u_int unit = minor(dev); device_t ppidev = UNITODEVICE(unit); diff --git a/sys/dev/ppbus/pps.c b/sys/dev/ppbus/pps.c index c79d965..3b69097 100644 --- a/sys/dev/ppbus/pps.c +++ b/sys/dev/ppbus/pps.c @@ -125,7 +125,7 @@ ppsattach(device_t dev) } static int -ppsopen(dev_t dev, int flags, int fmt, struct proc *p) +ppsopen(dev_t dev, int flags, int fmt, struct thread *td) { u_int unit = minor(dev); struct pps_data *sc = UNITOSOFTC(unit); @@ -154,7 +154,7 @@ ppsopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -ppsclose(dev_t dev, int flags, int fmt, struct proc *p) +ppsclose(dev_t dev, int flags, int fmt, struct thread *td) { u_int unit = minor(dev); struct pps_data *sc = UNITOSOFTC(unit); @@ -193,7 +193,7 @@ ppsintr(void *arg) } static int -ppsioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +ppsioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td) { u_int unit = minor(dev); struct pps_data *sc = UNITOSOFTC(unit); diff --git a/sys/dev/random/randomdev.c b/sys/dev/random/randomdev.c index a99fe6d..868d72f 100644 --- a/sys/dev/random/randomdev.c +++ b/sys/dev/random/randomdev.c @@ -39,6 +39,7 @@ #include <sys/module.h> #include <sys/mutex.h> #include <sys/poll.h> +#include <sys/proc.h> #include <sys/queue.h> #include <sys/random.h> #include <sys/selinfo.h> @@ -138,18 +139,18 @@ SYSCTL_PROC(_kern_random_sys_harvest, OID_AUTO, interrupt, random_check_boolean, "I", "Harvest IRQ entropy"); static int -random_open(dev_t dev, int flags, int fmt, struct proc *p) +random_open(dev_t dev, int flags, int fmt, struct thread *td) { - if ((flags & FWRITE) && (securelevel > 0 || suser(p))) + if ((flags & FWRITE) && (securelevel > 0 || suser(td->td_proc))) return EPERM; else return 0; } static int -random_close(dev_t dev, int flags, int fmt, struct proc *p) +random_close(dev_t dev, int flags, int fmt, struct thread *td) { - if ((flags & FWRITE) && !(securelevel > 0 || suser(p))) + if ((flags & FWRITE) && !(securelevel > 0 || suser(td->td_proc))) random_reseed(); return 0; } @@ -201,7 +202,7 @@ random_write(dev_t dev, struct uio *uio, int flag) } static int -random_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) +random_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) { switch (cmd) { /* Really handled in upper layer */ @@ -214,7 +215,7 @@ random_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) } static int -random_poll(dev_t dev, int events, struct proc *p) +random_poll(dev_t dev, int events, struct thread *td) { int revents; @@ -223,7 +224,7 @@ random_poll(dev_t dev, int events, struct proc *p) if (random_systat.seeded) revents = events & (POLLIN | POLLRDNORM); else - selrecord(p, &random_systat.rsel); + selrecord(curthread, &random_systat.rsel); } return revents; } diff --git a/sys/dev/rc/rc.c b/sys/dev/rc/rc.c index e4252e0..59e8dff 100644 --- a/sys/dev/rc/rc.c +++ b/sys/dev/rc/rc.c @@ -715,10 +715,10 @@ rc_stop(tp, rw) } static int -rcopen(dev, flag, mode, p) +rcopen(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { register struct rc_chans *rc; register struct tty *tp; @@ -764,7 +764,7 @@ again: } } if (tp->t_state & TS_XCLUDE && - suser(p)) { + suser_td(td)) { error = EBUSY; goto out; } @@ -810,10 +810,10 @@ out: } static int -rcclose(dev, flag, mode, p) +rcclose(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { register struct rc_chans *rc; register struct tty *tp; @@ -1064,18 +1064,18 @@ struct rc_softc *rcb; } static int -rcioctl(dev, cmd, data, flag, p) +rcioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; int flag; caddr_t data; -struct proc *p; +struct thread *td; { register struct rc_chans *rc = &rc_chans[GET_UNIT(dev)]; register int s, error; struct tty *tp = rc->rc_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); error = ttioctl(tp, cmd, data, flag); @@ -1118,7 +1118,7 @@ struct proc *p; break; case TIOCMSDTRWAIT: - error = suser(p); + error = suser_td(td); if (error != 0) { splx(s); return (error); diff --git a/sys/dev/rp/rp.c b/sys/dev/rp/rp.c index f9391f3..9c49f20 100644 --- a/sys/dev/rp/rp.c +++ b/sys/dev/rp/rp.c @@ -954,10 +954,10 @@ rp_releaseresource(CONTROLLER_t *ctlp) } int -rpopen(dev, flag, mode, p) +rpopen(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { struct rp_port *rp; int unit, port, mynor, umynor, flags; /* SG */ @@ -1008,7 +1008,7 @@ open_top: goto open_top; } } - if(tp->t_state & TS_XCLUDE && suser(p) != 0) { + if(tp->t_state & TS_XCLUDE && suser_td(td) != 0) { splx(oldspl); error = EBUSY; goto out2; @@ -1113,10 +1113,10 @@ out2: } int -rpclose(dev, flag, mode, p) +rpclose(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { int oldspl, unit, mynor, umynor, port; /* SG */ struct rp_port *rp; @@ -1228,12 +1228,12 @@ rpdtrwakeup(void *chan) } int -rpioctl(dev, cmd, data, flag, p) +rpioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct rp_port *rp; CHANNEL_t *cp; @@ -1265,7 +1265,7 @@ rpioctl(dev, cmd, data, flag, p) } switch (cmd) { case TIOCSETA: - error = suser(p); + error = suser_td(td); if(error != 0) return(error); *ct = *(struct termios *)data; @@ -1322,7 +1322,7 @@ rpioctl(dev, cmd, data, flag, p) t = &tp->t_termios; - 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); } @@ -1410,7 +1410,7 @@ rpioctl(dev, cmd, data, flag, p) *(int *)data = result; break; case TIOCMSDTRWAIT: - error = suser(p); + error = suser_td(td); if(error != 0) { splx(oldspl); return(error); diff --git a/sys/dev/scd/scd.c b/sys/dev/scd/scd.c index 1ab5afa..4561d90 100644 --- a/sys/dev/scd/scd.c +++ b/sys/dev/scd/scd.c @@ -232,7 +232,7 @@ scd_attach(struct isa_device *dev) } static int -scdopen(dev_t dev, int flags, int fmt, struct proc *p) +scdopen(dev_t dev, int flags, int fmt, struct thread *td) { int unit,part,phys; int rc; @@ -286,7 +286,7 @@ scdopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -scdclose(dev_t dev, int flags, int fmt, struct proc *p) +scdclose(dev_t dev, int flags, int fmt, struct thread *td) { int unit,part,phys; struct scd_data *cd; @@ -418,7 +418,7 @@ scd_start(int unit) } static int -scdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) +scdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) { struct scd_data *cd; int unit,part; diff --git a/sys/dev/si/si.c b/sys/dev/si/si.c index 0f42692..dc1858f 100644 --- a/sys/dev/si/si.c +++ b/sys/dev/si/si.c @@ -93,7 +93,7 @@ enum si_mctl { GET, SET, BIS, BIC }; static void si_command(struct si_port *, int, int); static int si_modem(struct si_port *, enum si_mctl, int); static void si_write_enable(struct si_port *, int); -static int si_Sioctl(dev_t, u_long, caddr_t, int, struct proc *); +static int si_Sioctl(dev_t, u_long, caddr_t, int, struct thread *); static void si_start(struct tty *); static void si_stop(struct tty *, int); static timeout_t si_lstart; @@ -595,7 +595,7 @@ try_next2: } static int -siopen(dev_t dev, int flag, int mode, struct proc *p) +siopen(dev_t dev, int flag, int mode, struct thread *td) { int oldspl, error; int card, port; @@ -607,7 +607,7 @@ siopen(dev_t dev, int flag, int mode, struct proc *p) /* quickly let in /dev/si_control */ if (IS_CONTROLDEV(mynor)) { - if ((error = suser(p))) + if ((error = suser_td(td))) return(error); return(0); } @@ -650,7 +650,7 @@ siopen(dev_t dev, int flag, int mode, struct proc *p) dev->si_tty = tp; ccbp = pp->sp_ccb; /* Find control block */ DPRINT((pp, DBG_ENTRY|DBG_OPEN, "siopen(%s,%x,%x,%x)\n", - devtoname(dev), flag, mode, p)); + devtoname(dev), flag, mode, td)); oldspl = spltty(); /* Keep others out */ error = 0; @@ -686,7 +686,7 @@ open_top: } } if (tp->t_state & TS_XCLUDE && - suser(p)) { + suser_td(td)) { DPRINT((pp, DBG_OPEN|DBG_FAIL, "already open and EXCLUSIVE set\n")); error = EBUSY; @@ -764,7 +764,7 @@ out: } static int -siclose(dev_t dev, int flag, int mode, struct proc *p) +siclose(dev_t dev, int flag, int mode, struct thread *td) { struct si_port *pp; struct tty *tp; @@ -781,7 +781,7 @@ siclose(dev_t dev, int flag, int mode, struct proc *p) tp = pp->sp_tty; DPRINT((pp, DBG_ENTRY|DBG_CLOSE, "siclose(%s,%x,%x,%x) sp_state:%x\n", - devtoname(dev), flag, mode, p, pp->sp_state)); + devtoname(dev), flag, mode, td, pp->sp_state)); /* did we sleep and loose a race? */ if (pp->sp_state & SS_CLOSING) { @@ -915,7 +915,7 @@ out: static int -siioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +siioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { struct si_port *pp; struct tty *tp; @@ -929,7 +929,7 @@ siioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) #endif if (IS_SI_IOCTL(cmd)) - return(si_Sioctl(dev, cmd, data, flag, p)); + return(si_Sioctl(dev, cmd, data, flag, td)); pp = MINOR2PP(mynor); tp = pp->sp_tty; @@ -951,7 +951,7 @@ siioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) } switch (cmd) { case TIOCSETA: - error = suser(p); + error = suser_td(td); if (error != 0) return (error); *ct = *(struct termios *)data; @@ -1023,7 +1023,7 @@ siioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) si_write_enable(pp, 0); } - 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) goto out; @@ -1064,7 +1064,7 @@ siioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) break; case TIOCMSDTRWAIT: /* must be root since the wait applies to following logins */ - error = suser(p); + error = suser_td(td); if (error == 0) pp->sp_dtr_wait = *(int *)data * hz / 100; break; @@ -1087,7 +1087,7 @@ out: * Handle the Specialix ioctls. All MUST be called via the CONTROL device */ static int -si_Sioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +si_Sioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { struct si_softc *xsc; struct si_port *xpp; @@ -1117,7 +1117,7 @@ si_Sioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) ip = (int *)data; -#define SUCHECK if ((error = suser(p))) goto out +#define SUCHECK if ((error = suser_td(td))) goto out switch (cmd) { case TCSIPORTS: diff --git a/sys/dev/sio/sio.c b/sys/dev/sio/sio.c index 3c68d7c..05d8f35 100644 --- a/sys/dev/sio/sio.c +++ b/sys/dev/sio/sio.c @@ -1378,11 +1378,11 @@ determined_type: ; } static int -sioopen(dev, flag, mode, p) +sioopen(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct com_s *com; int error; @@ -1440,7 +1440,7 @@ open_top: } } if (tp->t_state & TS_XCLUDE && - suser(p)) { + suser_td(td)) { error = EBUSY; goto out; } @@ -1560,11 +1560,11 @@ out: } static int -sioclose(dev, flag, mode, p) +sioclose(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct com_s *com; int mynor; @@ -2114,12 +2114,12 @@ cont: } static int -sioioctl(dev, cmd, data, flag, p) +sioioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct com_s *com; int error; @@ -2150,7 +2150,7 @@ sioioctl(dev, cmd, data, flag, p) } switch (cmd) { case TIOCSETA: - error = suser(p); + error = suser_td(td); if (error != 0) return (error); *ct = *(struct termios *)data; @@ -2200,7 +2200,7 @@ sioioctl(dev, cmd, data, flag, p) if (lt->c_ospeed != 0) dt->c_ospeed = tp->t_ospeed; } - 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); s = spltty(); @@ -2241,7 +2241,7 @@ sioioctl(dev, cmd, data, flag, p) break; case TIOCMSDTRWAIT: /* must be root since the wait applies to following logins */ - error = suser(p); + error = suser_td(td); if (error != 0) { splx(s); return (error); diff --git a/sys/dev/smbus/smb.c b/sys/dev/smbus/smb.c index 7eac3cc..beb3c4a 100644 --- a/sys/dev/smbus/smb.c +++ b/sys/dev/smbus/smb.c @@ -134,7 +134,7 @@ smb_attach(device_t dev) } static int -smbopen (dev_t dev, int flags, int fmt, struct proc *p) +smbopen (dev_t dev, int flags, int fmt, struct thread *td) { struct smb_softc *sc = IIC_SOFTC(minor(dev)); @@ -150,7 +150,7 @@ smbopen (dev_t dev, int flags, int fmt, struct proc *p) } static int -smbclose(dev_t dev, int flags, int fmt, struct proc *p) +smbclose(dev_t dev, int flags, int fmt, struct thread *td) { struct smb_softc *sc = IIC_SOFTC(minor(dev)); @@ -182,7 +182,7 @@ smbread(dev_t dev, struct uio * uio, int ioflag) } static int -smbioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +smbioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td) { device_t smbdev = IIC_DEVICE(minor(dev)); struct smb_softc *sc = IIC_SOFTC(minor(dev)); diff --git a/sys/dev/snp/snp.c b/sys/dev/snp/snp.c index 08eae23..93c1947 100644 --- a/sys/dev/snp/snp.c +++ b/sys/dev/snp/snp.c @@ -162,7 +162,7 @@ snplwrite(tp, uio, flag) uio2.uio_resid = ilen; uio2.uio_segflg = UIO_SYSSPACE; uio2.uio_rw = UIO_WRITE; - uio2.uio_procp = uio->uio_procp; + uio2.uio_td = uio->uio_td; error = ttwrite(tp, &uio2, flag); if (error != 0) break; @@ -375,15 +375,15 @@ snp_in(snp, buf, n) } static int -snpopen(dev, flag, mode, p) +snpopen(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { struct snoop *snp; int error; - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) return (error); if (dev->si_drv1 == NULL) { @@ -455,11 +455,11 @@ detach_notty: } static int -snpclose(dev, flags, fmt, p) +snpclose(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { struct snoop *snp; @@ -490,12 +490,12 @@ snp_down(snp) } static int -snpioctl(dev, cmd, data, flags, p) +snpioctl(dev, cmd, data, flags, td) dev_t dev; u_long cmd; caddr_t data; int flags; - struct proc *p; + struct thread *td; { struct snoop *snp; struct tty *tp, *tpo; @@ -579,10 +579,10 @@ snpioctl(dev, cmd, data, flags, p) } static int -snppoll(dev, events, p) +snppoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { struct snoop *snp; int revents; @@ -598,7 +598,7 @@ snppoll(dev, events, p) if (snp->snp_flags & SNOOP_DOWN || snp->snp_len > 0) revents |= events & (POLLIN | POLLRDNORM); else - selrecord(p, &snp->snp_sel); + selrecord(td, &snp->snp_sel); } return (revents); } diff --git a/sys/dev/sound/isa/emu8000.c b/sys/dev/sound/isa/emu8000.c index 7067a8f..ea434e6 100644 --- a/sys/dev/sound/isa/emu8000.c +++ b/sys/dev/sound/isa/emu8000.c @@ -743,19 +743,19 @@ emupnp_attach(device_t dev) } static int -emu_open(dev_t i_dev, int flags, int mode, struct proc *p) +emu_open(dev_t i_dev, int flags, int mode, struct thread *td) { return (0); } static int -emu_close(dev_t i_dev, int flags, int mode, struct proc *p) +emu_close(dev_t i_dev, int flags, int mode, struct thread *td) { return (0); } static int -emu_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) +emu_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td) { sc_p scp; mididev_info *devinfo; diff --git a/sys/dev/sound/isa/gusmidi.c b/sys/dev/sound/isa/gusmidi.c index 88193bf..797d168 100644 --- a/sys/dev/sound/isa/gusmidi.c +++ b/sys/dev/sound/isa/gusmidi.c @@ -214,7 +214,7 @@ gusmidi_init(device_t dev) } static int -gusmidi_open(dev_t i_dev, int flags, int mode, struct proc *p) +gusmidi_open(dev_t i_dev, int flags, int mode, struct thread *td) { sc_p scp; mididev_info *devinfo; @@ -242,7 +242,7 @@ gusmidi_open(dev_t i_dev, int flags, int mode, struct proc *p) } static int -gusmidi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) +gusmidi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td) { sc_p scp; mididev_info *devinfo; diff --git a/sys/dev/sound/isa/mpu.c b/sys/dev/sound/isa/mpu.c index a8cf490..14d1653 100644 --- a/sys/dev/sound/isa/mpu.c +++ b/sys/dev/sound/isa/mpu.c @@ -408,7 +408,7 @@ mpusbc_attach(device_t dev) } static int -mpu_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) +mpu_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td) { sc_p scp; mididev_info *devinfo; diff --git a/sys/dev/sound/isa/opl.c b/sys/dev/sound/isa/opl.c index a4a0e66..5ebf974 100644 --- a/sys/dev/sound/isa/opl.c +++ b/sys/dev/sound/isa/opl.c @@ -764,7 +764,7 @@ oplsbc_attach(device_t dev) } static int -opl_open(dev_t i_dev, int flags, int mode, struct proc *p) +opl_open(dev_t i_dev, int flags, int mode, struct thread *td) { sc_p scp; mididev_info *devinfo; @@ -805,7 +805,7 @@ opl_open(dev_t i_dev, int flags, int mode, struct proc *p) } static int -opl_close(dev_t i_dev, int flags, int mode, struct proc *p) +opl_close(dev_t i_dev, int flags, int mode, struct thread *td) { sc_p scp; mididev_info *devinfo; @@ -838,7 +838,7 @@ opl_close(dev_t i_dev, int flags, int mode, struct proc *p) } static int -opl_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) +opl_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td) { sc_p scp; mididev_info *devinfo; diff --git a/sys/dev/sound/isa/sb16.c b/sys/dev/sound/isa/sb16.c index cfc2363..53c4242 100644 --- a/sys/dev/sound/isa/sb16.c +++ b/sys/dev/sound/isa/sb16.c @@ -150,7 +150,7 @@ sb_dspwr(struct sb_info *sb, u_char val) } } #if __FreeBSD_version > 500000 - if (curproc->p_intr_nesting_level == 0) + if (curthread->td_intr_nesting_level == 0) printf("sb_dspwr(0x%02x) timed out.\n", val); #endif return 0; diff --git a/sys/dev/sound/isa/uartsio.c b/sys/dev/sound/isa/uartsio.c index 297e986..3577ce5 100644 --- a/sys/dev/sound/isa/uartsio.c +++ b/sys/dev/sound/isa/uartsio.c @@ -261,7 +261,7 @@ uartsio_attach(device_t dev) } static int -uartsio_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) +uartsio_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td) { sc_p scp; mididev_info *devinfo; diff --git a/sys/dev/sound/midi/midi.c b/sys/dev/sound/midi/midi.c index ad62804..e577398 100644 --- a/sys/dev/sound/midi/midi.c +++ b/sys/dev/sound/midi/midi.c @@ -268,16 +268,16 @@ mididev_info_number(void) */ static int -midiopen(dev_t i_dev, int flags, int mode, struct proc * p) +midiopen(dev_t i_dev, int flags, int mode, struct thread *td) { int ret; switch (MIDIDEV(i_dev)) { case MIDI_DEV_MIDIN: - ret = midi_open(i_dev, flags, mode, p); + ret = midi_open(i_dev, flags, mode, td); break; case MIDI_DEV_STATUS: - ret = midistat_open(i_dev, flags, mode, p); + ret = midistat_open(i_dev, flags, mode, td); break; default: ret = ENXIO; @@ -288,16 +288,16 @@ midiopen(dev_t i_dev, int flags, int mode, struct proc * p) } static int -midiclose(dev_t i_dev, int flags, int mode, struct proc * p) +midiclose(dev_t i_dev, int flags, int mode, struct thread *td) { int ret; switch (MIDIDEV(i_dev)) { case MIDI_DEV_MIDIN: - ret = midi_close(i_dev, flags, mode, p); + ret = midi_close(i_dev, flags, mode, td); break; case MIDI_DEV_STATUS: - ret = midistat_close(i_dev, flags, mode, p); + ret = midistat_close(i_dev, flags, mode, td); break; default: ret = ENXIO; @@ -345,13 +345,13 @@ midiwrite(dev_t i_dev, struct uio * buf, int flag) } static int -midiioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p) +midiioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td) { int ret; switch (MIDIDEV(i_dev)) { case MIDI_DEV_MIDIN: - ret = midi_ioctl(i_dev, cmd, arg, mode, p); + ret = midi_ioctl(i_dev, cmd, arg, mode, td); break; default: ret = ENXIO; @@ -362,13 +362,13 @@ midiioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p) } static int -midipoll(dev_t i_dev, int events, struct proc * p) +midipoll(dev_t i_dev, int events, struct thread *td) { int ret; switch (MIDIDEV(i_dev)) { case MIDI_DEV_MIDIN: - ret = midi_poll(i_dev, events, p); + ret = midi_poll(i_dev, events, td); break; default: ret = ENXIO; @@ -383,7 +383,7 @@ midipoll(dev_t i_dev, int events, struct proc * p) */ int -midi_open(dev_t i_dev, int flags, int mode, struct proc * p) +midi_open(dev_t i_dev, int flags, int mode, struct thread *td) { int dev, unit, ret; mididev_info *d; @@ -422,13 +422,13 @@ midi_open(dev_t i_dev, int flags, int mode, struct proc * p) if (d->open == NULL) ret = 0; else - ret = d->open(i_dev, flags, mode, p); + ret = d->open(i_dev, flags, mode, td); return (ret); } int -midi_close(dev_t i_dev, int flags, int mode, struct proc * p) +midi_close(dev_t i_dev, int flags, int mode, struct thread *td) { int dev, unit, ret; mididev_info *d; @@ -468,7 +468,7 @@ midi_close(dev_t i_dev, int flags, int mode, struct proc * p) if (d->close == NULL) ret = 0; else - ret = d->close(i_dev, flags, mode, p); + ret = d->close(i_dev, flags, mode, td); return (ret); } @@ -570,7 +570,7 @@ midi_write(dev_t i_dev, struct uio * buf, int flag) */ int -midi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p) +midi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td) { int ret = ENOSYS, dev, unit; mididev_info *d; @@ -583,7 +583,7 @@ midi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p) return (ENXIO); if (d->ioctl) - ret = d->ioctl(i_dev, cmd, arg, mode, p); + ret = d->ioctl(i_dev, cmd, arg, mode, td); if (ret != ENOSYS) return ret; @@ -715,7 +715,7 @@ midi_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p) } int -midi_poll(dev_t i_dev, int events, struct proc * p) +midi_poll(dev_t i_dev, int events, struct thread *td) { int unit, dev, ret, lim; mididev_info *d; @@ -742,7 +742,7 @@ midi_poll(dev_t i_dev, int events, struct proc * p) lim = d->midi_dbuf_out.unit_size; if (d->midi_dbuf_out.fl < lim) /* No enough space, record select. */ - selrecord(p, &d->midi_dbuf_out.sel); + selrecord(td, &d->midi_dbuf_out.sel); else /* We can write now. */ ret |= events & (POLLOUT | POLLWRNORM); @@ -758,7 +758,7 @@ midi_poll(dev_t i_dev, int events, struct proc * p) lim = d->midi_dbuf_in.unit_size; if (d->midi_dbuf_in.rl < lim) /* No data ready, record select. */ - selrecord(p, &d->midi_dbuf_in.sel); + selrecord(td, &d->midi_dbuf_in.sel); else /* We can write now. */ ret |= events & (POLLIN | POLLRDNORM); @@ -811,7 +811,7 @@ midi_sync(mididev_info *d) */ int -midistat_open(dev_t i_dev, int flags, int mode, struct proc * p) +midistat_open(dev_t i_dev, int flags, int mode, struct thread *td) { if (midistatbusy) return (EBUSY); @@ -827,7 +827,7 @@ midistat_open(dev_t i_dev, int flags, int mode, struct proc * p) } int -midistat_close(dev_t i_dev, int flags, int mode, struct proc * p) +midistat_close(dev_t i_dev, int flags, int mode, struct thread *td) { midistatbusy = 0; diff --git a/sys/dev/sound/midi/sequencer.c b/sys/dev/sound/midi/sequencer.c index d8beba2..ab35f81 100644 --- a/sys/dev/sound/midi/sequencer.c +++ b/sys/dev/sound/midi/sequencer.c @@ -131,7 +131,7 @@ struct seq_softc { */ int output_threshould; /* Sequence output threshould */ snd_sync_parm sync_parm; /* AIOSYNC parameter set */ - struct proc *sync_proc; /* AIOSYNCing process */ + struct thread *sync_thread; /* AIOSYNCing thread */ }; typedef struct seq_softc *sc_p; @@ -187,8 +187,8 @@ static int seq_local(sc_p scp, u_char *event); static int seq_sysex(sc_p scp, u_char *event); static void seq_timer(void *arg); static int seq_reset(sc_p scp); -static int seq_openmidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p); -static int seq_closemidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p); +static int seq_openmidi(sc_p scp, mididev_info *md, int flags, int mode, struct thread *p); +static int seq_closemidi(sc_p scp, mididev_info *md, int flags, int mode, struct thread *p); static void seq_panic(sc_p scp); static int seq_sync(sc_p scp); @@ -268,7 +268,7 @@ seq_initunit(int unit) } int -seq_open(dev_t i_dev, int flags, int mode, struct proc *p) +seq_open(dev_t i_dev, int flags, int mode, struct thread *td) { int unit; sc_p scp; @@ -319,7 +319,7 @@ seq_open(dev_t i_dev, int flags, int mode, struct proc *p) } int -seq_close(dev_t i_dev, int flags, int mode, struct proc *p) +seq_close(dev_t i_dev, int flags, int mode, struct thread *td) { int unit; sc_p scp; @@ -551,7 +551,7 @@ seq_write(dev_t i_dev, struct uio *buf, int flag) } int -seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) +seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td) { int unit, midiunit, ret, tmp, arg2; sc_p scp; @@ -644,7 +644,7 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) { if ((md->flags & MIDI_F_WRITING) != 0) { arg2 = *(int *)arg; - midi_ioctl(MIDIMKDEV(major(i_dev), md->unit, SND_DEV_MIDIN), cmd, (caddr_t)&arg2, mode, p); + midi_ioctl(MIDIMKDEV(major(i_dev), md->unit, SND_DEV_MIDIN), cmd, (caddr_t)&arg2, mode, td); } } @@ -661,7 +661,7 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) TAILQ_FOREACH(md, &scp->midi_open, md_linkseq) { if ((md->flags & MIDI_F_WRITING) != 0) { arg2 = *(int *)arg; - midi_ioctl(MIDIMKDEV(major(i_dev), md->unit, SND_DEV_MIDIN), cmd, (caddr_t)&arg2, mode, p); + midi_ioctl(MIDIMKDEV(major(i_dev), md->unit, SND_DEV_MIDIN), cmd, (caddr_t)&arg2, mode, td); } } @@ -773,7 +773,7 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) mtx_unlock(&sd->flagqueue_mtx); if (ret != 0) break; - ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); + ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, td); break; case SNDCTL_SEQ_NRSYNTHS: *(int *)arg = mididev_info_number(); @@ -790,7 +790,7 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) mtx_unlock(&sd->flagqueue_mtx); if (ret != 0) break; - ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); + ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, td); break; case SNDCTL_FM_4OP_ENABLE: midiunit = *(int *)arg; @@ -799,7 +799,7 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) mtx_unlock(&sd->flagqueue_mtx); if (ret != 0) break; - ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); + ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, td); break; case SNDCTL_SYNTH_INFO: synthinfo = (struct synth_info *)arg; @@ -809,7 +809,7 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) mtx_unlock(&sd->flagqueue_mtx); if (ret != 0) break; - ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); + ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, td); break; case SNDCTL_SEQ_OUTOFBAND: event = (struct seq_event_rec *)arg; @@ -825,7 +825,7 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) mtx_unlock(&sd->flagqueue_mtx); if (ret != 0) break; - ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); + ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, td); break; case SNDCTL_PMGR_IFACE: patinfo = (struct patmgr_info *)arg; @@ -835,7 +835,7 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) mtx_unlock(&sd->flagqueue_mtx); if (ret != 0) break; - ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); + ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, td); break; case SNDCTL_PMGR_ACCESS: patinfo = (struct patmgr_info *)arg; @@ -845,7 +845,7 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) mtx_unlock(&sd->flagqueue_mtx); if (ret != 0) break; - ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, p); + ret = midi_ioctl(MIDIMKDEV(major(i_dev), midiunit, SND_DEV_MIDIN), cmd, arg, mode, td); break; case SNDCTL_SEQ_THRESHOLD: tmp = *(int *)arg; @@ -871,7 +871,7 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) mtx_unlock(&sd->flagqueue_mtx); if (ret != 0) break; - ret = midi_ioctl(MIDIMKDEV(major(i_dev), 0, SND_DEV_MIDIN), cmd, arg, mode, p); + ret = midi_ioctl(MIDIMKDEV(major(i_dev), 0, SND_DEV_MIDIN), cmd, arg, mode, td); break; } @@ -879,7 +879,7 @@ seq_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) } int -seq_poll(dev_t i_dev, int events, struct proc *p) +seq_poll(dev_t i_dev, int events, struct thread *td) { int unit, ret, lim; sc_p scp; @@ -916,7 +916,7 @@ seq_poll(dev_t i_dev, int events, struct proc *p) lim = sd->midi_dbuf_out.unit_size; if (sd->midi_dbuf_out.fl < lim) /* No enough space, record select. */ - selrecord(p, &sd->midi_dbuf_out.sel); + selrecord(td, &sd->midi_dbuf_out.sel); else /* We can write now. */ ret |= events & (POLLOUT | POLLWRNORM); @@ -932,7 +932,7 @@ seq_poll(dev_t i_dev, int events, struct proc *p) lim = sd->midi_dbuf_in.unit_size; if (sd->midi_dbuf_in.rl < lim) /* No data ready, record select. */ - selrecord(p, &sd->midi_dbuf_in.sel); + selrecord(td, &sd->midi_dbuf_in.sel); else /* We can write now. */ ret |= events & (POLLIN | POLLRDNORM); @@ -1849,7 +1849,7 @@ seq_timer(void *arg) } static int -seq_openmidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p) +seq_openmidi(sc_p scp, mididev_info *md, int flags, int mode, struct thread *td) { int midiunit, err, insync; @@ -1859,7 +1859,7 @@ seq_openmidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p) DEB(printf("seq_openmidi: opening midi unit %d.\n", midiunit)); - err = midi_open(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, p); + err = midi_open(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, td); if (err != 0) { printf("seq_openmidi: failed to open midi device %d.\n", midiunit); return (err); @@ -1887,7 +1887,7 @@ seq_openmidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p) } static int -seq_closemidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p) +seq_closemidi(sc_p scp, mididev_info *md, int flags, int mode, struct thread *td) { int midiunit, insync; @@ -1901,7 +1901,7 @@ seq_closemidi(sc_p scp, mididev_info *md, int flags, int mode, struct proc *p) DEB(printf("seq_closemidi: closing midi unit %d.\n", midiunit)); - midi_close(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, p); + midi_close(MIDIMKDEV(MIDI_CDEV_MAJOR, midiunit, SND_DEV_MIDIN), flags, mode, td); mtx_lock(&md->flagqueue_mtx); md->intr = NULL; md->intrarg = NULL; @@ -2152,7 +2152,7 @@ lookup_mididev(sc_p scp, int unit, int mode, mididev_info **mdp) if (md->unit == unit) { *mdp = md; if (mode == LOOKUP_CLOSE) - return seq_closemidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc); + return seq_closemidi(scp, md, scp->fflags, MIDIDEV_MODE, curthread); return (md != NULL && MIDICONFED(md)) ? 0 : ENXIO; } @@ -2162,7 +2162,7 @@ lookup_mididev(sc_p scp, int unit, int mode, mididev_info **mdp) md = get_mididev_info_unit(unit); if (md != NULL) { *mdp = md; - ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curproc); + ret = seq_openmidi(scp, md, scp->fflags, MIDIDEV_MODE, curthread); return ret; } } @@ -2172,22 +2172,22 @@ lookup_mididev(sc_p scp, int unit, int mode, mididev_info **mdp) /* XXX These functions are actually redundant. */ static int -seqopen(dev_t i_dev, int flags, int mode, struct proc * p) +seqopen(dev_t i_dev, int flags, int mode, struct thread *td) { switch (MIDIDEV(i_dev)) { case MIDI_DEV_SEQ: - return seq_open(i_dev, flags, mode, p); + return seq_open(i_dev, flags, mode, td); } return (ENXIO); } static int -seqclose(dev_t i_dev, int flags, int mode, struct proc * p) +seqclose(dev_t i_dev, int flags, int mode, struct thread *td) { switch (MIDIDEV(i_dev)) { case MIDI_DEV_SEQ: - return seq_close(i_dev, flags, mode, p); + return seq_close(i_dev, flags, mode, td); } return (ENXIO); @@ -2216,22 +2216,22 @@ seqwrite(dev_t i_dev, struct uio * buf, int flag) } static int -seqioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc * p) +seqioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td) { switch (MIDIDEV(i_dev)) { case MIDI_DEV_SEQ: - return seq_ioctl(i_dev, cmd, arg, mode, p); + return seq_ioctl(i_dev, cmd, arg, mode, td); } return (ENXIO); } static int -seqpoll(dev_t i_dev, int events, struct proc * p) +seqpoll(dev_t i_dev, int events, struct thread *td) { switch (MIDIDEV(i_dev)) { case MIDI_DEV_SEQ: - return seq_poll(i_dev, events, p); + return seq_poll(i_dev, events, td); } return (ENXIO); diff --git a/sys/dev/sound/pcm/channel.c b/sys/dev/sound/pcm/channel.c index 8cf2d88..dc843ee 100644 --- a/sys/dev/sound/pcm/channel.c +++ b/sys/dev/sound/pcm/channel.c @@ -498,7 +498,7 @@ chn_sync(struct pcm_channel *c, int threshold) /* called externally, handle locking */ int -chn_poll(struct pcm_channel *c, int ev, struct proc *p) +chn_poll(struct pcm_channel *c, int ev, struct thread *td) { struct snd_dbuf *bs = c->bufsoft; int ret; @@ -510,7 +510,7 @@ chn_poll(struct pcm_channel *c, int ev, struct proc *p) if (chn_polltrigger(c) && chn_pollreset(c)) ret = ev; else - selrecord(p, sndbuf_getsel(bs)); + selrecord(curthread, sndbuf_getsel(bs)); return ret; } diff --git a/sys/dev/sound/pcm/channel.h b/sys/dev/sound/pcm/channel.h index 6743f4a..118cf5d 100644 --- a/sys/dev/sound/pcm/channel.h +++ b/sys/dev/sound/pcm/channel.h @@ -73,7 +73,7 @@ int chn_read(struct pcm_channel *c, struct uio *buf); u_int32_t chn_start(struct pcm_channel *c, int force); int chn_sync(struct pcm_channel *c, int threshold); int chn_flush(struct pcm_channel *c); -int chn_poll(struct pcm_channel *c, int ev, struct proc *p); +int chn_poll(struct pcm_channel *c, int ev, struct thread *td); int chn_init(struct pcm_channel *c, void *devinfo, int dir); int chn_kill(struct pcm_channel *c); diff --git a/sys/dev/sound/pcm/dsp.c b/sys/dev/sound/pcm/dsp.c index 6a4bfc6..4ae4e67 100644 --- a/sys/dev/sound/pcm/dsp.c +++ b/sys/dev/sound/pcm/dsp.c @@ -169,7 +169,7 @@ relchns(dev_t dev, struct pcm_channel *rdch, struct pcm_channel *wrch, u_int32_t } static int -dsp_open(dev_t i_dev, int flags, int mode, struct proc *p) +dsp_open(dev_t i_dev, int flags, int mode, struct thread *td) { struct pcm_channel *rdch, *wrch; struct snddev_info *d; @@ -229,9 +229,9 @@ dsp_open(dev_t i_dev, int flags, int mode, struct proc *p) if (rdch == NULL) { /* not already open, try to get a channel */ if (devtype == SND_DEV_DSPREC) - rdch = pcm_chnalloc(d, PCMDIR_REC, p->p_pid, PCMCHAN(i_dev)); + rdch = pcm_chnalloc(d, PCMDIR_REC, td->td_proc->p_pid, PCMCHAN(i_dev)); else - rdch = pcm_chnalloc(d, PCMDIR_REC, p->p_pid, -1); + rdch = pcm_chnalloc(d, PCMDIR_REC, td->td_proc->p_pid, -1); if (!rdch) { /* no channel available, exit */ pcm_unlock(d); @@ -251,7 +251,7 @@ dsp_open(dev_t i_dev, int flags, int mode, struct proc *p) /* open for write */ if (wrch == NULL) { /* not already open, try to get a channel */ - wrch = pcm_chnalloc(d, PCMDIR_PLAY, p->p_pid, -1); + wrch = pcm_chnalloc(d, PCMDIR_PLAY, td->td_proc->p_pid, -1); if (!wrch) { /* no channel available */ if (rdch && (flags & FREAD)) { @@ -310,7 +310,7 @@ dsp_open(dev_t i_dev, int flags, int mode, struct proc *p) } static int -dsp_close(dev_t i_dev, int flags, int mode, struct proc *p) +dsp_close(dev_t i_dev, int flags, int mode, struct thread *td) { struct pcm_channel *rdch, *wrch; struct snddev_info *d; @@ -429,7 +429,7 @@ dsp_write(dev_t i_dev, struct uio *buf, int flag) } static int -dsp_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) +dsp_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td) { struct pcm_channel *wrch, *rdch; struct snddev_info *d; @@ -446,7 +446,7 @@ dsp_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) dev_t pdev; pdev = makedev(SND_CDEV_MAJOR, PCMMKMINOR(PCMUNIT(i_dev), SND_DEV_CTL, 0)); - return mixer_ioctl(pdev, cmd, arg, mode, p); + return mixer_ioctl(pdev, cmd, arg, mode, td); } s = spltty(); @@ -961,7 +961,7 @@ dsp_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) } static int -dsp_poll(dev_t i_dev, int events, struct proc *p) +dsp_poll(dev_t i_dev, int events, struct thread *td) { struct pcm_channel *wrch = NULL, *rdch = NULL; intrmask_t s; @@ -974,12 +974,12 @@ dsp_poll(dev_t i_dev, int events, struct proc *p) if (wrch) { e = (events & (POLLOUT | POLLWRNORM)); if (e) - ret |= chn_poll(wrch, e, p); + ret |= chn_poll(wrch, e, td); } if (rdch) { e = (events & (POLLIN | POLLRDNORM)); if (e) - ret |= chn_poll(rdch, e, p); + ret |= chn_poll(rdch, e, td); } relchns(i_dev, rdch, wrch, SD_F_PRIO_RD | SD_F_PRIO_WR); diff --git a/sys/dev/sound/pcm/mixer.c b/sys/dev/sound/pcm/mixer.c index cddb515..d4894a5 100644 --- a/sys/dev/sound/pcm/mixer.c +++ b/sys/dev/sound/pcm/mixer.c @@ -392,7 +392,7 @@ mixer_hwvol_step(device_t dev, int left_step, int right_step) /* ----------------------------------------------------------------------- */ static int -mixer_open(dev_t i_dev, int flags, int mode, struct proc *p) +mixer_open(dev_t i_dev, int flags, int mode, struct thread *td) { struct snd_mixer *m; intrmask_t s; @@ -409,7 +409,7 @@ mixer_open(dev_t i_dev, int flags, int mode, struct proc *p) } static int -mixer_close(dev_t i_dev, int flags, int mode, struct proc *p) +mixer_close(dev_t i_dev, int flags, int mode, struct thread *td) { struct snd_mixer *m; intrmask_t s; @@ -431,7 +431,7 @@ mixer_close(dev_t i_dev, int flags, int mode, struct proc *p) } int -mixer_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p) +mixer_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td) { struct snd_mixer *m; intrmask_t s; diff --git a/sys/dev/sound/pcm/mixer.h b/sys/dev/sound/pcm/mixer.h index 054d79d..4f51bf2 100644 --- a/sys/dev/sound/pcm/mixer.h +++ b/sys/dev/sound/pcm/mixer.h @@ -29,7 +29,7 @@ int mixer_init(device_t dev, kobj_class_t cls, void *devinfo); int mixer_uninit(device_t dev); int mixer_reinit(device_t dev); -int mixer_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p); +int mixer_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td); int mixer_hwvol_init(device_t dev); void mixer_hwvol_mute(device_t dev); diff --git a/sys/dev/sound/pcm/sndstat.c b/sys/dev/sound/pcm/sndstat.c index dd786e9..b3b0999 100644 --- a/sys/dev/sound/pcm/sndstat.c +++ b/sys/dev/sound/pcm/sndstat.c @@ -109,7 +109,7 @@ SYSCTL_PROC(_hw_snd, OID_AUTO, verbose, CTLTYPE_INT | CTLFLAG_RW, 0, sizeof(int), sysctl_hw_sndverbose, "I", ""); static int -sndstat_open(dev_t i_dev, int flags, int mode, struct proc *p) +sndstat_open(dev_t i_dev, int flags, int mode, struct thread *td) { intrmask_t s; int err; @@ -137,7 +137,7 @@ sndstat_open(dev_t i_dev, int flags, int mode, struct proc *p) } static int -sndstat_close(dev_t i_dev, int flags, int mode, struct proc *p) +sndstat_close(dev_t i_dev, int flags, int mode, struct thread *td) { intrmask_t s; diff --git a/sys/dev/speaker/spkr.c b/sys/dev/speaker/spkr.c index 0fadea8..e0986de 100644 --- a/sys/dev/speaker/spkr.c +++ b/sys/dev/speaker/spkr.c @@ -460,11 +460,11 @@ static int spkr_active = FALSE; /* exclusion flag */ static char *spkr_inbuf; /* incoming buf */ int -spkropen(dev, flags, fmt, p) +spkropen(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { #ifdef DEBUG (void) printf("spkropen: entering with dev = %s\n", devtoname(dev)); @@ -519,11 +519,11 @@ spkrwrite(dev, uio, ioflag) } int -spkrclose(dev, flags, fmt, p) +spkrclose(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { #ifdef DEBUG (void) printf("spkrclose: entering with dev = %s\n", devtoname(dev)); @@ -542,12 +542,12 @@ spkrclose(dev, flags, fmt, p) } int -spkrioctl(dev, cmd, cmdarg, flags, p) +spkrioctl(dev, cmd, cmdarg, flags, td) dev_t dev; unsigned long cmd; caddr_t cmdarg; int flags; - struct proc *p; + struct thread *td; { #ifdef DEBUG (void) printf("spkrioctl: entering with dev = %s, cmd = %lx\n", diff --git a/sys/dev/streams/streams.c b/sys/dev/streams/streams.c index b1ccc35..8d02576 100644 --- a/sys/dev/streams/streams.c +++ b/sys/dev/streams/streams.c @@ -61,8 +61,8 @@ #include <compat/svr4/svr4_stropts.h> #include <compat/svr4/svr4_socket.h> -static int svr4_soo_close __P((struct file *, struct proc *)); -static int svr4_ptm_alloc __P((struct proc *)); +static int svr4_soo_close __P((struct file *, struct thread *)); +static int svr4_ptm_alloc __P((struct thread *)); static d_open_t streamsopen; struct svr4_sockcache_entry { @@ -198,7 +198,7 @@ MODULE_VERSION(streams, 1); * routine. */ static int -streamsopen(dev_t dev, int oflags, int devtype, struct proc *p) +streamsopen(dev_t dev, int oflags, int devtype, struct thread *td) { int type, protocol; int fd; @@ -206,9 +206,10 @@ streamsopen(dev_t dev, int oflags, int devtype, struct proc *p) struct socket *so; int error; int family; + struct proc *p = td->td_proc; PROC_LOCK(p); - if (p->p_dupfd >= 0) { + if (td->td_dupfd >= 0) { PROC_UNLOCK(p); return ENODEV; } @@ -254,16 +255,16 @@ streamsopen(dev_t dev, int oflags, int devtype, struct proc *p) break; case dev_ptm: - return svr4_ptm_alloc(p); + return svr4_ptm_alloc(td); default: return EOPNOTSUPP; } - if ((error = falloc(p, &fp, &fd)) != 0) + if ((error = falloc(td, &fp, &fd)) != 0) return error; - if ((error = socreate(family, &so, type, protocol, p)) != 0) { + if ((error = socreate(family, &so, type, protocol, td)) != 0) { p->p_fd->fd_ofiles[fd] = 0; ffree(fp); return error; @@ -276,15 +277,16 @@ streamsopen(dev_t dev, int oflags, int devtype, struct proc *p) (void)svr4_stream_get(fp); PROC_LOCK(p); - p->p_dupfd = fd; + td->td_dupfd = fd; PROC_UNLOCK(p); return ENXIO; } static int -svr4_ptm_alloc(p) - struct proc *p; +svr4_ptm_alloc(td) + struct thread *td; { + struct proc *p = td->td_proc; /* * XXX this is very, very ugly. But I can't find a better * way that won't duplicate a big amount of code from @@ -319,13 +321,13 @@ svr4_ptm_alloc(p) if ((error = copyout(ptyname, path, sizeof(ptyname))) != 0) return error; - switch (error = open(p, &oa)) { + switch (error = open(td, &oa)) { case ENOENT: case ENXIO: return error; case 0: PROC_LOCK(p); - p->p_dupfd = p->p_retval[0]; + td->td_dupfd = td->td_retval[0]; PROC_UNLOCK(p); return ENXIO; default: @@ -394,14 +396,14 @@ svr4_delete_socket(p, fp) } static int -svr4_soo_close(struct file *fp, struct proc *p) +svr4_soo_close(struct file *fp, struct thread *td) { struct socket *so = (struct socket *)fp->f_data; /* CHECKUNIT_DIAG(ENXIO);*/ - svr4_delete_socket(p, fp); + svr4_delete_socket(td->td_proc, fp); free(so->so_emuldata, M_TEMP); - return soo_close(fp, p); + return soo_close(fp, td); return (0); } diff --git a/sys/dev/syscons/schistory.c b/sys/dev/syscons/schistory.c index bd9b1d2..3df7682 100644 --- a/sys/dev/syscons/schistory.c +++ b/sys/dev/syscons/schistory.c @@ -278,7 +278,7 @@ sc_hist_down_line(scr_stat *scp) int sc_hist_ioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, - struct proc *p) + struct thread *td) { scr_stat *scp; int error; diff --git a/sys/dev/syscons/scmouse.c b/sys/dev/syscons/scmouse.c index b8bb5d1..92ced7d 100644 --- a/sys/dev/syscons/scmouse.c +++ b/sys/dev/syscons/scmouse.c @@ -600,7 +600,7 @@ sc_mouse_paste(scr_stat *scp) int sc_mouse_ioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, - struct proc *p) + struct thread *td) { mouse_info_t *mouse; mouse_info_t buf; @@ -658,8 +658,8 @@ sc_mouse_ioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, case MOUSE_MODE: if (ISSIGVALID(mouse->u.mode.signal)) { scp->mouse_signal = mouse->u.mode.signal; - scp->mouse_proc = p; - scp->mouse_pid = p->p_pid; + scp->mouse_proc = td->td_proc; + scp->mouse_pid = td->td_proc->p_pid; } else { scp->mouse_signal = 0; diff --git a/sys/dev/syscons/scterm-sc.c b/sys/dev/syscons/scterm-sc.c index fb02b92..1b9b979 100644 --- a/sys/dev/syscons/scterm-sc.c +++ b/sys/dev/syscons/scterm-sc.c @@ -711,7 +711,7 @@ outloop: static int scterm_ioctl(scr_stat *scp, struct tty *tp, u_long cmd, caddr_t data, - int flag, struct proc *p) + int flag, struct thread *td) { term_stat *tcp = scp->ts; vid_info_t *vi; diff --git a/sys/dev/syscons/scvesactl.c b/sys/dev/syscons/scvesactl.c index a9ff4ad..7a92d33f 100644 --- a/sys/dev/syscons/scvesactl.c +++ b/sys/dev/syscons/scvesactl.c @@ -46,7 +46,7 @@ static d_ioctl_t *prev_user_ioctl; static int -vesa_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +vesa_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { scr_stat *scp; struct tty *tp; @@ -106,7 +106,7 @@ vesa_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) } if (prev_user_ioctl) - return (*prev_user_ioctl)(dev, cmd, data, flag, p); + return (*prev_user_ioctl)(dev, cmd, data, flag, td); else return ENOIOCTL; } diff --git a/sys/dev/syscons/scvidctl.c b/sys/dev/syscons/scvidctl.c index b75e545..b28752b 100644 --- a/sys/dev/syscons/scvidctl.c +++ b/sys/dev/syscons/scvidctl.c @@ -435,7 +435,7 @@ sc_set_pixel_mode(scr_stat *scp, struct tty *tp, int xsize, int ysize, (*vidsw[(a)->va_index]->ioctl)((a), (c), (caddr_t)(d))) int -sc_vid_ioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, struct proc *p) +sc_vid_ioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, struct thread *td) { scr_stat *scp; video_adapter_t *adp; diff --git a/sys/dev/syscons/syscons.c b/sys/dev/syscons/syscons.c index fe5176f..644864e 100644 --- a/sys/dev/syscons/syscons.c +++ b/sys/dev/syscons/syscons.c @@ -442,7 +442,7 @@ scdevtounit(dev_t dev) } int -scopen(dev_t dev, int flag, int mode, struct proc *p) +scopen(dev_t dev, int flag, int mode, struct thread *td) { int unit = scdevtounit(dev); sc_softc_t *sc; @@ -481,7 +481,7 @@ scopen(dev_t dev, int flag, int mode, struct proc *p) (*linesw[tp->t_line].l_modem)(tp, 1); } else - if (tp->t_state & TS_XCLUDE && suser(p)) + if (tp->t_state & TS_XCLUDE && suser_td(td)) return(EBUSY); error = (*linesw[tp->t_line].l_open)(dev, tp); @@ -501,7 +501,7 @@ scopen(dev_t dev, int flag, int mode, struct proc *p) } int -scclose(dev_t dev, int flag, int mode, struct proc *p) +scclose(dev_t dev, int flag, int mode, struct thread *td) { struct tty *tp = dev->si_tty; scr_stat *scp; @@ -634,7 +634,7 @@ scparam(struct tty *tp, struct termios *t) } int -scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int error; int i; @@ -647,23 +647,23 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) /* If there is a user_ioctl function call that first */ if (sc_user_ioctl) { - error = (*sc_user_ioctl)(dev, cmd, data, flag, p); + error = (*sc_user_ioctl)(dev, cmd, data, flag, td); if (error != ENOIOCTL) return error; } - error = sc_vid_ioctl(tp, cmd, data, flag, p); + error = sc_vid_ioctl(tp, cmd, data, flag, td); if (error != ENOIOCTL) return error; #ifndef SC_NO_HISTORY - error = sc_hist_ioctl(tp, cmd, data, flag, p); + error = sc_hist_ioctl(tp, cmd, data, flag, td); if (error != ENOIOCTL) return error; #endif #ifndef SC_NO_SYSMOUSE - error = sc_mouse_ioctl(tp, cmd, data, flag, p); + error = sc_mouse_ioctl(tp, cmd, data, flag, td); if (error != ENOIOCTL) return error; #endif @@ -674,7 +674,7 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) sc = scp->sc; if (scp->tsw) { - error = (*scp->tsw->te_ioctl)(scp, tp, cmd, data, flag, p); + error = (*scp->tsw->te_ioctl)(scp, tp, cmd, data, flag, td); if (error != ENOIOCTL) return error; } @@ -855,7 +855,7 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) DPRINTF(5, ("sc%d: VT_SETMODE ", sc->unit)); if (scp->smode.mode == VT_PROCESS) { p1 = pfind(scp->pid); - if (scp->proc == p1 && scp->proc != p) { + if (scp->proc == p1 && scp->proc != td->td_proc) { if (p1) PROC_UNLOCK(p1); DPRINTF(5, ("error EPERM\n")); @@ -884,9 +884,9 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) DPRINTF(5, ("error EINVAL\n")); return EINVAL; } - DPRINTF(5, ("VT_PROCESS %d, ", p->p_pid)); + DPRINTF(5, ("VT_PROCESS %d, ", td->td_proc->p_pid)); bcopy(data, &scp->smode, sizeof(struct vt_mode)); - scp->proc = p; + scp->proc = td->td_proc; scp->pid = scp->proc->p_pid; if ((scp == sc->cur_scp) && (sc->unit == sc_console_unit)) cons_unavail = TRUE; @@ -911,7 +911,7 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) return EINVAL; } /* ...and this process is controlling it. */ - if (scp->proc != p) { + if (scp->proc != td->td_proc) { splx(s); return EPERM; } @@ -977,19 +977,19 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) return 0; case KDENABIO: /* allow io operations */ - error = suser(p); + error = suser_td(td); if (error != 0) return error; if (securelevel > 0) return EPERM; #ifdef __i386__ - p->p_frame->tf_eflags |= PSL_IOPL; + td->td_frame->tf_eflags |= PSL_IOPL; #endif return 0; case KDDISABIO: /* disallow io operations (default) */ #ifdef __i386__ - p->p_frame->tf_eflags &= ~PSL_IOPL; + td->td_frame->tf_eflags &= ~PSL_IOPL; #endif return 0; @@ -1270,7 +1270,7 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) break; } - 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/dev/syscons/syscons.h b/sys/dev/syscons/syscons.h index 7a353f8..b5e206a 100644 --- a/sys/dev/syscons/syscons.h +++ b/sys/dev/syscons/syscons.h @@ -338,7 +338,7 @@ typedef int sc_term_init_t(scr_stat *scp, void **tcp, int code); typedef int sc_term_term_t(scr_stat *scp, void **tcp); typedef void sc_term_puts_t(scr_stat *scp, u_char *buf, int len); typedef int sc_term_ioctl_t(scr_stat *scp, struct tty *tp, u_long cmd, - caddr_t data, int flag, struct proc *p); + caddr_t data, int flag, struct thread *td); typedef int sc_term_reset_t(scr_stat *scp, int code); #define SC_TE_HARD_RESET 0 #define SC_TE_SOFT_RESET 1 @@ -508,7 +508,7 @@ typedef struct { /* syscons.c */ extern int (*sc_user_ioctl)(dev_t dev, u_long cmd, caddr_t data, - int flag, struct proc *p); + int flag, struct thread *td); int sc_probe_unit(int unit, int flags); int sc_attach_unit(int unit, int flags); @@ -550,7 +550,7 @@ void sc_hist_end(scr_stat *scp); int sc_hist_up_line(scr_stat *scp); int sc_hist_down_line(scr_stat *scp); int sc_hist_ioctl(struct tty *tp, u_long cmd, caddr_t data, - int flag, struct proc *p); + int flag, struct thread *td); #endif /* SC_NO_HISTORY */ /* scmouse.c */ @@ -575,7 +575,7 @@ void sc_mouse_paste(scr_stat *scp); #ifndef SC_NO_SYSMOUSE void sc_mouse_move(scr_stat *scp, int x, int y); int sc_mouse_ioctl(struct tty *tp, u_long cmd, caddr_t data, - int flag, struct proc *p); + int flag, struct thread *td); #endif /* SC_NO_SYSMOUSE */ /* scvidctl.c */ @@ -585,7 +585,7 @@ int sc_set_graphics_mode(scr_stat *scp, struct tty *tp, int mode); int sc_set_pixel_mode(scr_stat *scp, struct tty *tp, int xsize, int ysize, int fontsize); int sc_vid_ioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, - struct proc *p); + struct thread *td); int sc_render_add(sc_renderer_t *rndr); int sc_render_remove(sc_renderer_t *rndr); diff --git a/sys/dev/syscons/sysmouse.c b/sys/dev/syscons/sysmouse.c index bb38cfe..80eac8e 100644 --- a/sys/dev/syscons/sysmouse.c +++ b/sys/dev/syscons/sysmouse.c @@ -72,7 +72,7 @@ static void smstart(struct tty *tp); static int smparam(struct tty *tp, struct termios *t); static int -smopen(dev_t dev, int flag, int mode, struct proc *p) +smopen(dev_t dev, int flag, int mode, struct thread *td) { struct tty *tp; @@ -99,7 +99,7 @@ smopen(dev_t dev, int flag, int mode, struct proc *p) tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; smparam(tp, &tp->t_termios); (*linesw[tp->t_line].l_modem)(tp, 1); - } else if (tp->t_state & TS_XCLUDE && suser(p)) { + } else if (tp->t_state & TS_XCLUDE && suser_td(td)) { return EBUSY; } @@ -107,7 +107,7 @@ smopen(dev_t dev, int flag, int mode, struct proc *p) } static int -smclose(dev_t dev, int flag, int mode, struct proc *p) +smclose(dev_t dev, int flag, int mode, struct thread *td) { struct tty *tp; int s; @@ -151,7 +151,7 @@ smparam(struct tty *tp, struct termios *t) } static int -smioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +smioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { struct tty *tp; mousehw_t *hw; @@ -239,7 +239,7 @@ smioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) return ENODEV; } - 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/dev/tdfx/tdfx_pci.c b/sys/dev/tdfx/tdfx_pci.c index 7ffee6f..5594a13 100644 --- a/sys/dev/tdfx/tdfx_pci.c +++ b/sys/dev/tdfx/tdfx_pci.c @@ -407,7 +407,7 @@ tdfx_setmtrr(device_t dev) { } static int -tdfx_open(dev_t dev, int flags, int fmt, struct proc *p) +tdfx_open(dev_t dev, int flags, int fmt, struct thread *td) { /* * The open cdev method handles open(2) calls to /dev/3dfx[n] @@ -417,7 +417,7 @@ tdfx_open(dev_t dev, int flags, int fmt, struct proc *p) UNIT(minor(dev))); if(tdfx_info->busy != 0) return EBUSY; #ifdef DEBUG - printf("3dfx: Opened by #%d\n", p->p_pid); + printf("3dfx: Opened by #%d\n", td->td_proc->p_pid); #endif /* Set the driver as busy */ tdfx_info->busy++; @@ -425,7 +425,7 @@ tdfx_open(dev_t dev, int flags, int fmt, struct proc *p) } static int -tdfx_close(dev_t dev, int fflag, int devtype, struct proc* p) +tdfx_close(dev_t dev, int fflag, int devtype, struct thread *td) { /* * The close cdev method handles close(2) calls to /dev/3dfx[n] @@ -436,7 +436,7 @@ tdfx_close(dev_t dev, int fflag, int devtype, struct proc* p) if(tdfx_info->busy == 0) return EBADF; tdfx_info->busy = 0; #ifdef DEBUG - printf("Closed by #%d\n", p->p_pid); + printf("Closed by #%d\n", td->td_proc->p_pid); #endif return 0; } @@ -790,37 +790,37 @@ tdfx_do_pio(u_int cmd, struct tdfx_pio_data *piod) * want to distinguish errors from useful data, and maintain compatibility. * * There is this portion of the proc struct called p_retval[], we can store a - * return value in p->p_retval[0] and place the return value if it is positive + * return value in td->td_retval[0] and place the return value if it is positive * in there, then we can return 0 (good). If the return value is negative, we * can return -retval and the error should be properly handled. */ static int -tdfx_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc * p) +tdfx_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int retval = 0; struct tdfx_pio_data *piod = (struct tdfx_pio_data*)data; #ifdef DEBUG - printf("IOCTL'd by #%d, cmd: 0x%x, data: 0x%x\n", p->p_pid, (u_int32_t)cmd, + printf("IOCTL'd by #%d, cmd: 0x%x, data: 0x%x\n", td->td_proc->p_pid, (u_int32_t)cmd, (unsigned int)piod); #endif switch(_IOC_TYPE(cmd)) { /* Return the real error if negative, or simply stick the valid return - * in p->p_retval */ + * in td->td_retval */ case 0x33: /* The '3'(0x33) type IOCTL is for querying the installed cards */ - if((retval = tdfx_do_query(cmd, piod)) > 0) p->p_retval[0] = retval; + if((retval = tdfx_do_query(cmd, piod)) > 0) td->td_retval[0] = retval; else return -retval; break; case 0: /* The 0 type IOCTL is for programmed I/O methods */ - if((tdfx_do_pio(cmd, piod)) > 0) p->p_retval[0] = retval; + if((tdfx_do_pio(cmd, piod)) > 0) td->td_retval[0] = retval; else return -retval; break; default: /* Technically, we won't reach this from linux emu, but when glide * finally gets ported, watch out! */ #ifdef DEBUG - printf("Bad IOCTL from #%d\n", p->p_pid); + printf("Bad IOCTL from #%d\n", td->td_proc->p_pid); #endif return ENXIO; } @@ -833,7 +833,7 @@ tdfx_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc * p) * Linux emulation IOCTL for /dev/tdfx */ static int -linux_ioctl_tdfx(struct proc* p, struct linux_ioctl_args* args) +linux_ioctl_tdfx(struct thread *td, struct linux_ioctl_args* args) { int error = 0; u_long cmd = args->cmd & 0xffff; @@ -842,11 +842,11 @@ linux_ioctl_tdfx(struct proc* p, struct linux_ioctl_args* args) and one void*. */ char d_pio[2*sizeof(short) + sizeof(int) + sizeof(void*)]; - struct file *fp = p->p_fd->fd_ofiles[args->fd]; + struct file *fp = td->td_proc->p_fd->fd_ofiles[args->fd]; /* We simply copy the data and send it right to ioctl */ copyin((caddr_t)args->arg, &d_pio, sizeof(d_pio)); - error = fo_ioctl(fp, cmd, (caddr_t)&d_pio, p); + error = fo_ioctl(fp, cmd, (caddr_t)&d_pio, td); return error; } #endif /* TDFX_LINUX */ diff --git a/sys/dev/twe/twe_freebsd.c b/sys/dev/twe/twe_freebsd.c index e77e11f..3543913 100644 --- a/sys/dev/twe/twe_freebsd.c +++ b/sys/dev/twe/twe_freebsd.c @@ -90,7 +90,7 @@ static struct cdevsw twe_cdevsw = { * Accept an open operation on the control device. */ static int -twe_open(dev_t dev, int flags, int fmt, struct proc *p) +twe_open(dev_t dev, int flags, int fmt, struct thread *td) { int unit = minor(dev); struct twe_softc *sc = devclass_get_softc(twe_devclass, unit); @@ -103,7 +103,7 @@ twe_open(dev_t dev, int flags, int fmt, struct proc *p) * Accept the last close on the control device. */ static int -twe_close(dev_t dev, int flags, int fmt, struct proc *p) +twe_close(dev_t dev, int flags, int fmt, struct thread *td) { int unit = minor(dev); struct twe_softc *sc = devclass_get_softc(twe_devclass, unit); @@ -116,7 +116,7 @@ twe_close(dev_t dev, int flags, int fmt, struct proc *p) * Handle controller-specific control operations. */ static int -twe_ioctl_wrapper(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct proc *p) +twe_ioctl_wrapper(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *td) { struct twe_softc *sc = (struct twe_softc *)dev->si_drv1; @@ -599,7 +599,7 @@ static int disks_registered = 0; * for opens on subdevices (eg. slices, partitions). */ static int -twed_open(dev_t dev, int flags, int fmt, struct proc *p) +twed_open(dev_t dev, int flags, int fmt, struct thread *td) { struct twed_softc *sc = (struct twed_softc *)dev->si_drv1; struct disklabel *label; @@ -632,7 +632,7 @@ twed_open(dev_t dev, int flags, int fmt, struct proc *p) * Handle last close of the disk device. */ static int -twed_close(dev_t dev, int flags, int fmt, struct proc *p) +twed_close(dev_t dev, int flags, int fmt, struct thread *td) { struct twed_softc *sc = (struct twed_softc *)dev->si_drv1; diff --git a/sys/dev/usb/ohci.c b/sys/dev/usb/ohci.c index 38dab89..14d8f3a 100644 --- a/sys/dev/usb/ohci.c +++ b/sys/dev/usb/ohci.c @@ -1887,7 +1887,7 @@ ohci_abort_xfer(xfer, status) timeout(ohci_abort_xfer_end, xfer, hz / USB_FRAMES_PER_SECOND); } else { #if defined(DIAGNOSTIC) && defined(__i386__) && defined(__FreeBSD__) - KASSERT(curproc->p_intr_nesting_level == 0, + KASSERT(curthread->td_intr_nesting_level == 0, ("ohci_abort_req in interrupt context")); #endif usb_delay_ms(opipe->pipe.device->bus, 1); diff --git a/sys/dev/usb/ugen.c b/sys/dev/usb/ugen.c index 637c7a0..2f65a8a 100644 --- a/sys/dev/usb/ugen.c +++ b/sys/dev/usb/ugen.c @@ -157,7 +157,7 @@ Static void ugen_isoc_rintr(usbd_xfer_handle xfer, usbd_private_handle addr, Static int ugen_do_read(struct ugen_softc *, int, struct uio *, int); Static int ugen_do_write(struct ugen_softc *, int, struct uio *, int); Static int ugen_do_ioctl(struct ugen_softc *, int, u_long, - caddr_t, int, struct proc *); + caddr_t, int, struct thread *); #if defined(__FreeBSD__) Static void ugen_make_devnodes(struct ugen_softc *sc); Static void ugen_destroy_devnodes(struct ugen_softc *sc); @@ -358,7 +358,7 @@ ugen_set_config(struct ugen_softc *sc, int configno) } int -ugenopen(dev_t dev, int flag, int mode, struct proc *p) +ugenopen(dev_t dev, int flag, int mode, struct thread *td) { struct ugen_softc *sc; int unit = UGENUNIT(dev); @@ -490,7 +490,7 @@ ugenopen(dev_t dev, int flag, int mode, struct proc *p) } int -ugenclose(dev_t dev, int flag, int mode, struct proc *p) +ugenclose(dev_t dev, int flag, int mode, struct thread *td) { int endpt = UGENENDPOINT(dev); struct ugen_softc *sc; @@ -1034,7 +1034,7 @@ ugen_get_alt_index(struct ugen_softc *sc, int ifaceidx) Static int ugen_do_ioctl(struct ugen_softc *sc, int endpt, u_long cmd, - caddr_t addr, int flag, struct proc *p) + caddr_t addr, int flag, struct thread *td) { struct ugen_endpoint *sce; usbd_status err; @@ -1223,7 +1223,7 @@ ugen_do_ioctl(struct ugen_softc *sc, int endpt, u_long cmd, uio.uio_offset = 0; uio.uio_segflg = UIO_USERSPACE; uio.uio_rw = UIO_READ; - uio.uio_procp = p; + uio.uio_td = td; #if defined(__NetBSD__) || defined(__OpenBSD__) error = uiomove((caddr_t)cdesc, len, &uio); #elif defined(__FreeBSD__) @@ -1273,7 +1273,7 @@ ugen_do_ioctl(struct ugen_softc *sc, int endpt, u_long cmd, uio.uio_rw = ur->request.bmRequestType & UT_READ ? UIO_READ : UIO_WRITE; - uio.uio_procp = p; + uio.uio_td = td; ptr = malloc(len, M_TEMP, M_WAITOK); if (uio.uio_rw == UIO_WRITE) { error = uiomove(ptr, len, &uio); @@ -1310,7 +1310,7 @@ ugen_do_ioctl(struct ugen_softc *sc, int endpt, u_long cmd, } int -ugenioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +ugenioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { int endpt = UGENENDPOINT(dev); struct ugen_softc *sc; @@ -1319,14 +1319,14 @@ ugenioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) USB_GET_SC(ugen, UGENUNIT(dev), sc); sc->sc_refcnt++; - error = ugen_do_ioctl(sc, endpt, cmd, addr, flag, p); + error = ugen_do_ioctl(sc, endpt, cmd, addr, flag, td); if (--sc->sc_refcnt < 0) usb_detach_wakeup(USBDEV(sc->sc_dev)); return (error); } int -ugenpoll(dev_t dev, int events, struct proc *p) +ugenpoll(dev_t dev, int events, struct thread *td) { struct ugen_softc *sc; struct ugen_endpoint *sce; @@ -1350,7 +1350,7 @@ ugenpoll(dev_t dev, int events, struct proc *p) if (sce->q.c_cc > 0) revents |= events & (POLLIN | POLLRDNORM); else - selrecord(p, &sce->rsel); + selrecord(td, &sce->rsel); } break; case UE_ISOCHRONOUS: @@ -1358,7 +1358,7 @@ ugenpoll(dev_t dev, int events, struct proc *p) if (sce->cur != sce->fill) revents |= events & (POLLIN | POLLRDNORM); else - selrecord(p, &sce->rsel); + selrecord(td, &sce->rsel); } break; case UE_BULK: diff --git a/sys/dev/usb/uhci.c b/sys/dev/usb/uhci.c index 5ae6070..7358fe1 100644 --- a/sys/dev/usb/uhci.c +++ b/sys/dev/usb/uhci.c @@ -1613,7 +1613,7 @@ uhci_abort_xfer(usbd_xfer_handle xfer, usbd_status status) timeout(uhci_abort_xfer_end, xfer, hz / USB_FRAMES_PER_SECOND); } else { #if defined(DIAGNOSTIC) && defined(__i386__) && defined(__FreeBSD__) - KASSERT(curproc->p_intr_nesting_level == 0, + KASSERT(curthread->td_intr_nesting_level == 0, ("ohci_abort_req in interrupt context")); #endif usb_delay_ms(xfer->pipe->device->bus, 1); diff --git a/sys/dev/usb/uhid.c b/sys/dev/usb/uhid.c index cffc5e5..7914cb3 100644 --- a/sys/dev/usb/uhid.c +++ b/sys/dev/usb/uhid.c @@ -163,7 +163,7 @@ Static void uhid_intr(usbd_xfer_handle, usbd_private_handle, Static int uhid_do_read(struct uhid_softc *, struct uio *uio, int); Static int uhid_do_write(struct uhid_softc *, struct uio *uio, int); Static int uhid_do_ioctl(struct uhid_softc *, u_long, caddr_t, int, - struct proc *); + struct thread *); USB_DECLARE_DRIVER(uhid); @@ -373,11 +373,11 @@ uhid_intr(xfer, addr, status) } int -uhidopen(dev, flag, mode, p) +uhidopen(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct uhid_softc *sc; usbd_status err; @@ -422,11 +422,11 @@ uhidopen(dev, flag, mode, p) } int -uhidclose(dev, flag, mode, p) +uhidclose(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct uhid_softc *sc; @@ -588,12 +588,12 @@ uhidwrite(dev, uio, flag) } int -uhid_do_ioctl(sc, cmd, addr, flag, p) +uhid_do_ioctl(sc, cmd, addr, flag, td) struct uhid_softc *sc; u_long cmd; caddr_t addr; int flag; - struct proc *p; + struct thread *td; { struct usb_ctl_report_desc *rd; struct usb_ctl_report *re; @@ -614,8 +614,8 @@ uhid_do_ioctl(sc, cmd, addr, flag, p) if (*(int *)addr) { if (sc->sc_async != NULL) return (EBUSY); - sc->sc_async = p; - DPRINTF(("uhid_do_ioctl: FIOASYNC %p\n", p)); + sc->sc_async = td->td_proc; /* XXXKSE */ + DPRINTF(("uhid_do_ioctl: FIOASYNC %p\n", td->td_proc)); } else sc->sc_async = NULL; break; @@ -703,12 +703,12 @@ uhid_do_ioctl(sc, cmd, addr, flag, p) } int -uhidioctl(dev, cmd, addr, flag, p) +uhidioctl(dev, cmd, addr, flag, td) dev_t dev; u_long cmd; caddr_t addr; int flag; - struct proc *p; + struct thread *td; { struct uhid_softc *sc; int error; @@ -716,17 +716,17 @@ uhidioctl(dev, cmd, addr, flag, p) USB_GET_SC(uhid, UHIDUNIT(dev), sc); sc->sc_refcnt++; - error = uhid_do_ioctl(sc, cmd, addr, flag, p); + error = uhid_do_ioctl(sc, cmd, addr, flag, td); if (--sc->sc_refcnt < 0) usb_detach_wakeup(USBDEV(sc->sc_dev)); return (error); } int -uhidpoll(dev, events, p) +uhidpoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { struct uhid_softc *sc; int revents = 0; @@ -744,7 +744,7 @@ uhidpoll(dev, events, p) if (sc->sc_q.c_cc > 0) revents |= events & (POLLIN | POLLRDNORM); else - selrecord(p, &sc->sc_rsel); + selrecord(td, &sc->sc_rsel); } splx(s); diff --git a/sys/dev/usb/ulpt.c b/sys/dev/usb/ulpt.c index 524bc83..052583b 100644 --- a/sys/dev/usb/ulpt.c +++ b/sys/dev/usb/ulpt.c @@ -467,7 +467,7 @@ int ulptusein = 1; * Reset the printer, then wait until it's selected and not busy. */ int -ulptopen(dev_t dev, int flag, int mode, struct proc *p) +ulptopen(dev_t dev, int flag, int mode, struct thread *td) { u_char flags = ULPTFLAGS(dev); struct ulpt_softc *sc; @@ -586,7 +586,7 @@ ulpt_statusmsg(u_char status, struct ulpt_softc *sc) } int -ulptclose(dev_t dev, int flag, int mode, struct proc *p) +ulptclose(dev_t dev, int flag, int mode, struct thread *td) { struct ulpt_softc *sc; @@ -676,7 +676,7 @@ ulptwrite(dev_t dev, struct uio *uio, int flags) } int -ulptioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +ulptioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int error = 0; diff --git a/sys/dev/usb/umodem.c b/sys/dev/usb/umodem.c index 05c9a47..ad24d94 100644 --- a/sys/dev/usb/umodem.c +++ b/sys/dev/usb/umodem.c @@ -571,10 +571,10 @@ umodemparam(tp, t) } int -umodemopen(dev, flag, mode, p) +umodemopen(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { int unit = UMODEMUNIT(dev); struct umodem_softc *sc; @@ -599,7 +599,7 @@ umodemopen(dev, flag, mode, p) if (ISSET(tp->t_state, TS_ISOPEN) && ISSET(tp->t_state, TS_XCLUDE) && - suser(p)) + suser_td(td)) return (EBUSY); /* @@ -781,10 +781,10 @@ umodemreadcb(xfer, p, status) } int -umodemclose(dev, flag, mode, p) +umodemclose(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { struct umodem_softc *sc; struct tty *tp; @@ -924,12 +924,12 @@ umodemtty(dev) } int -umodemioctl(dev, cmd, data, flag, p) +umodemioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct umodem_softc *sc; struct tty *tp; @@ -946,12 +946,12 @@ umodemioctl(dev, cmd, data, flag, p) DPRINTF(("umodemioctl: cmd=0x%08lx\n", cmd)); - 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 >= 0) return (error); #if defined(__NetBSD__) || defined(__OpenBSD__) - error = ttioctl(tp, cmd, data, flag, p); + error = ttioctl(tp, cmd, data, flag, td); #elif defined(__FreeBSD__) error = ttioctl(tp, cmd, data, flag); #endif diff --git a/sys/dev/usb/ums.c b/sys/dev/usb/ums.c index ffabb7b..2a72120 100644 --- a/sys/dev/usb/ums.c +++ b/sys/dev/usb/ums.c @@ -586,7 +586,7 @@ ums_disable(priv) } Static int -ums_open(dev_t dev, int flag, int fmt, struct proc *p) +ums_open(dev_t dev, int flag, int fmt, struct thread *td) { struct ums_softc *sc; @@ -596,7 +596,7 @@ ums_open(dev_t dev, int flag, int fmt, struct proc *p) } Static int -ums_close(dev_t dev, int flag, int fmt, struct proc *p) +ums_close(dev_t dev, int flag, int fmt, struct thread *td) { struct ums_softc *sc; @@ -682,7 +682,7 @@ ums_read(dev_t dev, struct uio *uio, int flag) } Static int -ums_poll(dev_t dev, int events, struct proc *p) +ums_poll(dev_t dev, int events, struct thread *td) { struct ums_softc *sc; int revents = 0; @@ -699,7 +699,7 @@ ums_poll(dev_t dev, int events, struct proc *p) revents = events & (POLLIN | POLLRDNORM); } else { sc->state |= UMS_SELECT; - selrecord(p, &sc->rsel); + selrecord(td, &sc->rsel); } } splx(s); @@ -708,7 +708,7 @@ ums_poll(dev_t dev, int events, struct proc *p) } int -ums_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +ums_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct ums_softc *sc; int error = 0; diff --git a/sys/dev/usb/urio.c b/sys/dev/usb/urio.c index 1e86195..e1ad11b 100644 --- a/sys/dev/usb/urio.c +++ b/sys/dev/usb/urio.c @@ -291,11 +291,11 @@ USB_ATTACH(urio) int -urioopen(dev, flag, mode, p) +urioopen(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { #if (USBDI >= 1) struct urio_softc * sc; @@ -335,11 +335,11 @@ urioopen(dev, flag, mode, p) } int -urioclose(dev, flag, mode, p) +urioclose(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { #if (USBDI >= 1) struct urio_softc * sc; @@ -509,12 +509,12 @@ uriowrite(dev, uio, flag) int -urioioctl(dev, cmd, addr, flag, p) +urioioctl(dev, cmd, addr, flag, td) dev_t dev; u_long cmd; caddr_t addr; int flag; - struct proc *p; + struct thread *td; { #if (USBDI >= 1) struct urio_softc * sc; @@ -584,7 +584,7 @@ urioioctl(dev, cmd, addr, flag, p) uio.uio_rw = req.bmRequestType & UT_READ ? UIO_READ : UIO_WRITE; - uio.uio_procp = p; + uio.uio_td = td; ptr = malloc(len, M_TEMP, M_WAITOK); if (uio.uio_rw == UIO_WRITE) { error = uiomove(ptr, len, &uio); diff --git a/sys/dev/usb/usb.c b/sys/dev/usb/usb.c index 2b4ad42..9457ef2 100644 --- a/sys/dev/usb/usb.c +++ b/sys/dev/usb/usb.c @@ -129,7 +129,7 @@ d_open_t usbopen; d_close_t usbclose; d_read_t usbread; d_ioctl_t usbioctl; -int usbpoll(dev_t, int, struct proc *); +d_poll_t usbpoll; struct cdevsw usb_cdevsw = { /* open */ usbopen, @@ -336,10 +336,10 @@ usbctlprint(aux, pnp) #endif /* defined(__NetBSD__) || defined(__OpenBSD__) */ int -usbopen(dev, flag, mode, p) +usbopen(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { int unit = USBUNIT(dev); struct usb_softc *sc; @@ -398,10 +398,10 @@ usbread(dev, uio, flag) } int -usbclose(dev, flag, mode, p) +usbclose(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { int unit = USBUNIT(dev); @@ -414,12 +414,12 @@ usbclose(dev, flag, mode, p) } int -usbioctl(devt, cmd, data, flag, p) +usbioctl(devt, cmd, data, flag, td) dev_t devt; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct usb_softc *sc; int unit = USBUNIT(devt); @@ -432,7 +432,7 @@ usbioctl(devt, cmd, data, flag, p) case FIOASYNC: if (*(int *)data) - usb_async_proc = p; + usb_async_proc = td->td_proc; else usb_async_proc = 0; return (0); @@ -492,7 +492,7 @@ usbioctl(devt, cmd, data, flag, p) uio.uio_rw = ur->request.bmRequestType & UT_READ ? UIO_READ : UIO_WRITE; - uio.uio_procp = p; + uio.uio_td = td; ptr = malloc(len, M_TEMP, M_WAITOK); if (uio.uio_rw == UIO_WRITE) { error = uiomove(ptr, len, &uio); @@ -545,10 +545,10 @@ usbioctl(devt, cmd, data, flag, p) } int -usbpoll(dev, events, p) +usbpoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { int revents, mask, s; int unit = USBUNIT(dev); @@ -562,7 +562,7 @@ usbpoll(dev, events, p) revents |= events & mask; if (revents == 0 && (events & mask)) { DPRINTFN(2,("usb: sleeping on %p\n", &usb_selevent)); - selrecord(p, &usb_selevent); + selrecord(curthread, &usb_selevent); } splx(s); diff --git a/sys/dev/usb/usbdi.c b/sys/dev/usb/usbdi.c index 9acffce..20d6a03 100644 --- a/sys/dev/usb/usbdi.c +++ b/sys/dev/usb/usbdi.c @@ -931,7 +931,7 @@ usbd_do_request_flags(dev, req, data, flags, actlen) #ifdef DIAGNOSTIC #if defined(__i386__) && defined(__FreeBSD__) - KASSERT(curproc->p_intr_nesting_level == 0, + KASSERT(curthread->td_intr_nesting_level == 0, ("usbd_do_request: in interrupt context")); #endif if (dev->bus->intr_context) { diff --git a/sys/dev/usb/uscanner.c b/sys/dev/usb/uscanner.c index 46728bc..bd33a20 100644 --- a/sys/dev/usb/uscanner.c +++ b/sys/dev/usb/uscanner.c @@ -325,11 +325,11 @@ USB_ATTACH(uscanner) } int -uscanneropen(dev, flag, mode, p) +uscanneropen(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct uscanner_softc *sc; int unit = USCANNERUNIT(dev); @@ -388,11 +388,11 @@ uscanneropen(dev, flag, mode, p) } int -uscannerclose(dev, flag, mode, p) +uscannerclose(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct uscanner_softc *sc; @@ -639,10 +639,10 @@ USB_DETACH(uscanner) } int -uscannerpoll(dev, events, p) +uscannerpoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { struct uscanner_softc *sc; int revents = 0; diff --git a/sys/dev/vinum/vinum.c b/sys/dev/vinum/vinum.c index 5824d84..8ac6afa 100644 --- a/sys/dev/vinum/vinum.c +++ b/sys/dev/vinum/vinum.c @@ -238,7 +238,7 @@ vinum_modevent(module_t mod, modeventtype_t type, void *unused) if (!vinum_inactive(1)) /* is anything open? */ return EBUSY; /* yes, we can't do it */ vinum_conf.flags |= VF_STOPPING; /* note that we want to stop */ - sync(curproc, &dummyarg); /* write out buffers */ + sync(curthread, &dummyarg); /* write out buffers */ free_vinum(0); /* clean up */ #ifdef VINUMDEBUG if (total_malloced) { @@ -293,7 +293,7 @@ int vinumopen(dev_t dev, int flags, int fmt, - struct proc *p) + struct thread *td) { int error; unsigned int index; @@ -378,7 +378,7 @@ vinumopen(dev_t dev, } case VINUM_SUPERDEV_TYPE: - error = suser(p); /* are we root? */ + error = suser_td(td); /* are we root? */ if (error == 0) { /* yes, can do */ if (devminor == VINUM_DAEMON_DEV) /* daemon device */ vinum_conf.flags |= VF_DAEMONOPEN; /* we're open */ @@ -402,7 +402,7 @@ int vinumclose(dev_t dev, int flags, int fmt, - struct proc *p) + struct thread *td) { unsigned int index; struct volume *vol; diff --git a/sys/dev/vinum/vinumext.h b/sys/dev/vinum/vinumext.h index 9b96df8..9d98ee8 100644 --- a/sys/dev/vinum/vinumext.h +++ b/sys/dev/vinum/vinumext.h @@ -62,7 +62,7 @@ extern int debug; /* debug flags */ } #ifndef _KERNEL struct vnode; -struct proc; +struct thread; #endif #ifdef _KERNEL @@ -117,7 +117,7 @@ void remove_plex_entry(int plexno, int force, int recurse); void remove_volume_entry(int volno, int force, int recurse); void checkdiskconfig(char *); -int open_drive(struct drive *, struct proc *, int); +int open_drive(struct drive *, struct thread *, int); void close_drive(struct drive *drive); void close_locked_drive(struct drive *drive); int driveio(struct drive *, char *, size_t, off_t, int); @@ -245,7 +245,7 @@ void FFree(void *mem, char *, int); #define LOCKDRIVE(d) lockdrive (d, __FILE__, __LINE__) #else #define Malloc(x) malloc((x), M_DEVBUF, \ - curproc->p_intr_nesting_level == 0? M_WAITOK: M_NOWAIT) + curthread->td_proc->p_intr_nesting_level == 0? M_WAITOK: M_NOWAIT) #define Free(x) free((x), M_DEVBUF) #define LOCKDRIVE(d) lockdrive (d) #endif diff --git a/sys/dev/vinum/vinumio.c b/sys/dev/vinum/vinumio.c index 564d21c..f329137 100644 --- a/sys/dev/vinum/vinumio.c +++ b/sys/dev/vinum/vinumio.c @@ -49,7 +49,7 @@ static int drivecmp(const void *va, const void *vb); * Return an error number */ int -open_drive(struct drive *drive, struct proc *p, int verbose) +open_drive(struct drive *drive, struct thread *td, int verbose) { int devmajor; /* major devs for disk device */ int devminor; /* minor devs for disk device */ @@ -216,7 +216,7 @@ init_drive(struct drive *drive, int verbose) log(LOG_ERR, "vinum: Can't open drive without drive name\n"); return EINVAL; } - drive->lasterror = open_drive(drive, curproc, verbose); /* open the drive */ + drive->lasterror = open_drive(drive, curthread, verbose); /* open the drive */ if (drive->lasterror) return drive->lasterror; @@ -224,7 +224,7 @@ init_drive(struct drive *drive, int verbose) DIOCGPART, (caddr_t) & drive->partinfo, FREAD, - curproc); + curthread); if (drive->lasterror) { if (verbose) log(LOG_WARNING, @@ -669,7 +669,7 @@ daemon_save_config(void) DIOCWLABEL, (caddr_t) & wlabel_on, FWRITE, - curproc); + curthread); if (error == 0) error = write_drive(drive, (char *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET); if (error == 0) @@ -682,7 +682,7 @@ daemon_save_config(void) DIOCWLABEL, (caddr_t) & wlabel_on, FWRITE, - curproc); + curthread); unlockdrive(drive); if (error) { log(LOG_ERR, diff --git a/sys/dev/vinum/vinumioctl.c b/sys/dev/vinum/vinumioctl.c index bef310b..aeafdd2 100644 --- a/sys/dev/vinum/vinumioctl.c +++ b/sys/dev/vinum/vinumioctl.c @@ -66,7 +66,7 @@ vinumioctl(dev_t dev, u_long cmd, caddr_t data, int flag, - struct proc *p) + struct thread *td) { unsigned int objno; int error = 0; @@ -319,8 +319,8 @@ vinumioctl(dev_t dev, default: log(LOG_WARNING, "vinumioctl: invalid ioctl from process %d (%s): %lx\n", - curproc->p_pid, - curproc->p_comm, + curthread->td_proc->p_pid, + curthread->td_proc->p_comm, cmd); return EINVAL; diff --git a/sys/dev/vinum/vinummemory.c b/sys/dev/vinum/vinummemory.c index 5a2093b..6936e48 100644 --- a/sys/dev/vinum/vinummemory.c +++ b/sys/dev/vinum/vinummemory.c @@ -152,7 +152,7 @@ MMalloc(int size, char *file, int line) /* Wait for malloc if we can */ result = malloc(size, M_DEVBUF, - curproc->p_intr_nesting_level == 0 ? M_WAITOK : M_NOWAIT); + curthread->td_intr_nesting_level == 0 ? M_WAITOK : M_NOWAIT); if (result == NULL) log(LOG_ERR, "vinum: can't allocate %d bytes from %s:%d\n", size, file, line); else { diff --git a/sys/dev/wi/if_wi.c b/sys/dev/wi/if_wi.c index 9c7230f..19394c8 100644 --- a/sys/dev/wi/if_wi.c +++ b/sys/dev/wi/if_wi.c @@ -72,6 +72,7 @@ #include <sys/systm.h> #include <sys/sockio.h> #include <sys/mbuf.h> +#include <sys/proc.h> #include <sys/kernel.h> #include <sys/socket.h> #include <sys/module.h> diff --git a/sys/dev/wl/if_wl.c b/sys/dev/wl/if_wl.c index 0267d93..5ce3dc2 100644 --- a/sys/dev/wl/if_wl.c +++ b/sys/dev/wl/if_wl.c @@ -1145,7 +1145,7 @@ wlioctl(struct ifnet *ifp, u_long cmd, caddr_t data) short base = sc->base; short mode = 0; int opri, error = 0; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ int irq, irqval, i, isroot; caddr_t up; #ifdef WLCACHE @@ -1254,7 +1254,7 @@ wlioctl(struct ifnet *ifp, u_long cmd, caddr_t data) /* pointer to buffer in user space */ up = (void *)ifr->ifr_data; /* work out if they're root */ - isroot = (suser(p) == 0); + isroot = (suser_td(td) == 0); for (i = 0; i < 0x40; i++) { /* don't hand the DES key out to non-root users */ @@ -1269,7 +1269,7 @@ wlioctl(struct ifnet *ifp, u_long cmd, caddr_t data) /* copy the PSA in from the caller; we only copy _some_ values */ case SIOCSWLPSA: /* root only */ - if ((error = suser(p))) + if ((error = suser_td(td))) break; error = EINVAL; /* assume the worst */ /* pointer to buffer in user space containing data */ @@ -1323,7 +1323,7 @@ wlioctl(struct ifnet *ifp, u_long cmd, caddr_t data) */ case SIOCSWLCNWID: /* root only */ - if ((error = suser(p))) + if ((error = suser_td(td))) break; if (!(ifp->if_flags & IFF_UP)) { error = EIO; /* only allowed while up */ @@ -1341,7 +1341,7 @@ wlioctl(struct ifnet *ifp, u_long cmd, caddr_t data) /* copy the EEPROM in 2.4 Gz WaveMODEM out to the caller */ case SIOCGWLEEPROM: /* root only */ - if ((error = suser(p))) + if ((error = suser_td(td))) break; /* pointer to buffer in user space */ up = (void *)ifr->ifr_data; @@ -1364,7 +1364,7 @@ wlioctl(struct ifnet *ifp, u_long cmd, caddr_t data) /* zero (Delete) the wl cache */ case SIOCDWLCACHE: /* root only */ - if ((error = suser(p))) + if ((error = suser_td(td))) break; wl_cache_zero(unit); break; diff --git a/sys/fs/cd9660/cd9660_lookup.c b/sys/fs/cd9660/cd9660_lookup.c index b2d5057..979c0bd 100644 --- a/sys/fs/cd9660/cd9660_lookup.c +++ b/sys/fs/cd9660/cd9660_lookup.c @@ -120,7 +120,7 @@ cd9660_lookup(ap) struct componentname *cnp = ap->a_cnp; int flags = cnp->cn_flags; int nameiop = cnp->cn_nameiop; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; bp = NULL; *vpp = NULL; @@ -351,16 +351,16 @@ found: * it's a relocated directory. */ if (flags & ISDOTDOT) { - VOP_UNLOCK(pdp, 0, p); /* race to get the inode */ + VOP_UNLOCK(pdp, 0, td); /* race to get the inode */ error = cd9660_vget_internal(vdp->v_mount, dp->i_ino, &tdp, dp->i_ino != ino, ep); brelse(bp); if (error) { - vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, td); return (error); } if (lockparent && (flags & ISLASTCN)) { - if ((error = vn_lock(pdp, LK_EXCLUSIVE, p)) != 0) { + if ((error = vn_lock(pdp, LK_EXCLUSIVE, td)) != 0) { cnp->cn_flags |= PDIRUNLOCK; vput(tdp); return (error); @@ -380,7 +380,7 @@ found: return (error); if (!lockparent || !(flags & ISLASTCN)) { cnp->cn_flags |= PDIRUNLOCK; - VOP_UNLOCK(pdp, 0, p); + VOP_UNLOCK(pdp, 0, td); } *vpp = tdp; } diff --git a/sys/fs/cd9660/cd9660_node.c b/sys/fs/cd9660/cd9660_node.c index 00f79e8..53ffeca 100644 --- a/sys/fs/cd9660/cd9660_node.c +++ b/sys/fs/cd9660/cd9660_node.c @@ -97,7 +97,7 @@ cd9660_ihashget(dev, inum) dev_t dev; ino_t inum; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct iso_node *ip; struct vnode *vp; @@ -108,7 +108,7 @@ loop: vp = ITOV(ip); mtx_lock(&vp->v_interlock); mtx_unlock(&cd9660_ihash_mtx); - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) goto loop; return (vp); } @@ -124,7 +124,6 @@ void cd9660_ihashins(ip) struct iso_node *ip; { - struct proc *p = curproc; /* XXX */ struct iso_node **ipp, *iq; mtx_lock(&cd9660_ihash_mtx); @@ -136,7 +135,7 @@ cd9660_ihashins(ip) *ipp = ip; mtx_unlock(&cd9660_ihash_mtx); - lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, p); + lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, curthread); } /* @@ -167,11 +166,11 @@ int cd9660_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; register struct iso_node *ip = VTOI(vp); int error = 0; @@ -179,13 +178,13 @@ cd9660_inactive(ap) vprint("cd9660_inactive: pushing active", vp); ip->i_flag = 0; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); /* * If we are done with the inode, reclaim it * so that it can be reused immediately. */ if (ip->inode.iso_mode == 0) - vrecycle(vp, NULL, p); + vrecycle(vp, NULL, td); return error; } @@ -196,7 +195,7 @@ int cd9660_reclaim(ap) struct vop_reclaim_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; diff --git a/sys/fs/cd9660/cd9660_vfsops.c b/sys/fs/cd9660/cd9660_vfsops.c index 0b42933..73a5bce 100644 --- a/sys/fs/cd9660/cd9660_vfsops.c +++ b/sys/fs/cd9660/cd9660_vfsops.c @@ -65,10 +65,10 @@ MALLOC_DEFINE(M_ISOFSMNT, "ISOFS mount", "ISOFS mount structure"); MALLOC_DEFINE(M_ISOFSNODE, "ISOFS node", "ISOFS vnode private part"); static int cd9660_mount __P((struct mount *, - char *, caddr_t, struct nameidata *, struct proc *)); -static int cd9660_unmount __P((struct mount *, int, struct proc *)); + char *, caddr_t, struct nameidata *, struct thread *)); +static int cd9660_unmount __P((struct mount *, int, struct thread *)); static int cd9660_root __P((struct mount *, struct vnode **)); -static int cd9660_statfs __P((struct mount *, struct statfs *, struct proc *)); +static int cd9660_statfs __P((struct mount *, struct statfs *, struct thread *)); static int cd9660_vget __P((struct mount *, ino_t, struct vnode **)); static int cd9660_fhtovp __P((struct mount *, struct fid *, struct vnode **)); static int cd9660_vptofh __P((struct vnode *, struct fid *)); @@ -97,9 +97,9 @@ MODULE_VERSION(cd9660, 1); * Called by vfs_mountroot when iso is going to be mounted as root. */ -static int iso_get_ssector __P((dev_t dev, struct proc *p)); +static int iso_get_ssector __P((dev_t dev, struct thread *td)); static int iso_mountfs __P((struct vnode *devvp, struct mount *mp, - struct proc *p, struct iso_args *argp)); + struct thread *td, struct iso_args *argp)); /* * Try to find the start of the last data track on this CD-ROM. This @@ -107,9 +107,9 @@ static int iso_mountfs __P((struct vnode *devvp, struct mount *mp, * and return 0 if we fail, this is always a safe bet. */ static int -iso_get_ssector(dev, p) +iso_get_ssector(dev, td) dev_t dev; - struct proc *p; + struct thread *td; { struct ioc_toc_header h; struct ioc_read_toc_single_entry t; @@ -122,13 +122,13 @@ iso_get_ssector(dev, p) if (ioctlp == NULL) return 0; - if (ioctlp(dev, CDIOREADTOCHEADER, (caddr_t)&h, FREAD, p) != 0) + if (ioctlp(dev, CDIOREADTOCHEADER, (caddr_t)&h, FREAD, td) != 0) return 0; for (i = h.ending_track; i >= 0; i--) { t.address_format = CD_LBA_FORMAT; t.track = i; - if (ioctlp(dev, CDIOREADTOCENTRY, (caddr_t)&t, FREAD, p) != 0) + if (ioctlp(dev, CDIOREADTOCENTRY, (caddr_t)&t, FREAD, td) != 0) return 0; if ((t.entry.control & 4) != 0) /* found a data track */ @@ -141,12 +141,12 @@ iso_get_ssector(dev, p) return ntohl(t.entry.addr.lba); } -static int iso_mountroot __P((struct mount *mp, struct proc *p)); +static int iso_mountroot __P((struct mount *mp, struct thread *td)); static int -iso_mountroot(mp, p) +iso_mountroot(mp, td) struct mount *mp; - struct proc *p; + struct thread *td; { struct iso_args args; int error; @@ -156,14 +156,14 @@ iso_mountroot(mp, p) return (error); } args.flags = ISOFSMNT_ROOT; - args.ssector = iso_get_ssector(rootdev, p); + args.ssector = iso_get_ssector(rootdev, td); if (bootverbose) printf("iso_mountroot(): using session at block %d\n", args.ssector); - if ((error = iso_mountfs(rootvp, mp, p, &args)) != 0) + if ((error = iso_mountfs(rootvp, mp, td, &args)) != 0) return (error); - (void)cd9660_statfs(mp, &mp->mnt_stat, p); + (void)cd9660_statfs(mp, &mp->mnt_stat, td); return (0); } @@ -173,12 +173,12 @@ iso_mountroot(mp, p) * mount system call */ static int -cd9660_mount(mp, path, data, ndp, p) +cd9660_mount(mp, path, data, ndp, td) register struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { struct vnode *devvp; struct iso_args args; @@ -188,7 +188,7 @@ cd9660_mount(mp, path, data, ndp, p) struct iso_mnt *imp = 0; if ((mp->mnt_flag & MNT_ROOTFS) != 0) { - return (iso_mountroot(mp, p)); + return (iso_mountroot(mp, td)); } if ((error = copyin(data, (caddr_t)&args, sizeof (struct iso_args)))) return (error); @@ -209,7 +209,7 @@ cd9660_mount(mp, path, data, ndp, p) * Not an update, or updating the name: look up the name * and verify that it refers to a sensible block device. */ - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, td); if ((error = namei(ndp))) return (error); NDFREE(ndp, NDF_ONLY_PNBUF); @@ -225,18 +225,18 @@ cd9660_mount(mp, path, data, ndp, p) * or has superuser abilities */ accessmode = VREAD; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_ACCESS(devvp, accessmode, td->td_proc->p_ucred, td); if (error) - error = suser(p); + error = suser_td(td); if (error) { vput(devvp); return (error); } - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); if ((mp->mnt_flag & MNT_UPDATE) == 0) { - error = iso_mountfs(devvp, mp, p, &args); + error = iso_mountfs(devvp, mp, td, &args); } else { if (devvp != imp->im_devvp) error = EINVAL; /* needs translation */ @@ -251,7 +251,7 @@ cd9660_mount(mp, path, data, ndp, p) (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void) cd9660_statfs(mp, &mp->mnt_stat, p); + (void) cd9660_statfs(mp, &mp->mnt_stat, td); return 0; } @@ -259,10 +259,10 @@ cd9660_mount(mp, path, data, ndp, p) * Common code for mount and mountroot */ static int -iso_mountfs(devvp, mp, p, argp) +iso_mountfs(devvp, mp, td, argp) register struct vnode *devvp; struct mount *mp; - struct proc *p; + struct thread *td; struct iso_args *argp; { register struct iso_mnt *isomp = (struct iso_mnt *)0; @@ -295,12 +295,12 @@ iso_mountfs(devvp, mp, p, argp) return error; if (vcount(devvp) > 1 && devvp != rootvp) return EBUSY; - if ((error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0))) + if ((error = vinvalbuf(devvp, V_SAVE, td->td_proc->p_ucred, td, 0, 0))) return (error); - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_OPEN(devvp, FREAD, FSCRED, p); - VOP_UNLOCK(devvp, 0, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(devvp, FREAD, FSCRED, td); + VOP_UNLOCK(devvp, 0, td); if (error) return error; @@ -510,7 +510,7 @@ out: if (supbp) brelse(supbp); if (needclose) - (void)VOP_CLOSE(devvp, FREAD, NOCRED, p); + (void)VOP_CLOSE(devvp, FREAD, NOCRED, td); if (isomp) { free((caddr_t)isomp, M_ISOFSMNT); mp->mnt_data = (qaddr_t)0; @@ -522,10 +522,10 @@ out: * unmount system call */ static int -cd9660_unmount(mp, mntflags, p) +cd9660_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { register struct iso_mnt *isomp; int error, flags = 0; @@ -543,7 +543,7 @@ cd9660_unmount(mp, mntflags, p) isomp = VFSTOISOFS(mp); isomp->im_devvp->v_rdev->si_mountpoint = NULL; - error = VOP_CLOSE(isomp->im_devvp, FREAD, NOCRED, p); + error = VOP_CLOSE(isomp->im_devvp, FREAD, NOCRED, td); vrele(isomp->im_devvp); free((caddr_t)isomp, M_ISOFSMNT); mp->mnt_data = (qaddr_t)0; @@ -576,10 +576,10 @@ cd9660_root(mp, vpp) * Get file system statistics. */ int -cd9660_statfs(mp, sbp, p) +cd9660_statfs(mp, sbp, td) struct mount *mp; register struct statfs *sbp; - struct proc *p; + struct thread *td; { register struct iso_mnt *isomp; diff --git a/sys/fs/cd9660/cd9660_vnops.c b/sys/fs/cd9660/cd9660_vnops.c index 702823e..a902b58 100644 --- a/sys/fs/cd9660/cd9660_vnops.c +++ b/sys/fs/cd9660/cd9660_vnops.c @@ -87,7 +87,7 @@ cd9660_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -128,7 +128,7 @@ cd9660_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -162,7 +162,7 @@ cd9660_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { @@ -197,7 +197,7 @@ cd9660_getattr(ap) auio.uio_offset = 0; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = ap->a_p; + auio.uio_td = ap->a_td; auio.uio_resid = MAXPATHLEN; rdlnk.a_uio = &auio; rdlnk.a_vp = ap->a_vp; @@ -226,7 +226,7 @@ cd9660_ioctl(ap) caddr_t a_data; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; diff --git a/sys/fs/coda/coda_psdev.c b/sys/fs/coda/coda_psdev.c index 0d8560f..2346c7c 100644 --- a/sys/fs/coda/coda_psdev.c +++ b/sys/fs/coda/coda_psdev.c @@ -117,11 +117,11 @@ vcodaattach(n) } int -vc_nb_open(dev, flag, mode, p) +vc_nb_open(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; /* NetBSD only */ + struct thread *td; /* NetBSD only */ { register struct vcomm *vcp; @@ -149,11 +149,11 @@ vc_nb_open(dev, flag, mode, p) } int -vc_nb_close (dev, flag, mode, p) +vc_nb_close (dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { register struct vcomm *vcp; register struct vmsg *vmp, *nvmp = NULL; @@ -225,7 +225,7 @@ vc_nb_close (dev, flag, mode, p) #endif } - err = dounmount(mi->mi_vfsp, flag, p); + err = dounmount(mi->mi_vfsp, flag, td); if (err) myprintf(("Error %d unmounting vfs in vcclose(%d)\n", err, minor(dev))); @@ -387,12 +387,12 @@ vc_nb_write(dev, uiop, flag) } int -vc_nb_ioctl(dev, cmd, addr, flag, p) +vc_nb_ioctl(dev, cmd, addr, flag, td) dev_t dev; u_long cmd; caddr_t addr; int flag; - struct proc *p; + struct thread *td; { ENTRY; @@ -441,10 +441,10 @@ vc_nb_ioctl(dev, cmd, addr, flag, p) } int -vc_nb_poll(dev, events, p) +vc_nb_poll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { register struct vcomm *vcp; int event_msk = 0; @@ -463,7 +463,7 @@ vc_nb_poll(dev, events, p) if (!EMPTY(vcp->vc_requests)) return(events & (POLLIN|POLLRDNORM)); - selrecord(p, &(vcp->vc_selproc)); + selrecord(curthread, &(vcp->vc_selproc)); return(0); } @@ -490,7 +490,8 @@ coda_call(mntinfo, inSize, outSize, buffer) struct vmsg *vmp; int error; #ifdef CTL_C - struct proc *p = curproc; + struct thread *td = curthread; + struct proc *p = td->td_proc; sigset_t psig_omask; sigset_t tempset; int i; diff --git a/sys/fs/coda/coda_psdev.h b/sys/fs/coda/coda_psdev.h index c6276f3..c6ecf7f 100644 --- a/sys/fs/coda/coda_psdev.h +++ b/sys/fs/coda/coda_psdev.h @@ -31,9 +31,9 @@ * */ -int vc_nb_open(dev_t dev, int flag, int mode, struct proc *p); -int vc_nb_close (dev_t dev, int flag, int mode, struct proc *p); +int vc_nb_open(dev_t dev, int flag, int mode, struct thread *p); +int vc_nb_close (dev_t dev, int flag, int mode, struct thread *p); int vc_nb_read(dev_t dev, struct uio *uiop, int flag); int vc_nb_write(dev_t dev, struct uio *uiop, int flag); -int vc_nb_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p); -int vc_nb_poll(dev_t dev, int events, struct proc *p); +int vc_nb_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *p); +int vc_nb_poll(dev_t dev, int events, struct thread *p); diff --git a/sys/fs/coda/coda_vfsops.c b/sys/fs/coda/coda_vfsops.c index 8bcd36f..d01d5a7 100644 --- a/sys/fs/coda/coda_vfsops.c +++ b/sys/fs/coda/coda_vfsops.c @@ -83,7 +83,7 @@ struct coda_op_stats coda_vfsopstats[CODA_VFSOPS_SIZE]; #define MRAK_INT_GEN(op) (coda_vfsopstats[op].gen_intrn++) extern int coda_nc_initialized; /* Set if cache has been initialized */ -extern int vc_nb_open __P((dev_t, int, int, struct proc *)); +extern int vc_nb_open __P((dev_t, int, int, struct thread *)); int coda_vfsopstats_init(void) @@ -107,12 +107,12 @@ coda_vfsopstats_init(void) */ /*ARGSUSED*/ int -coda_mount(vfsp, path, data, ndp, p) +coda_mount(vfsp, path, data, ndp, td) struct mount *vfsp; /* Allocated and initialized by mount(2) */ char *path; /* path covered: ignored by the fs-layer */ caddr_t data; /* Need to define a data type for this in netbsd? */ struct nameidata *ndp; /* Clobber this to lookup the device name */ - struct proc *p; /* The ever-famous proc pointer */ + struct thread *td; /* The ever-famous proc pointer */ { struct vnode *dvp; struct cnode *cp; @@ -135,7 +135,7 @@ coda_mount(vfsp, path, data, ndp, p) } /* Validate mount device. Similar to getmdev(). */ - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, data, p); + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, data, td); error = namei(ndp); dvp = ndp->ni_vp; @@ -233,10 +233,10 @@ coda_mount(vfsp, path, data, ndp, p) } int -coda_unmount(vfsp, mntflags, p) +coda_unmount(vfsp, mntflags, td) struct mount *vfsp; int mntflags; - struct proc *p; + struct thread *td; { struct coda_mntinfo *mi = vftomi(vfsp); int active, error = 0; @@ -292,8 +292,12 @@ coda_root(vfsp, vpp) struct coda_mntinfo *mi = vftomi(vfsp); struct vnode **result; int error; - struct proc *p = curproc; /* XXX - bnoble */ + struct thread *td = curthread; /* XXX - bnoble */ + struct proc *p = td->td_proc; ViceFid VFid; + + ENTRY; + ENTRY; MARK_ENTRY(CODA_ROOT_STATS); @@ -308,9 +312,9 @@ coda_root(vfsp, vpp) /* On Mach, this is vref. On NetBSD, VOP_LOCK */ #if 1 vref(*vpp); - vn_lock(*vpp, LK_EXCLUSIVE, p); + vn_lock(*vpp, LK_EXCLUSIVE, td); #else - vget(*vpp, LK_EXCLUSIVE, p); + vget(*vpp, LK_EXCLUSIVE, td); #endif MARK_INT_SAT(CODA_ROOT_STATS); return(0); @@ -331,9 +335,9 @@ coda_root(vfsp, vpp) *vpp = mi->mi_rootvp; #if 1 vref(*vpp); - vn_lock(*vpp, LK_EXCLUSIVE, p); + vn_lock(*vpp, LK_EXCLUSIVE, td); #else - vget(*vpp, LK_EXCLUSIVE, p); + vget(*vpp, LK_EXCLUSIVE, td); #endif MARK_INT_SAT(CODA_ROOT_STATS); @@ -351,9 +355,9 @@ coda_root(vfsp, vpp) *vpp = mi->mi_rootvp; #if 1 vref(*vpp); - vn_lock(*vpp, LK_EXCLUSIVE, p); + vn_lock(*vpp, LK_EXCLUSIVE, td); #else - vget(*vpp, LK_EXCLUSIVE, p); + vget(*vpp, LK_EXCLUSIVE, td); #endif MARK_INT_FAIL(CODA_ROOT_STATS); @@ -374,10 +378,10 @@ coda_root(vfsp, vpp) * Get file system statistics. */ int -coda_nb_statfs(vfsp, sbp, p) +coda_nb_statfs(vfsp, sbp, td) register struct mount *vfsp; struct statfs *sbp; - struct proc *p; + struct thread *td; { ENTRY; /* MARK_ENTRY(CODA_STATFS_STATS); */ @@ -412,11 +416,11 @@ coda_nb_statfs(vfsp, sbp, p) * Flush any pending I/O. */ int -coda_sync(vfsp, waitfor, cred, p) +coda_sync(vfsp, waitfor, cred, td) struct mount *vfsp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { ENTRY; MARK_ENTRY(CODA_SYNC_STATS); @@ -441,7 +445,8 @@ coda_fhtovp(vfsp, fhp, nam, vpp, exflagsp, creadanonp) struct cfid *cfid = (struct cfid *)fhp; struct cnode *cp = 0; int error; - struct proc *p = curproc; /* XXX -mach */ + struct thread *td = curthread; /* XXX -mach */ + struct proc *p = td->td_proc; ViceFid VFid; int vtype; diff --git a/sys/fs/coda/coda_vfsops.h b/sys/fs/coda/coda_vfsops.h index 7fc9adf..57b9a5a 100644 --- a/sys/fs/coda/coda_vfsops.h +++ b/sys/fs/coda/coda_vfsops.h @@ -48,13 +48,13 @@ struct mount; int coda_vfsopstats_init(void); int coda_mount(struct mount *, char *, caddr_t, struct nameidata *, - struct proc *); -int coda_start(struct mount *, int, struct proc *); -int coda_unmount(struct mount *, int, struct proc *); + struct thread *); +int coda_start(struct mount *, int, struct thread *); +int coda_unmount(struct mount *, int, struct thread *); int coda_root(struct mount *, struct vnode **); -int coda_quotactl(struct mount *, int, uid_t, caddr_t, struct proc *); -int coda_nb_statfs(struct mount *, struct statfs *, struct proc *); -int coda_sync(struct mount *, int, struct ucred *, struct proc *); +int coda_quotactl(struct mount *, int, uid_t, caddr_t, struct thread *); +int coda_nb_statfs(struct mount *, struct statfs *, struct thread *); +int coda_sync(struct mount *, int, struct ucred *, struct thread *); int coda_vget(struct mount *, ino_t, struct vnode **); int coda_fhtovp(struct mount *, struct fid *, struct mbuf *, struct vnode **, int *, struct ucred **); diff --git a/sys/fs/coda/coda_vnops.c b/sys/fs/coda/coda_vnops.c index dd0a96e..8fd7170d 100644 --- a/sys/fs/coda/coda_vnops.c +++ b/sys/fs/coda/coda_vnops.c @@ -235,7 +235,7 @@ coda_open(v) struct cnode *cp = VTOC(*vpp); int flag = ap->a_mode & (~O_EXCL); struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; struct vnode *vp; @@ -256,7 +256,7 @@ coda_open(v) return(0); } - error = venus_open(vtomi((*vpp)), &cp->c_fid, flag, cred, p, &dev, &inode); + error = venus_open(vtomi((*vpp)), &cp->c_fid, flag, cred, td->td_proc, &dev, &inode); if (error) return (error); if (!error) { @@ -272,7 +272,7 @@ coda_open(v) return (error); /* We get the vnode back locked. Needs unlocked */ - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); /* Keep a reference until the close comes in. */ vref(*vpp); @@ -297,14 +297,14 @@ coda_open(v) cp->c_inode = inode; /* Open the cache file. */ - error = VOP_OPEN(vp, flag, cred, p); + error = VOP_OPEN(vp, flag, cred, td); if (error) { printf("coda_open: VOP_OPEN on container failed %d\n", error); return (error); } /* grab (above) does this when it calls newvnode unless it's in the cache*/ if (vp->v_type == VREG) { - error = vfs_object_create(vp, p, cred); + error = vfs_object_create(vp, td, cred); if (error != 0) { printf("coda_open: vfs_object_create() returns %d\n", error); vput(vp); @@ -327,7 +327,7 @@ coda_close(v) struct cnode *cp = VTOC(vp); int flag = ap->a_fflag; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; @@ -348,7 +348,7 @@ coda_close(v) #ifdef hmm vgone(cp->c_ovp); #else - VOP_CLOSE(cp->c_ovp, flag, cred, p); /* Do errors matter here? */ + VOP_CLOSE(cp->c_ovp, flag, cred, td); /* Do errors matter here? */ vrele(cp->c_ovp); #endif } else { @@ -358,7 +358,7 @@ coda_close(v) } return ENODEV; } else { - VOP_CLOSE(cp->c_ovp, flag, cred, p); /* Do errors matter here? */ + VOP_CLOSE(cp->c_ovp, flag, cred, td); /* Do errors matter here? */ vrele(cp->c_ovp); } @@ -368,7 +368,7 @@ coda_close(v) if (flag & FWRITE) /* file was opened for write */ --cp->c_owrite; - error = venus_close(vtomi(vp), &cp->c_fid, flag, cred, p); + error = venus_close(vtomi(vp), &cp->c_fid, flag, cred, td->td_proc); vrele(CTOV(cp)); CODADEBUG(CODA_CLOSE, myprintf(("close: result %d\n",error)); ) @@ -383,7 +383,7 @@ coda_read(v) ENTRY; return(coda_rdwr(ap->a_vp, ap->a_uio, UIO_READ, - ap->a_ioflag, ap->a_cred, ap->a_uio->uio_procp)); + ap->a_ioflag, ap->a_cred, ap->a_uio->uio_td)); } int @@ -394,24 +394,25 @@ coda_write(v) ENTRY; return(coda_rdwr(ap->a_vp, ap->a_uio, UIO_WRITE, - ap->a_ioflag, ap->a_cred, ap->a_uio->uio_procp)); + ap->a_ioflag, ap->a_cred, ap->a_uio->uio_td)); } int -coda_rdwr(vp, uiop, rw, ioflag, cred, p) +coda_rdwr(vp, uiop, rw, ioflag, cred, td) struct vnode *vp; struct uio *uiop; enum uio_rw rw; int ioflag; struct ucred *cred; - struct proc *p; + struct thread *td; { /* upcall decl */ /* NOTE: container file operation!!! */ /* locals */ struct cnode *cp = VTOC(vp); struct vnode *cfvp = cp->c_ovp; - struct proc *lp = p; + struct proc *p = td->td_proc; + struct thread *ltd = td; int igot_internally = 0; int opened_internally = 0; int error = 0; @@ -448,7 +449,7 @@ coda_rdwr(vp, uiop, rw, ioflag, cred, p) PROC_UNLOCK(p); } else - lp = curproc; + ltd = curthread; if (cp->c_inode != 0 && !iscore) { igot_internally = 1; @@ -458,23 +459,23 @@ coda_rdwr(vp, uiop, rw, ioflag, cred, p) return(error); } /* - * We get the vnode back locked by curproc in both Mach and + * We get the vnode back locked by curthread in both Mach and * NetBSD. Needs unlocked */ - VOP_UNLOCK(cfvp, 0, lp); + VOP_UNLOCK(cfvp, 0, ltd); } else { opened_internally = 1; MARK_INT_GEN(CODA_OPEN_STATS); error = VOP_OPEN(vp, (rw == UIO_READ ? FREAD : FWRITE), - cred, p); + cred, td); printf("coda_rdwr: Internally Opening %p\n", vp); if (error) { printf("coda_rdwr: VOP_OPEN on container failed %d\n", error); return (error); } if (vp->v_type == VREG) { - error = vfs_object_create(vp, p, cred); + error = vfs_object_create(vp, td, cred); if (error != 0) { printf("coda_rdwr: vfs_object_create() returns %d\n", error); vput(vp); @@ -501,7 +502,7 @@ printf("coda_rdwr: Internally Opening %p\n", vp); { struct vattr attr; - if (VOP_GETATTR(cfvp, &attr, cred, p) == 0) { + if (VOP_GETATTR(cfvp, &attr, cred, td) == 0) { vnode_pager_setsize(vp, attr.va_size); } } @@ -515,7 +516,7 @@ printf("coda_rdwr: Internally Opening %p\n", vp); /* Do an internal close if necessary. */ if (opened_internally) { MARK_INT_GEN(CODA_CLOSE_STATS); - (void)VOP_CLOSE(vp, (rw == UIO_READ ? FREAD : FWRITE), cred, p); + (void)VOP_CLOSE(vp, (rw == UIO_READ ? FREAD : FWRITE), cred, td); } /* Invalidate cached attributes if writing. */ @@ -537,7 +538,7 @@ coda_ioctl(v) caddr_t data = ap->a_data; int flag = ap->a_fflag; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; struct vnode *tvp; @@ -562,7 +563,7 @@ coda_ioctl(v) /* Should we use the name cache here? It would get it from lookupname sooner or later anyway, right? */ - NDINIT(&ndp, LOOKUP, (iap->follow ? FOLLOW : NOFOLLOW), UIO_USERSPACE, iap->path, p); + NDINIT(&ndp, LOOKUP, (iap->follow ? FOLLOW : NOFOLLOW), UIO_USERSPACE, iap->path, td); error = namei(&ndp); tvp = ndp.ni_vp; @@ -591,7 +592,7 @@ coda_ioctl(v) NDFREE(&ndp, 0); return(EINVAL); } - error = venus_ioctl(vtomi(tvp), &((VTOC(tvp))->c_fid), com, flag, data, cred, p); + error = venus_ioctl(vtomi(tvp), &((VTOC(tvp))->c_fid), com, flag, data, cred, td->td_proc); if (error) MARK_INT_FAIL(CODA_IOCTL_STATS); @@ -622,7 +623,7 @@ coda_getattr(v) struct cnode *cp = VTOC(vp); struct vattr *vap = ap->a_vap; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; @@ -651,7 +652,7 @@ coda_getattr(v) return(0); } - error = venus_getattr(vtomi(vp), &cp->c_fid, cred, p, vap); + error = venus_getattr(vtomi(vp), &cp->c_fid, cred, td->td_proc, vap); if (!error) { CODADEBUG(CODA_GETATTR, myprintf(("getattr miss (%lx.%lx.%lx): result %d\n", @@ -689,7 +690,7 @@ coda_setattr(v) struct cnode *cp = VTOC(vp); register struct vattr *vap = ap->a_vap; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; @@ -704,7 +705,7 @@ coda_setattr(v) if (codadebug & CODADBGMSK(CODA_SETATTR)) { print_vattr(vap); } - error = venus_setattr(vtomi(vp), &cp->c_fid, vap, cred, p); + error = venus_setattr(vtomi(vp), &cp->c_fid, vap, cred, td->td_proc); if (!error) cp->c_flags &= ~C_VATTR; @@ -729,7 +730,7 @@ coda_access(v) struct cnode *cp = VTOC(vp); int mode = ap->a_mode; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ int error; @@ -758,7 +759,7 @@ coda_access(v) } } - error = venus_access(vtomi(vp), &cp->c_fid, mode, cred, p); + error = venus_access(vtomi(vp), &cp->c_fid, mode, cred, td->td_proc); return(error); } @@ -773,7 +774,7 @@ coda_readlink(v) struct cnode *cp = VTOC(vp); struct uio *uiop = ap->a_uio; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_uio->uio_procp; + struct thread *td = ap->a_uio->uio_td; /* locals */ int error; char *str; @@ -797,7 +798,7 @@ coda_readlink(v) return(error); } - error = venus_readlink(vtomi(vp), &cp->c_fid, cred, p, &str, &len); + error = venus_readlink(vtomi(vp), &cp->c_fid, cred, td->td_proc, &str, &len); if (!error) { uiop->uio_rw = UIO_READ; @@ -824,7 +825,7 @@ coda_fsync(v) struct vnode *vp = ap->a_vp; struct cnode *cp = VTOC(vp); struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* locals */ struct vnode *convp = cp->c_ovp; int error; @@ -847,7 +848,7 @@ coda_fsync(v) } if (convp) - VOP_FSYNC(convp, cred, MNT_WAIT, p); + VOP_FSYNC(convp, cred, MNT_WAIT, td); /* * We see fsyncs with usecount == 1 then usecount == 0. @@ -873,7 +874,7 @@ coda_fsync(v) /* needs research */ return 0; - error = venus_fsync(vtomi(vp), &cp->c_fid, cred, p); + error = venus_fsync(vtomi(vp), &cp->c_fid, cred, td->td_proc); CODADEBUG(CODA_FSYNC, myprintf(("in fsync result %d\n",error)); ); return(error); @@ -890,7 +891,7 @@ coda_inactive(v) struct vnode *vp = ap->a_vp; struct cnode *cp = VTOC(vp); struct ucred *cred __attribute__((unused)) = NULL; - struct proc *p __attribute__((unused)) = curproc; + struct thread *td __attribute__((unused)) = curthread; /* upcall decl */ /* locals */ @@ -930,7 +931,7 @@ coda_inactive(v) printf("coda_inactive: cp->ovp != NULL use %d: vp %p, cp %p\n", vp->v_usecount, vp, cp); #endif - lockmgr(&cp->c_lock, LK_RELEASE, &vp->v_interlock, p); + lockmgr(&cp->c_lock, LK_RELEASE, &vp->v_interlock, td); } else { #ifdef OLD_DIAGNOSTIC if (CTOV(cp)->v_usecount) { @@ -940,7 +941,7 @@ coda_inactive(v) panic("coda_inactive: cp->ovp != NULL"); } #endif - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vgone(vp); } @@ -972,7 +973,7 @@ coda_lookup(v) */ struct componentname *cnp = ap->a_cnp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* locals */ struct cnode *cp; const char *nm = cnp->cn_nameptr; @@ -1015,7 +1016,7 @@ coda_lookup(v) } else { /* The name wasn't cached, so we need to contact Venus */ - error = venus_lookup(vtomi(dvp), &dcp->c_fid, nm, len, cred, p, &VFid, &vtype); + error = venus_lookup(vtomi(dvp), &dcp->c_fid, nm, len, cred, td->td_proc, &VFid, &vtype); if (error) { MARK_INT_FAIL(CODA_LOOKUP_STATS); @@ -1086,7 +1087,7 @@ coda_lookup(v) */ if (!error || (error == EJUSTRETURN)) { if (!(cnp->cn_flags & LOCKPARENT) || !(cnp->cn_flags & ISLASTCN)) { - if ((error = VOP_UNLOCK(dvp, 0, p))) { + if ((error = VOP_UNLOCK(dvp, 0, td))) { return error; } /* @@ -1094,7 +1095,7 @@ coda_lookup(v) * lock it without bothering to check anything else. */ if (*ap->a_vpp) { - if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, p))) { + if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, td))) { printf("coda_lookup: "); panic("unlocked parent but couldn't lock child"); } @@ -1103,7 +1104,7 @@ coda_lookup(v) /* The parent is locked, and may be the same as the child */ if (*ap->a_vpp && (*ap->a_vpp != dvp)) { /* Different, go ahead and lock it. */ - if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, p))) { + if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, td))) { printf("coda_lookup: "); panic("unlocked parent but couldn't lock child"); } @@ -1132,7 +1133,7 @@ coda_create(v) struct vnode **vpp = ap->a_vpp; struct componentname *cnp = ap->a_cnp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* locals */ int error; struct cnode *cp; @@ -1153,7 +1154,7 @@ coda_create(v) return(EACCES); } - error = venus_create(vtomi(dvp), &dcp->c_fid, nm, len, exclusive, mode, va, cred, p, &VFid, &attr); + error = venus_create(vtomi(dvp), &dcp->c_fid, nm, len, exclusive, mode, va, cred, td->td_proc, &VFid, &attr); if (!error) { @@ -1192,7 +1193,7 @@ coda_create(v) if (!error) { if (cnp->cn_flags & LOCKLEAF) { - if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, p))) { + if ((error = VOP_LOCK(*ap->a_vpp, LK_EXCLUSIVE, td))) { printf("coda_create: "); panic("unlocked parent but couldn't lock child"); } @@ -1216,7 +1217,7 @@ coda_remove(v) struct cnode *cp = VTOC(dvp); struct componentname *cnp = ap->a_cnp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* locals */ int error; const char *nm = cnp->cn_nameptr; @@ -1259,7 +1260,7 @@ coda_remove(v) return(ENOENT); } - error = venus_remove(vtomi(dvp), &cp->c_fid, nm, len, cred, p); + error = venus_remove(vtomi(dvp), &cp->c_fid, nm, len, cred, td->td_proc); CODADEBUG(CODA_REMOVE, myprintf(("in remove result %d\n",error)); ) @@ -1278,7 +1279,7 @@ coda_link(v) struct cnode *tdcp = VTOC(tdvp); struct componentname *cnp = ap->a_cnp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* locals */ int error; const char *nm = cnp->cn_nameptr; @@ -1308,7 +1309,7 @@ coda_link(v) return(EACCES); } - error = venus_link(vtomi(vp), &cp->c_fid, &tdcp->c_fid, nm, len, cred, p); + error = venus_link(vtomi(vp), &cp->c_fid, &tdcp->c_fid, nm, len, cred, td->td_proc); /* Invalidate the parent's attr cache, the modification time has changed */ VTOC(tdvp)->c_flags &= ~C_VATTR; @@ -1332,7 +1333,7 @@ coda_rename(v) struct cnode *ndcp = VTOC(ndvp); struct componentname *tcnp = ap->a_tcnp; struct ucred *cred = fcnp->cn_cred; - struct proc *p = fcnp->cn_proc; + struct thread *td = fcnp->cn_thread; /* true args */ int error; const char *fnm = fcnp->cn_nameptr; @@ -1346,7 +1347,7 @@ coda_rename(v) This could be Bad. XXX */ #ifdef OLD_DIAGNOSTIC if ((fcnp->cn_cred != tcnp->cn_cred) - || (fcnp->cn_proc != tcnp->cn_proc)) + || (fcnp->cn_thread != tcnp->cn_thread)) { panic("coda_rename: component names don't agree"); } @@ -1389,7 +1390,7 @@ coda_rename(v) goto exit; } - error = venus_rename(vtomi(odvp), &odcp->c_fid, &ndcp->c_fid, fnm, flen, tnm, tlen, cred, p); + error = venus_rename(vtomi(odvp), &odcp->c_fid, &ndcp->c_fid, fnm, flen, tnm, tlen, cred, td->td_proc); exit: CODADEBUG(CODA_RENAME, myprintf(("in rename result %d\n",error));) @@ -1426,7 +1427,7 @@ coda_mkdir(v) register struct vattr *va = ap->a_vap; struct vnode **vpp = ap->a_vpp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* locals */ int error; const char *nm = cnp->cn_nameptr; @@ -1450,7 +1451,7 @@ coda_mkdir(v) return(EACCES); } - error = venus_mkdir(vtomi(dvp), &dcp->c_fid, nm, len, va, cred, p, &VFid, &ova); + error = venus_mkdir(vtomi(dvp), &dcp->c_fid, nm, len, va, cred, td->td_proc, &VFid, &ova); if (!error) { if (coda_find(&VFid) != NULL) @@ -1495,7 +1496,7 @@ coda_rmdir(v) struct cnode *dcp = VTOC(dvp); struct componentname *cnp = ap->a_cnp; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* true args */ int error; const char *nm = cnp->cn_nameptr; @@ -1527,7 +1528,7 @@ coda_rmdir(v) /* Invalidate the parent's attr cache, the modification time has changed */ dcp->c_flags &= ~C_VATTR; - error = venus_rmdir(vtomi(dvp), &dcp->c_fid, nm, len, cred, p); + error = venus_rmdir(vtomi(dvp), &dcp->c_fid, nm, len, cred, td->td_proc); CODADEBUG(CODA_RMDIR, myprintf(("in rmdir result %d\n", error)); ) @@ -1546,7 +1547,7 @@ coda_symlink(v) struct vattr *tva = ap->a_vap; char *path = ap->a_target; struct ucred *cred = cnp->cn_cred; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct vnode **vpp = ap->a_vpp; /* locals */ int error; @@ -1589,7 +1590,7 @@ coda_symlink(v) goto exit; } - error = venus_symlink(vtomi(tdvp), &tdcp->c_fid, path, plen, nm, len, tva, cred, p); + error = venus_symlink(vtomi(tdvp), &tdcp->c_fid, path, plen, nm, len, tva, cred, td->td_proc); /* Invalidate the parent's attr cache, the modification time has changed */ tdcp->c_flags &= ~C_VATTR; @@ -1618,7 +1619,7 @@ coda_readdir(v) int *eofflag = ap->a_eofflag; u_long **cookies = ap->a_cookies; int *ncookies = ap->a_ncookies; - struct proc *p = ap->a_uio->uio_procp; + struct thread *td = ap->a_uio->uio_td; /* upcall decl */ /* locals */ int error = 0; @@ -1643,14 +1644,14 @@ coda_readdir(v) if (cp->c_ovp == NULL) { opened_internally = 1; MARK_INT_GEN(CODA_OPEN_STATS); - error = VOP_OPEN(vp, FREAD, cred, p); + error = VOP_OPEN(vp, FREAD, cred, td); printf("coda_readdir: Internally Opening %p\n", vp); if (error) { printf("coda_readdir: VOP_OPEN on container failed %d\n", error); return (error); } if (vp->v_type == VREG) { - error = vfs_object_create(vp, p, cred); + error = vfs_object_create(vp, td, cred); if (error != 0) { printf("coda_readdir: vfs_object_create() returns %d\n", error); vput(vp); @@ -1672,7 +1673,7 @@ printf("coda_readdir: Internally Opening %p\n", vp); /* Do an "internal close" if necessary. */ if (opened_internally) { MARK_INT_GEN(CODA_CLOSE_STATS); - (void)VOP_CLOSE(vp, FREAD, cred, p); + (void)VOP_CLOSE(vp, FREAD, cred, td); } } @@ -1693,7 +1694,7 @@ coda_bmap(v) daddr_t bn __attribute__((unused)) = ap->a_bn; /* fs block number */ struct vnode **vpp = ap->a_vpp; /* RETURN vp of device */ daddr_t *bnp __attribute__((unused)) = ap->a_bnp; /* RETURN device block number */ - struct proc *p __attribute__((unused)) = curproc; + struct thread *td __attribute__((unused)) = curthread; /* upcall decl */ /* locals */ @@ -1731,7 +1732,7 @@ coda_strategy(v) /* true args */ struct vop_strategy_args *ap = v; register struct buf *bp __attribute__((unused)) = ap->a_bp; - struct proc *p __attribute__((unused)) = curproc; + struct thread *td __attribute__((unused)) = curthread; /* upcall decl */ /* locals */ @@ -1786,7 +1787,7 @@ coda_lock(v) struct vop_lock_args *ap = v; struct vnode *vp = ap->a_vp; struct cnode *cp = VTOC(vp); - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* upcall decl */ /* locals */ @@ -1798,9 +1799,9 @@ coda_lock(v) } #ifndef DEBUG_LOCKS - return (lockmgr(&cp->c_lock, ap->a_flags, &vp->v_interlock, p)); + return (lockmgr(&cp->c_lock, ap->a_flags, &vp->v_interlock, td)); #else - return (debuglockmgr(&cp->c_lock, ap->a_flags, &vp->v_interlock, p, + return (debuglockmgr(&cp->c_lock, ap->a_flags, &vp->v_interlock, td, "coda_lock", vp->filename, vp->line)); #endif } @@ -1813,7 +1814,7 @@ coda_unlock(v) struct vop_unlock_args *ap = v; struct vnode *vp = ap->a_vp; struct cnode *cp = VTOC(vp); - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; /* upcall decl */ /* locals */ @@ -1823,7 +1824,7 @@ coda_unlock(v) cp->c_fid.Volume, cp->c_fid.Vnode, cp->c_fid.Unique)); } - return (lockmgr(&cp->c_lock, ap->a_flags | LK_RELEASE, &vp->v_interlock, p)); + return (lockmgr(&cp->c_lock, ap->a_flags | LK_RELEASE, &vp->v_interlock, td)); } int @@ -1835,7 +1836,7 @@ coda_islocked(v) struct cnode *cp = VTOC(ap->a_vp); ENTRY; - return (lockstatus(&cp->c_lock, ap->a_p)); + return (lockstatus(&cp->c_lock, ap->a_td)); } /* How one looks up a vnode given a device/inode pair: */ diff --git a/sys/fs/coda/coda_vnops.h b/sys/fs/coda/coda_vnops.h index 9fcd978..663d357 100644 --- a/sys/fs/coda/coda_vnops.h +++ b/sys/fs/coda/coda_vnops.h @@ -82,7 +82,7 @@ int coda_fbsd_getpages __P((void *)); int (**coda_vnodeop_p)(void *); int coda_rdwr(struct vnode *vp, struct uio *uiop, enum uio_rw rw, - int ioflag, struct ucred *cred, struct proc *p); + int ioflag, struct ucred *cred, struct thread *td); int coda_grab_vnode(dev_t dev, ino_t ino, struct vnode **vpp); void print_vattr(struct vattr *attr); void print_cred(struct ucred *cred); diff --git a/sys/fs/devfs/devfs.h b/sys/fs/devfs/devfs.h index 28640ce..598fbf0 100644 --- a/sys/fs/devfs/devfs.h +++ b/sys/fs/devfs/devfs.h @@ -104,7 +104,7 @@ struct devfs_mount { extern vop_t **devfs_vnodeop_p; extern vop_t **devfs_specop_p; -int devfs_allocv (struct devfs_dirent *de, struct mount *mp, struct vnode **vpp, struct proc *p); +int devfs_allocv (struct devfs_dirent *de, struct mount *mp, struct vnode **vpp, struct thread *td); dev_t *devfs_itod (int inode); struct devfs_dirent **devfs_itode (struct devfs_mount *dm, int inode); int devfs_populate (struct devfs_mount *dm); diff --git a/sys/fs/devfs/devfs_devs.c b/sys/fs/devfs/devfs_devs.c index 9f19fca..6b406be 100644 --- a/sys/fs/devfs/devfs_devs.c +++ b/sys/fs/devfs/devfs_devs.c @@ -283,7 +283,7 @@ devfs_populate(struct devfs_mount *dm) if (dm->dm_generation == devfs_generation) return (0); - lockmgr(&dm->dm_lock, LK_UPGRADE, 0, curproc); + lockmgr(&dm->dm_lock, LK_UPGRADE, 0, curthread); if (devfs_noverflow && dm->dm_overflow == NULL) { i = devfs_noverflow * sizeof (struct devfs_dirent *); MALLOC(dm->dm_overflow, struct devfs_dirent **, i, @@ -358,7 +358,7 @@ devfs_populate(struct devfs_mount *dm) #endif } } - lockmgr(&dm->dm_lock, LK_DOWNGRADE, 0, curproc); + lockmgr(&dm->dm_lock, LK_DOWNGRADE, 0, curthread); return (0); } diff --git a/sys/fs/devfs/devfs_vfsops.c b/sys/fs/devfs/devfs_vfsops.c index 2d1aa90..e970c5a 100644 --- a/sys/fs/devfs/devfs_vfsops.c +++ b/sys/fs/devfs/devfs_vfsops.c @@ -52,23 +52,23 @@ MALLOC_DEFINE(M_DEVFS, "DEVFS", "DEVFS data"); static int devfs_mount __P((struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p)); + struct nameidata *ndp, struct thread *td)); static int devfs_unmount __P((struct mount *mp, int mntflags, - struct proc *p)); + struct thread *td)); static int devfs_root __P((struct mount *mp, struct vnode **vpp)); static int devfs_statfs __P((struct mount *mp, struct statfs *sbp, - struct proc *p)); + struct thread *td)); /* * Mount the filesystem */ static int -devfs_mount(mp, path, data, ndp, p) +devfs_mount(mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { int error; struct devfs_mount *fmp; @@ -101,20 +101,20 @@ devfs_mount(mp, path, data, ndp, p) FREE(fmp, M_DEVFS); return (error); } - VOP_UNLOCK(rvp, 0, p); + VOP_UNLOCK(rvp, 0, td); bzero(mp->mnt_stat.f_mntfromname, MNAMELEN); bcopy("devfs", mp->mnt_stat.f_mntfromname, sizeof("devfs")); - (void)devfs_statfs(mp, &mp->mnt_stat, p); + (void)devfs_statfs(mp, &mp->mnt_stat, td); return (0); } static int -devfs_unmount(mp, mntflags, p) +devfs_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { int error; int flags = 0; @@ -142,13 +142,13 @@ devfs_root(mp, vpp) struct vnode **vpp; { int error; - struct proc *p; + struct thread *td; struct vnode *vp; struct devfs_mount *dmp; - p = curproc; /* XXX */ + td = curthread; /* XXX */ dmp = VFSTODEVFS(mp); - error = devfs_allocv(dmp->dm_rootdir, mp, &vp, p); + error = devfs_allocv(dmp->dm_rootdir, mp, &vp, td); if (error) return (error); vp->v_flag |= VROOT; @@ -157,10 +157,10 @@ devfs_root(mp, vpp) } static int -devfs_statfs(mp, sbp, p) +devfs_statfs(mp, sbp, td) struct mount *mp; struct statfs *sbp; - struct proc *p; + struct thread *td; { sbp->f_flags = 0; diff --git a/sys/fs/devfs/devfs_vnops.c b/sys/fs/devfs/devfs_vnops.c index bafc3b3..ba6231c 100644 --- a/sys/fs/devfs/devfs_vnops.c +++ b/sys/fs/devfs/devfs_vnops.c @@ -111,18 +111,18 @@ devfs_fqpn(char *buf, struct vnode *dvp, struct componentname *cnp) } int -devfs_allocv(struct devfs_dirent *de, struct mount *mp, struct vnode **vpp, struct proc *p) +devfs_allocv(struct devfs_dirent *de, struct mount *mp, struct vnode **vpp, struct thread *td) { int error; struct vnode *vp; dev_t dev; - if (p == NULL) - p = curproc; /* XXX */ + if (td == NULL) + td = curthread; /* XXX */ loop: vp = de->de_vnode; if (vp != NULL) { - if (vget(vp, LK_EXCLUSIVE, p ? p : curproc)) + if (vget(vp, LK_EXCLUSIVE, td ? td : curthread)) goto loop; *vpp = vp; return (0); @@ -153,7 +153,7 @@ loop: } vp->v_data = de; de->de_vnode = vp; - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); *vpp = vp; return (0); } @@ -164,7 +164,7 @@ devfs_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -184,7 +184,7 @@ devfs_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -252,7 +252,7 @@ devfs_lookupx(ap) { struct componentname *cnp; struct vnode *dvp, **vpp; - struct proc *p; + struct thread *td; struct devfs_dirent *de, *dd; struct devfs_mount *dmp; dev_t cdev, *cpdev; @@ -263,7 +263,7 @@ devfs_lookupx(ap) vpp = ap->a_vpp; dvp = ap->a_dvp; pname = cnp->cn_nameptr; - p = cnp->cn_proc; + td = cnp->cn_thread; flags = cnp->cn_flags; nameiop = cnp->cn_nameiop; dmp = VFSTODEVFS(dvp->v_mount); @@ -281,7 +281,7 @@ devfs_lookupx(ap) if ((flags & ISDOTDOT) && (dvp->v_flag & VROOT)) return (EIO); - error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, cnp->cn_proc); + error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, td); if (error) return (error); @@ -296,17 +296,17 @@ devfs_lookupx(ap) if (flags & ISDOTDOT) { if (nameiop != LOOKUP) return (EINVAL); - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); de = TAILQ_FIRST(&dd->de_dlist); /* "." */ de = TAILQ_NEXT(de, de_list); /* ".." */ de = de->de_dir; - error = devfs_allocv(de, dvp->v_mount, vpp, p); + error = devfs_allocv(de, dvp->v_mount, vpp, td); if (error) { - vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td); return (error); } if ((flags & LOCKPARENT) && (flags & ISLASTCN)) - error = vn_lock(dvp, LK_EXCLUSIVE, p); + error = vn_lock(dvp, LK_EXCLUSIVE, td); if (error) vput(*vpp); return (error); @@ -357,7 +357,7 @@ notfound: (flags & (LOCKPARENT | WANTPARENT)) && (flags & ISLASTCN)) { cnp->cn_flags |= SAVENAME; if (!(flags & LOCKPARENT)) - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); return (EJUSTRETURN); } return (ENOENT); @@ -366,7 +366,7 @@ notfound: found: if ((cnp->cn_nameiop == DELETE) && (flags & ISLASTCN)) { - error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, p); + error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, td); if (error) return (error); if (*vpp == dvp) { @@ -374,18 +374,18 @@ found: *vpp = dvp; return (0); } - error = devfs_allocv(de, dvp->v_mount, vpp, p); + error = devfs_allocv(de, dvp->v_mount, vpp, td); if (error) return (error); if (!(flags & LOCKPARENT)) - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); return (0); } - error = devfs_allocv(de, dvp->v_mount, vpp, p); + error = devfs_allocv(de, dvp->v_mount, vpp, td); if (error) return (error); if (!(flags & LOCKPARENT) || !(flags & ISLASTCN)) - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); return (0); } @@ -396,9 +396,9 @@ devfs_lookup(struct vop_lookup_args *ap) struct devfs_mount *dmp; dmp = VFSTODEVFS(ap->a_dvp->v_mount); - lockmgr(&dmp->dm_lock, LK_SHARED, 0, curproc); + lockmgr(&dmp->dm_lock, LK_SHARED, 0, curthread); j = devfs_lookupx(ap); - lockmgr(&dmp->dm_lock, LK_RELEASE, 0, curproc); + lockmgr(&dmp->dm_lock, LK_RELEASE, 0, curthread); return (j); } @@ -416,7 +416,7 @@ struct vop_mknod_args { { struct componentname *cnp; struct vnode *dvp, **vpp; - struct proc *p; + struct thread *td; struct devfs_dirent *dd, *de; struct devfs_mount *dmp; int cloned, flags, nameiop; @@ -424,11 +424,11 @@ struct vop_mknod_args { dvp = ap->a_dvp; dmp = VFSTODEVFS(dvp->v_mount); - lockmgr(&dmp->dm_lock, LK_EXCLUSIVE, 0, curproc); + lockmgr(&dmp->dm_lock, LK_EXCLUSIVE, 0, curthread); cnp = ap->a_cnp; vpp = ap->a_vpp; - p = cnp->cn_proc; + td = cnp->cn_thread; flags = cnp->cn_flags; nameiop = cnp->cn_nameiop; cloned = 0; @@ -448,9 +448,9 @@ struct vop_mknod_args { if (de == NULL) goto notfound; de->de_flags &= ~DE_WHITEOUT; - error = devfs_allocv(de, dvp->v_mount, vpp, p); + error = devfs_allocv(de, dvp->v_mount, vpp, td); notfound: - lockmgr(&dmp->dm_lock, LK_RELEASE, 0, curproc); + lockmgr(&dmp->dm_lock, LK_RELEASE, 0, curthread); return (error); } @@ -512,7 +512,7 @@ devfs_readdir(ap) return (EINVAL); dmp = VFSTODEVFS(ap->a_vp->v_mount); - lockmgr(&dmp->dm_lock, LK_SHARED, 0, curproc); + lockmgr(&dmp->dm_lock, LK_SHARED, 0, curthread); devfs_populate(dmp); error = 0; de = ap->a_vp->v_data; @@ -553,7 +553,7 @@ devfs_readdir(ap) *ap->a_ncookies = ncookies; *ap->a_cookies = cookiebuf; } - lockmgr(&dmp->dm_lock, LK_RELEASE, 0, curproc); + lockmgr(&dmp->dm_lock, LK_RELEASE, 0, curthread); uio->uio_offset = off; return (error); } @@ -610,11 +610,11 @@ devfs_remove(ap) struct devfs_dirent *de; struct devfs_mount *dmp = VFSTODEVFS(vp->v_mount); - lockmgr(&dmp->dm_lock, LK_EXCLUSIVE, 0, curproc); + lockmgr(&dmp->dm_lock, LK_EXCLUSIVE, 0, curthread); dd = ap->a_dvp->v_data; de = vp->v_data; de->de_flags |= DE_WHITEOUT; - lockmgr(&dmp->dm_lock, LK_RELEASE, 0, curproc); + lockmgr(&dmp->dm_lock, LK_RELEASE, 0, curthread); return (0); } @@ -683,7 +683,7 @@ devfs_setattr(ap) if (uid != de->de_uid || gid != de->de_gid) { if (((ap->a_cred->cr_uid != de->de_uid) || uid != de->de_uid || (gid != de->de_gid && !groupmember(gid, ap->a_cred))) && - (error = suser(ap->a_p)) != 0) + (error = suser(ap->a_td->td_proc)) != 0) return (error); de->de_uid = uid; de->de_gid = gid; @@ -691,21 +691,21 @@ devfs_setattr(ap) } if (vap->va_mode != (mode_t)VNOVAL) { if ((ap->a_cred->cr_uid != de->de_uid) && - (error = suser(ap->a_p))) + (error = suser(ap->a_td->td_proc))) return (error); de->de_mode = vap->va_mode; c = 1; } if (vap->va_atime.tv_sec != VNOVAL) { if ((ap->a_cred->cr_uid != de->de_uid) && - (error = suser(ap->a_p))) + (error = suser(ap->a_td->td_proc))) return (error); de->de_atime = vap->va_atime; c = 1; } if (vap->va_mtime.tv_sec != VNOVAL) { if ((ap->a_cred->cr_uid != de->de_uid) && - (error = suser(ap->a_p))) + (error = suser(ap->a_td->td_proc))) return (error); de->de_mtime = vap->va_mtime; c = 1; @@ -731,7 +731,7 @@ devfs_symlink(ap) struct devfs_dirent *de; struct devfs_mount *dmp; - error = suser(ap->a_cnp->cn_proc); + error = suser(ap->a_cnp->cn_thread->td_proc); if (error) return(error); dmp = VFSTODEVFS(ap->a_dvp->v_mount); @@ -745,10 +745,10 @@ devfs_symlink(ap) i = strlen(ap->a_target) + 1; MALLOC(de->de_symlink, char *, i, M_DEVFS, M_WAITOK); bcopy(ap->a_target, de->de_symlink, i); - lockmgr(&dmp->dm_lock, LK_EXCLUSIVE, 0, curproc); + lockmgr(&dmp->dm_lock, LK_EXCLUSIVE, 0, curthread); TAILQ_INSERT_TAIL(&dd->de_dlist, de, de_list); devfs_allocv(de, ap->a_dvp->v_mount, ap->a_vpp, 0); - lockmgr(&dmp->dm_lock, LK_RELEASE, 0, curproc); + lockmgr(&dmp->dm_lock, LK_RELEASE, 0, curthread); return (0); } diff --git a/sys/fs/fdescfs/fdesc.h b/sys/fs/fdescfs/fdesc.h index b78d132..f90ea8d 100644 --- a/sys/fs/fdescfs/fdesc.h +++ b/sys/fs/fdescfs/fdesc.h @@ -65,5 +65,5 @@ struct fdescnode { extern int fdesc_init __P((struct vfsconf *)); extern int fdesc_root __P((struct mount *, struct vnode **)); extern int fdesc_allocvp __P((fdntype, int, struct mount *, struct vnode **, - struct proc *)); + struct thread *)); #endif /* _KERNEL */ diff --git a/sys/fs/fdescfs/fdesc_vfsops.c b/sys/fs/fdescfs/fdesc_vfsops.c index ed16306..11da211 100644 --- a/sys/fs/fdescfs/fdesc_vfsops.c +++ b/sys/fs/fdescfs/fdesc_vfsops.c @@ -59,22 +59,22 @@ static MALLOC_DEFINE(M_FDESCMNT, "FDESC mount", "FDESC mount structure"); static int fdesc_mount __P((struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p)); + struct nameidata *ndp, struct thread *td)); static int fdesc_unmount __P((struct mount *mp, int mntflags, - struct proc *p)); + struct thread *td)); static int fdesc_statfs __P((struct mount *mp, struct statfs *sbp, - struct proc *p)); + struct thread *td)); /* * Mount the per-process file descriptors (/dev/fd) */ static int -fdesc_mount(mp, path, data, ndp, p) +fdesc_mount(mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { int error = 0; struct fdescmount *fmp; @@ -86,7 +86,7 @@ fdesc_mount(mp, path, data, ndp, p) if (mp->mnt_flag & MNT_UPDATE) return (EOPNOTSUPP); - error = fdesc_allocvp(Froot, FD_ROOT, mp, &rvp, p); + error = fdesc_allocvp(Froot, FD_ROOT, mp, &rvp, td); if (error) return (error); @@ -102,15 +102,15 @@ fdesc_mount(mp, path, data, ndp, p) bzero(mp->mnt_stat.f_mntfromname, MNAMELEN); bcopy("fdesc", mp->mnt_stat.f_mntfromname, sizeof("fdesc")); - (void)fdesc_statfs(mp, &mp->mnt_stat, p); + (void)fdesc_statfs(mp, &mp->mnt_stat, td); return (0); } static int -fdesc_unmount(mp, mntflags, p) +fdesc_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { int error; int flags = 0; @@ -143,7 +143,7 @@ fdesc_root(mp, vpp) struct mount *mp; struct vnode **vpp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct vnode *vp; /* @@ -151,16 +151,16 @@ fdesc_root(mp, vpp) */ vp = VFSTOFDESC(mp)->f_root; VREF(vp); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); *vpp = vp; return (0); } static int -fdesc_statfs(mp, sbp, p) +fdesc_statfs(mp, sbp, td) struct mount *mp; struct statfs *sbp; - struct proc *p; + struct thread *td; { struct filedesc *fdp; int lim; @@ -174,8 +174,8 @@ fdesc_statfs(mp, sbp, p) * limit is ever reduced below the current number * of open files... ] */ - lim = p->p_rlimit[RLIMIT_NOFILE].rlim_cur; - fdp = p->p_fd; + lim = td->td_proc->p_rlimit[RLIMIT_NOFILE].rlim_cur; + fdp = td->td_proc->p_fd; last = min(fdp->fd_nfiles, lim); freefd = 0; for (i = fdp->fd_freefile; i < last; i++) diff --git a/sys/fs/fdescfs/fdesc_vnops.c b/sys/fs/fdescfs/fdesc_vnops.c index 8d5b95e..6a9f897 100644 --- a/sys/fs/fdescfs/fdesc_vnops.c +++ b/sys/fs/fdescfs/fdesc_vnops.c @@ -95,12 +95,12 @@ fdesc_init(vfsp) } int -fdesc_allocvp(ftype, ix, mp, vpp, p) +fdesc_allocvp(ftype, ix, mp, vpp, td) fdntype ftype; int ix; struct mount *mp; struct vnode **vpp; - struct proc *p; + struct thread *td; { struct fdhashhead *fc; struct fdescnode *fd; @@ -110,7 +110,7 @@ fdesc_allocvp(ftype, ix, mp, vpp, p) loop: LIST_FOREACH(fd, fc, fd_hash) { if (fd->fd_ix == ix && fd->fd_vnode->v_mount == mp) { - if (vget(fd->fd_vnode, 0, p)) + if (vget(fd->fd_vnode, 0, td)) goto loop; *vpp = fd->fd_vnode; return (error); @@ -174,9 +174,9 @@ fdesc_lookup(ap) struct vnode *dvp = ap->a_dvp; struct componentname *cnp = ap->a_cnp; char *pname = cnp->cn_nameptr; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; int nlen = cnp->cn_namelen; - int nfiles = p->p_fd->fd_nfiles; + int nfiles = td->td_proc->p_fd->fd_nfiles; u_int fd; int error; struct vnode *fvp; @@ -186,11 +186,11 @@ fdesc_lookup(ap) goto bad; } - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); if (cnp->cn_namelen == 1 && *pname == '.') { *vpp = dvp; VREF(dvp); - vn_lock(dvp, LK_SHARED | LK_RETRY, p); + vn_lock(dvp, LK_SHARED | LK_RETRY, td); return (0); } @@ -213,21 +213,21 @@ fdesc_lookup(ap) fd = 10 * fd + *pname++ - '0'; } - if (fd >= nfiles || p->p_fd->fd_ofiles[fd] == NULL) { + if (fd >= nfiles || td->td_proc->p_fd->fd_ofiles[fd] == NULL) { error = EBADF; goto bad; } - error = fdesc_allocvp(Fdesc, FD_DESC+fd, dvp->v_mount, &fvp, p); + error = fdesc_allocvp(Fdesc, FD_DESC+fd, dvp->v_mount, &fvp, td); if (error) goto bad; VTOFDESC(fvp)->fd_fd = fd; - vn_lock(fvp, LK_SHARED | LK_RETRY, p); + vn_lock(fvp, LK_SHARED | LK_RETRY, td); *vpp = fvp; return (0); bad: - vn_lock(dvp, LK_SHARED | LK_RETRY, p); + vn_lock(dvp, LK_SHARED | LK_RETRY, td); *vpp = NULL; return (error); } @@ -238,7 +238,7 @@ fdesc_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -247,14 +247,14 @@ fdesc_open(ap) return (0); /* - * XXX Kludge: set p->p_dupfd to contain the value of the the file + * XXX Kludge: set td->td_proc->p_dupfd to contain the value of the the file * descriptor being sought for duplication. The error return ensures * that the vnode for this device will be released by vn_open. Open * will detect this special error and take the actions in dupfdopen. * Other callers of vn_open or VOP_OPEN will simply report the * error. */ - ap->a_p->p_dupfd = VTOFDESC(vp)->fd_fd; /* XXX */ + ap->a_td->td_dupfd = VTOFDESC(vp)->fd_fd; /* XXX */ return (ENODEV); } @@ -264,12 +264,12 @@ fdesc_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; struct vattr *vap = ap->a_vap; - struct filedesc *fdp = ap->a_p->p_fd; + struct filedesc *fdp = ap->a_td->td_proc->p_fd; struct file *fp; struct stat stb; u_int fd; @@ -304,7 +304,7 @@ fdesc_getattr(ap) return (EBADF); bzero(&stb, sizeof(stb)); - error = fo_stat(fp, &stb, ap->a_p); + error = fo_stat(fp, &stb, ap->a_td); if (error == 0) { VATTR_NULL(vap); vap->va_type = IFTOVT(stb.st_mode); @@ -360,7 +360,7 @@ fdesc_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vattr *vap = ap->a_vap; @@ -381,7 +381,7 @@ fdesc_setattr(ap) /* * Allow setattr where there is an underlying vnode. */ - error = getvnode(ap->a_p->p_fd, fd, &fp); + error = getvnode(ap->a_td->td_proc->p_fd, fd, &fp); if (error) { /* * getvnode() returns EINVAL if the file descriptor is not @@ -399,7 +399,7 @@ fdesc_setattr(ap) vp = (struct vnode *)fp->f_data; if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - error = VOP_SETATTR(vp, ap->a_vap, ap->a_cred, ap->a_p); + error = VOP_SETATTR(vp, ap->a_vap, ap->a_cred, ap->a_td); vn_finished_write(mp); return (error); } @@ -438,7 +438,7 @@ fdesc_readdir(ap) uio->uio_resid < UIO_MX) return (EINVAL); i = (u_int)off / UIO_MX; - fdp = uio->uio_procp->p_fd; + fdp = uio->uio_td->td_proc->p_fd; error = 0; fcnt = i - 2; /* The first two nodes are `.' and `..' */ @@ -488,17 +488,17 @@ fdesc_poll(ap) struct vnode *a_vp; int a_events; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { - return seltrue(0, ap->a_events, ap->a_p); + return seltrue(0, ap->a_events, ap->a_td); } static int fdesc_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -507,7 +507,7 @@ fdesc_inactive(ap) * Clear out the v_type field to avoid * nasty things happening in vgone(). */ - VOP_UNLOCK(vp, 0, ap->a_p); + VOP_UNLOCK(vp, 0, ap->a_td); vp->v_type = VNON; return (0); } diff --git a/sys/fs/fifofs/fifo_vnops.c b/sys/fs/fifofs/fifo_vnops.c index 5fadba2..baddfa4 100644 --- a/sys/fs/fifofs/fifo_vnops.c +++ b/sys/fs/fifofs/fifo_vnops.c @@ -41,6 +41,7 @@ #include <sys/lock.h> #include <sys/malloc.h> #include <sys/vnode.h> +#include <sys/proc.h> /* XXXKSE */ #include <sys/socket.h> #include <sys/socketvar.h> #include <sys/filio.h> @@ -161,26 +162,26 @@ fifo_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; struct fifoinfo *fip; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; struct socket *rso, *wso; int error; if ((fip = vp->v_fifoinfo) == NULL) { MALLOC(fip, struct fifoinfo *, sizeof(*fip), M_VNODE, M_WAITOK); vp->v_fifoinfo = fip; - error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, ap->a_p); + error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, ap->a_td); if (error) { free(fip, M_VNODE); vp->v_fifoinfo = NULL; return (error); } fip->fi_readsock = rso; - error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, ap->a_p); + error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, ap->a_td); if (error) { (void)soclose(rso); free(fip, M_VNODE); @@ -222,10 +223,10 @@ fifo_open(ap) } if ((ap->a_mode & FREAD) && (ap->a_mode & O_NONBLOCK) == 0) { while (fip->fi_writers == 0) { - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); error = tsleep((caddr_t)&fip->fi_readers, PCATCH | PSOCK, "fifoor", 0); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (error) goto bad; } @@ -238,10 +239,10 @@ fifo_open(ap) } } else { while (fip->fi_readers == 0) { - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); error = tsleep((caddr_t)&fip->fi_writers, PCATCH | PSOCK, "fifoow", 0); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (error) goto bad; } @@ -249,7 +250,7 @@ fifo_open(ap) } return (0); bad: - VOP_CLOSE(vp, ap->a_mode, ap->a_cred, p); + VOP_CLOSE(vp, ap->a_mode, ap->a_cred, td); return (error); } @@ -268,7 +269,7 @@ fifo_read(ap) { struct uio *uio = ap->a_uio; struct socket *rso = ap->a_vp->v_fifoinfo->fi_readsock; - struct proc *p = uio->uio_procp; + struct thread *td = uio->uio_td; int error, startresid; #ifdef DIAGNOSTIC @@ -280,10 +281,10 @@ fifo_read(ap) if (ap->a_ioflag & IO_NDELAY) rso->so_state |= SS_NBIO; startresid = uio->uio_resid; - VOP_UNLOCK(ap->a_vp, 0, p); + VOP_UNLOCK(ap->a_vp, 0, td); error = soreceive(rso, (struct sockaddr **)0, uio, (struct mbuf **)0, (struct mbuf **)0, (int *)0); - vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, td); if (ap->a_ioflag & IO_NDELAY) rso->so_state &= ~SS_NBIO; return (error); @@ -303,7 +304,7 @@ fifo_write(ap) } */ *ap; { struct socket *wso = ap->a_vp->v_fifoinfo->fi_writesock; - struct proc *p = ap->a_uio->uio_procp; + struct thread *td = ap->a_uio->uio_td; int error; #ifdef DIAGNOSTIC @@ -312,10 +313,10 @@ fifo_write(ap) #endif if (ap->a_ioflag & IO_NDELAY) wso->so_state |= SS_NBIO; - VOP_UNLOCK(ap->a_vp, 0, p); + VOP_UNLOCK(ap->a_vp, 0, td); error = sosend(wso, (struct sockaddr *)0, ap->a_uio, 0, - (struct mbuf *)0, 0, p); - vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, p); + (struct mbuf *)0, 0, td); + vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, td); if (ap->a_ioflag & IO_NDELAY) wso->so_state &= ~SS_NBIO; return (error); @@ -333,7 +334,7 @@ fifo_ioctl(ap) caddr_t a_data; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct file filetmp; @@ -343,13 +344,13 @@ fifo_ioctl(ap) return (0); if (ap->a_fflag & FREAD) { filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_readsock; - error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_p); + error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_td); if (error) return (error); } if (ap->a_fflag & FWRITE) { filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_writesock; - error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_p); + error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_td); if (error) return (error); } @@ -446,7 +447,7 @@ fifo_poll(ap) struct vnode *a_vp; int a_events; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct file filetmp; @@ -456,13 +457,13 @@ fifo_poll(ap) filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_readsock; if (filetmp.f_data) revents |= soo_poll(&filetmp, ap->a_events, ap->a_cred, - ap->a_p); + ap->a_td); } if (ap->a_events & (POLLOUT | POLLWRNORM | POLLWRBAND)) { filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_writesock; if (filetmp.f_data) revents |= soo_poll(&filetmp, ap->a_events, ap->a_cred, - ap->a_p); + ap->a_td); } return (revents); } @@ -477,7 +478,7 @@ fifo_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; diff --git a/sys/fs/hpfs/hpfs.h b/sys/fs/hpfs/hpfs.h index f354b6b..f0253d5 100644 --- a/sys/fs/hpfs/hpfs.h +++ b/sys/fs/hpfs/hpfs.h @@ -417,7 +417,7 @@ void hpfs_hphashinit __P((void)); void hpfs_hphashdestroy __P((void)); struct hpfsnode *hpfs_hphashlookup __P((dev_t, lsn_t)); struct hpfsnode *hpfs_hphashget __P((dev_t, lsn_t)); -struct vnode *hpfs_hphashvget __P((dev_t, lsn_t, struct proc *)); +struct vnode *hpfs_hphashvget __P((dev_t, lsn_t, struct thread *)); void hpfs_hphashins __P((register struct hpfsnode *)); void hpfs_hphashrem __P((register struct hpfsnode *)); extern struct lock hpfs_hphash_lock; diff --git a/sys/fs/hpfs/hpfs_hash.c b/sys/fs/hpfs/hpfs_hash.c index 791680c..fd8eeca 100644 --- a/sys/fs/hpfs/hpfs_hash.c +++ b/sys/fs/hpfs/hpfs_hash.c @@ -123,10 +123,10 @@ loop: #endif struct vnode * -hpfs_hphashvget(dev, ino, p) +hpfs_hphashvget(dev, ino, td) dev_t dev; lsn_t ino; - struct proc *p; + struct thread *td; { struct hpfsnode *hp; struct vnode *vp; @@ -138,7 +138,7 @@ loop: vp = HPTOV(hp); mtx_lock(&vp->v_interlock); mtx_unlock(&hpfs_hphash_mtx); - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) goto loop; return (vp); } diff --git a/sys/fs/hpfs/hpfs_vfsops.c b/sys/fs/hpfs/hpfs_vfsops.c index 46e197d..e83f356 100644 --- a/sys/fs/hpfs/hpfs_vfsops.c +++ b/sys/fs/hpfs/hpfs_vfsops.c @@ -64,37 +64,37 @@ MALLOC_DEFINE(M_HPFSNO, "HPFS node", "HPFS node structure"); static int hpfs_root __P((struct mount *, struct vnode **)); static int hpfs_statfs __P((struct mount *, struct statfs *, - struct proc *)); -static int hpfs_unmount __P((struct mount *, int, struct proc *)); + struct thread *)); +static int hpfs_unmount __P((struct mount *, int, struct thread *)); static int hpfs_vget __P((struct mount *mp, ino_t ino, struct vnode **vpp)); static int hpfs_mountfs __P((register struct vnode *, struct mount *, - struct hpfs_args *, struct proc *)); + struct hpfs_args *, struct thread *)); static int hpfs_vptofh __P((struct vnode *, struct fid *)); static int hpfs_fhtovp __P((struct mount *, struct fid *, struct vnode **)); #if !defined(__FreeBSD__) static int hpfs_quotactl __P((struct mount *, int, uid_t, caddr_t, - struct proc *)); -static int hpfs_start __P((struct mount *, int, struct proc *)); + struct lwp *)); +static int hpfs_start __P((struct mount *, int, struct lwp *)); static int hpfs_sync __P((struct mount *, int, struct ucred *, - struct proc *)); + struct lwp *)); #endif #if defined(__FreeBSD__) struct sockaddr; static int hpfs_mount __P((struct mount *, char *, caddr_t, - struct nameidata *, struct proc *)); + struct nameidata *, struct thread *)); static int hpfs_init __P((struct vfsconf *)); static int hpfs_uninit __P((struct vfsconf *)); #else /* defined(__NetBSD__) */ static int hpfs_mount __P((struct mount *, const char *, void *, - struct nameidata *, struct proc *)); + struct nameidata *, struct thread *)); static void hpfs_init __P((void)); static int hpfs_mountroot __P((void)); static int hpfs_sysctl __P((int *, u_int, void *, size_t *, void *, - size_t, struct proc *)); + size_t, struct thread *)); static int hpfs_checkexp __P((struct mount *, struct mbuf *, int *, struct ucred **)); #endif @@ -127,14 +127,14 @@ hpfs_checkexp(mp, nam, exflagsp, credanonp) #if !defined(__FreeBSD__) /*ARGSUSED*/ static int -hpfs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) +hpfs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, td) int *name; u_int namelen; void *oldp; size_t *oldlenp; void *newp; size_t newlen; - struct proc *p; + struct lwp *td; { return (EINVAL); } @@ -179,12 +179,14 @@ hpfs_mount ( #if defined(__FreeBSD__) char *path, caddr_t data, + struct nameidata *ndp, + struct thread *td ) #else /* defined(__NetBSD__) */ const char *path, void *data, -#endif struct nameidata *ndp, - struct proc *p ) + struct lwp *l ) +#endif { u_int size; int err = 0; @@ -237,7 +239,11 @@ hpfs_mount ( * Not an update, or updating the name: look up the name * and verify that it refers to a sensible block device. */ - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); +#ifdef __FreeBSD__ + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, td); +#else + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, l); +#endif err = namei(ndp); if (err) { /* can't get devvp!*/ @@ -282,7 +288,7 @@ hpfs_mount ( &size); /* real size*/ bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - err = hpfs_mountfs(devvp, mp, &args, p); + err = hpfs_mountfs(devvp, mp, &args, td); if (err) goto error_2; @@ -292,7 +298,7 @@ hpfs_mount ( * * This code is common to root and non-root mounts */ - (void)VFS_STATFS(mp, &mp->mnt_stat, p); + (void)VFS_STATFS(mp, &mp->mnt_stat, td); goto success; @@ -312,11 +318,11 @@ success: * Common code for mount and mountroot */ int -hpfs_mountfs(devvp, mp, argsp, p) +hpfs_mountfs(devvp, mp, argsp, td) register struct vnode *devvp; struct mount *mp; struct hpfs_args *argsp; - struct proc *p; + struct thread *td; { int error, ncount, ronly; struct sublock *sup; @@ -345,19 +351,19 @@ hpfs_mountfs(devvp, mp, argsp, p) return (EBUSY); #if defined(__FreeBSD__) - VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0); - VOP__UNLOCK(devvp, 0, p); + VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = vinvalbuf(devvp, V_SAVE, td->td_proc->p_ucred, td, 0, 0); + VOP__UNLOCK(devvp, 0, td); #else - error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0); + error = vinvalbuf(devvp, V_SAVE, td->td_proc->p_ucred, td, 0, 0); #endif if (error) return (error); ronly = (mp->mnt_flag & MNT_RDONLY) != 0; - VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p); - VOP__UNLOCK(devvp, 0, p); + VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, td); + VOP__UNLOCK(devvp, 0, td); if (error) return (error); @@ -443,7 +449,7 @@ failed: #else devvp->v_specflags &= ~SI_MOUNTEDON; #endif - (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p); + (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, td); return (error); } @@ -452,7 +458,7 @@ static int hpfs_start ( struct mount *mp, int flags, - struct proc *p ) + struct lwp *td ) { return (0); } @@ -462,7 +468,7 @@ static int hpfs_unmount( struct mount *mp, int mntflags, - struct proc *p) + struct thread *td) { int error, flags, ronly; register struct hpfsmount *hpmp = VFSTOHPFS(mp); @@ -489,9 +495,9 @@ hpfs_unmount( hpmp->hpm_devvp->v_specflags &= ~SI_MOUNTEDON; #endif - vinvalbuf(hpmp->hpm_devvp, V_SAVE, NOCRED, p, 0, 0); + vinvalbuf(hpmp->hpm_devvp, V_SAVE, NOCRED, td, 0, 0); error = VOP_CLOSE(hpmp->hpm_devvp, ronly ? FREAD : FREAD|FWRITE, - NOCRED, p); + NOCRED, td); vrele(hpmp->hpm_devvp); @@ -527,7 +533,7 @@ static int hpfs_statfs( struct mount *mp, struct statfs *sbp, - struct proc *p) + struct thread *td) { struct hpfsmount *hpmp = VFSTOHPFS(mp); @@ -562,7 +568,7 @@ hpfs_sync ( struct mount *mp, int waitfor, struct ucred *cred, - struct proc *p) + struct lwp *td) { return (0); } @@ -573,7 +579,7 @@ hpfs_quotactl ( int cmds, uid_t uid, caddr_t arg, - struct proc *p) + struct lwp *td) { printf("hpfs_quotactl():\n"); return (EOPNOTSUPP); @@ -628,7 +634,7 @@ hpfs_vget( struct vnode *vp; struct hpfsnode *hp; struct buf *bp; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ int error; dprintf(("hpfs_vget(0x%x): ",ino)); @@ -637,7 +643,7 @@ hpfs_vget( hp = NULL; vp = NULL; - if ((*vpp = hpfs_hphashvget(hpmp->hpm_dev, ino, p)) != NULL) { + if ((*vpp = hpfs_hphashvget(hpmp->hpm_dev, ino, td)) != NULL) { dprintf(("hashed\n")); return (0); } @@ -686,14 +692,14 @@ hpfs_vget( hp->h_devvp = hpmp->hpm_devvp; VREF(hp->h_devvp); - error = VN_LOCK(vp, LK_EXCLUSIVE, p); + error = VN_LOCK(vp, LK_EXCLUSIVE, td); if (error) { vput(vp); return (error); } do { - if ((*vpp = hpfs_hphashvget(hpmp->hpm_dev, ino, p)) != NULL) { + if ((*vpp = hpfs_hphashvget(hpmp->hpm_dev, ino, td)) != NULL) { dprintf(("hashed2\n")); vput(vp); return (0); diff --git a/sys/fs/hpfs/hpfs_vnops.c b/sys/fs/hpfs/hpfs_vnops.c index 0e2a4b7..e612a24 100644 --- a/sys/fs/hpfs/hpfs_vnops.c +++ b/sys/fs/hpfs/hpfs_vnops.c @@ -102,7 +102,7 @@ hpfs_fsync(ap) struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -153,7 +153,7 @@ hpfs_ioctl ( caddr_t a_data; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap) { register struct vnode *vp = ap->a_vp; @@ -465,7 +465,7 @@ hpfs_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -517,14 +517,14 @@ hpfs_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; struct hpfsnode *hp = VTOHP(vp); struct vattr *vap = ap->a_vap; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; int error; dprintf(("hpfs_setattr(0x%x):\n", hp->h_no)); @@ -563,9 +563,9 @@ hpfs_setattr(ap) if (vp->v_mount->mnt_flag & MNT_RDONLY) return (EROFS); if (cred->cr_uid != hp->h_uid && - (error = suser_xxx(cred, p, PRISON_ROOT)) && + (error = suser_xxx(cred, td->td_proc, PRISON_ROOT)) && ((vap->va_vaflags & VA_UTIMES_NULL) == 0 || - (error = VOP_ACCESS(vp, VWRITE, cred, p)))) + (error = VOP_ACCESS(vp, VWRITE, cred, td)))) return (error); if (vap->va_atime.tv_sec != VNOVAL) hp->h_atime = vap->va_atime.tv_sec; @@ -590,7 +590,7 @@ hpfs_setattr(ap) if (vap->va_size < hp->h_fn.fn_size) { #if defined(__FreeBSD__) - error = vtruncbuf(vp, cred, p, vap->va_size, DEV_BSIZE); + error = vtruncbuf(vp, cred, td, vap->va_size, DEV_BSIZE); if (error) return (error); #else /* defined(__NetBSD__) */ @@ -646,16 +646,16 @@ hpfs_inactive(ap) vprint("hpfs_inactive: pushing active", vp); if (hp->h_flag & H_INVAL) { - VOP__UNLOCK(vp,0,ap->a_p); + VOP__UNLOCK(vp,0,ap->a_td); #if defined(__FreeBSD__) - vrecycle(vp, NULL, ap->a_p); + vrecycle(vp, NULL, ap->a_td); #else /* defined(__NetBSD__) */ vgone(vp); #endif return (0); } - VOP__UNLOCK(vp,0,ap->a_p); + VOP__UNLOCK(vp,0,ap->a_td); return (0); } @@ -759,7 +759,7 @@ hpfs_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -800,7 +800,7 @@ hpfs_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { #if HPFS_DEBUG @@ -829,7 +829,7 @@ hpfs_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { #if HPFS_DEBUG @@ -1131,7 +1131,7 @@ hpfs_lookup(ap) return (EOPNOTSUPP); } - error = VOP_ACCESS(dvp, VEXEC, cred, cnp->cn_proc); + error = VOP_ACCESS(dvp, VEXEC, cred, cnp->cn_thread); if(error) return (error); @@ -1148,17 +1148,17 @@ hpfs_lookup(ap) dprintf(("hpfs_lookup(0x%x,...): .. faked (0x%x)\n", dhp->h_no, dhp->h_fn.fn_parent)); - VOP__UNLOCK(dvp,0,cnp->cn_proc); + VOP__UNLOCK(dvp,0,cnp->cn_thread); error = VFS_VGET(hpmp->hpm_mp, dhp->h_fn.fn_parent, ap->a_vpp); if(error) { - VOP__LOCK(dvp, 0, cnp->cn_proc); + VOP__LOCK(dvp, 0, cnp->cn_thread); return(error); } if( lockparent && (flags & ISLASTCN) && - (error = VOP__LOCK(dvp, 0, cnp->cn_proc)) ) { + (error = VOP__LOCK(dvp, 0, cnp->cn_thread)) ) { vput( *(ap->a_vpp) ); return (error); } @@ -1174,7 +1174,7 @@ hpfs_lookup(ap) if ((error == ENOENT) && (flags & ISLASTCN) && (nameiop == CREATE || nameiop == RENAME)) { if(!lockparent) - VOP__UNLOCK(dvp, 0, cnp->cn_proc); + VOP__UNLOCK(dvp, 0, cnp->cn_thread); cnp->cn_flags |= SAVENAME; return (EJUSTRETURN); } @@ -1186,7 +1186,7 @@ hpfs_lookup(ap) dep->de_fnode, dep->de_cpid)); if (nameiop == DELETE && (flags & ISLASTCN)) { - error = VOP_ACCESS(dvp, VWRITE, cred, cnp->cn_proc); + error = VOP_ACCESS(dvp, VWRITE, cred, cnp->cn_thread); if (error) { brelse(bp); return (error); @@ -1220,7 +1220,7 @@ hpfs_lookup(ap) brelse(bp); if(!lockparent || !(flags & ISLASTCN)) - VOP__UNLOCK(dvp, 0, cnp->cn_proc); + VOP__UNLOCK(dvp, 0, cnp->cn_thread); if ((flags & MAKEENTRY) && (!(flags & ISLASTCN) || (nameiop != DELETE && nameiop != CREATE))) diff --git a/sys/fs/msdosfs/denode.h b/sys/fs/msdosfs/denode.h index f7ba83b..6083de6 100644 --- a/sys/fs/msdosfs/denode.h +++ b/sys/fs/msdosfs/denode.h @@ -280,6 +280,6 @@ int dosdirempty __P((struct denode *dep)); int createde __P((struct denode *dep, struct denode *ddep, struct denode **depp, struct componentname *cnp)); int deupdat __P((struct denode *dep, int waitfor)); int removede __P((struct denode *pdep, struct denode *dep)); -int detrunc __P((struct denode *dep, u_long length, int flags, struct ucred *cred, struct proc *p)); +int detrunc __P((struct denode *dep, u_long length, int flags, struct ucred *cred, struct thread *td)); int doscheckpath __P(( struct denode *source, struct denode *target)); #endif /* _KERNEL */ diff --git a/sys/fs/msdosfs/msdosfs_denode.c b/sys/fs/msdosfs/msdosfs_denode.c index bf176bd..8ab7f11 100644 --- a/sys/fs/msdosfs/msdosfs_denode.c +++ b/sys/fs/msdosfs/msdosfs_denode.c @@ -125,7 +125,7 @@ msdosfs_hashget(dev, dirclust, diroff) u_long dirclust; u_long diroff; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct denode *dep; struct vnode *vp; @@ -139,7 +139,7 @@ loop: vp = DETOV(dep); mtx_lock(&vp->v_interlock); mtx_unlock(&dehash_mtx); - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) goto loop; return (dep); } @@ -209,7 +209,7 @@ deget(pmp, dirclust, diroffset, depp) struct denode *ldep; struct vnode *nvp; struct buf *bp; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct timeval tv; #ifdef MSDOSFS_DEBUG @@ -278,7 +278,7 @@ deget(pmp, dirclust, diroffset, depp) * of at the start of msdosfs_hashins() so that reinsert() can * call msdosfs_hashins() with a locked denode. */ - if (VOP_LOCK(nvp, LK_EXCLUSIVE, p) != 0) + if (VOP_LOCK(nvp, LK_EXCLUSIVE, td) != 0) panic("deget: unexpected lock failure"); /* @@ -414,12 +414,12 @@ deupdat(dep, waitfor) * Truncate the file described by dep to the length specified by length. */ int -detrunc(dep, length, flags, cred, p) +detrunc(dep, length, flags, cred, td) struct denode *dep; u_long length; int flags; struct ucred *cred; - struct proc *p; + struct thread *td; { int error; int allerror; @@ -520,7 +520,7 @@ detrunc(dep, length, flags, cred, p) dep->de_FileSize = length; if (!isadir) dep->de_flag |= DE_UPDATE|DE_MODIFIED; - allerror = vtruncbuf(DETOV(dep), cred, p, length, pmp->pm_bpcluster); + allerror = vtruncbuf(DETOV(dep), cred, td, length, pmp->pm_bpcluster); #ifdef MSDOSFS_DEBUG if (allerror) printf("detrunc(): vtruncbuf error %d\n", allerror); @@ -671,12 +671,12 @@ int msdosfs_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; struct denode *dep = VTODE(vp); - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; int error = 0; #ifdef MSDOSFS_DEBUG @@ -702,14 +702,14 @@ msdosfs_inactive(ap) dep, dep->de_refcnt, vp->v_mount->mnt_flag, MNT_RDONLY); #endif if (dep->de_refcnt <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) { - error = detrunc(dep, (u_long) 0, 0, NOCRED, p); + error = detrunc(dep, (u_long) 0, 0, NOCRED, td); dep->de_flag |= DE_UPDATE; dep->de_Name[0] = SLOT_DELETED; } deupdat(dep, 0); out: - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); /* * If we are done with the denode, reclaim it * so that it can be reused immediately. @@ -719,6 +719,6 @@ out: dep->de_Name[0]); #endif if (dep->de_Name[0] == SLOT_DELETED) - vrecycle(vp, NULL, p); + vrecycle(vp, NULL, td); return (error); } diff --git a/sys/fs/msdosfs/msdosfs_lookup.c b/sys/fs/msdosfs/msdosfs_lookup.c index 987ac3b..3f0bb76 100644 --- a/sys/fs/msdosfs/msdosfs_lookup.c +++ b/sys/fs/msdosfs/msdosfs_lookup.c @@ -110,7 +110,7 @@ msdosfs_lookup(ap) u_char dosfilename[12]; int flags = cnp->cn_flags; int nameiop = cnp->cn_nameiop; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; int unlen; int wincnt = 1; @@ -340,7 +340,7 @@ notfound: * Access for write is interpreted as allowing * creation of files in the directory. */ - error = VOP_ACCESS(vdp, VWRITE, cnp->cn_cred, cnp->cn_proc); + error = VOP_ACCESS(vdp, VWRITE, cnp->cn_cred, cnp->cn_thread); if (error) return (error); /* @@ -365,7 +365,7 @@ notfound: */ cnp->cn_flags |= SAVENAME; if (!lockparent) { - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } return (EJUSTRETURN); @@ -438,7 +438,7 @@ foundroot: /* * Write access to directory required to delete files. */ - error = VOP_ACCESS(vdp, VWRITE, cnp->cn_cred, cnp->cn_proc); + error = VOP_ACCESS(vdp, VWRITE, cnp->cn_cred, cnp->cn_thread); if (error) return (error); @@ -456,7 +456,7 @@ foundroot: return (error); *vpp = DETOV(tdp); if (!lockparent) { - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } return (0); @@ -473,7 +473,7 @@ foundroot: if (blkoff == MSDOSFSROOT_OFS) return EROFS; /* really? XXX */ - error = VOP_ACCESS(vdp, VWRITE, cnp->cn_cred, cnp->cn_proc); + error = VOP_ACCESS(vdp, VWRITE, cnp->cn_cred, cnp->cn_thread); if (error) return (error); @@ -489,7 +489,7 @@ foundroot: *vpp = DETOV(tdp); cnp->cn_flags |= SAVENAME; if (!lockparent) { - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } return (0); @@ -516,16 +516,16 @@ foundroot: */ pdp = vdp; if (flags & ISDOTDOT) { - VOP_UNLOCK(pdp, 0, p); + VOP_UNLOCK(pdp, 0, td); cnp->cn_flags |= PDIRUNLOCK; error = deget(pmp, cluster, blkoff, &tdp); if (error) { - vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, td); cnp->cn_flags &= ~PDIRUNLOCK; return (error); } if (lockparent && (flags & ISLASTCN)) { - error = vn_lock(pdp, LK_EXCLUSIVE, p); + error = vn_lock(pdp, LK_EXCLUSIVE, td); if (error) { vput(DETOV(tdp)); return (error); @@ -540,7 +540,7 @@ foundroot: if ((error = deget(pmp, cluster, blkoff, &tdp)) != 0) return (error); if (!lockparent || !(flags & ISLASTCN)) { - VOP_UNLOCK(pdp, 0, p); + VOP_UNLOCK(pdp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } *vpp = DETOV(tdp); diff --git a/sys/fs/msdosfs/msdosfs_vfsops.c b/sys/fs/msdosfs/msdosfs_vfsops.c index 1962daf..cd1e404 100644 --- a/sys/fs/msdosfs/msdosfs_vfsops.c +++ b/sys/fs/msdosfs/msdosfs_vfsops.c @@ -88,17 +88,17 @@ static MALLOC_DEFINE(M_MSDOSFSFAT, "MSDOSFS FAT", "MSDOSFS file allocation table static int update_mp __P((struct mount *mp, struct msdosfs_args *argp)); static int mountmsdosfs __P((struct vnode *devvp, struct mount *mp, - struct proc *p, struct msdosfs_args *argp)); + struct thread *td, struct msdosfs_args *argp)); static int msdosfs_fhtovp __P((struct mount *, struct fid *, struct vnode **)); static int msdosfs_mount __P((struct mount *, char *, caddr_t, - struct nameidata *, struct proc *)); + struct nameidata *, struct thread *)); static int msdosfs_root __P((struct mount *, struct vnode **)); static int msdosfs_statfs __P((struct mount *, struct statfs *, - struct proc *)); + struct thread *)); static int msdosfs_sync __P((struct mount *, int, struct ucred *, - struct proc *)); -static int msdosfs_unmount __P((struct mount *, int, struct proc *)); + struct thread *)); +static int msdosfs_unmount __P((struct mount *, int, struct thread *)); static int msdosfs_vptofh __P((struct vnode *, struct fid *)); static int @@ -159,7 +159,7 @@ int msdosfs_mountroot() { register struct mount *mp; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ size_t size; int error; struct msdosfs_args args; @@ -189,13 +189,13 @@ msdosfs_mountroot() } if ((error = update_mp(mp, &args)) != 0) { - (void)msdosfs_unmount(mp, 0, p); + (void)msdosfs_unmount(mp, 0, td); free(mp, M_MOUNT); return (error); } if ((error = vfs_lock(mp)) != 0) { - (void)msdosfs_unmount(mp, 0, p); + (void)msdosfs_unmount(mp, 0, td); free(mp, M_MOUNT); return (error); } @@ -208,7 +208,7 @@ msdosfs_mountroot() (void) copystr(ROOTNAME, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void)msdosfs_statfs(mp, &mp->mnt_stat, p); + (void)msdosfs_statfs(mp, &mp->mnt_stat, td); vfs_unlock(mp); return (0); } @@ -220,12 +220,12 @@ msdosfs_mountroot() * special file to treat as a filesystem. */ static int -msdosfs_mount(mp, path, data, ndp, p) +msdosfs_mount(mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { struct vnode *devvp; /* vnode for blk device to mount */ struct msdosfs_args args; /* will hold data from mount request */ @@ -263,16 +263,16 @@ msdosfs_mount(mp, path, data, ndp, p) * If upgrade to read-write by non-root, then verify * that user has necessary permissions on the device. */ - if (p->p_ucred->cr_uid != 0) { + if (td->td_proc->p_ucred->cr_uid != 0) { devvp = pmp->pm_devvp; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); error = VOP_ACCESS(devvp, VREAD | VWRITE, - p->p_ucred, p); + td->td_proc->p_ucred, td); if (error) { - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); return (error); } - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); } pmp->pm_flags &= ~MSDOSFSMNT_RONLY; } @@ -295,7 +295,7 @@ msdosfs_mount(mp, path, data, ndp, p) * Not an update, or updating the name: look up the name * and verify that it refers to a sensible block device. */ - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, td); error = namei(ndp); if (error) return (error); @@ -310,20 +310,20 @@ msdosfs_mount(mp, path, data, ndp, p) * If mount by non-root, then verify that user has necessary * permissions on the device. */ - if (p->p_ucred->cr_uid != 0) { + if (td->td_proc->p_ucred->cr_uid != 0) { accessmode = VREAD; if ((mp->mnt_flag & MNT_RDONLY) == 0) accessmode |= VWRITE; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_ACCESS(devvp, accessmode, td->td_proc->p_ucred, td); if (error) { vput(devvp); return (error); } - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); } if ((mp->mnt_flag & MNT_UPDATE) == 0) { - error = mountmsdosfs(devvp, mp, p, &args); + error = mountmsdosfs(devvp, mp, td, &args); #ifdef MSDOSFS_DEBUG /* only needed for the printf below */ pmp = VFSTOMSDOSFS(mp); #endif @@ -340,13 +340,13 @@ msdosfs_mount(mp, path, data, ndp, p) error = update_mp(mp, &args); if (error) { - msdosfs_unmount(mp, MNT_FORCE, p); + msdosfs_unmount(mp, MNT_FORCE, td); return error; } (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void) msdosfs_statfs(mp, &mp->mnt_stat, p); + (void) msdosfs_statfs(mp, &mp->mnt_stat, td); #ifdef MSDOSFS_DEBUG printf("msdosfs_mount(): mp %p, pmp %p, inusemap %p\n", mp, pmp, pmp->pm_inusemap); #endif @@ -354,10 +354,10 @@ msdosfs_mount(mp, path, data, ndp, p) } static int -mountmsdosfs(devvp, mp, p, argp) +mountmsdosfs(devvp, mp, td, argp) struct vnode *devvp; struct mount *mp; - struct proc *p; + struct thread *td; struct msdosfs_args *argp; { struct msdosfsmount *pmp; @@ -386,16 +386,16 @@ mountmsdosfs(devvp, mp, p, argp) return (error); if (vcount(devvp) > 1 && devvp != rootvp) return (EBUSY); - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0); - VOP_UNLOCK(devvp, 0, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = vinvalbuf(devvp, V_SAVE, td->td_proc->p_ucred, td, 0, 0); + VOP_UNLOCK(devvp, 0, td); if (error) return (error); ronly = (mp->mnt_flag & MNT_RDONLY) != 0; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p); - VOP_UNLOCK(devvp, 0, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, td); + VOP_UNLOCK(devvp, 0, td); if (error) return (error); @@ -415,7 +415,7 @@ mountmsdosfs(devvp, mp, p, argp) * Let's check it... */ error = VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, - FREAD, NOCRED, p); + FREAD, NOCRED, td); if (error) goto error_exit; tmp = dpart.part->p_fstype; @@ -724,7 +724,7 @@ mountmsdosfs(devvp, mp, p, argp) error_exit: if (bp) brelse(bp); - (void) VOP_CLOSE(devvp, ronly ? FREAD : FREAD | FWRITE, NOCRED, p); + (void) VOP_CLOSE(devvp, ronly ? FREAD : FREAD | FWRITE, NOCRED, td); if (pmp) { if (pmp->pm_inusemap) free(pmp->pm_inusemap, M_MSDOSFSFAT); @@ -738,10 +738,10 @@ error_exit: * Unmount the filesystem described by mp. */ static int -msdosfs_unmount(mp, mntflags, p) +msdosfs_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { struct msdosfsmount *pmp; int error, flags; @@ -778,7 +778,7 @@ msdosfs_unmount(mp, mntflags, p) #endif error = VOP_CLOSE(pmp->pm_devvp, (pmp->pm_flags&MSDOSFSMNT_RONLY) ? FREAD : FREAD | FWRITE, - NOCRED, p); + NOCRED, td); vrele(pmp->pm_devvp); free(pmp->pm_inusemap, M_MSDOSFSFAT); free(pmp, M_MSDOSFSMNT); @@ -807,10 +807,10 @@ msdosfs_root(mp, vpp) } static int -msdosfs_statfs(mp, sbp, p) +msdosfs_statfs(mp, sbp, td) struct mount *mp; struct statfs *sbp; - struct proc *p; + struct thread *td; { struct msdosfsmount *pmp; @@ -832,11 +832,11 @@ msdosfs_statfs(mp, sbp, p) } static int -msdosfs_sync(mp, waitfor, cred, p) +msdosfs_sync(mp, waitfor, cred, td) struct mount *mp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { struct vnode *vp, *nvp; struct denode *dep; @@ -879,17 +879,17 @@ loop: mtx_lock(&mntvnode_mtx); continue; } - error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, p); + error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, td); if (error) { mtx_lock(&mntvnode_mtx); if (error == ENOENT) goto loop; continue; } - error = VOP_FSYNC(vp, cred, waitfor, p); + error = VOP_FSYNC(vp, cred, waitfor, td); if (error) allerror = error; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vrele(vp); mtx_lock(&mntvnode_mtx); } @@ -899,11 +899,11 @@ loop: * Flush filesystem control info. */ if (waitfor != MNT_LAZY) { - vn_lock(pmp->pm_devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_FSYNC(pmp->pm_devvp, cred, waitfor, p); + vn_lock(pmp->pm_devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_FSYNC(pmp->pm_devvp, cred, waitfor, td); if (error) allerror = error; - VOP_UNLOCK(pmp->pm_devvp, 0, p); + VOP_UNLOCK(pmp->pm_devvp, 0, td); } return (allerror); } diff --git a/sys/fs/msdosfs/msdosfs_vnops.c b/sys/fs/msdosfs/msdosfs_vnops.c index 77d2760..bbdcecb 100644 --- a/sys/fs/msdosfs/msdosfs_vnops.c +++ b/sys/fs/msdosfs/msdosfs_vnops.c @@ -211,7 +211,7 @@ msdosfs_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -233,7 +233,7 @@ msdosfs_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -273,7 +273,7 @@ msdosfs_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct denode *dep = VTODE(ap->a_vp); @@ -339,7 +339,7 @@ msdosfs_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -351,7 +351,7 @@ msdosfs_setattr(ap) #ifdef MSDOSFS_DEBUG printf("msdosfs_setattr(): vp %p, vap %p, cred %p, p %p\n", - ap->a_vp, vap, cred, ap->a_p); + ap->a_vp, vap, cred, ap->a_td); #endif /* @@ -376,7 +376,7 @@ msdosfs_setattr(ap) if (vp->v_mount->mnt_flag & MNT_RDONLY) return (EROFS); if (cred->cr_uid != pmp->pm_uid && - (error = suser_xxx(cred, ap->a_p, PRISON_ROOT))) + (error = suser_xxx(cred, ap->a_td->td_proc, PRISON_ROOT))) return (error); /* * We are very inconsistent about handling unsupported @@ -417,7 +417,7 @@ msdosfs_setattr(ap) gid = pmp->pm_gid; if ((cred->cr_uid != pmp->pm_uid || uid != pmp->pm_uid || (gid != pmp->pm_gid && !groupmember(gid, cred))) && - (error = suser_xxx(cred, ap->a_p, PRISON_ROOT))) + (error = suser_xxx(cred, ap->a_td->td_proc, PRISON_ROOT))) return error; if (uid != pmp->pm_uid || gid != pmp->pm_gid) return EINVAL; @@ -441,7 +441,7 @@ msdosfs_setattr(ap) default: break; } - error = detrunc(dep, vap->va_size, 0, cred, ap->a_p); + error = detrunc(dep, vap->va_size, 0, cred, ap->a_td); if (error) return error; } @@ -449,9 +449,9 @@ msdosfs_setattr(ap) if (vp->v_mount->mnt_flag & MNT_RDONLY) return (EROFS); if (cred->cr_uid != pmp->pm_uid && - (error = suser_xxx(cred, ap->a_p, PRISON_ROOT)) && + (error = suser_xxx(cred, ap->a_td->td_proc, PRISON_ROOT)) && ((vap->va_vaflags & VA_UTIMES_NULL) == 0 || - (error = VOP_ACCESS(ap->a_vp, VWRITE, cred, ap->a_p)))) + (error = VOP_ACCESS(ap->a_vp, VWRITE, cred, ap->a_td)))) return (error); if (vp->v_type != VDIR) { if ((pmp->pm_flags & MSDOSFSMNT_NOWIN95) == 0 && @@ -472,7 +472,7 @@ msdosfs_setattr(ap) if (vp->v_mount->mnt_flag & MNT_RDONLY) return (EROFS); if (cred->cr_uid != pmp->pm_uid && - (error = suser_xxx(cred, ap->a_p, PRISON_ROOT))) + (error = suser_xxx(cred, ap->a_td->td_proc, PRISON_ROOT))) return (error); if (vp->v_type != VDIR) { /* We ignore the read and execute bits. */ @@ -601,7 +601,7 @@ msdosfs_write(ap) struct buf *bp; int ioflag = ap->a_ioflag; struct uio *uio = ap->a_uio; - struct proc *p = uio->uio_procp; + struct thread *td = uio->uio_td; struct vnode *vp = ap->a_vp; struct vnode *thisvp; struct denode *dep = VTODE(vp); @@ -636,12 +636,12 @@ msdosfs_write(ap) /* * If they've exceeded their filesize limit, tell them about it. */ - if (p && + if (td && ((uoff_t)uio->uio_offset + uio->uio_resid > - p->p_rlimit[RLIMIT_FSIZE].rlim_cur)) { - PROC_LOCK(p); - psignal(p, SIGXFSZ); - PROC_UNLOCK(p); + td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur)) { + PROC_LOCK(td->td_proc); + psignal(td->td_proc, SIGXFSZ); + PROC_UNLOCK(td->td_proc); return (EFBIG); } @@ -795,7 +795,7 @@ msdosfs_fsync(ap) struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -931,7 +931,7 @@ msdosfs_rename(ap) struct vnode *tvp = ap->a_tvp; struct componentname *tcnp = ap->a_tcnp; struct componentname *fcnp = ap->a_fcnp; - struct proc *p = fcnp->cn_proc; + struct thread *td = fcnp->cn_thread; struct denode *ip, *xp, *dp, *zp; u_char toname[11], oldname[11]; u_long from_diroffset, to_diroffset; @@ -987,7 +987,7 @@ abortit: goto abortit; } - error = vn_lock(fvp, LK_EXCLUSIVE, p); + error = vn_lock(fvp, LK_EXCLUSIVE, td); if (error) goto abortit; dp = VTODE(fdvp); @@ -1008,7 +1008,7 @@ abortit: (fcnp->cn_flags & ISDOTDOT) || (tcnp->cn_flags & ISDOTDOT) || (ip->de_flag & DE_RENAME)) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); error = EINVAL; goto abortit; } @@ -1038,8 +1038,8 @@ abortit: * to namei, as the parent directory is unlocked by the * call to doscheckpath(). */ - error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc); - VOP_UNLOCK(fvp, 0, p); + error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_thread); + VOP_UNLOCK(fvp, 0, td); if (VTODE(fdvp)->de_StartCluster != VTODE(tdvp)->de_StartCluster) newparent = 1; if (doingdirectory && newparent) { @@ -1108,7 +1108,7 @@ abortit: if ((fcnp->cn_flags & SAVESTART) == 0) panic("msdosfs_rename: lost from startdir"); if (!newparent) - VOP_UNLOCK(tdvp, 0, p); + VOP_UNLOCK(tdvp, 0, td); if (relookup(fdvp, &fvp, fcnp) == 0) vrele(fdvp); if (fvp == NULL) { @@ -1119,7 +1119,7 @@ abortit: panic("rename: lost dir entry"); vrele(ap->a_fvp); if (newparent) - VOP_UNLOCK(tdvp, 0, p); + VOP_UNLOCK(tdvp, 0, td); vrele(tdvp); return 0; } @@ -1139,9 +1139,9 @@ abortit: if (doingdirectory) panic("rename: lost dir entry"); vrele(ap->a_fvp); - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); if (newparent) - VOP_UNLOCK(fdvp, 0, p); + VOP_UNLOCK(fdvp, 0, td); xp = NULL; } else { vrele(fvp); @@ -1163,8 +1163,8 @@ abortit: if (error) { bcopy(oldname, ip->de_Name, 11); if (newparent) - VOP_UNLOCK(fdvp, 0, p); - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fdvp, 0, td); + VOP_UNLOCK(fvp, 0, td); goto bad; } ip->de_refcnt++; @@ -1173,8 +1173,8 @@ abortit: if (error) { /* XXX should really panic here, fs is corrupt */ if (newparent) - VOP_UNLOCK(fdvp, 0, p); - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fdvp, 0, td); + VOP_UNLOCK(fvp, 0, td); goto bad; } if (!doingdirectory) { @@ -1183,8 +1183,8 @@ abortit: if (error) { /* XXX should really panic here, fs is corrupt */ if (newparent) - VOP_UNLOCK(fdvp, 0, p); - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fdvp, 0, td); + VOP_UNLOCK(fvp, 0, td); goto bad; } if (ip->de_dirclust == MSDOSFSROOT) @@ -1194,7 +1194,7 @@ abortit: } reinsert(ip); if (newparent) - VOP_UNLOCK(fdvp, 0, p); + VOP_UNLOCK(fdvp, 0, td); } /* @@ -1213,7 +1213,7 @@ abortit: if (error) { /* XXX should really panic here, fs is corrupt */ brelse(bp); - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); goto bad; } dotdotp = (struct direntry *)bp->b_data + 1; @@ -1223,12 +1223,12 @@ abortit: error = bwrite(bp); if (error) { /* XXX should really panic here, fs is corrupt */ - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); goto bad; } } - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); bad: if (xp) vput(tvp); @@ -1392,7 +1392,7 @@ msdosfs_rmdir(ap) register struct vnode *dvp = ap->a_dvp; register struct componentname *cnp = ap->a_cnp; register struct denode *ip, *dp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; int error; ip = VTODE(vp); @@ -1427,14 +1427,14 @@ msdosfs_rmdir(ap) * the name cache. */ cache_purge(dvp); - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); /* * Truncate the directory that is being deleted. */ - error = detrunc(ip, (u_long)0, IO_SYNC, cnp->cn_cred, p); + error = detrunc(ip, (u_long)0, IO_SYNC, cnp->cn_cred, td); cache_purge(vp); - vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td); out: return (error); } diff --git a/sys/fs/ntfs/ntfs_subr.c b/sys/fs/ntfs/ntfs_subr.c index e1e6006..c215741 100644 --- a/sys/fs/ntfs/ntfs_subr.c +++ b/sys/fs/ntfs/ntfs_subr.c @@ -227,7 +227,7 @@ ntfs_ntvattrget( vget() */ error = ntfs_vgetex(ntmp->ntm_mountp, aalp->al_inumber, NTFS_A_DATA, NULL, LK_EXCLUSIVE, - VG_EXT, curproc, &newvp); + VG_EXT, curthread, &newvp); if (error) { printf("ntfs_ntvattrget: CAN'T VGET INO: %d\n", aalp->al_inumber); diff --git a/sys/fs/ntfs/ntfs_vfsops.c b/sys/fs/ntfs/ntfs_vfsops.c index 26a09b8..19e6925 100644 --- a/sys/fs/ntfs/ntfs_vfsops.c +++ b/sys/fs/ntfs/ntfs_vfsops.c @@ -76,36 +76,36 @@ MALLOC_DEFINE(M_NTFSDIR,"NTFS dir", "NTFS dir buffer"); static int ntfs_root __P((struct mount *, struct vnode **)); static int ntfs_statfs __P((struct mount *, struct statfs *, - struct proc *)); -static int ntfs_unmount __P((struct mount *, int, struct proc *)); + struct thread *)); +static int ntfs_unmount __P((struct mount *, int, struct thread *)); static int ntfs_vget __P((struct mount *mp, ino_t ino, struct vnode **vpp)); static int ntfs_mountfs __P((register struct vnode *, struct mount *, - struct ntfs_args *, struct proc *)); + struct ntfs_args *, struct thread *)); static int ntfs_vptofh __P((struct vnode *, struct fid *)); static int ntfs_fhtovp __P((struct mount *, struct fid *, struct vnode **)); #if !defined (__FreeBSD__) static int ntfs_quotactl __P((struct mount *, int, uid_t, caddr_t, - struct proc *)); -static int ntfs_start __P((struct mount *, int, struct proc *)); + struct thread *)); +static int ntfs_start __P((struct mount *, int, struct thread *)); static int ntfs_sync __P((struct mount *, int, struct ucred *, - struct proc *)); + struct thread *)); #endif #if defined(__FreeBSD__) struct sockaddr; static int ntfs_mount __P((struct mount *, char *, caddr_t, - struct nameidata *, struct proc *)); + struct nameidata *, struct thread *)); static int ntfs_init __P((struct vfsconf *)); #elif defined(__NetBSD__) static int ntfs_mount __P((struct mount *, const char *, void *, - struct nameidata *, struct proc *)); + struct nameidata *, struct thread *)); static void ntfs_init __P((void)); static int ntfs_mountroot __P((void)); static int ntfs_sysctl __P((int *, u_int, void *, size_t *, void *, - size_t, struct proc *)); + size_t, struct thread *)); static int ntfs_checkexp __P((struct mount *, struct mbuf *, int *, struct ucred **)); #endif @@ -180,7 +180,7 @@ ntfs_mountroot() args.gid = 0; args.mode = 0777; - if ((error = ntfs_mountfs(rootvp, mp, &args, p)) != 0) { + if ((error = ntfs_mountfs(rootvp, mp, &args, td)) != 0) { mp->mnt_op->vfs_refcount--; vfs_unbusy(mp); free(mp, M_MOUNT); @@ -191,7 +191,7 @@ ntfs_mountroot() mtx_lock(&mountlist_mtx); TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list); mtx_unlock(&mountlist_mtx); - (void)ntfs_statfs(mp, &mp->mnt_stat, p); + (void)ntfs_statfs(mp, &mp->mnt_stat, td); vfs_unbusy(mp); return (0); } @@ -236,7 +236,7 @@ ntfs_mount ( void *data, #endif struct nameidata *ndp, - struct proc *p ) + struct thread *td ) { size_t size; int err = 0; @@ -266,7 +266,7 @@ ntfs_mount ( /* * Attempt mount */ - if( ( err = ntfs_mountfs(rootvp, mp, &args, p)) != 0) { + if( ( err = ntfs_mountfs(rootvp, mp, &args, td)) != 0) { /* fs specific cleanup (if any)*/ goto error_1; } @@ -316,7 +316,7 @@ ntfs_mount ( * Not an update, or updating the name: look up the name * and verify that it refers to a sensible block device. */ - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, td); err = namei(ndp); if (err) { /* can't get devvp!*/ @@ -385,7 +385,7 @@ ntfs_mount ( &size); /* real size*/ bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - err = ntfs_mountfs(devvp, mp, &args, p); + err = ntfs_mountfs(devvp, mp, &args, td); } if (err) { goto error_2; @@ -400,7 +400,7 @@ dostatfs: * * This code is common to root and non-root mounts */ - (void)VFS_STATFS(mp, &mp->mnt_stat, p); + (void)VFS_STATFS(mp, &mp->mnt_stat, td); goto success; @@ -420,11 +420,11 @@ success: * Common code for mount and mountroot */ int -ntfs_mountfs(devvp, mp, argsp, p) +ntfs_mountfs(devvp, mp, argsp, td) register struct vnode *devvp; struct mount *mp; struct ntfs_args *argsp; - struct proc *p; + struct thread *td; { struct buf *bp; struct ntfsmount *ntmp; @@ -449,19 +449,19 @@ ntfs_mountfs(devvp, mp, argsp, p) if (ncount > 1 && devvp != rootvp) return (EBUSY); #if defined(__FreeBSD__) - VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0); - VOP__UNLOCK(devvp, 0, p); + VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = vinvalbuf(devvp, V_SAVE, td->td_proc->p_ucred, td, 0, 0); + VOP__UNLOCK(devvp, 0, td); #else - error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0); + error = vinvalbuf(devvp, V_SAVE, td->td_proc->p_ucred, td, 0, 0); #endif if (error) return (error); ronly = (mp->mnt_flag & MNT_RDONLY) != 0; - VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p); - VOP__UNLOCK(devvp, 0, p); + VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, td); + VOP__UNLOCK(devvp, 0, td); if (error) return (error); @@ -624,11 +624,11 @@ out: #if defined __NetBSD__ /* lock the device vnode before calling VOP_CLOSE() */ - VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, p); - (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p); - VOP__UNLOCK(devvp, 0, p); + VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, td); + (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, td); + VOP__UNLOCK(devvp, 0, td); #else - (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p); + (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, td); #endif return (error); @@ -639,7 +639,7 @@ static int ntfs_start ( struct mount *mp, int flags, - struct proc *p ) + struct thread *td ) { return (0); } @@ -649,7 +649,7 @@ static int ntfs_unmount( struct mount *mp, int mntflags, - struct proc *p) + struct thread *td) { register struct ntfsmount *ntmp; int error, ronly = 0, flags, i; @@ -689,17 +689,17 @@ ntfs_unmount( if (ntmp->ntm_devvp->v_type != VBAD) ntmp->ntm_devvp->v_rdev->si_mountpoint = NULL; - vinvalbuf(ntmp->ntm_devvp, V_SAVE, NOCRED, p, 0, 0); + vinvalbuf(ntmp->ntm_devvp, V_SAVE, NOCRED, td, 0, 0); #if defined(__NetBSD__) /* lock the device vnode before calling VOP_CLOSE() */ VOP_LOCK(ntmp->ntm_devvp, LK_EXCLUSIVE | LK_RETRY); error = VOP_CLOSE(ntmp->ntm_devvp, ronly ? FREAD : FREAD|FWRITE, - NOCRED, p); - VOP__UNLOCK(ntmp->ntm_devvp, 0, p); + NOCRED, td); + VOP__UNLOCK(ntmp->ntm_devvp, 0, td); #else error = VOP_CLOSE(ntmp->ntm_devvp, ronly ? FREAD : FREAD|FWRITE, - NOCRED, p); + NOCRED, td); #endif vrele(ntmp->ntm_devvp); @@ -744,7 +744,7 @@ ntfs_quotactl ( int cmds, uid_t uid, caddr_t arg, - struct proc *p) + struct thread *td) { printf("\nntfs_quotactl():\n"); return EOPNOTSUPP; @@ -787,7 +787,7 @@ static int ntfs_statfs( struct mount *mp, struct statfs *sbp, - struct proc *p) + struct thread *td) { struct ntfsmount *ntmp = VFSTONTFS(mp); u_int64_t mftsize,mftallocated; @@ -831,7 +831,7 @@ ntfs_sync ( struct mount *mp, int waitfor, struct ucred *cred, - struct proc *p) + struct thread *td) { /*dprintf(("ntfs_sync():\n"));*/ return (0); @@ -888,7 +888,7 @@ ntfs_vgetex( char *attrname, u_long lkflags, u_long flags, - struct proc *p, + struct thread *td, struct vnode **vpp) { int error; @@ -953,7 +953,7 @@ ntfs_vgetex( } if (FTOV(fp)) { - VGET(FTOV(fp), lkflags, p); + VGET(FTOV(fp), lkflags, td); *vpp = FTOV(fp); ntfs_ntput(ip); return (0); @@ -980,7 +980,7 @@ ntfs_vgetex( ntfs_ntput(ip); if (lkflags & LK_TYPE_MASK) { - error = VN_LOCK(vp, lkflags, p); + error = VN_LOCK(vp, lkflags, td); if (error) { vput(vp); return (error); @@ -999,7 +999,7 @@ ntfs_vget( struct vnode **vpp) { return ntfs_vgetex(mp, ino, NTFS_A_DATA, NULL, - LK_EXCLUSIVE | LK_RETRY, 0, curproc, vpp); + LK_EXCLUSIVE | LK_RETRY, 0, curthread, vpp); } #if defined(__FreeBSD__) diff --git a/sys/fs/ntfs/ntfs_vfsops.h b/sys/fs/ntfs/ntfs_vfsops.h index c05686f..b82877a 100644 --- a/sys/fs/ntfs/ntfs_vfsops.h +++ b/sys/fs/ntfs/ntfs_vfsops.h @@ -36,9 +36,9 @@ struct mount; struct ntfsmount; -struct proc; +struct thread; struct vnode; int ntfs_vgetex(struct mount *, ino_t, u_int32_t, char *, u_long, u_long, - struct proc *, struct vnode **); + struct thread *, struct vnode **); int ntfs_calccfree(struct ntfsmount *, cn_t *); diff --git a/sys/fs/ntfs/ntfs_vnops.c b/sys/fs/ntfs/ntfs_vnops.c index 5c2297f..baad440 100644 --- a/sys/fs/ntfs/ntfs_vnops.c +++ b/sys/fs/ntfs/ntfs_vnops.c @@ -191,7 +191,7 @@ ntfs_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -245,7 +245,7 @@ ntfs_inactive(ap) if (ntfs_prtactive && vp->v_usecount != 0) vprint("ntfs_inactive: pushing active", vp); - VOP__UNLOCK(vp, 0, ap->a_p); + VOP__UNLOCK(vp, 0, ap->a_td); /* XXX since we don't support any filesystem changes * right now, nothing more needs to be done @@ -423,7 +423,7 @@ ntfs_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -471,7 +471,7 @@ ntfs_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { #if NTFS_DEBUG @@ -500,7 +500,7 @@ ntfs_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { #if NTFS_DEBUG @@ -674,7 +674,7 @@ ntfs_lookup(ap) (int)cnp->cn_namelen, cnp->cn_nameptr, cnp->cn_namelen, dip->i_number, lockparent, wantparent)); - error = VOP_ACCESS(dvp, VEXEC, cred, cnp->cn_proc); + error = VOP_ACCESS(dvp, VEXEC, cred, cnp->cn_thread); if(error) return (error); @@ -713,7 +713,7 @@ ntfs_lookup(ap) if(error) return (error); - VOP__UNLOCK(dvp,0,cnp->cn_proc); + VOP__UNLOCK(dvp,0,cnp->cn_thread); cnp->cn_flags |= PDIRUNLOCK; dprintf(("ntfs_lookup: parentdir: %d\n", @@ -722,13 +722,13 @@ ntfs_lookup(ap) vap->va_a_name->n_pnumber,ap->a_vpp); ntfs_ntvattrrele(vap); if (error) { - if (VN_LOCK(dvp,LK_EXCLUSIVE|LK_RETRY,cnp->cn_proc)==0) + if (VN_LOCK(dvp,LK_EXCLUSIVE|LK_RETRY,cnp->cn_thread)==0) cnp->cn_flags &= ~PDIRUNLOCK; return (error); } if (lockparent && (cnp->cn_flags & ISLASTCN)) { - error = VN_LOCK(dvp, LK_EXCLUSIVE, cnp->cn_proc); + error = VN_LOCK(dvp, LK_EXCLUSIVE, cnp->cn_thread); if (error) { vput( *(ap->a_vpp) ); return (error); @@ -746,7 +746,7 @@ ntfs_lookup(ap) VTONT(*ap->a_vpp)->i_number)); if(!lockparent || !(cnp->cn_flags & ISLASTCN)) - VOP__UNLOCK(dvp, 0, cnp->cn_proc); + VOP__UNLOCK(dvp, 0, cnp->cn_thread); } if (cnp->cn_flags & MAKEENTRY) @@ -768,7 +768,7 @@ ntfs_fsync(ap) struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; - struct proc *a_p; + struct thread *a_td; } */ *ap; { return (0); diff --git a/sys/fs/nullfs/null_subr.c b/sys/fs/nullfs/null_subr.c index 97aa492..add959e 100644 --- a/sys/fs/nullfs/null_subr.c +++ b/sys/fs/nullfs/null_subr.c @@ -110,7 +110,7 @@ null_node_find(mp, lowervp) struct mount *mp; struct vnode *lowervp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct null_node_hashhead *hd; struct null_node *a; struct vnode *vp; @@ -123,17 +123,17 @@ null_node_find(mp, lowervp) */ hd = NULL_NHASH(lowervp); loop: - lockmgr(&null_hashlock, LK_EXCLUSIVE, NULL, p); + lockmgr(&null_hashlock, LK_EXCLUSIVE, NULL, td); LIST_FOREACH(a, hd, null_hash) { if (a->null_lowervp == lowervp && NULLTOV(a)->v_mount == mp) { vp = NULLTOV(a); - lockmgr(&null_hashlock, LK_RELEASE, NULL, p); + lockmgr(&null_hashlock, LK_RELEASE, NULL, td); /* * We need vget for the VXLOCK * stuff, but we don't want to lock * the lower node. */ - if (vget(vp, LK_EXCLUSIVE | LK_CANRECURSE, p)) { + if (vget(vp, LK_EXCLUSIVE | LK_CANRECURSE, td)) { printf ("null_node_find: vget failed.\n"); goto loop; }; @@ -141,11 +141,11 @@ loop: * Now we got both vnodes locked, so release the * lower one. */ - VOP_UNLOCK(lowervp, 0, p); + VOP_UNLOCK(lowervp, 0, td); return (vp); } } - lockmgr(&null_hashlock, LK_RELEASE, NULL, p); + lockmgr(&null_hashlock, LK_RELEASE, NULL, td); return NULLVP; } @@ -162,7 +162,7 @@ null_node_alloc(mp, lowervp, vpp) struct vnode *lowervp; struct vnode **vpp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct null_node_hashhead *hd; struct null_node *xp; struct vnode *othervp, *vp; @@ -211,16 +211,16 @@ null_node_alloc(mp, lowervp, vpp) * NULL, then we copy that up and manually lock the new vnode. */ - lockmgr(&null_hashlock, LK_EXCLUSIVE, NULL, p); + lockmgr(&null_hashlock, LK_EXCLUSIVE, NULL, td); vp->v_vnlock = lowervp->v_vnlock; - error = VOP_LOCK(vp, LK_EXCLUSIVE | LK_THISLAYER, p); + error = VOP_LOCK(vp, LK_EXCLUSIVE | LK_THISLAYER, td); if (error) panic("null_node_alloc: can't lock new vnode\n"); VREF(lowervp); hd = NULL_NHASH(lowervp); LIST_INSERT_HEAD(hd, xp, null_hash); - lockmgr(&null_hashlock, LK_RELEASE, NULL, p); + lockmgr(&null_hashlock, LK_RELEASE, NULL, td); return 0; } diff --git a/sys/fs/nullfs/null_vfsops.c b/sys/fs/nullfs/null_vfsops.c index f707751..1ab0aaa 100644 --- a/sys/fs/nullfs/null_vfsops.c +++ b/sys/fs/nullfs/null_vfsops.c @@ -63,33 +63,33 @@ static int nullfs_fhtovp(struct mount *mp, struct fid *fidp, static int nullfs_checkexp(struct mount *mp, struct sockaddr *nam, int *extflagsp, struct ucred **credanonp); static int nullfs_mount(struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p); + struct nameidata *ndp, struct thread *td); static int nullfs_quotactl(struct mount *mp, int cmd, uid_t uid, - caddr_t arg, struct proc *p); + caddr_t arg, struct thread *td); static int nullfs_root(struct mount *mp, struct vnode **vpp); -static int nullfs_start(struct mount *mp, int flags, struct proc *p); +static int nullfs_start(struct mount *mp, int flags, struct thread *td); static int nullfs_statfs(struct mount *mp, struct statfs *sbp, - struct proc *p); + struct thread *td); static int nullfs_sync(struct mount *mp, int waitfor, - struct ucred *cred, struct proc *p); -static int nullfs_unmount(struct mount *mp, int mntflags, struct proc *p); + struct ucred *cred, struct thread *td); +static int nullfs_unmount(struct mount *mp, int mntflags, struct thread *td); static int nullfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp); static int nullfs_vptofh(struct vnode *vp, struct fid *fhp); static int nullfs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp, int namespace, const char *attrname, - struct proc *p); + struct thread *td); /* * Mount null layer */ static int -nullfs_mount(mp, path, data, ndp, p) +nullfs_mount(mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { int error = 0; struct null_args args; @@ -106,7 +106,7 @@ nullfs_mount(mp, path, data, ndp, p) */ if (mp->mnt_flag & MNT_UPDATE) { return (EOPNOTSUPP); - /* return VFS_MOUNT(MOUNTTONULLMOUNT(mp)->nullm_vfs, path, data, ndp, p);*/ + /* return VFS_MOUNT(MOUNTTONULLMOUNT(mp)->nullm_vfs, path, data, ndp, td);*/ } /* @@ -122,20 +122,20 @@ nullfs_mount(mp, path, data, ndp, p) */ if ((mp->mnt_vnodecovered->v_op == null_vnodeop_p) && VOP_ISLOCKED(mp->mnt_vnodecovered, NULL)) { - VOP_UNLOCK(mp->mnt_vnodecovered, 0, p); + VOP_UNLOCK(mp->mnt_vnodecovered, 0, td); isvnunlocked = 1; } /* * Find lower node */ NDINIT(ndp, LOOKUP, FOLLOW|WANTPARENT|LOCKLEAF, - UIO_USERSPACE, args.target, p); + UIO_USERSPACE, args.target, td); error = namei(ndp); /* * Re-lock vnode. */ if (isvnunlocked && !VOP_ISLOCKED(mp->mnt_vnodecovered, NULL)) - vn_lock(mp->mnt_vnodecovered, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(mp->mnt_vnodecovered, LK_EXCLUSIVE | LK_RETRY, td); if (error) return (error); @@ -174,7 +174,7 @@ nullfs_mount(mp, path, data, ndp, p) /* * Unlock the node (either the lower or the alias) */ - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); /* * Make sure the node alias worked */ @@ -199,7 +199,7 @@ nullfs_mount(mp, path, data, ndp, p) (void) copyinstr(args.target, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void)nullfs_statfs(mp, &mp->mnt_stat, p); + (void)nullfs_statfs(mp, &mp->mnt_stat, td); NULLFSDEBUG("nullfs_mount: lower %s, alias at %s\n", mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname); return (0); @@ -211,23 +211,23 @@ nullfs_mount(mp, path, data, ndp, p) * when that filesystem was mounted. */ static int -nullfs_start(mp, flags, p) +nullfs_start(mp, flags, td) struct mount *mp; int flags; - struct proc *p; + struct thread *td; { return (0); - /* return VFS_START(MOUNTTONULLMOUNT(mp)->nullm_vfs, flags, p); */ + /* return VFS_START(MOUNTTONULLMOUNT(mp)->nullm_vfs, flags, td); */ } /* * Free reference to null layer */ static int -nullfs_unmount(mp, mntflags, p) +nullfs_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { void *mntdata; int error; @@ -257,7 +257,7 @@ nullfs_root(mp, vpp) struct mount *mp; struct vnode **vpp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct vnode *vp; NULLFSDEBUG("nullfs_root(mp = %p, vp = %p->%p)\n", (void *)mp, @@ -277,27 +277,27 @@ nullfs_root(mp, vpp) return (EDEADLK); } #endif - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); *vpp = vp; return 0; } static int -nullfs_quotactl(mp, cmd, uid, arg, p) +nullfs_quotactl(mp, cmd, uid, arg, td) struct mount *mp; int cmd; uid_t uid; caddr_t arg; - struct proc *p; + struct thread *td; { - return VFS_QUOTACTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, uid, arg, p); + return VFS_QUOTACTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, uid, arg, td); } static int -nullfs_statfs(mp, sbp, p) +nullfs_statfs(mp, sbp, td) struct mount *mp; struct statfs *sbp; - struct proc *p; + struct thread *td; { int error; struct statfs mstat; @@ -308,7 +308,7 @@ nullfs_statfs(mp, sbp, p) bzero(&mstat, sizeof(mstat)); - error = VFS_STATFS(MOUNTTONULLMOUNT(mp)->nullm_vfs, &mstat, p); + error = VFS_STATFS(MOUNTTONULLMOUNT(mp)->nullm_vfs, &mstat, td); if (error) return (error); @@ -331,11 +331,11 @@ nullfs_statfs(mp, sbp, p) } static int -nullfs_sync(mp, waitfor, cred, p) +nullfs_sync(mp, waitfor, cred, td) struct mount *mp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { /* * XXX - Assumes no data cached at null layer. @@ -392,16 +392,16 @@ nullfs_vptofh(vp, fhp) } static int -nullfs_extattrctl(mp, cmd, filename_vp, namespace, attrname, p) +nullfs_extattrctl(mp, cmd, filename_vp, namespace, attrname, td) struct mount *mp; int cmd; struct vnode *filename_vp; int namespace; const char *attrname; - struct proc *p; + struct thread *td; { return VFS_EXTATTRCTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, filename_vp, - namespace, attrname, p); + namespace, attrname, td); } diff --git a/sys/fs/nullfs/null_vnops.c b/sys/fs/nullfs/null_vnops.c index 0801c0b..3683ac1 100644 --- a/sys/fs/nullfs/null_vnops.c +++ b/sys/fs/nullfs/null_vnops.c @@ -320,7 +320,7 @@ null_bypass(ap) *(vps_p[i]) = old_vps[i]; #if 0 if (reles & VDESC_VP0_WILLUNLOCK) - VOP_UNLOCK(*(vps_p[i]), LK_THISLAYER, curproc); + VOP_UNLOCK(*(vps_p[i]), LK_THISLAYER, curthread); #endif if (reles & VDESC_VP0_WILLRELE) vrele(*(vps_p[i])); @@ -368,7 +368,7 @@ null_lookup(ap) { struct componentname *cnp = ap->a_cnp; struct vnode *dvp = ap->a_dvp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; int flags = cnp->cn_flags; struct vnode *vp, *ldvp, *lvp; int error; @@ -393,7 +393,7 @@ null_lookup(ap) * tracked by underlying filesystem. */ if (cnp->cn_flags & PDIRUNLOCK) - VOP_UNLOCK(dvp, LK_THISLAYER, p); + VOP_UNLOCK(dvp, LK_THISLAYER, td); if ((error == 0 || error == EJUSTRETURN) && lvp != NULL) { if (ldvp == lvp) { *ap->a_vpp = dvp; @@ -418,7 +418,7 @@ null_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -464,7 +464,7 @@ null_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { int error; @@ -485,7 +485,7 @@ null_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -520,7 +520,7 @@ null_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -581,12 +581,12 @@ null_lock(ap) struct vop_lock_args /* { struct vnode *a_vp; int a_flags; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; int flags = ap->a_flags; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; struct vnode *lvp; int error; @@ -594,7 +594,7 @@ null_lock(ap) if (vp->v_vnlock != NULL) return 0; /* lock is shared across layers */ error = lockmgr(&vp->v_lock, flags & ~LK_THISLAYER, - &vp->v_interlock, p); + &vp->v_interlock, td); return (error); } @@ -611,9 +611,9 @@ null_lock(ap) NULLFSDEBUG("null_lock: avoiding LK_DRAIN\n"); return(lockmgr(vp->v_vnlock, (flags & ~LK_TYPE_MASK) | LK_EXCLUSIVE, - &vp->v_interlock, p)); + &vp->v_interlock, td)); } - return(lockmgr(vp->v_vnlock, flags, &vp->v_interlock, p)); + return(lockmgr(vp->v_vnlock, flags, &vp->v_interlock, td)); } else { /* * To prevent race conditions involving doing a lookup @@ -625,21 +625,21 @@ null_lock(ap) */ lvp = NULLVPTOLOWERVP(vp); if (lvp == NULL) - return (lockmgr(&vp->v_lock, flags, &vp->v_interlock, p)); + return (lockmgr(&vp->v_lock, flags, &vp->v_interlock, td)); if (flags & LK_INTERLOCK) { mtx_unlock(&vp->v_interlock); flags &= ~LK_INTERLOCK; } if ((flags & LK_TYPE_MASK) == LK_DRAIN) { error = VOP_LOCK(lvp, - (flags & ~LK_TYPE_MASK) | LK_EXCLUSIVE, p); + (flags & ~LK_TYPE_MASK) | LK_EXCLUSIVE, td); } else - error = VOP_LOCK(lvp, flags, p); + error = VOP_LOCK(lvp, flags, td); if (error) return (error); - error = lockmgr(&vp->v_lock, flags, &vp->v_interlock, p); + error = lockmgr(&vp->v_lock, flags, &vp->v_interlock, td); if (error) - VOP_UNLOCK(lvp, 0, p); + VOP_UNLOCK(lvp, 0, td); return (error); } } @@ -654,12 +654,12 @@ null_unlock(ap) struct vop_unlock_args /* { struct vnode *a_vp; int a_flags; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; int flags = ap->a_flags; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; struct vnode *lvp; if (vp->v_vnlock != NULL) { @@ -667,35 +667,35 @@ null_unlock(ap) return 0; /* the lock is shared across layers */ flags &= ~LK_THISLAYER; return (lockmgr(vp->v_vnlock, flags | LK_RELEASE, - &vp->v_interlock, p)); + &vp->v_interlock, td)); } lvp = NULLVPTOLOWERVP(vp); if (lvp == NULL) - return (lockmgr(&vp->v_lock, flags | LK_RELEASE, &vp->v_interlock, p)); + return (lockmgr(&vp->v_lock, flags | LK_RELEASE, &vp->v_interlock, td)); if ((flags & LK_THISLAYER) == 0) { if (flags & LK_INTERLOCK) { mtx_unlock(&vp->v_interlock); flags &= ~LK_INTERLOCK; } - VOP_UNLOCK(lvp, flags & ~LK_INTERLOCK, p); + VOP_UNLOCK(lvp, flags & ~LK_INTERLOCK, td); } else flags &= ~LK_THISLAYER; - return (lockmgr(&vp->v_lock, flags | LK_RELEASE, &vp->v_interlock, p)); + return (lockmgr(&vp->v_lock, flags | LK_RELEASE, &vp->v_interlock, td)); } static int null_islocked(ap) struct vop_islocked_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; if (vp->v_vnlock != NULL) - return (lockstatus(vp->v_vnlock, p)); - return (lockstatus(&vp->v_lock, p)); + return (lockstatus(vp->v_vnlock, td)); + return (lockstatus(&vp->v_lock, td)); } /* @@ -707,23 +707,23 @@ static int null_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; struct null_node *xp = VTONULL(vp); struct vnode *lowervp = xp->null_lowervp; - lockmgr(&null_hashlock, LK_EXCLUSIVE, NULL, p); + lockmgr(&null_hashlock, LK_EXCLUSIVE, NULL, td); LIST_REMOVE(xp, null_hash); - lockmgr(&null_hashlock, LK_RELEASE, NULL, p); + lockmgr(&null_hashlock, LK_RELEASE, NULL, td); xp->null_lowervp = NULLVP; if (vp->v_vnlock != NULL) { vp->v_vnlock = &vp->v_lock; /* we no longer share the lock */ } else - VOP_UNLOCK(vp, LK_THISLAYER, p); + VOP_UNLOCK(vp, LK_THISLAYER, td); vput(lowervp); /* @@ -743,7 +743,7 @@ static int null_reclaim(ap) struct vop_reclaim_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -774,7 +774,7 @@ null_createvobject(ap) struct vop_createvobject_args /* { struct vnode *vp; struct ucred *cred; - struct proc *p; + struct thread *td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -783,7 +783,7 @@ null_createvobject(ap) if (vp->v_type == VNON || lowervp == NULL) return 0; - error = VOP_CREATEVOBJECT(lowervp, ap->a_cred, ap->a_p); + error = VOP_CREATEVOBJECT(lowervp, ap->a_cred, ap->a_td); if (error) return (error); vp->v_flag |= VOBJBUF; diff --git a/sys/fs/nwfs/nwfs.h b/sys/fs/nwfs/nwfs.h index 41b25ae..3d2a262 100644 --- a/sys/fs/nwfs/nwfs.h +++ b/sys/fs/nwfs/nwfs.h @@ -75,9 +75,9 @@ struct nwmount { int ncp_conn_logged_in(struct nwmount *); int nwfs_ioctl(struct vop_ioctl_args *ap); -int nwfs_doio(struct buf *bp, struct ucred *cr, struct proc *p); +int nwfs_doio(struct buf *bp, struct ucred *cr, struct thread *td); int nwfs_vinvalbuf(struct vnode *vp, int flags, struct ucred *cred, - struct proc *p, int intrflg); + struct thread *td, int intrflg); #endif /* _KERNEL */ #endif /* _NWFS_H_ */ diff --git a/sys/fs/nwfs/nwfs_io.c b/sys/fs/nwfs/nwfs_io.c index 0529158..7325ac3 100644 --- a/sys/fs/nwfs/nwfs_io.c +++ b/sys/fs/nwfs/nwfs_io.c @@ -92,7 +92,7 @@ nwfs_readvdir(struct vnode *vp, struct uio *uio, struct ucred *cred) { count = 0; i = uio->uio_offset / DE_SIZE; /* offset in directory */ if (i == 0) { - error = ncp_initsearch(vp, uio->uio_procp, cred); + error = ncp_initsearch(vp, uio->uio_td, cred); if (error) { NCPVNDEBUG("cannot initialize search, error=%d",error); return( error ); @@ -114,7 +114,7 @@ nwfs_readvdir(struct vnode *vp, struct uio *uio, struct ucred *cred) { dp.d_type = DT_DIR; break; default: - error = ncp_search_for_file_or_subdir(nmp, &np->n_seq, &fattr, uio->uio_procp, cred); + error = ncp_search_for_file_or_subdir(nmp, &np->n_seq, &fattr, uio->uio_td, cred); if (error && error < 0x80) break; dp.d_fileno = fattr.dirEntNum; dp.d_type = (fattr.attributes & aDIR) ? DT_DIR : DT_REG; @@ -158,7 +158,7 @@ int nwfs_readvnode(struct vnode *vp, struct uio *uiop, struct ucred *cred) { struct nwmount *nmp = VFSTONWFS(vp->v_mount); struct nwnode *np = VTONW(vp); - struct proc *p; + struct thread *td; struct vattr vattr; int error, biosize; @@ -170,7 +170,7 @@ nwfs_readvnode(struct vnode *vp, struct uio *uiop, struct ucred *cred) { if (uiop->uio_offset < 0) return EINVAL; /* if (uiop->uio_offset + uiop->uio_resid > nmp->nm_maxfilesize) return (EFBIG);*/ - p = uiop->uio_procp; + td = uiop->uio_td; if (vp->v_type == VDIR) { error = nwfs_readvdir(vp, uiop, cred); return error; @@ -178,14 +178,14 @@ nwfs_readvnode(struct vnode *vp, struct uio *uiop, struct ucred *cred) { biosize = NWFSTOCONN(nmp)->buffer_size; if (np->n_flag & NMODIFIED) { nwfs_attr_cacheremove(vp); - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); np->n_mtime = vattr.va_mtime.tv_sec; } else { - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); if (np->n_mtime != vattr.va_mtime.tv_sec) { - error = nwfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nwfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); np->n_mtime = vattr.va_mtime.tv_sec; } @@ -203,7 +203,7 @@ nwfs_writevnode(vp, uiop, cred, ioflag) { struct nwmount *nmp = VTONWFS(vp); struct nwnode *np = VTONW(vp); - struct proc *p; + struct thread *td; /* struct vattr vattr;*/ int error = 0; @@ -215,11 +215,11 @@ nwfs_writevnode(vp, uiop, cred, ioflag) if (uiop->uio_offset < 0) return EINVAL; /* if (uiop->uio_offset + uiop->uio_resid > nmp->nm_maxfilesize) return (EFBIG);*/ - p = uiop->uio_procp; + td = uiop->uio_td; if (ioflag & (IO_APPEND | IO_SYNC)) { if (np->n_flag & NMODIFIED) { nwfs_attr_cacheremove(vp); - error = nwfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nwfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); } if (ioflag & IO_APPEND) { @@ -228,17 +228,18 @@ nwfs_writevnode(vp, uiop, cred, ioflag) * the correct size. */ #if notyet nwfs_attr_cacheremove(vp); - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); #endif uiop->uio_offset = np->n_size; } } if (uiop->uio_resid == 0) return 0; - if (p && uiop->uio_offset + uiop->uio_resid > p->p_rlimit[RLIMIT_FSIZE].rlim_cur) { - PROC_LOCK(p); - psignal(p, SIGXFSZ); - PROC_UNLOCK(p); + if (td && uiop->uio_offset + uiop->uio_resid + > td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) { + PROC_LOCK(td->td_proc); + psignal(td->td_proc, SIGXFSZ); + PROC_UNLOCK(td->td_proc); return (EFBIG); } error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, uiop, cred); @@ -256,10 +257,10 @@ nwfs_writevnode(vp, uiop, cred, ioflag) * Do an I/O operation to/from a cache block. */ int -nwfs_doio(bp, cr, p) +nwfs_doio(bp, cr, td) struct buf *bp; struct ucred *cr; - struct proc *p; + struct thread *td; { struct uio *uiop; struct vnode *vp; @@ -276,7 +277,7 @@ nwfs_doio(bp, cr, p) uiop->uio_iov = &io; uiop->uio_iovcnt = 1; uiop->uio_segflg = UIO_SYSSPACE; - uiop->uio_procp = p; + uiop->uio_td = td; if (bp->b_iocmd == BIO_READ) { io.iov_len = uiop->uio_resid = bp->b_bcount; io.iov_base = bp->b_data; @@ -399,14 +400,14 @@ nwfs_getpages(ap) vm_offset_t kva; struct buf *bp; struct vnode *vp; - struct proc *p; + struct thread *td; struct ucred *cred; struct nwmount *nmp; struct nwnode *np; vm_page_t *pages; vp = ap->a_vp; - p = curproc; /* XXX */ + td = curthread; /* XXX */ cred = curproc->p_ucred; /* XXX */ np = VTONW(vp); nmp = VFSTONWFS(vp->v_mount); @@ -431,7 +432,7 @@ nwfs_getpages(ap) uio.uio_resid = count; uio.uio_segflg = UIO_SYSSPACE; uio.uio_rw = UIO_READ; - uio.uio_procp = p; + uio.uio_td = td; error = ncp_read(NWFSTOCONN(nmp), &np->n_fh, &uio,cred); pmap_qremove(kva, npages); @@ -511,15 +512,15 @@ nwfs_putpages(ap) { int error; struct vnode *vp = ap->a_vp; - struct proc *p; + struct thread *td; struct ucred *cred; #ifndef NWFS_RWCACHE - p = curproc; /* XXX */ - cred = p->p_ucred; /* XXX */ - VOP_OPEN(vp, FWRITE, cred, p); + td = curthread; /* XXX */ + cred = td->td_proc->p_ucred; /* XXX */ + VOP_OPEN(vp, FWRITE, cred, td); error = vop_stdputpages(ap); - VOP_CLOSE(vp, FWRITE, cred, p); + VOP_CLOSE(vp, FWRITE, cred, td); return error; #else struct uio uio; @@ -532,9 +533,9 @@ nwfs_putpages(ap) struct nwnode *np; vm_page_t *pages; - p = curproc; /* XXX */ - cred = p->p_ucred; /* XXX */ -/* VOP_OPEN(vp, FWRITE, cred, p);*/ + td = curthread; /* XXX */ + cred = td->td_proc->p_ucred; /* XXX */ +/* VOP_OPEN(vp, FWRITE, cred, td);*/ np = VTONW(vp); nmp = VFSTONWFS(vp->v_mount); pages = ap->a_m; @@ -558,11 +559,11 @@ nwfs_putpages(ap) uio.uio_resid = count; uio.uio_segflg = UIO_SYSSPACE; uio.uio_rw = UIO_WRITE; - uio.uio_procp = p; + uio.uio_td = td; NCPVNDEBUG("ofs=%d,resid=%d\n",(int)uio.uio_offset, uio.uio_resid); error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, &uio, cred); -/* VOP_CLOSE(vp, FWRITE, cred, p);*/ +/* VOP_CLOSE(vp, FWRITE, cred, td);*/ NCPVNDEBUG("paged write done: %d\n", error); pmap_qremove(kva, npages); @@ -583,11 +584,11 @@ nwfs_putpages(ap) * doing the flush, just wait for completion. */ int -nwfs_vinvalbuf(vp, flags, cred, p, intrflg) +nwfs_vinvalbuf(vp, flags, cred, td, intrflg) struct vnode *vp; int flags; struct ucred *cred; - struct proc *p; + struct thread *td; int intrflg; { struct nwnode *np = VTONW(vp); @@ -607,12 +608,12 @@ nwfs_vinvalbuf(vp, flags, cred, p, intrflg) while (np->n_flag & NFLUSHINPROG) { np->n_flag |= NFLUSHWANT; error = tsleep((caddr_t)&np->n_flag, PRIBIO + 2, "nwfsvinv", slptimeo); - error = ncp_chkintr(NWFSTOCONN(VTONWFS(vp)), p); + error = ncp_chkintr(NWFSTOCONN(VTONWFS(vp)), td->td_proc); if (error == EINTR && intrflg) return EINTR; } np->n_flag |= NFLUSHINPROG; - error = vinvalbuf(vp, flags, cred, p, slpflag, 0); + error = vinvalbuf(vp, flags, cred, td, slpflag, 0); while (error) { if (intrflg && (error == ERESTART || error == EINTR)) { np->n_flag &= ~NFLUSHINPROG; @@ -622,7 +623,7 @@ nwfs_vinvalbuf(vp, flags, cred, p, intrflg) } return EINTR; } - error = vinvalbuf(vp, flags, cred, p, slpflag, 0); + error = vinvalbuf(vp, flags, cred, td, slpflag, 0); } np->n_flag &= ~(NMODIFIED | NFLUSHINPROG); if (np->n_flag & NFLUSHWANT) { diff --git a/sys/fs/nwfs/nwfs_ioctl.c b/sys/fs/nwfs/nwfs_ioctl.c index 41c956c..fd8b944 100644 --- a/sys/fs/nwfs/nwfs_ioctl.c +++ b/sys/fs/nwfs/nwfs_ioctl.c @@ -53,11 +53,11 @@ nwfs_ioctl(ap) caddr_t a_data; int fflag; struct ucred *cred; - struct proc *p; + struct thread *td; } */ *ap; { int error; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; struct ucred *cred = ap->a_cred; struct vnode *vp = ap->a_vp; struct nwnode *np = VTONW(vp); @@ -69,23 +69,23 @@ nwfs_ioctl(ap) switch (ap->a_command) { case NWFSIOC_GETCONN: - error = ncp_conn_lock(conn, p, cred, NCPM_READ); + error = ncp_conn_lock(conn, td, cred, NCPM_READ); if (error) break; - error = ncp_conn_gethandle(conn, p, &hp); - ncp_conn_unlock(conn, p); + error = ncp_conn_gethandle(conn, td, &hp); + ncp_conn_unlock(conn, td); if (error) break; *(int*)data = hp->nh_id; break; case NWFSIOC_GETEINFO: - if ((error = VOP_ACCESS(vp, VEXEC, cred, p))) break; + if ((error = VOP_ACCESS(vp, VEXEC, cred, td))) break; fap = data; error = ncp_obtain_info(nmp, np->n_fid.f_id, 0, NULL, fap, - ap->a_p,ap->a_cred); + ap->a_td,ap->a_cred); strcpy(fap->entryName, np->n_name); fap->nameLen = np->n_nmlen; break; case NWFSIOC_GETNS: - if ((error = VOP_ACCESS(vp, VEXEC, cred, p))) break; + if ((error = VOP_ACCESS(vp, VEXEC, cred, td))) break; *(int*)data = nmp->name_space; break; default: diff --git a/sys/fs/nwfs/nwfs_node.c b/sys/fs/nwfs/nwfs_node.c index c708e1d..8fce6ac 100644 --- a/sys/fs/nwfs/nwfs_node.c +++ b/sys/fs/nwfs/nwfs_node.c @@ -139,7 +139,7 @@ static int nwfs_allocvp(struct mount *mp, ncpfid fid, struct nw_entry_info *fap, struct vnode *dvp, struct vnode **vpp) { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct nwnode *np; struct nwnode_hash_head *nhpp; struct nwmount *nmp = VFSTONWFS(mp); @@ -147,20 +147,20 @@ nwfs_allocvp(struct mount *mp, ncpfid fid, struct nw_entry_info *fap, int error; loop: - lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, p); + lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td); rescan: if (nwfs_hashlookup(nmp, fid, &np) == 0) { vp = NWTOV(np); mtx_lock(&vp->v_interlock); - lockmgr(&nwhashlock, LK_RELEASE, NULL, p); - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) + lockmgr(&nwhashlock, LK_RELEASE, NULL, td); + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) goto loop; if (fap) np->n_attr = fap->attributes; *vpp = vp; return(0); } - lockmgr(&nwhashlock, LK_RELEASE, NULL, p); + lockmgr(&nwhashlock, LK_RELEASE, NULL, td); if (fap == NULL || ((fap->attributes & aDIR) == 0 && dvp == NULL)) panic("nwfs_allocvp: fap = %p, dvp = %p\n", fap, dvp); @@ -186,7 +186,7 @@ rescan: np->n_parent = VTONW(dvp)->n_fid; } lockinit(&vp->v_lock, PINOD, "nwnode", 0, LK_CANRECURSE); - lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, p); + lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td); /* * Another process can create vnode while we blocked in malloc() or * getnewvnode(). Rescan list again. @@ -201,8 +201,8 @@ rescan: *vpp = vp; nhpp = NWNOHASH(fid); LIST_INSERT_HEAD(nhpp, np, n_hash); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - lockmgr(&nwhashlock, LK_RELEASE, NULL, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + lockmgr(&nwhashlock, LK_RELEASE, NULL, td); if (vp->v_type == VDIR && dvp && (dvp->v_flag & VROOT) == 0) { np->n_flag |= NREFPARENT; @@ -229,14 +229,14 @@ nwfs_nget(struct mount *mp, ncpfid fid, struct nw_entry_info *fap, } int -nwfs_lookupnp(struct nwmount *nmp, ncpfid fid, struct proc *p, +nwfs_lookupnp(struct nwmount *nmp, ncpfid fid, struct thread *td, struct nwnode **npp) { int error; - lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, p); + lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td); error = nwfs_hashlookup(nmp, fid, npp); - lockmgr(&nwhashlock, LK_RELEASE, NULL, p); + lockmgr(&nwhashlock, LK_RELEASE, NULL, td); return error; } @@ -247,26 +247,26 @@ int nwfs_reclaim(ap) struct vop_reclaim_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *dvp = NULL, *vp = ap->a_vp; struct nwnode *dnp, *np = VTONW(vp); struct nwmount *nmp = VTONWFS(vp); - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; NCPVNDEBUG("%s,%d\n", np->n_name, vp->v_usecount); if (np->n_flag & NREFPARENT) { np->n_flag &= ~NREFPARENT; - if (nwfs_lookupnp(nmp, np->n_parent, p, &dnp) == 0) { + if (nwfs_lookupnp(nmp, np->n_parent, td, &dnp) == 0) { dvp = dnp->n_vnode; } else { NCPVNDEBUG("%s: has no parent ?\n",np->n_name); } } - lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, p); + lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td); LIST_REMOVE(np, n_hash); - lockmgr(&nwhashlock, LK_RELEASE, NULL, p); + lockmgr(&nwhashlock, LK_RELEASE, NULL, td); cache_purge(vp); if (nmp->n_root == np) { nmp->n_root = NULL; @@ -283,22 +283,22 @@ int nwfs_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { - struct proc *p = ap->a_p; - struct ucred *cred = p->p_ucred; + struct thread *td = ap->a_td; + struct ucred *cred = td->td_proc->p_ucred; struct vnode *vp = ap->a_vp; struct nwnode *np = VTONW(vp); int error; NCPVNDEBUG("%s: %d\n", VTONW(vp)->n_name, vp->v_usecount); if (np->opened) { - error = nwfs_vinvalbuf(vp, V_SAVE, cred, p, 1); - error = ncp_close_file(NWFSTOCONN(VTONWFS(vp)), &np->n_fh, p, cred); + error = nwfs_vinvalbuf(vp, V_SAVE, cred, td, 1); + error = ncp_close_file(NWFSTOCONN(VTONWFS(vp)), &np->n_fh, td, cred); np->opened = 0; } - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (np->n_flag & NSHOULDFREE) { cache_purge(vp); vgone(vp); diff --git a/sys/fs/nwfs/nwfs_node.h b/sys/fs/nwfs/nwfs_node.h index 34c693d..fa5de92 100644 --- a/sys/fs/nwfs/nwfs_node.h +++ b/sys/fs/nwfs/nwfs_node.h @@ -83,7 +83,7 @@ struct uio; void nwfs_hash_init(void); void nwfs_hash_free(void); -int nwfs_lookupnp(struct nwmount *nmp, ncpfid fid, struct proc *p, +int nwfs_lookupnp(struct nwmount *nmp, ncpfid fid, struct thread *td, struct nwnode **npp); int nwfs_inactive(struct vop_inactive_args *); int nwfs_reclaim(struct vop_reclaim_args *); diff --git a/sys/fs/nwfs/nwfs_subr.c b/sys/fs/nwfs/nwfs_subr.c index b83e89b..4755891 100644 --- a/sys/fs/nwfs/nwfs_subr.c +++ b/sys/fs/nwfs/nwfs_subr.c @@ -71,7 +71,7 @@ ncp_extract_file_info(struct nwmount *nmp, struct ncp_rq *rqp, } int -ncp_initsearch(struct vnode *dvp,struct proc *p,struct ucred *cred) +ncp_initsearch(struct vnode *dvp, struct thread *td, struct ucred *cred) { struct nwmount *nmp = VTONWFS(dvp); struct ncp_conn *conn = NWFSTOCONN(nmp); @@ -82,7 +82,7 @@ ncp_initsearch(struct vnode *dvp,struct proc *p,struct ucred *cred) int error; NCPNDEBUG("vol=%d,dir=%d\n", volnum, dirent); - error = ncp_rq_alloc(87, conn, p, cred, &rqp); + error = ncp_rq_alloc(87, conn, td, cred, &rqp); if (error) return error; mb_put_uint8(&rqp->rq, 2); /* subfunction */ @@ -102,13 +102,13 @@ int ncp_search_for_file_or_subdir(struct nwmount *nmp, struct nw_search_seq *seq, struct nw_entry_info *target, - struct proc *p,struct ucred *cred) + struct thread *td,struct ucred *cred) { struct ncp_conn *conn = NWFSTOCONN(nmp); struct ncp_rq *rqp; int error; - error = ncp_rq_alloc(87, conn, p, cred, &rqp); + error = ncp_rq_alloc(87, conn, td, cred, &rqp); if (error) return error; mb_put_uint8(&rqp->rq, 3); /* subfunction */ @@ -138,7 +138,7 @@ ncp_search_for_file_or_subdir(struct nwmount *nmp, int ncp_obtain_info(struct nwmount *nmp, u_int32_t dirent, int namelen, char *path, struct nw_entry_info *target, - struct proc *p,struct ucred *cred) + struct thread *td,struct ucred *cred) { struct ncp_conn *conn=NWFSTOCONN(nmp); struct ncp_rq *rqp; @@ -150,7 +150,7 @@ ncp_obtain_info(struct nwmount *nmp, u_int32_t dirent, return EINVAL; } ns = (path == NULL || path[0] == 0) ? NW_NS_DOS : nmp->name_space; - error = ncp_rq_alloc(87, conn, p, cred, &rqp); + error = ncp_rq_alloc(87, conn, td, cred, &rqp); if (error) return error; mb_put_uint8(&rqp->rq, 6); /* subfunction */ @@ -173,7 +173,7 @@ ncp_obtain_info(struct nwmount *nmp, u_int32_t dirent, */ int ncp_lookup(struct vnode *dvp, int len, char *name, struct nw_entry_info *fap, - struct proc *p,struct ucred *cred) + struct thread *td,struct ucred *cred) { struct nwmount *nmp; struct nwnode *dnp = VTONW(dvp); @@ -190,10 +190,10 @@ ncp_lookup(struct vnode *dvp, int len, char *name, struct nw_entry_info *fap, if (len == 1 && name[0] == '.') { if (dnp->n_flag & NVOLUME) { error = ncp_obtain_info(nmp, dnp->n_fid.f_id, 0, NULL, - fap, p, cred); + fap, td, cred); } else { error = ncp_obtain_info(nmp, dnp->n_fid.f_parent, - dnp->n_nmlen, dnp->n_name, fap, p, cred); + dnp->n_nmlen, dnp->n_name, fap, td, cred); } return error; } else if (len == 2 && name[0] == '.' && name[1] == '.') { @@ -201,7 +201,7 @@ ncp_lookup(struct vnode *dvp, int len, char *name, struct nw_entry_info *fap, return EIO; } else { error = ncp_obtain_info(nmp, dnp->n_fid.f_id, - len, name, fap, p, cred); + len, name, fap, td, cred); } return error; } @@ -221,7 +221,7 @@ int ncp_open_create_file_or_subdir(struct nwmount *nmp,struct vnode *dvp,int namelen, char *name, int open_create_mode, u_int32_t create_attributes, int desired_acc_rights, struct ncp_open_info *nop, - struct proc *p,struct ucred *cred) + struct thread *td,struct ucred *cred) { struct ncp_conn *conn=NWFSTOCONN(nmp); @@ -231,7 +231,7 @@ ncp_open_create_file_or_subdir(struct nwmount *nmp,struct vnode *dvp,int namelen u_int32_t dirent; int error; - error = ncp_rq_alloc(87, conn, p, cred, &rqp); + error = ncp_rq_alloc(87, conn, td, cred, &rqp); if (error) return error; volnum = nmp->n_volume; @@ -267,12 +267,12 @@ ncp_open_create_file_or_subdir(struct nwmount *nmp,struct vnode *dvp,int namelen } int -ncp_close_file(struct ncp_conn *conn, ncp_fh *fh,struct proc *p,struct ucred *cred) +ncp_close_file(struct ncp_conn *conn, ncp_fh *fh,struct thread *td,struct ucred *cred) { struct ncp_rq *rqp; int error; - error = ncp_rq_alloc(66, conn, p, cred, &rqp); + error = ncp_rq_alloc(66, conn, td, cred, &rqp); if (error) return error; mb_put_uint8(&rqp->rq, 0); @@ -286,13 +286,13 @@ ncp_close_file(struct ncp_conn *conn, ncp_fh *fh,struct proc *p,struct ucred *cr int ncp_DeleteNSEntry(struct nwmount *nmp, u_int32_t dirent, - int namelen,char *name,struct proc *p,struct ucred *cred) + int namelen,char *name,struct thread *td,struct ucred *cred) { struct ncp_rq *rqp; int error; struct ncp_conn *conn=NWFSTOCONN(nmp); - error = ncp_rq_alloc(87, conn, p, cred, &rqp); + error = ncp_rq_alloc(87, conn, td, cred, &rqp); if (error) return error; mb_put_uint8(&rqp->rq, 8); /* subfunction */ @@ -311,12 +311,12 @@ ncp_nsrename(struct ncp_conn *conn, int volume, int ns, int oldtype, struct ncp_nlstables *nt, nwdirent fdir, char *old_name, int oldlen, nwdirent tdir, char *new_name, int newlen, - struct proc *p, struct ucred *cred) + struct thread *td, struct ucred *cred) { struct ncp_rq *rqp; int error; - error = ncp_rq_alloc(87, conn, p, cred, &rqp); + error = ncp_rq_alloc(87, conn, td, cred, &rqp); if (error) return error; mb_put_uint8(&rqp->rq, 4); @@ -345,7 +345,7 @@ int ncp_modify_file_or_subdir_dos_info(struct nwmount *nmp, struct vnode *vp, u_int32_t info_mask, struct nw_modify_dos_info *info, - struct proc *p,struct ucred *cred) + struct thread *td,struct ucred *cred) { struct nwnode *np=VTONW(vp); struct ncp_rq *rqp; @@ -354,7 +354,7 @@ ncp_modify_file_or_subdir_dos_info(struct nwmount *nmp, struct vnode *vp, struct ncp_conn *conn=NWFSTOCONN(nmp); int error; - error = ncp_rq_alloc(87, conn, p, cred, &rqp); + error = ncp_rq_alloc(87, conn, td, cred, &rqp); if (error) return error; mb_put_uint8(&rqp->rq, 7); /* subfunction */ @@ -371,11 +371,11 @@ ncp_modify_file_or_subdir_dos_info(struct nwmount *nmp, struct vnode *vp, } int -ncp_setattr(vp, vap, cred, procp) +ncp_setattr(vp, vap, cred, td) struct vnode *vp; struct vattr *vap; struct ucred *cred; - struct proc *procp; + struct thread *td; { struct nwmount *nmp=VTONWFS(vp); struct nwnode *np=VTONW(vp); @@ -387,12 +387,12 @@ ncp_setattr(vp, vap, cred, procp) if (vap->va_size != VNOVAL) { error = ncp_open_create_file_or_subdir(nmp, vp, 0, NULL, OC_MODE_OPEN, 0, - AR_WRITE | AR_READ, &nwn,procp,cred); + AR_WRITE | AR_READ, &nwn,td,cred); if (error) return error; - error = ncp_rq_alloc(73, conn, procp, cred, &rqp); + error = ncp_rq_alloc(73, conn, td, cred, &rqp); if (error) { - ncp_close_file(conn, &nwn.fh, procp, cred); + ncp_close_file(conn, &nwn.fh, td, cred); return error; } mb_put_uint8(&rqp->rq, 0); @@ -403,7 +403,7 @@ ncp_setattr(vp, vap, cred, procp) np->n_vattr.va_size = np->n_size = vap->va_size; if (!error) ncp_rq_done(rqp); - ncp_close_file(conn, &nwn.fh, procp, cred); + ncp_close_file(conn, &nwn.fh, td, cred); if (error) return error; } @@ -419,7 +419,7 @@ ncp_setattr(vp, vap, cred, procp) ncp_unix2dostime(&vap->va_atime, nmp->m.tz, &info.lastAccessDate, NULL, NULL); } if (info_mask) { - error = ncp_modify_file_or_subdir_dos_info(nmp, vp, info_mask, &info,procp,cred); + error = ncp_modify_file_or_subdir_dos_info(nmp, vp, info_mask, &info,td,cred); } return (error); } @@ -427,14 +427,14 @@ ncp_setattr(vp, vap, cred, procp) int ncp_get_volume_info_with_number(struct ncp_conn *conn, int n, struct ncp_volume_info *target, - struct proc *p,struct ucred *cred) + struct thread *td,struct ucred *cred) { struct ncp_rq *rqp; u_int32_t tmp32; u_int8_t len; int error; - error = ncp_rq_alloc_subfn(22, 44, conn, p, cred, &rqp); + error = ncp_rq_alloc_subfn(22, 44, conn, td, cred, &rqp); if (error) return error; mb_put_uint8(&rqp->rq,n); @@ -462,14 +462,14 @@ ncp_get_volume_info_with_number(struct ncp_conn *conn, int ncp_get_namespaces(struct ncp_conn *conn, u_int32_t volume, int *nsf, - struct proc *p,struct ucred *cred) + struct thread *td,struct ucred *cred) { struct ncp_rq *rqp; int error; u_int8_t ns; u_int16_t nscnt; - error = ncp_rq_alloc(87, conn, p, cred, &rqp); + error = ncp_rq_alloc(87, conn, td, cred, &rqp); if (error) return error; mb_put_uint8(&rqp->rq, 24); /* Subfunction: Get Loaded Name Spaces */ @@ -491,14 +491,14 @@ ncp_get_namespaces(struct ncp_conn *conn, u_int32_t volume, int *nsf, int ncp_lookup_volume(struct ncp_conn *conn, char *volname, u_char *volNum, u_int32_t *dirEnt, - struct proc *p,struct ucred *cred) + struct thread *td,struct ucred *cred) { struct ncp_rq *rqp; u_int32_t tmp32; int error; NCPNDEBUG("looking up vol %s\n", volname); - error = ncp_rq_alloc(87, conn, p, cred, &rqp); + error = ncp_rq_alloc(87, conn, td, cred, &rqp); if (error) return error; mb_put_uint8(&rqp->rq, 22); /* Subfunction: Generate dir handle */ diff --git a/sys/fs/nwfs/nwfs_subr.h b/sys/fs/nwfs/nwfs_subr.h index b603c76..4fece8a 100644 --- a/sys/fs/nwfs/nwfs_subr.h +++ b/sys/fs/nwfs/nwfs_subr.h @@ -46,48 +46,48 @@ struct ncp_open_info; struct nw_entry_info; struct nw_search_info; struct nwmount; -struct proc; +struct thread; struct timespec; struct ucred; struct vattr; struct vnode; -int ncp_initsearch(struct vnode *dvp,struct proc *p,struct ucred *cred); +int ncp_initsearch(struct vnode *dvp,struct thread *td, struct ucred *cred); int ncp_search_for_file_or_subdir(struct nwmount *nmp,struct nw_search_seq *seq, struct nw_entry_info *target, - struct proc *p,struct ucred *cred); + struct thread *td, struct ucred *cred); int ncp_lookup(struct vnode *dvp, int len, char *name, struct nw_entry_info *fap, - struct proc *p,struct ucred *cred); + struct thread *td, struct ucred *cred); int ncp_lookup_volume(struct ncp_conn *conn, char *volname, u_char *volNum, u_int32_t *dirEnt, - struct proc *p,struct ucred *cred); + struct thread *td, struct ucred *cred); int ncp_close_file(struct ncp_conn *conn, ncp_fh *fh, - struct proc *p,struct ucred *cred); + struct thread *td, struct ucred *cred); int ncp_open_create_file_or_subdir(struct nwmount *nmp,struct vnode *dvp, int namelen,char *name, int open_create_mode, u_int32_t create_attributes, int desired_acc_rights, struct ncp_open_info *nop, - struct proc *p,struct ucred *cred); + struct thread *td, struct ucred *cred); int ncp_DeleteNSEntry(struct nwmount *nmp, u_int32_t dirent, int namelen, char *name, - struct proc *p,struct ucred *cred); + struct thread *td, struct ucred *cred); int ncp_nsrename(struct ncp_conn *conn, int volume, int ns, int oldtype, struct ncp_nlstables *nt, nwdirent fdir, char *old_name, int oldlen, nwdirent tdir, char *new_name, int newlen, - struct proc *p, struct ucred *cred); + struct thread *td, struct ucred *cred); int ncp_obtain_info(struct nwmount *nmp, u_int32_t dirent, int namelen, char *path, struct nw_entry_info *target, - struct proc *p,struct ucred *cred); + struct thread *td, struct ucred *cred); int ncp_modify_file_or_subdir_dos_info(struct nwmount *nmp, struct vnode *vp, u_int32_t info_mask, struct nw_modify_dos_info *info, - struct proc *p,struct ucred *cred); -int ncp_setattr(struct vnode *,struct vattr *,struct ucred *,struct proc *); + struct thread *td, struct ucred *cred); +int ncp_setattr(struct vnode *,struct vattr *,struct ucred *,struct thread *td); int ncp_get_namespaces(struct ncp_conn *conn, u_int32_t volume, int *nsf, - struct proc *p,struct ucred *cred); + struct thread *td, struct ucred *cred); int ncp_get_volume_info_with_number(struct ncp_conn *conn, int n, struct ncp_volume_info *target, - struct proc *p,struct ucred *cred); + struct thread *td, struct ucred *cred); void ncp_unix2dostime (struct timespec *tsp, int tz, u_int16_t *ddp, u_int16_t *dtp, u_int8_t *dhp); diff --git a/sys/fs/nwfs/nwfs_vfsops.c b/sys/fs/nwfs/nwfs_vfsops.c index 2fb0752..de5ae2f 100644 --- a/sys/fs/nwfs/nwfs_vfsops.c +++ b/sys/fs/nwfs/nwfs_vfsops.c @@ -71,13 +71,13 @@ MODULE_DEPEND(nwfs, ncp, 1, 1, 1); MODULE_DEPEND(nwfs, libmchain, 1, 1, 1); static int nwfs_mount(struct mount *, char *, caddr_t, - struct nameidata *, struct proc *); -static int nwfs_quotactl(struct mount *, int, uid_t, caddr_t, struct proc *); + struct nameidata *, struct thread *); +static int nwfs_quotactl(struct mount *, int, uid_t, caddr_t, struct thread *); static int nwfs_root(struct mount *, struct vnode **); -static int nwfs_start(struct mount *, int, struct proc *); -static int nwfs_statfs(struct mount *, struct statfs *, struct proc *); -static int nwfs_sync(struct mount *, int, struct ucred *, struct proc *); -static int nwfs_unmount(struct mount *, int, struct proc *); +static int nwfs_start(struct mount *, int, struct thread *); +static int nwfs_statfs(struct mount *, struct statfs *, struct thread *); +static int nwfs_sync(struct mount *, int, struct ucred *, struct thread *); +static int nwfs_unmount(struct mount *, int, struct thread *); static int nwfs_init(struct vfsconf *vfsp); static int nwfs_uninit(struct vfsconf *vfsp); @@ -144,7 +144,7 @@ nwfs_initnls(struct nwmount *nmp) { * data - addr in user space of mount params */ static int nwfs_mount(struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p) + struct nameidata *ndp, struct thread *td) { struct nwfs_args args; /* will hold data from mount request */ int error; @@ -169,7 +169,7 @@ static int nwfs_mount(struct mount *mp, char *path, caddr_t data, nwfs_printf("mount version mismatch: kernel=%d, mount=%d\n",NWFS_VERSION,args.version); return (1); } - error = ncp_conn_getbyref(args.connRef,p,p->p_ucred,NCPM_EXECUTE,&conn); + error = ncp_conn_getbyref(args.connRef, td , td->td_proc->p_ucred,NCPM_EXECUTE,&conn); if (error) { nwfs_printf("invalid connection refernce %d\n",args.connRef); return (error); @@ -179,7 +179,7 @@ static int nwfs_mount(struct mount *mp, char *path, caddr_t data, nwfs_printf("can't get connection handle\n"); return (error); } - ncp_conn_unlock(conn,p); /* we keep the ref */ + ncp_conn_unlock(conn, td); /* we keep the ref */ mp->mnt_stat.f_iosize = conn->buffer_size; /* We must malloc our own mount info */ MALLOC(nmp,struct nwmount *,sizeof(struct nwmount),M_NWFSDATA,M_USE_RESERVE | M_ZERO); @@ -220,7 +220,7 @@ static int nwfs_mount(struct mount *mp, char *path, caddr_t data, /* * Lose the lock but keep the ref. */ - VOP_UNLOCK(vp, 0, curproc); + VOP_UNLOCK(vp, 0, curthread); NCPVODEBUG("rootvp.vrefcnt=%d\n",vp->v_usecount); return error; bad: @@ -233,7 +233,7 @@ bad: /* Unmount the filesystem described by mp. */ static int -nwfs_unmount(struct mount *mp, int mntflags, struct proc *p) +nwfs_unmount(struct mount *mp, int mntflags, struct thread *td) { struct nwmount *nmp = VFSTONWFS(mp); struct ncp_conn *conn; @@ -249,9 +249,9 @@ nwfs_unmount(struct mount *mp, int mntflags, struct proc *p) return (error); conn = NWFSTOCONN(nmp); ncp_conn_puthandle(nmp->connh,NULL,0); - if (ncp_conn_lock(conn,p,p->p_ucred,NCPM_WRITE | NCPM_EXECUTE) == 0) { + if (ncp_conn_lock(conn, td, td->td_proc->p_ucred,NCPM_WRITE | NCPM_EXECUTE) == 0) { if(ncp_conn_free(conn)) - ncp_conn_unlock(conn,p); + ncp_conn_unlock(conn, td); } mp->mnt_data = (qaddr_t)0; if (nmp->m.flags & NWFS_MOUNT_HAVE_NLS) @@ -269,8 +269,8 @@ nwfs_root(struct mount *mp, struct vnode **vpp) { struct nwnode *np; struct ncp_conn *conn; struct nw_entry_info fattr; - struct proc *p = curproc; - struct ucred *cred = p->p_ucred; + struct thread *td = curthread; + struct ucred *cred = td->td_proc->p_ucred; int error, nsf, opt; u_char vol; @@ -278,16 +278,16 @@ nwfs_root(struct mount *mp, struct vnode **vpp) { conn = NWFSTOCONN(nmp); if (nmp->n_root) { *vpp = NWTOV(nmp->n_root); - while (vget(*vpp, LK_EXCLUSIVE, curproc) != 0) + while (vget(*vpp, LK_EXCLUSIVE, curthread) != 0) ; return 0; } error = ncp_lookup_volume(conn, nmp->m.mounted_vol, &vol, - &nmp->n_rootent.f_id, p, cred); + &nmp->n_rootent.f_id, td, cred); if (error) return ENOENT; nmp->n_volume = vol; - error = ncp_get_namespaces(conn, vol, &nsf, p, cred); + error = ncp_get_namespaces(conn, vol, &nsf, td, cred); if (error) return ENOENT; if (nsf & NW_NSB_OS2) { @@ -313,7 +313,7 @@ nwfs_root(struct mount *mp, struct vnode **vpp) { if (nmp->m.root_path[0]) { nmp->m.root_path[0]--; error = ncp_obtain_info(nmp, nmp->n_rootent.f_id, - -nmp->m.root_path[0], nmp->m.root_path, &fattr, p, cred); + -nmp->m.root_path[0], nmp->m.root_path, &fattr, td, cred); if (error) { NCPFATAL("Invalid root path specified\n"); return ENOENT; @@ -321,7 +321,7 @@ nwfs_root(struct mount *mp, struct vnode **vpp) { nmp->n_rootent.f_parent = fattr.dirEntNum; nmp->m.root_path[0]++; error = ncp_obtain_info(nmp, nmp->n_rootent.f_id, - -nmp->m.root_path[0], nmp->m.root_path, &fattr, p, cred); + -nmp->m.root_path[0], nmp->m.root_path, &fattr, td, cred); if (error) { NCPFATAL("Invalid root path specified\n"); return ENOENT; @@ -329,7 +329,7 @@ nwfs_root(struct mount *mp, struct vnode **vpp) { nmp->n_rootent.f_id = fattr.dirEntNum; } else { error = ncp_obtain_info(nmp, nmp->n_rootent.f_id, - 0, NULL, &fattr, p, cred); + 0, NULL, &fattr, td, cred); if (error) { NCPFATAL("Can't obtain volume info\n"); return ENOENT; @@ -345,7 +345,7 @@ nwfs_root(struct mount *mp, struct vnode **vpp) { if (nmp->m.root_path[0] == 0) np->n_flag |= NVOLUME; nmp->n_root = np; -/* error = VOP_GETATTR(vp, &vattr, cred, p); +/* error = VOP_GETATTR(vp, &vattr, cred, td); if (error) { vput(vp); NCPFATAL("Can't get root directory entry\n"); @@ -360,10 +360,10 @@ nwfs_root(struct mount *mp, struct vnode **vpp) { */ /* ARGSUSED */ static int -nwfs_start(mp, flags, p) +nwfs_start(mp, flags, td) struct mount *mp; int flags; - struct proc *p; + struct thread *td; { NCPVODEBUG("flags=%04x\n",flags); return (0); @@ -374,12 +374,12 @@ nwfs_start(mp, flags, p) */ /* ARGSUSED */ static int -nwfs_quotactl(mp, cmd, uid, arg, p) +nwfs_quotactl(mp, cmd, uid, arg, td) struct mount *mp; int cmd; uid_t uid; caddr_t arg; - struct proc *p; + struct thread *td; { NCPVODEBUG("return EOPNOTSUPP\n"); return (EOPNOTSUPP); @@ -395,7 +395,7 @@ nwfs_init(struct vfsconf *vfsp) name[0] = CTL_HW; name[1] = HW_NCPU; - error = kernel_sysctl(curproc, name, 2, &ncpu, &olen, NULL, 0, &plen); + error = kernel_sysctl(curthread, name, 2, &ncpu, &olen, NULL, 0, &plen); if (error == 0 && ncpu > 1) printf("warning: nwfs module compiled without SMP support."); #endif @@ -419,10 +419,10 @@ nwfs_uninit(struct vfsconf *vfsp) * nwfs_statfs call */ int -nwfs_statfs(mp, sbp, p) +nwfs_statfs(mp, sbp, td) struct mount *mp; struct statfs *sbp; - struct proc *p; + struct thread *td; { struct nwmount *nmp = VFSTONWFS(mp); int error = 0, secsize; @@ -430,7 +430,8 @@ nwfs_statfs(mp, sbp, p) struct ncp_volume_info vi; if (np == NULL) return EINVAL; - error = ncp_get_volume_info_with_number(NWFSTOCONN(nmp), nmp->n_volume, &vi,p,p->p_ucred); + error = ncp_get_volume_info_with_number(NWFSTOCONN(nmp), + nmp->n_volume, &vi, td, td->td_proc->p_ucred); if (error) return error; secsize = 512; /* XXX how to get real value ??? */ sbp->f_spare2=0; /* placeholder */ @@ -465,11 +466,11 @@ nwfs_statfs(mp, sbp, p) */ /* ARGSUSED */ static int -nwfs_sync(mp, waitfor, cred, p) +nwfs_sync(mp, waitfor, cred, td) struct mount *mp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { struct vnode *vp, *nvp; int error, allerror = 0; @@ -496,11 +497,11 @@ loop: mtx_lock(&mntvnode_mtx); continue; } - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) { + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) { mtx_lock(&mntvnode_mtx); goto loop; } - error = VOP_FSYNC(vp, cred, waitfor, p); + error = VOP_FSYNC(vp, cred, waitfor, td); if (error) allerror = error; vput(vp); diff --git a/sys/fs/nwfs/nwfs_vnops.c b/sys/fs/nwfs/nwfs_vnops.c index dc83b3d..9d773f8 100644 --- a/sys/fs/nwfs/nwfs_vnops.c +++ b/sys/fs/nwfs/nwfs_vnops.c @@ -132,7 +132,7 @@ nwfs_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -170,7 +170,7 @@ nwfs_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -181,24 +181,24 @@ nwfs_open(ap) struct vattr vattr; int error, nwm; - NCPVNDEBUG("%s,%d\n",np->n_name, np->opened); + NCPVNDEBUG("%s,%d\n", np->n_name, np->opened); if (vp->v_type != VREG && vp->v_type != VDIR) { NCPFATAL("open vtype = %d\n", vp->v_type); return (EACCES); } if (vp->v_type == VDIR) return 0; /* nothing to do now */ if (np->n_flag & NMODIFIED) { - if ((error = nwfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 1)) == EINTR) + if ((error = nwfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_td, 1)) == EINTR) return (error); np->n_atime = 0; - error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p); + error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_td); if (error) return (error); np->n_mtime = vattr.va_mtime.tv_sec; } else { - error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p); + error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_td); if (error) return (error); if (np->n_mtime != vattr.va_mtime.tv_sec) { - if ((error = nwfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 1)) == EINTR) + if ((error = nwfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_td, 1)) == EINTR) return (error); np->n_mtime = vattr.va_mtime.tv_sec; } @@ -211,13 +211,13 @@ nwfs_open(ap) if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) nwm |= AR_WRITE; error = ncp_open_create_file_or_subdir(nmp, vp, 0, NULL, OC_MODE_OPEN, - 0, nwm, &no, ap->a_p, ap->a_cred); + 0, nwm, &no, ap->a_td, ap->a_cred); if (error) { if (mode & FWRITE) return EACCES; nwm = AR_READ; error = ncp_open_create_file_or_subdir(nmp, vp, 0, NULL, OC_MODE_OPEN, 0, - nwm, &no, ap->a_p,ap->a_cred); + nwm, &no, ap->a_td, ap->a_cred); } if (!error) { np->opened++; @@ -235,14 +235,15 @@ nwfs_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *td; } */ *ap; { struct vnode *vp = ap->a_vp; struct nwnode *np = VTONW(vp); int error; - NCPVNDEBUG("name=%s,pid=%d,c=%d\n",np->n_name,ap->a_p->p_pid,np->opened); + NCPVNDEBUG("name=%s,pid=%d,c=%d\n", np->n_name, ap->a_td->td_proc->p_pid, + np->opened); if (vp->v_type == VDIR) return 0; /* nothing to do now */ error = 0; @@ -252,7 +253,7 @@ nwfs_close(ap) return 0; } mtx_unlock(&vp->v_interlock); - error = nwfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 1); + error = nwfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_td, 1); mtx_lock(&vp->v_interlock); if (np->opened == 0) { mtx_unlock(&vp->v_interlock); @@ -261,7 +262,7 @@ nwfs_close(ap) if (--np->opened == 0) { mtx_unlock(&vp->v_interlock); error = ncp_close_file(NWFSTOCONN(VTONWFS(vp)), &np->n_fh, - ap->a_p, ap->a_cred); + ap->a_td, ap->a_cred); } else mtx_unlock(&vp->v_interlock); np->n_atime = 0; @@ -277,7 +278,7 @@ nwfs_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -289,16 +290,16 @@ nwfs_getattr(ap) u_int32_t oldsize; NCPVNDEBUG("%lx:%d: '%s' %d\n", (long)vp, nmp->n_volume, np->n_name, (vp->v_flag & VROOT) != 0); - error = nwfs_attr_cachelookup(vp,va); + error = nwfs_attr_cachelookup(vp, va); if (!error) return 0; NCPVNDEBUG("not in cache\n"); oldsize = np->n_size; if (np->n_flag & NVOLUME) { error = ncp_obtain_info(nmp, np->n_fid.f_id, 0, NULL, &fattr, - ap->a_p,ap->a_cred); + ap->a_td, ap->a_cred); } else { error = ncp_obtain_info(nmp, np->n_fid.f_parent, np->n_nmlen, - np->n_name, &fattr, ap->a_p, ap->a_cred); + np->n_name, &fattr, ap->a_td, ap->a_cred); } if (error) { NCPVNDEBUG("error %d\n", error); @@ -319,7 +320,7 @@ nwfs_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -357,13 +358,13 @@ nwfs_setattr(ap) return EINVAL; }; } - error = ncp_setattr(vp, vap, ap->a_cred, ap->a_p); + error = ncp_setattr(vp, vap, ap->a_cred, ap->a_td); if (error && vap->va_size != VNOVAL) { np->n_size = tsize; vnode_pager_setsize(vp, (u_long)tsize); } np->n_atime = 0; /* invalidate cache */ - VOP_GETATTR(vp, vap, ap->a_cred, ap->a_p); + VOP_GETATTR(vp, vap, ap->a_cred, ap->a_td); np->n_mtime = vap->va_mtime.tv_sec; return (0); } @@ -403,11 +404,11 @@ nwfs_write(ap) struct uio *uio = ap->a_uio; int error; - NCPVNDEBUG("%d,ofs=%d,sz=%d\n",vp->v_type, (int)uio->uio_offset, uio->uio_resid); + NCPVNDEBUG("%d,ofs=%d,sz=%d\n", vp->v_type, (int)uio->uio_offset, uio->uio_resid); if (vp->v_type != VREG) return (EPERM); - error = nwfs_writevnode(vp, uio, ap->a_cred,ap->a_ioflag); + error = nwfs_writevnode(vp, uio, ap->a_cred, ap->a_ioflag); return(error); } /* @@ -443,18 +444,18 @@ nwfs_create(ap) *vpp = NULL; if (vap->va_type == VSOCK) return (EOPNOTSUPP); - if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc))) { + if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_thread))) { return (error); } fmode = AR_READ | AR_WRITE; /* if (vap->va_vaflags & VA_EXCLUSIVE) fmode |= AR_DENY_READ | AR_DENY_WRITE;*/ - error = ncp_open_create_file_or_subdir(nmp,dvp,cnp->cn_namelen,cnp->cn_nameptr, + error = ncp_open_create_file_or_subdir(nmp, dvp, cnp->cn_namelen, cnp->cn_nameptr, OC_MODE_CREATE | OC_MODE_OPEN | OC_MODE_REPLACE, - 0, fmode, &no, cnp->cn_proc, cnp->cn_cred); + 0, fmode, &no, cnp->cn_thread, cnp->cn_cred); if (!error) { - error = ncp_close_file(NWFSTOCONN(nmp), &no.fh, cnp->cn_proc,cnp->cn_cred); + error = ncp_close_file(NWFSTOCONN(nmp), &no.fh, cnp->cn_thread, cnp->cn_cred); fid.f_parent = VTONW(dvp)->n_fid.f_id; fid.f_id = no.fattr.dirEntNum; error = nwfs_nget(VTOVFS(dvp), fid, &no.fattr, dvp, &vp); @@ -493,7 +494,7 @@ nwfs_remove(ap) return EPERM; cache_purge(vp); error = ncp_DeleteNSEntry(nmp, VTONW(dvp)->n_fid.f_id, - cnp->cn_namelen,cnp->cn_nameptr,cnp->cn_proc,cnp->cn_cred); + cnp->cn_namelen, cnp->cn_nameptr, cnp->cn_thread, cnp->cn_cred); if (error == 0) np->n_flag |= NSHOULDFREE; else if (error == 0x899c) @@ -539,7 +540,7 @@ nwfs_rename(ap) if (tvp && tvp != fvp) { error = ncp_DeleteNSEntry(nmp, VTONW(tdvp)->n_fid.f_id, tcnp->cn_namelen, tcnp->cn_nameptr, - tcnp->cn_proc, tcnp->cn_cred); + tcnp->cn_thread, tcnp->cn_cred); if (error == 0x899c) error = EACCES; if (error) goto out; @@ -554,7 +555,7 @@ nwfs_rename(ap) oldtype, &nmp->m.nls, VTONW(fdvp)->n_fid.f_id, fcnp->cn_nameptr, fcnp->cn_namelen, VTONW(tdvp)->n_fid.f_id, tcnp->cn_nameptr, tcnp->cn_namelen, - tcnp->cn_proc,tcnp->cn_cred); + tcnp->cn_thread, tcnp->cn_cred); if (error == 0x8992) error = EEXIST; @@ -648,15 +649,15 @@ nwfs_mkdir(ap) struct vattr vattr; char *name=cnp->cn_nameptr; - if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc))) { + if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_thread))) { return (error); } if ((name[0] == '.') && ((len == 1) || ((len == 2) && (name[1] == '.')))) { return EEXIST; } - if (ncp_open_create_file_or_subdir(VTONWFS(dvp),dvp, cnp->cn_namelen, - cnp->cn_nameptr,OC_MODE_CREATE, aDIR, 0xffff, - &no, cnp->cn_proc, cnp->cn_cred) != 0) { + if (ncp_open_create_file_or_subdir(VTONWFS(dvp), dvp, cnp->cn_namelen, + cnp->cn_nameptr, OC_MODE_CREATE, aDIR, 0xffff, + &no, cnp->cn_thread, cnp->cn_cred) != 0) { error = EACCES; } else { error = 0; @@ -697,7 +698,7 @@ nwfs_rmdir(ap) return EINVAL; error = ncp_DeleteNSEntry(nmp, dnp->n_fid.f_id, - cnp->cn_namelen, cnp->cn_nameptr,cnp->cn_proc,cnp->cn_cred); + cnp->cn_namelen, cnp->cn_nameptr, cnp->cn_thread, cnp->cn_cred); if (error == 0) np->n_flag |= NSHOULDFREE; else if (error == NWE_DIR_NOT_EMPTY) @@ -745,10 +746,10 @@ nwfs_fsync(ap) struct vnode * a_vp; struct ucred * a_cred; int a_waitfor; - struct proc * a_p; + struct thread *a_td; } */ *ap; { -/* return (nfs_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_p, 1));*/ +/* return (nfs_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_td, 1));*/ return (0); } @@ -800,16 +801,16 @@ static int nwfs_strategy (ap) { struct buf *bp=ap->a_bp; struct ucred *cr; - struct proc *p; + struct thread *td; int error = 0; NCPVNDEBUG("\n"); if (bp->b_flags & B_PHYS) panic("nwfs physio"); if (bp->b_flags & B_ASYNC) - p = (struct proc *)0; + td = (struct thread *)0; else - p = curproc; /* XXX */ + td = curthread; /* XXX */ if (bp->b_iocmd == BIO_READ) cr = bp->b_rcred; else @@ -820,7 +821,7 @@ static int nwfs_strategy (ap) * otherwise just do it ourselves. */ if ((bp->b_flags & B_ASYNC) == 0 ) - error = nwfs_doio(bp, cr, p); + error = nwfs_doio(bp, cr, td); return (error); } @@ -851,9 +852,9 @@ nwfs_lookup(ap) ncpfid fid; int nameiop=cnp->cn_nameiop, islastcn; int lockparent, wantparent, error = 0, notfound; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; char _name[cnp->cn_namelen+1]; - bcopy(cnp->cn_nameptr,_name,cnp->cn_namelen); + bcopy(cnp->cn_nameptr, _name, cnp->cn_namelen); _name[cnp->cn_namelen]=0; if (dvp->v_type != VDIR) @@ -869,7 +870,7 @@ nwfs_lookup(ap) islastcn = flags & ISLASTCN; if (islastcn && (mp->mnt_flag & MNT_RDONLY) && (nameiop != LOOKUP)) return (EROFS); - if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, p))) + if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, td))) return (error); lockparent = flags & LOCKPARENT; wantparent = flags & (LOCKPARENT|WANTPARENT); @@ -884,7 +885,7 @@ printf("dvp %d:%d:%d\n", (int)mp, (int)dvp->v_flag & VROOT, (int)flags & ISDOTDO return ENOENT; error = cache_lookup(dvp, vpp, cnp); - NCPVNDEBUG("cache_lookup returned %d\n",error); + NCPVNDEBUG("cache_lookup returned %d\n", error); if (error > 0) return error; if (error) { /* name was found */ @@ -898,18 +899,18 @@ printf("dvp %d:%d:%d\n", (int)mp, (int)dvp->v_flag & VROOT, (int)flags & ISDOTDO error = 0; NCPVNDEBUG("cached '.'"); } else if (flags & ISDOTDOT) { - VOP_UNLOCK(dvp, 0, p); /* unlock parent */ - error = vget(vp, LK_EXCLUSIVE, p); + VOP_UNLOCK(dvp, 0, td); /* unlock parent */ + error = vget(vp, LK_EXCLUSIVE, td); if (!error && lockparent && islastcn) - error = vn_lock(dvp, LK_EXCLUSIVE, p); + error = vn_lock(dvp, LK_EXCLUSIVE, td); } else { - error = vget(vp, LK_EXCLUSIVE, p); + error = vget(vp, LK_EXCLUSIVE, td); if (!lockparent || error || !islastcn) - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); } if (!error) { if (vpid == vp->v_id) { - if (!VOP_GETATTR(vp, &vattr, cnp->cn_cred, p) + if (!VOP_GETATTR(vp, &vattr, cnp->cn_cred, td) && vattr.va_ctime.tv_sec == VTONW(vp)->n_ctime) { if (nameiop != LOOKUP && islastcn) cnp->cn_flags |= SAVENAME; @@ -920,9 +921,9 @@ printf("dvp %d:%d:%d\n", (int)mp, (int)dvp->v_flag & VROOT, (int)flags & ISDOTDO } vput(vp); if (lockparent && dvp != vp && islastcn) - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); } - error = vn_lock(dvp, LK_EXCLUSIVE, p); + error = vn_lock(dvp, LK_EXCLUSIVE, td); *vpp = NULLVP; if (error) return (error); @@ -937,7 +938,7 @@ printf("dvp %d:%d:%d\n", (int)mp, (int)dvp->v_flag & VROOT, (int)flags & ISDOTDO fap = NULL; notfound = 0; } else { - error = nwfs_lookupnp(nmp, dnp->n_parent, p, &npp); + error = nwfs_lookupnp(nmp, dnp->n_parent, td, &npp); if (error) { return error; } @@ -945,18 +946,18 @@ printf("dvp %d:%d:%d\n", (int)mp, (int)dvp->v_flag & VROOT, (int)flags & ISDOTDO fap = &fattr; /*np = *npp;*/ notfound = ncp_obtain_info(nmp, npp->n_dosfid, - 0, NULL, fap, p, cnp->cn_cred); + 0, NULL, fap, td, cnp->cn_cred); } } else { fap = &fattr; notfound = ncp_lookup(dvp, cnp->cn_namelen, cnp->cn_nameptr, - fap, p, cnp->cn_cred); + fap, td, cnp->cn_cred); fid.f_id = fap->dirEntNum; if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') { fid.f_parent = dnp->n_fid.f_parent; } else fid.f_parent = dnp->n_fid.f_id; - NCPVNDEBUG("call to ncp_lookup returned=%d\n",notfound); + NCPVNDEBUG("call to ncp_lookup returned=%d\n", notfound); } if (notfound && notfound < 0x80 ) return (notfound); /* hard error */ @@ -965,7 +966,7 @@ printf("dvp %d:%d:%d\n", (int)mp, (int)dvp->v_flag & VROOT, (int)flags & ISDOTDO if ((nameiop == CREATE || nameiop == RENAME) && wantparent && islastcn) { cnp->cn_flags |= SAVENAME; if (!lockparent) - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); return (EJUSTRETURN); } return ENOENT; @@ -974,7 +975,7 @@ printf("dvp %d:%d:%d\n", (int)mp, (int)dvp->v_flag & VROOT, (int)flags & ISDOTDO }*/ /* handle DELETE case ... */ if (nameiop == DELETE && islastcn) { /* delete last component */ - error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, cnp->cn_proc); + error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, cnp->cn_thread); if (error) return (error); if (NWCMPF(&dnp->n_fid, &fid)) { /* we found ourselfs */ VREF(dvp); @@ -985,11 +986,11 @@ printf("dvp %d:%d:%d\n", (int)mp, (int)dvp->v_flag & VROOT, (int)flags & ISDOTDO if (error) return (error); *vpp = vp; cnp->cn_flags |= SAVENAME; /* I free it later */ - if (!lockparent) VOP_UNLOCK(dvp,0,p); + if (!lockparent) VOP_UNLOCK(dvp, 0, td); return (0); } if (nameiop == RENAME && islastcn && wantparent) { - error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, cnp->cn_proc); + error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, cnp->cn_thread); if (error) return (error); if (NWCMPF(&dnp->n_fid, &fid)) return EISDIR; error = nwfs_nget(mp, fid, fap, dvp, &vp); @@ -997,18 +998,18 @@ printf("dvp %d:%d:%d\n", (int)mp, (int)dvp->v_flag & VROOT, (int)flags & ISDOTDO *vpp = vp; cnp->cn_flags |= SAVENAME; if (!lockparent) - VOP_UNLOCK(dvp,0,p); + VOP_UNLOCK(dvp, 0, td); return (0); } if (flags & ISDOTDOT) { - VOP_UNLOCK(dvp, 0, p); /* race to get the inode */ + VOP_UNLOCK(dvp, 0, td); /* race to get the inode */ error = nwfs_nget(mp, fid, NULL, NULL, &vp); if (error) { - vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td); return (error); } if (lockparent && islastcn && - (error = vn_lock(dvp, LK_EXCLUSIVE, p))) { + (error = vn_lock(dvp, LK_EXCLUSIVE, td))) { vput(vp); return (error); } @@ -1022,7 +1023,7 @@ printf("dvp %d:%d:%d\n", (int)mp, (int)dvp->v_flag & VROOT, (int)flags & ISDOTDO *vpp = vp; NCPVNDEBUG("lookup: getnewvp!\n"); if (!lockparent || !islastcn) - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); } if ((cnp->cn_flags & MAKEENTRY)/* && !islastcn*/) { VTONW(*vpp)->n_ctime = VTONW(*vpp)->n_vattr.va_ctime.tv_sec; diff --git a/sys/fs/portalfs/portal_vfsops.c b/sys/fs/portalfs/portal_vfsops.c index 5c47e72..80356e4 100644 --- a/sys/fs/portalfs/portal_vfsops.c +++ b/sys/fs/portalfs/portal_vfsops.c @@ -62,23 +62,23 @@ static MALLOC_DEFINE(M_PORTALFSMNT, "PORTAL mount", "PORTAL mount structure"); static int portal_mount __P((struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p)); + struct nameidata *ndp, struct thread *td)); static int portal_unmount __P((struct mount *mp, int mntflags, - struct proc *p)); + struct thread *td)); static int portal_root __P((struct mount *mp, struct vnode **vpp)); static int portal_statfs __P((struct mount *mp, struct statfs *sbp, - struct proc *p)); + struct thread *td)); /* * Mount the per-process file descriptors (/dev/fd) */ static int -portal_mount(mp, path, data, ndp, p) +portal_mount(mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { struct file *fp; struct portal_args args; @@ -99,12 +99,12 @@ portal_mount(mp, path, data, ndp, p) if (error) return (error); - error = holdsock(p->p_fd, args.pa_socket, &fp); + error = holdsock(td->td_proc->p_fd, args.pa_socket, &fp); if (error) return (error); so = (struct socket *) fp->f_data; if (so->so_proto->pr_domain->dom_family != AF_UNIX) { - fdrop(fp, p); + fdrop(fp, td); return (ESOCKTNOSUPPORT); } @@ -118,7 +118,7 @@ portal_mount(mp, path, data, ndp, p) if (error) { FREE(fmp, M_PORTALFSMNT); FREE(pn, M_TEMP); - fdrop(fp, p); + fdrop(fp, td); return (error); } @@ -144,16 +144,16 @@ portal_mount(mp, path, data, ndp, p) bcopy("portal", mp->mnt_stat.f_mntfromname, sizeof("portal")); #endif - (void)portal_statfs(mp, &mp->mnt_stat, p); - fdrop(fp, p); + (void)portal_statfs(mp, &mp->mnt_stat, td); + fdrop(fp, td); return (0); } static int -portal_unmount(mp, mntflags, p) +portal_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { int error, flags = 0; @@ -186,7 +186,7 @@ portal_unmount(mp, mntflags, p) * Discard reference to underlying file. Must call closef because * this may be the last reference. */ - closef(VFSTOPORTAL(mp)->pm_server, (struct proc *) 0); + closef(VFSTOPORTAL(mp)->pm_server, (struct thread *) 0); /* * Finally, throw away the portalmount structure */ @@ -200,7 +200,7 @@ portal_root(mp, vpp) struct mount *mp; struct vnode **vpp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct vnode *vp; /* @@ -208,16 +208,16 @@ portal_root(mp, vpp) */ vp = VFSTOPORTAL(mp)->pm_root; VREF(vp); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); *vpp = vp; return (0); } static int -portal_statfs(mp, sbp, p) +portal_statfs(mp, sbp, td) struct mount *mp; struct statfs *sbp; - struct proc *p; + struct thread *td; { sbp->f_flags = 0; diff --git a/sys/fs/portalfs/portal_vnops.c b/sys/fs/portalfs/portal_vnops.c index 03deb34..0e20d13 100644 --- a/sys/fs/portalfs/portal_vnops.c +++ b/sys/fs/portalfs/portal_vnops.c @@ -65,7 +65,7 @@ static int portal_fileid = PORTAL_ROOTFILEID+1; -static void portal_closefd __P((struct proc *p, int fd)); +static void portal_closefd __P((struct thread *td, int fd)); static int portal_connect __P((struct socket *so, struct socket *so2)); static int portal_getattr __P((struct vop_getattr_args *ap)); static int portal_lookup __P((struct vop_lookup_args *ap)); @@ -76,15 +76,15 @@ static int portal_reclaim __P((struct vop_reclaim_args *ap)); static int portal_setattr __P((struct vop_setattr_args *ap)); static void -portal_closefd(p, fd) - struct proc *p; +portal_closefd(td, fd) + struct thread *td; int fd; { int error; struct close_args ua; ua.fd = fd; - error = close(p, &ua); + error = close(td, &ua); /* * We should never get an error, and there isn't anything * we could do if we got one, so just print a message. @@ -204,12 +204,12 @@ portal_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct socket *so = 0; struct portalnode *pt; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; struct vnode *vp = ap->a_vp; int s; struct uio auio; @@ -237,7 +237,7 @@ portal_open(ap) * to deal with the side effects. Check for this * by testing whether the p_dupfd has been set. */ - if (p->p_dupfd >= 0) + if (td->td_dupfd >= 0) return (ENODEV); pt = VTOPORTAL(vp); @@ -246,7 +246,7 @@ portal_open(ap) /* * Create a new socket. */ - error = socreate(AF_UNIX, &so, SOCK_STREAM, 0, ap->a_p); + error = socreate(AF_UNIX, &so, SOCK_STREAM, 0, ap->a_td); if (error) goto bad; @@ -315,12 +315,12 @@ portal_open(ap) auio.uio_iovcnt = 2; auio.uio_rw = UIO_WRITE; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; auio.uio_resid = aiov[0].iov_len + aiov[1].iov_len; error = sosend(so, (struct sockaddr *) 0, &auio, - (struct mbuf *) 0, (struct mbuf *) 0, 0, p); + (struct mbuf *) 0, (struct mbuf *) 0, 0 , td); if (error) goto bad; @@ -392,7 +392,7 @@ portal_open(ap) int i; printf("portal_open: %d extra fds\n", newfds - 1); for (i = 1; i < newfds; i++) { - portal_closefd(p, *ip); + portal_closefd(td, *ip); ip++; } } @@ -401,9 +401,9 @@ portal_open(ap) * Check that the mode the file is being opened for is a subset * of the mode of the existing descriptor. */ - fp = p->p_fd->fd_ofiles[fd]; + fp = td->td_proc->p_fd->fd_ofiles[fd]; if (((ap->a_mode & (FREAD|FWRITE)) | fp->f_flag) != fp->f_flag) { - portal_closefd(p, fd); + portal_closefd(td, fd); error = EACCES; goto bad; } @@ -413,7 +413,7 @@ portal_open(ap) * special error code (ENXIO) which causes magic things to * happen in vn_open. The whole concept is, well, hmmm. */ - p->p_dupfd = fd; + td->td_dupfd = fd; error = ENXIO; bad:; @@ -437,7 +437,7 @@ portal_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -482,7 +482,7 @@ portal_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { diff --git a/sys/fs/procfs/procfs.h b/sys/fs/procfs/procfs.h index b46b9c0..d97f825 100644 --- a/sys/fs/procfs/procfs.h +++ b/sys/fs/procfs/procfs.h @@ -119,14 +119,14 @@ void procfs_exit __P((struct proc *)); int procfs_freevp __P((struct vnode *)); int procfs_allocvp __P((struct mount *, struct vnode **, long, pfstype)); struct vnode *procfs_findtextvp __P((struct proc *)); -int procfs_sstep __P((struct proc *)); -void procfs_fix_sstep __P((struct proc *)); -int procfs_read_regs __P((struct proc *, struct reg *)); -int procfs_write_regs __P((struct proc *, struct reg *)); -int procfs_read_fpregs __P((struct proc *, struct fpreg *)); -int procfs_write_fpregs __P((struct proc *, struct fpreg *)); -int procfs_read_dbregs __P((struct proc *, struct dbreg *)); -int procfs_write_dbregs __P((struct proc *, struct dbreg *)); +int procfs_sstep __P((struct thread *)); +void procfs_fix_sstep __P((struct thread *)); +int procfs_read_regs __P((struct thread *, struct reg *)); +int procfs_write_regs __P((struct thread *, struct reg *)); +int procfs_read_fpregs __P((struct thread *, struct fpreg *)); +int procfs_write_fpregs __P((struct thread *, struct fpreg *)); +int procfs_read_dbregs __P((struct thread *, struct dbreg *)); +int procfs_write_dbregs __P((struct thread *, struct dbreg *)); int procfs_donote __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio)); int procfs_doregs __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio)); int procfs_dofpregs __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio)); @@ -140,12 +140,12 @@ int procfs_docmdline __P((struct proc *, struct proc *, struct pfsnode *pfsp, st int procfs_dorlimit __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio)); /* functions to check whether or not files should be displayed */ -int procfs_validfile __P((struct proc *)); -int procfs_validfpregs __P((struct proc *)); -int procfs_validregs __P((struct proc *)); -int procfs_validdbregs __P((struct proc *)); -int procfs_validmap __P((struct proc *)); -int procfs_validtype __P((struct proc *)); +int procfs_validfile __P((struct thread *)); +int procfs_validfpregs __P((struct thread *)); +int procfs_validregs __P((struct thread *)); +int procfs_validdbregs __P((struct thread *)); +int procfs_validmap __P((struct thread *)); +int procfs_validtype __P((struct thread *)); #define PROCFS_LOCKED 0x01 #define PROCFS_WANT 0x02 diff --git a/sys/fs/procfs/procfs_ctl.c b/sys/fs/procfs/procfs_ctl.c index 30b61f2..eacf32a 100644 --- a/sys/fs/procfs/procfs_ctl.c +++ b/sys/fs/procfs/procfs_ctl.c @@ -190,7 +190,7 @@ out: /* * do single-step fixup if needed */ - FIX_SSTEP(p); + FIX_SSTEP(&p->p_thread); /* XXXKSE */ #endif /* @@ -246,7 +246,7 @@ out: case PROCFS_CTL_STEP: _PHOLD(p); PROC_UNLOCK(p); - error = procfs_sstep(p); + error = procfs_sstep(&p->p_thread); /* XXXKSE */ PRELE(p); if (error) return (error); @@ -300,7 +300,7 @@ out: mtx_lock_spin(&sched_lock); if (p->p_stat == SSTOP) - setrunnable(p); + setrunnable(&p->p_thread); /* XXXKSE */ mtx_unlock_spin(&sched_lock); return (0); } @@ -347,9 +347,9 @@ procfs_doctl(curp, p, pfs, uio) if (TRACE_WAIT_P(curp, p)) { p->p_xstat = nm->nm_val; #ifdef FIX_SSTEP - FIX_SSTEP(p); + FIX_SSTEP(&p->p_thread); /* XXXKSE */ #endif - setrunnable(p); + setrunnable(&p->p_thread); /* XXXKSE */ mtx_unlock_spin(&sched_lock); } else { mtx_unlock_spin(&sched_lock); diff --git a/sys/fs/procfs/procfs_dbregs.c b/sys/fs/procfs/procfs_dbregs.c index d61b8c9..5de041a 100644 --- a/sys/fs/procfs/procfs_dbregs.c +++ b/sys/fs/procfs/procfs_dbregs.c @@ -83,14 +83,14 @@ procfs_dodbregs(curp, p, pfs, uio) if (kl < 0) error = EINVAL; else - error = procfs_read_dbregs(p, &r); + error = procfs_read_dbregs(&p->p_thread, &r); /* XXXKSE */ if (error == 0) error = uiomove(kv, kl, uio); if (error == 0 && uio->uio_rw == UIO_WRITE) { if (p->p_stat != SSTOP) error = EBUSY; else - error = procfs_write_dbregs(p, &r); + error = procfs_write_dbregs(&p->p_thread, &r); /* XXXKSE */ } PRELE(p); @@ -99,9 +99,8 @@ procfs_dodbregs(curp, p, pfs, uio) } int -procfs_validdbregs(p) - struct proc *p; +procfs_validdbregs(struct thread *td) { - return ((p->p_flag & P_SYSTEM) == 0); + return ((td->td_proc->p_flag & P_SYSTEM) == 0); } diff --git a/sys/fs/procfs/procfs_fpregs.c b/sys/fs/procfs/procfs_fpregs.c index 9b6cd3a..2b68693 100644 --- a/sys/fs/procfs/procfs_fpregs.c +++ b/sys/fs/procfs/procfs_fpregs.c @@ -80,14 +80,14 @@ procfs_dofpregs(curp, p, pfs, uio) if (kl < 0) error = EINVAL; else - error = procfs_read_fpregs(p, &r); + error = procfs_read_fpregs(&p->p_thread, &r); if (error == 0) error = uiomove(kv, kl, uio); if (error == 0 && uio->uio_rw == UIO_WRITE) { if (p->p_stat != SSTOP) error = EBUSY; else - error = procfs_write_fpregs(p, &r); + error = procfs_write_fpregs(&p->p_thread, &r); } PRELE(p); @@ -96,9 +96,8 @@ procfs_dofpregs(curp, p, pfs, uio) } int -procfs_validfpregs(p) - struct proc *p; +procfs_validfpregs(struct thread *td) { - return ((p->p_flag & P_SYSTEM) == 0); + return (( td->td_proc->p_flag & P_SYSTEM) == 0); } diff --git a/sys/fs/procfs/procfs_map.c b/sys/fs/procfs/procfs_map.c index 692594d..945639a 100644 --- a/sys/fs/procfs/procfs_map.c +++ b/sys/fs/procfs/procfs_map.c @@ -182,8 +182,7 @@ case OBJT_DEVICE: } int -procfs_validmap(p) - struct proc *p; +procfs_validmap(struct thread *td) { - return ((p->p_flag & P_SYSTEM) == 0); + return ((td->td_proc->p_flag & P_SYSTEM) == 0); } diff --git a/sys/fs/procfs/procfs_regs.c b/sys/fs/procfs/procfs_regs.c index 6a00ecd..f590075 100644 --- a/sys/fs/procfs/procfs_regs.c +++ b/sys/fs/procfs/procfs_regs.c @@ -81,14 +81,14 @@ procfs_doregs(curp, p, pfs, uio) if (kl < 0) error = EINVAL; else - error = procfs_read_regs(p, &r); + error = procfs_read_regs(&p->p_thread, &r); /* XXXKSE */ if (error == 0) error = uiomove(kv, kl, uio); if (error == 0 && uio->uio_rw == UIO_WRITE) { if (p->p_stat != SSTOP) error = EBUSY; else - error = procfs_write_regs(p, &r); + error = procfs_write_regs(&p->p_thread, &r); /* XXXKSE */ } PRELE(p); @@ -97,9 +97,8 @@ procfs_doregs(curp, p, pfs, uio) } int -procfs_validregs(p) - struct proc *p; +procfs_validregs(struct thread *td) { - return ((p->p_flag & P_SYSTEM) == 0); + return ((td->td_proc->p_flag & P_SYSTEM) == 0); } diff --git a/sys/fs/procfs/procfs_status.c b/sys/fs/procfs/procfs_status.c index 3a2a814..c75294b 100644 --- a/sys/fs/procfs/procfs_status.c +++ b/sys/fs/procfs/procfs_status.c @@ -145,8 +145,14 @@ procfs_dostatus(curp, p, pfs, uio) } DOCHECK(); - ps += snprintf(ps, psbuf + sizeof(psbuf) - ps, " %s", - (p->p_wchan && p->p_wmesg) ? p->p_wmesg : "nochan"); + if (p->p_flag & P_KSES) { + ps += snprintf(ps, psbuf + sizeof(psbuf) - ps, " %s", + "-kse- "); + } else { + ps += snprintf(ps, psbuf + sizeof(psbuf) - ps, " %s", + (p->p_thread.td_wchan && p->p_thread.td_wmesg) ? + p->p_thread.td_wmesg : "nochan"); + } DOCHECK(); cr = p->p_ucred; diff --git a/sys/fs/procfs/procfs_subr.c b/sys/fs/procfs/procfs_subr.c index 8575058..a411546 100644 --- a/sys/fs/procfs/procfs_subr.c +++ b/sys/fs/procfs/procfs_subr.c @@ -88,7 +88,7 @@ procfs_allocvp(mp, vpp, pid, pfs_type) long pid; pfstype pfs_type; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct pfsnode *pfs; struct vnode *vp; struct pfsnode **pp; @@ -100,7 +100,7 @@ loop: if (pfs->pfs_pid == pid && pfs->pfs_type == pfs_type && vp->v_mount == mp) { - if (vget(vp, 0, p)) + if (vget(vp, 0, td)) goto loop; *vpp = vp; return (0); @@ -246,7 +246,7 @@ procfs_rw(ap) { struct vnode *vp = ap->a_vp; struct uio *uio = ap->a_uio; - struct proc *curp = uio->uio_procp; + struct proc *curp = uio->uio_td->td_proc; struct pfsnode *pfs = VTOPFS(vp); struct proc *p; int rtval; diff --git a/sys/fs/procfs/procfs_type.c b/sys/fs/procfs/procfs_type.c index 3919c88..31cbcf0 100644 --- a/sys/fs/procfs/procfs_type.c +++ b/sys/fs/procfs/procfs_type.c @@ -78,8 +78,7 @@ procfs_dotype(curp, p, pfs, uio) } int -procfs_validtype(p) - struct proc *p; +procfs_validtype(struct thread *td) { - return ((p->p_flag & P_SYSTEM) == 0); + return ((td->td_proc->p_flag & P_SYSTEM) == 0); } diff --git a/sys/fs/procfs/procfs_vfsops.c b/sys/fs/procfs/procfs_vfsops.c index c0d7add..2442022 100644 --- a/sys/fs/procfs/procfs_vfsops.c +++ b/sys/fs/procfs/procfs_vfsops.c @@ -52,11 +52,11 @@ #include <fs/procfs/procfs.h> static int procfs_mount __P((struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p)); + struct nameidata *ndp, struct thread *td)); static int procfs_statfs __P((struct mount *mp, struct statfs *sbp, - struct proc *p)); + struct thread *td)); static int procfs_unmount __P((struct mount *mp, int mntflags, - struct proc *p)); + struct thread *td)); /* * VFS Operations. @@ -65,12 +65,12 @@ static int procfs_unmount __P((struct mount *mp, int mntflags, */ /* ARGSUSED */ static int -procfs_mount(mp, path, data, ndp, p) +procfs_mount(mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { size_t size; int error; @@ -90,7 +90,7 @@ procfs_mount(mp, path, data, ndp, p) size = sizeof("procfs") - 1; bcopy("procfs", mp->mnt_stat.f_mntfromname, size); bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void)procfs_statfs(mp, &mp->mnt_stat, p); + (void)procfs_statfs(mp, &mp->mnt_stat, td); return (0); } @@ -99,10 +99,10 @@ procfs_mount(mp, path, data, ndp, p) * unmount system call */ static int -procfs_unmount(mp, mntflags, p) +procfs_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { int error; int flags = 0; @@ -133,10 +133,10 @@ procfs_root(mp, vpp) * Get file system statistics. */ static int -procfs_statfs(mp, sbp, p) +procfs_statfs(mp, sbp, td) struct mount *mp; struct statfs *sbp; - struct proc *p; + struct thread *td; { sbp->f_bsize = PAGE_SIZE; sbp->f_iosize = PAGE_SIZE; diff --git a/sys/fs/procfs/procfs_vnops.c b/sys/fs/procfs/procfs_vnops.c index 206f3e5..5367078 100644 --- a/sys/fs/procfs/procfs_vnops.c +++ b/sys/fs/procfs/procfs_vnops.c @@ -91,7 +91,7 @@ static struct proc_target { u_char pt_namlen; char *pt_name; pfstype pt_pfstype; - int (*pt_valid) __P((struct proc *p)); + int (*pt_valid) __P((struct thread *p)); } proc_targets[] = { #define N(s) sizeof(s)-1, s /* name type validp */ @@ -133,7 +133,7 @@ procfs_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct pfsnode *pfs = VTOPFS(ap->a_vp); @@ -143,7 +143,7 @@ procfs_open(ap) p2 = PFIND(pfs->pfs_pid); if (p2 == NULL) return (ENOENT); - if (pfs->pfs_pid && p_cansee(ap->a_p, p2)) { + if (pfs->pfs_pid && p_cansee(ap->a_td->td_proc, p2)) { error = ENOENT; goto out; } @@ -156,7 +156,7 @@ procfs_open(ap) goto out; } - p1 = ap->a_p; + p1 = ap->a_td->td_proc; error = p_candebug(p1, p2); if (error) return (error); @@ -185,7 +185,7 @@ procfs_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct pfsnode *pfs = VTOPFS(ap->a_vp); @@ -235,7 +235,7 @@ procfs_ioctl(ap) struct procfs_status *psp; unsigned char flags; - p = ap->a_p; + p = ap->a_td->td_proc; procp = pfind(pfs->pfs_pid); if (procp == NULL) { return ENOTTY; @@ -380,7 +380,7 @@ procfs_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct pfsnode *pfs = VTOPFS(ap->a_vp); @@ -407,7 +407,7 @@ procfs_getattr(ap) return (ENOENT); } - if (p_cansee(ap->a_p, procp)) { + if (p_cansee(ap->a_td->td_proc, procp)) { PROC_UNLOCK(procp); return (ENOENT); } @@ -569,7 +569,7 @@ procfs_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { @@ -603,7 +603,7 @@ procfs_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct pfsnode *pfs = VTOPFS(ap->a_vp); @@ -621,7 +621,7 @@ procfs_access(ap) procp = PFIND(pfs->pfs_pid); if (procp == NULL) return (ENOENT); - if (p_cansee(ap->a_p, procp)) { + if (p_cansee(ap->a_td->td_proc, procp)) { PROC_UNLOCK(procp); return (ENOENT); } @@ -629,7 +629,7 @@ procfs_access(ap) } vap = &vattr; - error = VOP_GETATTR(vp, vap, ap->a_cred, ap->a_p); + error = VOP_GETATTR(vp, vap, ap->a_cred, ap->a_td); if (error) return (error); @@ -658,12 +658,13 @@ procfs_lookup(ap) struct vnode **vpp = ap->a_vpp; struct vnode *dvp = ap->a_dvp; char *pname = cnp->cn_nameptr; - struct proc *curp = cnp->cn_proc; + struct proc *curp = cnp->cn_thread->td_proc; struct proc_target *pt; pid_t pid; struct pfsnode *pfs; struct proc *p; int i; + struct thread *td; *vpp = NULL; @@ -708,13 +709,14 @@ procfs_lookup(ap) return (procfs_root(dvp->v_mount, vpp)); p = PFIND(pfs->pfs_pid); + td = &p->p_thread; /* XXXKSE */ if (p == NULL) break; for (pt = proc_targets, i = 0; i < nproc_targets; pt++, i++) { if (cnp->cn_namelen == pt->pt_namlen && bcmp(pt->pt_name, pname, cnp->cn_namelen) == 0 && - (pt->pt_valid == NULL || (*pt->pt_valid)(p))) + (pt->pt_valid == NULL || (*pt->pt_valid)(td))) goto found; } PROC_UNLOCK(p); @@ -735,11 +737,11 @@ procfs_lookup(ap) * Does this process have a text file? */ int -procfs_validfile(p) - struct proc *p; +procfs_validfile(td) + struct thread *td; { - return (procfs_findtextvp(p) != NULLVP); + return (procfs_findtextvp(td->td_proc) != NULLVP); } /* @@ -765,6 +767,7 @@ procfs_readdir(ap) struct pfsnode *pfs; int count, error, i, off; static u_int delen; + struct thread *td; if (!delen) { @@ -794,16 +797,17 @@ procfs_readdir(ap) struct proc_target *pt; p = PFIND(pfs->pfs_pid); + td = &p->p_thread; /* XXXKSE */ if (p == NULL) break; - if (p_cansee(curproc, p)) { + if (p_cansee(curthread->td_proc, p)) { PROC_UNLOCK(p); break; } for (pt = &proc_targets[i]; uio->uio_resid >= delen && i < nproc_targets; pt++, i++) { - if (pt->pt_valid && (*pt->pt_valid)(p) == 0) + if (pt->pt_valid && (*pt->pt_valid)(td) == 0) continue; dp->d_reclen = delen; @@ -864,11 +868,11 @@ procfs_readdir(ap) p = LIST_NEXT(p, p_list); if (p == NULL) goto done; - if (p_cansee(curproc, p)) + if (p_cansee(curthread->td_proc, p)) continue; pcnt++; } - while (p_cansee(curproc, p)) { + while (p_cansee(curthread->td_proc, p)) { p = LIST_NEXT(p, p_list); if (p == NULL) goto done; diff --git a/sys/fs/pseudofs/pseudofs.c b/sys/fs/pseudofs/pseudofs.c index e74c683..45117ac 100644 --- a/sys/fs/pseudofs/pseudofs.c +++ b/sys/fs/pseudofs/pseudofs.c @@ -51,7 +51,7 @@ SYSCTL_NODE(_vfs, OID_AUTO, pfs, CTLFLAG_RW, 0, */ int pfs_mount(struct pfs_info *pi, struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p) + struct nameidata *ndp, struct thread *td) { struct statfs *sbp; @@ -79,7 +79,7 @@ pfs_mount(struct pfs_info *pi, struct mount *mp, char *path, caddr_t data, * Unmount a pseudofs instance */ int -pfs_unmount(struct mount *mp, int mntflags, struct proc *p) +pfs_unmount(struct mount *mp, int mntflags, struct thread *td) { struct pfs_info *pi; int error; @@ -108,7 +108,7 @@ pfs_root(struct mount *mp, struct vnode **vpp) * Return filesystem stats */ int -pfs_statfs(struct mount *mp, struct statfs *sbp, struct proc *p) +pfs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td) { bcopy(&mp->mnt_stat, sbp, sizeof *sbp); return (0); diff --git a/sys/fs/pseudofs/pseudofs.h b/sys/fs/pseudofs/pseudofs.h index cfe3d9e..474f442 100644 --- a/sys/fs/pseudofs/pseudofs.h +++ b/sys/fs/pseudofs/pseudofs.h @@ -56,7 +56,7 @@ struct pfs_node; struct pfs_bitmap; #define PFS_FILL_ARGS \ - struct proc *curp, struct proc *p, struct pfs_node *pn, struct sbuf *sb + struct thread *td, struct proc *p, struct pfs_node *pn, struct sbuf *sb #define PFS_FILL_PROTO(name) \ int name(PFS_FILL_ARGS); typedef int (*pfs_fill_t)(PFS_FILL_ARGS); @@ -122,12 +122,12 @@ struct pfs_node { */ int pfs_mount (struct pfs_info *pi, struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p); + struct nameidata *ndp, struct thread *td); int pfs_unmount (struct mount *mp, int mntflags, - struct proc *p); + struct thread *td); int pfs_root (struct mount *mp, struct vnode **vpp); int pfs_statfs (struct mount *mp, struct statfs *sbp, - struct proc *p); + struct thread *td); int pfs_init (struct pfs_info *pi, struct vfsconf *vfc); int pfs_uninit (struct pfs_info *pi, struct vfsconf *vfc); @@ -143,8 +143,8 @@ static struct pfs_info name##_info = { \ \ static int \ _##name##_mount(struct mount *mp, char *path, caddr_t data, \ - struct nameidata *ndp, struct proc *p) { \ - return pfs_mount(&name##_info, mp, path, data, ndp, p); \ + struct nameidata *ndp, struct thread *td) { \ + return pfs_mount(&name##_info, mp, path, data, ndp, td); \ } \ \ static int \ diff --git a/sys/fs/pseudofs/pseudofs_vncache.c b/sys/fs/pseudofs/pseudofs_vncache.c index 465bfcd..3ff33d7 100644 --- a/sys/fs/pseudofs/pseudofs_vncache.c +++ b/sys/fs/pseudofs/pseudofs_vncache.c @@ -98,7 +98,7 @@ pfs_vncache_alloc(struct mount *mp, struct vnode **vpp, for (pv = pfs_vncache; pv; pv = pv->pv_next) { pvd = (struct pfs_vdata *)pv->pv_vnode->v_data; if (pvd->pvd_pn == pn && pvd->pvd_pid == pid) { - if (vget(pv->pv_vnode, 0, curproc) == 0) { + if (vget(pv->pv_vnode, 0, curthread) == 0) { ++pfs_vncache_hits; *vpp = pv->pv_vnode; mtx_unlock(&pfs_vncache_mutex); diff --git a/sys/fs/pseudofs/pseudofs_vnops.c b/sys/fs/pseudofs/pseudofs_vnops.c index ea26435..db62cbd 100644 --- a/sys/fs/pseudofs/pseudofs_vnops.c +++ b/sys/fs/pseudofs/pseudofs_vnops.c @@ -56,7 +56,7 @@ pfs_access(struct vop_access_args *va) struct vattr vattr; int error; - error = VOP_GETATTR(vn, &vattr, va->a_cred, va->a_p); + error = VOP_GETATTR(vn, &vattr, va->a_cred, va->a_td); if (error) return (error); error = vaccess(vn->v_type, vattr.va_mode, vattr.va_uid, @@ -230,7 +230,7 @@ pfs_read(struct vop_read_args *va) return (EIO); } - error = (pn->pn_func)(curproc, proc, pn, sb); + error = (pn->pn_func)(curthread, proc, pn, sb); if (proc != NULL) PRELE(proc); @@ -392,7 +392,7 @@ pfs_readlink(struct vop_readlink_args *va) /* sbuf_new() can't fail with a static buffer */ sbuf_new(&sb, buf, sizeof buf, 0); - error = (pn->pn_func)(curproc, proc, pn, &sb); + error = (pn->pn_func)(curthread, proc, pn, &sb); if (proc != NULL) PRELE(proc); diff --git a/sys/fs/specfs/spec_vnops.c b/sys/fs/specfs/spec_vnops.c index f2b1c34..0cdfd26 100644 --- a/sys/fs/specfs/spec_vnops.c +++ b/sys/fs/specfs/spec_vnops.c @@ -131,10 +131,10 @@ spec_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; struct vnode *vp = ap->a_vp; dev_t dev = vp->v_rdev; int error; @@ -191,9 +191,9 @@ spec_open(ap) if (dsw->d_flags & D_TTY) vp->v_flag |= VISTTY; - VOP_UNLOCK(vp, 0, p); - error = (*dsw->d_open)(dev, ap->a_mode, S_IFCHR, p); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_UNLOCK(vp, 0, td); + error = (*dsw->d_open)(dev, ap->a_mode, S_IFCHR, td); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (error) return (error); @@ -238,7 +238,7 @@ spec_read(ap) } */ *ap; { struct vnode *vp; - struct proc *p; + struct thread *td; struct uio *uio; dev_t dev; int error, resid; @@ -246,15 +246,15 @@ spec_read(ap) vp = ap->a_vp; dev = vp->v_rdev; uio = ap->a_uio; - p = uio->uio_procp; + td = uio->uio_td; resid = uio->uio_resid; if (resid == 0) return (0); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); error = (*devsw(dev)->d_read) (dev, uio, ap->a_ioflag); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (uio->uio_resid != resid || (error == 0 && resid != 0)) getnanotime(&dev->si_atime); return (error); @@ -274,7 +274,7 @@ spec_write(ap) } */ *ap; { struct vnode *vp; - struct proc *p; + struct thread *td; struct uio *uio; dev_t dev; int error, resid; @@ -282,12 +282,12 @@ spec_write(ap) vp = ap->a_vp; dev = vp->v_rdev; uio = ap->a_uio; - p = uio->uio_procp; + td = uio->uio_td; resid = uio->uio_resid; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); error = (*devsw(dev)->d_write) (dev, uio, ap->a_ioflag); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (uio->uio_resid != resid || (error == 0 && resid != 0)) { getnanotime(&dev->si_ctime); dev->si_mtime = dev->si_ctime; @@ -307,14 +307,14 @@ spec_ioctl(ap) caddr_t a_data; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { dev_t dev; dev = ap->a_vp->v_rdev; return ((*devsw(dev)->d_ioctl)(dev, ap->a_command, - ap->a_data, ap->a_fflag, ap->a_p)); + ap->a_data, ap->a_fflag, ap->a_td)); } /* ARGSUSED */ @@ -324,13 +324,13 @@ spec_poll(ap) struct vnode *a_vp; int a_events; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { dev_t dev; dev = ap->a_vp->v_rdev; - return (*devsw(dev)->d_poll)(dev, ap->a_events, ap->a_p); + return (*devsw(dev)->d_poll)(dev, ap->a_events, ap->a_td); } /* ARGSUSED */ @@ -359,7 +359,7 @@ spec_fsync(ap) struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -563,11 +563,11 @@ spec_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; dev_t dev = vp->v_rdev; /* @@ -579,10 +579,10 @@ spec_close(ap) * if the reference count is 2 (this last descriptor * plus the session), release the reference from the session. */ - if (vcount(vp) == 2 && p && (vp->v_flag & VXLOCK) == 0 && - vp == p->p_session->s_ttyvp) { + if (vcount(vp) == 2 && td && (vp->v_flag & VXLOCK) == 0 && + vp == td->td_proc->p_session->s_ttyvp) { vrele(vp); - p->p_session->s_ttyvp = NULL; + td->td_proc->p_session->s_ttyvp = NULL; } /* * We do not want to really close the device if it @@ -600,7 +600,7 @@ spec_close(ap) } else if (vcount(vp) > 1) { return (0); } - return (devsw(dev)->d_close(dev, ap->a_fflag, S_IFCHR, p)); + return (devsw(dev)->d_close(dev, ap->a_fflag, S_IFCHR, td)); } /* @@ -716,7 +716,7 @@ spec_getpages(ap) bp->b_iodone = spec_getpages_iodone; /* B_PHYS is not set, but it is nice to fill this in. */ - bp->b_rcred = bp->b_wcred = curproc->p_ucred; + bp->b_rcred = bp->b_wcred = curthread->td_proc->p_ucred; if (bp->b_rcred != NOCRED) crhold(bp->b_rcred); if (bp->b_wcred != NOCRED) diff --git a/sys/fs/umapfs/umap_subr.c b/sys/fs/umapfs/umap_subr.c index afcaceb..c61fe7c 100644 --- a/sys/fs/umapfs/umap_subr.c +++ b/sys/fs/umapfs/umap_subr.c @@ -141,7 +141,7 @@ umap_node_find(mp, targetvp) struct mount *mp; struct vnode *targetvp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct umap_node_hashhead *hd; struct umap_node *a; struct vnode *vp; @@ -168,7 +168,7 @@ loop: * stuff, but we don't want to lock * the lower node. */ - if (vget(vp, 0, p)) { + if (vget(vp, 0, td)) { #ifdef DEBUG printf ("umap_node_find: vget failed.\n"); #endif diff --git a/sys/fs/umapfs/umap_vfsops.c b/sys/fs/umapfs/umap_vfsops.c index 116ce16..a22b8df 100644 --- a/sys/fs/umapfs/umap_vfsops.c +++ b/sys/fs/umapfs/umap_vfsops.c @@ -62,35 +62,35 @@ static int umapfs_fhtovp __P((struct mount *mp, struct fid *fidp, static int umapfs_checkexp __P((struct mount *mp, struct sockaddr *nam, int *extflagsp, struct ucred **credanonp)); static int umapfs_mount __P((struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p)); + struct nameidata *ndp, struct thread *td)); static int umapfs_quotactl __P((struct mount *mp, int cmd, uid_t uid, - caddr_t arg, struct proc *p)); + caddr_t arg, struct thread *td)); static int umapfs_root __P((struct mount *mp, struct vnode **vpp)); -static int umapfs_start __P((struct mount *mp, int flags, struct proc *p)); +static int umapfs_start __P((struct mount *mp, int flags, struct thread *td)); static int umapfs_statfs __P((struct mount *mp, struct statfs *sbp, - struct proc *p)); + struct thread *td)); static int umapfs_sync __P((struct mount *mp, int waitfor, - struct ucred *cred, struct proc *p)); + struct ucred *cred, struct thread *td)); static int umapfs_unmount __P((struct mount *mp, int mntflags, - struct proc *p)); + struct thread *td)); static int umapfs_vget __P((struct mount *mp, ino_t ino, struct vnode **vpp)); static int umapfs_vptofh __P((struct vnode *vp, struct fid *fhp)); static int umapfs_extattrctl __P((struct mount *mp, int cmd, struct vnode *filename_vp, int namespace, const char *attrname, - struct proc *p)); + struct thread *td)); /* * Mount umap layer */ static int -umapfs_mount(mp, path, data, ndp, p) +umapfs_mount(mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { struct umap_args args; struct vnode *lowerrootvp, *vp; @@ -105,7 +105,7 @@ umapfs_mount(mp, path, data, ndp, p) /* * Only for root */ - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) return (error); #ifdef DEBUG @@ -117,7 +117,7 @@ umapfs_mount(mp, path, data, ndp, p) */ if (mp->mnt_flag & MNT_UPDATE) { return (EOPNOTSUPP); - /* return (VFS_MOUNT(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, path, data, ndp, p));*/ + /* return (VFS_MOUNT(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, path, data, ndp, td));*/ } /* @@ -131,7 +131,7 @@ umapfs_mount(mp, path, data, ndp, p) * Find lower node */ NDINIT(ndp, LOOKUP, FOLLOW|WANTPARENT|LOCKLEAF, - UIO_USERSPACE, args.target, p); + UIO_USERSPACE, args.target, td); error = namei(ndp); if (error) return (error); @@ -209,7 +209,7 @@ umapfs_mount(mp, path, data, ndp, p) /* * Unlock the node (either the lower or the alias) */ - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); /* * Make sure the node alias worked */ @@ -234,7 +234,7 @@ umapfs_mount(mp, path, data, ndp, p) (void) copyinstr(args.target, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void)umapfs_statfs(mp, &mp->mnt_stat, p); + (void)umapfs_statfs(mp, &mp->mnt_stat, td); #ifdef DEBUG printf("umapfs_mount: lower %s, alias at %s\n", mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname); @@ -248,23 +248,23 @@ umapfs_mount(mp, path, data, ndp, p) * when that filesystem was mounted. */ static int -umapfs_start(mp, flags, p) +umapfs_start(mp, flags, td) struct mount *mp; int flags; - struct proc *p; + struct thread *td; { return (0); - /* return (VFS_START(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, flags, p)); */ + /* return (VFS_START(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, flags, td)); */ } /* * Free reference to umap layer */ static int -umapfs_unmount(mp, mntflags, p) +umapfs_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { int error; int flags = 0; @@ -304,7 +304,7 @@ umapfs_root(mp, vpp) struct mount *mp; struct vnode **vpp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct vnode *vp; #ifdef DEBUG @@ -318,27 +318,27 @@ umapfs_root(mp, vpp) */ vp = MOUNTTOUMAPMOUNT(mp)->umapm_rootvp; VREF(vp); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); *vpp = vp; return (0); } static int -umapfs_quotactl(mp, cmd, uid, arg, p) +umapfs_quotactl(mp, cmd, uid, arg, td) struct mount *mp; int cmd; uid_t uid; caddr_t arg; - struct proc *p; + struct thread *td; { - return (VFS_QUOTACTL(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, cmd, uid, arg, p)); + return (VFS_QUOTACTL(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, cmd, uid, arg, td)); } static int -umapfs_statfs(mp, sbp, p) +umapfs_statfs(mp, sbp, td) struct mount *mp; struct statfs *sbp; - struct proc *p; + struct thread *td; { int error; struct statfs mstat; @@ -351,7 +351,7 @@ umapfs_statfs(mp, sbp, p) bzero(&mstat, sizeof(mstat)); - error = VFS_STATFS(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, &mstat, p); + error = VFS_STATFS(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, &mstat, td); if (error) return (error); @@ -374,11 +374,11 @@ umapfs_statfs(mp, sbp, p) } static int -umapfs_sync(mp, waitfor, cred, p) +umapfs_sync(mp, waitfor, cred, td) struct mount *mp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { /* * XXX - Assumes no data cached at umap layer. @@ -427,16 +427,16 @@ umapfs_vptofh(vp, fhp) } static int -umapfs_extattrctl(mp, cmd, filename_vp, namespace, attrname, p) +umapfs_extattrctl(mp, cmd, filename_vp, namespace, attrname, td) struct mount *mp; int cmd; struct vnode *filename_vp; int namespace; const char *attrname; - struct proc *p; + struct thread *td; { return (VFS_EXTATTRCTL(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, cmd, - filename_vp, namespace, attrname, p)); + filename_vp, namespace, attrname, td)); } diff --git a/sys/fs/umapfs/umap_vnops.c b/sys/fs/umapfs/umap_vnops.c index b73ff2c..77a8a14 100644 --- a/sys/fs/umapfs/umap_vnops.c +++ b/sys/fs/umapfs/umap_vnops.c @@ -283,7 +283,7 @@ umap_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { short uid, gid; @@ -359,7 +359,7 @@ umap_lock(ap) struct vop_lock_args /* { struct vnode *a_vp; int a_flags; - struct proc *a_p; + struct thread *a_td; } */ *ap; { @@ -380,7 +380,7 @@ umap_unlock(ap) struct vop_unlock_args /* { struct vnode *a_vp; int a_flags; - struct proc *a_p; + struct thread *a_td; } */ *ap; { vop_nounlock(ap); @@ -392,7 +392,7 @@ static int umap_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -405,8 +405,8 @@ umap_inactive(ap) * cache and reusable. * */ - VOP_INACTIVE(lowervp, ap->a_p); - VOP_UNLOCK(ap->a_vp, 0, ap->a_p); + VOP_INACTIVE(lowervp, ap->a_td); + VOP_UNLOCK(ap->a_vp, 0, ap->a_td); return (0); } diff --git a/sys/fs/unionfs/union.h b/sys/fs/unionfs/union.h index 63a881c..0caff1a 100644 --- a/sys/fs/unionfs/union.h +++ b/sys/fs/unionfs/union.h @@ -119,22 +119,22 @@ extern int union_allocvp __P((struct vnode **, struct mount *, struct componentname *, struct vnode *, struct vnode *, int)); extern int union_freevp __P((struct vnode *)); -extern struct vnode *union_dircache __P((struct vnode *, struct proc *)); +extern struct vnode *union_dircache __P((struct vnode *, struct thread *)); extern int union_copyup __P((struct union_node *, int, struct ucred *, - struct proc *)); + struct thread *)); extern int union_dowhiteout __P((struct union_node *, struct ucred *, - struct proc *)); + struct thread *)); extern int union_mkshadow __P((struct union_mount *, struct vnode *, struct componentname *, struct vnode **)); extern int union_mkwhiteout __P((struct union_mount *, struct vnode *, struct componentname *, char *)); extern int union_cn_close __P((struct vnode *, int, struct ucred *, - struct proc *)); + struct thread *)); extern void union_removed_upper __P((struct union_node *un)); extern struct vnode *union_lowervp __P((struct vnode *)); extern void union_newsize __P((struct vnode *, off_t, off_t)); -extern int (*union_dircheckp) __P((struct proc *, struct vnode **, +extern int (*union_dircheckp) __P((struct thread *, struct vnode **, struct file *)); #define MOUNTTOUNIONMOUNT(mp) ((struct union_mount *)((mp)->mnt_data)) diff --git a/sys/fs/unionfs/union_subr.c b/sys/fs/unionfs/union_subr.c index 52a5483..5919672 100644 --- a/sys/fs/unionfs/union_subr.c +++ b/sys/fs/unionfs/union_subr.c @@ -89,11 +89,11 @@ static void union_updatevp __P((struct union_node *un, static void union_newlower __P((struct union_node *, struct vnode *)); static void union_newupper __P((struct union_node *, struct vnode *)); static int union_copyfile __P((struct vnode *, struct vnode *, - struct ucred *, struct proc *)); + struct ucred *, struct thread *)); static int union_vn_create __P((struct vnode **, struct union_node *, - struct proc *)); + struct thread *)); static int union_vn_close __P((struct vnode *, int, struct ucred *, - struct proc *)); + struct thread *)); int union_init() @@ -351,7 +351,7 @@ union_allocvp(vpp, mp, dvp, upperdvp, cnp, uppervp, lowervp, docache) int error; struct union_node *un = 0; struct union_mount *um = MOUNTTOUNIONMOUNT(mp); - struct proc *p = (cnp) ? cnp->cn_proc : curproc; + struct thread *td = (cnp) ? cnp->cn_thread : curthread; int hash = 0; int vflag; int try; @@ -410,7 +410,7 @@ loop: un->un_uppervp == NULLVP) && (UNIONTOV(un)->v_mount == mp)) { if (vget(UNIONTOV(un), 0, - cnp ? cnp->cn_proc : NULL)) { + cnp ? cnp->cn_thread : NULL)) { union_list_unlock(hash); goto loop; } @@ -450,21 +450,21 @@ loop: * while moving up the tree). */ VREF(dvp); - VOP_UNLOCK(dvp, 0, p); - error = vn_lock(un->un_vnode, LK_EXCLUSIVE, p); - vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_UNLOCK(dvp, 0, td); + error = vn_lock(un->un_vnode, LK_EXCLUSIVE, td); + vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td); vrele(dvp); } else { /* * our new un is under dvp */ - error = vn_lock(un->un_vnode, LK_EXCLUSIVE, p); + error = vn_lock(un->un_vnode, LK_EXCLUSIVE, td); } } else if (dvp == NULLVP) { /* * dvp is NULL, we need to lock un. */ - error = vn_lock(un->un_vnode, LK_EXCLUSIVE, p); + error = vn_lock(un->un_vnode, LK_EXCLUSIVE, td); } else { /* * dvp == un->un_vnode, we are already locked. @@ -573,7 +573,7 @@ loop: bzero(un, sizeof(*un)); lockinit(&un->un_lock, PVFS, "unlock", 0, 0); - vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, td); un->un_vnode = *vpp; un->un_uppervp = uppervp; @@ -656,11 +656,11 @@ union_freevp(vp) * haven't been bumped at all. */ static int -union_copyfile(fvp, tvp, cred, p) +union_copyfile(fvp, tvp, cred, td) struct vnode *fvp; struct vnode *tvp; struct ucred *cred; - struct proc *p; + struct thread *td; { char *buf; struct uio uio; @@ -677,12 +677,12 @@ union_copyfile(fvp, tvp, cred, p) bzero(&uio, sizeof(uio)); - uio.uio_procp = p; + uio.uio_td = td; uio.uio_segflg = UIO_SYSSPACE; uio.uio_offset = 0; - VOP_LEASE(fvp, p, cred, LEASE_READ); - VOP_LEASE(tvp, p, cred, LEASE_WRITE); + VOP_LEASE(fvp, td, cred, LEASE_READ); + VOP_LEASE(tvp, td, cred, LEASE_WRITE); buf = malloc(MAXBSIZE, M_TEMP, M_WAITOK); @@ -743,11 +743,11 @@ union_copyfile(fvp, tvp, cred, p) */ int -union_copyup(un, docopy, cred, p) +union_copyup(un, docopy, cred, td) struct union_node *un; int docopy; struct ucred *cred; - struct proc *p; + struct thread *td; { int error; struct mount *mp; @@ -757,15 +757,15 @@ union_copyup(un, docopy, cred, p) * If the user does not have read permission, the vnode should not * be copied to upper layer. */ - vn_lock(un->un_lowervp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_ACCESS(un->un_lowervp, VREAD, cred, p); - VOP_UNLOCK(un->un_lowervp, 0, p); + vn_lock(un->un_lowervp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_ACCESS(un->un_lowervp, VREAD, cred, td); + VOP_UNLOCK(un->un_lowervp, 0, td); if (error) return (error); if ((error = vn_start_write(un->un_dirvp, &mp, V_WAIT | PCATCH)) != 0) return (error); - if ((error = union_vn_create(&uvp, un, p)) != 0) { + if ((error = union_vn_create(&uvp, un, td)) != 0) { vn_finished_write(mp); return (error); } @@ -778,24 +778,24 @@ union_copyup(un, docopy, cred, p) * XX - should not ignore errors * from VOP_CLOSE */ - vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_OPEN(lvp, FREAD, cred, p); + vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(lvp, FREAD, cred, td); if (error == 0 && vn_canvmio(lvp) == TRUE) - error = vfs_object_create(lvp, p, cred); + error = vfs_object_create(lvp, td, cred); if (error == 0) { - error = union_copyfile(lvp, uvp, cred, p); - VOP_UNLOCK(lvp, 0, p); - (void) VOP_CLOSE(lvp, FREAD, cred, p); + error = union_copyfile(lvp, uvp, cred, td); + VOP_UNLOCK(lvp, 0, td); + (void) VOP_CLOSE(lvp, FREAD, cred, td); } if (error == 0) UDEBUG(("union: copied up %s\n", un->un_path)); } - VOP_UNLOCK(uvp, 0, p); + VOP_UNLOCK(uvp, 0, td); vn_finished_write(mp); union_newupper(un, uvp); KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount)); - union_vn_close(uvp, FWRITE, cred, p); + union_vn_close(uvp, FWRITE, cred, td); KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount)); /* * Subsequent IOs will go to the top layer, so @@ -809,12 +809,12 @@ union_copyup(un, docopy, cred, p) int i; for (i = 0; i < un->un_openl; i++) { - (void) VOP_CLOSE(lvp, FREAD, cred, p); - (void) VOP_OPEN(uvp, FREAD, cred, p); + (void) VOP_CLOSE(lvp, FREAD, cred, td); + (void) VOP_OPEN(uvp, FREAD, cred, td); } if (un->un_openl) { if (vn_canvmio(uvp) == TRUE) - error = vfs_object_create(uvp, p, cred); + error = vfs_object_create(uvp, td, cred); } un->un_openl = 0; } @@ -862,7 +862,7 @@ union_relookup(um, dvp, vpp, cnp, cn, path, pathlen) cn->cn_nameiop = CREATE; cn->cn_flags = (LOCKPARENT|LOCKLEAF|HASBUF|SAVENAME|ISLASTCN); - cn->cn_proc = cnp->cn_proc; + cn->cn_thread = cnp->cn_thread; if (um->um_op == UNMNT_ABOVE) cn->cn_cred = cnp->cn_cred; else @@ -871,7 +871,7 @@ union_relookup(um, dvp, vpp, cnp, cn, path, pathlen) cn->cn_consume = cnp->cn_consume; VREF(dvp); - VOP_UNLOCK(dvp, 0, cnp->cn_proc); + VOP_UNLOCK(dvp, 0, cnp->cn_thread); /* * Pass dvp unlocked and referenced on call to relookup(). @@ -880,7 +880,7 @@ union_relookup(um, dvp, vpp, cnp, cn, path, pathlen) */ if ((error = relookup(dvp, vpp, cn)) != 0) { - vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_proc); + vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_thread); return(error); } @@ -916,7 +916,7 @@ union_mkshadow(um, dvp, cnp, vpp) { int error; struct vattr va; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct componentname cn; struct mount *mp; @@ -955,7 +955,7 @@ union_mkshadow(um, dvp, cnp, vpp) va.va_mode = um->um_cmode; /* VOP_LEASE: dvp is locked */ - VOP_LEASE(dvp, p, cn.cn_cred, LEASE_WRITE); + VOP_LEASE(dvp, td, cn.cn_cred, LEASE_WRITE); error = VOP_MKDIR(dvp, vpp, &cn, &va); if (cn.cn_flags & HASBUF) { @@ -984,7 +984,7 @@ union_mkwhiteout(um, dvp, cnp, path) char *path; { int error; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct vnode *wvp; struct componentname cn; struct mount *mp; @@ -1011,7 +1011,7 @@ union_mkwhiteout(um, dvp, cnp, path) } /* VOP_LEASE: dvp is locked */ - VOP_LEASE(dvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_WHITEOUT(dvp, &cn, CREATE); if (cn.cn_flags & HASBUF) { @@ -1037,18 +1037,18 @@ union_mkwhiteout(um, dvp, cnp, path) * use. If an error occurs *vpp iis undefined. */ static int -union_vn_create(vpp, un, p) +union_vn_create(vpp, un, td) struct vnode **vpp; struct union_node *un; - struct proc *p; + struct thread *td; { struct vnode *vp; - struct ucred *cred = p->p_ucred; + struct ucred *cred = td->td_proc->p_ucred; struct vattr vat; struct vattr *vap = &vat; int fmode = FFLAGS(O_WRONLY|O_CREAT|O_TRUNC|O_EXCL); int error; - int cmode = UN_FILEMODE & ~p->p_fd->fd_cmask; + int cmode = UN_FILEMODE & ~td->td_proc->p_fd->fd_cmask; struct componentname cn; *vpp = NULLVP; @@ -1067,8 +1067,8 @@ union_vn_create(vpp, un, p) bcopy(un->un_path, cn.cn_pnbuf, cn.cn_namelen+1); cn.cn_nameiop = CREATE; cn.cn_flags = (LOCKPARENT|LOCKLEAF|HASBUF|SAVENAME|ISLASTCN); - cn.cn_proc = p; - cn.cn_cred = p->p_ucred; + cn.cn_thread = td; + cn.cn_cred = td->td_proc->p_ucred; cn.cn_nameptr = cn.cn_pnbuf; cn.cn_consume = 0; @@ -1112,7 +1112,7 @@ union_vn_create(vpp, un, p) VATTR_NULL(vap); vap->va_type = VREG; vap->va_mode = cmode; - VOP_LEASE(un->un_dirvp, p, cred, LEASE_WRITE); + VOP_LEASE(un->un_dirvp, td, cred, LEASE_WRITE); error = VOP_CREATE(un->un_dirvp, &vp, &cn, vap); if (cn.cn_flags & HASBUF) { zfree(namei_zone, cn.cn_pnbuf); @@ -1122,9 +1122,9 @@ union_vn_create(vpp, un, p) if (error) return (error); - error = VOP_OPEN(vp, fmode, cred, p); + error = VOP_OPEN(vp, fmode, cred, td); if (error == 0 && vn_canvmio(vp) == TRUE) - error = vfs_object_create(vp, p, cred); + error = vfs_object_create(vp, td, cred); if (error) { vput(vp); return (error); @@ -1135,16 +1135,16 @@ union_vn_create(vpp, un, p) } static int -union_vn_close(vp, fmode, cred, p) +union_vn_close(vp, fmode, cred, td) struct vnode *vp; int fmode; struct ucred *cred; - struct proc *p; + struct thread *td; { if (fmode & FWRITE) --vp->v_writecount; - return (VOP_CLOSE(vp, fmode, cred, p)); + return (VOP_CLOSE(vp, fmode, cred, td)); } #if 0 @@ -1159,7 +1159,7 @@ void union_removed_upper(un) struct union_node *un; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct vnode **vpp; /* @@ -1188,17 +1188,17 @@ union_removed_upper(un) * during a remove/rmdir operation. */ int -union_dowhiteout(un, cred, p) +union_dowhiteout(un, cred, td) struct union_node *un; struct ucred *cred; - struct proc *p; + struct thread *td; { struct vattr va; if (un->un_lowervp != NULLVP) return (1); - if (VOP_GETATTR(un->un_uppervp, &va, cred, p) == 0 && + if (VOP_GETATTR(un->un_uppervp, &va, cred, td) == 0 && (va.va_flags & OPAQUE)) return (1); @@ -1234,9 +1234,9 @@ union_dircache_r(vp, vppp, cntp) } struct vnode * -union_dircache(vp, p) +union_dircache(vp, td) struct vnode *vp; - struct proc *p; + struct thread *td; { int cnt; struct vnode *nvp; @@ -1245,7 +1245,7 @@ union_dircache(vp, p) struct union_node *un; int error; - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); dircache = VTOUNION(vp)->un_dircache; nvp = NULLVP; @@ -1271,7 +1271,7 @@ union_dircache(vp, p) if (*vpp == NULLVP) goto out; - /*vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, p);*/ + /*vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, td);*/ UDEBUG(("ALLOCVP-3 %p ref %d\n", *vpp, (*vpp ? (*vpp)->v_usecount : -99))); VREF(*vpp); error = union_allocvp(&nvp, vp->v_mount, NULLVP, NULLVP, NULL, *vpp, NULLVP, 0); @@ -1284,7 +1284,7 @@ union_dircache(vp, p) un->un_dircache = dircache; out: - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); return (nvp); } @@ -1292,14 +1292,14 @@ out: * Module glue to remove #ifdef UNION from vfs_syscalls.c */ static int -union_dircheck(struct proc *p, struct vnode **vp, struct file *fp) +union_dircheck(struct thread *td, struct vnode **vp, struct file *fp) { int error = 0; if ((*vp)->v_op == union_vnodeop_p) { struct vnode *lvp; - lvp = union_dircache(*vp, p); + lvp = union_dircache(*vp, td); if (lvp != NULLVP) { struct vattr va; @@ -1307,7 +1307,7 @@ union_dircheck(struct proc *p, struct vnode **vp, struct file *fp) * If the directory is opaque, * then don't show lower entries */ - error = VOP_GETATTR(*vp, &va, fp->f_cred, p); + error = VOP_GETATTR(*vp, &va, fp->f_cred, td); if (va.va_flags & OPAQUE) { vput(lvp); lvp = NULL; @@ -1315,17 +1315,17 @@ union_dircheck(struct proc *p, struct vnode **vp, struct file *fp) } if (lvp != NULLVP) { - error = VOP_OPEN(lvp, FREAD, fp->f_cred, p); + error = VOP_OPEN(lvp, FREAD, fp->f_cred, td); if (error == 0 && vn_canvmio(lvp) == TRUE) - error = vfs_object_create(lvp, p, fp->f_cred); + error = vfs_object_create(lvp, td, fp->f_cred); if (error) { vput(lvp); return (error); } - VOP_UNLOCK(lvp, 0, p); + VOP_UNLOCK(lvp, 0, td); fp->f_data = (caddr_t) lvp; fp->f_offset = 0; - error = vn_close(*vp, FREAD, fp->f_cred, p); + error = vn_close(*vp, FREAD, fp->f_cred, td); if (error) return (error); *vp = lvp; diff --git a/sys/fs/unionfs/union_vfsops.c b/sys/fs/unionfs/union_vfsops.c index aa4986c..7f616cb 100644 --- a/sys/fs/unionfs/union_vfsops.c +++ b/sys/fs/unionfs/union_vfsops.c @@ -59,23 +59,23 @@ static MALLOC_DEFINE(M_UNIONFSMNT, "UNION mount", "UNION mount structure"); extern int union_init __P((struct vfsconf *)); static int union_mount __P((struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p)); + struct nameidata *ndp, struct thread *td)); static int union_root __P((struct mount *mp, struct vnode **vpp)); static int union_statfs __P((struct mount *mp, struct statfs *sbp, - struct proc *p)); + struct thread *td)); static int union_unmount __P((struct mount *mp, int mntflags, - struct proc *p)); + struct thread *td)); /* * Mount union filesystem */ static int -union_mount(mp, path, data, ndp, p) +union_mount(mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { int error = 0; struct union_args args; @@ -127,7 +127,7 @@ union_mount(mp, path, data, ndp, p) * Unlock lower node to avoid deadlock. */ if (lowerrootvp->v_op == union_vnodeop_p) - VOP_UNLOCK(lowerrootvp, 0, p); + VOP_UNLOCK(lowerrootvp, 0, td); #endif /* @@ -135,13 +135,13 @@ union_mount(mp, path, data, ndp, p) * upperrootvp will be turned referenced but not locked. */ NDINIT(ndp, LOOKUP, FOLLOW|WANTPARENT, - UIO_USERSPACE, args.target, p); + UIO_USERSPACE, args.target, td); error = namei(ndp); #if 0 if (lowerrootvp->v_op == union_vnodeop_p) - vn_lock(lowerrootvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(lowerrootvp, LK_EXCLUSIVE | LK_RETRY, td); #endif if (error) goto bad; @@ -223,9 +223,9 @@ union_mount(mp, path, data, ndp, p) goto bad; } - um->um_cred = p->p_ucred; + um->um_cred = td->td_proc->p_ucred; crhold(um->um_cred); - um->um_cmode = UN_DIRMODE &~ p->p_fd->fd_cmask; + um->um_cmode = UN_DIRMODE &~ td->td_proc->p_fd->fd_cmask; /* * Depending on what you think the MNT_LOCAL flag might mean, @@ -275,7 +275,7 @@ union_mount(mp, path, data, ndp, p) (void) copyinstr(args.target, cp, len - 1, &size); bzero(cp + size, len - size); - (void)union_statfs(mp, &mp->mnt_stat, p); + (void)union_statfs(mp, &mp->mnt_stat, td); UDEBUG(("union_mount: from %s, on %s\n", mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname)); @@ -303,10 +303,10 @@ bad: * Free reference to union layer */ static int -union_unmount(mp, mntflags, p) +union_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { struct union_mount *um = MOUNTTOUNIONMOUNT(mp); int error; @@ -396,10 +396,10 @@ union_root(mp, vpp) } static int -union_statfs(mp, sbp, p) +union_statfs(mp, sbp, td) struct mount *mp; struct statfs *sbp; - struct proc *p; + struct thread *td; { int error; struct union_mount *um = MOUNTTOUNIONMOUNT(mp); @@ -412,7 +412,7 @@ union_statfs(mp, sbp, p) bzero(&mstat, sizeof(mstat)); if (um->um_lowervp) { - error = VFS_STATFS(um->um_lowervp->v_mount, &mstat, p); + error = VFS_STATFS(um->um_lowervp->v_mount, &mstat, td); if (error) return (error); } @@ -431,7 +431,7 @@ union_statfs(mp, sbp, p) sbp->f_files = mstat.f_files; sbp->f_ffree = mstat.f_ffree; - error = VFS_STATFS(um->um_uppervp->v_mount, &mstat, p); + error = VFS_STATFS(um->um_uppervp->v_mount, &mstat, td); if (error) return (error); diff --git a/sys/fs/unionfs/union_vnops.c b/sys/fs/unionfs/union_vnops.c index b5abfa7..aca606b 100644 --- a/sys/fs/unionfs/union_vnops.c +++ b/sys/fs/unionfs/union_vnops.c @@ -109,13 +109,13 @@ static int union_write __P((struct vop_read_args *ap)); static __inline struct vnode * -union_lock_upper(struct union_node *un, struct proc *p) +union_lock_upper(struct union_node *un, struct thread *td) { struct vnode *uppervp; if ((uppervp = un->un_uppervp) != NULL) { VREF(uppervp); - vn_lock(uppervp, LK_EXCLUSIVE | LK_CANRECURSE | LK_RETRY, p); + vn_lock(uppervp, LK_EXCLUSIVE | LK_CANRECURSE | LK_RETRY, td); } KASSERT((uppervp == NULL || uppervp->v_usecount > 0), ("uppervp usecount is 0")); return(uppervp); @@ -123,29 +123,29 @@ union_lock_upper(struct union_node *un, struct proc *p) static __inline void -union_unlock_upper(struct vnode *uppervp, struct proc *p) +union_unlock_upper(struct vnode *uppervp, struct thread *td) { vput(uppervp); } static __inline struct vnode * -union_lock_other(struct union_node *un, struct proc *p) +union_lock_other(struct union_node *un, struct thread *td) { struct vnode *vp; if (un->un_uppervp != NULL) { - vp = union_lock_upper(un, p); + vp = union_lock_upper(un, td); } else if ((vp = un->un_lowervp) != NULL) { VREF(vp); - vn_lock(vp, LK_EXCLUSIVE | LK_CANRECURSE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_CANRECURSE | LK_RETRY, td); } return(vp); } static __inline void -union_unlock_other(struct vnode *vp, struct proc *p) +union_unlock_other(struct vnode *vp, struct thread *td) { vput(vp); } @@ -178,7 +178,7 @@ union_lookup1(udvp, pdvp, vpp, cnp) struct componentname *cnp; { int error; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct vnode *dvp = *pdvp; struct vnode *tdvp; struct mount *mp; @@ -201,7 +201,7 @@ union_lookup1(udvp, pdvp, vpp, cnp) dvp = dvp->v_mount->mnt_vnodecovered; VREF(dvp); vput(tdvp); - vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td); } } @@ -232,7 +232,7 @@ union_lookup1(udvp, pdvp, vpp, cnp) UDEBUG(("parentdir %p result %p flag %lx\n", dvp, tdvp, cnp->cn_flags)); if (dvp != tdvp && (cnp->cn_flags & ISLASTCN) == 0) - vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td); /* * Lastly check if the current node is a mount point in @@ -252,7 +252,7 @@ union_lookup1(udvp, pdvp, vpp, cnp) ) { int relock_pdvp = 0; - if (vfs_busy(mp, 0, 0, p)) + if (vfs_busy(mp, 0, 0, td)) continue; if (dvp == *pdvp) @@ -261,10 +261,10 @@ union_lookup1(udvp, pdvp, vpp, cnp) dvp = NULL; error = VFS_ROOT(mp, &dvp); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); if (relock_pdvp) - vn_lock(*pdvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(*pdvp, LK_EXCLUSIVE | LK_RETRY, td); if (error) { *vpp = NULL; @@ -291,7 +291,7 @@ union_lookup(ap) struct vnode *dvp = ap->a_dvp; /* starting dir */ struct union_node *dun = VTOUNION(dvp); /* associated union node */ struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; int lockparent = cnp->cn_flags & LOCKPARENT; struct union_mount *um = MOUNTTOUNIONMOUNT(dvp->v_mount); struct ucred *saved_cred = NULL; @@ -329,7 +329,7 @@ union_lookup(ap) * We must lock upperdvp while holding our lock on dvp * to avoid a deadlock. */ - upperdvp = union_lock_upper(dun, p); + upperdvp = union_lock_upper(dun, td); /* * do the lookup in the upper level. @@ -403,7 +403,7 @@ union_lookup(ap) int terror; terror = VOP_GETATTR(upperdvp, &va, - cnp->cn_cred, cnp->cn_proc); + cnp->cn_cred, cnp->cn_thread); if (terror == 0 && (va.va_flags & OPAQUE)) iswhiteout = 1; } @@ -446,7 +446,7 @@ union_lookup(ap) * to us so we NULL it out. */ VREF(lowerdvp); - vn_lock(lowerdvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(lowerdvp, LK_EXCLUSIVE | LK_RETRY, td); lerror = union_lookup1(um->um_lowervp, &lowerdvp, &lowervp, cnp); if (lowerdvp == lowervp) vrele(lowerdvp); @@ -470,7 +470,7 @@ union_lookup(ap) if ((cnp->cn_flags & ISDOTDOT) && dun->un_pvp != NULLVP) { if ((lowervp = LOWERVP(dun->un_pvp)) != NULL) { VREF(lowervp); - vn_lock(lowervp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(lowervp, LK_EXCLUSIVE | LK_RETRY, td); lerror = 0; } } @@ -533,11 +533,11 @@ union_lookup(ap) */ if (uppervp && uppervp != upperdvp) - VOP_UNLOCK(uppervp, 0, p); + VOP_UNLOCK(uppervp, 0, td); if (lowervp) - VOP_UNLOCK(lowervp, 0, p); + VOP_UNLOCK(lowervp, 0, td); if (upperdvp) - VOP_UNLOCK(upperdvp, 0, p); + VOP_UNLOCK(upperdvp, 0, td); error = union_allocvp(ap->a_vpp, dvp->v_mount, dvp, upperdvp, cnp, uppervp, lowervp, 1); @@ -600,7 +600,7 @@ out: if (*ap->a_vpp != dvp) { if ((error == 0 || error == EJUSTRETURN) && (!lockparent || (cnp->cn_flags & ISLASTCN) == 0)) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); } } @@ -637,24 +637,24 @@ union_create(ap) { struct union_node *dun = VTOUNION(ap->a_dvp); struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct vnode *dvp; int error = EROFS; - if ((dvp = union_lock_upper(dun, p)) != NULL) { + if ((dvp = union_lock_upper(dun, td)) != NULL) { struct vnode *vp; struct mount *mp; error = VOP_CREATE(dvp, &vp, cnp, ap->a_vap); if (error == 0) { mp = ap->a_dvp->v_mount; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); UDEBUG(("ALLOCVP-1 FROM %p REFS %d\n", vp, vp->v_usecount)); error = union_allocvp(ap->a_vpp, mp, NULLVP, NULLVP, cnp, vp, NULLVP, 1); UDEBUG(("ALLOCVP-2B FROM %p REFS %d\n", *ap->a_vpp, vp->v_usecount)); } - union_unlock_upper(dvp, p); + union_unlock_upper(dvp, td); } return (error); } @@ -672,9 +672,9 @@ union_whiteout(ap) struct vnode *uppervp; int error = EOPNOTSUPP; - if ((uppervp = union_lock_upper(un, cnp->cn_proc)) != NULLVP) { + if ((uppervp = union_lock_upper(un, cnp->cn_thread)) != NULLVP) { error = VOP_WHITEOUT(un->un_uppervp, cnp, ap->a_flags); - union_unlock_upper(uppervp, cnp->cn_proc); + union_unlock_upper(uppervp, cnp->cn_thread); } return(error); } @@ -700,9 +700,9 @@ union_mknod(ap) struct vnode *dvp; int error = EROFS; - if ((dvp = union_lock_upper(dun, cnp->cn_proc)) != NULL) { + if ((dvp = union_lock_upper(dun, cnp->cn_thread)) != NULL) { error = VOP_MKNOD(dvp, ap->a_vpp, cnp, ap->a_vap); - union_unlock_upper(dvp, cnp->cn_proc); + union_unlock_upper(dvp, cnp->cn_thread); } return (error); } @@ -723,14 +723,14 @@ union_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct union_node *un = VTOUNION(ap->a_vp); struct vnode *tvp; int mode = ap->a_mode; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; int error = 0; int tvpisupper = 1; @@ -742,7 +742,7 @@ union_open(ap) * * At the end of this section tvp will be left locked. */ - if ((tvp = union_lock_upper(un, p)) == NULLVP) { + if ((tvp = union_lock_upper(un, td)) == NULLVP) { /* * If the lower vnode is being opened for writing, then * copy the file contents to the upper vnode and open that, @@ -751,12 +751,12 @@ union_open(ap) tvp = un->un_lowervp; if ((ap->a_mode & FWRITE) && (tvp->v_type == VREG)) { int docopy = !(mode & O_TRUNC); - error = union_copyup(un, docopy, cred, p); - tvp = union_lock_upper(un, p); + error = union_copyup(un, docopy, cred, td); + tvp = union_lock_upper(un, td); } else { un->un_openl++; VREF(tvp); - vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, td); tvpisupper = 0; } } @@ -766,13 +766,13 @@ union_open(ap) */ if (error == 0) - error = VOP_OPEN(tvp, mode, cred, p); + error = VOP_OPEN(tvp, mode, cred, td); /* * Absolutely necessary or UFS will blowup */ if (error == 0 && vn_canvmio(tvp) == TRUE) { - error = vfs_object_create(tvp, p, cred); + error = vfs_object_create(tvp, td, cred); } /* @@ -780,7 +780,7 @@ union_open(ap) */ if (tvpisupper) { if (tvp) - union_unlock_upper(tvp, p); + union_unlock_upper(tvp, td); } else { vput(tvp); } @@ -800,7 +800,7 @@ union_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct union_node *un = VTOUNION(ap->a_vp); @@ -833,11 +833,11 @@ union_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct union_node *un = VTOUNION(ap->a_vp); - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; int error = EACCES; struct vnode *vp; @@ -856,15 +856,15 @@ union_access(ap) } } - if ((vp = union_lock_upper(un, p)) != NULLVP) { + if ((vp = union_lock_upper(un, td)) != NULLVP) { ap->a_vp = vp; error = VCALL(vp, VOFFSET(vop_access), ap); - union_unlock_upper(vp, p); + union_unlock_upper(vp, td); return(error); } if ((vp = un->un_lowervp) != NULLVP) { - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); ap->a_vp = vp; /* @@ -885,7 +885,7 @@ union_access(ap) error = VCALL(vp, VOFFSET(vop_access), ap); } } - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); } return(error); } @@ -912,7 +912,7 @@ union_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { int error; @@ -933,7 +933,7 @@ union_getattr(ap) vap = ap->a_vap; if ((vp = un->un_uppervp) != NULLVP) { - error = VOP_GETATTR(vp, vap, ap->a_cred, ap->a_p); + error = VOP_GETATTR(vp, vap, ap->a_cred, ap->a_td); if (error) return (error); /* XXX isn't this dangerouso without a lock? */ @@ -950,7 +950,7 @@ union_getattr(ap) } if (vp != NULLVP) { - error = VOP_GETATTR(vp, vap, ap->a_cred, ap->a_p); + error = VOP_GETATTR(vp, vap, ap->a_cred, ap->a_td); if (error) return (error); /* XXX isn't this dangerous without a lock? */ @@ -968,11 +968,11 @@ union_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct union_node *un = VTOUNION(ap->a_vp); - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; struct vattr *vap = ap->a_vap; struct vnode *uppervp; int error; @@ -995,7 +995,7 @@ union_setattr(ap) */ if (un->un_uppervp == NULLVP && (un->un_lowervp->v_type == VREG)) { error = union_copyup(un, (ap->a_vap->va_size != 0), - ap->a_cred, ap->a_p); + ap->a_cred, ap->a_td); if (error) return (error); } @@ -1005,12 +1005,12 @@ union_setattr(ap) * otherwise return read-only filesystem error. */ error = EROFS; - if ((uppervp = union_lock_upper(un, p)) != NULLVP) { + if ((uppervp = union_lock_upper(un, td)) != NULLVP) { error = VOP_SETATTR(un->un_uppervp, ap->a_vap, - ap->a_cred, ap->a_p); + ap->a_cred, ap->a_td); if ((error == 0) && (ap->a_vap->va_size != VNOVAL)) union_newsize(ap->a_vp, ap->a_vap->va_size, VNOVAL); - union_unlock_upper(uppervp, p); + union_unlock_upper(uppervp, td); } return (error); } @@ -1025,15 +1025,15 @@ union_read(ap) } */ *ap; { struct union_node *un = VTOUNION(ap->a_vp); - struct proc *p = ap->a_uio->uio_procp; + struct thread *td = ap->a_uio->uio_td; struct vnode *uvp; int error; - uvp = union_lock_other(un, p); + uvp = union_lock_other(un, td); KASSERT(uvp != NULL, ("union_read: backing vnode missing!")); error = VOP_READ(uvp, ap->a_uio, ap->a_ioflag, ap->a_cred); - union_unlock_other(uvp, p); + union_unlock_other(uvp, td); /* * XXX @@ -1066,11 +1066,11 @@ union_write(ap) } */ *ap; { struct union_node *un = VTOUNION(ap->a_vp); - struct proc *p = ap->a_uio->uio_procp; + struct thread *td = ap->a_uio->uio_td; struct vnode *uppervp; int error; - if ((uppervp = union_lock_upper(un, p)) == NULLVP) + if ((uppervp = union_lock_upper(un, td)) == NULLVP) panic("union: missing upper layer in write"); error = VOP_WRITE(uppervp, ap->a_uio, ap->a_ioflag, ap->a_cred); @@ -1085,7 +1085,7 @@ union_write(ap) if (cur > un->un_uppersz) union_newsize(ap->a_vp, cur, VNOVAL); } - union_unlock_upper(uppervp, p); + union_unlock_upper(uppervp, td); return (error); } @@ -1093,7 +1093,7 @@ static int union_lease(ap) struct vop_lease_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; struct ucred *a_cred; int a_flag; } */ *ap; @@ -1112,7 +1112,7 @@ union_ioctl(ap) caddr_t a_data; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *ovp = OTHERVP(ap->a_vp); @@ -1127,7 +1127,7 @@ union_poll(ap) struct vnode *a_vp; int a_events; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *ovp = OTHERVP(ap->a_vp); @@ -1141,7 +1141,7 @@ union_revoke(ap) struct vop_revoke_args /* { struct vnode *a_vp; int a_flags; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -1160,17 +1160,17 @@ union_fsync(ap) struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; - struct proc *a_p; + struct thread *a_td; } */ *ap; { int error = 0; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; struct vnode *targetvp; struct union_node *un = VTOUNION(ap->a_vp); - if ((targetvp = union_lock_other(un, p)) != NULLVP) { - error = VOP_FSYNC(targetvp, ap->a_cred, ap->a_waitfor, p); - union_unlock_other(targetvp, p); + if ((targetvp = union_lock_other(un, td)) != NULLVP) { + error = VOP_FSYNC(targetvp, ap->a_cred, ap->a_waitfor, td); + union_unlock_other(targetvp, td); } return (error); @@ -1194,16 +1194,16 @@ union_remove(ap) struct union_node *dun = VTOUNION(ap->a_dvp); struct union_node *un = VTOUNION(ap->a_vp); struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct vnode *uppervp; struct vnode *upperdvp; int error; - if ((upperdvp = union_lock_upper(dun, p)) == NULLVP) + if ((upperdvp = union_lock_upper(dun, td)) == NULLVP) panic("union remove: null upper vnode"); - if ((uppervp = union_lock_upper(un, p)) != NULLVP) { - if (union_dowhiteout(un, cnp->cn_cred, p)) + if ((uppervp = union_lock_upper(un, td)) != NULLVP) { + if (union_dowhiteout(un, cnp->cn_cred, td)) cnp->cn_flags |= DOWHITEOUT; error = VOP_REMOVE(upperdvp, uppervp, cnp); #if 0 @@ -1211,13 +1211,13 @@ union_remove(ap) if (!error) union_removed_upper(un); #endif - union_unlock_upper(uppervp, p); + union_unlock_upper(uppervp, td); } else { error = union_mkwhiteout( MOUNTTOUNIONMOUNT(ap->a_dvp->v_mount), upperdvp, ap->a_cnp, un->un_path); } - union_unlock_upper(upperdvp, p); + union_unlock_upper(upperdvp, td); return (error); } @@ -1238,7 +1238,7 @@ union_link(ap) } */ *ap; { struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct union_node *dun = VTOUNION(ap->a_tdvp); struct vnode *vp; struct vnode *tdvp; @@ -1250,24 +1250,24 @@ union_link(ap) struct union_node *tun = VTOUNION(ap->a_vp); if (tun->un_uppervp == NULLVP) { - vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, td); #if 0 if (dun->un_uppervp == tun->un_dirvp) { if (dun->un_flags & UN_ULOCK) { dun->un_flags &= ~UN_ULOCK; - VOP_UNLOCK(dun->un_uppervp, 0, p); + VOP_UNLOCK(dun->un_uppervp, 0, td); } } #endif - error = union_copyup(tun, 1, cnp->cn_cred, p); + error = union_copyup(tun, 1, cnp->cn_cred, td); #if 0 if (dun->un_uppervp == tun->un_dirvp) { vn_lock(dun->un_uppervp, - LK_EXCLUSIVE | LK_RETRY, p); + LK_EXCLUSIVE | LK_RETRY, td); dun->un_flags |= UN_ULOCK; } #endif - VOP_UNLOCK(ap->a_vp, 0, p); + VOP_UNLOCK(ap->a_vp, 0, td); } vp = tun->un_uppervp; } @@ -1282,18 +1282,18 @@ union_link(ap) * is expected to be locked on return. */ - if ((tdvp = union_lock_upper(dun, p)) == NULLVP) + if ((tdvp = union_lock_upper(dun, td)) == NULLVP) return (EROFS); - VOP_UNLOCK(ap->a_tdvp, 0, p); /* unlock calling node */ + VOP_UNLOCK(ap->a_tdvp, 0, td); /* unlock calling node */ error = VOP_LINK(tdvp, vp, cnp); /* call link on upper */ /* * We have to unlock tdvp prior to relocking our calling node in * order to avoid a deadlock. */ - union_unlock_upper(tdvp, p); - vn_lock(ap->a_tdvp, LK_EXCLUSIVE | LK_RETRY, p); + union_unlock_upper(tdvp, td); + vn_lock(ap->a_tdvp, LK_EXCLUSIVE | LK_RETRY, td); return (error); } @@ -1350,9 +1350,9 @@ union_rename(ap) if (un->un_uppervp == NULLVP) { switch(fvp->v_type) { case VREG: - vn_lock(un->un_vnode, LK_EXCLUSIVE | LK_RETRY, ap->a_fcnp->cn_proc); - error = union_copyup(un, 1, ap->a_fcnp->cn_cred, ap->a_fcnp->cn_proc); - VOP_UNLOCK(un->un_vnode, 0, ap->a_fcnp->cn_proc); + vn_lock(un->un_vnode, LK_EXCLUSIVE | LK_RETRY, ap->a_fcnp->cn_thread); + error = union_copyup(un, 1, ap->a_fcnp->cn_cred, ap->a_fcnp->cn_thread); + VOP_UNLOCK(un->un_vnode, 0, ap->a_fcnp->cn_thread); if (error) goto bad; break; @@ -1368,12 +1368,12 @@ union_rename(ap) #if 0 vrele(fvp); fvp = NULL; - vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY, ap->a_fcnp->cn_proc); + vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY, ap->a_fcnp->cn_thread); error = union_mkshadow(um, fdvp, ap->a_fcnp, &un->un_uppervp); - VOP_UNLOCK(fdvp, 0, ap->a_fcnp->cn_proc); + VOP_UNLOCK(fdvp, 0, ap->a_fcnp->cn_thread); if (un->un_uppervp) - VOP_UNLOCK(un->un_uppervp, 0, ap->a_fcnp->cn_proc); + VOP_UNLOCK(un->un_uppervp, 0, ap->a_fcnp->cn_thread); if (error) goto bad; break; @@ -1417,7 +1417,7 @@ union_rename(ap) * new tdvp is a lock and reference on uppervp, put away * the old tdvp. */ - tdvp = union_lock_upper(un, ap->a_tcnp->cn_proc); + tdvp = union_lock_upper(un, ap->a_tcnp->cn_thread); vput(ap->a_tdvp); } @@ -1432,7 +1432,7 @@ union_rename(ap) if (tvp != NULLVP && tvp->v_op == union_vnodeop_p) { struct union_node *un = VTOUNION(tvp); - tvp = union_lock_upper(un, ap->a_tcnp->cn_proc); + tvp = union_lock_upper(un, ap->a_tcnp->cn_thread); vput(ap->a_tvp); /* note: tvp may be NULL */ } @@ -1473,18 +1473,18 @@ union_mkdir(ap) { struct union_node *dun = VTOUNION(ap->a_dvp); struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct vnode *upperdvp; int error = EROFS; - if ((upperdvp = union_lock_upper(dun, p)) != NULLVP) { + if ((upperdvp = union_lock_upper(dun, td)) != NULLVP) { struct vnode *vp; error = VOP_MKDIR(upperdvp, &vp, cnp, ap->a_vap); - union_unlock_upper(upperdvp, p); + union_unlock_upper(upperdvp, td); if (error == 0) { - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); UDEBUG(("ALLOCVP-2 FROM %p REFS %d\n", vp, vp->v_usecount)); error = union_allocvp(ap->a_vpp, ap->a_dvp->v_mount, ap->a_dvp, NULLVP, cnp, vp, NULLVP, 1); @@ -1505,25 +1505,25 @@ union_rmdir(ap) struct union_node *dun = VTOUNION(ap->a_dvp); struct union_node *un = VTOUNION(ap->a_vp); struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct vnode *upperdvp; struct vnode *uppervp; int error; - if ((upperdvp = union_lock_upper(dun, p)) == NULLVP) + if ((upperdvp = union_lock_upper(dun, td)) == NULLVP) panic("union rmdir: null upper vnode"); - if ((uppervp = union_lock_upper(un, p)) != NULLVP) { - if (union_dowhiteout(un, cnp->cn_cred, p)) + if ((uppervp = union_lock_upper(un, td)) != NULLVP) { + if (union_dowhiteout(un, cnp->cn_cred, td)) cnp->cn_flags |= DOWHITEOUT; error = VOP_RMDIR(upperdvp, uppervp, ap->a_cnp); - union_unlock_upper(uppervp, p); + union_unlock_upper(uppervp, td); } else { error = union_mkwhiteout( MOUNTTOUNIONMOUNT(ap->a_dvp->v_mount), dun->un_uppervp, ap->a_cnp, un->un_path); } - union_unlock_upper(upperdvp, p); + union_unlock_upper(upperdvp, td); return (error); } @@ -1546,14 +1546,14 @@ union_symlink(ap) { struct union_node *dun = VTOUNION(ap->a_dvp); struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct vnode *dvp; int error = EROFS; - if ((dvp = union_lock_upper(dun, p)) != NULLVP) { + if ((dvp = union_lock_upper(dun, td)) != NULLVP) { error = VOP_SYMLINK(dvp, ap->a_vpp, cnp, ap->a_vap, ap->a_target); - union_unlock_upper(dvp, p); + union_unlock_upper(dvp, td); } return (error); } @@ -1577,14 +1577,14 @@ union_readdir(ap) } */ *ap; { struct union_node *un = VTOUNION(ap->a_vp); - struct proc *p = ap->a_uio->uio_procp; + struct thread *td = ap->a_uio->uio_td; struct vnode *uvp; int error = 0; - if ((uvp = union_lock_upper(un, p)) != NULLVP) { + if ((uvp = union_lock_upper(un, td)) != NULLVP) { ap->a_vp = uvp; error = VCALL(uvp, VOFFSET(vop_readdir), ap); - union_unlock_upper(uvp, p); + union_unlock_upper(uvp, td); } return(error); } @@ -1600,15 +1600,15 @@ union_readlink(ap) int error; struct union_node *un = VTOUNION(ap->a_vp); struct uio *uio = ap->a_uio; - struct proc *p = uio->uio_procp; + struct thread *td = uio->uio_td; struct vnode *vp; - vp = union_lock_other(un, p); + vp = union_lock_other(un, td); KASSERT(vp != NULL, ("union_readlink: backing vnode missing!")); ap->a_vp = vp; error = VCALL(vp, VOFFSET(vop_readlink), ap); - union_unlock_other(vp, p); + union_unlock_other(vp, td); return (error); } @@ -1645,11 +1645,11 @@ static int union_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; struct union_node *un = VTOUNION(vp); struct vnode **vpp; @@ -1676,11 +1676,11 @@ union_inactive(ap) #if 0 if ((un->un_flags & UN_ULOCK) && un->un_uppervp) { un->un_flags &= ~UN_ULOCK; - VOP_UNLOCK(un->un_uppervp, 0, p); + VOP_UNLOCK(un->un_uppervp, 0, td); } #endif - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if ((un->un_flags & UN_CACHED) == 0) vgone(vp); @@ -1705,7 +1705,7 @@ union_lock(ap) { #if 0 struct vnode *vp = ap->a_vp; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; int flags = ap->a_flags; struct union_node *un; #endif @@ -1723,12 +1723,12 @@ union_lock(ap) if (un->un_uppervp != NULLVP && (flags & LK_TYPE_MASK) == LK_EXCLUSIVE) { if ((un->un_flags & UN_ULOCK) == 0 && vp->v_usecount) { - error = vn_lock(un->un_uppervp, flags, p); + error = vn_lock(un->un_uppervp, flags, td); if (error) { struct vop_unlock_args uap = { 0 }; uap.a_vp = ap->a_vp; uap.a_flags = ap->a_flags; - uap.a_p = ap->a_p; + uap.a_td = ap->a_td; vop_stdunlock(&uap); return (error); } @@ -1750,7 +1750,7 @@ union_unlock(ap) struct vop_unlock_args /* { struct vnode *a_vp; int a_flags; - struct proc *a_p; + struct thread *a_td; } */ *ap; { #if 0 @@ -1773,7 +1773,7 @@ union_unlock(ap) if ((un->un_flags & UN_ULOCK) && lockstatus(&un->un_lock, NULL) != LK_EXCLUSIVE) { un->un_flags &= ~UN_ULOCK; - VOP_UNLOCK(un->un_uppervp, LK_EXCLUSIVE, p); + VOP_UNLOCK(un->un_uppervp, LK_EXCLUSIVE, td); } #endif return(error); @@ -1788,7 +1788,7 @@ union_createvobject(ap) struct vop_createvobject_args /* { struct vnode *vp; struct ucred *cred; - struct proc *p; + struct thread *td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -1856,16 +1856,16 @@ union_pathconf(ap) } */ *ap; { int error; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct union_node *un = VTOUNION(ap->a_vp); struct vnode *vp; - vp = union_lock_other(un, p); + vp = union_lock_other(un, td); KASSERT(vp != NULL, ("union_pathconf: backing vnode missing!")); ap->a_vp = vp; error = VCALL(vp, VOFFSET(vop_pathconf), ap); - union_unlock_other(vp, p); + union_unlock_other(vp, td); return (error); } diff --git a/sys/geom/geom_ccd.c b/sys/geom/geom_ccd.c index 68df08e..090087b 100644 --- a/sys/geom/geom_ccd.c +++ b/sys/geom/geom_ccd.c @@ -202,8 +202,8 @@ static void ccdiodone(struct bio *bp); static void ccdstart(struct ccd_s *, struct bio *); static void ccdinterleave(struct ccd_s *, int); static void ccdintr(struct ccd_s *, struct bio *); -static int ccdinit(struct ccd_s *, char **, struct proc *); -static int ccdlookup(char *, struct proc *p, struct vnode **); +static int ccdinit(struct ccd_s *, char **, struct thread *); +static int ccdlookup(char *, struct thread *p, struct vnode **); static void ccdbuffer(struct ccdbuf **ret, struct ccd_s *, struct bio *, daddr_t, caddr_t, long); static void ccdgetdisklabel(dev_t); @@ -381,7 +381,7 @@ ccd_modevent(module_t mod, int type, void *data) DEV_MODULE(ccd, ccd_modevent, NULL); static int -ccdinit(struct ccd_s *cs, char **cpaths, struct proc *p) +ccdinit(struct ccd_s *cs, char **cpaths, struct thread *td) { struct ccdcinfo *ci = NULL; /* XXX */ size_t size; @@ -438,7 +438,7 @@ ccdinit(struct ccd_s *cs, char **cpaths, struct proc *p) * Get partition information for the component. */ if ((error = VOP_IOCTL(vp, DIOCGPART, (caddr_t)&dpart, - FREAD, p->p_ucred, p)) != 0) { + FREAD, td->td_proc->p_ucred, td)) != 0) { #ifdef DEBUG if (ccddebug & (CCDB_FOLLOW|CCDB_INIT)) printf("ccd%d: %s: ioctl failed, error = %d\n", @@ -701,7 +701,7 @@ ccdinterleave(struct ccd_s *cs, int unit) /* ARGSUSED */ static int -ccdopen(dev_t dev, int flags, int fmt, struct proc *p) +ccdopen(dev_t dev, int flags, int fmt, struct thread *td) { int unit = ccdunit(dev); struct ccd_s *cs; @@ -746,7 +746,7 @@ ccdopen(dev_t dev, int flags, int fmt, struct proc *p) /* ARGSUSED */ static int -ccdclose(dev_t dev, int flags, int fmt, struct proc *p) +ccdclose(dev_t dev, int flags, int fmt, struct thread *td) { int unit = ccdunit(dev); struct ccd_s *cs; @@ -770,7 +770,7 @@ ccdclose(dev_t dev, int flags, int fmt, struct proc *p) cs->sc_openmask &= ~(1 << part); /* collect "garbage" if possible */ if (!IS_INITED(cs) && (cs->sc_flags & CCDF_WANTED) == 0) - ccddestroy(cs, p); + ccddestroy(cs, td->td_proc); else ccdunlock(cs); return (0); @@ -1238,7 +1238,7 @@ ccdiodone(struct bio *ibp) } static int -ccdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +ccdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int unit = ccdunit(dev); int i, j, lookedup = 0, error = 0; @@ -1317,10 +1317,10 @@ ccdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) if (ccddebug & CCDB_INIT) printf("ccdioctl: lookedup = %d\n", lookedup); #endif - if ((error = ccdlookup(cpp[i], p, &vpp[i])) != 0) { + if ((error = ccdlookup(cpp[i], td, &vpp[i])) != 0) { for (j = 0; j < lookedup; ++j) (void)vn_close(vpp[j], FREAD|FWRITE, - p->p_ucred, p); + td->td_proc->p_ucred, td); free(vpp, M_DEVBUF); free(cpp, M_DEVBUF); ccdunlock(cs); @@ -1334,10 +1334,10 @@ ccdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) /* * Initialize the ccd. Fills in the softc for us. */ - if ((error = ccdinit(cs, cpp, p)) != 0) { + if ((error = ccdinit(cs, cpp, td)) != 0) { for (j = 0; j < lookedup; ++j) (void)vn_close(vpp[j], FREAD|FWRITE, - p->p_ucred, p); + td->td_proc->p_ucred, td); /* * We can't ccddestroy() cs just yet, because nothing * prevents user-level app to do another ioctl() @@ -1398,7 +1398,7 @@ ccdioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) cs->sc_cinfo[i].ci_vp); #endif (void)vn_close(cs->sc_cinfo[i].ci_vp, FREAD|FWRITE, - p->p_ucred, p); + td->td_proc->p_ucred, td); free(cs->sc_cinfo[i].ci_path, M_DEVBUF); } @@ -1557,7 +1557,7 @@ ccdsize(dev_t dev) struct ccd_s *cs; int part, size; - if (ccdopen(dev, 0, S_IFCHR, curproc)) + if (ccdopen(dev, 0, S_IFCHR, curthread)) return (-1); cs = ccdfind(ccdunit(dev)); @@ -1571,7 +1571,7 @@ ccdsize(dev_t dev) else size = cs->sc_label.d_partitions[part].p_size; - if (ccdclose(dev, 0, S_IFCHR, curproc)) + if (ccdclose(dev, 0, S_IFCHR, curthread)) return (-1); return (size); @@ -1591,13 +1591,13 @@ ccddump(dev_t dev) * set *vpp to the file's vnode. */ static int -ccdlookup(char *path, struct proc *p, struct vnode **vpp) +ccdlookup(char *path, struct thread *td, struct vnode **vpp) { struct nameidata nd; struct vnode *vp; int error, flags; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, path, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, path, td); flags = FREAD | FWRITE; if ((error = vn_open(&nd, &flags, 0)) != 0) { #ifdef DEBUG @@ -1621,15 +1621,15 @@ ccdlookup(char *path, struct proc *p, struct vnode **vpp) vprint("ccdlookup: vnode info", vp); #endif - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); NDFREE(&nd, NDF_ONLY_PNBUF); *vpp = vp; return (0); bad: - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); NDFREE(&nd, NDF_ONLY_PNBUF); /* vn_close does vrele() for vp */ - (void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p); + (void)vn_close(vp, FREAD|FWRITE, td->td_proc->p_ucred, td); return (error); } diff --git a/sys/gnu/ext2fs/ext2_extern.h b/sys/gnu/ext2fs/ext2_extern.h index b37b3ec..580683b 100644 --- a/sys/gnu/ext2fs/ext2_extern.h +++ b/sys/gnu/ext2fs/ext2_extern.h @@ -62,7 +62,7 @@ int ext2_init __P((struct vfsconf *)); int ext2_reallocblks __P((struct vop_reallocblks_args *)); int ext2_reclaim __P((struct vop_reclaim_args *)); void ext2_setblock __P((struct ext2_sb_info *, u_char *, daddr_t)); -int ext2_truncate __P((struct vnode *, off_t, int, struct ucred *, struct proc *)); +int ext2_truncate __P((struct vnode *, off_t, int, struct ucred *, struct thread *)); int ext2_update __P((struct vnode *, int)); int ext2_valloc __P((struct vnode *, int, struct ucred *, struct vnode **)); int ext2_vfree __P((struct vnode *, ino_t, int)); diff --git a/sys/gnu/ext2fs/ext2_ihash.c b/sys/gnu/ext2fs/ext2_ihash.c index 1fd39e9..d1537af 100644 --- a/sys/gnu/ext2fs/ext2_ihash.c +++ b/sys/gnu/ext2fs/ext2_ihash.c @@ -40,6 +40,7 @@ #include <sys/lock.h> #include <sys/vnode.h> #include <sys/malloc.h> +#include <sys/proc.h> #include <sys/mutex.h> #include <ufs/ufs/quota.h> @@ -97,7 +98,7 @@ ufs_ihashget(dev, inum) dev_t dev; ino_t inum; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct inode *ip; struct vnode *vp; @@ -108,7 +109,7 @@ loop: vp = ITOV(ip); mtx_lock(&vp->v_interlock); mtx_unlock(&ufs_ihash_mtx); - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) goto loop; return (vp); } @@ -124,11 +125,11 @@ void ufs_ihashins(ip) struct inode *ip; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct ihashhead *ipp; /* lock the inode, then put it on the appropriate hash list */ - lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, p); + lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, td); mtx_lock(&ufs_ihash_mtx); ipp = INOHASH(ip->i_dev, ip->i_number); diff --git a/sys/gnu/ext2fs/ext2_inode.c b/sys/gnu/ext2fs/ext2_inode.c index 5a60006..6a3e011 100644 --- a/sys/gnu/ext2fs/ext2_inode.c +++ b/sys/gnu/ext2fs/ext2_inode.c @@ -129,12 +129,12 @@ ext2_update(vp, waitfor) * disk blocks. */ int -ext2_truncate(vp, length, flags, cred, p) +ext2_truncate(vp, length, flags, cred, td) struct vnode *vp; off_t length; int flags; struct ucred *cred; - struct proc *p; + struct thread *td; { register struct vnode *ovp = vp; register daddr_t lastblock; @@ -268,7 +268,7 @@ printf("ext2_truncate called %d to %d\n", VTOI(ovp)->i_number, length); bcopy((caddr_t)&oip->i_db[0], (caddr_t)newblks, sizeof newblks); bcopy((caddr_t)oldblks, (caddr_t)&oip->i_db[0], sizeof oldblks); oip->i_size = osize; - error = vtruncbuf(ovp, cred, p, length, (int)fs->s_blocksize); + error = vtruncbuf(ovp, cred, td, length, (int)fs->s_blocksize); if (error && (allerror == 0)) allerror = error; diff --git a/sys/gnu/ext2fs/ext2_lookup.c b/sys/gnu/ext2fs/ext2_lookup.c index 4804ff1..b2e1511 100644 --- a/sys/gnu/ext2fs/ext2_lookup.c +++ b/sys/gnu/ext2fs/ext2_lookup.c @@ -322,7 +322,7 @@ ext2_lookup(ap) struct ucred *cred = cnp->cn_cred; int flags = cnp->cn_flags; int nameiop = cnp->cn_nameiop; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; int DIRBLKSIZ = VTOI(ap->a_dvp)->i_e2fs->s_blocksize; @@ -503,7 +503,7 @@ searchloop: * Access for write is interpreted as allowing * creation of files in the directory. */ - if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc)) != 0) + if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread)) != 0) return (error); /* * Return an indication of where the new directory @@ -541,7 +541,7 @@ searchloop: */ cnp->cn_flags |= SAVENAME; if (!lockparent) - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); return (EJUSTRETURN); } /* @@ -584,7 +584,7 @@ found: /* * Write access to directory required to delete files. */ - if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc)) != 0) + if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread)) != 0) return (error); /* * Return pointer to current entry in dp->i_offset, @@ -618,7 +618,7 @@ found: } *vpp = tdp; if (!lockparent) - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); return (0); } @@ -630,7 +630,7 @@ found: */ if (nameiop == RENAME && wantparent && (flags & ISLASTCN)) { - if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc)) != 0) + if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread)) != 0) return (error); /* * Careful about locking second inode. @@ -643,7 +643,7 @@ found: *vpp = tdp; cnp->cn_flags |= SAVENAME; if (!lockparent) - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); return (0); } @@ -668,13 +668,13 @@ found: */ pdp = vdp; if (flags & ISDOTDOT) { - VOP_UNLOCK(pdp, 0, p); /* race to get the inode */ + VOP_UNLOCK(pdp, 0, td); /* race to get the inode */ if ((error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) != 0) { - vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, td); return (error); } if (lockparent && (flags & ISLASTCN) && - (error = vn_lock(pdp, LK_EXCLUSIVE, p))) { + (error = vn_lock(pdp, LK_EXCLUSIVE, td))) { vput(tdp); return (error); } @@ -686,7 +686,7 @@ found: if ((error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) != 0) return (error); if (!lockparent || !(flags & ISLASTCN)) - VOP_UNLOCK(pdp, 0, p); + VOP_UNLOCK(pdp, 0, td); *vpp = tdp; } @@ -799,7 +799,7 @@ ext2_direnter(ip, dvp, cnp) auio.uio_iovcnt = 1; auio.uio_rw = UIO_WRITE; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = (struct proc *)0; + auio.uio_td = (struct thread *)0; error = VOP_WRITE(dvp, &auio, IO_SYNC, cnp->cn_cred); if (DIRBLKSIZ > VFSTOUFS(dvp->v_mount)->um_mountp->mnt_stat.f_bsize) @@ -880,7 +880,7 @@ ext2_direnter(ip, dvp, cnp) dp->i_flag |= IN_CHANGE | IN_UPDATE; if (!error && dp->i_endoff && dp->i_endoff < dp->i_size) error = UFS_TRUNCATE(dvp, (off_t)dp->i_endoff, IO_SYNC, - cnp->cn_cred, cnp->cn_proc); + cnp->cn_cred, cnp->cn_thread); return (error); } @@ -983,7 +983,7 @@ ext2_dirempty(ip, parentino, cred) for (off = 0; off < ip->i_size; off += dp->rec_len) { error = vn_rdwr(UIO_READ, ITOV(ip), (caddr_t)dp, MINDIRSIZ, off, - UIO_SYSSPACE, IO_NODELOCKED, cred, &count, (struct proc *)0); + UIO_SYSSPACE, IO_NODELOCKED, cred, &count, (struct thread *)0); /* * Since we read MINDIRSIZ, residual must * be 0 unless we're at end of file. @@ -1047,7 +1047,7 @@ ext2_checkpath(source, target, cred) } error = vn_rdwr(UIO_READ, vp, (caddr_t)&dirbuf, sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE, - IO_NODELOCKED, cred, (int *)0, (struct proc *)0); + IO_NODELOCKED, cred, (int *)0, (struct thread *)0); if (error != 0) break; namlen = dirbuf.dotdot_type; /* like ufs little-endian */ diff --git a/sys/gnu/ext2fs/ext2_mount.h b/sys/gnu/ext2fs/ext2_mount.h index 4c73aa3..85c9866 100644 --- a/sys/gnu/ext2fs/ext2_mount.h +++ b/sys/gnu/ext2fs/ext2_mount.h @@ -88,7 +88,7 @@ struct ufsmount { int um_i_effnlink_valid; /* i_effnlink valid? */ int (*um_balloc) __P((struct vnode *, off_t, int, struct ucred *, int, struct buf **)); int (*um_blkatoff) __P((struct vnode *, off_t, char **, struct buf **)); - int (*um_truncate) __P((struct vnode *, off_t, int, struct ucred *, struct proc *)); + int (*um_truncate) __P((struct vnode *, off_t, int, struct ucred *, struct thread *)); int (*um_update) __P((struct vnode *, int)); int (*um_valloc) __P((struct vnode *, int, struct ucred *, struct vnode **)); int (*um_vfree) __P((struct vnode *, ino_t, int)); diff --git a/sys/gnu/ext2fs/ext2_readwrite.c b/sys/gnu/ext2fs/ext2_readwrite.c index 62bc27a..2772f7b 100644 --- a/sys/gnu/ext2fs/ext2_readwrite.c +++ b/sys/gnu/ext2fs/ext2_readwrite.c @@ -172,7 +172,7 @@ WRITE(ap) register struct inode *ip; register FS *fs; struct buf *bp; - struct proc *p; + struct thread *td; daddr_t lbn; off_t osize; int seqcount; @@ -216,15 +216,15 @@ WRITE(ap) * Maybe this should be above the vnode op call, but so long as * file servers have no limits, I don't think it matters. */ - p = uio->uio_procp; + td = uio->uio_td; /* For p_rlimit. */ mtx_assert(&Giant, MA_OWNED); - if (vp->v_type == VREG && p && + if (vp->v_type == VREG && td && uio->uio_offset + uio->uio_resid > - p->p_rlimit[RLIMIT_FSIZE].rlim_cur) { - PROC_LOCK(p); - psignal(p, SIGXFSZ); - PROC_UNLOCK(p); + td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) { + PROC_LOCK(td->td_proc); + psignal(td->td_proc, SIGXFSZ); + PROC_UNLOCK(td->td_proc); return (EFBIG); } @@ -302,7 +302,7 @@ WRITE(ap) if (error) { if (ioflag & IO_UNIT) { (void)UFS_TRUNCATE(vp, osize, - ioflag & IO_SYNC, ap->a_cred, uio->uio_procp); + ioflag & IO_SYNC, ap->a_cred, uio->uio_td); uio->uio_offset -= resid - uio->uio_resid; uio->uio_resid = resid; } diff --git a/sys/gnu/ext2fs/ext2_vfsops.c b/sys/gnu/ext2fs/ext2_vfsops.c index 7263615..713a0cb 100644 --- a/sys/gnu/ext2fs/ext2_vfsops.c +++ b/sys/gnu/ext2fs/ext2_vfsops.c @@ -71,16 +71,16 @@ #include <gnu/ext2fs/ext2_fs_sb.h> static int ext2_fhtovp __P((struct mount *, struct fid *, struct vnode **)); -static int ext2_flushfiles __P((struct mount *mp, int flags, struct proc *p)); +static int ext2_flushfiles __P((struct mount *mp, int flags, struct thread *td)); static int ext2_mount __P((struct mount *, - char *, caddr_t, struct nameidata *, struct proc *)); -static int ext2_mountfs __P((struct vnode *, struct mount *, struct proc *)); + char *, caddr_t, struct nameidata *, struct thread *)); +static int ext2_mountfs __P((struct vnode *, struct mount *, struct thread *)); static int ext2_reload __P((struct mount *mountp, struct ucred *cred, - struct proc *p)); + struct thread *td)); static int ext2_sbupdate __P((struct ufsmount *, int)); -static int ext2_statfs __P((struct mount *, struct statfs *, struct proc *)); -static int ext2_sync __P((struct mount *, int, struct ucred *, struct proc *)); -static int ext2_unmount __P((struct mount *, int, struct proc *)); +static int ext2_statfs __P((struct mount *, struct statfs *, struct thread *)); +static int ext2_sync __P((struct mount *, int, struct ucred *, struct thread *)); +static int ext2_unmount __P((struct mount *, int, struct thread *)); static int ext2_vget __P((struct mount *, ino_t, struct vnode **)); static int ext2_vptofh __P((struct vnode *, struct fid *)); @@ -130,7 +130,7 @@ ext2_mountroot() { register struct ext2_sb_info *fs; register struct mount *mp; - struct proc *p = curproc; + struct thread *td = curthread; struct ufsmount *ump; u_int size; int error; @@ -143,12 +143,12 @@ ext2_mountroot() bzero((char *)mp, (u_long)sizeof(struct mount)); mp->mnt_op = &ext2fs_vfsops; mp->mnt_flag = MNT_RDONLY; - if (error = ext2_mountfs(rootvp, mp, p)) { + if (error = ext2_mountfs(rootvp, mp, td)) { bsd_free(mp, M_MOUNT); return (error); } if (error = vfs_lock(mp)) { - (void)ext2_unmount(mp, 0, p); + (void)ext2_unmount(mp, 0, td); bsd_free(mp, M_MOUNT); return (error); } @@ -164,7 +164,7 @@ ext2_mountroot() (void) copystr(ROOTNAME, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void)ext2_statfs(mp, &mp->mnt_stat, p); + (void)ext2_statfs(mp, &mp->mnt_stat, td); vfs_unlock(mp); inittodr(fs->s_es->s_wtime); /* this helps to set the time */ return (0); @@ -177,12 +177,12 @@ ext2_mountroot() * mount system call */ static int -ext2_mount(mp, path, data, ndp, p) +ext2_mount(mp, path, data, ndp, td) register struct mount *mp; char *path; caddr_t data; /* this is actually a (struct ufs_args *) */ struct nameidata *ndp; - struct proc *p; + struct thread *td; { struct vnode *devvp; struct ufs_args args; @@ -210,10 +210,10 @@ ext2_mount(mp, path, data, ndp, p) flags = WRITECLOSE; if (mp->mnt_flag & MNT_FORCE) flags |= FORCECLOSE; - if (vfs_busy(mp, LK_NOWAIT, 0, p)) + if (vfs_busy(mp, LK_NOWAIT, 0, td)) return (EBUSY); - error = ext2_flushfiles(mp, flags, p); - vfs_unbusy(mp, p); + error = ext2_flushfiles(mp, flags, td); + vfs_unbusy(mp, td); if (!error && fs->s_wasvalid) { fs->s_es->s_state |= EXT2_VALID_FS; ext2_sbupdate(ump, MNT_WAIT); @@ -221,7 +221,7 @@ ext2_mount(mp, path, data, ndp, p) fs->s_rd_only = 1; } if (!error && (mp->mnt_flag & MNT_RELOAD)) - error = ext2_reload(mp, ndp->ni_cnd.cn_cred, p); + error = ext2_reload(mp, ndp->ni_cnd.cn_cred, td); if (error) return (error); devvp = ump->um_devvp; @@ -233,14 +233,14 @@ ext2_mount(mp, path, data, ndp, p) * If upgrade to read-write by non-root, then verify * that user has necessary permissions on the device. */ - if (suser(p)) { - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); + if (suser_td(td)) { + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); if ((error = VOP_ACCESS(devvp, VREAD | VWRITE, - p->p_ucred, p)) != 0) { - VOP_UNLOCK(devvp, 0, p); + td->td_proc->p_ucred, td)) != 0) { + VOP_UNLOCK(devvp, 0, td); return (error); } - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); } if ((fs->s_es->s_state & EXT2_VALID_FS) == 0 || @@ -271,7 +271,7 @@ ext2_mount(mp, path, data, ndp, p) * Not an update, or updating the name: look up the name * and verify that it refers to a sensible block device. */ - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, td); if ((error = namei(ndp)) != 0) return (error); NDFREE(ndp, NDF_ONLY_PNBUF); @@ -286,20 +286,20 @@ ext2_mount(mp, path, data, ndp, p) * If mount by non-root, then verify that user has necessary * permissions on the device. */ - if (suser(p)) { + if (suser_td(td)) { accessmode = VREAD; if ((mp->mnt_flag & MNT_RDONLY) == 0) accessmode |= VWRITE; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - if ((error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p)) != 0) { + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + if ((error = VOP_ACCESS(devvp, accessmode, td->td_proc->p_ucred, td)) != 0) { vput(devvp); return (error); } - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); } if ((mp->mnt_flag & MNT_UPDATE) == 0) { - error = ext2_mountfs(devvp, mp, p); + error = ext2_mountfs(devvp, mp, td); } else { if (devvp != ump->um_devvp) error = EINVAL; /* needs translation */ @@ -321,7 +321,7 @@ ext2_mount(mp, path, data, ndp, p) (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void)ext2_statfs(mp, &mp->mnt_stat, p); + (void)ext2_statfs(mp, &mp->mnt_stat, td); return (0); } @@ -522,10 +522,10 @@ static int compute_sb_data(devvp, es, fs) * 6) re-read inode data for all active vnodes. */ static int -ext2_reload(mountp, cred, p) +ext2_reload(mountp, cred, td) register struct mount *mountp; struct ucred *cred; - struct proc *p; + struct thread *td; { register struct vnode *vp, *nvp, *devvp; struct inode *ip; @@ -540,7 +540,7 @@ ext2_reload(mountp, cred, p) * Step 1: invalidate all cached meta-data. */ devvp = VFSTOUFS(mountp)->um_devvp; - if (vinvalbuf(devvp, 0, cred, p, 0, 0)) + if (vinvalbuf(devvp, 0, cred, td, 0, 0)) panic("ext2_reload: dirty1"); /* * Step 2: re-read superblock from disk. @@ -578,16 +578,16 @@ loop: /* * Step 4: invalidate all inactive vnodes. */ - if (vrecycle(vp, NULL, p)) + if (vrecycle(vp, NULL, td)) goto loop; /* * Step 5: invalidate all cached file data. */ mtx_lock(&vp->v_interlock); - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) { + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) { goto loop; } - if (vinvalbuf(vp, 0, cred, p, 0, 0)) + if (vinvalbuf(vp, 0, cred, td, 0, 0)) panic("ext2_reload: dirty2"); /* * Step 6: re-read inode data for all active vnodes. @@ -615,10 +615,10 @@ loop: * Common code for mount and mountroot */ static int -ext2_mountfs(devvp, mp, p) +ext2_mountfs(devvp, mp, td) register struct vnode *devvp; struct mount *mp; - struct proc *p; + struct thread *td; { register struct ufsmount *ump; struct buf *bp; @@ -640,7 +640,7 @@ ext2_mountfs(devvp, mp, p) return (error); if (vcount(devvp) > 1 && devvp != rootvp) return (EBUSY); - if ((error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0)) != 0) + if ((error = vinvalbuf(devvp, V_SAVE, td->td_proc->p_ucred, td, 0, 0)) != 0) return (error); #ifdef READONLY /* turn on this to force it to be read-only */ @@ -648,12 +648,12 @@ ext2_mountfs(devvp, mp, p) #endif ronly = (mp->mnt_flag & MNT_RDONLY) != 0; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p); - VOP_UNLOCK(devvp, 0, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, td); + VOP_UNLOCK(devvp, 0, td); if (error) return (error); - if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0) + if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, td) != 0) size = DEV_BSIZE; else { havepart = 1; @@ -739,7 +739,7 @@ ext2_mountfs(devvp, mp, p) out: if (bp) brelse(bp); - (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p); + (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, td); if (ump) { bsd_free(ump->um_e2fs->s_es, M_UFSMNT); bsd_free(ump->um_e2fs, M_UFSMNT); @@ -753,10 +753,10 @@ out: * unmount system call */ static int -ext2_unmount(mp, mntflags, p) +ext2_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { register struct ufsmount *ump; register struct ext2_sb_info *fs; @@ -768,7 +768,7 @@ ext2_unmount(mp, mntflags, p) return (EINVAL); flags |= FORCECLOSE; } - if ((error = ext2_flushfiles(mp, flags, p)) != 0) + if ((error = ext2_flushfiles(mp, flags, td)) != 0) return (error); ump = VFSTOUFS(mp); fs = ump->um_e2fs; @@ -795,7 +795,7 @@ ext2_unmount(mp, mntflags, p) ump->um_devvp->v_rdev->si_mountpoint = NULL; error = VOP_CLOSE(ump->um_devvp, ronly ? FREAD : FREAD|FWRITE, - NOCRED, p); + NOCRED, td); vrele(ump->um_devvp); bsd_free(fs->s_es, M_UFSMNT); bsd_free(fs, M_UFSMNT); @@ -809,10 +809,10 @@ ext2_unmount(mp, mntflags, p) * Flush out all the files in a filesystem. */ static int -ext2_flushfiles(mp, flags, p) +ext2_flushfiles(mp, flags, td) register struct mount *mp; int flags; - struct proc *p; + struct thread *td; { register struct ufsmount *ump; int error; @@ -828,7 +828,7 @@ ext2_flushfiles(mp, flags, p) for (i = 0; i < MAXQUOTAS; i++) { if (ump->um_quotas[i] == NULLVP) continue; - quotaoff(p, mp, i); + quotaoff(td, mp, i); } /* * Here we fall through to vflush again to ensure @@ -845,10 +845,10 @@ ext2_flushfiles(mp, flags, p) * taken from ext2/super.c ext2_statfs */ static int -ext2_statfs(mp, sbp, p) +ext2_statfs(mp, sbp, td) struct mount *mp; register struct statfs *sbp; - struct proc *p; + struct thread *td; { unsigned long overhead; register struct ufsmount *ump; @@ -904,11 +904,11 @@ ext2_statfs(mp, sbp, p) * Note: we are always called with the filesystem marked `MPBUSY'. */ static int -ext2_sync(mp, waitfor, cred, p) +ext2_sync(mp, waitfor, cred, td) struct mount *mp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { struct vnode *nvp, *vp; struct inode *ip; @@ -945,16 +945,16 @@ loop: mtx_lock(&mntvnode_mtx); continue; } - error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, p); + error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, td); if (error) { mtx_lock(&mntvnode_mtx); if (error == ENOENT) goto loop; continue; } - if ((error = VOP_FSYNC(vp, cred, waitfor, p)) != 0) + if ((error = VOP_FSYNC(vp, cred, waitfor, td)) != 0) allerror = error; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vrele(vp); mtx_lock(&mntvnode_mtx); } @@ -963,10 +963,10 @@ loop: * Force stale file system control information to be flushed. */ if (waitfor != MNT_LAZY) { - vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p); - if ((error = VOP_FSYNC(ump->um_devvp, cred, waitfor, p)) != 0) + vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, td); + if ((error = VOP_FSYNC(ump->um_devvp, cred, waitfor, td)) != 0) allerror = error; - VOP_UNLOCK(ump->um_devvp, 0, p); + VOP_UNLOCK(ump->um_devvp, 0, td); } #if QUOTA qsync(mp); diff --git a/sys/gnu/ext2fs/ext2_vnops.c b/sys/gnu/ext2fs/ext2_vnops.c index 2bd494b..ad60728 100644 --- a/sys/gnu/ext2fs/ext2_vnops.c +++ b/sys/gnu/ext2fs/ext2_vnops.c @@ -191,7 +191,7 @@ ext2_fsync(ap) struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -335,7 +335,7 @@ ext2_link(ap) struct vnode *vp = ap->a_vp; struct vnode *tdvp = ap->a_tdvp; struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct inode *ip; int error; @@ -347,7 +347,7 @@ ext2_link(ap) error = EXDEV; goto out2; } - if (tdvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE, p))) { + if (tdvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE, td))) { goto out2; } ip = VTOI(vp); @@ -370,7 +370,7 @@ ext2_link(ap) } out1: if (tdvp != vp) - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); out2: return (error); } @@ -396,7 +396,7 @@ ext2_rename(ap) struct vnode *fdvp = ap->a_fdvp; struct componentname *tcnp = ap->a_tcnp; struct componentname *fcnp = ap->a_fcnp; - struct proc *p = fcnp->cn_proc; + struct thread *td = fcnp->cn_thread; struct inode *ip, *xp, *dp; struct dirtemplate dirbuf; int doingdirectory = 0, oldparent = 0, newparent = 0; @@ -487,18 +487,18 @@ abortit: vput(fvp); return (error); } - if ((error = vn_lock(fvp, LK_EXCLUSIVE, p)) != 0) + if ((error = vn_lock(fvp, LK_EXCLUSIVE, td)) != 0) goto abortit; dp = VTOI(fdvp); ip = VTOI(fvp); if (ip->i_nlink >= LINK_MAX) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); error = EMLINK; goto abortit; } if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) || (dp->i_flags & APPEND)) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); error = EPERM; goto abortit; } @@ -509,7 +509,7 @@ abortit: if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') || dp == ip || (fcnp->cn_flags | tcnp->cn_flags) & ISDOTDOT || (ip->i_flag & IN_RENAME)) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); error = EINVAL; goto abortit; } @@ -537,7 +537,7 @@ abortit: ip->i_nlink++; ip->i_flag |= IN_CHANGE; if ((error = UFS_UPDATE(fvp, 1)) != 0) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); goto bad; } @@ -551,8 +551,8 @@ abortit: * to namei, as the parent directory is unlocked by the * call to checkpath(). */ - error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc); - VOP_UNLOCK(fvp, 0, p); + error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_thread); + VOP_UNLOCK(fvp, 0, td); if (oldparent != dp->i_number) newparent = dp->i_number; if (doingdirectory && newparent) { @@ -678,7 +678,7 @@ abortit: if (--xp->i_nlink != 0) panic("ufs_rename: linked directory"); error = UFS_TRUNCATE(tvp, (off_t)0, IO_SYNC, - tcnp->cn_cred, tcnp->cn_proc); + tcnp->cn_cred, tcnp->cn_thread); } xp->i_flag |= IN_CHANGE; vput(tvp); @@ -732,7 +732,7 @@ abortit: error = vn_rdwr(UIO_READ, fvp, (caddr_t)&dirbuf, sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE, IO_NODELOCKED, - tcnp->cn_cred, (int *)0, (struct proc *)0); + tcnp->cn_cred, (int *)0, (struct thread *)0); if (error == 0) { /* Like ufs little-endian: */ namlen = dirbuf.dotdot_type; @@ -749,7 +749,7 @@ abortit: (off_t)0, UIO_SYSSPACE, IO_NODELOCKED|IO_SYNC, tcnp->cn_cred, (int *)0, - (struct proc *)0); + (struct thread *)0); cache_purge(fdvp); } } @@ -775,7 +775,7 @@ bad: out: if (doingdirectory) ip->i_flag &= ~IN_RENAME; - if (vn_lock(fvp, LK_EXCLUSIVE, p) == 0) { + if (vn_lock(fvp, LK_EXCLUSIVE, td) == 0) { ip->i_nlink--; ip->i_flag |= IN_CHANGE; ip->i_flag &= ~IN_RENAME; @@ -920,7 +920,7 @@ ext2_mkdir(ap) dirtemplate.dotdot_reclen = DIRBLKSIZ - 12; error = vn_rdwr(UIO_WRITE, tvp, (caddr_t)&dirtemplate, sizeof (dirtemplate), (off_t)0, UIO_SYSSPACE, - IO_NODELOCKED|IO_SYNC, cnp->cn_cred, (int *)0, (struct proc *)0); + IO_NODELOCKED|IO_SYNC, cnp->cn_cred, (int *)0, (struct thread *)0); if (error) { dp->i_nlink--; dp->i_flag |= IN_CHANGE; @@ -970,7 +970,7 @@ ext2_rmdir(ap) struct vnode *vp = ap->a_vp; struct vnode *dvp = ap->a_dvp; struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct inode *ip, *dp; int error; @@ -1005,7 +1005,7 @@ ext2_rmdir(ap) dp->i_nlink--; dp->i_flag |= IN_CHANGE; cache_purge(dvp); - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); /* * Truncate inode. The only stuff left * in the directory is "." and "..". The @@ -1018,9 +1018,9 @@ ext2_rmdir(ap) * worry about them later. */ ip->i_nlink -= 2; - error = UFS_TRUNCATE(vp, (off_t)0, IO_SYNC, cnp->cn_cred, p); + error = UFS_TRUNCATE(vp, (off_t)0, IO_SYNC, cnp->cn_cred, td); cache_purge(ITOV(ip)); - vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td); out: return (error); } @@ -1056,7 +1056,7 @@ ext2_symlink(ap) } else error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0, UIO_SYSSPACE, IO_NODELOCKED, ap->a_cnp->cn_cred, (int *)0, - (struct proc *)0); + (struct thread *)0); if (error) vput(vp); return (error); diff --git a/sys/gnu/ext2fs/fs.h b/sys/gnu/ext2fs/fs.h index 8bedb05..c7e96c9 100644 --- a/sys/gnu/ext2fs/fs.h +++ b/sys/gnu/ext2fs/fs.h @@ -153,8 +153,8 @@ extern u_char *fragtbl[]; * I think I'll try a VOP_LOCK/VOP_UNLOCK on the device vnode */ #define DEVVP(inode) (VFSTOUFS(ITOV(inode)->v_mount)->um_devvp) -#define lock_super(devvp) vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, curproc) -#define unlock_super(devvp) VOP_UNLOCK(devvp, 0, curproc) +#define lock_super(devvp) vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, curthread) +#define unlock_super(devvp) VOP_UNLOCK(devvp, 0, curthread) /* * To lock a buffer, set the B_LOCKED flag and then brelse() it. To unlock, diff --git a/sys/gnu/fs/ext2fs/ext2_extern.h b/sys/gnu/fs/ext2fs/ext2_extern.h index b37b3ec..580683b 100644 --- a/sys/gnu/fs/ext2fs/ext2_extern.h +++ b/sys/gnu/fs/ext2fs/ext2_extern.h @@ -62,7 +62,7 @@ int ext2_init __P((struct vfsconf *)); int ext2_reallocblks __P((struct vop_reallocblks_args *)); int ext2_reclaim __P((struct vop_reclaim_args *)); void ext2_setblock __P((struct ext2_sb_info *, u_char *, daddr_t)); -int ext2_truncate __P((struct vnode *, off_t, int, struct ucred *, struct proc *)); +int ext2_truncate __P((struct vnode *, off_t, int, struct ucred *, struct thread *)); int ext2_update __P((struct vnode *, int)); int ext2_valloc __P((struct vnode *, int, struct ucred *, struct vnode **)); int ext2_vfree __P((struct vnode *, ino_t, int)); diff --git a/sys/gnu/fs/ext2fs/ext2_inode.c b/sys/gnu/fs/ext2fs/ext2_inode.c index 5a60006..6a3e011 100644 --- a/sys/gnu/fs/ext2fs/ext2_inode.c +++ b/sys/gnu/fs/ext2fs/ext2_inode.c @@ -129,12 +129,12 @@ ext2_update(vp, waitfor) * disk blocks. */ int -ext2_truncate(vp, length, flags, cred, p) +ext2_truncate(vp, length, flags, cred, td) struct vnode *vp; off_t length; int flags; struct ucred *cred; - struct proc *p; + struct thread *td; { register struct vnode *ovp = vp; register daddr_t lastblock; @@ -268,7 +268,7 @@ printf("ext2_truncate called %d to %d\n", VTOI(ovp)->i_number, length); bcopy((caddr_t)&oip->i_db[0], (caddr_t)newblks, sizeof newblks); bcopy((caddr_t)oldblks, (caddr_t)&oip->i_db[0], sizeof oldblks); oip->i_size = osize; - error = vtruncbuf(ovp, cred, p, length, (int)fs->s_blocksize); + error = vtruncbuf(ovp, cred, td, length, (int)fs->s_blocksize); if (error && (allerror == 0)) allerror = error; diff --git a/sys/gnu/fs/ext2fs/ext2_lookup.c b/sys/gnu/fs/ext2fs/ext2_lookup.c index 4804ff1..b2e1511 100644 --- a/sys/gnu/fs/ext2fs/ext2_lookup.c +++ b/sys/gnu/fs/ext2fs/ext2_lookup.c @@ -322,7 +322,7 @@ ext2_lookup(ap) struct ucred *cred = cnp->cn_cred; int flags = cnp->cn_flags; int nameiop = cnp->cn_nameiop; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; int DIRBLKSIZ = VTOI(ap->a_dvp)->i_e2fs->s_blocksize; @@ -503,7 +503,7 @@ searchloop: * Access for write is interpreted as allowing * creation of files in the directory. */ - if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc)) != 0) + if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread)) != 0) return (error); /* * Return an indication of where the new directory @@ -541,7 +541,7 @@ searchloop: */ cnp->cn_flags |= SAVENAME; if (!lockparent) - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); return (EJUSTRETURN); } /* @@ -584,7 +584,7 @@ found: /* * Write access to directory required to delete files. */ - if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc)) != 0) + if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread)) != 0) return (error); /* * Return pointer to current entry in dp->i_offset, @@ -618,7 +618,7 @@ found: } *vpp = tdp; if (!lockparent) - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); return (0); } @@ -630,7 +630,7 @@ found: */ if (nameiop == RENAME && wantparent && (flags & ISLASTCN)) { - if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc)) != 0) + if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread)) != 0) return (error); /* * Careful about locking second inode. @@ -643,7 +643,7 @@ found: *vpp = tdp; cnp->cn_flags |= SAVENAME; if (!lockparent) - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); return (0); } @@ -668,13 +668,13 @@ found: */ pdp = vdp; if (flags & ISDOTDOT) { - VOP_UNLOCK(pdp, 0, p); /* race to get the inode */ + VOP_UNLOCK(pdp, 0, td); /* race to get the inode */ if ((error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) != 0) { - vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, td); return (error); } if (lockparent && (flags & ISLASTCN) && - (error = vn_lock(pdp, LK_EXCLUSIVE, p))) { + (error = vn_lock(pdp, LK_EXCLUSIVE, td))) { vput(tdp); return (error); } @@ -686,7 +686,7 @@ found: if ((error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) != 0) return (error); if (!lockparent || !(flags & ISLASTCN)) - VOP_UNLOCK(pdp, 0, p); + VOP_UNLOCK(pdp, 0, td); *vpp = tdp; } @@ -799,7 +799,7 @@ ext2_direnter(ip, dvp, cnp) auio.uio_iovcnt = 1; auio.uio_rw = UIO_WRITE; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = (struct proc *)0; + auio.uio_td = (struct thread *)0; error = VOP_WRITE(dvp, &auio, IO_SYNC, cnp->cn_cred); if (DIRBLKSIZ > VFSTOUFS(dvp->v_mount)->um_mountp->mnt_stat.f_bsize) @@ -880,7 +880,7 @@ ext2_direnter(ip, dvp, cnp) dp->i_flag |= IN_CHANGE | IN_UPDATE; if (!error && dp->i_endoff && dp->i_endoff < dp->i_size) error = UFS_TRUNCATE(dvp, (off_t)dp->i_endoff, IO_SYNC, - cnp->cn_cred, cnp->cn_proc); + cnp->cn_cred, cnp->cn_thread); return (error); } @@ -983,7 +983,7 @@ ext2_dirempty(ip, parentino, cred) for (off = 0; off < ip->i_size; off += dp->rec_len) { error = vn_rdwr(UIO_READ, ITOV(ip), (caddr_t)dp, MINDIRSIZ, off, - UIO_SYSSPACE, IO_NODELOCKED, cred, &count, (struct proc *)0); + UIO_SYSSPACE, IO_NODELOCKED, cred, &count, (struct thread *)0); /* * Since we read MINDIRSIZ, residual must * be 0 unless we're at end of file. @@ -1047,7 +1047,7 @@ ext2_checkpath(source, target, cred) } error = vn_rdwr(UIO_READ, vp, (caddr_t)&dirbuf, sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE, - IO_NODELOCKED, cred, (int *)0, (struct proc *)0); + IO_NODELOCKED, cred, (int *)0, (struct thread *)0); if (error != 0) break; namlen = dirbuf.dotdot_type; /* like ufs little-endian */ diff --git a/sys/gnu/fs/ext2fs/ext2_mount.h b/sys/gnu/fs/ext2fs/ext2_mount.h index 4c73aa3..85c9866 100644 --- a/sys/gnu/fs/ext2fs/ext2_mount.h +++ b/sys/gnu/fs/ext2fs/ext2_mount.h @@ -88,7 +88,7 @@ struct ufsmount { int um_i_effnlink_valid; /* i_effnlink valid? */ int (*um_balloc) __P((struct vnode *, off_t, int, struct ucred *, int, struct buf **)); int (*um_blkatoff) __P((struct vnode *, off_t, char **, struct buf **)); - int (*um_truncate) __P((struct vnode *, off_t, int, struct ucred *, struct proc *)); + int (*um_truncate) __P((struct vnode *, off_t, int, struct ucred *, struct thread *)); int (*um_update) __P((struct vnode *, int)); int (*um_valloc) __P((struct vnode *, int, struct ucred *, struct vnode **)); int (*um_vfree) __P((struct vnode *, ino_t, int)); diff --git a/sys/gnu/fs/ext2fs/ext2_readwrite.c b/sys/gnu/fs/ext2fs/ext2_readwrite.c index 62bc27a..2772f7b 100644 --- a/sys/gnu/fs/ext2fs/ext2_readwrite.c +++ b/sys/gnu/fs/ext2fs/ext2_readwrite.c @@ -172,7 +172,7 @@ WRITE(ap) register struct inode *ip; register FS *fs; struct buf *bp; - struct proc *p; + struct thread *td; daddr_t lbn; off_t osize; int seqcount; @@ -216,15 +216,15 @@ WRITE(ap) * Maybe this should be above the vnode op call, but so long as * file servers have no limits, I don't think it matters. */ - p = uio->uio_procp; + td = uio->uio_td; /* For p_rlimit. */ mtx_assert(&Giant, MA_OWNED); - if (vp->v_type == VREG && p && + if (vp->v_type == VREG && td && uio->uio_offset + uio->uio_resid > - p->p_rlimit[RLIMIT_FSIZE].rlim_cur) { - PROC_LOCK(p); - psignal(p, SIGXFSZ); - PROC_UNLOCK(p); + td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) { + PROC_LOCK(td->td_proc); + psignal(td->td_proc, SIGXFSZ); + PROC_UNLOCK(td->td_proc); return (EFBIG); } @@ -302,7 +302,7 @@ WRITE(ap) if (error) { if (ioflag & IO_UNIT) { (void)UFS_TRUNCATE(vp, osize, - ioflag & IO_SYNC, ap->a_cred, uio->uio_procp); + ioflag & IO_SYNC, ap->a_cred, uio->uio_td); uio->uio_offset -= resid - uio->uio_resid; uio->uio_resid = resid; } diff --git a/sys/gnu/fs/ext2fs/ext2_vfsops.c b/sys/gnu/fs/ext2fs/ext2_vfsops.c index 7263615..713a0cb 100644 --- a/sys/gnu/fs/ext2fs/ext2_vfsops.c +++ b/sys/gnu/fs/ext2fs/ext2_vfsops.c @@ -71,16 +71,16 @@ #include <gnu/ext2fs/ext2_fs_sb.h> static int ext2_fhtovp __P((struct mount *, struct fid *, struct vnode **)); -static int ext2_flushfiles __P((struct mount *mp, int flags, struct proc *p)); +static int ext2_flushfiles __P((struct mount *mp, int flags, struct thread *td)); static int ext2_mount __P((struct mount *, - char *, caddr_t, struct nameidata *, struct proc *)); -static int ext2_mountfs __P((struct vnode *, struct mount *, struct proc *)); + char *, caddr_t, struct nameidata *, struct thread *)); +static int ext2_mountfs __P((struct vnode *, struct mount *, struct thread *)); static int ext2_reload __P((struct mount *mountp, struct ucred *cred, - struct proc *p)); + struct thread *td)); static int ext2_sbupdate __P((struct ufsmount *, int)); -static int ext2_statfs __P((struct mount *, struct statfs *, struct proc *)); -static int ext2_sync __P((struct mount *, int, struct ucred *, struct proc *)); -static int ext2_unmount __P((struct mount *, int, struct proc *)); +static int ext2_statfs __P((struct mount *, struct statfs *, struct thread *)); +static int ext2_sync __P((struct mount *, int, struct ucred *, struct thread *)); +static int ext2_unmount __P((struct mount *, int, struct thread *)); static int ext2_vget __P((struct mount *, ino_t, struct vnode **)); static int ext2_vptofh __P((struct vnode *, struct fid *)); @@ -130,7 +130,7 @@ ext2_mountroot() { register struct ext2_sb_info *fs; register struct mount *mp; - struct proc *p = curproc; + struct thread *td = curthread; struct ufsmount *ump; u_int size; int error; @@ -143,12 +143,12 @@ ext2_mountroot() bzero((char *)mp, (u_long)sizeof(struct mount)); mp->mnt_op = &ext2fs_vfsops; mp->mnt_flag = MNT_RDONLY; - if (error = ext2_mountfs(rootvp, mp, p)) { + if (error = ext2_mountfs(rootvp, mp, td)) { bsd_free(mp, M_MOUNT); return (error); } if (error = vfs_lock(mp)) { - (void)ext2_unmount(mp, 0, p); + (void)ext2_unmount(mp, 0, td); bsd_free(mp, M_MOUNT); return (error); } @@ -164,7 +164,7 @@ ext2_mountroot() (void) copystr(ROOTNAME, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void)ext2_statfs(mp, &mp->mnt_stat, p); + (void)ext2_statfs(mp, &mp->mnt_stat, td); vfs_unlock(mp); inittodr(fs->s_es->s_wtime); /* this helps to set the time */ return (0); @@ -177,12 +177,12 @@ ext2_mountroot() * mount system call */ static int -ext2_mount(mp, path, data, ndp, p) +ext2_mount(mp, path, data, ndp, td) register struct mount *mp; char *path; caddr_t data; /* this is actually a (struct ufs_args *) */ struct nameidata *ndp; - struct proc *p; + struct thread *td; { struct vnode *devvp; struct ufs_args args; @@ -210,10 +210,10 @@ ext2_mount(mp, path, data, ndp, p) flags = WRITECLOSE; if (mp->mnt_flag & MNT_FORCE) flags |= FORCECLOSE; - if (vfs_busy(mp, LK_NOWAIT, 0, p)) + if (vfs_busy(mp, LK_NOWAIT, 0, td)) return (EBUSY); - error = ext2_flushfiles(mp, flags, p); - vfs_unbusy(mp, p); + error = ext2_flushfiles(mp, flags, td); + vfs_unbusy(mp, td); if (!error && fs->s_wasvalid) { fs->s_es->s_state |= EXT2_VALID_FS; ext2_sbupdate(ump, MNT_WAIT); @@ -221,7 +221,7 @@ ext2_mount(mp, path, data, ndp, p) fs->s_rd_only = 1; } if (!error && (mp->mnt_flag & MNT_RELOAD)) - error = ext2_reload(mp, ndp->ni_cnd.cn_cred, p); + error = ext2_reload(mp, ndp->ni_cnd.cn_cred, td); if (error) return (error); devvp = ump->um_devvp; @@ -233,14 +233,14 @@ ext2_mount(mp, path, data, ndp, p) * If upgrade to read-write by non-root, then verify * that user has necessary permissions on the device. */ - if (suser(p)) { - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); + if (suser_td(td)) { + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); if ((error = VOP_ACCESS(devvp, VREAD | VWRITE, - p->p_ucred, p)) != 0) { - VOP_UNLOCK(devvp, 0, p); + td->td_proc->p_ucred, td)) != 0) { + VOP_UNLOCK(devvp, 0, td); return (error); } - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); } if ((fs->s_es->s_state & EXT2_VALID_FS) == 0 || @@ -271,7 +271,7 @@ ext2_mount(mp, path, data, ndp, p) * Not an update, or updating the name: look up the name * and verify that it refers to a sensible block device. */ - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, td); if ((error = namei(ndp)) != 0) return (error); NDFREE(ndp, NDF_ONLY_PNBUF); @@ -286,20 +286,20 @@ ext2_mount(mp, path, data, ndp, p) * If mount by non-root, then verify that user has necessary * permissions on the device. */ - if (suser(p)) { + if (suser_td(td)) { accessmode = VREAD; if ((mp->mnt_flag & MNT_RDONLY) == 0) accessmode |= VWRITE; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - if ((error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p)) != 0) { + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + if ((error = VOP_ACCESS(devvp, accessmode, td->td_proc->p_ucred, td)) != 0) { vput(devvp); return (error); } - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); } if ((mp->mnt_flag & MNT_UPDATE) == 0) { - error = ext2_mountfs(devvp, mp, p); + error = ext2_mountfs(devvp, mp, td); } else { if (devvp != ump->um_devvp) error = EINVAL; /* needs translation */ @@ -321,7 +321,7 @@ ext2_mount(mp, path, data, ndp, p) (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void)ext2_statfs(mp, &mp->mnt_stat, p); + (void)ext2_statfs(mp, &mp->mnt_stat, td); return (0); } @@ -522,10 +522,10 @@ static int compute_sb_data(devvp, es, fs) * 6) re-read inode data for all active vnodes. */ static int -ext2_reload(mountp, cred, p) +ext2_reload(mountp, cred, td) register struct mount *mountp; struct ucred *cred; - struct proc *p; + struct thread *td; { register struct vnode *vp, *nvp, *devvp; struct inode *ip; @@ -540,7 +540,7 @@ ext2_reload(mountp, cred, p) * Step 1: invalidate all cached meta-data. */ devvp = VFSTOUFS(mountp)->um_devvp; - if (vinvalbuf(devvp, 0, cred, p, 0, 0)) + if (vinvalbuf(devvp, 0, cred, td, 0, 0)) panic("ext2_reload: dirty1"); /* * Step 2: re-read superblock from disk. @@ -578,16 +578,16 @@ loop: /* * Step 4: invalidate all inactive vnodes. */ - if (vrecycle(vp, NULL, p)) + if (vrecycle(vp, NULL, td)) goto loop; /* * Step 5: invalidate all cached file data. */ mtx_lock(&vp->v_interlock); - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) { + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) { goto loop; } - if (vinvalbuf(vp, 0, cred, p, 0, 0)) + if (vinvalbuf(vp, 0, cred, td, 0, 0)) panic("ext2_reload: dirty2"); /* * Step 6: re-read inode data for all active vnodes. @@ -615,10 +615,10 @@ loop: * Common code for mount and mountroot */ static int -ext2_mountfs(devvp, mp, p) +ext2_mountfs(devvp, mp, td) register struct vnode *devvp; struct mount *mp; - struct proc *p; + struct thread *td; { register struct ufsmount *ump; struct buf *bp; @@ -640,7 +640,7 @@ ext2_mountfs(devvp, mp, p) return (error); if (vcount(devvp) > 1 && devvp != rootvp) return (EBUSY); - if ((error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0)) != 0) + if ((error = vinvalbuf(devvp, V_SAVE, td->td_proc->p_ucred, td, 0, 0)) != 0) return (error); #ifdef READONLY /* turn on this to force it to be read-only */ @@ -648,12 +648,12 @@ ext2_mountfs(devvp, mp, p) #endif ronly = (mp->mnt_flag & MNT_RDONLY) != 0; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p); - VOP_UNLOCK(devvp, 0, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, td); + VOP_UNLOCK(devvp, 0, td); if (error) return (error); - if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0) + if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, td) != 0) size = DEV_BSIZE; else { havepart = 1; @@ -739,7 +739,7 @@ ext2_mountfs(devvp, mp, p) out: if (bp) brelse(bp); - (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p); + (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, td); if (ump) { bsd_free(ump->um_e2fs->s_es, M_UFSMNT); bsd_free(ump->um_e2fs, M_UFSMNT); @@ -753,10 +753,10 @@ out: * unmount system call */ static int -ext2_unmount(mp, mntflags, p) +ext2_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { register struct ufsmount *ump; register struct ext2_sb_info *fs; @@ -768,7 +768,7 @@ ext2_unmount(mp, mntflags, p) return (EINVAL); flags |= FORCECLOSE; } - if ((error = ext2_flushfiles(mp, flags, p)) != 0) + if ((error = ext2_flushfiles(mp, flags, td)) != 0) return (error); ump = VFSTOUFS(mp); fs = ump->um_e2fs; @@ -795,7 +795,7 @@ ext2_unmount(mp, mntflags, p) ump->um_devvp->v_rdev->si_mountpoint = NULL; error = VOP_CLOSE(ump->um_devvp, ronly ? FREAD : FREAD|FWRITE, - NOCRED, p); + NOCRED, td); vrele(ump->um_devvp); bsd_free(fs->s_es, M_UFSMNT); bsd_free(fs, M_UFSMNT); @@ -809,10 +809,10 @@ ext2_unmount(mp, mntflags, p) * Flush out all the files in a filesystem. */ static int -ext2_flushfiles(mp, flags, p) +ext2_flushfiles(mp, flags, td) register struct mount *mp; int flags; - struct proc *p; + struct thread *td; { register struct ufsmount *ump; int error; @@ -828,7 +828,7 @@ ext2_flushfiles(mp, flags, p) for (i = 0; i < MAXQUOTAS; i++) { if (ump->um_quotas[i] == NULLVP) continue; - quotaoff(p, mp, i); + quotaoff(td, mp, i); } /* * Here we fall through to vflush again to ensure @@ -845,10 +845,10 @@ ext2_flushfiles(mp, flags, p) * taken from ext2/super.c ext2_statfs */ static int -ext2_statfs(mp, sbp, p) +ext2_statfs(mp, sbp, td) struct mount *mp; register struct statfs *sbp; - struct proc *p; + struct thread *td; { unsigned long overhead; register struct ufsmount *ump; @@ -904,11 +904,11 @@ ext2_statfs(mp, sbp, p) * Note: we are always called with the filesystem marked `MPBUSY'. */ static int -ext2_sync(mp, waitfor, cred, p) +ext2_sync(mp, waitfor, cred, td) struct mount *mp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { struct vnode *nvp, *vp; struct inode *ip; @@ -945,16 +945,16 @@ loop: mtx_lock(&mntvnode_mtx); continue; } - error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, p); + error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, td); if (error) { mtx_lock(&mntvnode_mtx); if (error == ENOENT) goto loop; continue; } - if ((error = VOP_FSYNC(vp, cred, waitfor, p)) != 0) + if ((error = VOP_FSYNC(vp, cred, waitfor, td)) != 0) allerror = error; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vrele(vp); mtx_lock(&mntvnode_mtx); } @@ -963,10 +963,10 @@ loop: * Force stale file system control information to be flushed. */ if (waitfor != MNT_LAZY) { - vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p); - if ((error = VOP_FSYNC(ump->um_devvp, cred, waitfor, p)) != 0) + vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, td); + if ((error = VOP_FSYNC(ump->um_devvp, cred, waitfor, td)) != 0) allerror = error; - VOP_UNLOCK(ump->um_devvp, 0, p); + VOP_UNLOCK(ump->um_devvp, 0, td); } #if QUOTA qsync(mp); diff --git a/sys/gnu/fs/ext2fs/ext2_vnops.c b/sys/gnu/fs/ext2fs/ext2_vnops.c index 2bd494b..ad60728 100644 --- a/sys/gnu/fs/ext2fs/ext2_vnops.c +++ b/sys/gnu/fs/ext2fs/ext2_vnops.c @@ -191,7 +191,7 @@ ext2_fsync(ap) struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -335,7 +335,7 @@ ext2_link(ap) struct vnode *vp = ap->a_vp; struct vnode *tdvp = ap->a_tdvp; struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct inode *ip; int error; @@ -347,7 +347,7 @@ ext2_link(ap) error = EXDEV; goto out2; } - if (tdvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE, p))) { + if (tdvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE, td))) { goto out2; } ip = VTOI(vp); @@ -370,7 +370,7 @@ ext2_link(ap) } out1: if (tdvp != vp) - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); out2: return (error); } @@ -396,7 +396,7 @@ ext2_rename(ap) struct vnode *fdvp = ap->a_fdvp; struct componentname *tcnp = ap->a_tcnp; struct componentname *fcnp = ap->a_fcnp; - struct proc *p = fcnp->cn_proc; + struct thread *td = fcnp->cn_thread; struct inode *ip, *xp, *dp; struct dirtemplate dirbuf; int doingdirectory = 0, oldparent = 0, newparent = 0; @@ -487,18 +487,18 @@ abortit: vput(fvp); return (error); } - if ((error = vn_lock(fvp, LK_EXCLUSIVE, p)) != 0) + if ((error = vn_lock(fvp, LK_EXCLUSIVE, td)) != 0) goto abortit; dp = VTOI(fdvp); ip = VTOI(fvp); if (ip->i_nlink >= LINK_MAX) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); error = EMLINK; goto abortit; } if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) || (dp->i_flags & APPEND)) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); error = EPERM; goto abortit; } @@ -509,7 +509,7 @@ abortit: if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') || dp == ip || (fcnp->cn_flags | tcnp->cn_flags) & ISDOTDOT || (ip->i_flag & IN_RENAME)) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); error = EINVAL; goto abortit; } @@ -537,7 +537,7 @@ abortit: ip->i_nlink++; ip->i_flag |= IN_CHANGE; if ((error = UFS_UPDATE(fvp, 1)) != 0) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); goto bad; } @@ -551,8 +551,8 @@ abortit: * to namei, as the parent directory is unlocked by the * call to checkpath(). */ - error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc); - VOP_UNLOCK(fvp, 0, p); + error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_thread); + VOP_UNLOCK(fvp, 0, td); if (oldparent != dp->i_number) newparent = dp->i_number; if (doingdirectory && newparent) { @@ -678,7 +678,7 @@ abortit: if (--xp->i_nlink != 0) panic("ufs_rename: linked directory"); error = UFS_TRUNCATE(tvp, (off_t)0, IO_SYNC, - tcnp->cn_cred, tcnp->cn_proc); + tcnp->cn_cred, tcnp->cn_thread); } xp->i_flag |= IN_CHANGE; vput(tvp); @@ -732,7 +732,7 @@ abortit: error = vn_rdwr(UIO_READ, fvp, (caddr_t)&dirbuf, sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE, IO_NODELOCKED, - tcnp->cn_cred, (int *)0, (struct proc *)0); + tcnp->cn_cred, (int *)0, (struct thread *)0); if (error == 0) { /* Like ufs little-endian: */ namlen = dirbuf.dotdot_type; @@ -749,7 +749,7 @@ abortit: (off_t)0, UIO_SYSSPACE, IO_NODELOCKED|IO_SYNC, tcnp->cn_cred, (int *)0, - (struct proc *)0); + (struct thread *)0); cache_purge(fdvp); } } @@ -775,7 +775,7 @@ bad: out: if (doingdirectory) ip->i_flag &= ~IN_RENAME; - if (vn_lock(fvp, LK_EXCLUSIVE, p) == 0) { + if (vn_lock(fvp, LK_EXCLUSIVE, td) == 0) { ip->i_nlink--; ip->i_flag |= IN_CHANGE; ip->i_flag &= ~IN_RENAME; @@ -920,7 +920,7 @@ ext2_mkdir(ap) dirtemplate.dotdot_reclen = DIRBLKSIZ - 12; error = vn_rdwr(UIO_WRITE, tvp, (caddr_t)&dirtemplate, sizeof (dirtemplate), (off_t)0, UIO_SYSSPACE, - IO_NODELOCKED|IO_SYNC, cnp->cn_cred, (int *)0, (struct proc *)0); + IO_NODELOCKED|IO_SYNC, cnp->cn_cred, (int *)0, (struct thread *)0); if (error) { dp->i_nlink--; dp->i_flag |= IN_CHANGE; @@ -970,7 +970,7 @@ ext2_rmdir(ap) struct vnode *vp = ap->a_vp; struct vnode *dvp = ap->a_dvp; struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct inode *ip, *dp; int error; @@ -1005,7 +1005,7 @@ ext2_rmdir(ap) dp->i_nlink--; dp->i_flag |= IN_CHANGE; cache_purge(dvp); - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); /* * Truncate inode. The only stuff left * in the directory is "." and "..". The @@ -1018,9 +1018,9 @@ ext2_rmdir(ap) * worry about them later. */ ip->i_nlink -= 2; - error = UFS_TRUNCATE(vp, (off_t)0, IO_SYNC, cnp->cn_cred, p); + error = UFS_TRUNCATE(vp, (off_t)0, IO_SYNC, cnp->cn_cred, td); cache_purge(ITOV(ip)); - vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td); out: return (error); } @@ -1056,7 +1056,7 @@ ext2_symlink(ap) } else error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0, UIO_SYSSPACE, IO_NODELOCKED, ap->a_cnp->cn_cred, (int *)0, - (struct proc *)0); + (struct thread *)0); if (error) vput(vp); return (error); diff --git a/sys/gnu/fs/ext2fs/fs.h b/sys/gnu/fs/ext2fs/fs.h index 8bedb05..c7e96c9 100644 --- a/sys/gnu/fs/ext2fs/fs.h +++ b/sys/gnu/fs/ext2fs/fs.h @@ -153,8 +153,8 @@ extern u_char *fragtbl[]; * I think I'll try a VOP_LOCK/VOP_UNLOCK on the device vnode */ #define DEVVP(inode) (VFSTOUFS(ITOV(inode)->v_mount)->um_devvp) -#define lock_super(devvp) vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, curproc) -#define unlock_super(devvp) VOP_UNLOCK(devvp, 0, curproc) +#define lock_super(devvp) vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, curthread) +#define unlock_super(devvp) VOP_UNLOCK(devvp, 0, curthread) /* * To lock a buffer, set the B_LOCKED flag and then brelse() it. To unlock, diff --git a/sys/gnu/i386/fpemul/fpu_entry.c b/sys/gnu/i386/fpemul/fpu_entry.c index 77cee77..ec75bee 100644 --- a/sys/gnu/i386/fpemul/fpu_entry.c +++ b/sys/gnu/i386/fpemul/fpu_entry.c @@ -211,10 +211,10 @@ math_emulate(struct trapframe * tframe) REENTRANT_CHECK(ON); #endif /* PARANOID */ - if ((((struct pcb *) curproc->p_addr)->pcb_flags & FP_SOFTFP) == 0) { + if ((curthread->td_pcb->pcb_flags & FP_SOFTFP) == 0) { finit(); control_word = __INITIAL_NPXCW__; - ((struct pcb *) curproc->p_addr)->pcb_flags |= FP_SOFTFP; + curthread->td_pcb->pcb_flags |= FP_SOFTFP; } FPU_info = tframe; FPU_ORIG_EIP = FPU_EIP; /* --pink-- */ @@ -232,10 +232,10 @@ math_emulate(struct trapframe * tframe) #endif FPU_lookahead = FPU_LOOKAHEAD; - PROC_LOCK(curproc); + PROC_LOCK(curthread->td_proc); if (curproc->p_flag & P_TRACED) FPU_lookahead = 0; - PROC_UNLOCK(curproc); + PROC_UNLOCK(curthread->td_proc); do_another_FPU_instruction: diff --git a/sys/gnu/i386/fpemul/fpu_system.h b/sys/gnu/i386/fpemul/fpu_system.h index a77f0c2..f4927c8 100644 --- a/sys/gnu/i386/fpemul/fpu_system.h +++ b/sys/gnu/i386/fpemul/fpu_system.h @@ -69,7 +69,7 @@ #include <linux/kernel.h> */ -#define I387 (*(union i387_union *)&(((struct pcb *)curproc->p_addr)->pcb_save.sv_87)) +#define I387 (*(union i387_union *)&(curthread->td_pcb->pcb_save.sv_87)) #define FPU_info (I387.soft.frame) #define FPU_CS (*(unsigned short *) &(FPU_info->tf_cs)) diff --git a/sys/i386/apm/apm.c b/sys/i386/apm/apm.c index 4d8f188..1b7cbc5 100644 --- a/sys/i386/apm/apm.c +++ b/sys/i386/apm/apm.c @@ -1047,7 +1047,7 @@ apm_attach(device_t dev) } static int -apmopen(dev_t dev, int flag, int fmt, struct proc *p) +apmopen(dev_t dev, int flag, int fmt, struct thread *td) { struct apm_softc *sc = &apm_softc; int ctl = APMDEV(dev); @@ -1075,7 +1075,7 @@ apmopen(dev_t dev, int flag, int fmt, struct proc *p) } static int -apmclose(dev_t dev, int flag, int fmt, struct proc *p) +apmclose(dev_t dev, int flag, int fmt, struct thread *td) { struct apm_softc *sc = &apm_softc; int ctl = APMDEV(dev); @@ -1098,7 +1098,7 @@ apmclose(dev_t dev, int flag, int fmt, struct proc *p) } static int -apmioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +apmioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct apm_softc *sc = &apm_softc; struct apm_bios_arg *args; @@ -1282,7 +1282,7 @@ apmwrite(dev_t dev, struct uio *uio, int ioflag) } static int -apmpoll(dev_t dev, int events, struct proc *p) +apmpoll(dev_t dev, int events, struct thread *td) { struct apm_softc *sc = &apm_softc; int revents = 0; @@ -1291,7 +1291,7 @@ apmpoll(dev_t dev, int events, struct proc *p) if (sc->event_count) { revents |= events & (POLLIN | POLLRDNORM); } else { - selrecord(p, &sc->sc_rsel); + selrecord(td, &sc->sc_rsel); } } diff --git a/sys/i386/bios/apm.c b/sys/i386/bios/apm.c index 4d8f188..1b7cbc5 100644 --- a/sys/i386/bios/apm.c +++ b/sys/i386/bios/apm.c @@ -1047,7 +1047,7 @@ apm_attach(device_t dev) } static int -apmopen(dev_t dev, int flag, int fmt, struct proc *p) +apmopen(dev_t dev, int flag, int fmt, struct thread *td) { struct apm_softc *sc = &apm_softc; int ctl = APMDEV(dev); @@ -1075,7 +1075,7 @@ apmopen(dev_t dev, int flag, int fmt, struct proc *p) } static int -apmclose(dev_t dev, int flag, int fmt, struct proc *p) +apmclose(dev_t dev, int flag, int fmt, struct thread *td) { struct apm_softc *sc = &apm_softc; int ctl = APMDEV(dev); @@ -1098,7 +1098,7 @@ apmclose(dev_t dev, int flag, int fmt, struct proc *p) } static int -apmioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +apmioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct apm_softc *sc = &apm_softc; struct apm_bios_arg *args; @@ -1282,7 +1282,7 @@ apmwrite(dev_t dev, struct uio *uio, int ioflag) } static int -apmpoll(dev_t dev, int events, struct proc *p) +apmpoll(dev_t dev, int events, struct thread *td) { struct apm_softc *sc = &apm_softc; int revents = 0; @@ -1291,7 +1291,7 @@ apmpoll(dev_t dev, int events, struct proc *p) if (sc->event_count) { revents |= events & (POLLIN | POLLRDNORM); } else { - selrecord(p, &sc->sc_rsel); + selrecord(td, &sc->sc_rsel); } } diff --git a/sys/i386/conf/NOTES b/sys/i386/conf/NOTES index 83bf89a..a707b0f 100644 --- a/sys/i386/conf/NOTES +++ b/sys/i386/conf/NOTES @@ -84,7 +84,7 @@ options BLKDEV_IOSIZE=8192 # Options for the VM subsystem options PQ_CACHESIZE=512 # color for 512k/16k cache -options UPAGES=3 # number of 4k stack pages per process +options KSTACK_PAGES=3 # number of 4k stack pages per process # Deprecated options supported for backwards compatibility #options PQ_NOOPT # No coloring #options PQ_LARGECACHE # color for 512k/16k cache @@ -442,7 +442,7 @@ options IPX #IPX/SPX communications protocols options IPXIP #IPX in IP encapsulation (not available) options IPTUNNEL #IP in IPX encapsulation (not available) -options NCP #NetWare Core protocol +#options NCP #NetWare Core protocol options NETATALK #Appletalk communications protocols options NETATALKDEBUG #Appletalk debugging @@ -692,7 +692,7 @@ options HPFS #OS/2 File system options MSDOSFS #MS DOS File System (FAT, FAT32) options NTFS #NT File System options NULLFS #NULL filesystem -options NWFS #NetWare filesystem +#options NWFS #NetWare filesystem options PORTALFS #Portal filesystem options PROCFS #Process filesystem options PSEUDOFS #Pseudo-filesystem framework diff --git a/sys/i386/i386/apic_vector.s b/sys/i386/i386/apic_vector.s index 5c68f81..8096d3c 100644 --- a/sys/i386/i386/apic_vector.s +++ b/sys/i386/i386/apic_vector.s @@ -48,10 +48,10 @@ IDTVEC(vec_name) ; \ movl $KPSEL,%eax ; \ mov %ax,%fs ; \ FAKE_MCOUNT(13*4(%esp)) ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ pushl intr_unit + (irq_num) * 4 ; \ - call *intr_handler + (irq_num) * 4 ; /* do the work ASAP */ \ + call *intr_handler + (irq_num) * 4 ; /* do the work ASAP */ \ addl $4, %esp ; \ movl $0, lapic+LA_EOI ; \ lock ; \ @@ -59,7 +59,7 @@ IDTVEC(vec_name) ; \ movl intr_countp + (irq_num) * 4, %eax ; \ lock ; \ incl (%eax) ; \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ jmp doreti @@ -152,8 +152,8 @@ IDTVEC(vec_name) ; \ MASK_LEVEL_IRQ(irq_num) ; \ EOI_IRQ(irq_num) ; \ 0: ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ ; \ /* entry point used by doreti_unpend for HWIs. */ \ __CONCAT(Xresume,irq_num): ; \ @@ -162,7 +162,7 @@ __CONCAT(Xresume,irq_num): ; \ call sched_ithd ; \ addl $4, %esp ; /* discard the parameter */ \ ; \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ jmp doreti @@ -227,10 +227,10 @@ Xhardclock: movl $0, lapic+LA_EOI /* End Of Interrupt to APIC */ - movl PCPU(CURPROC),%ebx - incl P_INTR_NESTING_LEVEL(%ebx) + movl PCPU(CURTHREAD),%ebx + incl TD_INTR_NESTING_LEVEL(%ebx) call forwarded_hardclock - decl P_INTR_NESTING_LEVEL(%ebx) + decl TD_INTR_NESTING_LEVEL(%ebx) MEXITCOUNT jmp doreti @@ -252,10 +252,10 @@ Xstatclock: movl $0, lapic+LA_EOI /* End Of Interrupt to APIC */ FAKE_MCOUNT(13*4(%esp)) - movl PCPU(CURPROC),%ebx - incl P_INTR_NESTING_LEVEL(%ebx) + movl PCPU(CURTHREAD),%ebx + incl TD_INTR_NESTING_LEVEL(%ebx) call forwarded_statclock - decl P_INTR_NESTING_LEVEL(%ebx) + decl TD_INTR_NESTING_LEVEL(%ebx) MEXITCOUNT jmp doreti diff --git a/sys/i386/i386/db_interface.c b/sys/i386/i386/db_interface.c index a2e5018..7e78088 100644 --- a/sys/i386/i386/db_interface.c +++ b/sys/i386/i386/db_interface.c @@ -351,23 +351,24 @@ DB_SHOW_COMMAND(pcpu, db_show_pcpu) gd = GLOBALDATA; #endif db_printf("cpuid = %d\n", gd->gd_cpuid); - 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("npxproc = "); - if (gd->gd_npxproc != NULL) - db_printf("%p: pid %d \"%s\"\n", gd->gd_npxproc, - gd->gd_npxproc->p_pid, gd->gd_npxproc->p_comm); + db_printf("npxthread = "); + if (gd->gd_npxthread != NULL) + db_printf("%p: pid %d \"%s\"\n", gd->gd_npxthread, + gd->gd_npxthread->td_proc->p_pid, gd->gd_npxthread->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/i386/i386/db_trace.c b/sys/i386/i386/db_trace.c index dc1e2f0..3a07050 100644 --- a/sys/i386/i386/db_trace.c +++ b/sys/i386/i386/db_trace.c @@ -291,13 +291,15 @@ db_stack_trace_cmd(addr, have_addr, count, modif) boolean_t first; struct pcb *pcb; struct proc *p; + struct thread *td; pid_t pid; if (count == -1) count = 1024; if (!have_addr) { - p = curproc; + td = curthread; + p = td->td_proc; frame = (struct i386_frame *)ddb_regs.tf_ebp; if (frame == NULL) frame = (struct i386_frame *)(ddb_regs.tf_esp - 4); @@ -310,8 +312,9 @@ db_stack_trace_cmd(addr, have_addr, count, modif) * 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; frame = (struct i386_frame *)ddb_regs.tf_ebp; if (frame == NULL) frame = (struct i386_frame *) @@ -333,7 +336,7 @@ db_stack_trace_cmd(addr, have_addr, count, modif) db_printf("pid %d swapped out\n", pid); return; } - pcb = &p->p_addr->u_pcb; + pcb = p->p_thread.td_pcb; /* XXXKSE */ frame = (struct i386_frame *)pcb->pcb_ebp; if (frame == NULL) frame = (struct i386_frame *) diff --git a/sys/i386/i386/genassym.c b/sys/i386/i386/genassym.c index 0704db7..8f4be92 100644 --- a/sys/i386/i386/genassym.c +++ b/sys/i386/i386/genassym.c @@ -37,7 +37,7 @@ * $FreeBSD$ */ -#include "opt_upages.h" +#include "opt_kstack_pages.h" #include <sys/param.h> #include <sys/systm.h> @@ -50,6 +50,7 @@ #include <sys/mutex.h> #include <sys/socket.h> #include <sys/resourcevar.h> +#include <sys/user.h> /* XXX */ #ifdef KTR_PERCPU #include <sys/ktr.h> @@ -79,21 +80,31 @@ ASSYM(P_VMSPACE, offsetof(struct proc, p_vmspace)); ASSYM(VM_PMAP, offsetof(struct vmspace, vm_pmap)); ASSYM(PM_ACTIVE, offsetof(struct pmap, pm_active)); -ASSYM(P_ADDR, offsetof(struct proc, p_addr)); -ASSYM(P_INTR_NESTING_LEVEL, offsetof(struct proc, p_intr_nesting_level)); ASSYM(P_SFLAG, offsetof(struct proc, p_sflag)); ASSYM(P_STAT, offsetof(struct proc, p_stat)); -ASSYM(P_WCHAN, offsetof(struct proc, p_wchan)); +ASSYM(P_UAREA, offsetof(struct proc, p_uarea)); + +/*ASSYM(TD_STAT, offsetof(struct thread, td__stat));*/ +ASSYM(TD_FLAGS, offsetof(struct thread, td_flags)); +ASSYM(TD_WCHAN, offsetof(struct thread, td_wchan)); +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_INTR_NESTING_LEVEL, offsetof(struct thread, td_intr_nesting_level)); + +ASSYM(KE_FLAGS, offsetof(struct kse, ke_flags)); -ASSYM(PS_ASTPENDING, PS_ASTPENDING); -ASSYM(PS_NEEDRESCHED, PS_NEEDRESCHED); +ASSYM(KEF_ASTPENDING, KEF_ASTPENDING); +ASSYM(KEF_NEEDRESCHED, KEF_NEEDRESCHED); ASSYM(SSLEEP, SSLEEP); ASSYM(SRUN, SRUN); ASSYM(V_TRAP, offsetof(struct vmmeter, v_trap)); ASSYM(V_SYSCALL, offsetof(struct vmmeter, v_syscall)); ASSYM(V_INTR, offsetof(struct vmmeter, v_intr)); -ASSYM(UPAGES, UPAGES); +/* ASSYM(UPAGES, UPAGES);*/ +ASSYM(UAREA_PAGES, UAREA_PAGES); +ASSYM(KSTACK_PAGES, KSTACK_PAGES); ASSYM(PAGE_SIZE, PAGE_SIZE); ASSYM(NPTEPG, NPTEPG); ASSYM(NPDEPG, NPDEPG); @@ -133,9 +144,7 @@ ASSYM(PCB_SAVEFPU_SIZE, sizeof(union savefpu)); ASSYM(PCB_SAVE87_SIZE, sizeof(struct save87)); ASSYM(PCB_ONFAULT, offsetof(struct pcb, pcb_onfault)); -#ifdef SMP ASSYM(PCB_SIZE, sizeof(struct pcb)); -#endif ASSYM(TF_TRAPNO, offsetof(struct trapframe, tf_trapno)); ASSYM(TF_ERR, offsetof(struct trapframe, tf_err)); @@ -166,9 +175,9 @@ ASSYM(BI_ESYMTAB, offsetof(struct bootinfo, bi_esymtab)); ASSYM(BI_KERNEND, offsetof(struct bootinfo, bi_kernend)); ASSYM(GD_SIZEOF, sizeof(struct globaldata)); ASSYM(GD_PRVSPACE, offsetof(struct globaldata, gd_prvspace)); -ASSYM(GD_CURPROC, offsetof(struct globaldata, gd_curproc)); -ASSYM(GD_NPXPROC, offsetof(struct globaldata, gd_npxproc)); -ASSYM(GD_IDLEPROC, offsetof(struct globaldata, gd_idleproc)); +ASSYM(GD_CURTHREAD, offsetof(struct globaldata, gd_curthread)); +ASSYM(GD_NPXTHREAD, offsetof(struct globaldata, gd_npxthread)); +ASSYM(GD_IDLETHREAD, offsetof(struct globaldata, gd_idlethread)); ASSYM(GD_CURPCB, offsetof(struct globaldata, gd_curpcb)); ASSYM(GD_COMMON_TSS, offsetof(struct globaldata, gd_common_tss)); ASSYM(GD_SWITCHTIME, offsetof(struct globaldata, gd_switchtime)); diff --git a/sys/i386/i386/locore.s b/sys/i386/i386/locore.s index 97a1e16..ab3dad5 100644 --- a/sys/i386/i386/locore.s +++ b/sys/i386/i386/locore.s @@ -147,9 +147,11 @@ IdlePTD: .long 0 /* phys addr of kernel PTD */ #endif KPTphys: .long 0 /* phys addr of kernel page tables */ - .globl proc0paddr -proc0paddr: .long 0 /* address of proc 0 address space */ -p0upa: .long 0 /* phys addr of proc0's UPAGES */ + .globl proc0uarea, proc0kstack +proc0uarea: .long 0 /* address of proc 0 uarea space */ +proc0kstack: .long 0 /* address of proc 0 kstack space */ +p0upa: .long 0 /* phys addr of proc0's UAREA */ +p0kpa: .long 0 /* phys addr of proc0's STACK */ vm86phystk: .long 0 /* PA of vm86/bios stack */ @@ -369,13 +371,14 @@ NON_GPROF_ENTRY(btext) /* now running relocated at KERNBASE where the system is linked to run */ begin: /* set up bootstrap stack */ - movl proc0paddr,%eax /* location of in-kernel pages */ - leal UPAGES*PAGE_SIZE(%eax),%esp /* bootstrap stack end location */ + movl proc0kstack,%eax /* location of in-kernel stack */ + /* bootstrap stack end location */ + leal (KSTACK_PAGES*PAGE_SIZE-PCB_SIZE)(%eax),%esp xorl %ebp,%ebp /* mark end of frames */ movl IdlePTD,%esi - movl %esi,PCB_CR3(%eax) + movl %esi,(KSTACK_PAGES*PAGE_SIZE-PCB_SIZE+PCB_CR3)(%eax) testl $CPUID_PGE, R(cpu_feature) jz 1f @@ -762,10 +765,15 @@ no_kernend: movl %esi,R(IdlePTD) /* Allocate UPAGES */ - ALLOCPAGES(UPAGES) + ALLOCPAGES(UAREA_PAGES) movl %esi,R(p0upa) addl $KERNBASE, %esi - movl %esi, R(proc0paddr) + movl %esi, R(proc0uarea) + + ALLOCPAGES(KSTACK_PAGES) + movl %esi,R(p0kpa) + addl $KERNBASE, %esi + movl %esi, R(proc0kstack) ALLOCPAGES(1) /* vm86/bios stack */ movl %esi,R(vm86phystk) @@ -833,7 +841,12 @@ map_read_write: /* Map proc0's UPAGES in the physical way ... */ movl R(p0upa), %eax - movl $UPAGES, %ecx + movl $(UAREA_PAGES), %ecx + fillkptphys($PG_RW) + +/* Map proc0's KSTACK in the physical way ... */ + movl R(p0kpa), %eax + movl $(KSTACK_PAGES), %ecx fillkptphys($PG_RW) /* Map ISA hole */ diff --git a/sys/i386/i386/machdep.c b/sys/i386/i386/machdep.c index e0dade2..6711515 100644 --- a/sys/i386/i386/machdep.c +++ b/sys/i386/i386/machdep.c @@ -49,7 +49,7 @@ #include "opt_msgbuf.h" #include "opt_npx.h" #include "opt_perfmon.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" /* #include "opt_userconfig.h" */ #include <sys/param.h> @@ -289,14 +289,16 @@ osendsig(catcher, sig, mask, code) struct osigframe sf; struct osigframe *fp; struct proc *p; + struct thread *td; struct sigacts *psp; struct trapframe *regs; int oonstack; - p = curproc; + td = curthread; + p = td->td_proc; PROC_LOCK_ASSERT(p, MA_OWNED); psp = p->p_sigacts; - regs = p->p_frame; + regs = td->td_frame; oonstack = sigonstack(regs->tf_esp); /* Allocate and validate space for the signal handler context. */ @@ -386,7 +388,7 @@ osendsig(catcher, sig, mask, code) if (regs->tf_eflags & PSL_VM) { /* XXX confusing names: `tf' isn't a trapframe; `regs' is. */ struct trapframe_vm86 *tf = (struct trapframe_vm86 *)regs; - struct vm86_kernel *vm86 = &p->p_addr->u_pcb.pcb_ext->ext_vm86; + struct vm86_kernel *vm86 = &td->td_pcb->pcb_ext->ext_vm86; sf.sf_siginfo.si_sc.sc_gs = tf->tf_vm86_gs; sf.sf_siginfo.si_sc.sc_fs = tf->tf_vm86_fs; @@ -409,7 +411,7 @@ osendsig(catcher, sig, mask, code) * ...Kill the process. */ PROC_LOCK(p); - sigexit(p, SIGILL); + sigexit(td, SIGILL); /* NOTREACHED */ } @@ -434,12 +436,14 @@ sendsig(catcher, sig, mask, code) { struct sigframe sf; struct proc *p; + struct thread *td; struct sigacts *psp; struct trapframe *regs; struct sigframe *sfp; int oonstack; - p = curproc; + td = curthread; + p = td->td_proc; PROC_LOCK_ASSERT(p, MA_OWNED); psp = p->p_sigacts; #ifdef COMPAT_43 @@ -448,7 +452,7 @@ sendsig(catcher, sig, mask, code) return; } #endif - regs = p->p_frame; + regs = td->td_frame; oonstack = sigonstack(regs->tf_esp); /* Save user context. */ @@ -528,7 +532,7 @@ sendsig(catcher, sig, mask, code) */ if (regs->tf_eflags & PSL_VM) { struct trapframe_vm86 *tf = (struct trapframe_vm86 *)regs; - struct vm86_kernel *vm86 = &p->p_addr->u_pcb.pcb_ext->ext_vm86; + struct vm86_kernel *vm86 = &td->td_pcb->pcb_ext->ext_vm86; sf.sf_uc.uc_mcontext.mc_gs = tf->tf_vm86_gs; sf.sf_uc.uc_mcontext.mc_fs = tf->tf_vm86_fs; @@ -561,7 +565,7 @@ sendsig(catcher, sig, mask, code) * ...Kill the process. */ PROC_LOCK(p); - sigexit(p, SIGILL); + sigexit(td, SIGILL); /* NOTREACHED */ } @@ -586,17 +590,18 @@ sendsig(catcher, sig, mask, code) */ #ifdef COMPAT_43 int -osigreturn(p, uap) - struct proc *p; +osigreturn(td, uap) + struct thread *td; struct osigreturn_args /* { struct osigcontext *sigcntxp; } */ *uap; { struct trapframe *regs; struct osigcontext *scp; + struct proc *p = td->td_proc; int eflags; - regs = p->p_frame; + regs = td->td_frame; scp = uap->sigcntxp; if (!useracc((caddr_t)scp, sizeof(*scp), VM_PROT_READ)) return (EFAULT); @@ -609,9 +614,9 @@ osigreturn(p, uap) * if pcb_ext == 0 or vm86_inited == 0, the user hasn't * set up the vm86 area, and we can't enter vm86 mode. */ - if (p->p_addr->u_pcb.pcb_ext == 0) + if (td->td_pcb->pcb_ext == 0) return (EINVAL); - vm86 = &p->p_addr->u_pcb.pcb_ext->ext_vm86; + vm86 = &td->td_pcb->pcb_ext->ext_vm86; if (vm86->vm86_inited == 0) return (EINVAL); @@ -697,12 +702,13 @@ osigreturn(p, uap) #endif int -sigreturn(p, uap) - struct proc *p; +sigreturn(td, uap) + struct thread *td; struct sigreturn_args /* { ucontext_t *sigcntxp; } */ *uap; { + struct proc *p = td->td_proc; struct trapframe *regs; ucontext_t *ucp; int cs, eflags; @@ -712,7 +718,7 @@ sigreturn(p, uap) if (!useracc((caddr_t)ucp, sizeof(struct osigcontext), VM_PROT_READ)) return (EFAULT); if (((struct osigcontext *)ucp)->sc_trapno == 0x01d516) - return (osigreturn(p, (struct osigreturn_args *)uap)); + return (osigreturn(td, (struct osigreturn_args *)uap)); /* * Since ucp is not an osigcontext but a ucontext_t, we have to * check again if all of it is accessible. A ucontext_t is @@ -724,7 +730,7 @@ sigreturn(p, uap) if (!useracc((caddr_t)ucp, sizeof(*ucp), VM_PROT_READ)) return (EFAULT); - regs = p->p_frame; + regs = td->td_frame; eflags = ucp->uc_mcontext.mc_eflags; if (eflags & PSL_VM) { struct trapframe_vm86 *tf = (struct trapframe_vm86 *)regs; @@ -734,9 +740,9 @@ sigreturn(p, uap) * if pcb_ext == 0 or vm86_inited == 0, the user hasn't * set up the vm86 area, and we can't enter vm86 mode. */ - if (p->p_addr->u_pcb.pcb_ext == 0) + if (td->td_pcb->pcb_ext == 0) return (EINVAL); - vm86 = &p->p_addr->u_pcb.pcb_ext->ext_vm86; + vm86 = &td->td_pcb->pcb_ext->ext_vm86; if (vm86->vm86_inited == 0) return (EINVAL); @@ -865,14 +871,14 @@ cpu_idle(void) * Clear registers on exec */ void -setregs(p, entry, stack, ps_strings) - struct proc *p; +setregs(td, entry, stack, ps_strings) + struct thread *td; u_long entry; u_long stack; u_long ps_strings; { - struct trapframe *regs = p->p_frame; - struct pcb *pcb = &p->p_addr->u_pcb; + struct trapframe *regs = td->td_frame; + struct pcb *pcb = td->td_pcb; if (pcb->pcb_ldt) user_ldt_free(pcb); @@ -925,7 +931,7 @@ setregs(p, entry, stack, ps_strings) * traps to the emulator (if it is done at all) mainly because * emulators don't provide an entry point for initialization. */ - p->p_addr->u_pcb.pcb_flags &= ~FP_SOFTFP; + td->td_pcb->pcb_flags &= ~FP_SOFTFP; /* * Arrange to trap the next npx or `fwait' instruction (see npx.c @@ -948,7 +954,7 @@ setregs(p, entry, stack, ps_strings) * Make sure sure edx is 0x0 on entry. Linux binaries depend * on it. */ - p->p_retval[1] = 0; + td->td_retval[1] = 0; } void @@ -1016,7 +1022,8 @@ extern int has_f00f_bug; static struct i386tss dblfault_tss; static char dblfault_stack[PAGE_SIZE]; -extern struct user *proc0paddr; +extern struct user *proc0uarea; +extern vm_offset_t proc0kstack; /* software prototypes -- in more palatable form */ @@ -1661,8 +1668,12 @@ init386(first) struct region_descriptor r_gdt, r_idt; #endif - proc0.p_addr = proc0paddr; - + proc_linkup(&proc0); + 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; atdevbase = ISA_HOLE_START + KERNBASE; metadata_missing = 0; @@ -1721,10 +1732,11 @@ init386(first) lgdt(&r_gdt); /* setup curproc so that mutexes work */ - PCPU_SET(curproc, &proc0); + + PCPU_SET(curthread, thread0); PCPU_SET(spinlocks, NULL); - LIST_INIT(&proc0.p_contested); + LIST_INIT(&thread0->td_contested); /* * Initialize mutexes. @@ -1828,8 +1840,9 @@ init386(first) initializecpu(); /* Initialize CPU registers */ /* make an initial tss so cpu can get interrupt stack on syscall! */ - PCPU_SET(common_tss.tss_esp0, - (int) proc0.p_addr + UPAGES*PAGE_SIZE - 16); + /* Note: -16 is so we can grow the trapframe if we came from vm86 */ + PCPU_SET(common_tss.tss_esp0, thread0->td_kstack + + KSTACK_PAGES * PAGE_SIZE - sizeof(struct pcb) - 16); PCPU_SET(common_tss.tss_ss0, GSEL(GDATA_SEL, SEL_KPL)); gsel_tss = GSEL(GPROC0_SEL, SEL_KPL); private_tss = 0; @@ -1884,10 +1897,10 @@ init386(first) _udatasel = LSEL(LUDATA_SEL, SEL_UPL); /* setup proc 0's pcb */ - proc0.p_addr->u_pcb.pcb_flags = 0; - proc0.p_addr->u_pcb.pcb_cr3 = (int)IdlePTD; - proc0.p_addr->u_pcb.pcb_ext = 0; - proc0.p_frame = &proc0_tf; + thread0->td_pcb->pcb_flags = 0; /* XXXKSE */ + thread0->td_pcb->pcb_cr3 = (int)IdlePTD; + thread0->td_pcb->pcb_ext = 0; + thread0->td_frame = &proc0_tf; } #if defined(I586_CPU) && !defined(NO_F00F_HACK) @@ -1930,31 +1943,26 @@ f00f_hack(void *unused) { #endif /* defined(I586_CPU) && !NO_F00F_HACK */ int -ptrace_set_pc(p, addr) - struct proc *p; - unsigned long addr; +ptrace_set_pc(struct thread *td, unsigned long addr) { - p->p_frame->tf_eip = addr; + td->td_frame->tf_eip = addr; return (0); } int -ptrace_single_step(p) - struct proc *p; +ptrace_single_step(struct thread *td) { - p->p_frame->tf_eflags |= PSL_T; + td->td_frame->tf_eflags |= PSL_T; return (0); } int -fill_regs(p, regs) - struct proc *p; - struct reg *regs; +fill_regs(struct thread *td, struct reg *regs) { struct pcb *pcb; struct trapframe *tp; - tp = p->p_frame; + tp = td->td_frame; regs->r_fs = tp->tf_fs; regs->r_es = tp->tf_es; regs->r_ds = tp->tf_ds; @@ -1970,20 +1978,18 @@ fill_regs(p, regs) regs->r_eflags = tp->tf_eflags; regs->r_esp = tp->tf_esp; regs->r_ss = tp->tf_ss; - pcb = &p->p_addr->u_pcb; + pcb = td->td_pcb; regs->r_gs = pcb->pcb_gs; return (0); } int -set_regs(p, regs) - struct proc *p; - struct reg *regs; +set_regs(struct thread *td, struct reg *regs) { struct pcb *pcb; struct trapframe *tp; - tp = p->p_frame; + tp = td->td_frame; if (!EFL_SECURE(regs->r_eflags, tp->tf_eflags) || !CS_SECURE(regs->r_cs)) return (EINVAL); @@ -2002,7 +2008,7 @@ set_regs(p, regs) tp->tf_eflags = regs->r_eflags; tp->tf_esp = regs->r_esp; tp->tf_ss = regs->r_ss; - pcb = &p->p_addr->u_pcb; + pcb = td->td_pcb; pcb->pcb_gs = regs->r_gs; return (0); } @@ -2062,45 +2068,39 @@ set_fpregs_xmm(sv_87, sv_xmm) #endif /* CPU_ENABLE_SSE */ int -fill_fpregs(p, fpregs) - struct proc *p; - struct fpreg *fpregs; +fill_fpregs(struct thread *td, struct fpreg *fpregs) { #ifdef CPU_ENABLE_SSE if (cpu_fxsr) { - fill_fpregs_xmm(&p->p_addr->u_pcb.pcb_save.sv_xmm, + fill_fpregs_xmm(&td->td_pcb->pcb_save.sv_xmm, (struct save87 *)fpregs); return (0); } #endif /* CPU_ENABLE_SSE */ - bcopy(&p->p_addr->u_pcb.pcb_save.sv_87, fpregs, sizeof *fpregs); + bcopy(&td->td_pcb->pcb_save.sv_87, fpregs, sizeof *fpregs); return (0); } int -set_fpregs(p, fpregs) - struct proc *p; - struct fpreg *fpregs; +set_fpregs(struct thread *td, struct fpreg *fpregs) { #ifdef CPU_ENABLE_SSE if (cpu_fxsr) { set_fpregs_xmm((struct save87 *)fpregs, - &p->p_addr->u_pcb.pcb_save.sv_xmm); + &td->td_pcb->pcb_save.sv_xmm); return (0); } #endif /* CPU_ENABLE_SSE */ - bcopy(fpregs, &p->p_addr->u_pcb.pcb_save.sv_87, sizeof *fpregs); + bcopy(fpregs, &td->td_pcb->pcb_save.sv_87, sizeof *fpregs); return (0); } int -fill_dbregs(p, dbregs) - struct proc *p; - struct dbreg *dbregs; +fill_dbregs(struct thread *td, struct dbreg *dbregs) { struct pcb *pcb; - if (p == NULL) { + if (td == NULL) { dbregs->dr0 = rdr0(); dbregs->dr1 = rdr1(); dbregs->dr2 = rdr2(); @@ -2109,9 +2109,8 @@ fill_dbregs(p, dbregs) dbregs->dr5 = rdr5(); dbregs->dr6 = rdr6(); dbregs->dr7 = rdr7(); - } - else { - pcb = &p->p_addr->u_pcb; + } else { + pcb = td->td_pcb; dbregs->dr0 = pcb->pcb_dr0; dbregs->dr1 = pcb->pcb_dr1; dbregs->dr2 = pcb->pcb_dr2; @@ -2125,15 +2124,13 @@ fill_dbregs(p, dbregs) } int -set_dbregs(p, dbregs) - struct proc *p; - struct dbreg *dbregs; +set_dbregs(struct thread *td, struct dbreg *dbregs) { struct pcb *pcb; int i; u_int32_t mask1, mask2; - if (p == NULL) { + if (td == NULL) { load_dr0(dbregs->dr0); load_dr1(dbregs->dr1); load_dr2(dbregs->dr2); @@ -2142,8 +2139,7 @@ set_dbregs(p, dbregs) load_dr5(dbregs->dr5); load_dr6(dbregs->dr6); load_dr7(dbregs->dr7); - } - else { + } else { /* * Don't let an illegal value for dr7 get set. Specifically, * check for undefined settings. Setting these bit patterns @@ -2155,7 +2151,7 @@ set_dbregs(p, dbregs) if ((dbregs->dr7 & mask1) == mask2) return (EINVAL); - pcb = &p->p_addr->u_pcb; + pcb = td->td_pcb; /* * Don't let a process set a breakpoint that is not within the @@ -2172,7 +2168,7 @@ set_dbregs(p, dbregs) * from within kernel mode? */ - if (suser(p) != 0) { + if (suser_td(td) != 0) { if (dbregs->dr7 & 0x3) { /* dr0 is enabled */ if (dbregs->dr0 >= VM_MAXUSER_ADDRESS) diff --git a/sys/i386/i386/math_emu.h b/sys/i386/i386/math_emu.h index 545a87d..bc28dc1 100644 --- a/sys/i386/i386/math_emu.h +++ b/sys/i386/i386/math_emu.h @@ -69,7 +69,7 @@ struct i387_struct { int32_t st_space[20]; /* 8*10 bytes for each FP-reg = 80 bytes */ }; -#define I387 (*(struct i387_struct *)&(((struct pcb *)curproc->p_addr)->pcb_save.sv_87)) +#define I387 (*(struct i387_struct *)&(curthread->td_pcb->pcb_save.sv_87)) #define SWD (*(struct swd *) &I387.swd) #define ROUNDING ((I387.cwd >> 10) & 3) #define PRECISION ((I387.cwd >> 8) & 3) diff --git a/sys/i386/i386/math_emulate.c b/sys/i386/i386/math_emulate.c index 94f32b1..e7da93e 100644 --- a/sys/i386/i386/math_emulate.c +++ b/sys/i386/i386/math_emulate.c @@ -98,8 +98,8 @@ math_emulate(struct trapframe * info) u_int32_t oldeip; /* ever used fp? */ - if ((((struct pcb *)curproc->p_addr)->pcb_flags & FP_SOFTFP) == 0) { - ((struct pcb *)curproc->p_addr)->pcb_flags |= FP_SOFTFP; + if ((curthread->td_pcb->pcb_flags & FP_SOFTFP) == 0) { + curthread->td_pcb->pcb_flags |= FP_SOFTFP; I387.cwd = 0x037f; I387.swd = 0x0000; I387.twd = 0x0000; @@ -604,7 +604,7 @@ static int __regoffset[] = { tEAX, tECX, tEDX, tEBX, tESP, tEBP, tESI, tEDI }; -#define REG(x) (((int *)curproc->p_frame)[__regoffset[(x)]]) +#define REG(x) (((int *)curthread->td_frame)[__regoffset[(x)]]) static char * sib(struct trapframe * info, int mod) diff --git a/sys/i386/i386/mem.c b/sys/i386/i386/mem.c index 5eded32..48ecff8 100644 --- a/sys/i386/i386/mem.c +++ b/sys/i386/i386/mem.c @@ -98,17 +98,17 @@ MALLOC_DEFINE(M_MEMDESC, "memdesc", "memory range descriptors"); 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)) { case 14: - p->p_frame->tf_eflags &= ~PSL_IOPL; + td->td_frame->tf_eflags &= ~PSL_IOPL; } return (0); } static int -mmopen(dev_t dev, int flags, int fmt, struct proc *p) +mmopen(dev_t dev, int flags, int fmt, struct thread *td) { int error; @@ -119,12 +119,12 @@ mmopen(dev_t dev, int flags, int fmt, struct proc *p) return (EPERM); break; case 14: - error = suser(p); + error = suser_td(td); if (error != 0) return (error); if (securelevel > 0) return (EPERM); - p->p_frame->tf_eflags |= PSL_IOPL; + td->td_frame->tf_eflags |= PSL_IOPL; break; } return (0); @@ -235,7 +235,7 @@ memmmap(dev_t dev, vm_offset_t offset, int prot) * and mem_range_attr_set. */ static int -mmioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +mmioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td) { int nd, error = 0; struct mem_range_op *mo = (struct mem_range_op *)data; diff --git a/sys/i386/i386/mp_machdep.c b/sys/i386/i386/mp_machdep.c index d912e0c..f558524 100644 --- a/sys/i386/i386/mp_machdep.c +++ b/sys/i386/i386/mp_machdep.c @@ -26,7 +26,7 @@ */ #include "opt_cpu.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" #ifdef SMP #include <machine/smptests.h> @@ -1960,8 +1960,8 @@ start_all_aps(u_int boot_addr) SMPpt[pg] = (pt_entry_t)(PG_V | PG_RW | vtophys(gd)); /* allocate and set up an idle stack data page */ - stack = (char *)kmem_alloc(kernel_map, UPAGES*PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); /* XXXKSE */ + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[pg + 1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -1977,7 +1977,7 @@ start_all_aps(u_int boot_addr) outb(CMOS_DATA, BIOS_WARM); /* 'warm-start' */ #endif - bootSTK = &SMP_prvspace[x].idlestack[UPAGES*PAGE_SIZE]; + bootSTK = &SMP_prvspace[x].idlekstack[KSTACK_PAGES * PAGE_SIZE]; bootAP = x; /* attempt to start the Application Processor */ @@ -2019,8 +2019,8 @@ start_all_aps(u_int boot_addr) */ /* Allocate and setup BSP idle stack */ - stack = (char *)kmem_alloc(kernel_map, UPAGES * PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -2241,7 +2241,7 @@ ap_init(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); /* lock against other AP's that are waking up */ @@ -2323,7 +2323,7 @@ forwarded_statclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - statclock_process(curproc, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); + statclock_process(curthread->td_kse, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } @@ -2354,7 +2354,7 @@ forwarded_hardclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - hardclock_process(curproc, TRAPF_USERMODE(&frame)); + hardclock_process(curthread, TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } diff --git a/sys/i386/i386/mptable.c b/sys/i386/i386/mptable.c index d912e0c..f558524 100644 --- a/sys/i386/i386/mptable.c +++ b/sys/i386/i386/mptable.c @@ -26,7 +26,7 @@ */ #include "opt_cpu.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" #ifdef SMP #include <machine/smptests.h> @@ -1960,8 +1960,8 @@ start_all_aps(u_int boot_addr) SMPpt[pg] = (pt_entry_t)(PG_V | PG_RW | vtophys(gd)); /* allocate and set up an idle stack data page */ - stack = (char *)kmem_alloc(kernel_map, UPAGES*PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); /* XXXKSE */ + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[pg + 1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -1977,7 +1977,7 @@ start_all_aps(u_int boot_addr) outb(CMOS_DATA, BIOS_WARM); /* 'warm-start' */ #endif - bootSTK = &SMP_prvspace[x].idlestack[UPAGES*PAGE_SIZE]; + bootSTK = &SMP_prvspace[x].idlekstack[KSTACK_PAGES * PAGE_SIZE]; bootAP = x; /* attempt to start the Application Processor */ @@ -2019,8 +2019,8 @@ start_all_aps(u_int boot_addr) */ /* Allocate and setup BSP idle stack */ - stack = (char *)kmem_alloc(kernel_map, UPAGES * PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -2241,7 +2241,7 @@ ap_init(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); /* lock against other AP's that are waking up */ @@ -2323,7 +2323,7 @@ forwarded_statclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - statclock_process(curproc, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); + statclock_process(curthread->td_kse, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } @@ -2354,7 +2354,7 @@ forwarded_hardclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - hardclock_process(curproc, TRAPF_USERMODE(&frame)); + hardclock_process(curthread, TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } diff --git a/sys/i386/i386/perfmon.c b/sys/i386/i386/perfmon.c index 2d38312..ed0b53e 100644 --- a/sys/i386/i386/perfmon.c +++ b/sys/i386/i386/perfmon.c @@ -288,7 +288,7 @@ static int writer; static int writerpmc; static int -perfmon_open(dev_t dev, int flags, int fmt, struct proc *p) +perfmon_open(dev_t dev, int flags, int fmt, struct thread *td) { if (!perfmon_cpuok) return ENXIO; @@ -305,7 +305,7 @@ perfmon_open(dev_t dev, int flags, int fmt, struct proc *p) } static int -perfmon_close(dev_t dev, int flags, int fmt, struct proc *p) +perfmon_close(dev_t dev, int flags, int fmt, struct thread *td) { if (flags & FWRITE) { int i; @@ -320,7 +320,7 @@ perfmon_close(dev_t dev, int flags, int fmt, struct proc *p) } static int -perfmon_ioctl(dev_t dev, u_long cmd, caddr_t param, int flags, struct proc *p) +perfmon_ioctl(dev_t dev, u_long cmd, caddr_t param, int flags, struct thread *td) { struct pmc *pmc; struct pmc_data *pmcd; diff --git a/sys/i386/i386/pmap.c b/sys/i386/i386/pmap.c index 3ce91ab..b41b11f 100644 --- a/sys/i386/i386/pmap.c +++ b/sys/i386/i386/pmap.c @@ -71,7 +71,7 @@ #include "opt_disable_pse.h" #include "opt_pmap.h" #include "opt_msgbuf.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" #include <sys/param.h> #include <sys/systm.h> @@ -171,7 +171,7 @@ vm_offset_t kernel_vm_end; 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; @@ -183,7 +183,7 @@ static pt_entry_t *CMAP2, *ptmmap; caddr_t CADDR1 = 0, ptvmmap = 0; static caddr_t CADDR2; static pt_entry_t *msgbufmap; -struct msgbuf *msgbufp=0; +struct msgbuf *msgbufp = 0; /* * Crashdump maps. @@ -819,7 +819,7 @@ retry: } /* - * Create the UPAGES for a new process. + * Create the Uarea stack for a new process. * This routine directly affects the fork perf for a process. */ void @@ -840,22 +840,22 @@ pmap_new_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; + /* get a kernel virtual address for the U area for this proc */ + 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 = (unsigned *)vtopte(up); - for (i = 0; i < UPAGES; i++) { + for (i = 0; i < UAREA_PAGES; i++) { /* * Get a kernel stack page */ @@ -892,7 +892,7 @@ pmap_new_proc(p) } /* - * Dispose the UPAGES for a process that has exited. + * Dispose the U-Area for a process that has exited. * This routine directly impacts the exit perf of a process. */ void @@ -906,9 +906,9 @@ pmap_dispose_proc(p) unsigned *ptek, oldpte; upobj = p->p_upages_obj; - up = (vm_offset_t)p->p_addr; + up = (vm_offset_t)p->p_uarea; ptek = (unsigned *)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?"); @@ -927,7 +927,7 @@ pmap_dispose_proc(p) } /* - * Allow the UPAGES for a process to be prejudicially paged out. + * Allow the U_AREA for a process to be prejudicially paged out. */ void pmap_swapout_proc(p) @@ -939,8 +939,8 @@ pmap_swapout_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_lookup(upobj, i); if (m == NULL) panic("pmap_swapout_proc: upage already missing?"); @@ -951,7 +951,7 @@ pmap_swapout_proc(p) } /* - * Bring the UPAGES for a specified process back in. + * Bring the U-Area for a specified process back in. */ void pmap_swapin_proc(p) @@ -963,8 +963,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) { @@ -980,6 +980,191 @@ pmap_swapin_proc(p) } } +/* + * Create the kernel stack (including pcb for i386) for a new thread. + * This routine directly affects the fork perf for a process and + * create performance for a thread. + */ +void +pmap_new_thread(td) + struct thread *td; +{ +#ifdef I386_CPU + int updateneeded = 0; +#endif + int i; + vm_object_t ksobj; + vm_page_t m; + vm_offset_t ks; + unsigned *ptek, oldpte; + + /* + * allocate object for the kstack + */ + 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 proc */ + ks = (vm_offset_t)td->td_kstack; + if (ks == 0) { + ks = kmem_alloc_nofault(kernel_map, + (KSTACK_PAGES + 1) * PAGE_SIZE); + if (ks == 0) + panic("pmap_new_thread: kstack allocation failed"); + ks += PAGE_SIZE; + td->td_kstack = ks; + } + + ptek = (unsigned *)vtopte(ks - PAGE_SIZE); + oldpte = *ptek; + *ptek = 0; + if (oldpte) { +#ifdef I386_CPU + updateneeded = 1; +#else + invlpg(ks - PAGE_SIZE); +#endif + } + ptek++; +#else + /* get a kernel virtual address for the kstack for this proc */ + ks = (vm_offset_t)td->td_kstack; + if (ks == 0) { + ks = kmem_alloc_nofault(kernel_map, KSTACK_PAGES * PAGE_SIZE); + if (ks == 0) + panic("pmap_new_thread: kstack allocation failed"); + td->td_kstack = 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) = VM_PAGE_TO_PHYS(m) | PG_RW | PG_V | pgeflag; + if (oldpte) { +#ifdef I386_CPU + updateneeded = 1; +#else + invlpg(ks + i * PAGE_SIZE); +#endif + } + + 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; + } +#ifdef I386_CPU + if (updateneeded) + invltlb(); +#endif +} + +/* + * Dispose the kernel stack for a thread that has exited. + * This routine directly impacts the exit perf of a process and thread. + */ +void +pmap_dispose_thread(td) + struct thread *td; +{ + int i; + vm_object_t ksobj; + vm_offset_t ks; + vm_page_t m; + unsigned *ptek, oldpte; + + ksobj = td->td_kstack_obj; + ks = td->td_kstack; + ptek = (unsigned *)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; +#ifndef I386_CPU + invlpg(ks + i * PAGE_SIZE); +#endif + vm_page_unwire(m, 0); + vm_page_free(m); + } +#ifdef I386_CPU + invltlb(); +#endif +} + +/* + * 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; + + 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); + } +} + /*************************************************** * Page table page management routines..... ***************************************************/ @@ -1517,7 +1702,7 @@ pmap_collect() { int i; vm_page_t m; - static int warningdone=0; + static int warningdone = 0; if (pmap_pagedaemon_waken == 0) return; @@ -2333,7 +2518,7 @@ retry: pmap->pm_stats.resident_count += size >> PAGE_SHIFT; npdes = size >> PDRSHIFT; - for(i=0;i<npdes;i++) { + for(i = 0; i < npdes; i++) { pmap->pm_pdir[ptepindex] = (pd_entry_t) (ptepa | PG_U | PG_RW | PG_V | PG_PS); ptepa += NBPDR; @@ -2444,7 +2629,7 @@ pmap_prefault(pmap, addra, entry) vm_page_t m, mpte; vm_object_t object; - if (!curproc || (pmap != vmspace_pmap(curproc->p_vmspace))) + if (!curthread || (pmap != vmspace_pmap(curthread->td_proc->p_vmspace))) return; object = entry->object.vm_object; @@ -2561,6 +2746,7 @@ pmap_copy(dst_pmap, src_pmap, dst_addr, len, src_addr) vm_offset_t pdnxt; unsigned src_frame, dst_frame; vm_page_t m; + pd_entry_t saved_pde; if (dst_addr != src_addr) return; @@ -2580,7 +2766,7 @@ pmap_copy(dst_pmap, src_pmap, dst_addr, len, src_addr) invltlb(); #endif } - + saved_pde = (pd_entry_t)((u_int32_t)APTDpde & (PG_FRAME|PG_RW | PG_V)); for(addr = src_addr; addr < end_addr; addr = pdnxt) { unsigned *src_pte, *dst_pte; vm_page_t dstmpte, srcmpte; @@ -2637,6 +2823,16 @@ pmap_copy(dst_pmap, src_pmap, dst_addr, len, src_addr) * block. */ dstmpte = pmap_allocpte(dst_pmap, addr); + if (((u_int32_t)APTDpde & PG_FRAME) != + ((u_int32_t)saved_pde & PG_FRAME)) { + APTDpde = saved_pde; +printf ("IT HAPPENNED!"); +#if defined(SMP) + cpu_invltlb(); +#else + invltlb(); +#endif + } if ((*dst_pte == 0) && (ptetemp = *src_pte)) { /* * Clear the modified and @@ -2831,7 +3027,7 @@ pmap_remove_pages(pmap, sva, eva) vm_page_t m; #ifdef PMAP_REMOVE_PAGES_CURPROC_ONLY - if (!curproc || (pmap != vmspace_pmap(curproc->p_vmspace))) { + if (!curthread || (pmap != vmspace_pmap(curthread->td_proc->p_vmspace))) { printf("warning: pmap_remove_pages called with non-current pmap\n"); return; } @@ -2839,8 +3035,8 @@ pmap_remove_pages(pmap, sva, eva) s = splvm(); for(pv = TAILQ_FIRST(&pmap->pm_pvlist); - pv; - pv = npv) { + pv; + pv = npv) { if (pv->pv_va >= eva || pv->pv_va < sva) { npv = TAILQ_NEXT(pv, pv_plist); @@ -2854,6 +3050,12 @@ pmap_remove_pages(pmap, sva, eva) #endif tpte = *pte; + if (tpte == 0) { + printf("TPTE at %p IS ZERO @ VA %08x\n", + pte, pv->pv_va); + panic("bad pte"); + } + /* * We cannot remove wired pages from a process' mapping at this time */ @@ -2861,15 +3063,19 @@ pmap_remove_pages(pmap, sva, eva) npv = TAILQ_NEXT(pv, pv_plist); continue; } - *pte = 0; m = PHYS_TO_VM_PAGE(tpte); + KASSERT(m->phys_addr == (tpte & PG_FRAME), + ("vm_page_t %p phys_addr mismatch %08x %08x", + m, m->phys_addr, tpte)); KASSERT(m < &vm_page_array[vm_page_array_size], ("pmap_remove_pages: bad tpte %x", tpte)); pv->pv_pmap->pm_stats.resident_count--; + *pte = 0; + /* * Update the vm_page_t clean and reference bits. */ @@ -2877,7 +3083,6 @@ pmap_remove_pages(pmap, sva, eva) vm_page_dirty(m); } - npv = TAILQ_NEXT(pv, pv_plist); TAILQ_REMOVE(&pv->pv_pmap->pm_pvlist, pv, pv_plist); @@ -3255,11 +3460,13 @@ pmap_mincore(pmap, addr) } void -pmap_activate(struct proc *p) +pmap_activate(struct thread *td) { + struct proc *p = td->td_proc; pmap_t pmap; + u_int32_t cr3; - pmap = vmspace_pmap(p->p_vmspace); + pmap = vmspace_pmap(td->td_proc->p_vmspace); #if defined(SMP) pmap->pm_active |= 1 << PCPU_GET(cpuid); #else @@ -3268,7 +3475,20 @@ pmap_activate(struct proc *p) #if defined(SWTCH_OPTIM_STATS) tlb_flush_count++; #endif - load_cr3(p->p_addr->u_pcb.pcb_cr3 = vtophys(pmap->pm_pdir)); + cr3 = vtophys(pmap->pm_pdir); + /* XXXKSE this is wrong. + * pmap_activate is for the current thread on the current cpu + */ + if (p->p_flag & P_KSES) { + /* Make sure all other cr3 entries are updated. */ + /* what if they are running? XXXKSE (maybe abort them) */ + FOREACH_THREAD_IN_PROC(p, td) { + td->td_pcb->pcb_cr3 = cr3; + } + } else { + td->td_pcb->pcb_cr3 = cr3; + } + load_cr3(cr3); } vm_offset_t @@ -3301,14 +3521,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; unsigned *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/i386/i386/procfs_machdep.c b/sys/i386/i386/procfs_machdep.c index f951b0f..e8440b1 100644 --- a/sys/i386/i386/procfs_machdep.c +++ b/sys/i386/i386/procfs_machdep.c @@ -87,7 +87,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); \ @@ -96,39 +96,39 @@ } 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)); } int -procfs_read_dbregs(p, dbregs) - struct proc *p; +procfs_read_dbregs(td, dbregs) + struct thread *td; struct dbreg *dbregs; { - PROCFS_ACTION(fill_dbregs(p, dbregs)); + PROCFS_ACTION(fill_dbregs(td, dbregs)); } int -procfs_write_dbregs(p, dbregs) - struct proc *p; +procfs_write_dbregs(td, dbregs) + struct thread *td; struct dbreg *dbregs; { - PROCFS_ACTION(set_dbregs(p, dbregs)); + PROCFS_ACTION(set_dbregs(td, dbregs)); } /* @@ -137,27 +137,27 @@ procfs_write_dbregs(p, dbregs) */ 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; { - PROCFS_ACTION(ptrace_single_step(p)); + PROCFS_ACTION(ptrace_single_step(td)); } diff --git a/sys/i386/i386/support.s b/sys/i386/i386/support.s index 55bc29c..81181cc 100644 --- a/sys/i386/i386/support.s +++ b/sys/i386/i386/support.s @@ -216,8 +216,8 @@ ENTRY(i586_bzero) * complicated since we avoid it if possible at all levels. We * want to localize the complications even when that increases them. * Here the extra work involves preserving CR0_TS in TS. - * `npxproc != NULL' is supposed to be the condition that all the - * FPU resources belong to an application, but npxproc and CR0_TS + * `npxthread != NULL' is supposed to be the condition that all the + * FPU resources belong to an application, but npxthread and CR0_TS * aren't set atomically enough for this condition to work in * interrupt handlers. * @@ -241,7 +241,7 @@ ENTRY(i586_bzero) * method. CR0_TS must be preserved although it is very likely to * always end up as clear. */ - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bz1 /* @@ -303,7 +303,7 @@ fpureg_i586_bzero_loop: cmpl $8,%ecx jae fpureg_i586_bzero_loop - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bz3 /* XXX check that the condition for cases 1-2 stayed false. */ @@ -517,7 +517,7 @@ ENTRY(i586_bcopy) sarb $1,kernel_fpu_lock jc small_i586_bcopy - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bc1 /* XXX turn off handling of cases 1-2, as above. */ @@ -593,7 +593,7 @@ large_i586_bcopy_loop: cmpl $64,%ecx jae 4b - cmpl $0,PCPU(NPXPROC) + cmpl $0,PCPU(NPXTHREAD) je i586_bc2 /* XXX check that the condition for cases 1-2 stayed false. */ @@ -991,14 +991,14 @@ ENTRY(fastmove) /* XXX grab FPU context atomically. */ cli -/* if (npxproc != NULL) { */ - cmpl $0,PCPU(NPXPROC) +/* if (npxthread != NULL) { */ + cmpl $0,PCPU(NPXTHREAD) je 6f /* fnsave(&curpcb->pcb_savefpu); */ movl PCPU(CURPCB),%eax fnsave PCB_SAVEFPU(%eax) -/* npxproc = NULL; */ - movl $0,PCPU(NPXPROC) +/* NPXTHREAD = NULL; */ + movl $0,PCPU(NPXTHREAD) /* } */ 6: /* now we own the FPU. */ @@ -1026,9 +1026,9 @@ ENTRY(fastmove) movl -4(%ebp),%edi /* stop_emulating(); */ clts -/* npxproc = curproc; */ - movl PCPU(CURPROC),%eax - movl %eax,PCPU(NPXPROC) +/* npxthread = curthread; */ + movl PCPU(CURTHREAD),%eax + movl %eax,PCPU(NPXTHREAD) movl PCPU(CURPCB),%eax /* XXX end of atomic FPU context grab. */ @@ -1113,8 +1113,8 @@ fastmove_loop: smsw %ax orb $CR0_TS,%al lmsw %ax -/* npxproc = NULL; */ - movl $0,PCPU(NPXPROC) +/* npxthread = NULL; */ + movl $0,PCPU(NPXTHREAD) /* XXX end of atomic FPU context ungrab. */ sti @@ -1154,7 +1154,7 @@ fastmove_fault: smsw %ax orb $CR0_TS,%al lmsw %ax - movl $0,PCPU(NPXPROC) + movl $0,PCPU(NPXTHREAD) /* XXX end of atomic FPU context ungrab. */ sti diff --git a/sys/i386/i386/swtch.s b/sys/i386/i386/swtch.s index 0f2f7a8..075aa36 100644 --- a/sys/i386/i386/swtch.s +++ b/sys/i386/i386/swtch.s @@ -77,17 +77,17 @@ ENTRY(cpu_throw) ENTRY(cpu_switch) /* switch to new process. first, save context as needed */ - movl PCPU(CURPROC),%ecx + movl PCPU(CURTHREAD),%ecx /* if no process to save, don't bother */ testl %ecx,%ecx jz sw1 - - movl P_VMSPACE(%ecx), %edx + movl TD_PROC(%ecx), %eax + movl P_VMSPACE(%eax), %edx movl PCPU(CPUID), %eax btrl %eax, VM_PMAP+PM_ACTIVE(%edx) - movl P_ADDR(%ecx),%edx + movl TD_PCB(%ecx),%edx movl (%esp),%eax /* Hardware registers */ movl %eax,PCB_EIP(%edx) @@ -124,7 +124,7 @@ ENTRY(cpu_switch) #ifdef DEV_NPX /* have we used fp, and need a save? */ - cmpl %ecx,PCPU(NPXPROC) + cmpl %ecx,PCPU(NPXTHREAD) jne 1f addl $PCB_SAVEFPU,%edx /* h/w bugs make saving complicated */ pushl %edx @@ -133,7 +133,11 @@ ENTRY(cpu_switch) 1: #endif /* DEV_NPX */ +/*##########################################################################*/ +/*##########################################################################*/ +/*##########################################################################*/ /* save is done, now choose a new process */ + /* But still trashing space above the old "Top Of Stack".. */ sw1: #ifdef SMP @@ -143,17 +147,17 @@ sw1: cmpl $0,PCPU(CPUID) je 1f - movl PCPU(IDLEPROC), %eax - jmp sw1b + movl PCPU(IDLETHREAD), %eax + jmp sw1b /* Idle thread can run on any kernel context */ 1: #endif /* - * Choose a new process to schedule. chooseproc() returns idleproc + * Choose a new process to schedule. choosethread() returns idleproc * if it cannot find another process to run. */ sw1a: - call chooseproc /* trash ecx, edx, ret eax*/ + call choosethread /* trash ecx, edx, ret eax*/ #ifdef INVARIANTS testl %eax,%eax /* no process? */ @@ -163,15 +167,20 @@ sw1b: movl %eax,%ecx #ifdef INVARIANTS - cmpb $SRUN,P_STAT(%ecx) + movl TD_PROC(%ecx), %eax /* XXXKSE */ + cmpb $SRUN,P_STAT(%eax) jne badsw2 #endif - movl P_ADDR(%ecx),%edx + movl TD_PCB(%ecx),%edx #if defined(SWTCH_OPTIM_STATS) incl swtch_optim_stats #endif + +/*##########################################################################*/ +/*##########################################################################*/ +/*##########################################################################*/ /* switch address space */ movl %cr3,%ebx cmpl PCB_CR3(%edx),%ebx @@ -181,9 +190,8 @@ sw1b: incl tlb_flush_count #endif movl PCB_CR3(%edx),%ebx - movl %ebx,%cr3 + movl %ebx,%cr3 /* LOAD NEW PAGE TABLES */ 4: - movl PCPU(CPUID), %esi cmpl $0, PCB_EXT(%edx) /* has pcb extension? */ je 1f @@ -191,12 +199,9 @@ sw1b: movl PCB_EXT(%edx), %edi /* new tss descriptor */ jmp 2f 1: - /* update common_tss.tss_esp0 pointer */ - movl %edx, %ebx /* pcb */ - addl $(UPAGES * PAGE_SIZE - 16), %ebx - movl %ebx, PCPU(COMMON_TSS) + TSS_ESP0 - + /* esp points to base of usable stack */ + movl %edx, PCPU(COMMON_TSS) + TSS_ESP0 /* stack is below pcb */ btrl %esi, private_tss jae 3f PCPU_ADDR(COMMON_TSSD, %edi) @@ -210,7 +215,9 @@ sw1b: movl $GPROC0_SEL*8, %esi /* GSEL(entry, SEL_KPL) */ ltr %si 3: - movl P_VMSPACE(%ecx), %ebx + /* note in a vmspace that this cpu is using it */ + movl TD_PROC(%ecx),%eax /* get proc from thread XXXKSE */ + movl P_VMSPACE(%eax), %ebx /* get vmspace of proc */ movl PCPU(CPUID), %eax btsl %eax, VM_PMAP+PM_ACTIVE(%ebx) @@ -233,22 +240,23 @@ sw1b: #endif /** GRAB_LOPRIO */ #endif /* SMP */ movl %edx, PCPU(CURPCB) - movl %ecx, PCPU(CURPROC) /* into next process */ + movl %ecx, PCPU(CURTHREAD) /* into next process */ #ifdef SMP /* XXX FIXME: we should be restoring the local APIC TPR */ #endif /* SMP */ - cmpl $0, PCB_USERLDT(%edx) - jnz 1f - movl _default_ldt,%eax - cmpl PCPU(CURRENTLDT),%eax - je 2f - lldt _default_ldt - movl %eax,PCPU(CURRENTLDT) + cmpl $0, PCB_USERLDT(%edx) /* if there is one */ + jnz 1f /* then use it */ + movl _default_ldt,%eax /* We will use the default */ + cmpl PCPU(CURRENTLDT),%eax /* check to see if already loaded */ + je 2f /* if so skip reload */ + lldt _default_ldt /* load the default... we trust it. */ + movl %eax,PCPU(CURRENTLDT) /* store what we have */ jmp 2f -1: pushl %edx - call set_user_ldt + +1: pushl %edx /* call a non-trusting routine */ + call set_user_ldt /* to check and load the ldt */ popl %edx 2: @@ -275,7 +283,7 @@ cpu_switch_load_gs: andl $0x0000fc00,%eax /* reserved bits */ pushl %ebx movl PCB_DR7(%edx),%ebx - andl $~0x0000fc00,%ebx + andl $~0x0000fc00,%ebx /* re-enable the restored watchpoints */ orl %ebx,%eax popl %ebx movl %eax,%dr7 @@ -322,25 +330,25 @@ ENTRY(savectx) #ifdef DEV_NPX /* - * If npxproc == NULL, then the npx h/w state is irrelevant and the + * If npxthread == NULL, then the npx h/w state is irrelevant and the * state had better already be in the pcb. This is true for forks * but not for dumps (the old book-keeping with FP flags in the pcb * always lost for dumps because the dump pcb has 0 flags). * - * If npxproc != NULL, then we have to save the npx h/w state to - * npxproc's pcb and copy it to the requested pcb, or save to the + * If npxthread != NULL, then we have to save the npx h/w state to + * npxthread's pcb and copy it to the requested pcb, or save to the * requested pcb and reload. Copying is easier because we would * have to handle h/w bugs for reloading. We used to lose the * parent's npx state for forks by forgetting to reload. */ pushfl cli - movl PCPU(NPXPROC),%eax + movl PCPU(NPXTHREAD),%eax testl %eax,%eax je 1f pushl %ecx - movl P_ADDR(%eax),%eax + movl TD_PCB(%eax),%eax leal PCB_SAVEFPU(%eax),%eax pushl %eax pushl %eax diff --git a/sys/i386/i386/sys_machdep.c b/sys/i386/i386/sys_machdep.c index 23c1cdd..acca4e7 100644 --- a/sys/i386/i386/sys_machdep.c +++ b/sys/i386/i386/sys_machdep.c @@ -35,7 +35,7 @@ * */ -#include "opt_upages.h" +#include "opt_kstack_pages.h" #include <sys/param.h> #include <sys/systm.h> @@ -65,10 +65,10 @@ -static int i386_get_ldt __P((struct proc *, char *)); -static int i386_set_ldt __P((struct proc *, char *)); -static int i386_get_ioperm __P((struct proc *, char *)); -static int i386_set_ioperm __P((struct proc *, char *)); +static int i386_get_ldt __P((struct thread *, char *)); +static int i386_set_ldt __P((struct thread *, char *)); +static int i386_get_ioperm __P((struct thread *, char *)); +static int i386_set_ioperm __P((struct thread *, char *)); #ifdef SMP static void set_user_ldt_rv __P((struct pcb *)); #endif @@ -81,28 +81,28 @@ struct sysarch_args { #endif int -sysarch(p, uap) - struct proc *p; +sysarch(td, uap) + struct thread *td; register struct sysarch_args *uap; { int error = 0; switch(uap->op) { case I386_GET_LDT: - error = i386_get_ldt(p, uap->parms); + error = i386_get_ldt(td, uap->parms); break; case I386_SET_LDT: - error = i386_set_ldt(p, uap->parms); + error = i386_set_ldt(td, uap->parms); break; case I386_GET_IOPERM: - error = i386_get_ioperm(p, uap->parms); + error = i386_get_ioperm(td, uap->parms); break; case I386_SET_IOPERM: - error = i386_set_ioperm(p, uap->parms); + error = i386_set_ioperm(td, uap->parms); break; case I386_VM86: - error = vm86_sysarch(p, uap->parms); + error = vm86_sysarch(td, uap->parms); break; default: error = EOPNOTSUPP; @@ -112,7 +112,7 @@ sysarch(p, uap) } int -i386_extend_pcb(struct proc *p) +i386_extend_pcb(struct thread *td) { int i, offset; u_long *addr; @@ -127,12 +127,18 @@ i386_extend_pcb(struct proc *p) 0, /* default 32 size */ 0 /* granularity */ }; + struct proc *p = td->td_proc; + if (td->td_proc->p_flag & P_KSES) + return (EINVAL); /* XXXKSE */ +/* XXXKSE All the code below only works in 1:1 needs changing */ ext = (struct pcb_ext *)kmem_alloc(kernel_map, ctob(IOPAGES+1)); if (ext == 0) return (ENOMEM); bzero(ext, sizeof(struct pcb_ext)); - ext->ext_tss.tss_esp0 = (unsigned)p->p_addr + ctob(UPAGES) - 16; + /* -16 is so we can convert a trapframe into vm86trapframe inplace */ + ext->ext_tss.tss_esp0 = td->td_kstack + ctob(KSTACK_PAGES) - + sizeof(struct pcb) - 16; ext->ext_tss.tss_ss0 = GSEL(GDATA_SEL, SEL_KPL); /* * The last byte of the i/o map must be followed by an 0xff byte. @@ -153,21 +159,21 @@ i386_extend_pcb(struct proc *p) ssd.ssd_limit -= ((unsigned)&ext->ext_tss - (unsigned)ext); ssdtosd(&ssd, &ext->ext_tssd); - KASSERT(p == curproc, ("giving a TSS to non-curproc")); - KASSERT(p->p_addr->u_pcb.pcb_ext == 0, ("already have a TSS!")); + KASSERT(p == curthread->td_proc, ("giving a TSS to non-curproc")); + KASSERT(td->td_pcb->pcb_ext == 0, ("already have a TSS!")); mtx_lock_spin(&sched_lock); - p->p_addr->u_pcb.pcb_ext = ext; + td->td_pcb->pcb_ext = ext; /* switch to the new TSS after syscall completes */ - p->p_sflag |= PS_NEEDRESCHED; + td->td_kse->ke_flags |= KEF_NEEDRESCHED; mtx_unlock_spin(&sched_lock); return 0; } static int -i386_set_ioperm(p, args) - struct proc *p; +i386_set_ioperm(td, args) + struct thread *td; char *args; { int i, error; @@ -177,7 +183,7 @@ i386_set_ioperm(p, args) if ((error = copyin(args, &ua, sizeof(struct i386_ioperm_args))) != 0) return (error); - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) return (error); if (securelevel > 0) return (EPERM); @@ -188,10 +194,10 @@ i386_set_ioperm(p, args) * cause confusion. This probably requires a global 'usage registry'. */ - if (p->p_addr->u_pcb.pcb_ext == 0) - if ((error = i386_extend_pcb(p)) != 0) + if (td->td_pcb->pcb_ext == 0) + if ((error = i386_extend_pcb(td)) != 0) return (error); - iomap = (char *)p->p_addr->u_pcb.pcb_ext->ext_iomap; + iomap = (char *)td->td_pcb->pcb_ext->ext_iomap; if (ua.start + ua.length > IOPAGES * PAGE_SIZE * NBBY) return (EINVAL); @@ -206,8 +212,8 @@ i386_set_ioperm(p, args) } static int -i386_get_ioperm(p, args) - struct proc *p; +i386_get_ioperm(td, args) + struct thread *td; char *args; { int i, state, error; @@ -219,12 +225,12 @@ i386_get_ioperm(p, args) if (ua.start >= IOPAGES * PAGE_SIZE * NBBY) return (EINVAL); - if (p->p_addr->u_pcb.pcb_ext == 0) { + if (td->td_pcb->pcb_ext == 0) { ua.length = 0; goto done; } - iomap = (char *)p->p_addr->u_pcb.pcb_ext->ext_iomap; + iomap = (char *)td->td_pcb->pcb_ext->ext_iomap; i = ua.start; state = (iomap[i >> 3] >> (i & 7)) & 1; @@ -351,12 +357,12 @@ user_ldt_free(struct pcb *pcb) } static int -i386_get_ldt(p, args) - struct proc *p; +i386_get_ldt(td, args) + struct thread *td; char *args; { int error = 0; - struct pcb *pcb = &p->p_addr->u_pcb; + struct pcb *pcb = td->td_pcb; struct pcb_ldt *pcb_ldt = pcb->pcb_ldt; int nldt, num; union descriptor *lp; @@ -388,19 +394,19 @@ i386_get_ldt(p, args) error = copyout(lp, uap->descs, num * sizeof(union descriptor)); if (!error) - p->p_retval[0] = num; + td->td_retval[0] = num; return(error); } static int -i386_set_ldt(p, args) - struct proc *p; +i386_set_ldt(td, args) + struct thread *td; char *args; { int error = 0, i, n; int largest_ld; - struct pcb *pcb = &p->p_addr->u_pcb; + struct pcb *pcb = td->td_pcb; struct pcb_ldt *pcb_ldt = pcb->pcb_ldt; struct i386_ldt_args ua, *uap = &ua; caddr_t old_ldt_base; @@ -530,7 +536,7 @@ i386_set_ldt(p, args) &((union descriptor *)(pcb_ldt->ldt_base))[uap->start], uap->num * sizeof(union descriptor)); if (!error) - p->p_retval[0] = uap->start; + td->td_retval[0] = uap->start; critical_exit(savecrit); return(error); diff --git a/sys/i386/i386/trap.c b/sys/i386/i386/trap.c index 4e72f9b..ee036c2 100644 --- a/sys/i386/i386/trap.c +++ b/sys/i386/i386/trap.c @@ -173,7 +173,8 @@ void trap(frame) struct trapframe frame; { - struct proc *p = curproc; + struct thread *td = curthread; + struct proc *p = td->td_proc; u_int sticks = 0; int i = 0, ucode = 0, type, code; vm_offset_t eva; @@ -225,8 +226,8 @@ restart: ((frame.tf_eflags & PSL_VM) && !in_vm86call)) { /* user trap */ - sticks = p->p_sticks; - p->p_frame = &frame; + sticks = td->td_kse->ke_sticks; + td->td_frame = &frame; switch (type) { case T_PRIVINFLT: /* privileged instruction fault */ @@ -444,7 +445,7 @@ restart: if (in_vm86call) break; - if (p->p_intr_nesting_level != 0) + if (td->td_intr_nesting_level != 0) break; /* @@ -620,7 +621,7 @@ restart: #endif user: - userret(p, &frame, sticks); + userret(td, &frame, sticks); if (mtx_owned(&Giant)) /* XXX why would Giant be owned here? */ mtx_unlock(&Giant); out: @@ -660,7 +661,7 @@ trap_pfault(frame, usermode, eva) if (p == NULL || (!usermode && va < VM_MAXUSER_ADDRESS && - (p->p_intr_nesting_level != 0 || + (td->td_intr_nesting_level != 0 || PCPU_GET(curpcb) == NULL || PCPU_GET(curpcb)->pcb_onfault == NULL))) { trap_fatal(frame, eva); @@ -696,7 +697,7 @@ trap_pfault(frame, usermode, eva) * a growable stack region, or if the stack * growth succeeded. */ - if (!grow_stack (p, va)) + if (!grow_stack (td, va)) rv = KERN_FAILURE; else /* Fault in the user page: */ @@ -728,7 +729,7 @@ trap_pfault(frame, usermode, eva) return (0); nogo: if (!usermode) { - if (p->p_intr_nesting_level == 0 && + if (td->td_intr_nesting_level == 0 && PCPU_GET(curpcb) != NULL && PCPU_GET(curpcb)->pcb_onfault != NULL) { frame->tf_eip = (int)PCPU_GET(curpcb)->pcb_onfault; @@ -756,7 +757,8 @@ trap_pfault(frame, usermode, eva) vm_map_t map = 0; int rv = 0; vm_prot_t ftype; - struct proc *p = curproc; + struct thread *td = curthread; + struct proc *p = td->td_proc; va = trunc_page(eva); if (va >= KERNBASE) { @@ -839,7 +841,7 @@ trap_pfault(frame, usermode, eva) return (0); nogo: if (!usermode) { - if (p->p_intr_nesting_level == 0 && + if (td->td_intr_nesting_level == 0 && PCPU_GET(curpcb) != NULL && PCPU_GET(curpcb)->pcb_onfault != NULL) { frame->tf_eip = (int)PCPU_GET(curpcb)->pcb_onfault; @@ -972,6 +974,7 @@ dblfault_handler() int trapwrite(addr) unsigned addr; { + struct thread *td; struct proc *p; vm_offset_t va; struct vmspace *vm; @@ -984,7 +987,8 @@ int trapwrite(addr) if (va >= VM_MAXUSER_ADDRESS) return (1); - p = curproc; + td = curthread; + p = td->td_proc; vm = p->p_vmspace; PROC_LOCK(p); @@ -1021,7 +1025,8 @@ syscall(frame) caddr_t params; int i; struct sysent *callp; - struct proc *p = curproc; + struct thread *td = curthread; + struct proc *p = td->td_proc; u_int sticks; int error; int narg; @@ -1039,8 +1044,8 @@ syscall(frame) } #endif - sticks = p->p_sticks; - p->p_frame = &frame; + sticks = td->td_kse->ke_sticks; + td->td_frame = &frame; params = (caddr_t)frame.tf_esp + sizeof(int); code = frame.tf_eax; @@ -1109,17 +1114,17 @@ syscall(frame) ktrsyscall(p->p_tracep, code, narg, args); } #endif - p->p_retval[0] = 0; - p->p_retval[1] = frame.tf_edx; + td->td_retval[0] = 0; + td->td_retval[1] = frame.tf_edx; STOPEVENT(p, S_SCE, narg); - error = (*callp->sy_call)(p, args); + error = (*callp->sy_call)(td, args); switch (error) { case 0: - frame.tf_eax = p->p_retval[0]; - frame.tf_edx = p->p_retval[1]; + frame.tf_eax = td->td_retval[0]; + frame.tf_edx = td->td_retval[1]; frame.tf_eflags &= ~PSL_C; break; @@ -1158,11 +1163,11 @@ bad: /* * Handle reschedule and other end-of-syscall issues */ - userret(p, &frame, sticks); + userret(td, &frame, 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 @@ -1183,7 +1188,7 @@ bad: 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]); } diff --git a/sys/i386/i386/vm86.c b/sys/i386/i386/vm86.c index bf4a29a..bd7a0ca 100644 --- a/sys/i386/i386/vm86.c +++ b/sys/i386/i386/vm86.c @@ -655,10 +655,11 @@ vm86_getptr(vmc, kva, sel, off) } int -vm86_sysarch(p, args) - struct proc *p; +vm86_sysarch(td, args) + struct thread *td; char *args; { + struct proc *p = td->td_proc; int error = 0; struct i386_vm86_args ua; struct vm86_kernel *vm86; @@ -666,10 +667,10 @@ vm86_sysarch(p, args) if ((error = copyin(args, &ua, sizeof(struct i386_vm86_args))) != 0) return (error); - if (p->p_addr->u_pcb.pcb_ext == 0) - if ((error = i386_extend_pcb(p)) != 0) + if (td->td_pcb->pcb_ext == 0) + if ((error = i386_extend_pcb(td)) != 0) return (error); - vm86 = &p->p_addr->u_pcb.pcb_ext->ext_vm86; + vm86 = &td->td_pcb->pcb_ext->ext_vm86; switch (ua.sub_op) { case VM86_INIT: { diff --git a/sys/i386/i386/vm86bios.s b/sys/i386/i386/vm86bios.s index e12ac41..4cc0645 100644 --- a/sys/i386/i386/vm86bios.s +++ b/sys/i386/i386/vm86bios.s @@ -67,13 +67,13 @@ ENTRY(vm86_bioscall) #ifdef DEV_NPX pushfl cli - movl PCPU(CURPROC),%ecx - cmpl %ecx,PCPU(NPXPROC) /* do we need to save fp? */ + movl PCPU(CURTHREAD),%ecx + cmpl %ecx,PCPU(NPXTHREAD) /* do we need to save fp? */ jne 1f testl %ecx,%ecx je 1f /* no curproc/npxproc */ pushl %edx - movl P_ADDR(%ecx),%ecx + movl TD_PCB(%ecx),%ecx addl $PCB_SAVEFPU,%ecx pushl %ecx call npxsave diff --git a/sys/i386/i386/vm_machdep.c b/sys/i386/i386/vm_machdep.c index 53cedff..83ddc21 100644 --- a/sys/i386/i386/vm_machdep.c +++ b/sys/i386/i386/vm_machdep.c @@ -47,7 +47,7 @@ #endif #include "opt_reset.h" #include "opt_isa.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" #include <sys/param.h> #include <sys/systm.h> @@ -117,19 +117,24 @@ 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; { + register struct proc *p1; + struct thread *td2; struct pcb *pcb2; #ifdef DEV_NPX int savecrit; #endif + p1 = td1->td_proc; + td2 = &p2->p_thread; if ((flags & RFPROC) == 0) { if ((flags & RFMEM) == 0) { /* unshare user LDT */ - struct pcb *pcb1 = &p1->p_addr->u_pcb; + struct pcb *pcb1 = td1->td_pcb; struct pcb_ldt *pcb_ldt = pcb1->pcb_ldt; if (pcb_ldt && pcb_ldt->ldt_refcnt > 1) { pcb_ldt = user_ldt_alloc(pcb1,pcb_ldt->ldt_len); @@ -145,30 +150,32 @@ cpu_fork(p1, p2, flags) /* Ensure that p1's pcb is up to date. */ #ifdef DEV_NPX - if (p1 == curproc) - p1->p_addr->u_pcb.pcb_gs = rgs(); + if (td1 == curthread) + td1->td_pcb->pcb_gs = rgs(); savecrit = critical_enter(); - if (PCPU_GET(npxproc) == p1) - npxsave(&p1->p_addr->u_pcb.pcb_save); + if (PCPU_GET(npxthread) == td1) + npxsave(&td1->td_pcb->pcb_save); critical_exit(savecrit); #endif + /* Point the pcb to the top of the stack */ + pcb2 = (struct pcb *)(td2->td_kstack + KSTACK_PAGES * PAGE_SIZE) - 1; + td2->td_pcb = pcb2; + /* Copy p1's pcb. */ - p2->p_addr->u_pcb = p1->p_addr->u_pcb; - pcb2 = &p2->p_addr->u_pcb; + bcopy(td1->td_pcb, pcb2, sizeof(*pcb2)); /* * Create a new fresh stack for the new process. * Copy the trap frame for the return to user mode as if from a * syscall. This copies most of the user mode register values. */ - p2->p_frame = (struct trapframe *) - ((int)p2->p_addr + UPAGES * PAGE_SIZE - 16) - 1; - 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)); - p2->p_frame->tf_eax = 0; /* Child returns zero */ - p2->p_frame->tf_eflags &= ~PSL_C; /* success */ - p2->p_frame->tf_edx = 1; + td2->td_frame->tf_eax = 0; /* Child returns zero */ + td2->td_frame->tf_eflags &= ~PSL_C; /* success */ + td2->td_frame->tf_edx = 1; /* * Set registers for trampoline to user mode. Leave space for the @@ -178,8 +185,8 @@ cpu_fork(p1, p2, flags) pcb2->pcb_edi = 0; pcb2->pcb_esi = (int)fork_return; /* fork_trampoline argument */ pcb2->pcb_ebp = 0; - pcb2->pcb_esp = (int)p2->p_frame - sizeof(void *); - pcb2->pcb_ebx = (int)p2; /* fork_trampoline argument */ + pcb2->pcb_esp = (int)td2->td_frame - sizeof(void *); + pcb2->pcb_ebx = (int)td2; /* fork_trampoline argument */ pcb2->pcb_eip = (int)fork_trampoline; /*- * pcb2->pcb_dr*: cloned above. @@ -228,8 +235,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; { @@ -237,18 +244,18 @@ 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_esi = (int) func; /* function */ - p->p_addr->u_pcb.pcb_ebx = (int) arg; /* first arg */ + td->td_pcb->pcb_esi = (int) func; /* function */ + td->td_pcb->pcb_ebx = (int) arg; /* first arg */ } void -cpu_exit(p) - register struct proc *p; +cpu_exit(td) + register struct thread *td; { - struct pcb *pcb = &p->p_addr->u_pcb; + struct pcb *pcb = td->td_pcb; #ifdef DEV_NPX - npxexit(p); + npxexit(td); #endif if (pcb->pcb_ext != 0) { /* @@ -280,25 +287,29 @@ 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; { + struct proc *p = td->td_proc; int error; caddr_t tempuser; - tempuser = malloc(ctob(UPAGES), M_TEMP, M_WAITOK | M_ZERO); + tempuser = malloc(ctob(UAREA_PAGES + KSTACK_PAGES), M_TEMP, M_WAITOK | M_ZERO); if (!tempuser) return EINVAL; - bcopy(p->p_addr, tempuser, sizeof(struct user)); - bcopy(p->p_frame, - tempuser + ((caddr_t) p->p_frame - (caddr_t) p->p_addr), + bcopy(p->p_uarea, tempuser, sizeof(struct user)); +#if 0 /* XXXKSE - broken, fixme!!!!! td_frame is in kstack! */ + bcopy(td->td_frame, + tempuser + ((caddr_t) td->td_frame - (caddr_t) p->p_uarea), sizeof(struct trapframe)); +#endif - error = vn_rdwr(UIO_WRITE, vp, (caddr_t) tempuser, ctob(UPAGES), - (off_t)0, UIO_SYSSPACE, IO_UNIT, cred, (int *)NULL, p); + error = vn_rdwr(UIO_WRITE, vp, (caddr_t) tempuser, + ctob(UAREA_PAGES + KSTACK_PAGES), + (off_t)0, UIO_SYSSPACE, IO_UNIT, cred, (int *)NULL, td); free(tempuser, M_TEMP); diff --git a/sys/i386/ibcs2/ibcs2_fcntl.c b/sys/i386/ibcs2/ibcs2_fcntl.c index 971adce..6151c5d 100644 --- a/sys/i386/ibcs2/ibcs2_fcntl.c +++ b/sys/i386/ibcs2/ibcs2_fcntl.c @@ -169,73 +169,74 @@ oflags2ioflags(flags) } int -ibcs2_open(p, uap) - struct proc *p; +ibcs2_open(td, uap) + struct thread *td; struct ibcs2_open_args *uap; { + struct proc *p = td->td_proc; int noctty = SCARG(uap, flags) & IBCS2_O_NOCTTY; int ret; caddr_t sg = stackgap_init(); SCARG(uap, flags) = cvt_o_flags(SCARG(uap, flags)); if (SCARG(uap, flags) & O_CREAT) - CHECKALTCREAT(p, &sg, SCARG(uap, path)); + CHECKALTCREAT(td, &sg, SCARG(uap, path)); else - CHECKALTEXIST(p, &sg, SCARG(uap, path)); - ret = open(p, (struct open_args *)uap); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); + ret = open(td, (struct open_args *)uap); #ifdef SPX_HACK if (ret == ENXIO) { if (!strcmp(SCARG(uap, path), "/compat/ibcs2/dev/spx")) - ret = spx_open(p, uap); + ret = spx_open(td, uap); } else #endif /* SPX_HACK */ PROC_LOCK(p); if (!ret && !noctty && SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) { struct filedesc *fdp = p->p_fd; - struct file *fp = fdp->fd_ofiles[p->p_retval[0]]; + struct file *fp = fdp->fd_ofiles[td->td_retval[0]]; PROC_UNLOCK(p); /* ignore any error, just give it a try */ if (fp->f_type == DTYPE_VNODE) - fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, p); + fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, td); } else PROC_UNLOCK(p); return ret; } int -ibcs2_creat(p, uap) - struct proc *p; +ibcs2_creat(td, uap) + struct thread *td; struct ibcs2_creat_args *uap; { struct open_args cup; caddr_t sg = stackgap_init(); - CHECKALTCREAT(p, &sg, SCARG(uap, path)); + CHECKALTCREAT(td, &sg, SCARG(uap, path)); SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, mode) = SCARG(uap, mode); SCARG(&cup, flags) = O_WRONLY | O_CREAT | O_TRUNC; - return open(p, &cup); + return open(td, &cup); } int -ibcs2_access(p, uap) - struct proc *p; +ibcs2_access(td, uap) + struct thread *td; struct ibcs2_access_args *uap; { struct access_args cup; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, flags) = SCARG(uap, flags); - return access(p, &cup); + return access(td, &cup); } int -ibcs2_fcntl(p, uap) - struct proc *p; +ibcs2_fcntl(td, uap) + struct thread *td; struct ibcs2_fcntl_args *uap; { int error; @@ -248,32 +249,32 @@ ibcs2_fcntl(p, uap) SCARG(&fa, fd) = SCARG(uap, fd); SCARG(&fa, cmd) = F_DUPFD; SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg); - return fcntl(p, &fa); + return fcntl(td, &fa); case IBCS2_F_GETFD: SCARG(&fa, fd) = SCARG(uap, fd); SCARG(&fa, cmd) = F_GETFD; SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg); - return fcntl(p, &fa); + return fcntl(td, &fa); case IBCS2_F_SETFD: SCARG(&fa, fd) = SCARG(uap, fd); SCARG(&fa, cmd) = F_SETFD; SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg); - return fcntl(p, &fa); + return fcntl(td, &fa); case IBCS2_F_GETFL: SCARG(&fa, fd) = SCARG(uap, fd); SCARG(&fa, cmd) = F_GETFL; SCARG(&fa, arg) = (/* XXX */ int)SCARG(uap, arg); - error = fcntl(p, &fa); + error = fcntl(td, &fa); if (error) return error; - p->p_retval[0] = oflags2ioflags(p->p_retval[0]); + td->td_retval[0] = oflags2ioflags(td->td_retval[0]); return error; case IBCS2_F_SETFL: SCARG(&fa, fd) = SCARG(uap, fd); SCARG(&fa, cmd) = F_SETFL; SCARG(&fa, arg) = (/* XXX */ int) ioflags2oflags((int)SCARG(uap, arg)); - return fcntl(p, &fa); + return fcntl(td, &fa); case IBCS2_F_GETLK: { @@ -287,7 +288,7 @@ ibcs2_fcntl(p, uap) SCARG(&fa, fd) = SCARG(uap, fd); SCARG(&fa, cmd) = F_GETLK; SCARG(&fa, arg) = (/* XXX */ int)flp; - error = fcntl(p, &fa); + error = fcntl(td, &fa); if (error) return error; cvt_flock2iflock(flp, &ifl); @@ -308,7 +309,7 @@ ibcs2_fcntl(p, uap) SCARG(&fa, cmd) = F_SETLK; SCARG(&fa, arg) = (/* XXX */ int)flp; - return fcntl(p, &fa); + return fcntl(td, &fa); } case IBCS2_F_SETLKW: @@ -323,7 +324,7 @@ ibcs2_fcntl(p, uap) SCARG(&fa, fd) = SCARG(uap, fd); SCARG(&fa, cmd) = F_SETLKW; SCARG(&fa, arg) = (/* XXX */ int)flp; - return fcntl(p, &fa); + return fcntl(td, &fa); } } return ENOSYS; diff --git a/sys/i386/ibcs2/ibcs2_ioctl.c b/sys/i386/ibcs2/ibcs2_ioctl.c index 4dfa80b..39fdc99 100644 --- a/sys/i386/ibcs2/ibcs2_ioctl.c +++ b/sys/i386/ibcs2/ibcs2_ioctl.c @@ -57,7 +57,7 @@ static void stio2stios __P((struct ibcs2_termio *, struct ibcs2_termios *)); int -ibcs2_gtty(struct proc *p, struct ibcs2_gtty_args *args) +ibcs2_gtty(struct thread *td, struct ibcs2_gtty_args *args) { struct ioctl_args ioctl_arg; @@ -65,11 +65,11 @@ ibcs2_gtty(struct proc *p, struct ibcs2_gtty_args *args) ioctl_arg.com = TIOCGETC; ioctl_arg.data = (caddr_t)args->buf; - return ioctl(p, &ioctl_arg); + return ioctl(td, &ioctl_arg); } int -ibcs2_stty(struct proc *p, struct ibcs2_stty_args *args) +ibcs2_stty(struct thread *td, struct ibcs2_stty_args *args) { struct ioctl_args ioctl_arg; @@ -77,7 +77,7 @@ ibcs2_stty(struct proc *p, struct ibcs2_stty_args *args) ioctl_arg.com = TIOCSETC; ioctl_arg.data = (caddr_t)args->buf; - return ioctl(p, &ioctl_arg); + return ioctl(td, &ioctl_arg); } @@ -336,10 +336,11 @@ stio2stios(t, ts) } int -ibcs2_ioctl(p, uap) - struct proc *p; +ibcs2_ioctl(td, uap) + struct thread *td; struct ibcs2_ioctl_args *uap; { + struct proc *p = td->td_proc; struct filedesc *fdp = p->p_fd; struct file *fp; int error; @@ -365,7 +366,7 @@ ibcs2_ioctl(p, uap) struct ibcs2_termios sts; struct ibcs2_termio st; - if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, p)) != 0) + if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, td)) != 0) return error; btios2stios (&bts, &sts); @@ -401,7 +402,7 @@ ibcs2_ioctl(p, uap) } /* get full BSD termios so we don't lose information */ - if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, p)) != 0) { + if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, td)) != 0) { DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ", p->p_pid, SCARG(uap, fd))); return error; @@ -416,7 +417,7 @@ ibcs2_ioctl(p, uap) stios2btios(&sts, &bts); return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA, - (caddr_t)&bts, p); + (caddr_t)&bts, td); } case IBCS2_XCSETA: @@ -432,7 +433,7 @@ ibcs2_ioctl(p, uap) } stios2btios (&sts, &bts); return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA, - (caddr_t)&bts, p); + (caddr_t)&bts, td); } case IBCS2_OXCSETA: @@ -448,7 +449,7 @@ ibcs2_ioctl(p, uap) } stios2btios (&sts, &bts); return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA, - (caddr_t)&bts, p); + (caddr_t)&bts, td); } case IBCS2_TCSBRK: @@ -463,9 +464,9 @@ ibcs2_ioctl(p, uap) DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid)); return ENOSYS; case 2: - return fo_ioctl(fp, TIOCSTOP, (caddr_t)0, p); + return fo_ioctl(fp, TIOCSTOP, (caddr_t)0, td); case 3: - return fo_ioctl(fp, TIOCSTART, (caddr_t)1, p); + return fo_ioctl(fp, TIOCSTART, (caddr_t)1, td); default: return EINVAL; } @@ -488,16 +489,16 @@ ibcs2_ioctl(p, uap) default: return EINVAL; } - return fo_ioctl(fp, TIOCFLUSH, (caddr_t)&arg, p); + return fo_ioctl(fp, TIOCFLUSH, (caddr_t)&arg, td); } case IBCS2_TIOCGWINSZ: SCARG(uap, cmd) = TIOCGWINSZ; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_TIOCSWINSZ: SCARG(uap, cmd) = TIOCSWINSZ; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_TIOCGPGRP: PROC_LOCK(p); @@ -512,7 +513,7 @@ ibcs2_ioctl(p, uap) SCARG(&sa, pid) = 0; SCARG(&sa, pgid) = (int)SCARG(uap, data); - if ((error = setpgid(p, &sa)) != 0) + if ((error = setpgid(td, &sa)) != 0) return error; return 0; } @@ -548,96 +549,96 @@ ibcs2_ioctl(p, uap) case IBCS2_KDGKBMODE: /* get keyboard translation mode */ SCARG(uap, cmd) = KDGKBMODE; /* printf("ioctl KDGKBMODE = %x\n", SCARG(uap, cmd));*/ - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDSKBMODE: /* set keyboard translation mode */ SCARG(uap, cmd) = KDSKBMODE; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDMKTONE: /* sound tone */ SCARG(uap, cmd) = KDMKTONE; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDGETMODE: /* get text/graphics mode */ SCARG(uap, cmd) = KDGETMODE; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDSETMODE: /* set text/graphics mode */ SCARG(uap, cmd) = KDSETMODE; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDSBORDER: /* set ega color border */ SCARG(uap, cmd) = KDSBORDER; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDGKBSTATE: SCARG(uap, cmd) = KDGKBSTATE; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDSETRAD: SCARG(uap, cmd) = KDSETRAD; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDENABIO: /* enable direct I/O to ports */ SCARG(uap, cmd) = KDENABIO; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDDISABIO: /* disable direct I/O to ports */ SCARG(uap, cmd) = KDDISABIO; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KIOCSOUND: /* start sound generation */ SCARG(uap, cmd) = KIOCSOUND; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDGKBTYPE: /* get keyboard type */ SCARG(uap, cmd) = KDGKBTYPE; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDGETLED: /* get keyboard LED status */ SCARG(uap, cmd) = KDGETLED; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_KDSETLED: /* set keyboard LED status */ SCARG(uap, cmd) = KDSETLED; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); /* Xenix keyboard and display ioctl's from sys/kd.h -- type 'k' */ case IBCS2_GETFKEY: /* Get function key */ SCARG(uap, cmd) = GETFKEY; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_SETFKEY: /* Set function key */ SCARG(uap, cmd) = SETFKEY; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_GIO_SCRNMAP: /* Get screen output map table */ SCARG(uap, cmd) = GIO_SCRNMAP; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_PIO_SCRNMAP: /* Set screen output map table */ SCARG(uap, cmd) = PIO_SCRNMAP; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_GIO_KEYMAP: /* Get keyboard map table */ SCARG(uap, cmd) = GIO_KEYMAP; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); case IBCS2_PIO_KEYMAP: /* Set keyboard map table */ SCARG(uap, cmd) = PIO_KEYMAP; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); /* socksys */ case IBCS2_SIOCSOCKSYS: - return ibcs2_socksys(p, (struct ibcs2_socksys_args *)uap); + return ibcs2_socksys(td, (struct ibcs2_socksys_args *)uap); case IBCS2_I_NREAD: /* STREAMS */ SCARG(uap, cmd) = FIONREAD; - return ioctl(p, (struct ioctl_args *)uap); + return ioctl(td, (struct ioctl_args *)uap); default: DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ", - p->p_pid, SCARG(uap, cmd))); + td->proc->p_pid, SCARG(uap, cmd))); return ENOSYS; } return ENOSYS; diff --git a/sys/i386/ibcs2/ibcs2_ipc.c b/sys/i386/ibcs2/ibcs2_ipc.c index 2acf3d2..804f82d 100644 --- a/sys/i386/ibcs2/ibcs2_ipc.c +++ b/sys/i386/ibcs2/ibcs2_ipc.c @@ -102,14 +102,14 @@ struct msqid_ds *bp; } int -ibcs2_msgsys(p, uap) - struct proc *p; +ibcs2_msgsys(td, uap) + struct thread *td; struct ibcs2_msgsys_args *uap; { switch (SCARG(uap, which)) { case 0: /* msgget */ SCARG(uap, which) = 1; - return msgsys(p, (struct msgsys_args *)uap); + return msgsys(td, (struct msgsys_args *)uap); case 1: { /* msgctl */ int error; struct msgsys_args margs; @@ -122,7 +122,7 @@ ibcs2_msgsys(p, uap) SCARG(&margs, a3) = SCARG(uap, a3); switch (SCARG(&margs, a3)) { case IBCS2_IPC_STAT: - error = msgsys(p, &margs); + error = msgsys(td, &margs); if (!error) cvt_msqid2imsqid( (struct msqid_ds *)SCARG(&margs, a4), @@ -132,18 +132,18 @@ ibcs2_msgsys(p, uap) cvt_imsqid2msqid((struct ibcs2_msqid_ds *)SCARG(uap, a4), (struct msqid_ds *)SCARG(&margs, a4)); - return msgsys(p, &margs); + return msgsys(td, &margs); case IBCS2_IPC_RMID: - return msgsys(p, &margs); + return msgsys(td, &margs); } return EINVAL; } case 2: /* msgrcv */ SCARG(uap, which) = 3; - return msgsys(p, (struct msgsys_args *)uap); + return msgsys(td, (struct msgsys_args *)uap); case 3: /* msgsnd */ SCARG(uap, which) = 2; - return msgsys(p, (struct msgsys_args *)uap); + return msgsys(td, (struct msgsys_args *)uap); default: return EINVAL; } @@ -233,8 +233,8 @@ struct semid_ds *bp; } int -ibcs2_semsys(p, uap) - struct proc *p; +ibcs2_semsys(td, uap) + struct thread *td; struct ibcs2_semsys_args *uap; { int error; @@ -255,7 +255,7 @@ ibcs2_semsys(p, uap) sup = stackgap_alloc(&sg, sizeof(union semun)); sup->buf = sp; SCARG(uap, a5) = (int)sup; - error = semsys(p, (struct semsys_args *)uap); + error = semsys(td, (struct semsys_args *)uap); if (!error) { SCARG(uap, a5) = (int)ssu.buf; isp = stackgap_alloc(&sg, sizeof(*isp)); @@ -280,7 +280,7 @@ ibcs2_semsys(p, uap) return error; cvt_isemid2semid(isp, sp); SCARG(uap, a5) = (int)sp; - return semsys(p, (struct semsys_args *)uap); + return semsys(td, (struct semsys_args *)uap); } case IBCS2_SETVAL: { @@ -290,17 +290,17 @@ ibcs2_semsys(p, uap) sp = stackgap_alloc(&sg, sizeof(*sp)); sp->val = (int) SCARG(uap, a5); SCARG(uap, a5) = (int)sp; - return semsys(p, (struct semsys_args *)uap); + return semsys(td, (struct semsys_args *)uap); } } - return semsys(p, (struct semsys_args *)uap); + return semsys(td, (struct semsys_args *)uap); case 1: /* semget */ - return semsys(p, (struct semsys_args *)uap); + return semsys(td, (struct semsys_args *)uap); case 2: /* semop */ - return semsys(p, (struct semsys_args *)uap); + return semsys(td, (struct semsys_args *)uap); } return EINVAL; } @@ -345,15 +345,15 @@ struct shmid_ds *bp; } int -ibcs2_shmsys(p, uap) - struct proc *p; +ibcs2_shmsys(td, uap) + struct thread *td; struct ibcs2_shmsys_args *uap; { int error; switch (SCARG(uap, which)) { case 0: /* shmat */ - return shmsys(p, (struct shmsys_args *)uap); + return shmsys(td, (struct shmsys_args *)uap); case 1: /* shmctl */ switch(SCARG(uap, a3)) { @@ -366,7 +366,7 @@ ibcs2_shmsys(p, uap) isp = (struct ibcs2_shmid_ds *)SCARG(uap, a4); sp = stackgap_alloc(&sg, sizeof(*sp)); SCARG(uap, a4) = (int)sp; - error = shmsys(p, (struct shmsys_args *)uap); + error = shmsys(td, (struct shmsys_args *)uap); if (!error) { SCARG(uap, a4) = (int)isp; isp = stackgap_alloc(&sg, sizeof(*isp)); @@ -391,17 +391,17 @@ ibcs2_shmsys(p, uap) return error; cvt_ishmid2shmid(isp, sp); SCARG(uap, a4) = (int)sp; - return shmsys(p, (struct shmsys_args *)uap); + return shmsys(td, (struct shmsys_args *)uap); } } - return shmsys(p, (struct shmsys_args *)uap); + return shmsys(td, (struct shmsys_args *)uap); case 2: /* shmdt */ - return shmsys(p, (struct shmsys_args *)uap); + return shmsys(td, (struct shmsys_args *)uap); case 3: /* shmget */ - return shmsys(p, (struct shmsys_args *)uap); + return shmsys(td, (struct shmsys_args *)uap); } return EINVAL; } diff --git a/sys/i386/ibcs2/ibcs2_isc.c b/sys/i386/ibcs2/ibcs2_isc.c index 9c690c9..31ebd0a 100644 --- a/sys/i386/ibcs2/ibcs2_isc.c +++ b/sys/i386/ibcs2/ibcs2_isc.c @@ -45,9 +45,9 @@ extern struct sysent isc_sysent[]; int -ibcs2_isc(struct proc *p, struct ibcs2_isc_args *uap) +ibcs2_isc(struct thread *td, struct ibcs2_isc_args *uap) { - struct trapframe *tf = p->p_frame; + struct trapframe *tf = td->td_frame; struct sysent *callp; u_int code; @@ -55,7 +55,7 @@ ibcs2_isc(struct proc *p, struct ibcs2_isc_args *uap) callp = &isc_sysent[code]; if(code < IBCS2_ISC_MAXSYSCALL) - return((*callp->sy_call)(p, (void *)uap)); + return((*callp->sy_call)(td, (void *)uap)); else return ENOSYS; } diff --git a/sys/i386/ibcs2/ibcs2_misc.c b/sys/i386/ibcs2/ibcs2_misc.c index c2e28b9..bbe32eb 100644 --- a/sys/i386/ibcs2/ibcs2_misc.c +++ b/sys/i386/ibcs2/ibcs2_misc.c @@ -85,8 +85,8 @@ #include <i386/ibcs2/ibcs2_xenix.h> int -ibcs2_ulimit(p, uap) - struct proc *p; +ibcs2_ulimit(td, uap) + struct thread *td; struct ibcs2_ulimit_args *uap; { #ifdef notyet @@ -104,31 +104,31 @@ ibcs2_ulimit(p, uap) switch (SCARG(uap, cmd)) { case IBCS2_GETFSIZE: - p->p_retval[0] = p->p_rlimit[RLIMIT_FSIZE].rlim_cur; - if (p->p_retval[0] == -1) p->p_retval[0] = 0x7fffffff; + td->td_retval[0] = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur; + if (td->td_retval[0] == -1) td->td_retval[0] = 0x7fffffff; return 0; case IBCS2_SETFSIZE: /* XXX - fix this */ #ifdef notyet rl.rlim_cur = SCARG(uap, newlimit); sra.resource = RLIMIT_FSIZE; sra.rlp = &rl; - error = setrlimit(p, &sra); + error = setrlimit(td, &sra); if (!error) - p->p_retval[0] = p->p_rlimit[RLIMIT_FSIZE].rlim_cur; + td->td_retval[0] = td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur; else DPRINTF(("failed ")); return error; #else - p->p_retval[0] = SCARG(uap, newlimit); + td->td_retval[0] = SCARG(uap, newlimit); return 0; #endif case IBCS2_GETPSIZE: mtx_assert(&Giant, MA_OWNED); - p->p_retval[0] = p->p_rlimit[RLIMIT_RSS].rlim_cur; /* XXX */ + td->td_retval[0] = td->td_proc->p_rlimit[RLIMIT_RSS].rlim_cur; /* XXX */ return 0; case IBCS2_GETDTABLESIZE: uap->cmd = IBCS2_SC_OPEN_MAX; - return ibcs2_sysconf(p, (struct ibcs2_sysconf_args *)uap); + return ibcs2_sysconf(td, (struct ibcs2_sysconf_args *)uap); default: return ENOSYS; } @@ -137,13 +137,13 @@ ibcs2_ulimit(p, uap) #define IBCS2_WSTOPPED 0177 #define IBCS2_STOPCODE(sig) ((sig) << 8 | IBCS2_WSTOPPED) int -ibcs2_wait(p, uap) - struct proc *p; +ibcs2_wait(td, uap) + struct thread *td; struct ibcs2_wait_args *uap; { int error, status; struct wait_args w4; - struct trapframe *tf = p->p_frame; + struct trapframe *tf = td->td_frame; SCARG(&w4, rusage) = NULL; if ((tf->tf_eflags & (PSL_Z|PSL_PF|PSL_N|PSL_V)) @@ -158,7 +158,7 @@ ibcs2_wait(p, uap) SCARG(&w4, status) = (int *)SCARG(uap, a1); SCARG(&w4, options) = 0; } - if ((error = wait4(p, &w4)) != 0) + if ((error = wait4(td, &w4)) != 0) return error; if (SCARG(&w4, status)) { /* this is real iBCS brain-damage */ error = copyin((caddr_t)SCARG(&w4, status), (caddr_t)&status, @@ -175,7 +175,7 @@ ibcs2_wait(p, uap) /* else exit status -- identical */ /* record result/status */ - p->p_retval[1] = status; + td->td_retval[1] = status; return copyout((caddr_t)&status, (caddr_t)SCARG(&w4, status), sizeof(SCARG(&w4, status))); } @@ -184,45 +184,45 @@ ibcs2_wait(p, uap) } int -ibcs2_execv(p, uap) - struct proc *p; +ibcs2_execv(td, uap) + struct thread *td; struct ibcs2_execv_args *uap; { struct execve_args ea; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&ea, fname) = SCARG(uap, path); SCARG(&ea, argv) = SCARG(uap, argp); SCARG(&ea, envv) = NULL; - return execve(p, &ea); + return execve(td, &ea); } int -ibcs2_execve(p, uap) - struct proc *p; +ibcs2_execve(td, uap) + struct thread *td; struct ibcs2_execve_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); - return execve(p, (struct execve_args *)uap); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); + return execve(td, (struct execve_args *)uap); } int -ibcs2_umount(p, uap) - struct proc *p; +ibcs2_umount(td, uap) + struct thread *td; struct ibcs2_umount_args *uap; { struct unmount_args um; SCARG(&um, path) = SCARG(uap, name); SCARG(&um, flags) = 0; - return unmount(p, &um); + return unmount(td, &um); } int -ibcs2_mount(p, uap) - struct proc *p; +ibcs2_mount(td, uap) + struct thread *td; struct ibcs2_mount_args *uap; { #ifdef notyet @@ -279,7 +279,7 @@ ibcs2_mount(p, uap) if (error = copyout(&na, SCARG(uap, data), sizeof na)) return (error); } - return (mount(p, uap)); + return (mount(td, uap)); #else return EINVAL; #endif @@ -294,8 +294,8 @@ ibcs2_mount(p, uap) */ int -ibcs2_getdents(p, uap) - struct proc *p; +ibcs2_getdents(td, uap) + struct thread *td; register struct ibcs2_getdents_args *uap; { register struct vnode *vp; @@ -314,7 +314,7 @@ ibcs2_getdents(p, uap) #define BSD_DIRENT(cp) ((struct dirent *)(cp)) #define IBCS2_RECLEN(reclen) (reclen + sizeof(u_short)) - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); if ((fp->f_flag & FREAD) == 0) return (EBADF); @@ -327,7 +327,7 @@ ibcs2_getdents(p, uap) buflen = max(DIRBLKSIZ, SCARG(uap, nbytes)); buflen = min(buflen, MAXBSIZE); buf = malloc(buflen, M_TEMP, M_WAITOK); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); again: aiov.iov_base = buf; aiov.iov_len = buflen; @@ -335,7 +335,7 @@ again: auio.uio_iovcnt = 1; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_resid = buflen; auio.uio_offset = off; @@ -425,18 +425,18 @@ again: goto again; fp->f_offset = off; /* update the vnode offset */ eof: - p->p_retval[0] = SCARG(uap, nbytes) - resid; + td->td_retval[0] = SCARG(uap, nbytes) - resid; out: if (cookies) free(cookies, M_TEMP); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); free(buf, M_TEMP); return (error); } int -ibcs2_read(p, uap) - struct proc *p; +ibcs2_read(td, uap) + struct thread *td; struct ibcs2_read_args *uap; { register struct vnode *vp; @@ -456,9 +456,9 @@ ibcs2_read(p, uap) u_long *cookies = NULL, *cookiep; int ncookies; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) { + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) { if (error == EINVAL) - return read(p, (struct read_args *)uap); + return read(td, (struct read_args *)uap); else return error; } @@ -466,7 +466,7 @@ ibcs2_read(p, uap) return (EBADF); vp = (struct vnode *)fp->f_data; if (vp->v_type != VDIR) - return read(p, (struct read_args *)uap); + return read(td, (struct read_args *)uap); DPRINTF(("ibcs2_read: read directory\n")); @@ -474,7 +474,7 @@ ibcs2_read(p, uap) buflen = max(DIRBLKSIZ, SCARG(uap, nbytes)); buflen = min(buflen, MAXBSIZE); buf = malloc(buflen, M_TEMP, M_WAITOK); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); again: aiov.iov_base = buf; aiov.iov_len = buflen; @@ -482,7 +482,7 @@ again: auio.uio_iovcnt = 1; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_resid = buflen; auio.uio_offset = off; @@ -576,40 +576,40 @@ again: goto again; fp->f_offset = off; /* update the vnode offset */ eof: - p->p_retval[0] = SCARG(uap, nbytes) - resid; + td->td_retval[0] = SCARG(uap, nbytes) - resid; out: if (cookies) free(cookies, M_TEMP); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); free(buf, M_TEMP); return (error); } int -ibcs2_mknod(p, uap) - struct proc *p; +ibcs2_mknod(td, uap) + struct thread *td; struct ibcs2_mknod_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTCREAT(p, &sg, SCARG(uap, path)); + CHECKALTCREAT(td, &sg, SCARG(uap, path)); if (S_ISFIFO(SCARG(uap, mode))) { struct mkfifo_args ap; SCARG(&ap, path) = SCARG(uap, path); SCARG(&ap, mode) = SCARG(uap, mode); - return mkfifo(p, &ap); + return mkfifo(td, &ap); } else { struct mknod_args ap; SCARG(&ap, path) = SCARG(uap, path); SCARG(&ap, mode) = SCARG(uap, mode); SCARG(&ap, dev) = SCARG(uap, dev); - return mknod(p, &ap); + return mknod(td, &ap); } } int -ibcs2_getgroups(p, uap) - struct proc *p; +ibcs2_getgroups(td, uap) + struct thread *td; struct ibcs2_getgroups_args *uap; { int error, i; @@ -625,23 +625,23 @@ ibcs2_getgroups(p, uap) iset = stackgap_alloc(&sg, SCARG(uap, gidsetsize) * sizeof(ibcs2_gid_t)); } - if ((error = getgroups(p, &sa)) != 0) + if ((error = getgroups(td, &sa)) != 0) return error; if (SCARG(uap, gidsetsize) == 0) return 0; - for (i = 0, gp = SCARG(&sa, gidset); i < p->p_retval[0]; i++) + for (i = 0, gp = SCARG(&sa, gidset); i < td->td_retval[0]; i++) iset[i] = (ibcs2_gid_t)*gp++; - if (p->p_retval[0] && (error = copyout((caddr_t)iset, + if (td->td_retval[0] && (error = copyout((caddr_t)iset, (caddr_t)SCARG(uap, gidset), - sizeof(ibcs2_gid_t) * p->p_retval[0]))) + sizeof(ibcs2_gid_t) * td->td_retval[0]))) return error; return 0; } int -ibcs2_setgroups(p, uap) - struct proc *p; +ibcs2_setgroups(td, uap) + struct thread *td; struct ibcs2_setgroups_args *uap; { int error, i; @@ -663,40 +663,40 @@ ibcs2_setgroups(p, uap) } for (i = 0, gp = SCARG(&sa, gidset); i < SCARG(&sa, gidsetsize); i++) *gp++ = (gid_t)iset[i]; - return setgroups(p, &sa); + return setgroups(td, &sa); } int -ibcs2_setuid(p, uap) - struct proc *p; +ibcs2_setuid(td, uap) + struct thread *td; struct ibcs2_setuid_args *uap; { struct setuid_args sa; SCARG(&sa, uid) = (uid_t)SCARG(uap, uid); - return setuid(p, &sa); + return setuid(td, &sa); } int -ibcs2_setgid(p, uap) - struct proc *p; +ibcs2_setgid(td, uap) + struct thread *td; struct ibcs2_setgid_args *uap; { struct setgid_args sa; SCARG(&sa, gid) = (gid_t)SCARG(uap, gid); - return setgid(p, &sa); + return setgid(td, &sa); } int -ibcs2_time(p, uap) - struct proc *p; +ibcs2_time(td, uap) + struct thread *td; struct ibcs2_time_args *uap; { struct timeval tv; microtime(&tv); - p->p_retval[0] = tv.tv_sec; + td->td_retval[0] = tv.tv_sec; if (SCARG(uap, tp)) return copyout((caddr_t)&tv.tv_sec, (caddr_t)SCARG(uap, tp), sizeof(ibcs2_time_t)); @@ -705,26 +705,26 @@ ibcs2_time(p, uap) } int -ibcs2_pathconf(p, uap) - struct proc *p; +ibcs2_pathconf(td, uap) + struct thread *td; struct ibcs2_pathconf_args *uap; { SCARG(uap, name)++; /* iBCS2 _PC_* defines are offset by one */ - return pathconf(p, (struct pathconf_args *)uap); + return pathconf(td, (struct pathconf_args *)uap); } int -ibcs2_fpathconf(p, uap) - struct proc *p; +ibcs2_fpathconf(td, uap) + struct thread *td; struct ibcs2_fpathconf_args *uap; { SCARG(uap, name)++; /* iBCS2 _PC_* defines are offset by one */ - return fpathconf(p, (struct fpathconf_args *)uap); + return fpathconf(td, (struct fpathconf_args *)uap); } int -ibcs2_sysconf(p, uap) - struct proc *p; +ibcs2_sysconf(td, uap) + struct thread *td; struct ibcs2_sysconf_args *uap; { int mib[2], value, len, error; @@ -742,14 +742,14 @@ ibcs2_sysconf(p, uap) SCARG(&ga, which) = RLIMIT_NPROC; SCARG(&ga, rlp) = stackgap_alloc(&sg, sizeof(struct rlimit *)); - if ((error = getrlimit(p, &ga)) != 0) + if ((error = getrlimit(td, &ga)) != 0) return error; - p->p_retval[0] = SCARG(&ga, rlp)->rlim_cur; + td->td_retval[0] = SCARG(&ga, rlp)->rlim_cur; return 0; } case IBCS2_SC_CLK_TCK: - p->p_retval[0] = hz; + td->td_retval[0] = hz; return 0; case IBCS2_SC_NGROUPS_MAX: @@ -762,9 +762,9 @@ ibcs2_sysconf(p, uap) SCARG(&ga, which) = RLIMIT_NOFILE; SCARG(&ga, rlp) = stackgap_alloc(&sg, sizeof(struct rlimit *)); - if ((error = getrlimit(p, &ga)) != 0) + if ((error = getrlimit(td, &ga)) != 0) return error; - p->p_retval[0] = SCARG(&ga, rlp)->rlim_cur; + td->td_retval[0] = SCARG(&ga, rlp)->rlim_cur; return 0; } @@ -781,11 +781,11 @@ ibcs2_sysconf(p, uap) break; case IBCS2_SC_PASS_MAX: - p->p_retval[0] = 128; /* XXX - should we create PASS_MAX ? */ + td->td_retval[0] = 128; /* XXX - should we create PASS_MAX ? */ return 0; case IBCS2_SC_XOPEN_VERSION: - p->p_retval[0] = 2; /* XXX: What should that be? */ + td->td_retval[0] = 2; /* XXX: What should that be? */ return 0; default: @@ -800,15 +800,15 @@ ibcs2_sysconf(p, uap) SCARG(&sa, oldlenp) = &len; SCARG(&sa, new) = NULL; SCARG(&sa, newlen) = 0; - if ((error = __sysctl(p, &sa)) != 0) + if ((error = __sysctl(td, &sa)) != 0) return error; - p->p_retval[0] = value; + td->td_retval[0] = value; return 0; } int -ibcs2_alarm(p, uap) - struct proc *p; +ibcs2_alarm(td, uap) + struct thread *td; struct ibcs2_alarm_args *uap; { int error; @@ -825,18 +825,18 @@ ibcs2_alarm(p, uap) SCARG(&sa, which) = ITIMER_REAL; SCARG(&sa, itv) = itp; SCARG(&sa, oitv) = oitp; - error = setitimer(p, &sa); + error = setitimer(td, &sa); if (error) return error; if (oitp->it_value.tv_usec) oitp->it_value.tv_sec++; - p->p_retval[0] = oitp->it_value.tv_sec; + td->td_retval[0] = oitp->it_value.tv_sec; return 0; } int -ibcs2_times(p, uap) - struct proc *p; +ibcs2_times(td, uap) + struct thread *td; struct ibcs2_times_args *uap; { int error; @@ -849,29 +849,29 @@ ibcs2_times(p, uap) SCARG(&ga, who) = RUSAGE_SELF; SCARG(&ga, rusage) = ru; - error = getrusage(p, &ga); + error = getrusage(td, &ga); if (error) return error; tms.tms_utime = CONVTCK(ru->ru_utime); tms.tms_stime = CONVTCK(ru->ru_stime); SCARG(&ga, who) = RUSAGE_CHILDREN; - error = getrusage(p, &ga); + error = getrusage(td, &ga); if (error) return error; tms.tms_cutime = CONVTCK(ru->ru_utime); tms.tms_cstime = CONVTCK(ru->ru_stime); microtime(&t); - p->p_retval[0] = CONVTCK(t); + td->td_retval[0] = CONVTCK(t); return copyout((caddr_t)&tms, (caddr_t)SCARG(uap, tp), sizeof(struct tms)); } int -ibcs2_stime(p, uap) - struct proc *p; +ibcs2_stime(td, uap) + struct thread *td; struct ibcs2_stime_args *uap; { int error; @@ -884,14 +884,14 @@ ibcs2_stime(p, uap) &(SCARG(&sa, tv)->tv_sec), sizeof(long))) != 0) return error; SCARG(&sa, tv)->tv_usec = 0; - if ((error = settimeofday(p, &sa)) != 0) + if ((error = settimeofday(td, &sa)) != 0) return EPERM; return 0; } int -ibcs2_utime(p, uap) - struct proc *p; +ibcs2_utime(td, uap) + struct thread *td; struct ibcs2_utime_args *uap; { int error; @@ -899,7 +899,7 @@ ibcs2_utime(p, uap) struct timeval *tp; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&sa, path) = SCARG(uap, path); if (SCARG(uap, buf)) { struct ibcs2_utimbuf ubuf; @@ -917,12 +917,12 @@ ibcs2_utime(p, uap) tp->tv_usec = 0; } else SCARG(&sa, tptr) = NULL; - return utimes(p, &sa); + return utimes(td, &sa); } int -ibcs2_nice(p, uap) - struct proc *p; +ibcs2_nice(td, uap) + struct thread *td; struct ibcs2_nice_args *uap; { int error; @@ -930,10 +930,10 @@ ibcs2_nice(p, uap) SCARG(&sa, which) = PRIO_PROCESS; SCARG(&sa, who) = 0; - SCARG(&sa, prio) = p->p_nice + SCARG(uap, incr); - if ((error = setpriority(p, &sa)) != 0) + SCARG(&sa, prio) = td->td_ksegrp->kg_nice + SCARG(uap, incr); + if ((error = setpriority(td, &sa)) != 0) return EPERM; - p->p_retval[0] = p->p_nice; + td->td_retval[0] = td->td_ksegrp->kg_nice; return 0; } @@ -942,14 +942,15 @@ ibcs2_nice(p, uap) */ int -ibcs2_pgrpsys(p, uap) - struct proc *p; +ibcs2_pgrpsys(td, uap) + struct thread *td; struct ibcs2_pgrpsys_args *uap; { + struct proc *p = td->td_proc; switch (SCARG(uap, type)) { case 0: /* getpgrp */ PROC_LOCK(p); - p->p_retval[0] = p->p_pgrp->pg_id; + td->td_retval[0] = p->p_pgrp->pg_id; PROC_UNLOCK(p); return 0; @@ -959,9 +960,9 @@ ibcs2_pgrpsys(p, uap) SCARG(&sa, pid) = 0; SCARG(&sa, pgid) = 0; - setpgid(p, &sa); + setpgid(td, &sa); PROC_LOCK(p); - p->p_retval[0] = p->p_pgrp->pg_id; + td->td_retval[0] = p->p_pgrp->pg_id; PROC_UNLOCK(p); return 0; } @@ -972,11 +973,11 @@ ibcs2_pgrpsys(p, uap) SCARG(&sa, pid) = SCARG(uap, pid); SCARG(&sa, pgid) = SCARG(uap, pgid); - return setpgid(p, &sa); + return setpgid(td, &sa); } case 3: /* setsid */ - return setsid(p, NULL); + return setsid(td, NULL); default: return EINVAL; @@ -988,8 +989,8 @@ ibcs2_pgrpsys(p, uap) */ int -ibcs2_plock(p, uap) - struct proc *p; +ibcs2_plock(td, uap) + struct thread *td; struct ibcs2_plock_args *uap; { int error; @@ -999,7 +1000,7 @@ ibcs2_plock(p, uap) #define IBCS2_DATALOCK 4 - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) return EPERM; switch(SCARG(uap, cmd)) { case IBCS2_UNLOCK: @@ -1012,8 +1013,8 @@ ibcs2_plock(p, uap) } int -ibcs2_uadmin(p, uap) - struct proc *p; +ibcs2_uadmin(td, uap) + struct thread *td; struct ibcs2_uadmin_args *uap; { #define SCO_A_REBOOT 1 @@ -1034,7 +1035,7 @@ ibcs2_uadmin(p, uap) #define SCO_AD_GETBMAJ 0 #define SCO_AD_GETCMAJ 1 - if (suser(p)) + if (suser_td(td)) return EPERM; switch(SCARG(uap, cmd)) { @@ -1046,11 +1047,11 @@ ibcs2_uadmin(p, uap) case SCO_AD_PWRDOWN: case SCO_AD_PWRNAP: r.opt = RB_HALT; - reboot(p, &r); + reboot(td, &r); case SCO_AD_BOOT: case SCO_AD_IBOOT: r.opt = RB_AUTOBOOT; - reboot(p, &r); + reboot(td, &r); } return EINVAL; case SCO_A_REMOUNT: @@ -1064,8 +1065,8 @@ ibcs2_uadmin(p, uap) } int -ibcs2_sysfs(p, uap) - struct proc *p; +ibcs2_sysfs(td, uap) + struct thread *td; struct ibcs2_sysfs_args *uap; { #define IBCS2_GETFSIND 1 @@ -1082,102 +1083,102 @@ ibcs2_sysfs(p, uap) } int -ibcs2_unlink(p, uap) - struct proc *p; +ibcs2_unlink(td, uap) + struct thread *td; struct ibcs2_unlink_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); - return unlink(p, (struct unlink_args *)uap); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); + return unlink(td, (struct unlink_args *)uap); } int -ibcs2_chdir(p, uap) - struct proc *p; +ibcs2_chdir(td, uap) + struct thread *td; struct ibcs2_chdir_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); - return chdir(p, (struct chdir_args *)uap); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); + return chdir(td, (struct chdir_args *)uap); } int -ibcs2_chmod(p, uap) - struct proc *p; +ibcs2_chmod(td, uap) + struct thread *td; struct ibcs2_chmod_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); - return chmod(p, (struct chmod_args *)uap); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); + return chmod(td, (struct chmod_args *)uap); } int -ibcs2_chown(p, uap) - struct proc *p; +ibcs2_chown(td, uap) + struct thread *td; struct ibcs2_chown_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); - return chown(p, (struct chown_args *)uap); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); + return chown(td, (struct chown_args *)uap); } int -ibcs2_rmdir(p, uap) - struct proc *p; +ibcs2_rmdir(td, uap) + struct thread *td; struct ibcs2_rmdir_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); - return rmdir(p, (struct rmdir_args *)uap); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); + return rmdir(td, (struct rmdir_args *)uap); } int -ibcs2_mkdir(p, uap) - struct proc *p; +ibcs2_mkdir(td, uap) + struct thread *td; struct ibcs2_mkdir_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTCREAT(p, &sg, SCARG(uap, path)); - return mkdir(p, (struct mkdir_args *)uap); + CHECKALTCREAT(td, &sg, SCARG(uap, path)); + return mkdir(td, (struct mkdir_args *)uap); } int -ibcs2_symlink(p, uap) - struct proc *p; +ibcs2_symlink(td, uap) + struct thread *td; struct ibcs2_symlink_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); - CHECKALTCREAT(p, &sg, SCARG(uap, link)); - return symlink(p, (struct symlink_args *)uap); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); + CHECKALTCREAT(td, &sg, SCARG(uap, link)); + return symlink(td, (struct symlink_args *)uap); } int -ibcs2_rename(p, uap) - struct proc *p; +ibcs2_rename(td, uap) + struct thread *td; struct ibcs2_rename_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, from)); - CHECKALTCREAT(p, &sg, SCARG(uap, to)); - return rename(p, (struct rename_args *)uap); + CHECKALTEXIST(td, &sg, SCARG(uap, from)); + CHECKALTCREAT(td, &sg, SCARG(uap, to)); + return rename(td, (struct rename_args *)uap); } int -ibcs2_readlink(p, uap) - struct proc *p; +ibcs2_readlink(td, uap) + struct thread *td; struct ibcs2_readlink_args *uap; { caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); - return readlink(p, (struct readlink_args *) uap); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); + return readlink(td, (struct readlink_args *) uap); } diff --git a/sys/i386/ibcs2/ibcs2_msg.c b/sys/i386/ibcs2/ibcs2_msg.c index 6c36cf8..413859a 100644 --- a/sys/i386/ibcs2/ibcs2_msg.c +++ b/sys/i386/ibcs2/ibcs2_msg.c @@ -41,16 +41,16 @@ int -ibcs2_getmsg(p, uap) - struct proc *p; +ibcs2_getmsg(td, uap) + struct thread *td; struct ibcs2_getmsg_args *uap; { return 0; /* fake */ } int -ibcs2_putmsg(p, uap) - struct proc *p; +ibcs2_putmsg(td, uap) + struct thread *td; struct ibcs2_putmsg_args *uap; { return 0; /* fake */ @@ -58,8 +58,8 @@ ibcs2_putmsg(p, uap) int -ibcs2_poll(p, uap) - struct proc *p; +ibcs2_poll(td, uap) + struct thread *td; struct ibcs2_poll_args *uap; { int error, i; @@ -107,12 +107,12 @@ ibcs2_poll(p, uap) FD_SET(conv.fd, writefds); FD_SET(conv.fd, exceptfds); } - if ((error = select(p, &tmp_select)) != 0) + if ((error = select(td, &tmp_select)) != 0) return error; - if (p->p_retval[0] == 0) + if (td->td_retval[0] == 0) return 0; - p->p_retval[0] = 0; - for (p->p_retval[0] = 0, i = 0; i < uap->nfds; i++) { + td->td_retval[0] = 0; + for (td->td_retval[0] = 0, i = 0; i < uap->nfds; i++) { copyin(uap->fds + i*sizeof(struct ibcs2_poll), &conv, sizeof(conv)); conv.revents = 0; @@ -127,7 +127,7 @@ ibcs2_poll(p, uap) if (FD_ISSET(conv.fd, exceptfds)) conv.revents |= IBCS2_POLLERR; if (conv.revents) - ++p->p_retval[0]; + ++td->td_retval[0]; } if ((error = copyout(&conv, uap->fds + i*sizeof(struct ibcs2_poll), diff --git a/sys/i386/ibcs2/ibcs2_other.c b/sys/i386/ibcs2/ibcs2_other.c index 4f90159..2881f42 100644 --- a/sys/i386/ibcs2/ibcs2_other.c +++ b/sys/i386/ibcs2/ibcs2_other.c @@ -45,14 +45,14 @@ #define IBCS2_SECURE_SETLUID 2 int -ibcs2_secure(struct proc *p, struct ibcs2_secure_args *uap) +ibcs2_secure(struct thread *td, struct ibcs2_secure_args *uap) { switch (uap->cmd) { case IBCS2_SECURE_GETLUID: /* get login uid */ - PROC_LOCK(p); - p->p_retval[0] = p->p_ucred->cr_uid; - PROC_UNLOCK(p); + PROC_LOCK(td->td_proc); + td->td_retval[0] = td->td_proc->p_ucred->cr_uid; + PROC_UNLOCK(td->td_proc); return 0; case IBCS2_SECURE_SETLUID: /* set login uid */ @@ -66,7 +66,7 @@ ibcs2_secure(struct proc *p, struct ibcs2_secure_args *uap) } int -ibcs2_lseek(struct proc *p, register struct ibcs2_lseek_args *uap) +ibcs2_lseek(struct thread *td, register struct ibcs2_lseek_args *uap) { struct lseek_args largs; int error; @@ -74,7 +74,7 @@ ibcs2_lseek(struct proc *p, register struct ibcs2_lseek_args *uap) largs.fd = uap->fd; largs.offset = uap->offset; largs.whence = uap->whence; - error = lseek(p, &largs); + error = lseek(td, &largs); return (error); } @@ -83,7 +83,7 @@ ibcs2_lseek(struct proc *p, register struct ibcs2_lseek_args *uap) #include <sys/un.h> int -spx_open(struct proc *p, void *uap) +spx_open(struct thread *td, void *uap) { struct socket_args sock; struct connect_args conn; @@ -96,7 +96,7 @@ spx_open(struct proc *p, void *uap) sock.domain = AF_UNIX; sock.type = SOCK_STREAM; sock.protocol = 0; - error = socket(p, &sock); + error = socket(td, &sock); if (error) return error; @@ -108,17 +108,17 @@ spx_open(struct proc *p, void *uap) strlen(Xaddr->sun_path) + 1; copyout("/tmp/.X11-unix/X0", Xaddr->sun_path, 18); - conn.s = fd = p->p_retval[0]; + conn.s = fd = td->td_retval[0]; conn.name = (caddr_t)Xaddr; conn.namelen = sizeof(struct sockaddr_un); - error = connect(p, &conn); + error = connect(td, &conn); if (error) { struct close_args cl; cl.fd = fd; - close(p, &cl); + close(td, &cl); return error; } - p->p_retval[0] = fd; + td->td_retval[0] = fd; return 0; } #endif /* SPX_HACK */ diff --git a/sys/i386/ibcs2/ibcs2_proto.h b/sys/i386/ibcs2/ibcs2_proto.h index a91c96d..c7ac3df 100644 --- a/sys/i386/ibcs2/ibcs2_proto.h +++ b/sys/i386/ibcs2/ibcs2_proto.h @@ -15,6 +15,8 @@ struct proc; +struct thread; + #define PAD_(t) (sizeof(register_t) <= sizeof(t) ? \ 0 : sizeof(register_t) - sizeof(t)) @@ -273,62 +275,62 @@ struct ibcs2_readlink_args { struct ibcs2_isc_args { register_t dummy; }; -int ibcs2_read __P((struct proc *, struct ibcs2_read_args *)); -int ibcs2_open __P((struct proc *, struct ibcs2_open_args *)); -int ibcs2_wait __P((struct proc *, struct ibcs2_wait_args *)); -int ibcs2_creat __P((struct proc *, struct ibcs2_creat_args *)); -int ibcs2_unlink __P((struct proc *, struct ibcs2_unlink_args *)); -int ibcs2_execv __P((struct proc *, struct ibcs2_execv_args *)); -int ibcs2_chdir __P((struct proc *, struct ibcs2_chdir_args *)); -int ibcs2_time __P((struct proc *, struct ibcs2_time_args *)); -int ibcs2_mknod __P((struct proc *, struct ibcs2_mknod_args *)); -int ibcs2_chmod __P((struct proc *, struct ibcs2_chmod_args *)); -int ibcs2_chown __P((struct proc *, struct ibcs2_chown_args *)); -int ibcs2_stat __P((struct proc *, struct ibcs2_stat_args *)); -int ibcs2_lseek __P((struct proc *, struct ibcs2_lseek_args *)); -int ibcs2_mount __P((struct proc *, struct ibcs2_mount_args *)); -int ibcs2_umount __P((struct proc *, struct ibcs2_umount_args *)); -int ibcs2_setuid __P((struct proc *, struct ibcs2_setuid_args *)); -int ibcs2_stime __P((struct proc *, struct ibcs2_stime_args *)); -int ibcs2_alarm __P((struct proc *, struct ibcs2_alarm_args *)); -int ibcs2_fstat __P((struct proc *, struct ibcs2_fstat_args *)); -int ibcs2_pause __P((struct proc *, struct ibcs2_pause_args *)); -int ibcs2_utime __P((struct proc *, struct ibcs2_utime_args *)); -int ibcs2_stty __P((struct proc *, struct ibcs2_stty_args *)); -int ibcs2_gtty __P((struct proc *, struct ibcs2_gtty_args *)); -int ibcs2_access __P((struct proc *, struct ibcs2_access_args *)); -int ibcs2_nice __P((struct proc *, struct ibcs2_nice_args *)); -int ibcs2_statfs __P((struct proc *, struct ibcs2_statfs_args *)); -int ibcs2_kill __P((struct proc *, struct ibcs2_kill_args *)); -int ibcs2_fstatfs __P((struct proc *, struct ibcs2_fstatfs_args *)); -int ibcs2_pgrpsys __P((struct proc *, struct ibcs2_pgrpsys_args *)); -int ibcs2_xenix __P((struct proc *, struct ibcs2_xenix_args *)); -int ibcs2_times __P((struct proc *, struct ibcs2_times_args *)); -int ibcs2_plock __P((struct proc *, struct ibcs2_plock_args *)); -int ibcs2_setgid __P((struct proc *, struct ibcs2_setgid_args *)); -int ibcs2_sigsys __P((struct proc *, struct ibcs2_sigsys_args *)); -int ibcs2_msgsys __P((struct proc *, struct ibcs2_msgsys_args *)); -int ibcs2_sysi86 __P((struct proc *, struct ibcs2_sysi86_args *)); -int ibcs2_shmsys __P((struct proc *, struct ibcs2_shmsys_args *)); -int ibcs2_semsys __P((struct proc *, struct ibcs2_semsys_args *)); -int ibcs2_ioctl __P((struct proc *, struct ibcs2_ioctl_args *)); -int ibcs2_uadmin __P((struct proc *, struct ibcs2_uadmin_args *)); -int ibcs2_utssys __P((struct proc *, struct ibcs2_utssys_args *)); -int ibcs2_execve __P((struct proc *, struct ibcs2_execve_args *)); -int ibcs2_fcntl __P((struct proc *, struct ibcs2_fcntl_args *)); -int ibcs2_ulimit __P((struct proc *, struct ibcs2_ulimit_args *)); -int ibcs2_rmdir __P((struct proc *, struct ibcs2_rmdir_args *)); -int ibcs2_mkdir __P((struct proc *, struct ibcs2_mkdir_args *)); -int ibcs2_getdents __P((struct proc *, struct ibcs2_getdents_args *)); -int ibcs2_sysfs __P((struct proc *, struct ibcs2_sysfs_args *)); -int ibcs2_getmsg __P((struct proc *, struct ibcs2_getmsg_args *)); -int ibcs2_putmsg __P((struct proc *, struct ibcs2_putmsg_args *)); -int ibcs2_poll __P((struct proc *, struct ibcs2_poll_args *)); -int ibcs2_secure __P((struct proc *, struct ibcs2_secure_args *)); -int ibcs2_symlink __P((struct proc *, struct ibcs2_symlink_args *)); -int ibcs2_lstat __P((struct proc *, struct ibcs2_lstat_args *)); -int ibcs2_readlink __P((struct proc *, struct ibcs2_readlink_args *)); -int ibcs2_isc __P((struct proc *, struct ibcs2_isc_args *)); +int ibcs2_read __P((struct thread *, struct ibcs2_read_args *)); +int ibcs2_open __P((struct thread *, struct ibcs2_open_args *)); +int ibcs2_wait __P((struct thread *, struct ibcs2_wait_args *)); +int ibcs2_creat __P((struct thread *, struct ibcs2_creat_args *)); +int ibcs2_unlink __P((struct thread *, struct ibcs2_unlink_args *)); +int ibcs2_execv __P((struct thread *, struct ibcs2_execv_args *)); +int ibcs2_chdir __P((struct thread *, struct ibcs2_chdir_args *)); +int ibcs2_time __P((struct thread *, struct ibcs2_time_args *)); +int ibcs2_mknod __P((struct thread *, struct ibcs2_mknod_args *)); +int ibcs2_chmod __P((struct thread *, struct ibcs2_chmod_args *)); +int ibcs2_chown __P((struct thread *, struct ibcs2_chown_args *)); +int ibcs2_stat __P((struct thread *, struct ibcs2_stat_args *)); +int ibcs2_lseek __P((struct thread *, struct ibcs2_lseek_args *)); +int ibcs2_mount __P((struct thread *, struct ibcs2_mount_args *)); +int ibcs2_umount __P((struct thread *, struct ibcs2_umount_args *)); +int ibcs2_setuid __P((struct thread *, struct ibcs2_setuid_args *)); +int ibcs2_stime __P((struct thread *, struct ibcs2_stime_args *)); +int ibcs2_alarm __P((struct thread *, struct ibcs2_alarm_args *)); +int ibcs2_fstat __P((struct thread *, struct ibcs2_fstat_args *)); +int ibcs2_pause __P((struct thread *, struct ibcs2_pause_args *)); +int ibcs2_utime __P((struct thread *, struct ibcs2_utime_args *)); +int ibcs2_stty __P((struct thread *, struct ibcs2_stty_args *)); +int ibcs2_gtty __P((struct thread *, struct ibcs2_gtty_args *)); +int ibcs2_access __P((struct thread *, struct ibcs2_access_args *)); +int ibcs2_nice __P((struct thread *, struct ibcs2_nice_args *)); +int ibcs2_statfs __P((struct thread *, struct ibcs2_statfs_args *)); +int ibcs2_kill __P((struct thread *, struct ibcs2_kill_args *)); +int ibcs2_fstatfs __P((struct thread *, struct ibcs2_fstatfs_args *)); +int ibcs2_pgrpsys __P((struct thread *, struct ibcs2_pgrpsys_args *)); +int ibcs2_xenix __P((struct thread *, struct ibcs2_xenix_args *)); +int ibcs2_times __P((struct thread *, struct ibcs2_times_args *)); +int ibcs2_plock __P((struct thread *, struct ibcs2_plock_args *)); +int ibcs2_setgid __P((struct thread *, struct ibcs2_setgid_args *)); +int ibcs2_sigsys __P((struct thread *, struct ibcs2_sigsys_args *)); +int ibcs2_msgsys __P((struct thread *, struct ibcs2_msgsys_args *)); +int ibcs2_sysi86 __P((struct thread *, struct ibcs2_sysi86_args *)); +int ibcs2_shmsys __P((struct thread *, struct ibcs2_shmsys_args *)); +int ibcs2_semsys __P((struct thread *, struct ibcs2_semsys_args *)); +int ibcs2_ioctl __P((struct thread *, struct ibcs2_ioctl_args *)); +int ibcs2_uadmin __P((struct thread *, struct ibcs2_uadmin_args *)); +int ibcs2_utssys __P((struct thread *, struct ibcs2_utssys_args *)); +int ibcs2_execve __P((struct thread *, struct ibcs2_execve_args *)); +int ibcs2_fcntl __P((struct thread *, struct ibcs2_fcntl_args *)); +int ibcs2_ulimit __P((struct thread *, struct ibcs2_ulimit_args *)); +int ibcs2_rmdir __P((struct thread *, struct ibcs2_rmdir_args *)); +int ibcs2_mkdir __P((struct thread *, struct ibcs2_mkdir_args *)); +int ibcs2_getdents __P((struct thread *, struct ibcs2_getdents_args *)); +int ibcs2_sysfs __P((struct thread *, struct ibcs2_sysfs_args *)); +int ibcs2_getmsg __P((struct thread *, struct ibcs2_getmsg_args *)); +int ibcs2_putmsg __P((struct thread *, struct ibcs2_putmsg_args *)); +int ibcs2_poll __P((struct thread *, struct ibcs2_poll_args *)); +int ibcs2_secure __P((struct thread *, struct ibcs2_secure_args *)); +int ibcs2_symlink __P((struct thread *, struct ibcs2_symlink_args *)); +int ibcs2_lstat __P((struct thread *, struct ibcs2_lstat_args *)); +int ibcs2_readlink __P((struct thread *, struct ibcs2_readlink_args *)); +int ibcs2_isc __P((struct thread *, struct ibcs2_isc_args *)); #ifdef COMPAT_43 diff --git a/sys/i386/ibcs2/ibcs2_signal.c b/sys/i386/ibcs2/ibcs2_signal.c index 6049142..197c295 100644 --- a/sys/i386/ibcs2/ibcs2_signal.c +++ b/sys/i386/ibcs2/ibcs2_signal.c @@ -188,8 +188,8 @@ bsd_to_ibcs2_sigaction(bsa, isa) } int -ibcs2_sigaction(p, uap) - register struct proc *p; +ibcs2_sigaction(td, uap) + register struct thread *td; struct ibcs2_sigaction_args *uap; { struct ibcs2_sigaction *nisa, *oisa, tmpisa; @@ -221,7 +221,7 @@ ibcs2_sigaction(p, uap) SCARG(&sa, act) = nbsa; SCARG(&sa, oact) = obsa; - if ((error = sigaction(p, &sa)) != 0) + if ((error = sigaction(td, &sa)) != 0) return error; if (oisa != NULL) { @@ -236,10 +236,11 @@ ibcs2_sigaction(p, uap) } int -ibcs2_sigsys(p, uap) - register struct proc *p; +ibcs2_sigsys(td, uap) + register struct thread *td; struct ibcs2_sigsys_args *uap; { + struct proc *p = td->td_proc; struct sigaction sa; int signum = ibcs2_to_bsd_sig[_SIG_IDX(IBCS2_SIGNO(SCARG(uap, sig)))]; int error; @@ -248,7 +249,7 @@ ibcs2_sigsys(p, uap) if (signum <= 0 || signum >= IBCS2_NSIG) { if (IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGNAL_MASK || IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGSET_MASK) - p->p_retval[0] = (int)IBCS2_SIG_ERR; + td->td_retval[0] = (int)IBCS2_SIG_ERR; return EINVAL; } @@ -275,7 +276,7 @@ ibcs2_sigsys(p, uap) SCARG(&sa, how) = SIG_BLOCK; SCARG(&sa, set) = &mask; SCARG(&sa, oset) = NULL; - return sigprocmask(p, &sa); + return sigprocmask(td, &sa); } case IBCS2_SIGNAL_MASK: @@ -305,19 +306,19 @@ ibcs2_sigsys(p, uap) if (signum != SIGALRM) sa.sa_flags |= SA_RESTART; #endif - p->p_retval[0] = (int)IBCS2_SIG_ERR; /* init error return */ + td->td_retval[0] = (int)IBCS2_SIG_ERR; /* init error return */ /* perform native sigaction() */ if ((error = copyout(&sa, nbsa, sizeof(sa))) != 0) return error; - if ((error = sigaction(p, &sa_args)) != 0) { + if ((error = sigaction(td, &sa_args)) != 0) { DPRINTF(("signal: sigaction failed: %d\n", error)); return error; } if ((error = copyin(obsa, &sa, sizeof(sa))) != 0) return error; - p->p_retval[0] = (int)sa.sa_handler; + td->td_retval[0] = (int)sa.sa_handler; /* special sigset() check */ if(IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGSET_MASK) { @@ -325,7 +326,7 @@ ibcs2_sigsys(p, uap) /* check to make sure signal is not blocked */ if(sigismember(&p->p_sigmask, signum)) { /* return SIG_HOLD and unblock signal*/ - p->p_retval[0] = (int)IBCS2_SIG_HOLD; + td->td_retval[0] = (int)IBCS2_SIG_HOLD; SIGDELSET(p->p_sigmask, signum); } PROC_UNLOCK(p); @@ -344,7 +345,7 @@ ibcs2_sigsys(p, uap) SCARG(&sa, how) = SIG_UNBLOCK; SCARG(&sa, set) = &mask; SCARG(&sa, oset) = NULL; - return sigprocmask(p, &sa); + return sigprocmask(td, &sa); } case IBCS2_SIGIGNORE_MASK: @@ -362,7 +363,7 @@ ibcs2_sigsys(p, uap) sa.sa_flags = 0; if ((error = copyout(&sa, bsa, sizeof(sa))) != 0) return error; - if ((error = sigaction(p, &sa_args)) != 0) { + if ((error = sigaction(td, &sa_args)) != 0) { DPRINTF(("sigignore: sigaction failed\n")); return error; } @@ -379,7 +380,7 @@ ibcs2_sigsys(p, uap) PROC_UNLOCK(p); SIGDELSET(mask, signum); SCARG(&sa, sigmask) = &mask; - return sigsuspend(p, &sa); + return sigsuspend(td, &sa); } default: @@ -388,10 +389,11 @@ ibcs2_sigsys(p, uap) } int -ibcs2_sigprocmask(p, uap) - register struct proc *p; +ibcs2_sigprocmask(td, uap) + register struct thread *td; struct ibcs2_sigprocmask_args *uap; { + struct proc *p = td->td_proc; ibcs2_sigset_t iss; sigset_t bss; int error = 0; @@ -442,10 +444,11 @@ ibcs2_sigprocmask(p, uap) } int -ibcs2_sigpending(p, uap) - register struct proc *p; +ibcs2_sigpending(td, uap) + register struct thread *td; struct ibcs2_sigpending_args *uap; { + struct proc *p = td->td_proc; sigset_t bss; ibcs2_sigset_t iss; @@ -459,8 +462,8 @@ ibcs2_sigpending(p, uap) } int -ibcs2_sigsuspend(p, uap) - register struct proc *p; +ibcs2_sigsuspend(td, uap) + register struct thread *td; struct ibcs2_sigsuspend_args *uap; { ibcs2_sigset_t sss; @@ -473,32 +476,33 @@ ibcs2_sigsuspend(p, uap) ibcs2_to_bsd_sigset(&sss, &bss); SCARG(&sa, sigmask) = &bss; - return sigsuspend(p, &sa); + return sigsuspend(td, &sa); } int -ibcs2_pause(p, uap) - register struct proc *p; +ibcs2_pause(td, uap) + register struct thread *td; struct ibcs2_pause_args *uap; { + struct proc *p = td->td_proc; sigset_t mask; struct sigsuspend_args sa; PROC_LOCK(p); - mask = p->p_sigmask; + mask = td->td_proc->p_sigmask; PROC_UNLOCK(p); SCARG(&sa, sigmask) = &mask; - return sigsuspend(p, &sa); + return sigsuspend(td, &sa); } int -ibcs2_kill(p, uap) - register struct proc *p; +ibcs2_kill(td, uap) + register struct thread *td; struct ibcs2_kill_args *uap; { struct kill_args ka; SCARG(&ka, pid) = SCARG(uap, pid); SCARG(&ka, signum) = ibcs2_to_bsd_sig[_SIG_IDX(SCARG(uap, signo))]; - return kill(p, &ka); + return kill(td, &ka); } diff --git a/sys/i386/ibcs2/ibcs2_socksys.c b/sys/i386/ibcs2/ibcs2_socksys.c index 16d964e..533b5c9 100644 --- a/sys/i386/ibcs2/ibcs2_socksys.c +++ b/sys/i386/ibcs2/ibcs2_socksys.c @@ -21,6 +21,8 @@ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * $FreeBSD$ */ #include <sys/param.h> @@ -44,9 +46,9 @@ struct setipdomainname_args { }; /* Local prototypes */ -static int ibcs2_getipdomainname __P((struct proc *, +static int ibcs2_getipdomainname __P((struct thread *, struct getipdomainname_args *)); -static int ibcs2_setipdomainname __P((struct proc *, +static int ibcs2_setipdomainname __P((struct thread *, struct setipdomainname_args *)); /* @@ -54,8 +56,8 @@ static int ibcs2_setipdomainname __P((struct proc *, */ int -ibcs2_socksys(p, uap) - register struct proc *p; +ibcs2_socksys(td, uap) + register struct thread *td; register struct ibcs2_socksys_args *uap; { int error; @@ -77,55 +79,55 @@ ibcs2_socksys(p, uap) passargs = (void *)(realargs + 1); switch (realargs[0]) { case SOCKSYS_ACCEPT: - return accept(p, passargs); + return accept(td, passargs); case SOCKSYS_BIND: - return bind(p, passargs); + return bind(td, passargs); case SOCKSYS_CONNECT: - return connect(p, passargs); + return connect(td, passargs); case SOCKSYS_GETPEERNAME: - return getpeername(p, passargs); + return getpeername(td, passargs); case SOCKSYS_GETSOCKNAME: - return getsockname(p, passargs); + return getsockname(td, passargs); case SOCKSYS_GETSOCKOPT: - return getsockopt(p, passargs); + return getsockopt(td, passargs); case SOCKSYS_LISTEN: - return listen(p, passargs); + return listen(td, passargs); case SOCKSYS_RECV: realargs[5] = realargs[6] = 0; /* FALLTHROUGH */ case SOCKSYS_RECVFROM: - return recvfrom(p, passargs); + return recvfrom(td, passargs); case SOCKSYS_SEND: realargs[5] = realargs[6] = 0; /* FALLTHROUGH */ case SOCKSYS_SENDTO: - return sendto(p, passargs); + return sendto(td, passargs); case SOCKSYS_SETSOCKOPT: - return setsockopt(p, passargs); + return setsockopt(td, passargs); case SOCKSYS_SHUTDOWN: - return shutdown(p, passargs); + return shutdown(td, passargs); case SOCKSYS_SOCKET: - return socket(p, passargs); + return socket(td, passargs); case SOCKSYS_SELECT: - return select(p, passargs); + return select(td, passargs); case SOCKSYS_GETIPDOMAIN: - return ibcs2_getipdomainname(p, passargs); + return ibcs2_getipdomainname(td, passargs); case SOCKSYS_SETIPDOMAIN: - return ibcs2_setipdomainname(p, passargs); + return ibcs2_setipdomainname(td, passargs); case SOCKSYS_ADJTIME: - return adjtime(p, passargs); + return adjtime(td, passargs); case SOCKSYS_SETREUID: - return setreuid(p, passargs); + return setreuid(td, passargs); case SOCKSYS_SETREGID: - return setregid(p, passargs); + return setregid(td, passargs); case SOCKSYS_GETTIME: - return gettimeofday(p, passargs); + return gettimeofday(td, passargs); case SOCKSYS_SETTIME: - return settimeofday(p, passargs); + return settimeofday(td, passargs); case SOCKSYS_GETITIMER: - return getitimer(p, passargs); + return getitimer(td, passargs); case SOCKSYS_SETITIMER: - return setitimer(p, passargs); + return setitimer(td, passargs); default: printf("socksys unknown %08x %08x %08x %08x %08x %08x %08x\n", @@ -138,8 +140,8 @@ ibcs2_socksys(p, uap) /* ARGSUSED */ static int -ibcs2_getipdomainname(p, uap) - struct proc *p; +ibcs2_getipdomainname(td, uap) + struct thread *td; struct getipdomainname_args *uap; { char hname[MAXHOSTNAMELEN], *dptr; @@ -162,14 +164,14 @@ ibcs2_getipdomainname(p, uap) /* ARGSUSED */ static int -ibcs2_setipdomainname(p, uap) - struct proc *p; +ibcs2_setipdomainname(td, uap) + struct thread *td; struct setipdomainname_args *uap; { char hname[MAXHOSTNAMELEN], *ptr; int error, sctl[2], hlen; - if ((error = suser(p))) + if ((error = suser_td(td))) return (error); /* W/out a hostname a domain-name is nonsense */ @@ -200,5 +202,5 @@ ibcs2_setipdomainname(p, uap) sctl[0] = CTL_KERN; sctl[1] = KERN_HOSTNAME; hlen = strlen(hname) + 1; - return (kernel_sysctl(p, sctl, 2, 0, 0, hname, hlen, 0)); + return (kernel_sysctl(td, sctl, 2, 0, 0, hname, hlen, 0)); } diff --git a/sys/i386/ibcs2/ibcs2_socksys.h b/sys/i386/ibcs2/ibcs2_socksys.h index f6b212e..f0c72bd 100644 --- a/sys/i386/ibcs2/ibcs2_socksys.h +++ b/sys/i386/ibcs2/ibcs2_socksys.h @@ -21,6 +21,8 @@ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * $FreeBSD$ */ #ifndef _I386_IBCS2_IBCS2_SOCKSYS_H_ @@ -121,6 +123,6 @@ struct ibcs2_socksys_args { caddr_t argsp; }; -int ibcs2_socksys __P((struct proc *, struct ibcs2_socksys_args *)); +int ibcs2_socksys __P((struct thread *, struct ibcs2_socksys_args *)); #endif /* !_I386_IBCS2_IBCS2_SOCKSYS_H_ */ diff --git a/sys/i386/ibcs2/ibcs2_stat.c b/sys/i386/ibcs2/ibcs2_stat.c index 824118f..fd39853 100644 --- a/sys/i386/ibcs2/ibcs2_stat.c +++ b/sys/i386/ibcs2/ibcs2_stat.c @@ -95,8 +95,8 @@ cvt_statfs(sp, buf, len) } int -ibcs2_statfs(p, uap) - struct proc *p; +ibcs2_statfs(td, uap) + struct thread *td; struct ibcs2_statfs_args *uap; { register struct mount *mp; @@ -105,23 +105,23 @@ ibcs2_statfs(p, uap) struct nameidata nd; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); mp = nd.ni_vp->v_mount; sp = &mp->mnt_stat; vrele(nd.ni_vp); - if ((error = VFS_STATFS(mp, sp, p)) != 0) + if ((error = VFS_STATFS(mp, sp, td)) != 0) return (error); sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len)); } int -ibcs2_fstatfs(p, uap) - struct proc *p; +ibcs2_fstatfs(td, uap) + struct thread *td; struct ibcs2_fstatfs_args *uap; { struct file *fp; @@ -129,19 +129,19 @@ ibcs2_fstatfs(p, uap) register struct statfs *sp; int error; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); mp = ((struct vnode *)fp->f_data)->v_mount; sp = &mp->mnt_stat; - if ((error = VFS_STATFS(mp, sp, p)) != 0) + if ((error = VFS_STATFS(mp, sp, td)) != 0) return (error); sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len)); } int -ibcs2_stat(p, uap) - struct proc *p; +ibcs2_stat(td, uap) + struct thread *td; struct ibcs2_stat_args *uap; { struct stat st; @@ -150,11 +150,11 @@ ibcs2_stat(p, uap) int error; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st)); - if ((error = stat(p, &cup)) != 0) + if ((error = stat(td, &cup)) != 0) return error; if ((error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0) @@ -165,8 +165,8 @@ ibcs2_stat(p, uap) } int -ibcs2_lstat(p, uap) - struct proc *p; +ibcs2_lstat(td, uap) + struct thread *td; struct ibcs2_lstat_args *uap; { struct stat st; @@ -175,11 +175,11 @@ ibcs2_lstat(p, uap) int error; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); SCARG(&cup, path) = SCARG(uap, path); SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st)); - if ((error = lstat(p, &cup)) != 0) + if ((error = lstat(td, &cup)) != 0) return error; if ((error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0) @@ -190,8 +190,8 @@ ibcs2_lstat(p, uap) } int -ibcs2_fstat(p, uap) - struct proc *p; +ibcs2_fstat(td, uap) + struct thread *td; struct ibcs2_fstat_args *uap; { struct stat st; @@ -203,7 +203,7 @@ ibcs2_fstat(p, uap) SCARG(&cup, fd) = SCARG(uap, fd); SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(st)); - if ((error = fstat(p, &cup)) != 0) + if ((error = fstat(td, &cup)) != 0) return error; if ((error = copyin(SCARG(&cup, sb), &st, sizeof(st))) != 0) @@ -214,8 +214,8 @@ ibcs2_fstat(p, uap) } int -ibcs2_utssys(p, uap) - struct proc *p; +ibcs2_utssys(td, uap) + struct thread *td; struct ibcs2_utssys_args *uap; { switch (SCARG(uap, flag)) { diff --git a/sys/i386/ibcs2/ibcs2_sysi86.c b/sys/i386/ibcs2/ibcs2_sysi86.c index bcc758b..ae5215f 100644 --- a/sys/i386/ibcs2/ibcs2_sysi86.c +++ b/sys/i386/ibcs2/ibcs2_sysi86.c @@ -26,7 +26,7 @@ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * ibcs2_sysi86.c,v 1.1 1994/10/14 08:53:11 sos Exp + * $FreeBSD$ */ #include <sys/param.h> @@ -51,7 +51,7 @@ extern int hw_float; int -ibcs2_sysi86(struct proc *p, struct ibcs2_sysi86_args *args) +ibcs2_sysi86(struct thread *td, struct ibcs2_sysi86_args *args) { switch (SCARG(args, cmd)) { case SI86_FPHW: { /* Floating Point information */ @@ -73,16 +73,16 @@ ibcs2_sysi86(struct proc *p, struct ibcs2_sysi86_args *args) int name[2]; int error; - if ((error = suser(p))) + if ((error = suser_td(td))) return (error); name[0] = CTL_KERN; name[1] = KERN_HOSTNAME; - return (userland_sysctl(p, name, 2, 0, 0, 0, + return (userland_sysctl(td, name, 2, 0, 0, 0, SCARG(args, arg), 7, 0)); } case SI86_MEM: /* size of physical memory */ - p->p_retval[0] = ctob(physmem); + td->td_retval[0] = ctob(physmem); return 0; default: diff --git a/sys/i386/ibcs2/ibcs2_util.c b/sys/i386/ibcs2/ibcs2_util.c index bef94fd3..8b0720a 100644 --- a/sys/i386/ibcs2/ibcs2_util.c +++ b/sys/i386/ibcs2/ibcs2_util.c @@ -50,8 +50,8 @@ const char ibcs2_emul_path[] = "/compat/ibcs2"; * be in exists. */ int -ibcs2_emul_find(p, sgp, prefix, path, pbuf, cflag) - struct proc *p; +ibcs2_emul_find(td, sgp, prefix, path, pbuf, cflag) + struct thread *td; caddr_t *sgp; /* Pointer to stackgap memory */ const char *prefix; char *path; @@ -104,7 +104,7 @@ ibcs2_emul_find(p, sgp, prefix, path, pbuf, cflag) for (cp = &ptr[len] - 1; *cp != '/'; cp--); *cp = '\0'; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, td); if ((error = namei(&nd)) != 0) { free(buf, M_TEMP); @@ -114,7 +114,7 @@ ibcs2_emul_find(p, sgp, prefix, path, pbuf, cflag) *cp = '/'; } else { - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, td); if ((error = namei(&nd)) != 0) { free(buf, M_TEMP); @@ -130,7 +130,7 @@ ibcs2_emul_find(p, sgp, prefix, path, pbuf, cflag) * to the emulation root directory. This is expensive :-( */ NDINIT(&ndroot, LOOKUP, FOLLOW, UIO_SYSSPACE, ibcs2_emul_path, - p); + td); if ((error = namei(&ndroot)) != 0) { /* Cannot happen! */ @@ -140,11 +140,11 @@ ibcs2_emul_find(p, sgp, prefix, path, pbuf, cflag) return error; } - if ((error = VOP_GETATTR(nd.ni_vp, &vat, p->p_ucred, p)) != 0) { + if ((error = VOP_GETATTR(nd.ni_vp, &vat, td->td_proc->p_ucred, td)) != 0) { goto done; } - if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, p->p_ucred, p)) + if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, td->td_proc->p_ucred, td)) != 0) { goto done; } diff --git a/sys/i386/ibcs2/ibcs2_util.h b/sys/i386/ibcs2/ibcs2_util.h index 4ef390f..93382c4 100644 --- a/sys/i386/ibcs2/ibcs2_util.h +++ b/sys/i386/ibcs2/ibcs2_util.h @@ -29,6 +29,8 @@ * * from: svr4_util.h,v 1.5 1994/11/18 02:54:31 christos Exp * from: linux_util.h,v 1.2 1995/03/05 23:23:50 fvdl Exp + * + * $FreeBSD$ */ /* @@ -60,7 +62,7 @@ static __inline void *stackgap_alloc(caddr_t *, size_t); static __inline caddr_t stackgap_init() { -#define szsigcode (*(curproc->p_sysent->sv_szsigcode)) +#define szsigcode (*(curthread->td_proc->p_sysent->sv_szsigcode)) return (caddr_t)(PS_STRINGS - szsigcode - SPARE_USRSPACE); } @@ -82,17 +84,17 @@ stackgap_alloc(sgp, sz) extern const char ibcs2_emul_path[]; -int ibcs2_emul_find __P((struct proc *, caddr_t *, const char *, char *, +int ibcs2_emul_find __P((struct thread *, caddr_t *, const char *, char *, char **, int)); #define CHECKALTEXIST(p, sgp, path) \ - ibcs2_emul_find(p, sgp, ibcs2_emul_path, path, &(path), 0) + ibcs2_emul_find(td, sgp, ibcs2_emul_path, path, &(path), 0) #define CHECKALTCREAT(p, sgp, path) \ - ibcs2_emul_find(p, sgp, ibcs2_emul_path, path, &(path), 1) + ibcs2_emul_find(td, sgp, ibcs2_emul_path, path, &(path), 1) #ifdef SPX_HACK -int spx_open __P((struct proc *p, void *uap)); +int spx_open __P((struct thread *td, void *uap)); #endif #endif /* !_IBCS2_UTIL_H_ */ diff --git a/sys/i386/ibcs2/ibcs2_xenix.c b/sys/i386/ibcs2/ibcs2_xenix.c index b11275c2..2f30195 100644 --- a/sys/i386/ibcs2/ibcs2_xenix.c +++ b/sys/i386/ibcs2/ibcs2_xenix.c @@ -53,9 +53,9 @@ extern struct sysent xenix_sysent[]; int -ibcs2_xenix(struct proc *p, struct ibcs2_xenix_args *uap) +ibcs2_xenix(struct thread *td, struct ibcs2_xenix_args *uap) { - struct trapframe *tf = p->p_frame; + struct trapframe *tf = td->td_frame; struct sysent *callp; u_int code; @@ -63,14 +63,14 @@ ibcs2_xenix(struct proc *p, struct ibcs2_xenix_args *uap) callp = &xenix_sysent[code]; if(code < IBCS2_XENIX_MAXSYSCALL) - return((*callp->sy_call)(p, (void *)uap)); + return((*callp->sy_call)(td, (void *)uap)); else return ENOSYS; } int -xenix_rdchk(p, uap) - struct proc *p; +xenix_rdchk(td, uap) + struct thread *td; struct xenix_rdchk_args *uap; { int error; @@ -81,15 +81,15 @@ xenix_rdchk(p, uap) SCARG(&sa, fd) = SCARG(uap, fd); SCARG(&sa, com) = FIONREAD; SCARG(&sa, data) = stackgap_alloc(&sg, sizeof(int)); - if ((error = ioctl(p, &sa)) != 0) + if ((error = ioctl(td, &sa)) != 0) return error; - p->p_retval[0] = (*((int*)SCARG(&sa, data))) ? 1 : 0; + td->td_retval[0] = (*((int*)SCARG(&sa, data))) ? 1 : 0; return 0; } int -xenix_chsize(p, uap) - struct proc *p; +xenix_chsize(td, uap) + struct thread *td; struct xenix_chsize_args *uap; { struct ftruncate_args sa; @@ -98,13 +98,13 @@ xenix_chsize(p, uap) SCARG(&sa, fd) = SCARG(uap, fd); SCARG(&sa, pad) = 0; SCARG(&sa, length) = SCARG(uap, size); - return ftruncate(p, &sa); + return ftruncate(td, &sa); } int -xenix_ftime(p, uap) - struct proc *p; +xenix_ftime(td, uap) + struct thread *td; struct xenix_ftime_args *uap; { struct timeval tv; @@ -127,7 +127,7 @@ xenix_ftime(p, uap) } int -xenix_nap(struct proc *p, struct xenix_nap_args *uap) +xenix_nap(struct thread *td, struct xenix_nap_args *uap) { long period; @@ -140,7 +140,7 @@ xenix_nap(struct proc *p, struct xenix_nap_args *uap) } int -xenix_utsname(struct proc *p, struct xenix_utsname_args *uap) +xenix_utsname(struct thread *td, struct xenix_utsname_args *uap) { struct ibcs2_sco_utsname { char sysname[9]; @@ -183,26 +183,26 @@ xenix_utsname(struct proc *p, struct xenix_utsname_args *uap) } int -xenix_scoinfo(struct proc *p, struct xenix_scoinfo_args *uap) +xenix_scoinfo(struct thread *td, struct xenix_scoinfo_args *uap) { /* scoinfo (not documented) */ - p->p_retval[0] = 0; + td->td_retval[0] = 0; return 0; } int -xenix_eaccess(struct proc *p, struct xenix_eaccess_args *uap) +xenix_eaccess(struct thread *td, struct xenix_eaccess_args *uap) { - struct ucred *cred = p->p_ucred; + struct ucred *cred = td->td_proc->p_ucred; struct vnode *vp; struct nameidata nd; int error, flags; caddr_t sg = stackgap_init(); - CHECKALTEXIST(p, &sg, SCARG(uap, path)); + CHECKALTEXIST(td, &sg, SCARG(uap, path)); NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return error; vp = nd.ni_vp; @@ -217,7 +217,7 @@ xenix_eaccess(struct proc *p, struct xenix_eaccess_args *uap) if (SCARG(uap, flags) & IBCS2_X_OK) flags |= VEXEC; if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0) - error = VOP_ACCESS(vp, flags, cred, p); + error = VOP_ACCESS(vp, flags, cred, td); } NDFREE(&nd, NDF_ONLY_PNBUF); vput(vp); diff --git a/sys/i386/ibcs2/ibcs2_xenix.h b/sys/i386/ibcs2/ibcs2_xenix.h index 3d487ee..07e827f 100644 --- a/sys/i386/ibcs2/ibcs2_xenix.h +++ b/sys/i386/ibcs2/ibcs2_xenix.h @@ -15,6 +15,8 @@ struct proc; +struct thread; + #define PAD_(t) (sizeof(register_t) <= sizeof(t) ? \ 0 : sizeof(register_t) - sizeof(t)) @@ -80,23 +82,23 @@ struct ibcs2_rename_args { struct xenix_utsname_args { long addr; char addr_[PAD_(long)]; }; -int xenix_rdchk __P((struct proc *, struct xenix_rdchk_args *)); -int xenix_chsize __P((struct proc *, struct xenix_chsize_args *)); -int xenix_ftime __P((struct proc *, struct xenix_ftime_args *)); -int xenix_nap __P((struct proc *, struct xenix_nap_args *)); -int xenix_scoinfo __P((struct proc *, struct xenix_scoinfo_args *)); -int xenix_eaccess __P((struct proc *, struct xenix_eaccess_args *)); -int ibcs2_sigaction __P((struct proc *, struct ibcs2_sigaction_args *)); -int ibcs2_sigprocmask __P((struct proc *, struct ibcs2_sigprocmask_args *)); -int ibcs2_sigpending __P((struct proc *, struct ibcs2_sigpending_args *)); -int ibcs2_sigsuspend __P((struct proc *, struct ibcs2_sigsuspend_args *)); -int ibcs2_getgroups __P((struct proc *, struct ibcs2_getgroups_args *)); -int ibcs2_setgroups __P((struct proc *, struct ibcs2_setgroups_args *)); -int ibcs2_sysconf __P((struct proc *, struct ibcs2_sysconf_args *)); -int ibcs2_pathconf __P((struct proc *, struct ibcs2_pathconf_args *)); -int ibcs2_fpathconf __P((struct proc *, struct ibcs2_fpathconf_args *)); -int ibcs2_rename __P((struct proc *, struct ibcs2_rename_args *)); -int xenix_utsname __P((struct proc *, struct xenix_utsname_args *)); +int xenix_rdchk __P((struct thread *, struct xenix_rdchk_args *)); +int xenix_chsize __P((struct thread *, struct xenix_chsize_args *)); +int xenix_ftime __P((struct thread *, struct xenix_ftime_args *)); +int xenix_nap __P((struct thread *, struct xenix_nap_args *)); +int xenix_scoinfo __P((struct thread *, struct xenix_scoinfo_args *)); +int xenix_eaccess __P((struct thread *, struct xenix_eaccess_args *)); +int ibcs2_sigaction __P((struct thread *, struct ibcs2_sigaction_args *)); +int ibcs2_sigprocmask __P((struct thread *, struct ibcs2_sigprocmask_args *)); +int ibcs2_sigpending __P((struct thread *, struct ibcs2_sigpending_args *)); +int ibcs2_sigsuspend __P((struct thread *, struct ibcs2_sigsuspend_args *)); +int ibcs2_getgroups __P((struct thread *, struct ibcs2_getgroups_args *)); +int ibcs2_setgroups __P((struct thread *, struct ibcs2_setgroups_args *)); +int ibcs2_sysconf __P((struct thread *, struct ibcs2_sysconf_args *)); +int ibcs2_pathconf __P((struct thread *, struct ibcs2_pathconf_args *)); +int ibcs2_fpathconf __P((struct thread *, struct ibcs2_fpathconf_args *)); +int ibcs2_rename __P((struct thread *, struct ibcs2_rename_args *)); +int xenix_utsname __P((struct thread *, struct xenix_utsname_args *)); #ifdef COMPAT_43 diff --git a/sys/i386/ibcs2/imgact_coff.c b/sys/i386/ibcs2/imgact_coff.c index a2f624d..3ea816b 100644 --- a/sys/i386/ibcs2/imgact_coff.c +++ b/sys/i386/ibcs2/imgact_coff.c @@ -54,7 +54,7 @@ MODULE_DEPEND(coff, ibcs2, 1, 1, 1); extern struct sysentvec ibcs2_svr3_sysvec; -static int coff_load_file __P((struct proc *p, char *name)); +static int coff_load_file __P((struct thread *td, char *name)); static int exec_coff_imgact __P((struct image_params *imgp)); static int load_coff_section __P((struct vmspace *vmspace, struct vnode *vp, vm_offset_t offset, caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot)); @@ -150,8 +150,9 @@ load_coff_section(struct vmspace *vmspace, struct vnode *vp, vm_offset_t offset, } static int -coff_load_file(struct proc *p, char *name) +coff_load_file(struct thread *td, char *name) { + struct proc *p = td->td_proc; struct vmspace *vmspace = p->p_vmspace; int error; struct nameidata nd; @@ -167,7 +168,7 @@ coff_load_file(struct proc *p, char *name) unsigned long bss_size = 0; int i; - NDINIT(&nd, LOOKUP, LOCKLEAF | FOLLOW | SAVENAME, UIO_SYSSPACE, name, p); + NDINIT(&nd, LOOKUP, LOCKLEAF | FOLLOW | SAVENAME, UIO_SYSSPACE, name, td); error = namei(&nd); if (error) @@ -182,7 +183,7 @@ coff_load_file(struct proc *p, char *name) goto fail; } - if ((error = VOP_GETATTR(vp, &attr, p->p_ucred, p)) != 0) + if ((error = VOP_GETATTR(vp, &attr, p->p_ucred, td)) != 0) goto fail; if ((vp->v_mount->mnt_flag & MNT_NOEXEC) @@ -195,17 +196,17 @@ coff_load_file(struct proc *p, char *name) goto fail; } - if ((error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p)) != 0) + if ((error = VOP_ACCESS(vp, VEXEC, p->p_ucred, td)) != 0) goto fail; - if ((error = VOP_OPEN(vp, FREAD, p->p_ucred, p)) != 0) + if ((error = VOP_OPEN(vp, FREAD, p->p_ucred, td)) != 0) goto fail; /* * Lose the lock on the vnode. It's no longer needed, and must not * exist for the pagefault paging to work below. */ - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if ((error = vm_mmap(kernel_map, (vm_offset_t *) &ptr, @@ -278,7 +279,7 @@ coff_load_file(struct proc *p, char *name) panic(__FUNCTION__ " vm_map_remove failed"); fail: - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); unlocked_fail: NDFREE(&nd, NDF_ONLY_PNBUF); vrele(nd.ni_vp); @@ -393,9 +394,9 @@ exec_coff_imgact(imgp) DPRINTF(("%s(%d): shared library %s\n", __FILE__, __LINE__, libname)); strcpy(&libbuf[emul_path_len], libname); - error = coff_load_file(imgp->proc, libbuf); +/* XXXKSE only 1:1 in coff */ error = coff_load_file(&imgp->proc->p_thread, libbuf); if (error) - error = coff_load_file(imgp->proc, + error = coff_load_file(&imgp->proc->p_thread, libname); if (error) break; diff --git a/sys/i386/include/cpu.h b/sys/i386/include/cpu.h index 04ef7a0..a7783a0 100644 --- a/sys/i386/include/cpu.h +++ b/sys/i386/include/cpu.h @@ -56,8 +56,8 @@ #define cpu_exec(p) /* nothing */ #define cpu_swapin(p) /* nothing */ -#define cpu_getstack(p) ((p)->p_frame->tf_esp) -#define cpu_setstack(p, ap) ((p)->p_frame->tf_esp = (ap)) +#define cpu_getstack(td) ((td)->td_frame->tf_esp) +#define cpu_setstack(td, ap) ((td)->td_frame->tf_esp = (ap)) #define TRAPF_USERMODE(framep) \ ((ISPL((framep)->tf_cs) == SEL_UPL) || ((framep)->tf_eflags & PSL_VM)) diff --git a/sys/i386/include/globaldata.h b/sys/i386/include/globaldata.h index 37388aa..f02354d 100644 --- a/sys/i386/include/globaldata.h +++ b/sys/i386/include/globaldata.h @@ -52,19 +52,19 @@ * other processors" */ struct globaldata { - struct globaldata *gd_prvspace; /* self-reference */ - struct proc *gd_curproc; /* current process */ - struct proc *gd_idleproc; /* idle process */ - struct proc *gd_npxproc; - struct pcb *gd_curpcb; /* current pcb */ - struct timeval gd_switchtime; - struct i386tss gd_common_tss; - int gd_switchticks; - struct segment_descriptor gd_common_tssd; - struct segment_descriptor *gd_tss_gdt; - int gd_currentldt; - u_int gd_cpuid; /* this cpu number */ - u_int gd_other_cpus; /* all other cpus */ + struct globaldata *gd_prvspace; /* self-reference */ + struct thread *gd_curthread; + struct thread *gd_npxthread; + struct pcb *gd_curpcb; + struct thread *gd_idlethread; + struct timeval gd_switchtime; + struct i386tss gd_common_tss; + int gd_switchticks; + struct segment_descriptor gd_common_tssd; + struct segment_descriptor *gd_tss_gdt; + int gd_currentldt; + u_int gd_cpuid; + u_int gd_other_cpus; SLIST_ENTRY(globaldata) gd_allcpu; struct lock_list_entry *gd_spinlocks; #ifdef KTR_PERCPU diff --git a/sys/i386/include/globals.h b/sys/i386/include/globals.h index 7613069..c3cc211 100644 --- a/sys/i386/include/globals.h +++ b/sys/i386/include/globals.h @@ -129,10 +129,12 @@ #define PCPU_PTR(member) __PCPU_PTR(gd_ ## member) #define PCPU_SET(member, val) __PCPU_SET(gd_ ## member, val) -#define CURPROC PCPU_GET(curproc) -#define CURTHD PCPU_GET(curproc) #define GLOBALDATA PCPU_GET(prvspace) -#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/i386/include/md_var.h b/sys/i386/include/md_var.h index bc9cb75..c3564c2 100644 --- a/sys/i386/include/md_var.h +++ b/sys/i386/include/md_var.h @@ -61,7 +61,7 @@ extern char sigcode[]; extern int szsigcode, szosigcode; typedef void alias_for_inthand_t __P((u_int cs, u_int ef, u_int esp, u_int ss)); -struct proc; +struct thread; struct reg; struct fpreg; struct dbreg; @@ -80,9 +80,9 @@ void doreti_popl_es __P((void)) __asm(__STRING(doreti_popl_es)); void doreti_popl_es_fault __P((void)) __asm(__STRING(doreti_popl_es_fault)); void doreti_popl_fs __P((void)) __asm(__STRING(doreti_popl_fs)); void doreti_popl_fs_fault __P((void)) __asm(__STRING(doreti_popl_fs_fault)); -int fill_fpregs __P((struct proc *, struct fpreg *)); -int fill_regs __P((struct proc *p, struct reg *regs)); -int fill_dbregs __P((struct proc *p, struct dbreg *dbregs)); +int fill_fpregs __P((struct thread *, struct fpreg *)); +int fill_regs __P((struct thread *p, struct reg *regs)); +int fill_dbregs __P((struct thread *p, struct dbreg *dbregs)); void fillw __P((int /*u_short*/ pat, void *base, size_t cnt)); void i486_bzero __P((void *buf, size_t len)); void i586_bcopy __P((const void *from, void *to, size_t len)); diff --git a/sys/i386/include/mptable.h b/sys/i386/include/mptable.h index d912e0c..f558524 100644 --- a/sys/i386/include/mptable.h +++ b/sys/i386/include/mptable.h @@ -26,7 +26,7 @@ */ #include "opt_cpu.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" #ifdef SMP #include <machine/smptests.h> @@ -1960,8 +1960,8 @@ start_all_aps(u_int boot_addr) SMPpt[pg] = (pt_entry_t)(PG_V | PG_RW | vtophys(gd)); /* allocate and set up an idle stack data page */ - stack = (char *)kmem_alloc(kernel_map, UPAGES*PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); /* XXXKSE */ + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[pg + 1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -1977,7 +1977,7 @@ start_all_aps(u_int boot_addr) outb(CMOS_DATA, BIOS_WARM); /* 'warm-start' */ #endif - bootSTK = &SMP_prvspace[x].idlestack[UPAGES*PAGE_SIZE]; + bootSTK = &SMP_prvspace[x].idlekstack[KSTACK_PAGES * PAGE_SIZE]; bootAP = x; /* attempt to start the Application Processor */ @@ -2019,8 +2019,8 @@ start_all_aps(u_int boot_addr) */ /* Allocate and setup BSP idle stack */ - stack = (char *)kmem_alloc(kernel_map, UPAGES * PAGE_SIZE); - for (i = 0; i < UPAGES; i++) + stack = (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE); + for (i = 0; i < KSTACK_PAGES; i++) SMPpt[1 + i] = (pt_entry_t) (PG_V | PG_RW | vtophys(PAGE_SIZE * i + stack)); @@ -2241,7 +2241,7 @@ ap_init(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); /* lock against other AP's that are waking up */ @@ -2323,7 +2323,7 @@ forwarded_statclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - statclock_process(curproc, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); + statclock_process(curthread->td_kse, TRAPF_PC(&frame), TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } @@ -2354,7 +2354,7 @@ forwarded_hardclock(struct trapframe frame) { mtx_lock_spin(&sched_lock); - hardclock_process(curproc, TRAPF_USERMODE(&frame)); + hardclock_process(curthread, TRAPF_USERMODE(&frame)); mtx_unlock_spin(&sched_lock); } diff --git a/sys/i386/include/mutex.h b/sys/i386/include/mutex.h index b0fe512..ae37b23 100644 --- a/sys/i386/include/mutex.h +++ b/sys/i386/include/mutex.h @@ -250,7 +250,7 @@ extern struct mtx clock_lock; pushl %ecx ; \ pushl %ebx ; \ movl $(MTX_UNOWNED) , %eax ; \ - movl PCPU(CURPROC), %ebx ; \ + movl PCPU(CURTHREAD), %ebx ; \ pushfl ; \ popl %ecx ; \ cli ; \ diff --git a/sys/i386/include/npx.h b/sys/i386/include/npx.h index 67ce661..589a4be 100644 --- a/sys/i386/include/npx.h +++ b/sys/i386/include/npx.h @@ -142,7 +142,7 @@ union savefpu { #ifdef _KERNEL int npxdna __P((void)); -void npxexit __P((struct proc *p)); +void npxexit __P((struct thread *td)); void npxinit __P((int control)); void npxsave __P((union savefpu *addr)); int npxtrap __P((void)); diff --git a/sys/i386/include/param.h b/sys/i386/include/param.h index 9f63c01..ba28cfb 100644 --- a/sys/i386/include/param.h +++ b/sys/i386/include/param.h @@ -111,9 +111,12 @@ #define IOPAGES 2 /* pages of i/o permission bitmap */ -#ifndef UPAGES -#define UPAGES 2 /* pages of u-area */ +#ifndef KSTACK_PAGES +#define KSTACK_PAGES 2 /* Includes pcb! */ #endif +#define UAREA_PAGES 1 /* holds struct user WITHOUT PCB (see def.) */ + +#define KSTACK_GUARD /* compile in the kstack guard page */ /* * Ceiling on amount of swblock kva space. diff --git a/sys/i386/include/pcb_ext.h b/sys/i386/include/pcb_ext.h index 7d6fb08..c6f9fc0 100644 --- a/sys/i386/include/pcb_ext.h +++ b/sys/i386/include/pcb_ext.h @@ -53,7 +53,7 @@ struct pcb_ldt { #ifdef _KERNEL -int i386_extend_pcb __P((struct proc *)); +int i386_extend_pcb __P((struct thread *)); void set_user_ldt __P((struct pcb *)); struct pcb_ldt *user_ldt_alloc __P((struct pcb *, int)); void user_ldt_free __P((struct pcb *)); diff --git a/sys/i386/include/pcpu.h b/sys/i386/include/pcpu.h index 37388aa..f02354d 100644 --- a/sys/i386/include/pcpu.h +++ b/sys/i386/include/pcpu.h @@ -52,19 +52,19 @@ * other processors" */ struct globaldata { - struct globaldata *gd_prvspace; /* self-reference */ - struct proc *gd_curproc; /* current process */ - struct proc *gd_idleproc; /* idle process */ - struct proc *gd_npxproc; - struct pcb *gd_curpcb; /* current pcb */ - struct timeval gd_switchtime; - struct i386tss gd_common_tss; - int gd_switchticks; - struct segment_descriptor gd_common_tssd; - struct segment_descriptor *gd_tss_gdt; - int gd_currentldt; - u_int gd_cpuid; /* this cpu number */ - u_int gd_other_cpus; /* all other cpus */ + struct globaldata *gd_prvspace; /* self-reference */ + struct thread *gd_curthread; + struct thread *gd_npxthread; + struct pcb *gd_curpcb; + struct thread *gd_idlethread; + struct timeval gd_switchtime; + struct i386tss gd_common_tss; + int gd_switchticks; + struct segment_descriptor gd_common_tssd; + struct segment_descriptor *gd_tss_gdt; + int gd_currentldt; + u_int gd_cpuid; + u_int gd_other_cpus; SLIST_ENTRY(globaldata) gd_allcpu; struct lock_list_entry *gd_spinlocks; #ifdef KTR_PERCPU diff --git a/sys/i386/include/privatespace.h b/sys/i386/include/privatespace.h index 496c4b6..83320cf 100644 --- a/sys/i386/include/privatespace.h +++ b/sys/i386/include/privatespace.h @@ -39,9 +39,9 @@ struct privatespace { struct globaldata globaldata; char __filler0[PAGE_SIZE - sizeof(struct globaldata)]; - /* page 1 - idle stack (UPAGES pages) */ - char idlestack[UPAGES * PAGE_SIZE]; - /* page 1+UPAGES... */ + /* page 1 - idle stack (KSTACK_PAGES pages) */ + char idlekstack[KSTACK_PAGES * PAGE_SIZE]; + /* page 1+KSTACK_PAGES... */ }; extern struct privatespace SMP_prvspace[]; diff --git a/sys/i386/include/proc.h b/sys/i386/include/proc.h index 4217c4f..9e9e449 100644 --- a/sys/i386/include/proc.h +++ b/sys/i386/include/proc.h @@ -42,6 +42,9 @@ /* * Machine-dependent part of the proc structure for i386. */ +struct mdthread { +}; + struct mdproc { }; diff --git a/sys/i386/include/reg.h b/sys/i386/include/reg.h index 47856a3..f4c6ae5 100644 --- a/sys/i386/include/reg.h +++ b/sys/i386/include/reg.h @@ -143,10 +143,10 @@ struct dbreg { /* * XXX these interfaces are MI, so they should be declared in a MI place. */ -int set_fpregs __P((struct proc *, struct fpreg *)); -int set_regs __P((struct proc *p, struct reg *regs)); -void setregs __P((struct proc *, u_long, u_long, u_long)); -int set_dbregs __P((struct proc *p, struct dbreg *dbregs)); +int set_fpregs __P((struct thread *, struct fpreg *)); +int set_regs __P((struct thread *p, struct reg *regs)); +void setregs __P((struct thread *, u_long, u_long, u_long)); +int set_dbregs __P((struct thread *p, struct dbreg *dbregs)); #endif #endif /* !_MACHINE_REG_H_ */ diff --git a/sys/i386/include/vm86.h b/sys/i386/include/vm86.h index 60c5615..fa77013 100644 --- a/sys/i386/include/vm86.h +++ b/sys/i386/include/vm86.h @@ -149,7 +149,7 @@ extern int vm86paddr; struct proc; extern int vm86_emulate __P((struct vm86frame *)); -extern int vm86_sysarch __P((struct proc *, char *)); +extern int vm86_sysarch __P((struct thread *, char *)); extern void vm86_trap __P((struct vm86frame *)); extern int vm86_intcall __P((int, struct vm86frame *)); extern int vm86_datacall __P((int, struct vm86frame *, struct vm86context *)); diff --git a/sys/i386/isa/apic_vector.s b/sys/i386/isa/apic_vector.s index 5c68f81..8096d3c 100644 --- a/sys/i386/isa/apic_vector.s +++ b/sys/i386/isa/apic_vector.s @@ -48,10 +48,10 @@ IDTVEC(vec_name) ; \ movl $KPSEL,%eax ; \ mov %ax,%fs ; \ FAKE_MCOUNT(13*4(%esp)) ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ pushl intr_unit + (irq_num) * 4 ; \ - call *intr_handler + (irq_num) * 4 ; /* do the work ASAP */ \ + call *intr_handler + (irq_num) * 4 ; /* do the work ASAP */ \ addl $4, %esp ; \ movl $0, lapic+LA_EOI ; \ lock ; \ @@ -59,7 +59,7 @@ IDTVEC(vec_name) ; \ movl intr_countp + (irq_num) * 4, %eax ; \ lock ; \ incl (%eax) ; \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ jmp doreti @@ -152,8 +152,8 @@ IDTVEC(vec_name) ; \ MASK_LEVEL_IRQ(irq_num) ; \ EOI_IRQ(irq_num) ; \ 0: ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ ; \ /* entry point used by doreti_unpend for HWIs. */ \ __CONCAT(Xresume,irq_num): ; \ @@ -162,7 +162,7 @@ __CONCAT(Xresume,irq_num): ; \ call sched_ithd ; \ addl $4, %esp ; /* discard the parameter */ \ ; \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ jmp doreti @@ -227,10 +227,10 @@ Xhardclock: movl $0, lapic+LA_EOI /* End Of Interrupt to APIC */ - movl PCPU(CURPROC),%ebx - incl P_INTR_NESTING_LEVEL(%ebx) + movl PCPU(CURTHREAD),%ebx + incl TD_INTR_NESTING_LEVEL(%ebx) call forwarded_hardclock - decl P_INTR_NESTING_LEVEL(%ebx) + decl TD_INTR_NESTING_LEVEL(%ebx) MEXITCOUNT jmp doreti @@ -252,10 +252,10 @@ Xstatclock: movl $0, lapic+LA_EOI /* End Of Interrupt to APIC */ FAKE_MCOUNT(13*4(%esp)) - movl PCPU(CURPROC),%ebx - incl P_INTR_NESTING_LEVEL(%ebx) + movl PCPU(CURTHREAD),%ebx + incl TD_INTR_NESTING_LEVEL(%ebx) call forwarded_statclock - decl P_INTR_NESTING_LEVEL(%ebx) + decl TD_INTR_NESTING_LEVEL(%ebx) MEXITCOUNT jmp doreti diff --git a/sys/i386/isa/asc.c b/sys/i386/isa/asc.c index 2cc081e..9042fbc 100644 --- a/sys/i386/isa/asc.c +++ b/sys/i386/isa/asc.c @@ -552,7 +552,7 @@ ascintr(int unit) ***/ STATIC int -ascopen(dev_t dev, int flags, int fmt, struct proc *p) +ascopen(dev_t dev, int flags, int fmt, struct thread *td) { struct asc_unit *scu; int unit; @@ -647,7 +647,7 @@ asc_startread(struct asc_unit *scu) ***/ STATIC int -ascclose(dev_t dev, int flags, int fmt, struct proc *p) +ascclose(dev_t dev, int flags, int fmt, struct thread *td) { int unit = UNIT(minor(dev)); struct asc_unit *scu = unittab + unit; @@ -794,7 +794,7 @@ ascread(dev_t dev, struct uio *uio, int ioflag) ***/ STATIC int -ascioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +ascioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td) { int unit = UNIT(minor(dev)); struct asc_unit *scu = unittab + unit; @@ -859,7 +859,7 @@ ascioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) } STATIC int -ascpoll(dev_t dev, int events, struct proc *p) +ascpoll(dev_t dev, int events, struct thread *td) { int unit = UNIT(minor(dev)); struct asc_unit *scu = unittab + unit; @@ -875,7 +875,7 @@ ascpoll(dev_t dev, int events, struct proc *p) if (!(scu->flags & DMA_ACTIVE)) dma_restart(scu); - selrecord(p, &scu->selp); + selrecord(td, &scu->selp); } } splx(sps); diff --git a/sys/i386/isa/atpic_vector.s b/sys/i386/isa/atpic_vector.s index 6b48737..3a42af4 100644 --- a/sys/i386/isa/atpic_vector.s +++ b/sys/i386/isa/atpic_vector.s @@ -61,8 +61,8 @@ IDTVEC(vec_name) ; \ mov $KPSEL,%ax ; \ mov %ax,%fs ; \ FAKE_MCOUNT((12+ACTUALLY_PUSHED)*4(%esp)) ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ pushl intr_unit + (irq_num) * 4 ; \ call *intr_handler + (irq_num) * 4 ; /* do the work ASAP */ \ enable_icus ; /* (re)enable ASAP (helps edge trigger?) */ \ @@ -70,7 +70,7 @@ IDTVEC(vec_name) ; \ incl cnt+V_INTR ; /* book-keeping can wait */ \ movl intr_countp + (irq_num) * 4,%eax ; \ incl (%eax) ; \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ jmp doreti @@ -104,14 +104,14 @@ IDTVEC(vec_name) ; \ movb %al,imen + IRQ_BYTE(irq_num) ; \ outb %al,$icu+ICU_IMR_OFFSET ; \ enable_icus ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ __CONCAT(Xresume,irq_num): ; \ FAKE_MCOUNT(13*4(%esp)) ; /* XXX late to avoid double count */ \ pushl $irq_num; /* pass the IRQ */ \ call sched_ithd ; \ addl $4, %esp ; /* discard the parameter */ \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ /* We could usually avoid the following jmp by inlining some of */ \ /* doreti, but it's probably better to use less cache. */ \ diff --git a/sys/i386/isa/ctx.c b/sys/i386/isa/ctx.c index 9a387fc..c755004 100644 --- a/sys/i386/isa/ctx.c +++ b/sys/i386/isa/ctx.c @@ -218,7 +218,7 @@ ctxattach(struct isa_device * devp) } static int -ctxopen(dev_t dev, int flags, int fmt, struct proc *p) +ctxopen(dev_t dev, int flags, int fmt, struct thread *td) { struct ctx_soft_registers *sr; u_char unit; @@ -273,7 +273,7 @@ ctxopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -ctxclose(dev_t dev, int flags, int fmt, struct proc *p) +ctxclose(dev_t dev, int flags, int fmt, struct thread *td) { int unit; @@ -383,7 +383,7 @@ ctxread(dev_t dev, struct uio * uio, int ioflag) } static int -ctxioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +ctxioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td) { int error; int unit, i; diff --git a/sys/i386/isa/cx.c b/sys/i386/isa/cx.c index 1c473e9..e9817d0 100644 --- a/sys/i386/isa/cx.c +++ b/sys/i386/isa/cx.c @@ -111,7 +111,7 @@ static void cxoproc (struct tty *tp); static void cxstop (struct tty *tp, int flag); static int cxparam (struct tty *tp, struct termios *t); -int cxopen (dev_t dev, int flag, int mode, struct proc *p) +int cxopen (dev_t dev, int flag, int mode, struct thread *td) { int unit = UNIT (dev); cx_chan_t *c = cxchan[unit]; @@ -162,7 +162,7 @@ int cxopen (dev_t dev, int flag, int mode, struct proc *p) tp = c->ttyp; tp->t_dev = dev; if ((tp->t_state & TS_ISOPEN) && (tp->t_state & TS_XCLUDE) && - suser(p)) + suser_td(td)) return (EBUSY); if (! (tp->t_state & TS_ISOPEN)) { ttychars (tp); @@ -247,7 +247,7 @@ int cxopen (dev_t dev, int flag, int mode, struct proc *p) return (error); } -int cxclose (dev_t dev, int flag, int mode, struct proc *p) +int cxclose (dev_t dev, int flag, int mode, struct thread *td) { int unit = UNIT (dev); cx_chan_t *c = cxchan[unit]; @@ -283,7 +283,7 @@ int cxclose (dev_t dev, int flag, int mode, struct proc *p) return (0); } -int cxioctl (dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +int cxioctl (dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int unit = UNIT (dev); cx_chan_t *c, *m; @@ -419,7 +419,7 @@ int cxioctl (dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) if (! tp) return (EINVAL); #if __FreeBSD__ >= 2 - error = (*linesw[tp->t_line].l_ioctl) (tp, cmd, data, flag, p); + error = (*linesw[tp->t_line].l_ioctl) (tp, cmd, data, flag, td); #else error = (*linesw[tp->t_line].l_ioctl) (tp, cmd, data, flag); #endif diff --git a/sys/i386/isa/cy.c b/sys/i386/isa/cy.c index 9d6f2bb..728ea0a 100644 --- a/sys/i386/isa/cy.c +++ b/sys/i386/isa/cy.c @@ -662,11 +662,11 @@ cyattach_common(cy_iobase, cy_align) } static int -sioopen(dev, flag, mode, p) +sioopen(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct com_s *com; int error; @@ -718,7 +718,7 @@ open_top: } } if (tp->t_state & TS_XCLUDE && - suser(p)) { + suser_td(td)) { error = EBUSY; goto out; } @@ -847,11 +847,11 @@ out: } static int -sioclose(dev, flag, mode, p) +sioclose(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct com_s *com; int mynor; @@ -1605,12 +1605,12 @@ siointr1(com) #endif static int -sioioctl(dev, cmd, data, flag, p) +sioioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct com_s *com; int error; @@ -1639,7 +1639,7 @@ sioioctl(dev, cmd, data, flag, p) } switch (cmd) { case TIOCSETA: - error = suser(p); + error = suser_td(td); if (error != 0) return (error); *ct = *(struct termios *)data; @@ -1689,7 +1689,7 @@ sioioctl(dev, cmd, data, flag, p) if (lt->c_ospeed != 0) dt->c_ospeed = tp->t_ospeed; } - 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); s = spltty(); @@ -1738,7 +1738,7 @@ sioioctl(dev, cmd, data, flag, p) break; case TIOCMSDTRWAIT: /* must be root since the wait applies to following logins */ - error = suser(p); + error = suser_td(td); if (error != 0) { splx(s); return (error); diff --git a/sys/i386/isa/gpib.c b/sys/i386/isa/gpib.c index 8792395..4b96605 100644 --- a/sys/i386/isa/gpib.c +++ b/sys/i386/isa/gpib.c @@ -163,11 +163,11 @@ gpattach(isdp) * i.e. even if gpib5 is open, we can't open another minor device */ static int -gpopen(dev, flags, fmt, p) +gpopen(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { struct gpib_softc *sc = &gpib_sc; u_char unit; @@ -241,11 +241,11 @@ enableremote(unit); * Close gpib device. */ static int -gpclose(dev, flags, fmt, p) +gpclose(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { struct gpib_softc *sc = &gpib_sc; unsigned char unit; @@ -397,7 +397,7 @@ gpwrite(dev, uio, ioflag) write to using a minor device = its GPIB address */ static int -gpioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) +gpioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td) { struct gpibdata *gd = (struct gpibdata *)data; int error,result; diff --git a/sys/i386/isa/gsc.c b/sys/i386/isa/gsc.c index 8d7ded3..29ad157 100644 --- a/sys/i386/isa/gsc.c +++ b/sys/i386/isa/gsc.c @@ -563,7 +563,7 @@ gscattach(struct isa_device *isdp) */ static int -gscopen (dev_t dev, int flags, int fmt, struct proc *p) +gscopen (dev_t dev, int flags, int fmt, struct thread *td) { struct gsc_unit *scu; int unit; @@ -630,7 +630,7 @@ gscopen (dev_t dev, int flags, int fmt, struct proc *p) */ static int -gscclose (dev_t dev, int flags, int fmt, struct proc *p) +gscclose (dev_t dev, int flags, int fmt, struct thread *td) { int unit = UNIT(minor(dev)); struct gsc_unit *scu = unittab + unit; @@ -753,7 +753,7 @@ gscread (dev_t dev, struct uio *uio, int ioflag) */ static int -gscioctl (dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +gscioctl (dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int unit = UNIT(minor(dev)); struct gsc_unit *scu = unittab + unit; diff --git a/sys/i386/isa/icu_vector.s b/sys/i386/isa/icu_vector.s index 6b48737..3a42af4 100644 --- a/sys/i386/isa/icu_vector.s +++ b/sys/i386/isa/icu_vector.s @@ -61,8 +61,8 @@ IDTVEC(vec_name) ; \ mov $KPSEL,%ax ; \ mov %ax,%fs ; \ FAKE_MCOUNT((12+ACTUALLY_PUSHED)*4(%esp)) ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ pushl intr_unit + (irq_num) * 4 ; \ call *intr_handler + (irq_num) * 4 ; /* do the work ASAP */ \ enable_icus ; /* (re)enable ASAP (helps edge trigger?) */ \ @@ -70,7 +70,7 @@ IDTVEC(vec_name) ; \ incl cnt+V_INTR ; /* book-keeping can wait */ \ movl intr_countp + (irq_num) * 4,%eax ; \ incl (%eax) ; \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ jmp doreti @@ -104,14 +104,14 @@ IDTVEC(vec_name) ; \ movb %al,imen + IRQ_BYTE(irq_num) ; \ outb %al,$icu+ICU_IMR_OFFSET ; \ enable_icus ; \ - movl PCPU(CURPROC),%ebx ; \ - incl P_INTR_NESTING_LEVEL(%ebx) ; \ + movl PCPU(CURTHREAD),%ebx ; \ + incl TD_INTR_NESTING_LEVEL(%ebx) ; \ __CONCAT(Xresume,irq_num): ; \ FAKE_MCOUNT(13*4(%esp)) ; /* XXX late to avoid double count */ \ pushl $irq_num; /* pass the IRQ */ \ call sched_ithd ; \ addl $4, %esp ; /* discard the parameter */ \ - decl P_INTR_NESTING_LEVEL(%ebx) ; \ + decl TD_INTR_NESTING_LEVEL(%ebx) ; \ MEXITCOUNT ; \ /* We could usually avoid the following jmp by inlining some of */ \ /* doreti, but it's probably better to use less cache. */ \ diff --git a/sys/i386/isa/ipl.s b/sys/i386/isa/ipl.s index d429f5a..c1b1d86 100644 --- a/sys/i386/isa/ipl.s +++ b/sys/i386/isa/ipl.s @@ -72,8 +72,9 @@ doreti_ast: * since we will be informed of any new ASTs by an IPI. */ cli - movl PCPU(CURPROC),%eax - testl $PS_ASTPENDING | PS_NEEDRESCHED,P_SFLAG(%eax) + movl PCPU(CURTHREAD),%eax + movl TD_KSE(%eax), %eax + testl $KEF_ASTPENDING | KEF_NEEDRESCHED,KE_FLAGS(%eax) je doreti_exit sti pushl %esp /* pass a pointer to the trapframe */ diff --git a/sys/i386/isa/istallion.c b/sys/i386/isa/istallion.c index b8ba4db..0b95211 100644 --- a/sys/i386/isa/istallion.c +++ b/sys/i386/isa/istallion.c @@ -573,7 +573,7 @@ static void stli_mkasyport(stliport_t *portp, asyport_t *pp, struct termios *tiosp); static int stli_memrw(dev_t dev, struct uio *uiop, int flag); static int stli_memioctl(dev_t dev, unsigned long cmd, caddr_t data, - int flag, struct proc *p); + int flag, struct thread *td); static int stli_getbrdstats(caddr_t data); static int stli_getportstats(stliport_t *portp, caddr_t data); static int stli_clrportstats(stliport_t *portp, caddr_t data); @@ -925,7 +925,7 @@ static int stliattach(struct isa_device *idp) /*****************************************************************************/ -STATIC int stliopen(dev_t dev, int flag, int mode, struct proc *p) +STATIC int stliopen(dev_t dev, int flag, int mode, struct thread *td) { struct tty *tp; stliport_t *portp; @@ -933,7 +933,7 @@ STATIC int stliopen(dev_t dev, int flag, int mode, struct proc *p) #if DEBUG printf("stliopen(dev=%x,flag=%x,mode=%x,p=%x)\n", (int) dev, flag, - mode, (int) p); + mode, (int) td); #endif /* @@ -1010,7 +1010,7 @@ stliopen_restart: } } if ((tp->t_state & TS_XCLUDE) && - suser(p)) { + suser_td(td)) { error = EBUSY; goto stliopen_end; } @@ -1054,7 +1054,7 @@ stliopen_end: /*****************************************************************************/ -STATIC int stliclose(dev_t dev, int flag, int mode, struct proc *p) +STATIC int stliclose(dev_t dev, int flag, int mode, struct thread *td) { struct tty *tp; stliport_t *portp; @@ -1062,7 +1062,7 @@ STATIC int stliclose(dev_t dev, int flag, int mode, struct proc *p) #if DEBUG printf("stliclose(dev=%s,flag=%x,mode=%x,p=%p)\n", - devtoname(dev), flag, mode, (void *) p); + devtoname(dev), flag, mode, (void *) td); #endif if (minor(dev) & STL_MEMDEV) @@ -1142,7 +1142,7 @@ STATIC int stliwrite(dev_t dev, struct uio *uiop, int flag) /*****************************************************************************/ STATIC int stliioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, - struct proc *p) + struct thread *td) { struct termios *newtios, *localtios; struct tty *tp; @@ -1153,11 +1153,11 @@ STATIC int stliioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, #if DEBUG printf("stliioctl(dev=%s,cmd=%lx,data=%p,flag=%x,p=%p)\n", - devtoname(dev), cmd, (void *) data, flag, (void *) p); + devtoname(dev), cmd, (void *) data, flag, (void *) td); #endif if (minor(dev) & STL_MEMDEV) - return(stli_memioctl(dev, cmd, data, flag, p)); + return(stli_memioctl(dev, cmd, data, flag, td)); portp = stli_dev2port(dev); if (portp == (stliport_t *) NULL) @@ -1182,7 +1182,7 @@ STATIC int stliioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, switch (cmd) { case TIOCSETA: - if ((error = suser(p)) == 0) + if ((error = suser_td(td)) == 0) *localtios = *((struct termios *) data); break; case TIOCGETA: @@ -1249,7 +1249,7 @@ STATIC int stliioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, * Call the line discipline and the common command processing to * process this command (if they can). */ - 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); @@ -1318,7 +1318,7 @@ STATIC int stliioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, *((int *) data) = (portp->sigs | TIOCM_LE); break; case TIOCMSDTRWAIT: - if ((error = suser(p)) == 0) + if ((error = suser_td(td)) == 0) portp->dtrwait = *((int *) data) * hz / 100; break; case TIOCMGDTRWAIT: @@ -3799,7 +3799,7 @@ STATIC int stli_memrw(dev_t dev, struct uio *uiop, int flag) */ static int stli_memioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, - struct proc *p) + struct thread *td) { stlibrd_t *brdp; int brdnr, rc; diff --git a/sys/i386/isa/loran.c b/sys/i386/isa/loran.c index cedcd0f..9ad1a4a 100644 --- a/sys/i386/isa/loran.c +++ b/sys/i386/isa/loran.c @@ -328,7 +328,7 @@ loranattach(struct isa_device *isdp) } static int -loranopen (dev_t dev, int flags, int fmt, struct proc *p) +loranopen (dev_t dev, int flags, int fmt, struct thread *td) { int idx; @@ -340,7 +340,7 @@ loranopen (dev_t dev, int flags, int fmt, struct proc *p) } static int -loranclose(dev_t dev, int flags, int fmt, struct proc *p) +loranclose(dev_t dev, int flags, int fmt, struct thread *td) { return(0); } diff --git a/sys/i386/isa/matcd/matcd.c b/sys/i386/isa/matcd/matcd.c index 7c3e758..0ec1c2e 100644 --- a/sys/i386/isa/matcd/matcd.c +++ b/sys/i386/isa/matcd/matcd.c @@ -608,7 +608,7 @@ static int docmd(char * cmd, int ldrive, int cdrive, <15> the drive to be locked while being accessed. ---------------------------------------------------------------------------*/ int matcdopen(dev_t dev, int flags, int fmt, - struct proc *p) + struct thread *td) { int cdrive,ldrive,partition,controller,lock; struct matcd_data *cd; @@ -797,7 +797,7 @@ int matcdopen(dev_t dev, int flags, int fmt, ---------------------------------------------------------------------------*/ int matcdclose(dev_t dev, int flags, int fmt, - struct proc *p) + struct thread *td) { int ldrive,cdrive,port,partition,controller,lock; struct matcd_data *cd; @@ -985,7 +985,7 @@ static void matcd_start(int controller) ---------------------------------------------------------------------------*/ int matcdioctl(dev_t dev, u_long command, caddr_t addr, - int flags, struct proc *p) + int flags, struct thread *td) { struct matcd_data *cd; int ldrive,cdrive,partition; @@ -2062,7 +2062,7 @@ nextblock: int docmd(char * cmd, int ldrive, int cdrive, int controller, int port) { - int retries,i,z; + int retries,i=0,z; lockbus(controller, ldrive); /*Request bus*/ retries=3; diff --git a/sys/i386/isa/mcd.c b/sys/i386/isa/mcd.c index 6f8c0f7..f295a43 100644 --- a/sys/i386/isa/mcd.c +++ b/sys/i386/isa/mcd.c @@ -270,7 +270,7 @@ int mcd_attach(struct isa_device *dev) return 1; } -int mcdopen(dev_t dev, int flags, int fmt, struct proc *p) +int mcdopen(dev_t dev, int flags, int fmt, struct thread *td) { int unit,part,phys,r,retry; struct mcd_data *cd; @@ -362,7 +362,7 @@ MCD_TRACE("open: partition=%d, disksize = %ld, blksize=%d\n", return ENXIO; } -int mcdclose(dev_t dev, int flags, int fmt, struct proc *p) +int mcdclose(dev_t dev, int flags, int fmt, struct thread *td) { int unit,part; struct mcd_data *cd; @@ -504,7 +504,7 @@ static void mcd_start(int unit) return; } -int mcdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) +int mcdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) { struct mcd_data *cd; int unit,part,retry,r; diff --git a/sys/i386/isa/mse.c b/sys/i386/isa/mse.c index 073ea7a..915bc3f 100644 --- a/sys/i386/isa/mse.c +++ b/sys/i386/isa/mse.c @@ -394,11 +394,11 @@ mse_detach(dev) * Exclusive open the mouse, initialize it and enable interrupts. */ static int -mseopen(dev, flags, fmt, p) +mseopen(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { mse_softc_t *sc; int s; @@ -434,11 +434,11 @@ mseopen(dev, flags, fmt, p) * mseclose: just turn off mouse innterrupts. */ static int -mseclose(dev, flags, fmt, p) +mseclose(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { mse_softc_t *sc = devclass_get_softc(mse_devclass, MSE_UNIT(dev)); int s; @@ -525,12 +525,12 @@ mseread(dev, uio, ioflag) * mseioctl: process ioctl commands. */ static int -mseioctl(dev, cmd, addr, flag, p) +mseioctl(dev, cmd, addr, flag, td) dev_t dev; u_long cmd; caddr_t addr; int flag; - struct proc *p; + struct thread *td; { mse_softc_t *sc = devclass_get_softc(mse_devclass, MSE_UNIT(dev)); mousestatus_t status; @@ -642,10 +642,10 @@ mseioctl(dev, cmd, addr, flag, p) * msepoll: check for mouse input to be processed. */ static int -msepoll(dev, events, p) +msepoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { mse_softc_t *sc = devclass_get_softc(mse_devclass, MSE_UNIT(dev)); int s; @@ -662,7 +662,7 @@ msepoll(dev, events, p) * Since this is an exclusive open device, any previous * proc pointer is trash now, so we can just assign it. */ - selrecord(p, &sc->sc_selp); + selrecord(td, &sc->sc_selp); } } splx(s); diff --git a/sys/i386/isa/npx.c b/sys/i386/isa/npx.c index 4fe3d04..84534ea 100644 --- a/sys/i386/isa/npx.c +++ b/sys/i386/isa/npx.c @@ -128,23 +128,23 @@ void stop_emulating __P((void)); #endif /* __GNUC__ */ #ifdef CPU_ENABLE_SSE -#define GET_FPU_CW(proc) \ +#define GET_FPU_CW(thread) \ (cpu_fxsr ? \ - (proc)->p_addr->u_pcb.pcb_save.sv_xmm.sv_env.en_cw : \ - (proc)->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_cw) -#define GET_FPU_SW(proc) \ + (thread)->td_pcb->pcb_save.sv_xmm.sv_env.en_cw : \ + (thread)->td_pcb->pcb_save.sv_87.sv_env.en_cw) +#define GET_FPU_SW(thread) \ (cpu_fxsr ? \ - (proc)->p_addr->u_pcb.pcb_save.sv_xmm.sv_env.en_sw : \ - (proc)->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_sw) + (thread)->td_pcb->pcb_save.sv_xmm.sv_env.en_sw : \ + (thread)->td_pcb->pcb_save.sv_87.sv_env.en_sw) #define GET_FPU_EXSW_PTR(pcb) \ (cpu_fxsr ? \ &(pcb)->pcb_save.sv_xmm.sv_ex_sw : \ &(pcb)->pcb_save.sv_87.sv_ex_sw) #else /* CPU_ENABLE_SSE */ -#define GET_FPU_CW(proc) \ - (proc->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_cw) -#define GET_FPU_SW(proc) \ - (proc->p_addr->u_pcb.pcb_save.sv_87.sv_env.en_sw) +#define GET_FPU_CW(thread) \ + (thread->td_pcb->pcb_save.sv_87.sv_env.en_cw) +#define GET_FPU_SW(thread) \ + (thread->td_pcb->pcb_save.sv_87.sv_env.en_sw) #define GET_FPU_EXSW_PTR(pcb) \ (&(pcb)->pcb_save.sv_87.sv_ex_sw) #endif /* CPU_ENABLE_SSE */ @@ -241,7 +241,7 @@ static void npx_intr(dummy) void *dummy; { - struct proc *p; + struct thread *td; /* * The BUSY# latch must be cleared in all cases so that the next @@ -250,22 +250,22 @@ npx_intr(dummy) outb(0xf0, 0); /* - * npxproc is normally non-null here. In that case, schedule an + * npxthread is normally non-null here. In that case, schedule an * AST to finish the exception handling in the correct context - * (this interrupt may occur after the process has entered the + * (this interrupt may occur after the thread has entered the * kernel via a syscall or an interrupt). Otherwise, the npx - * state of the process that caused this interrupt must have been - * pushed to the process' pcb, and clearing of the busy latch + * state of the thread that caused this interrupt must have been + * pushed to the thread' pcb, and clearing of the busy latch * above has finished the (essentially null) handling of this * interrupt. Control will eventually return to the instruction * that caused it and it will repeat. We will eventually (usually * soon) win the race to handle the interrupt properly. */ - p = PCPU_GET(npxproc); - if (p != NULL) { - p->p_addr->u_pcb.pcb_flags |= PCB_NPXTRAP; + td = PCPU_GET(npxthread); + if (td != NULL) { + td->td_pcb->pcb_flags |= PCB_NPXTRAP; mtx_lock_spin(&sched_lock); - p->p_sflag |= PS_ASTPENDING; + td->td_kse->ke_flags |= KEF_ASTPENDING; mtx_unlock_spin(&sched_lock); } } @@ -570,7 +570,7 @@ npxinit(control) /* * fninit has the same h/w bugs as fnsave. Use the detoxified * fnsave to throw away any junk in the fpu. npxsave() initializes - * the fpu and sets npxproc = NULL as important side effects. + * the fpu and sets npxthread = NULL as important side effects. */ savecrit = critical_enter(); npxsave(&dummy); @@ -586,13 +586,13 @@ npxinit(control) * Free coprocessor (if we have it). */ void -npxexit(p) - struct proc *p; +npxexit(td) + struct thread *td; { critical_t savecrit; savecrit = critical_enter(); - if (p == PCPU_GET(npxproc)) + if (td == PCPU_GET(npxthread)) npxsave(&PCPU_GET(curpcb)->pcb_save); critical_exit(savecrit); #ifdef NPX_DEBUG @@ -607,8 +607,9 @@ npxexit(p) */ if (masked_exceptions & 0x0d) log(LOG_ERR, - "pid %d (%s) exited with masked floating point exceptions 0x%02x\n", - p->p_pid, p->p_comm, masked_exceptions); + "pid %d (%s) exited with masked floating" + " point exceptions 0x%02x\n", + td->td_proc->p_pid, td->td_proc->p_comm, masked_exceptions); } #endif } @@ -809,8 +810,8 @@ npxtrap() u_long *exstat; if (!npx_exists) { - printf("npxtrap: npxproc = %p, curproc = %p, npx_exists = %d\n", - PCPU_GET(npxproc), curproc, npx_exists); + printf("npxtrap: npxthread = %p, curthread = %p, npx_exists = %d\n", + PCPU_GET(npxthread), curthread, npx_exists); panic("npxtrap from nowhere"); } savecrit = critical_enter(); @@ -820,18 +821,18 @@ npxtrap() * state to memory. Fetch the relevant parts of the state from * wherever they are. */ - if (PCPU_GET(npxproc) != curproc) { - control = GET_FPU_CW(curproc); - status = GET_FPU_SW(curproc); + if (PCPU_GET(npxthread) != curthread) { + control = GET_FPU_CW(curthread); + status = GET_FPU_SW(curthread); } else { fnstcw(&control); fnstsw(&status); } - exstat = GET_FPU_EXSW_PTR(&curproc->p_addr->u_pcb); + exstat = GET_FPU_EXSW_PTR(curthread->td_pcb); *exstat = status; - if (PCPU_GET(npxproc) != curproc) - GET_FPU_SW(curproc) &= ~0x80bf; + if (PCPU_GET(npxthread) != curthread) + GET_FPU_SW(curthread) &= ~0x80bf; else fnclex(); critical_exit(savecrit); @@ -841,7 +842,7 @@ npxtrap() /* * Implement device not available (DNA) exception * - * It would be better to switch FP context here (if curproc != npxproc) + * It would be better to switch FP context here (if curthread != npxthread) * and not necessarily for every context switch, but it is too hard to * access foreign pcb's. */ @@ -853,9 +854,9 @@ npxdna() if (!npx_exists) return (0); - if (PCPU_GET(npxproc) != NULL) { - printf("npxdna: npxproc = %p, curproc = %p\n", - PCPU_GET(npxproc), curproc); + if (PCPU_GET(npxthread) != NULL) { + printf("npxdna: npxthread = %p, curthread = %p\n", + PCPU_GET(npxthread), curthread); panic("npxdna"); } s = critical_enter(); @@ -863,7 +864,7 @@ npxdna() /* * Record new context early in case frstor causes an IRQ13. */ - PCPU_SET(npxproc, CURPROC); + PCPU_SET(npxthread, curthread); exstat = GET_FPU_EXSW_PTR(PCPU_GET(curpcb)); *exstat = 0; @@ -895,13 +896,13 @@ npxdna() * after the process has entered the kernel. It may even be delivered after * the fnsave here completes. A spurious IRQ13 for the fnsave is handled in * the same way as a very-late-arriving non-spurious IRQ13 from user mode: - * it is normally ignored at first because we set npxproc to NULL; it is + * it is normally ignored at first because we set npxthread to NULL; it is * normally retriggered in npxdna() after return to user mode. * * npxsave() must be called with interrupts disabled, so that it clears - * npxproc atomically with saving the state. We require callers to do the + * npxthread atomically with saving the state. We require callers to do the * disabling, since most callers need to disable interrupts anyway to call - * npxsave() atomically with checking npxproc. + * npxsave() atomically with checking npxthread. * * A previous version of npxsave() went to great lengths to excecute fnsave * with interrupts enabled in case executing it froze the CPU. This case @@ -917,7 +918,7 @@ npxsave(addr) fpusave(addr); start_emulating(); - PCPU_SET(npxproc, NULL); + PCPU_SET(npxthread, NULL); } static void diff --git a/sys/i386/isa/pcaudio.c b/sys/i386/isa/pcaudio.c index ebfce44..8002fcc 100644 --- a/sys/i386/isa/pcaudio.c +++ b/sys/i386/isa/pcaudio.c @@ -361,7 +361,7 @@ DRIVER_MODULE(pca, isa, pca_driver, pca_devclass, 0, 0); static int -pcaopen(dev_t dev, int flags, int fmt, struct proc *p) +pcaopen(dev_t dev, int flags, int fmt, struct thread *td) { /* audioctl device can always be opened */ if (minor(dev) == 128) @@ -389,7 +389,7 @@ pcaopen(dev_t dev, int flags, int fmt, struct proc *p) static int -pcaclose(dev_t dev, int flags, int fmt, struct proc *p) +pcaclose(dev_t dev, int flags, int fmt, struct thread *td) { /* audioctl device can always be closed */ if (minor(dev) == 128) @@ -460,7 +460,7 @@ pcawrite(dev_t dev, struct uio *uio, int flag) static int -pcaioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +pcaioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { audio_info_t *auptr; @@ -560,7 +560,7 @@ pcaintr(struct clockframe *frame) static int -pcapoll(dev_t dev, int events, struct proc *p) +pcapoll(dev_t dev, int events, struct thread *td) { int s; int revents = 0; @@ -572,7 +572,7 @@ pcapoll(dev_t dev, int events, struct proc *p) !pca_status.in_use[2]) revents |= events & (POLLOUT | POLLWRNORM); else - selrecord(p, &pca_status.wsel); + selrecord(td, &pca_status.wsel); } splx(s); return (revents); diff --git a/sys/i386/isa/pcvt/pcvt_drv.c b/sys/i386/isa/pcvt/pcvt_drv.c index 3c1cdea..3b0a64f 100644 --- a/sys/i386/isa/pcvt/pcvt_drv.c +++ b/sys/i386/isa/pcvt/pcvt_drv.c @@ -280,7 +280,7 @@ pcvt_attach(device_t dev) * driver open *---------------------------------------------------------------------------*/ static int -pcvt_open(dev_t dev, int flag, int mode, struct proc *p) +pcvt_open(dev_t dev, int flag, int mode, struct thread *td) { register struct tty *tp; register struct video_state *vsx; @@ -316,7 +316,7 @@ pcvt_open(dev_t dev, int flag, int mode, struct proc *p) (*linesw[tp->t_line].l_modem)(tp, 1); /* fake connection */ winsz = 1; /* set winsize later */ } - else if (tp->t_state & TS_XCLUDE && suser(p)) + else if (tp->t_state & TS_XCLUDE && suser_td(td)) { return (EBUSY); } @@ -348,7 +348,7 @@ pcvt_open(dev_t dev, int flag, int mode, struct proc *p) * driver close *---------------------------------------------------------------------------*/ static int -pcvt_close(dev_t dev, int flag, int mode, struct proc *p) +pcvt_close(dev_t dev, int flag, int mode, struct thread *td) { register struct tty *tp; register struct video_state *vsx; @@ -378,7 +378,7 @@ pcvt_close(dev_t dev, int flag, int mode, struct proc *p) * driver ioctl *---------------------------------------------------------------------------*/ static int -pcvt_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +pcvt_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { register int error; register struct tty *tp; @@ -396,7 +396,7 @@ pcvt_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) */ #ifdef XSERVER - if((error = usl_vt_ioctl(dev, cmd, data, flag, p)) >= 0) + if((error = usl_vt_ioctl(dev, cmd, data, flag, td)) >= 0) return error; #endif /* XSERVER */ @@ -406,7 +406,7 @@ pcvt_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) if((error = vgaioctl(dev,cmd,data,flag)) >= 0) return error; - if((error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p)) + if((error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, td)) != ENOIOCTL) return (error); diff --git a/sys/i386/isa/pcvt/pcvt_ext.c b/sys/i386/isa/pcvt/pcvt_ext.c index 967c928..7c9ed5f 100644 --- a/sys/i386/isa/pcvt/pcvt_ext.c +++ b/sys/i386/isa/pcvt/pcvt_ext.c @@ -2392,8 +2392,9 @@ vgapage(int new_screen) * ioctl handling for VT_USL mode *---------------------------------------------------------------------------*/ int -usl_vt_ioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p) +usl_vt_ioctl(dev_t dev, int cmd, caddr_t data, int flag, struct thread *td) { + struct proc *p = td->td_proc; int i, j, error, opri; struct vt_mode newmode; @@ -2613,9 +2614,9 @@ usl_vt_ioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p) /* grant the process IO access; only allowed if euid == 0 */ /* and insecure */ { - struct trapframe *fp = p->p_frame; + struct trapframe *fp = td->td_frame; - error = suser(p); + error = suser_td(td); if (error != 0) return (error); if (securelevel > 0) @@ -2629,7 +2630,7 @@ usl_vt_ioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p) case KDDISABIO: /* abandon IO access permission */ { - struct trapframe *fp = p->p_frame; + struct trapframe *fp = td->td_frame; fp->tf_eflags &= ~PSL_IOPL; return 0; } diff --git a/sys/i386/isa/pcvt/pcvt_hdr.h b/sys/i386/isa/pcvt/pcvt_hdr.h index 4c9f540..46ea500 100644 --- a/sys/i386/isa/pcvt/pcvt_hdr.h +++ b/sys/i386/isa/pcvt/pcvt_hdr.h @@ -994,7 +994,7 @@ void update_hp ( struct video_state *svsp ); void update_led ( void ); #ifdef XSERVER -int usl_vt_ioctl (dev_t dev, int cmd, caddr_t data, int flag, struct proc *); +int usl_vt_ioctl (dev_t dev, int cmd, caddr_t data, int flag, struct thread *); #endif void vga10_vga10 ( u_char *invga, u_char *outvga ); diff --git a/sys/i386/isa/rc.c b/sys/i386/isa/rc.c index e4252e0..59e8dff 100644 --- a/sys/i386/isa/rc.c +++ b/sys/i386/isa/rc.c @@ -715,10 +715,10 @@ rc_stop(tp, rw) } static int -rcopen(dev, flag, mode, p) +rcopen(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { register struct rc_chans *rc; register struct tty *tp; @@ -764,7 +764,7 @@ again: } } if (tp->t_state & TS_XCLUDE && - suser(p)) { + suser_td(td)) { error = EBUSY; goto out; } @@ -810,10 +810,10 @@ out: } static int -rcclose(dev, flag, mode, p) +rcclose(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { register struct rc_chans *rc; register struct tty *tp; @@ -1064,18 +1064,18 @@ struct rc_softc *rcb; } static int -rcioctl(dev, cmd, data, flag, p) +rcioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; int flag; caddr_t data; -struct proc *p; +struct thread *td; { register struct rc_chans *rc = &rc_chans[GET_UNIT(dev)]; register int s, error; struct tty *tp = rc->rc_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); error = ttioctl(tp, cmd, data, flag); @@ -1118,7 +1118,7 @@ struct proc *p; break; case TIOCMSDTRWAIT: - error = suser(p); + error = suser_td(td); if (error != 0) { splx(s); return (error); diff --git a/sys/i386/isa/scd.c b/sys/i386/isa/scd.c index 1ab5afa..4561d90 100644 --- a/sys/i386/isa/scd.c +++ b/sys/i386/isa/scd.c @@ -232,7 +232,7 @@ scd_attach(struct isa_device *dev) } static int -scdopen(dev_t dev, int flags, int fmt, struct proc *p) +scdopen(dev_t dev, int flags, int fmt, struct thread *td) { int unit,part,phys; int rc; @@ -286,7 +286,7 @@ scdopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -scdclose(dev_t dev, int flags, int fmt, struct proc *p) +scdclose(dev_t dev, int flags, int fmt, struct thread *td) { int unit,part,phys; struct scd_data *cd; @@ -418,7 +418,7 @@ scd_start(int unit) } static int -scdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) +scdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) { struct scd_data *cd; int unit,part; diff --git a/sys/i386/isa/spic.c b/sys/i386/isa/spic.c index 9593d73..a708658 100644 --- a/sys/i386/isa/spic.c +++ b/sys/i386/isa/spic.c @@ -362,7 +362,7 @@ spictimeout(void *arg) } static int -spicopen(dev_t dev, int flag, int fmt, struct proc *p) +spicopen(dev_t dev, int flag, int fmt, struct thread *td) { struct spic_softc *sc; @@ -380,7 +380,7 @@ spicopen(dev_t dev, int flag, int fmt, struct proc *p) } static int -spicclose(dev_t dev, int flag, int fmt, struct proc *p) +spicclose(dev_t dev, int flag, int fmt, struct thread *td) { struct spic_softc *sc; @@ -427,7 +427,7 @@ spicread(dev_t dev, struct uio *uio, int flag) } static int -spicioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +spicioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct spic_softc *sc; @@ -437,7 +437,7 @@ spicioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) } static int -spicpoll(dev_t dev, int events, struct proc *p) +spicpoll(dev_t dev, int events, struct thread *td) { struct spic_softc *sc; int revents = 0, s; @@ -448,7 +448,7 @@ spicpoll(dev_t dev, int events, struct proc *p) if (sc->sc_count) revents |= events & (POLLIN | POLLRDNORM); else - selrecord(p, &sc->sc_rsel); /* Who shall we wake? */ + selrecord(td, &sc->sc_rsel); /* Who shall we wake? */ } splx(s); diff --git a/sys/i386/isa/spigot.c b/sys/i386/isa/spigot.c index db4a926..0bd87ff 100644 --- a/sys/i386/isa/spigot.c +++ b/sys/i386/isa/spigot.c @@ -161,7 +161,7 @@ spigot_attach(struct isa_device *devp) } static int -spigot_open(dev_t dev, int flags, int fmt, struct proc *p) +spigot_open(dev_t dev, int flags, int fmt, struct thread *td) { int error; struct spigot_softc *ss = (struct spigot_softc *)&spigot_softc[UNIT(dev)]; @@ -179,7 +179,7 @@ struct spigot_softc *ss = (struct spigot_softc *)&spigot_softc[UNIT(dev)]; * require sufficient privilege soon and nothing much can be done * without them. */ - error = suser(p); + error = suser_td(td); if (error != 0) return error; if (securelevel > 0) @@ -194,7 +194,7 @@ struct spigot_softc *ss = (struct spigot_softc *)&spigot_softc[UNIT(dev)]; } static int -spigot_close(dev_t dev, int flags, int fmt, struct proc *p) +spigot_close(dev_t dev, int flags, int fmt, struct thread *td) { struct spigot_softc *ss = (struct spigot_softc *)&spigot_softc[UNIT(dev)]; @@ -221,7 +221,7 @@ spigot_read(dev_t dev, struct uio *uio, int ioflag) static int -spigot_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +spigot_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int error; struct spigot_softc *ss = (struct spigot_softc *)&spigot_softc[UNIT(dev)]; @@ -230,21 +230,21 @@ struct spigot_info *info; if(!data) return(EINVAL); switch(cmd){ case SPIGOT_SETINT: - ss->p = p; + ss->p = td->td_proc; ss->signal_num = *((int *)data); break; case SPIGOT_IOPL_ON: /* allow access to the IO PAGE */ #if !defined(SPIGOT_UNSECURE) - error = suser(p); + error = suser_td(td); if (error != 0) return error; if (securelevel > 0) return EPERM; #endif - p->p_frame->tf_eflags |= PSL_IOPL; + td->td_frame->tf_eflags |= PSL_IOPL; break; case SPIGOT_IOPL_OFF: /* deny access to the IO PAGE */ - p->p_frame->tf_eflags &= ~PSL_IOPL; + td->td_frame->tf_eflags &= ~PSL_IOPL; break; case SPIGOT_GET_INFO: info = (struct spigot_info *)data; diff --git a/sys/i386/isa/spkr.c b/sys/i386/isa/spkr.c index 0fadea8..e0986de 100644 --- a/sys/i386/isa/spkr.c +++ b/sys/i386/isa/spkr.c @@ -460,11 +460,11 @@ static int spkr_active = FALSE; /* exclusion flag */ static char *spkr_inbuf; /* incoming buf */ int -spkropen(dev, flags, fmt, p) +spkropen(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { #ifdef DEBUG (void) printf("spkropen: entering with dev = %s\n", devtoname(dev)); @@ -519,11 +519,11 @@ spkrwrite(dev, uio, ioflag) } int -spkrclose(dev, flags, fmt, p) +spkrclose(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { #ifdef DEBUG (void) printf("spkrclose: entering with dev = %s\n", devtoname(dev)); @@ -542,12 +542,12 @@ spkrclose(dev, flags, fmt, p) } int -spkrioctl(dev, cmd, cmdarg, flags, p) +spkrioctl(dev, cmd, cmdarg, flags, td) dev_t dev; unsigned long cmd; caddr_t cmdarg; int flags; - struct proc *p; + struct thread *td; { #ifdef DEBUG (void) printf("spkrioctl: entering with dev = %s, cmd = %lx\n", diff --git a/sys/i386/isa/stallion.c b/sys/i386/isa/stallion.c index b77ec96..c9c0df5 100644 --- a/sys/i386/isa/stallion.c +++ b/sys/i386/isa/stallion.c @@ -484,7 +484,7 @@ static void stl_disableintrs(stlport_t *portp); static void stl_sendbreak(stlport_t *portp, long len); static void stl_flush(stlport_t *portp, int flag); static int stl_memioctl(dev_t dev, unsigned long cmd, caddr_t data, - int flag, struct proc *p); + int flag, struct thread *td); static int stl_getbrdstats(caddr_t data); static int stl_getportstats(stlport_t *portp, caddr_t data); static int stl_clrportstats(stlport_t *portp, caddr_t data); @@ -759,7 +759,7 @@ void stlpciattach(pcici_t tag, int unit) /*****************************************************************************/ -STATIC int stlopen(dev_t dev, int flag, int mode, struct proc *p) +STATIC int stlopen(dev_t dev, int flag, int mode, struct thread *td) { struct tty *tp; stlport_t *portp; @@ -767,7 +767,7 @@ STATIC int stlopen(dev_t dev, int flag, int mode, struct proc *p) #if DEBUG printf("stlopen(dev=%x,flag=%x,mode=%x,p=%x)\n", (int) dev, flag, - mode, (int) p); + mode, (int) td); #endif /* @@ -832,7 +832,7 @@ stlopen_restart: } } if ((tp->t_state & TS_XCLUDE) && - suser(p)) { + suser_td(td)) { error = EBUSY; goto stlopen_end; } @@ -876,7 +876,7 @@ stlopen_end: /*****************************************************************************/ -STATIC int stlclose(dev_t dev, int flag, int mode, struct proc *p) +STATIC int stlclose(dev_t dev, int flag, int mode, struct thread *td) { struct tty *tp; stlport_t *portp; @@ -884,7 +884,7 @@ STATIC int stlclose(dev_t dev, int flag, int mode, struct proc *p) #if DEBUG printf("stlclose(dev=%s,flag=%x,mode=%x,p=%p)\n", devtoname(dev), - flag, mode, (void *) p); + flag, mode, (void *) td); #endif if (minor(dev) & STL_MEMDEV) @@ -934,7 +934,7 @@ STATIC int stlstop(struct tty *tp, int rw) /*****************************************************************************/ STATIC int stlioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, - struct proc *p) + struct thread *td) { struct termios *newtios, *localtios; struct tty *tp; @@ -943,11 +943,11 @@ STATIC int stlioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, #if DEBUG printf("stlioctl(dev=%s,cmd=%lx,data=%p,flag=%x,p=%p)\n", - devtoname(dev), cmd, (void *) data, flag, (void *) p); + devtoname(dev), cmd, (void *) data, flag, (void *) td); #endif if (minor(dev) & STL_MEMDEV) - return(stl_memioctl(dev, cmd, data, flag, p)); + return(stl_memioctl(dev, cmd, data, flag, td)); portp = stl_dev2port(dev); if (portp == (stlport_t *) NULL) @@ -970,7 +970,7 @@ STATIC int stlioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, switch (cmd) { case TIOCSETA: - if ((error = suser(p)) == 0) + if ((error = suser_td(td)) == 0) *localtios = *((struct termios *) data); break; case TIOCGETA: @@ -1037,7 +1037,7 @@ STATIC int stlioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, * Call the line discipline and the common command processing to * process this command (if they can). */ - 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); @@ -1088,7 +1088,7 @@ STATIC int stlioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, *((int *) data) = (stl_getsignals(portp) | TIOCM_LE); break; case TIOCMSDTRWAIT: - if ((error = suser(p)) == 0) + if ((error = suser_td(td)) == 0) portp->dtrwait = *((int *) data) * hz / 100; break; case TIOCMGDTRWAIT: @@ -3048,7 +3048,7 @@ static int stl_clrportstats(stlport_t *portp, caddr_t data) */ static int stl_memioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag, - struct proc *p) + struct thread *td) { stlbrd_t *brdp; int brdnr, rc; diff --git a/sys/i386/isa/tw.c b/sys/i386/isa/tw.c index 4bb509d..5d68678 100644 --- a/sys/i386/isa/tw.c +++ b/sys/i386/isa/tw.c @@ -418,11 +418,11 @@ static int twattach(idp) return (1); } -int twopen(dev, flag, mode, p) +int twopen(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct tw_sc *sc = &tw_sc[TWUNIT(dev)]; int s; @@ -438,11 +438,11 @@ int twopen(dev, flag, mode, p) return(0); } -int twclose(dev, flag, mode, p) +int twclose(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct tw_sc *sc = &tw_sc[TWUNIT(dev)]; int s; @@ -544,10 +544,10 @@ int twwrite(dev, uio, ioflag) * Determine if there is data available for reading */ -int twpoll(dev, events, p) +int twpoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { struct tw_sc *sc; int s; @@ -560,7 +560,7 @@ int twpoll(dev, events, p) if(sc->sc_nextin != sc->sc_nextout) revents |= events & (POLLIN | POLLRDNORM); else - selrecord(p, &sc->sc_selp); + selrecord(td, &sc->sc_selp); } splx(s); return(revents); diff --git a/sys/i386/isa/vesa.c b/sys/i386/isa/vesa.c index 0fa16b5..09d2a7d 100644 --- a/sys/i386/isa/vesa.c +++ b/sys/i386/isa/vesa.c @@ -672,6 +672,8 @@ vesa_bios_init(void) continue; /* reject unsupported modes */ +#define DOTHIS 1 +#ifdef DOTHIS #if 0 if ((vmode.v_modeattr & (V_MODESUPP | V_MODEOPTINFO | V_MODENONVGA)) @@ -689,6 +691,7 @@ vesa_bios_init(void) continue; } #endif +#endif /* DOTHIS */ /* expand the array if necessary */ if (modes >= vesa_vmode_max) { diff --git a/sys/i386/isa/wt.c b/sys/i386/isa/wt.c index 0adf3c8..4dc9818 100644 --- a/sys/i386/isa/wt.c +++ b/sys/i386/isa/wt.c @@ -285,7 +285,7 @@ COMPAT_ISA_DRIVER(wt, wtdriver); * Open routine, called on every device open. */ static int -wtopen (dev_t dev, int flag, int fmt, struct proc *p) +wtopen (dev_t dev, int flag, int fmt, struct thread *td) { int u = minor (dev) & T_UNIT; wtinfo_t *t = wttab + u; @@ -367,7 +367,7 @@ wtopen (dev_t dev, int flag, int fmt, struct proc *p) * Close routine, called on last device close. */ static int -wtclose (dev_t dev, int flags, int fmt, struct proc *p) +wtclose (dev_t dev, int flags, int fmt, struct thread *td) { int u = minor (dev) & T_UNIT; wtinfo_t *t = wttab + u; @@ -416,7 +416,7 @@ done: * ioctl (int fd, MTIOCTOP, struct mtop *buf) -- do BSD-like op */ static int -wtioctl (dev_t dev, u_long cmd, caddr_t arg, int flags, struct proc *p) +wtioctl (dev_t dev, u_long cmd, caddr_t arg, int flags, struct thread *td) { int u = minor (dev) & T_UNIT; wtinfo_t *t = wttab + u; diff --git a/sys/i386/linux/linux.h b/sys/i386/linux/linux.h index 594ebfc..2b2a916 100644 --- a/sys/i386/linux/linux.h +++ b/sys/i386/linux/linux.h @@ -40,8 +40,8 @@ */ extern u_char linux_debug_map[]; #define ldebug(name) isclr(linux_debug_map, LINUX_SYS_linux_ ## name) -#define ARGS(nm, fmt) "linux(%ld): "#nm"("fmt")\n", (long)p->p_pid -#define LMSG(fmt) "linux(%ld): "fmt"\n", (long)p->p_pid +#define ARGS(nm, fmt) "linux(%ld): "#nm"("fmt")\n", (long)td->td_proc->p_pid +#define LMSG(fmt) "linux(%ld): "fmt"\n", (long)td->td_proc->p_pid #ifdef MALLOC_DECLARE MALLOC_DECLARE(M_LINUX); @@ -453,9 +453,9 @@ extern struct sysentvec elf_linux_sysvec; * Pluggable ioctl handlers */ struct linux_ioctl_args; -struct proc; +struct thread; -typedef int linux_ioctl_function_t(struct proc *, struct linux_ioctl_args *); +typedef int linux_ioctl_function_t(struct thread *, struct linux_ioctl_args *); struct linux_ioctl_handler { linux_ioctl_function_t *func; diff --git a/sys/i386/linux/linux_machdep.c b/sys/i386/linux/linux_machdep.c index dfae7f4..ba443bb 100644 --- a/sys/i386/linux/linux_machdep.c +++ b/sys/i386/linux/linux_machdep.c @@ -99,13 +99,13 @@ bsd_to_linux_sigaltstack(int bsa) } int -linux_execve(struct proc *p, struct linux_execve_args *args) +linux_execve(struct thread *td, struct linux_execve_args *args) { struct execve_args bsd; caddr_t sg; sg = stackgap_init(); - CHECKALTEXIST(p, &sg, args->path); + CHECKALTEXIST(td, &sg, args->path); #ifdef DEBUG if (ldebug(execve)) @@ -115,7 +115,7 @@ linux_execve(struct proc *p, struct linux_execve_args *args) bsd.fname = args->path; bsd.argv = args->argp; bsd.envv = args->envp; - return (execve(p, &bsd)); + return (execve(td, &bsd)); } struct l_ipc_kludge { @@ -124,7 +124,7 @@ struct l_ipc_kludge { }; int -linux_ipc(struct proc *p, struct linux_ipc_args *args) +linux_ipc(struct thread *td, struct linux_ipc_args *args) { switch (args->what & 0xFFFF) { @@ -134,7 +134,7 @@ linux_ipc(struct proc *p, struct linux_ipc_args *args) a.semid = args->arg1; a.tsops = args->ptr; a.nsops = args->arg2; - return (linux_semop(p, &a)); + return (linux_semop(td, &a)); } case LINUX_SEMGET: { struct linux_semget_args a; @@ -142,7 +142,7 @@ linux_ipc(struct proc *p, struct linux_ipc_args *args) a.key = args->arg1; a.nsems = args->arg2; a.semflg = args->arg3; - return (linux_semget(p, &a)); + return (linux_semget(td, &a)); } case LINUX_SEMCTL: { struct linux_semctl_args a; @@ -154,7 +154,7 @@ linux_ipc(struct proc *p, struct linux_ipc_args *args) error = copyin((caddr_t)args->ptr, &a.arg, sizeof(a.arg)); if (error) return (error); - return (linux_semctl(p, &a)); + return (linux_semctl(td, &a)); } case LINUX_MSGSND: { struct linux_msgsnd_args a; @@ -163,7 +163,7 @@ linux_ipc(struct proc *p, struct linux_ipc_args *args) a.msgp = args->ptr; a.msgsz = args->arg2; a.msgflg = args->arg3; - return (linux_msgsnd(p, &a)); + return (linux_msgsnd(td, &a)); } case LINUX_MSGRCV: { struct linux_msgrcv_args a; @@ -186,14 +186,14 @@ linux_ipc(struct proc *p, struct linux_ipc_args *args) a.msgp = args->ptr; a.msgtyp = args->arg5; } - return (linux_msgrcv(p, &a)); + return (linux_msgrcv(td, &a)); } case LINUX_MSGGET: { struct linux_msgget_args a; a.key = args->arg1; a.msgflg = args->arg2; - return (linux_msgget(p, &a)); + return (linux_msgget(td, &a)); } case LINUX_MSGCTL: { struct linux_msgctl_args a; @@ -201,7 +201,7 @@ linux_ipc(struct proc *p, struct linux_ipc_args *args) a.msqid = args->arg1; a.cmd = args->arg2; a.buf = args->ptr; - return (linux_msgctl(p, &a)); + return (linux_msgctl(td, &a)); } case LINUX_SHMAT: { struct linux_shmat_args a; @@ -210,13 +210,13 @@ linux_ipc(struct proc *p, struct linux_ipc_args *args) a.shmaddr = args->ptr; a.shmflg = args->arg2; a.raddr = (l_ulong *)args->arg3; - return (linux_shmat(p, &a)); + return (linux_shmat(td, &a)); } case LINUX_SHMDT: { struct linux_shmdt_args a; a.shmaddr = args->ptr; - return (linux_shmdt(p, &a)); + return (linux_shmdt(td, &a)); } case LINUX_SHMGET: { struct linux_shmget_args a; @@ -224,7 +224,7 @@ linux_ipc(struct proc *p, struct linux_ipc_args *args) a.key = args->arg1; a.size = args->arg2; a.shmflg = args->arg3; - return (linux_shmget(p, &a)); + return (linux_shmget(td, &a)); } case LINUX_SHMCTL: { struct linux_shmctl_args a; @@ -232,7 +232,7 @@ linux_ipc(struct proc *p, struct linux_ipc_args *args) a.shmid = args->arg1; a.cmd = args->arg2; a.buf = args->ptr; - return (linux_shmctl(p, &a)); + return (linux_shmctl(td, &a)); } default: break; @@ -242,7 +242,7 @@ linux_ipc(struct proc *p, struct linux_ipc_args *args) } int -linux_old_select(struct proc *p, struct linux_old_select_args *args) +linux_old_select(struct thread *td, struct linux_old_select_args *args) { struct l_old_select_argv linux_args; struct linux_select_args newsel; @@ -262,11 +262,11 @@ linux_old_select(struct proc *p, struct linux_old_select_args *args) newsel.writefds = linux_args.writefds; newsel.exceptfds = linux_args.exceptfds; newsel.timeout = linux_args.timeout; - return (linux_select(p, &newsel)); + return (linux_select(td, &newsel)); } int -linux_fork(struct proc *p, struct linux_fork_args *args) +linux_fork(struct thread *td, struct linux_fork_args *args) { int error; @@ -275,16 +275,16 @@ linux_fork(struct proc *p, struct linux_fork_args *args) printf(ARGS(fork, "")); #endif - if ((error = fork(p, (struct fork_args *)args)) != 0) + if ((error = fork(td, (struct fork_args *)args)) != 0) return (error); - if (p->p_retval[1] == 1) - p->p_retval[0] = 0; + if (td->td_retval[1] == 1) + td->td_retval[0] = 0; return (0); } int -linux_vfork(struct proc *p, struct linux_vfork_args *args) +linux_vfork(struct thread *td, struct linux_vfork_args *args) { int error; @@ -293,11 +293,11 @@ linux_vfork(struct proc *p, struct linux_vfork_args *args) printf(ARGS(vfork, "")); #endif - if ((error = vfork(p, (struct vfork_args *)args)) != 0) + if ((error = vfork(td, (struct vfork_args *)args)) != 0) return (error); /* Are we the child? */ - if (p->p_retval[1] == 1) - p->p_retval[0] = 0; + if (td->td_retval[1] == 1) + td->td_retval[0] = 0; return (0); } @@ -308,7 +308,7 @@ linux_vfork(struct proc *p, struct linux_vfork_args *args) #define CLONE_PID 0x1000 int -linux_clone(struct proc *p, struct linux_clone_args *args) +linux_clone(struct thread *td, struct linux_clone_args *args) { int error, ff = RFPROC | RFSTOPPED; struct proc *p2; @@ -341,14 +341,14 @@ linux_clone(struct proc *p, struct linux_clone_args *args) ff |= RFFDG; mtx_lock(&Giant); - error = fork1(p, ff, &p2); + error = fork1(td, ff, &p2); if (error == 0) { - p->p_retval[0] = p2->p_pid; - p->p_retval[1] = 0; + td->td_retval[0] = p2->p_pid; + td->td_retval[1] = 0; PROC_LOCK(p2); p2->p_sigparent = exit_signal; - p2->p_frame->tf_esp = (unsigned int)args->stack; + p2->p_thread.td_frame->tf_esp = (unsigned int)args->stack; #ifdef DEBUG if (ldebug(clone)) @@ -361,7 +361,7 @@ linux_clone(struct proc *p, struct linux_clone_args *args) */ mtx_lock_spin(&sched_lock); p2->p_stat = SRUN; - setrunqueue(p2); + setrunqueue(&p2->p_thread); mtx_unlock_spin(&sched_lock); PROC_UNLOCK(p2); } @@ -384,8 +384,9 @@ struct l_mmap_argv { #define GUARD_SIZE (4 * PAGE_SIZE) int -linux_mmap(struct proc *p, struct linux_mmap_args *args) +linux_mmap(struct thread *td, struct linux_mmap_args *args) { + struct proc *p = td->td_proc; struct mmap_args /* { caddr_t addr; size_t len; @@ -501,11 +502,11 @@ linux_mmap(struct proc *p, struct linux_mmap_args *args) bsd_args.flags, bsd_args.fd, (int)bsd_args.pos); #endif - return (mmap(p, &bsd_args)); + return (mmap(td, &bsd_args)); } int -linux_pipe(struct proc *p, struct linux_pipe_args *args) +linux_pipe(struct thread *td, struct linux_pipe_args *args) { int error; int reg_edx; @@ -515,26 +516,26 @@ linux_pipe(struct proc *p, struct linux_pipe_args *args) printf(ARGS(pipe, "*")); #endif - reg_edx = p->p_retval[1]; - error = pipe(p, 0); + reg_edx = td->td_retval[1]; + error = pipe(td, 0); if (error) { - p->p_retval[1] = reg_edx; + td->td_retval[1] = reg_edx; return (error); } - error = copyout(p->p_retval, args->pipefds, 2*sizeof(int)); + error = copyout(td->td_retval, args->pipefds, 2*sizeof(int)); if (error) { - p->p_retval[1] = reg_edx; + td->td_retval[1] = reg_edx; return (error); } - p->p_retval[1] = reg_edx; - p->p_retval[0] = 0; + td->td_retval[1] = reg_edx; + td->td_retval[0] = 0; return (0); } int -linux_ioperm(struct proc *p, struct linux_ioperm_args *args) +linux_ioperm(struct thread *td, struct linux_ioperm_args *args) { struct sysarch_args sa; struct i386_ioperm_args *iia; @@ -547,28 +548,28 @@ linux_ioperm(struct proc *p, struct linux_ioperm_args *args) iia->enable = args->enable; sa.op = I386_SET_IOPERM; sa.parms = (char *)iia; - return (sysarch(p, &sa)); + return (sysarch(td, &sa)); } int -linux_iopl(struct proc *p, struct linux_iopl_args *args) +linux_iopl(struct thread *td, struct linux_iopl_args *args) { int error; if (args->level < 0 || args->level > 3) return (EINVAL); - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) return (error); if (securelevel > 0) return (EPERM); - p->p_frame->tf_eflags = (p->p_frame->tf_eflags & ~PSL_IOPL) | + td->td_frame->tf_eflags = (td->td_frame->tf_eflags & ~PSL_IOPL) | (args->level * (PSL_IOPL / 3)); return (0); } int -linux_modify_ldt(p, uap) - struct proc *p; +linux_modify_ldt(td, uap) + struct thread *td; struct linux_modify_ldt_args *uap; { int error; @@ -591,8 +592,8 @@ linux_modify_ldt(p, uap) ldt->num = uap->bytecount / sizeof(union descriptor); args.op = I386_GET_LDT; args.parms = (char*)ldt; - error = sysarch(p, &args); - p->p_retval[0] *= sizeof(union descriptor); + error = sysarch(td, &args); + td->td_retval[0] *= sizeof(union descriptor); break; case 0x01: /* write_ldt */ case 0x11: /* write_ldt */ @@ -621,7 +622,7 @@ linux_modify_ldt(p, uap) desc->sd.sd_gran = ld.limit_in_pages; args.op = I386_SET_LDT; args.parms = (char*)ldt; - error = sysarch(p, &args); + error = sysarch(td, &args); break; default: error = EINVAL; @@ -637,7 +638,7 @@ linux_modify_ldt(p, uap) } int -linux_sigaction(struct proc *p, struct linux_sigaction_args *args) +linux_sigaction(struct thread *td, struct linux_sigaction_args *args) { l_osigaction_t osa; l_sigaction_t act, oact; @@ -661,7 +662,7 @@ linux_sigaction(struct proc *p, struct linux_sigaction_args *args) act.lsa_mask.__bits[0] = osa.lsa_mask; } - error = linux_do_sigaction(p, args->sig, args->nsa ? &act : NULL, + error = linux_do_sigaction(td, args->sig, args->nsa ? &act : NULL, args->osa ? &oact : NULL); if (args->osa != NULL && !error) { @@ -682,7 +683,7 @@ linux_sigaction(struct proc *p, struct linux_sigaction_args *args) * enables the signal to happen with a different register set. */ int -linux_sigsuspend(struct proc *p, struct linux_sigsuspend_args *args) +linux_sigsuspend(struct thread *td, struct linux_sigsuspend_args *args) { struct sigsuspend_args bsd; sigset_t *sigmask; @@ -699,12 +700,12 @@ linux_sigsuspend(struct proc *p, struct linux_sigsuspend_args *args) mask.__bits[0] = args->mask; linux_to_bsd_sigset(&mask, sigmask); bsd.sigmask = sigmask; - return (sigsuspend(p, &bsd)); + return (sigsuspend(td, &bsd)); } int -linux_rt_sigsuspend(p, uap) - struct proc *p; +linux_rt_sigsuspend(td, uap) + struct thread *td; struct linux_rt_sigsuspend_args *uap; { l_sigset_t lmask; @@ -729,12 +730,13 @@ linux_rt_sigsuspend(p, uap) bmask = stackgap_alloc(&sg, sizeof(sigset_t)); linux_to_bsd_sigset(&lmask, bmask); bsd.sigmask = bmask; - return (sigsuspend(p, &bsd)); + return (sigsuspend(td, &bsd)); } int -linux_pause(struct proc *p, struct linux_pause_args *args) +linux_pause(struct thread *td, struct linux_pause_args *args) { + struct proc *p = td->td_proc; struct sigsuspend_args bsd; sigset_t *sigmask; caddr_t sg = stackgap_init(); @@ -749,13 +751,11 @@ linux_pause(struct proc *p, struct linux_pause_args *args) *sigmask = p->p_sigmask; PROC_UNLOCK(p); bsd.sigmask = sigmask; - return (sigsuspend(p, &bsd)); + return (sigsuspend(td, &bsd)); } int -linux_sigaltstack(p, uap) - struct proc *p; - struct linux_sigaltstack_args *uap; +linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap) { struct sigaltstack_args bsd; stack_t *ss, *oss; @@ -786,7 +786,7 @@ linux_sigaltstack(p, uap) bsd.ss = ss; bsd.oss = oss; - error = sigaltstack(p, &bsd); + error = sigaltstack(td, &bsd); if (!error && oss != NULL) { lss.ss_sp = oss->ss_sp; diff --git a/sys/i386/linux/linux_proto.h b/sys/i386/linux/linux_proto.h index 6105da1..12b52ff 100644 --- a/sys/i386/linux/linux_proto.h +++ b/sys/i386/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)) @@ -643,161 +645,161 @@ struct linux_fcntl64_args { char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)]; char arg_l_[PADL_(l_ulong)]; l_ulong arg; char arg_r_[PADR_(l_ulong)]; }; -int linux_fork __P((struct proc *, struct linux_fork_args *)); -int linux_open __P((struct proc *, struct linux_open_args *)); -int linux_waitpid __P((struct proc *, struct linux_waitpid_args *)); -int linux_creat __P((struct proc *, struct linux_creat_args *)); -int linux_link __P((struct proc *, struct linux_link_args *)); -int linux_unlink __P((struct proc *, struct linux_unlink_args *)); -int linux_execve __P((struct proc *, struct linux_execve_args *)); -int linux_chdir __P((struct proc *, struct linux_chdir_args *)); -int linux_time __P((struct proc *, struct linux_time_args *)); -int linux_mknod __P((struct proc *, struct linux_mknod_args *)); -int linux_chmod __P((struct proc *, struct linux_chmod_args *)); -int linux_lchown16 __P((struct proc *, struct linux_lchown16_args *)); -int linux_stat __P((struct proc *, struct linux_stat_args *)); -int linux_lseek __P((struct proc *, struct linux_lseek_args *)); -int linux_getpid __P((struct proc *, struct linux_getpid_args *)); -int linux_mount __P((struct proc *, struct linux_mount_args *)); -int linux_oldumount __P((struct proc *, struct linux_oldumount_args *)); -int linux_setuid16 __P((struct proc *, struct linux_setuid16_args *)); -int linux_getuid16 __P((struct proc *, struct linux_getuid16_args *)); -int linux_stime __P((struct proc *, struct linux_stime_args *)); -int linux_ptrace __P((struct proc *, struct linux_ptrace_args *)); -int linux_alarm __P((struct proc *, struct linux_alarm_args *)); -int linux_fstat __P((struct proc *, struct linux_fstat_args *)); -int linux_pause __P((struct proc *, struct linux_pause_args *)); -int linux_utime __P((struct proc *, struct linux_utime_args *)); -int linux_access __P((struct proc *, struct linux_access_args *)); -int linux_nice __P((struct proc *, struct linux_nice_args *)); -int linux_kill __P((struct proc *, struct linux_kill_args *)); -int linux_rename __P((struct proc *, struct linux_rename_args *)); -int linux_mkdir __P((struct proc *, struct linux_mkdir_args *)); -int linux_rmdir __P((struct proc *, struct linux_rmdir_args *)); -int linux_pipe __P((struct proc *, struct linux_pipe_args *)); -int linux_times __P((struct proc *, struct linux_times_args *)); -int linux_brk __P((struct proc *, struct linux_brk_args *)); -int linux_setgid16 __P((struct proc *, struct linux_setgid16_args *)); -int linux_getgid16 __P((struct proc *, struct linux_getgid16_args *)); -int linux_signal __P((struct proc *, struct linux_signal_args *)); -int linux_geteuid16 __P((struct proc *, struct linux_geteuid16_args *)); -int linux_getegid16 __P((struct proc *, struct linux_getegid16_args *)); -int linux_umount __P((struct proc *, struct linux_umount_args *)); -int linux_ioctl __P((struct proc *, struct linux_ioctl_args *)); -int linux_fcntl __P((struct proc *, struct linux_fcntl_args *)); -int linux_olduname __P((struct proc *, struct linux_olduname_args *)); -int linux_ustat __P((struct proc *, struct linux_ustat_args *)); -int linux_sigaction __P((struct proc *, struct linux_sigaction_args *)); -int linux_sgetmask __P((struct proc *, struct linux_sgetmask_args *)); -int linux_ssetmask __P((struct proc *, struct linux_ssetmask_args *)); -int linux_setreuid16 __P((struct proc *, struct linux_setreuid16_args *)); -int linux_setregid16 __P((struct proc *, struct linux_setregid16_args *)); -int linux_sigsuspend __P((struct proc *, struct linux_sigsuspend_args *)); -int linux_sigpending __P((struct proc *, struct linux_sigpending_args *)); -int linux_setrlimit __P((struct proc *, struct linux_setrlimit_args *)); -int linux_old_getrlimit __P((struct proc *, struct linux_old_getrlimit_args *)); -int linux_getgroups16 __P((struct proc *, struct linux_getgroups16_args *)); -int linux_setgroups16 __P((struct proc *, struct linux_setgroups16_args *)); -int linux_old_select __P((struct proc *, struct linux_old_select_args *)); -int linux_symlink __P((struct proc *, struct linux_symlink_args *)); -int linux_readlink __P((struct proc *, struct linux_readlink_args *)); -int linux_uselib __P((struct proc *, struct linux_uselib_args *)); -int linux_reboot __P((struct proc *, struct linux_reboot_args *)); -int linux_readdir __P((struct proc *, struct linux_readdir_args *)); -int linux_mmap __P((struct proc *, struct linux_mmap_args *)); -int linux_truncate __P((struct proc *, struct linux_truncate_args *)); -int linux_statfs __P((struct proc *, struct linux_statfs_args *)); -int linux_fstatfs __P((struct proc *, struct linux_fstatfs_args *)); -int linux_ioperm __P((struct proc *, struct linux_ioperm_args *)); -int linux_socketcall __P((struct proc *, struct linux_socketcall_args *)); -int linux_syslog __P((struct proc *, struct linux_syslog_args *)); -int linux_setitimer __P((struct proc *, struct linux_setitimer_args *)); -int linux_getitimer __P((struct proc *, struct linux_getitimer_args *)); -int linux_newstat __P((struct proc *, struct linux_newstat_args *)); -int linux_newlstat __P((struct proc *, struct linux_newlstat_args *)); -int linux_newfstat __P((struct proc *, struct linux_newfstat_args *)); -int linux_uname __P((struct proc *, struct linux_uname_args *)); -int linux_iopl __P((struct proc *, struct linux_iopl_args *)); -int linux_vhangup __P((struct proc *, struct linux_vhangup_args *)); -int linux_vm86old __P((struct proc *, struct linux_vm86old_args *)); -int linux_wait4 __P((struct proc *, struct linux_wait4_args *)); -int linux_swapoff __P((struct proc *, struct linux_swapoff_args *)); -int linux_sysinfo __P((struct proc *, struct linux_sysinfo_args *)); -int linux_ipc __P((struct proc *, struct linux_ipc_args *)); -int linux_sigreturn __P((struct proc *, struct linux_sigreturn_args *)); -int linux_clone __P((struct proc *, struct linux_clone_args *)); -int linux_newuname __P((struct proc *, struct linux_newuname_args *)); -int linux_modify_ldt __P((struct proc *, struct linux_modify_ldt_args *)); -int linux_adjtimex __P((struct proc *, struct linux_adjtimex_args *)); -int linux_sigprocmask __P((struct proc *, struct linux_sigprocmask_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_quotactl __P((struct proc *, struct linux_quotactl_args *)); -int linux_getpgid __P((struct proc *, struct linux_getpgid_args *)); -int linux_bdflush __P((struct proc *, struct linux_bdflush_args *)); -int linux_sysfs __P((struct proc *, struct linux_sysfs_args *)); -int linux_personality __P((struct proc *, struct linux_personality_args *)); -int linux_setfsuid16 __P((struct proc *, struct linux_setfsuid16_args *)); -int linux_setfsgid16 __P((struct proc *, struct linux_setfsgid16_args *)); -int linux_llseek __P((struct proc *, struct linux_llseek_args *)); -int linux_getdents __P((struct proc *, struct linux_getdents_args *)); -int linux_select __P((struct proc *, struct linux_select_args *)); -int linux_msync __P((struct proc *, struct linux_msync_args *)); -int linux_getsid __P((struct proc *, struct linux_getsid_args *)); -int linux_fdatasync __P((struct proc *, struct linux_fdatasync_args *)); -int linux_sysctl __P((struct proc *, struct linux_sysctl_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_mremap __P((struct proc *, struct linux_mremap_args *)); -int linux_setresuid16 __P((struct proc *, struct linux_setresuid16_args *)); -int linux_getresuid16 __P((struct proc *, struct linux_getresuid16_args *)); -int linux_vm86 __P((struct proc *, struct linux_vm86_args *)); -int linux_query_module __P((struct proc *, struct linux_query_module_args *)); -int linux_nfsservctl __P((struct proc *, struct linux_nfsservctl_args *)); -int linux_setresgid16 __P((struct proc *, struct linux_setresgid16_args *)); -int linux_getresgid16 __P((struct proc *, struct linux_getresgid16_args *)); -int linux_prctl __P((struct proc *, struct linux_prctl_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_pread __P((struct proc *, struct linux_pread_args *)); -int linux_pwrite __P((struct proc *, struct linux_pwrite_args *)); -int linux_chown16 __P((struct proc *, struct linux_chown16_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_sigaltstack __P((struct proc *, struct linux_sigaltstack_args *)); -int linux_sendfile __P((struct proc *, struct linux_sendfile_args *)); -int linux_vfork __P((struct proc *, struct linux_vfork_args *)); -int linux_getrlimit __P((struct proc *, struct linux_getrlimit_args *)); -int linux_mmap2 __P((struct proc *, struct linux_mmap2_args *)); -int linux_truncate64 __P((struct proc *, struct linux_truncate64_args *)); -int linux_ftruncate64 __P((struct proc *, struct linux_ftruncate64_args *)); -int linux_stat64 __P((struct proc *, struct linux_stat64_args *)); -int linux_lstat64 __P((struct proc *, struct linux_lstat64_args *)); -int linux_fstat64 __P((struct proc *, struct linux_fstat64_args *)); -int linux_lchown __P((struct proc *, struct linux_lchown_args *)); -int linux_getuid __P((struct proc *, struct linux_getuid_args *)); -int linux_getgid __P((struct proc *, struct linux_getgid_args *)); -int linux_getgroups __P((struct proc *, struct linux_getgroups_args *)); -int linux_setgroups __P((struct proc *, struct linux_setgroups_args *)); -int linux_fchown __P((struct proc *, struct linux_fchown_args *)); -int linux_chown __P((struct proc *, struct linux_chown_args *)); -int linux_setfsuid __P((struct proc *, struct linux_setfsuid_args *)); -int linux_setfsgid __P((struct proc *, struct linux_setfsgid_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_madvise __P((struct proc *, struct linux_madvise_args *)); -int linux_getdents64 __P((struct proc *, struct linux_getdents64_args *)); -int linux_fcntl64 __P((struct proc *, struct linux_fcntl64_args *)); +int linux_fork __P((struct thread *, struct linux_fork_args *)); +int linux_open __P((struct thread *, struct linux_open_args *)); +int linux_waitpid __P((struct thread *, struct linux_waitpid_args *)); +int linux_creat __P((struct thread *, struct linux_creat_args *)); +int linux_link __P((struct thread *, struct linux_link_args *)); +int linux_unlink __P((struct thread *, struct linux_unlink_args *)); +int linux_execve __P((struct thread *, struct linux_execve_args *)); +int linux_chdir __P((struct thread *, struct linux_chdir_args *)); +int linux_time __P((struct thread *, struct linux_time_args *)); +int linux_mknod __P((struct thread *, struct linux_mknod_args *)); +int linux_chmod __P((struct thread *, struct linux_chmod_args *)); +int linux_lchown16 __P((struct thread *, struct linux_lchown16_args *)); +int linux_stat __P((struct thread *, struct linux_stat_args *)); +int linux_lseek __P((struct thread *, struct linux_lseek_args *)); +int linux_getpid __P((struct thread *, struct linux_getpid_args *)); +int linux_mount __P((struct thread *, struct linux_mount_args *)); +int linux_oldumount __P((struct thread *, struct linux_oldumount_args *)); +int linux_setuid16 __P((struct thread *, struct linux_setuid16_args *)); +int linux_getuid16 __P((struct thread *, struct linux_getuid16_args *)); +int linux_stime __P((struct thread *, struct linux_stime_args *)); +int linux_ptrace __P((struct thread *, struct linux_ptrace_args *)); +int linux_alarm __P((struct thread *, struct linux_alarm_args *)); +int linux_fstat __P((struct thread *, struct linux_fstat_args *)); +int linux_pause __P((struct thread *, struct linux_pause_args *)); +int linux_utime __P((struct thread *, struct linux_utime_args *)); +int linux_access __P((struct thread *, struct linux_access_args *)); +int linux_nice __P((struct thread *, struct linux_nice_args *)); +int linux_kill __P((struct thread *, struct linux_kill_args *)); +int linux_rename __P((struct thread *, struct linux_rename_args *)); +int linux_mkdir __P((struct thread *, struct linux_mkdir_args *)); +int linux_rmdir __P((struct thread *, struct linux_rmdir_args *)); +int linux_pipe __P((struct thread *, struct linux_pipe_args *)); +int linux_times __P((struct thread *, struct linux_times_args *)); +int linux_brk __P((struct thread *, struct linux_brk_args *)); +int linux_setgid16 __P((struct thread *, struct linux_setgid16_args *)); +int linux_getgid16 __P((struct thread *, struct linux_getgid16_args *)); +int linux_signal __P((struct thread *, struct linux_signal_args *)); +int linux_geteuid16 __P((struct thread *, struct linux_geteuid16_args *)); +int linux_getegid16 __P((struct thread *, struct linux_getegid16_args *)); +int linux_umount __P((struct thread *, struct linux_umount_args *)); +int linux_ioctl __P((struct thread *, struct linux_ioctl_args *)); +int linux_fcntl __P((struct thread *, struct linux_fcntl_args *)); +int linux_olduname __P((struct thread *, struct linux_olduname_args *)); +int linux_ustat __P((struct thread *, struct linux_ustat_args *)); +int linux_sigaction __P((struct thread *, struct linux_sigaction_args *)); +int linux_sgetmask __P((struct thread *, struct linux_sgetmask_args *)); +int linux_ssetmask __P((struct thread *, struct linux_ssetmask_args *)); +int linux_setreuid16 __P((struct thread *, struct linux_setreuid16_args *)); +int linux_setregid16 __P((struct thread *, struct linux_setregid16_args *)); +int linux_sigsuspend __P((struct thread *, struct linux_sigsuspend_args *)); +int linux_sigpending __P((struct thread *, struct linux_sigpending_args *)); +int linux_setrlimit __P((struct thread *, struct linux_setrlimit_args *)); +int linux_old_getrlimit __P((struct thread *, struct linux_old_getrlimit_args *)); +int linux_getgroups16 __P((struct thread *, struct linux_getgroups16_args *)); +int linux_setgroups16 __P((struct thread *, struct linux_setgroups16_args *)); +int linux_old_select __P((struct thread *, struct linux_old_select_args *)); +int linux_symlink __P((struct thread *, struct linux_symlink_args *)); +int linux_readlink __P((struct thread *, struct linux_readlink_args *)); +int linux_uselib __P((struct thread *, struct linux_uselib_args *)); +int linux_reboot __P((struct thread *, struct linux_reboot_args *)); +int linux_readdir __P((struct thread *, struct linux_readdir_args *)); +int linux_mmap __P((struct thread *, struct linux_mmap_args *)); +int linux_truncate __P((struct thread *, struct linux_truncate_args *)); +int linux_statfs __P((struct thread *, struct linux_statfs_args *)); +int linux_fstatfs __P((struct thread *, struct linux_fstatfs_args *)); +int linux_ioperm __P((struct thread *, struct linux_ioperm_args *)); +int linux_socketcall __P((struct thread *, struct linux_socketcall_args *)); +int linux_syslog __P((struct thread *, struct linux_syslog_args *)); +int linux_setitimer __P((struct thread *, struct linux_setitimer_args *)); +int linux_getitimer __P((struct thread *, struct linux_getitimer_args *)); +int linux_newstat __P((struct thread *, struct linux_newstat_args *)); +int linux_newlstat __P((struct thread *, struct linux_newlstat_args *)); +int linux_newfstat __P((struct thread *, struct linux_newfstat_args *)); +int linux_uname __P((struct thread *, struct linux_uname_args *)); +int linux_iopl __P((struct thread *, struct linux_iopl_args *)); +int linux_vhangup __P((struct thread *, struct linux_vhangup_args *)); +int linux_vm86old __P((struct thread *, struct linux_vm86old_args *)); +int linux_wait4 __P((struct thread *, struct linux_wait4_args *)); +int linux_swapoff __P((struct thread *, struct linux_swapoff_args *)); +int linux_sysinfo __P((struct thread *, struct linux_sysinfo_args *)); +int linux_ipc __P((struct thread *, struct linux_ipc_args *)); +int linux_sigreturn __P((struct thread *, struct linux_sigreturn_args *)); +int linux_clone __P((struct thread *, struct linux_clone_args *)); +int linux_newuname __P((struct thread *, struct linux_newuname_args *)); +int linux_modify_ldt __P((struct thread *, struct linux_modify_ldt_args *)); +int linux_adjtimex __P((struct thread *, struct linux_adjtimex_args *)); +int linux_sigprocmask __P((struct thread *, struct linux_sigprocmask_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_quotactl __P((struct thread *, struct linux_quotactl_args *)); +int linux_getpgid __P((struct thread *, struct linux_getpgid_args *)); +int linux_bdflush __P((struct thread *, struct linux_bdflush_args *)); +int linux_sysfs __P((struct thread *, struct linux_sysfs_args *)); +int linux_personality __P((struct thread *, struct linux_personality_args *)); +int linux_setfsuid16 __P((struct thread *, struct linux_setfsuid16_args *)); +int linux_setfsgid16 __P((struct thread *, struct linux_setfsgid16_args *)); +int linux_llseek __P((struct thread *, struct linux_llseek_args *)); +int linux_getdents __P((struct thread *, struct linux_getdents_args *)); +int linux_select __P((struct thread *, struct linux_select_args *)); +int linux_msync __P((struct thread *, struct linux_msync_args *)); +int linux_getsid __P((struct thread *, struct linux_getsid_args *)); +int linux_fdatasync __P((struct thread *, struct linux_fdatasync_args *)); +int linux_sysctl __P((struct thread *, struct linux_sysctl_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_mremap __P((struct thread *, struct linux_mremap_args *)); +int linux_setresuid16 __P((struct thread *, struct linux_setresuid16_args *)); +int linux_getresuid16 __P((struct thread *, struct linux_getresuid16_args *)); +int linux_vm86 __P((struct thread *, struct linux_vm86_args *)); +int linux_query_module __P((struct thread *, struct linux_query_module_args *)); +int linux_nfsservctl __P((struct thread *, struct linux_nfsservctl_args *)); +int linux_setresgid16 __P((struct thread *, struct linux_setresgid16_args *)); +int linux_getresgid16 __P((struct thread *, struct linux_getresgid16_args *)); +int linux_prctl __P((struct thread *, struct linux_prctl_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_pread __P((struct thread *, struct linux_pread_args *)); +int linux_pwrite __P((struct thread *, struct linux_pwrite_args *)); +int linux_chown16 __P((struct thread *, struct linux_chown16_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_sigaltstack __P((struct thread *, struct linux_sigaltstack_args *)); +int linux_sendfile __P((struct thread *, struct linux_sendfile_args *)); +int linux_vfork __P((struct thread *, struct linux_vfork_args *)); +int linux_getrlimit __P((struct thread *, struct linux_getrlimit_args *)); +int linux_mmap2 __P((struct thread *, struct linux_mmap2_args *)); +int linux_truncate64 __P((struct thread *, struct linux_truncate64_args *)); +int linux_ftruncate64 __P((struct thread *, struct linux_ftruncate64_args *)); +int linux_stat64 __P((struct thread *, struct linux_stat64_args *)); +int linux_lstat64 __P((struct thread *, struct linux_lstat64_args *)); +int linux_fstat64 __P((struct thread *, struct linux_fstat64_args *)); +int linux_lchown __P((struct thread *, struct linux_lchown_args *)); +int linux_getuid __P((struct thread *, struct linux_getuid_args *)); +int linux_getgid __P((struct thread *, struct linux_getgid_args *)); +int linux_getgroups __P((struct thread *, struct linux_getgroups_args *)); +int linux_setgroups __P((struct thread *, struct linux_setgroups_args *)); +int linux_fchown __P((struct thread *, struct linux_fchown_args *)); +int linux_chown __P((struct thread *, struct linux_chown_args *)); +int linux_setfsuid __P((struct thread *, struct linux_setfsuid_args *)); +int linux_setfsgid __P((struct thread *, struct linux_setfsgid_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_madvise __P((struct thread *, struct linux_madvise_args *)); +int linux_getdents64 __P((struct thread *, struct linux_getdents64_args *)); +int linux_fcntl64 __P((struct thread *, struct linux_fcntl64_args *)); #ifdef COMPAT_43 diff --git a/sys/i386/linux/linux_sysvec.c b/sys/i386/linux/linux_sysvec.c index b90ea56..27e3649 100644 --- a/sys/i386/linux/linux_sysvec.c +++ b/sys/i386/linux/linux_sysvec.c @@ -219,13 +219,14 @@ extern unsigned long linux_sznonrtsigcode; static void linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) { - register struct proc *p = curproc; + register struct thread *td = curthread; + register struct proc *p = td->td_proc; register struct trapframe *regs; struct l_rt_sigframe *fp, frame; int oonstack; PROC_LOCK_ASSERT(p, MA_OWNED); - regs = p->p_frame; + regs = td->td_frame; oonstack = sigonstack(regs->tf_esp); #ifdef DEBUG @@ -335,7 +336,7 @@ linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) * instruction to halt it in its tracks. */ PROC_LOCK(p); - sigexit(p, SIGILL); + sigexit(td, SIGILL); /* NOTREACHED */ } @@ -369,7 +370,8 @@ linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) static void linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) { - register struct proc *p = curproc; + register struct thread *td = curthread; + register struct proc *p = td->td_proc; register struct trapframe *regs; struct l_sigframe *fp, frame; l_sigset_t lmask; @@ -381,7 +383,7 @@ linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) return; } - regs = p->p_frame; + regs = td->td_frame; oonstack = sigonstack(regs->tf_esp); #ifdef DEBUG @@ -468,7 +470,7 @@ linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) * instruction to halt it in its tracks. */ PROC_LOCK(p); - sigexit(p, SIGILL); + sigexit(td, SIGILL); /* NOTREACHED */ } @@ -497,16 +499,17 @@ linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) * a machine fault. */ int -linux_sigreturn(p, args) - struct proc *p; +linux_sigreturn(td, args) + struct thread *td; struct linux_sigreturn_args *args; { + struct proc *p = td->td_proc; struct l_sigframe frame; register struct trapframe *regs; l_sigset_t lmask; int eflags, i; - regs = p->p_frame; + regs = td->td_frame; #ifdef DEBUG if (ldebug(sigreturn)) @@ -592,10 +595,11 @@ linux_sigreturn(p, args) * a machine fault. */ int -linux_rt_sigreturn(p, args) - struct proc *p; +linux_rt_sigreturn(td, args) + struct thread *td; struct linux_rt_sigreturn_args *args; { + struct proc *p = td->td_proc; struct sigaltstack_args sasargs; struct l_ucontext uc; struct l_sigcontext *context; @@ -605,7 +609,7 @@ linux_rt_sigreturn(p, args) int eflags; caddr_t sg = stackgap_init(); - regs = p->p_frame; + regs = td->td_frame; #ifdef DEBUG if (ldebug(rt_sigreturn)) @@ -692,7 +696,7 @@ linux_rt_sigreturn(p, args) #endif sasargs.ss = ss; sasargs.oss = NULL; - (void) sigaltstack(p, &sasargs); + (void) sigaltstack(td, &sasargs); return (EJUSTRETURN); } @@ -740,7 +744,7 @@ exec_linux_imgact_try(imgp) if ((error = exec_shell_imgact(imgp)) == 0) { char *rpath = NULL; - linux_emul_find(imgp->proc, NULL, linux_emul_path, + linux_emul_find(&imgp->proc->p_thread, NULL, linux_emul_path, imgp->interpreter_name, &rpath, 0); if (rpath != imgp->interpreter_name) { int len = strlen(rpath) + 1; diff --git a/sys/i386/svr4/svr4_machdep.c b/sys/i386/svr4/svr4_machdep.c index 7dc2d47..f1522f6 100644 --- a/sys/i386/svr4/svr4_machdep.c +++ b/sys/i386/svr4/svr4_machdep.c @@ -77,26 +77,27 @@ static void svr4_getsiginfo __P((union svr4_siginfo *, int, u_long, caddr_t)); #if defined(__NetBSD__) void -svr4_setregs(p, epp, stack) - struct proc *p; +svr4_setregs(td, epp, stack) + struct thread *td; struct exec_package *epp; u_long stack; { - register struct pcb *pcb = &p->p_addr->u_pcb; + register struct pcb *pcb = td->td_pcb; pcb->pcb_savefpu.sv_env.en_cw = __SVR4_NPXCW__; - setregs(p, epp, stack, 0UL); + setregs(td, epp, stack, 0UL); } #endif /* __NetBSD__ */ void -svr4_getcontext(p, uc, mask, oonstack) - struct proc *p; +svr4_getcontext(td, uc, mask, oonstack) + struct thread *td; struct svr4_ucontext *uc; sigset_t *mask; int oonstack; { - struct trapframe *tf = p->p_frame; + struct proc *p = td->td_proc; + struct trapframe *tf = td->td_frame; svr4_greg_t *r = uc->uc_mcontext.greg; struct svr4_sigaltstack *s = &uc->uc_stack; #if defined(DONE_MORE_SIGALTSTACK_WORK) @@ -104,7 +105,7 @@ svr4_getcontext(p, uc, mask, oonstack) struct sigaltstack *sf; #endif - PROC_LOCK(p); + PROC_LOCK(td->td_proc); #if defined(DONE_MORE_SIGALTSTACK_WORK) psp = p->p_sigacts; sf = &p->p_sigstk; @@ -122,7 +123,7 @@ svr4_getcontext(p, uc, mask, oonstack) r[SVR4_X86_FS] = tf->tf_vm86_fs; r[SVR4_X86_ES] = tf->tf_vm86_es; r[SVR4_X86_DS] = tf->tf_vm86_ds; - r[SVR4_X86_EFL] = get_vflags(p); + r[SVR4_X86_EFL] = get_vflags(td); } else #endif { @@ -162,7 +163,7 @@ svr4_getcontext(p, uc, mask, oonstack) s->ss_size = 16384; s->ss_flags = 0; #endif - PROC_UNLOCK(p); + PROC_UNLOCK(td->td_proc); /* * Set the signal mask @@ -186,24 +187,25 @@ svr4_getcontext(p, uc, mask, oonstack) * a machine fault. */ int -svr4_setcontext(p, uc) - struct proc *p; +svr4_setcontext(td, uc) + struct thread *td; struct svr4_ucontext *uc; { #if defined(DONE_MORE_SIGALTSTACK_WORK) struct sigacts *psp; #endif + struct proc *p = td->td_proc; register struct trapframe *tf; svr4_greg_t *r = uc->uc_mcontext.greg; struct svr4_sigaltstack *s = &uc->uc_stack; struct sigaltstack *sf; sigset_t mask; - PROC_LOCK(p); + PROC_LOCK(td->td_proc); #if defined(DONE_MORE_SIGALTSTACK_WORK) - psp = p->p_sigacts; + psp = td->td_proc->p_sigacts; #endif - sf = &p->p_sigstk; + sf = &td->td_proc->p_sigstk; /* * XXX: @@ -219,7 +221,7 @@ svr4_setcontext(p, uc) DPRINTF(("svr4_setcontext(%d)\n", p->p_pid)); - tf = p->p_frame; + tf = td->td_frame; /* * Restore register context. @@ -231,7 +233,7 @@ svr4_setcontext(p, uc) tf->tf_vm86_fs = r[SVR4_X86_FS]; tf->tf_vm86_es = r[SVR4_X86_ES]; tf->tf_vm86_ds = r[SVR4_X86_DS]; - set_vflags(p, r[SVR4_X86_EFL]); + set_vflags(td, r[SVR4_X86_EFL]); } else #endif { @@ -293,7 +295,7 @@ svr4_setcontext(p, uc) SIG_CANTMASK(mask); p->p_sigmask = mask; } - PROC_UNLOCK(p); + PROC_UNLOCK(td->td_proc); return 0; /*EJUSTRETURN;*/ } @@ -409,7 +411,8 @@ svr4_sendsig(catcher, sig, mask, code) sigset_t *mask; u_long code; { - register struct proc *p = curproc; + register struct thread *td = curthread; + struct proc *p = td->td_proc; register struct trapframe *tf; struct svr4_sigframe *fp, frame; struct sigacts *psp; @@ -421,7 +424,7 @@ svr4_sendsig(catcher, sig, mask, code) PROC_LOCK_ASSERT(p, MA_OWNED); psp = p->p_sigacts; - tf = p->p_frame; + tf = td->td_frame; oonstack = sigonstack(tf->tf_esp); /* @@ -435,7 +438,7 @@ svr4_sendsig(catcher, sig, mask, code) } else { fp = (struct svr4_sigframe *)tf->tf_esp - 1; } - PROC_UNLOCK(p); + PROC_UNLOCK(td->td_proc); /* * Build the argument list for the signal handler. @@ -447,7 +450,7 @@ svr4_sendsig(catcher, sig, mask, code) * modify many kernel files to enable that] */ - svr4_getcontext(p, &frame.sf_uc, mask, oonstack); + svr4_getcontext(td, &frame.sf_uc, mask, oonstack); #if defined(DEBUG_SVR4) printf("obtained ucontext\n"); #endif @@ -469,8 +472,8 @@ svr4_sendsig(catcher, sig, mask, code) * Process has trashed its stack; give it an illegal * instruction to halt it in its tracks. */ - PROC_LOCK(p); - sigexit(p, SIGILL); + PROC_LOCK(td->td_proc); + sigexit(td, SIGILL); /* NOTREACHED */ } #if defined(__NetBSD__) @@ -502,8 +505,8 @@ svr4_sendsig(catcher, sig, mask, code) int -svr4_sys_sysarch(p, v) - struct proc *p; +svr4_sys_sysarch(td, v) + struct thread *td; struct svr4_sys_sysarch_args *v; { struct svr4_sys_sysarch_args *uap = v; @@ -583,7 +586,7 @@ svr4_sys_sysarch(p, v) return error; } - return sys_sysarch(p, &ua, retval); + return sys_sysarch(td, &ua, retval); } #endif diff --git a/sys/i386/svr4/svr4_machdep.h b/sys/i386/svr4/svr4_machdep.h index fbbf05b..f6f58e3 100644 --- a/sys/i386/svr4/svr4_machdep.h +++ b/sys/i386/svr4/svr4_machdep.h @@ -71,12 +71,12 @@ typedef struct { long f_weitek[33]; /* weitek */ } svr4_fregset_t; -struct proc; +struct thread; struct svr4_ucontext; -void svr4_getcontext __P((struct proc *, struct svr4_ucontext *, +void svr4_getcontext __P((struct thread *, struct svr4_ucontext *, sigset_t *, int)); -int svr4_setcontext __P((struct proc *p, struct svr4_ucontext *)); +int svr4_setcontext __P((struct thread *p, struct svr4_ucontext *)); typedef struct { svr4_gregset_t greg; diff --git a/sys/i4b/driver/i4b_ctl.c b/sys/i4b/driver/i4b_ctl.c index b30f792..d74fa7e 100644 --- a/sys/i4b/driver/i4b_ctl.c +++ b/sys/i4b/driver/i4b_ctl.c @@ -141,12 +141,12 @@ static void *devfs_token; #ifndef __FreeBSD__ #define PDEVSTATIC /* */ void i4bctlattach __P((void)); -int i4bctlopen __P((dev_t dev, int flag, int fmt, struct proc *p)); -int i4bctlclose __P((dev_t dev, int flag, int fmt, struct proc *p)); +int i4bctlopen __P((dev_t dev, int flag, int fmt, struct thread *td)); +int i4bctlclose __P((dev_t dev, int flag, int fmt, struct thread *td)); #ifdef __bsdi__ -int i4bctlioctl __P((dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)); +int i4bctlioctl __P((dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td)); #else -int i4bctlioctl __P((dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)); +int i4bctlioctl __P((dev_t dev, int cmd, caddr_t data, int flag, struct thread *td)); #endif #endif /* !FreeBSD */ @@ -230,7 +230,7 @@ i4bctlattach() * i4bctlopen - device driver open routine *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4bctlopen(dev_t dev, int flag, int fmt, struct proc *p) +i4bctlopen(dev_t dev, int flag, int fmt, struct thread *td) { if(minor(dev)) return (ENXIO); @@ -247,7 +247,7 @@ i4bctlopen(dev_t dev, int flag, int fmt, struct proc *p) * i4bctlclose - device driver close routine *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4bctlclose(dev_t dev, int flag, int fmt, struct proc *p) +i4bctlclose(dev_t dev, int flag, int fmt, struct thread *td) { openflag = 0; return (0); @@ -258,11 +258,11 @@ i4bctlclose(dev_t dev, int flag, int fmt, struct proc *p) *---------------------------------------------------------------------------*/ PDEVSTATIC int #if defined (__FreeBSD_version) && __FreeBSD_version >= 300003 -i4bctlioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +i4bctlioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) #elif defined(__bsdi__) -i4bctlioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +i4bctlioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) #else -i4bctlioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p) +i4bctlioctl(dev_t dev, int cmd, caddr_t data, int flag, struct thread *td) #endif { #if DO_I4B_DEBUG @@ -360,7 +360,7 @@ i4bctlioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p) * i4bctlpoll - device driver poll routine *---------------------------------------------------------------------------*/ static int -i4bctlpoll (dev_t dev, int events, struct proc *p) +i4bctlpoll (dev_t dev, int events, struct thread *td) { return (ENODEV); } diff --git a/sys/i4b/driver/i4b_rbch.c b/sys/i4b/driver/i4b_rbch.c index 1475428..29dce82 100644 --- a/sys/i4b/driver/i4b_rbch.c +++ b/sys/i4b/driver/i4b_rbch.c @@ -157,15 +157,15 @@ static void rbch_clrq(int unit); #define PDEVSTATIC /* - not static - */ #define IOCTL_CMD_T u_long void i4brbchattach __P((void)); -int i4brbchopen __P((dev_t dev, int flag, int fmt, struct proc *p)); -int i4brbchclose __P((dev_t dev, int flag, int fmt, struct proc *p)); +int i4brbchopen __P((dev_t dev, int flag, int fmt, struct thread *td)); +int i4brbchclose __P((dev_t dev, int flag, int fmt, struct thread *td)); int i4brbchread __P((dev_t dev, struct uio *uio, int ioflag)); int i4brbchwrite __P((dev_t dev, struct uio *uio, int ioflag)); -int i4brbchioctl __P((dev_t dev, IOCTL_CMD_T cmd, caddr_t arg, int flag, struct proc* pr)); +int i4brbchioctl __P((dev_t dev, IOCTL_CMD_T cmd, caddr_t arg, int flag, struct thread *td)); #ifdef OS_USES_POLL -int i4brbchpoll __P((dev_t dev, int events, struct proc *p)); +int i4brbchpoll __P((dev_t dev, int events, struct thread *td)); #else -PDEVSTATIC int i4brbchselect __P((dev_t dev, int rw, struct proc *p)); +PDEVSTATIC int i4brbchselect __P((dev_t dev, int rw, struct thread *td)); #endif #endif @@ -303,7 +303,7 @@ i4brbchattach() * open rbch device *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4brbchopen(dev_t dev, int flag, int fmt, struct proc *p) +i4brbchopen(dev_t dev, int flag, int fmt, struct thread *td) { int unit = minor(dev); @@ -328,7 +328,7 @@ i4brbchopen(dev_t dev, int flag, int fmt, struct proc *p) * close rbch device *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4brbchclose(dev_t dev, int flag, int fmt, struct proc *p) +i4brbchclose(dev_t dev, int flag, int fmt, struct thread *td) { int unit = minor(dev); struct rbch_softc *sc = &rbch_softc[unit]; @@ -575,7 +575,7 @@ i4brbchwrite(dev_t dev, struct uio * uio, int ioflag) * rbch device ioctl handlibg *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4brbchioctl(dev_t dev, IOCTL_CMD_T cmd, caddr_t data, int flag, struct proc *p) +i4brbchioctl(dev_t dev, IOCTL_CMD_T cmd, caddr_t data, int flag, struct thread *td) { int error = 0; int unit = minor(dev); @@ -674,7 +674,7 @@ i4brbchioctl(dev_t dev, IOCTL_CMD_T cmd, caddr_t data, int flag, struct proc *p) * device driver poll *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4brbchpoll(dev_t dev, int events, struct proc *p) +i4brbchpoll(dev_t dev, int events, struct thread *td) { int revents = 0; /* Events we found */ int s; @@ -720,7 +720,7 @@ i4brbchpoll(dev_t dev, int events, struct proc *p) } if(revents == 0) - selrecord(p, &sc->selp); + selrecord(td, &sc->selp); splx(s); return(revents); @@ -732,7 +732,7 @@ i4brbchpoll(dev_t dev, int events, struct proc *p) * device driver select *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4brbchselect(dev_t dev, int rw, struct proc *p) +i4brbchselect(dev_t dev, int rw, struct thread *td) { int unit = minor(dev); struct rbch_softc *sc = &rbch_softc[unit]; diff --git a/sys/i4b/driver/i4b_tel.c b/sys/i4b/driver/i4b_tel.c index 2b6115b..c9a195d 100644 --- a/sys/i4b/driver/i4b_tel.c +++ b/sys/i4b/driver/i4b_tel.c @@ -156,20 +156,20 @@ static u_char sinetab[]; PDEVSTATIC void i4btelattach __P((void)); #ifdef __bsdi__ -PDEVSTATIC int i4btelioctl __P((dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)); +PDEVSTATIC int i4btelioctl __P((dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td)); #else -PDEVSTATIC int i4btelioctl __P((dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)); +PDEVSTATIC int i4btelioctl __P((dev_t dev, int cmd, caddr_t data, int flag, struct thread *td)); #endif -int i4btelopen __P((dev_t dev, int flag, int fmt, struct proc *p)); -int i4btelclose __P((dev_t dev, int flag, int fmt, struct proc *p)); +int i4btelopen __P((dev_t dev, int flag, int fmt, struct thread *td)); +int i4btelclose __P((dev_t dev, int flag, int fmt, struct thread *td)); int i4btelread __P((dev_t dev, struct uio *uio, int ioflag)); int i4btelwrite __P((dev_t dev, struct uio * uio, int ioflag)); #ifdef OS_USES_POLL -int i4btelpoll __P((dev_t dev, int events, struct proc *p)); +int i4btelpoll __P((dev_t dev, int events, struct thread *td)); #else -int i4btelsel __P((dev_t dev, int rw, struct proc *p)); +int i4btelsel __P((dev_t dev, int rw, struct thread *td)); #endif #endif /* ! __FreeBSD__ */ @@ -234,7 +234,7 @@ SYSINIT(i4bteldev, SI_SUB_DRIVERS, #ifdef __bsdi__ -int i4btelsel(dev_t dev, int rw, struct proc *p); +int i4btelsel(dev_t dev, int rw, struct thread *td); int i4btelmatch(struct device *parent, struct cfdata *cf, void *aux); void dummy_i4btelattach(struct device*, struct device *, void *); @@ -314,7 +314,7 @@ i4btelattach() * open tel device *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4btelopen(dev_t dev, int flag, int fmt, struct proc *p) +i4btelopen(dev_t dev, int flag, int fmt, struct thread *td) { int unit = UNIT(dev); int func = FUNC(dev); @@ -343,7 +343,7 @@ i4btelopen(dev_t dev, int flag, int fmt, struct proc *p) * close tel device *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4btelclose(dev_t dev, int flag, int fmt, struct proc *p) +i4btelclose(dev_t dev, int flag, int fmt, struct thread *td) { int unit = UNIT(dev); int func = FUNC(dev); @@ -387,11 +387,11 @@ i4btelclose(dev_t dev, int flag, int fmt, struct proc *p) *---------------------------------------------------------------------------*/ PDEVSTATIC int #if defined(__FreeBSD__) -i4btelioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +i4btelioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) #elif defined(__bsdi__) -i4btelioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +i4btelioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) #else -i4btelioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p) +i4btelioctl(dev_t dev, int cmd, caddr_t data, int flag, struct thread *td) #endif { int unit = UNIT(dev); @@ -815,7 +815,7 @@ tel_tone(tel_sc_t *sc) * device driver poll *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4btelpoll(dev_t dev, int events, struct proc *p) +i4btelpoll(dev_t dev, int events, struct thread *td) { int revents = 0; /* Events we found */ int s; @@ -863,7 +863,7 @@ i4btelpoll(dev_t dev, int events, struct proc *p) if(revents == 0) { NDBGL4(L4_TELDBG, "i4btel%d, selrecord", unit); - selrecord(p, &sc->selp); + selrecord(td, &sc->selp); } } else if(func == FUNCDIAL) @@ -884,7 +884,7 @@ i4btelpoll(dev_t dev, int events, struct proc *p) if(revents == 0) { NDBGL4(L4_TELDBG, "i4bteld%d, selrecord", unit); - selrecord(p, &sc->selp); + selrecord(td, &sc->selp); } } splx(s); @@ -897,7 +897,7 @@ i4btelpoll(dev_t dev, int events, struct proc *p) * device driver select *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4btelsel(dev_t dev, int rw, struct proc *p) +i4btelsel(dev_t dev, int rw, struct thread *td) { int s; int unit = UNIT(dev); @@ -963,7 +963,7 @@ i4btelsel(dev_t dev, int rw, struct proc *p) } NDBGL4(L4_TELDBG, "i4bteld%d, selrecord", unit); - selrecord(p, &sc->selp); + selrecord(td, &sc->selp); splx(s); return 0; } diff --git a/sys/i4b/driver/i4b_trace.c b/sys/i4b/driver/i4b_trace.c index a9ad351..4a95094 100644 --- a/sys/i4b/driver/i4b_trace.c +++ b/sys/i4b/driver/i4b_trace.c @@ -101,14 +101,14 @@ static int outunit = -1; #define PDEVSTATIC /* - not static - */ void i4btrcattach __P((void)); -int i4btrcopen __P((dev_t dev, int flag, int fmt, struct proc *p)); -int i4btrcclose __P((dev_t dev, int flag, int fmt, struct proc *p)); +int i4btrcopen __P((dev_t dev, int flag, int fmt, struct thread *td)); +int i4btrcclose __P((dev_t dev, int flag, int fmt, struct thread *td)); int i4btrcread __P((dev_t dev, struct uio * uio, int ioflag)); #ifdef __bsdi__ -int i4btrcioctl __P((dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)); +int i4btrcioctl __P((dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td)); #else -int i4btrcioctl __P((dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)); +int i4btrcioctl __P((dev_t dev, int cmd, caddr_t data, int flag, struct thread *td)); #endif #endif @@ -333,7 +333,7 @@ get_trace_data_from_l1(i4b_trace_hdr_t *hdr, int len, char *buf) * open trace device *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4btrcopen(dev_t dev, int flag, int fmt, struct proc *p) +i4btrcopen(dev_t dev, int flag, int fmt, struct thread *td) { int x; int unit = minor(dev); @@ -360,7 +360,7 @@ i4btrcopen(dev_t dev, int flag, int fmt, struct proc *p) * close trace device *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4btrcclose(dev_t dev, int flag, int fmt, struct proc *p) +i4btrcclose(dev_t dev, int flag, int fmt, struct thread *td) { int unit = minor(dev); int i, x; @@ -462,7 +462,7 @@ i4btrcread(dev_t dev, struct uio * uio, int ioflag) * poll device *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4btrcpoll(dev_t dev, int events, struct proc *p) +i4btrcpoll(dev_t dev, int events, struct thread *td) { return(ENODEV); } @@ -473,11 +473,11 @@ i4btrcpoll(dev_t dev, int events, struct proc *p) *---------------------------------------------------------------------------*/ PDEVSTATIC int #if defined (__FreeBSD_version) && __FreeBSD_version >= 300003 -i4btrcioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +i4btrcioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) #elif defined(__bsdi__) -i4btrcioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +i4btrcioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) #else -i4btrcioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p) +i4btrcioctl(dev_t dev, int cmd, caddr_t data, int flag, struct thread *td) #endif { int error = 0; diff --git a/sys/i4b/layer4/i4b_i4bdrv.c b/sys/i4b/layer4/i4b_i4bdrv.c index f26adf8..f5f3224 100644 --- a/sys/i4b/layer4/i4b_i4bdrv.c +++ b/sys/i4b/layer4/i4b_i4bdrv.c @@ -132,20 +132,20 @@ static void *devfs_token; #define PDEVSTATIC /* - not static - */ PDEVSTATIC void i4battach __P((void)); -PDEVSTATIC int i4bopen __P((dev_t dev, int flag, int fmt, struct proc *p)); -PDEVSTATIC int i4bclose __P((dev_t dev, int flag, int fmt, struct proc *p)); +PDEVSTATIC int i4bopen __P((dev_t dev, int flag, int fmt, struct thread *td)); +PDEVSTATIC int i4bclose __P((dev_t dev, int flag, int fmt, struct thread *td)); PDEVSTATIC int i4bread __P((dev_t dev, struct uio *uio, int ioflag)); #ifdef __bsdi__ -PDEVSTATIC int i4bioctl __P((dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)); +PDEVSTATIC int i4bioctl __P((dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td)); #else -PDEVSTATIC int i4bioctl __P((dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)); +PDEVSTATIC int i4bioctl __P((dev_t dev, int cmd, caddr_t data, int flag, struct thread *td)); #endif #ifdef OS_USES_POLL -PDEVSTATIC int i4bpoll __P((dev_t dev, int events, struct proc *p)); +PDEVSTATIC int i4bpoll __P((dev_t dev, int events, struct thread *td)); #else -PDEVSTATIC int i4bselect __P((dev_t dev, int rw, struct proc *p)); +PDEVSTATIC int i4bselect __P((dev_t dev, int rw, struct thread *td)); #endif #endif /* #ifndef __FreeBSD__ */ @@ -275,7 +275,7 @@ i4battach() * i4bopen - device driver open routine *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4bopen(dev_t dev, int flag, int fmt, struct proc *p) +i4bopen(dev_t dev, int flag, int fmt, struct thread *td) { int x; @@ -297,7 +297,7 @@ i4bopen(dev_t dev, int flag, int fmt, struct proc *p) * i4bclose - device driver close routine *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4bclose(dev_t dev, int flag, int fmt, struct proc *p) +i4bclose(dev_t dev, int flag, int fmt, struct thread *td) { int x = splimp(); openflag = 0; @@ -360,11 +360,11 @@ i4bread(dev_t dev, struct uio *uio, int ioflag) *---------------------------------------------------------------------------*/ PDEVSTATIC int #if defined (__FreeBSD_version) && __FreeBSD_version >= 300003 -i4bioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +i4bioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) #elif defined(__bsdi__) -i4bioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +i4bioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) #else -i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p) +i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct thread *td) #endif { call_desc_t *cd; @@ -920,7 +920,7 @@ diag_done: * i4bselect - device driver select routine *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4bselect(dev_t dev, int rw, struct proc *p) +i4bselect(dev_t dev, int rw, struct thread *td) { int x; @@ -933,7 +933,7 @@ i4bselect(dev_t dev, int rw, struct proc *p) if(!IF_QEMPTY(&i4b_rdqueue)) return(1); x = splimp(); - selrecord(p, &select_rd_info); + selrecord(td, &select_rd_info); selflag = 1; splx(x); return(0); @@ -952,7 +952,7 @@ i4bselect(dev_t dev, int rw, struct proc *p) * i4bpoll - device driver poll routine *---------------------------------------------------------------------------*/ PDEVSTATIC int -i4bpoll(dev_t dev, int events, struct proc *p) +i4bpoll(dev_t dev, int events, struct thread *td) { int x; @@ -965,7 +965,7 @@ i4bpoll(dev_t dev, int events, struct proc *p) return(1); x = splimp(); - selrecord(p, &select_rd_info); + selrecord(td, &select_rd_info); selflag = 1; splx(x); return(0); diff --git a/sys/ia64/ia64/exception.S b/sys/ia64/ia64/exception.S index bec2ae1..60c321a 100644 --- a/sys/ia64/ia64/exception.S +++ b/sys/ia64/ia64/exception.S @@ -31,7 +31,7 @@ #include <assym.s> /* - * ar.k7 = curproc + * ar.k7 = curthread * ar.k6 = ksp * ar.k5 = kbsp * ar.k4 = globalp diff --git a/sys/ia64/ia64/exception.s b/sys/ia64/ia64/exception.s index bec2ae1..60c321a 100644 --- a/sys/ia64/ia64/exception.s +++ b/sys/ia64/ia64/exception.s @@ -31,7 +31,7 @@ #include <assym.s> /* - * ar.k7 = curproc + * ar.k7 = curthread * ar.k6 = ksp * ar.k5 = kbsp * ar.k4 = globalp diff --git a/sys/ia64/ia64/genassym.c b/sys/ia64/ia64/genassym.c index 7da41b0..0984c87 100644 --- a/sys/ia64/ia64/genassym.c +++ b/sys/ia64/ia64/genassym.c @@ -65,11 +65,8 @@ #include <nfs/nfs.h> #include <nfs/nfsdiskless.h> -ASSYM(UPAGES, UPAGES); -ASSYM(PAGE_SIZE, PAGE_SIZE); - -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)); @@ -79,13 +76,13 @@ 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(TD_PROC, offsetof(struct thread, td_proc)); +ASSYM(TD_PCB, offsetof(struct thread, td_pcb)); +ASSYM(TD_KSTACK, offsetof(struct thread, td_kstack)); +ASSYM(TD_MD_FLAGS, offsetof(struct thread, td_md.md_flags)); ASSYM(VM_MAXUSER_ADDRESS, VM_MAXUSER_ADDRESS); -ASSYM(SIZEOF_USER, sizeof(struct user)); - ASSYM(FRAME_SYSCALL, FRAME_SYSCALL); ASSYM(TF_CR_IPSR, offsetof(struct trapframe, tf_cr_ipsr)); @@ -101,35 +98,35 @@ ASSYM(FRAME_R6, FRAME_R6); ASSYM(FRAME_R7, FRAME_R7); ASSYM(FRAME_SP, FRAME_SP); -ASSYM(U_PCB_R4, offsetof(struct user, u_pcb.pcb_r4)); -ASSYM(U_PCB_R5, offsetof(struct user, u_pcb.pcb_r5)); -ASSYM(U_PCB_R6, offsetof(struct user, u_pcb.pcb_r6)); -ASSYM(U_PCB_R7, offsetof(struct user, u_pcb.pcb_r7)); +ASSYM(PCB_R4, offsetof(struct pcb, pcb_r4)); +ASSYM(PCB_R5, offsetof(struct pcb, pcb_r5)); +ASSYM(PCB_R6, offsetof(struct pcb, pcb_r6)); +ASSYM(PCB_R7, offsetof(struct pcb, pcb_r7)); -ASSYM(U_PCB_F2, offsetof(struct user, u_pcb.pcb_f2)); -ASSYM(U_PCB_F3, offsetof(struct user, u_pcb.pcb_f3)); -ASSYM(U_PCB_F4, offsetof(struct user, u_pcb.pcb_f4)); -ASSYM(U_PCB_F5, offsetof(struct user, u_pcb.pcb_f5)); +ASSYM(PCB_F2, offsetof(struct pcb, pcb_f2)); +ASSYM(PCB_F3, offsetof(struct pcb, pcb_f3)); +ASSYM(PCB_F4, offsetof(struct pcb, pcb_f4)); +ASSYM(PCB_F5, offsetof(struct pcb, pcb_f5)); -ASSYM(U_PCB_B0, offsetof(struct user, u_pcb.pcb_b0)); -ASSYM(U_PCB_B1, offsetof(struct user, u_pcb.pcb_b1)); -ASSYM(U_PCB_B2, offsetof(struct user, u_pcb.pcb_b2)); -ASSYM(U_PCB_B3, offsetof(struct user, u_pcb.pcb_b3)); -ASSYM(U_PCB_B4, offsetof(struct user, u_pcb.pcb_b4)); -ASSYM(U_PCB_B5, offsetof(struct user, u_pcb.pcb_b5)); +ASSYM(PCB_B0, offsetof(struct pcb, pcb_b0)); +ASSYM(PCB_B1, offsetof(struct pcb, pcb_b1)); +ASSYM(PCB_B2, offsetof(struct pcb, pcb_b2)); +ASSYM(PCB_B3, offsetof(struct pcb, pcb_b3)); +ASSYM(PCB_B4, offsetof(struct pcb, pcb_b4)); +ASSYM(PCB_B5, offsetof(struct pcb, pcb_b5)); -ASSYM(U_PCB_OLD_UNAT, offsetof(struct user, u_pcb.pcb_old_unat)); -ASSYM(U_PCB_SP, offsetof(struct user, u_pcb.pcb_sp)); -ASSYM(U_PCB_PFS, offsetof(struct user, u_pcb.pcb_pfs)); -ASSYM(U_PCB_BSPSTORE, offsetof(struct user, u_pcb.pcb_bspstore)); +ASSYM(PCB_OLD_UNAT, offsetof(struct pcb, pcb_old_unat)); +ASSYM(PCB_SP, offsetof(struct pcb, pcb_sp)); +ASSYM(PCB_PFS, offsetof(struct pcb, pcb_pfs)); +ASSYM(PCB_BSPSTORE, offsetof(struct pcb, pcb_bspstore)); -ASSYM(U_PCB_UNAT, offsetof(struct user, u_pcb.pcb_unat)); -ASSYM(U_PCB_RNAT, offsetof(struct user, u_pcb.pcb_rnat)); -ASSYM(U_PCB_PR, offsetof(struct user, u_pcb.pcb_pr)); +ASSYM(PCB_UNAT, offsetof(struct pcb, pcb_unat)); +ASSYM(PCB_RNAT, offsetof(struct pcb, pcb_rnat)); +ASSYM(PCB_PR, offsetof(struct pcb, pcb_pr)); -ASSYM(U_PCB_ONFAULT, offsetof(struct user, u_pcb.pcb_onfault)); +ASSYM(PCB_ONFAULT, offsetof(struct pcb, pcb_onfault)); -ASSYM(U_PCB_HIGHFP, offsetof(struct user, u_pcb.pcb_highfp)); +ASSYM(PCB_HIGHFP, offsetof(struct pcb, pcb_highfp)); ASSYM(UC_MCONTEXT_MC_AR_BSP, offsetof(ucontext_t, uc_mcontext.mc_ar_bsp)); ASSYM(UC_MCONTEXT_MC_AR_RNAT, offsetof(ucontext_t, uc_mcontext.mc_ar_rnat)); @@ -137,4 +134,8 @@ ASSYM(UC_MCONTEXT_MC_AR_RNAT, offsetof(ucontext_t, uc_mcontext.mc_ar_rnat)); ASSYM(EFAULT, EFAULT); ASSYM(ENAMETOOLONG, ENAMETOOLONG); +ASSYM(PAGE_SIZE, PAGE_SIZE); +ASSYM(KSTACK_PAGES, KSTACK_PAGES); + ASSYM(SIZEOF_TRAPFRAME, sizeof(struct trapframe)); +ASSYM(SIZEOF_PCB, sizeof(struct pcb)); diff --git a/sys/ia64/ia64/interrupt.c b/sys/ia64/ia64/interrupt.c index b4b51a8..8661fcd 100644 --- a/sys/ia64/ia64/interrupt.c +++ b/sys/ia64/ia64/interrupt.c @@ -81,10 +81,10 @@ static u_int schedclk2; void interrupt(u_int64_t vector, struct trapframe *framep) { - struct proc *p; + struct thread *td; - p = curproc; - atomic_add_int(&p->p_intr_nesting_level, 1); + td = curthread; + atomic_add_int(&td->td_intr_nesting_level, 1); switch (vector) { case 240: /* clock interrupt */ CTR0(KTR_INTR, "clock interrupt"); @@ -107,7 +107,7 @@ interrupt(u_int64_t vector, struct trapframe *framep) panic("unexpected interrupt: vec %ld\n", vector); /* NOTREACHED */ } - atomic_subtract_int(&p->p_intr_nesting_level, 1); + atomic_subtract_int(&td->td_intr_nesting_level, 1); } diff --git a/sys/ia64/ia64/locore.S b/sys/ia64/ia64/locore.S index 6aed337..55c0816 100644 --- a/sys/ia64/ia64/locore.S +++ b/sys/ia64/ia64/locore.S @@ -64,9 +64,9 @@ #endif .section .data.proc0,"aw" - .global proc0paddr + .global kstack .align PAGE_SIZE -proc0paddr: .space UPAGES * PAGE_SIZE +kstack: .space KSTACK_PAGES * PAGE_SIZE .text @@ -80,23 +80,19 @@ ENTRY(__start, 1) ;; mov cr.iva=r8 mov cr.pta=r9 - movl r10=proc0 ;; - add r10=P_ADDR,r10 - movl r11=proc0paddr + movl r11=kstack ;; - st8 [r10]=r11 srlz.i ;; srlz.d - mov r9=UPAGES*PAGE_SIZE-16 + mov r9=KSTACK_PAGES*PAGE_SIZE-SIZEOF_PCB-16 ;; movl gp=__gp // find kernel globals add sp=r9,r11 // proc0's stack - add r10=SIZEOF_USER,r11 // proc0's backing store mov ar.rsc=0 // turn off rse ;; - mov ar.bspstore=r10 // switch backing store + mov ar.bspstore=r11 // switch backing store ;; loadrs // invalidate regs ;; @@ -105,17 +101,19 @@ ENTRY(__start, 1) br.call.sptk.many rp=ia64_init /* - * switch to proc0 and then initialise the rest of the kernel. + * switch to thread0 and then initialise the rest of the kernel. */ alloc r16=ar.pfs,0,0,1,0 ;; - movl out0=proc0 + movl out0=thread0 ;; - add out0=P_ADDR,out0 + ld8 out0=[out0] + ;; + add out0=TD_PCB,out0 ;; ld8 out0=[out0] ;; - add r16=U_PCB_B0,out0 // return to mi_startup + add r16=PCB_B0,out0 // return to mi_startup movl r17=mi_startup ;; st8 [r16]=r17 diff --git a/sys/ia64/ia64/locore.s b/sys/ia64/ia64/locore.s index 6aed337..55c0816 100644 --- a/sys/ia64/ia64/locore.s +++ b/sys/ia64/ia64/locore.s @@ -64,9 +64,9 @@ #endif .section .data.proc0,"aw" - .global proc0paddr + .global kstack .align PAGE_SIZE -proc0paddr: .space UPAGES * PAGE_SIZE +kstack: .space KSTACK_PAGES * PAGE_SIZE .text @@ -80,23 +80,19 @@ ENTRY(__start, 1) ;; mov cr.iva=r8 mov cr.pta=r9 - movl r10=proc0 ;; - add r10=P_ADDR,r10 - movl r11=proc0paddr + movl r11=kstack ;; - st8 [r10]=r11 srlz.i ;; srlz.d - mov r9=UPAGES*PAGE_SIZE-16 + mov r9=KSTACK_PAGES*PAGE_SIZE-SIZEOF_PCB-16 ;; movl gp=__gp // find kernel globals add sp=r9,r11 // proc0's stack - add r10=SIZEOF_USER,r11 // proc0's backing store mov ar.rsc=0 // turn off rse ;; - mov ar.bspstore=r10 // switch backing store + mov ar.bspstore=r11 // switch backing store ;; loadrs // invalidate regs ;; @@ -105,17 +101,19 @@ ENTRY(__start, 1) br.call.sptk.many rp=ia64_init /* - * switch to proc0 and then initialise the rest of the kernel. + * switch to thread0 and then initialise the rest of the kernel. */ alloc r16=ar.pfs,0,0,1,0 ;; - movl out0=proc0 + movl out0=thread0 ;; - add out0=P_ADDR,out0 + ld8 out0=[out0] + ;; + add out0=TD_PCB,out0 ;; ld8 out0=[out0] ;; - add r16=U_PCB_B0,out0 // return to mi_startup + add r16=PCB_B0,out0 // return to mi_startup movl r17=mi_startup ;; st8 [r16]=r17 diff --git a/sys/ia64/ia64/machdep.c b/sys/ia64/ia64/machdep.c index eb6a997..e5af476 100644 --- a/sys/ia64/ia64/machdep.c +++ b/sys/ia64/ia64/machdep.c @@ -86,7 +86,9 @@ struct bootinfo bootinfo; struct mtx sched_lock; struct mtx Giant; -char proc0paddr[UPAGES * PAGE_SIZE]; +extern char kstack[]; +struct user *proc0uarea; +vm_offset_t proc0kstack; char machine[] = "ia64"; SYSCTL_STRING(_hw, HW_MACHINE, machine, CTLFLAG_RD, machine, 0, ""); @@ -546,11 +548,23 @@ ia64_init() } + proc_linkup(&proc0); + /* + * Init mapping for u page(s) for proc 0 + */ + proc0uarea = (struct user *)pmap_steal_memory(UAREA_PAGES * PAGE_SIZE); + proc0kstack = (vm_offset_t)kstack; + 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, 0, sz); ia64_set_k4((u_int64_t) globalp); @@ -568,18 +582,18 @@ ia64_init() * Set the kernel sp, reserving space for an (empty) trapframe, * and make proc0's trapframe pointer point to it for sanity. * Initialise proc0's backing store to start after u area. + * + * XXX what is all this +/- 16 stuff? */ - proc0.p_addr->u_pcb.pcb_sp = - (u_int64_t)proc0.p_addr + USPACE - sizeof(struct trapframe) - 16; - proc0.p_addr->u_pcb.pcb_bspstore = (u_int64_t) (proc0.p_addr + 1); - proc0.p_frame = - (struct trapframe *)(proc0.p_addr->u_pcb.pcb_sp + 16); + thread0->td_frame = (struct trapframe *)thread0->td_pcb - 1; + thread0->td_pcb->pcb_sp = (u_int64_t)thread0->td_frame - 16; + thread0->td_pcb->pcb_bspstore = (u_int64_t)proc0kstack; /* Setup curproc so that mutexes work */ - PCPU_SET(curproc, &proc0); + PCPU_SET(curthread, thread0); PCPU_SET(spinlocks, NULL); - LIST_INIT(&proc0.p_contested); + LIST_INIT(&thread0->td_contested); /* * Initialise mutexes. @@ -739,16 +753,19 @@ DELAY(int n) 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; u_int64_t sbs = 0; int oonstack, rndfsize; + td = curthread; + p = td->td_proc; PROC_LOCK_ASSERT(p, MA_OWNED); psp = p->p_sigacts; - frame = p->p_frame; + frame = td->td_frame; oonstack = sigonstack(frame->tf_r[FRAME_SP]); rndfsize = ((sizeof(sf) + 15) / 16) * 16; @@ -843,12 +860,12 @@ sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) #if 0 /* save the floating-point state, if necessary, then copy it. */ - ia64_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, + ia64_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; #endif /* @@ -907,7 +924,7 @@ 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) @@ -927,18 +944,20 @@ osigreturn(struct proc *p, */ int -sigreturn(struct proc *p, +sigreturn(struct thread *td, struct sigreturn_args /* { ucontext_t *sigcntxp; } */ *uap) { ucontext_t uc, *ucp; struct pcb *pcb; - struct trapframe *frame = p->p_frame; + struct trapframe *frame = td->td_frame; struct __mcontext *mcp; + struct proc *p; ucp = uap->sigcntxp; - pcb = &p->p_addr->u_pcb; + pcb = td->td_pcb; + p = td->td_proc; #ifdef DEBUG if (sigdebug & SDB_FOLLOW) @@ -1000,12 +1019,11 @@ sigreturn(struct proc *p, PROC_UNLOCK(p); /* XXX ksc.sc_ownedfp ? */ - ia64_fpstate_drop(p); + ia64_fpstate_drop(td); #if 0 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; #endif #ifdef DEBUG @@ -1039,11 +1057,11 @@ 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 *frame; - frame = p->p_frame; + frame = td->td_frame; /* * Make sure that we restore the entire trapframe after an @@ -1069,25 +1087,25 @@ setregs(struct proc *p, u_long entry, u_long stack, u_long ps_strings) * Setup the new backing store and make sure the new image * starts executing with an empty register stack frame. */ - frame->tf_ar_bspstore = p->p_md.md_bspstore; + frame->tf_ar_bspstore = td->td_md.md_bspstore; frame->tf_ndirty = 0; frame->tf_cr_ifs = (1L<<63); /* ifm=0, v=1 */ frame->tf_ar_rsc = 0xf; /* user mode rsc */ frame->tf_ar_fpsr = IA64_FPSR_DEFAULT; - p->p_md.md_flags &= ~MDP_FPUSED; - ia64_fpstate_drop(p); + td->td_md.md_flags &= ~MDP_FPUSED; + ia64_fpstate_drop(td); } int -ptrace_set_pc(struct proc *p, unsigned long addr) +ptrace_set_pc(struct thread *td, unsigned long addr) { /* TODO set pc in trapframe */ return 0; } int -ptrace_single_step(struct proc *p) +ptrace_single_step(struct thread *td) { /* TODO arrange for user process to single step */ return 0; @@ -1100,8 +1118,8 @@ ia64_pa_access(vm_offset_t pa) } int -fill_regs(p, regs) - struct proc *p; +fill_regs(td, regs) + struct thread *td; struct reg *regs; { /* TODO copy trapframe to regs */ @@ -1109,8 +1127,8 @@ fill_regs(p, regs) } int -set_regs(p, regs) - struct proc *p; +set_regs(td, regs) + struct thread *td; struct reg *regs; { /* TODO copy regs to trapframe */ @@ -1118,29 +1136,29 @@ set_regs(p, regs) } int -fill_fpregs(p, fpregs) - struct proc *p; +fill_fpregs(td, fpregs) + struct thread *td; struct fpreg *fpregs; { /* TODO copy fpu state to fpregs */ - ia64_fpstate_save(p, 0); + ia64_fpstate_save(td, 0); #if 0 - bcopy(&p->p_addr->u_pcb.pcb_fp, fpregs, sizeof *fpregs); + bcopy(&td->td_pcb->pcb_fp, fpregs, sizeof *fpregs); #endif return (0); } int -set_fpregs(p, fpregs) - struct proc *p; +set_fpregs(td, fpregs) + struct thread *td; struct fpreg *fpregs; { /* TODO copy fpregs fpu state */ - ia64_fpstate_drop(p); + ia64_fpstate_drop(td); #if 0 - bcopy(fpregs, &p->p_addr->u_pcb.pcb_fp, sizeof *fpregs); + bcopy(fpregs, &td->td_pcb->pcb_fp, sizeof *fpregs); #endif return (0); } @@ -1236,11 +1254,11 @@ SYSCTL_INT(_machdep, CPU_WALLCLOCK, wall_cmos_clock, CTLFLAG_RW, &wall_cmos_clock, 0, ""); void -ia64_fpstate_check(struct proc *p) +ia64_fpstate_check(struct thread *td) { - if ((p->p_frame->tf_cr_ipsr & IA64_PSR_DFH) == 0) - if (p != PCPU_GET(fpcurproc)) - panic("ia64_check_fpcurproc: bogus"); + if ((td->td_frame->tf_cr_ipsr & IA64_PSR_DFH) == 0) + if (td != PCPU_GET(fpcurthread)) + panic("ia64_check_fpcurthread: bogus"); } /* @@ -1251,17 +1269,17 @@ ia64_fpstate_check(struct proc *p) * by generating a disabled fp trap. */ void -ia64_fpstate_save(struct proc *p, int write) +ia64_fpstate_save(struct thread *td, int write) { - if (p == PCPU_GET(fpcurproc)) { + if (td == PCPU_GET(fpcurthread)) { /* * Save the state in the pcb. */ - savehighfp(p->p_addr->u_pcb.pcb_highfp); + savehighfp(td->td_pcb->pcb_highfp); if (write) { - p->p_frame->tf_cr_ipsr |= IA64_PSR_DFH; - PCPU_SET(fpcurproc, NULL); + td->td_frame->tf_cr_ipsr |= IA64_PSR_DFH; + PCPU_SET(fpcurthread, NULL); } } } @@ -1272,11 +1290,11 @@ ia64_fpstate_save(struct proc *p, int write) * (e.g. on sigreturn). */ void -ia64_fpstate_drop(struct proc *p) +ia64_fpstate_drop(struct thread *td) { - if (p == PCPU_GET(fpcurproc)) { - p->p_frame->tf_cr_ipsr |= IA64_PSR_DFH; - PCPU_SET(fpcurproc, NULL); + if (td == PCPU_GET(fpcurthread)) { + td->td_frame->tf_cr_ipsr |= IA64_PSR_DFH; + PCPU_SET(fpcurthread, NULL); } } @@ -1285,24 +1303,24 @@ ia64_fpstate_drop(struct proc *p) * from the pcb. */ void -ia64_fpstate_switch(struct proc *p) +ia64_fpstate_switch(struct thread *td) { - if (PCPU_GET(fpcurproc)) { + if (PCPU_GET(fpcurthread)) { /* * Dump the old fp state if its valid. */ - savehighfp(PCPU_GET(fpcurproc)->p_addr->u_pcb.pcb_highfp); - PCPU_GET(fpcurproc)->p_frame->tf_cr_ipsr |= IA64_PSR_DFH; + savehighfp(PCPU_GET(fpcurthread)->td_pcb->pcb_highfp); + PCPU_GET(fpcurthread)->td_frame->tf_cr_ipsr |= IA64_PSR_DFH; } /* * Remember the new FP owner and reload its state. */ - PCPU_SET(fpcurproc, p); - restorehighfp(p->p_addr->u_pcb.pcb_highfp); - p->p_frame->tf_cr_ipsr &= ~IA64_PSR_DFH; + PCPU_SET(fpcurthread, td); + restorehighfp(td->td_pcb->pcb_highfp); + td->td_frame->tf_cr_ipsr &= ~IA64_PSR_DFH; - p->p_md.md_flags |= MDP_FPUSED; + td->td_md.md_flags |= MDP_FPUSED; } /* diff --git a/sys/ia64/ia64/mem.c b/sys/ia64/ia64/mem.c index a6dd046..0142a48 100644 --- a/sys/ia64/ia64/mem.c +++ b/sys/ia64/ia64/mem.c @@ -99,12 +99,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; @@ -113,7 +113,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)) { @@ -124,7 +124,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 @@ -236,12 +236,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/ia64/ia64/pmap.c b/sys/ia64/ia64/pmap.c index 5ddba29..3f70fb7 100644 --- a/sys/ia64/ia64/pmap.c +++ b/sys/ia64/ia64/pmap.c @@ -222,7 +222,7 @@ static int pmap_ridbits = 18; 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; @@ -320,7 +320,7 @@ pmap_bootstrap() * Set up proc0's PCB. */ #if 0 - proc0.p_addr->u_pcb.pcb_hw.apcb_asn = 0; + thread0->td_pcb->pcb_hw.apcb_asn = 0; #endif } @@ -505,7 +505,7 @@ pmap_track_modified(vm_offset_t va) } /* - * Create the UPAGES for a new process. + * Create the U area for a new process. * This routine directly affects the fork perf for a process. */ void @@ -518,7 +518,7 @@ pmap_new_proc(struct proc *p) * 7 address for it which makes it impossible to accidentally * lose when recording a trapframe. */ - up = contigmalloc(UPAGES * PAGE_SIZE, M_PMAP, + up = contigmalloc(UAREA_PAGES * PAGE_SIZE, M_PMAP, M_WAITOK, 0ul, 256*1024*1024 - 1, @@ -526,86 +526,96 @@ pmap_new_proc(struct proc *p) 256*1024*1024); p->p_md.md_uservirt = up; - p->p_addr = (struct user *) + p->p_uarea = (struct user *) IA64_PHYS_TO_RR7(ia64_tpa((u_int64_t) up)); } /* - * Dispose the UPAGES for a process that has exited. + * Dispose the U area for a process that has exited. * This routine directly impacts the exit perf of a process. */ void pmap_dispose_proc(p) struct proc *p; { - contigfree(p->p_md.md_uservirt, UPAGES * PAGE_SIZE, M_PMAP); + contigfree(p->p_md.md_uservirt, UAREA_PAGES * PAGE_SIZE, M_PMAP); p->p_md.md_uservirt = 0; - p->p_addr = 0; + p->p_uarea = 0; } /* - * Allow the UPAGES for a process to be prejudicially paged out. + * Allow the U area for a process to be prejudicially paged out. */ void pmap_swapout_proc(p) struct proc *p; { -#if 0 - int i; - vm_object_t upobj; - vm_offset_t up; - vm_page_t m; +} + +/* + * Bring the U area for a specified process back in. + */ +void +pmap_swapin_proc(p) + struct proc *p; +{ +} + +/* + * Create the KSTACK for a new thread. + * This routine directly affects the fork perf for a process/thread. + */ +void +pmap_new_thread(struct thread *td) +{ + vm_offset_t *ks; /* - * Make sure we aren't fpcurproc. + * Use contigmalloc for user area so that we can use a region + * 7 address for it which makes it impossible to accidentally + * lose when recording a trapframe. */ - ia64_fpstate_save(p, 1); + ks = contigmalloc(KSTACK_PAGES * PAGE_SIZE, M_PMAP, + M_WAITOK, + 0ul, + 256*1024*1024 - 1, + PAGE_SIZE, + 256*1024*1024); - upobj = p->p_upages_obj; - up = (vm_offset_t)p->p_addr; - for (i = 0; i < UPAGES; i++) { - m = vm_page_lookup(upobj, i); - if (m == NULL) - panic("pmap_swapout_proc: upage already missing?"); - vm_page_dirty(m); - vm_page_unwire(m, 0); - pmap_kremove(up + i * PAGE_SIZE); - } -#endif + td->td_md.md_kstackvirt = ks; + td->td_kstack = IA64_PHYS_TO_RR7(ia64_tpa((u_int64_t)ks)); } /* - * Bring the UPAGES for a specified process back in. + * Dispose the KSTACK for a thread that has exited. + * This routine directly impacts the exit perf of a process/thread. */ void -pmap_swapin_proc(p) - struct proc *p; +pmap_dispose_thread(td) + struct thread *td; { -#if 0 - int i, rv; - vm_object_t upobj; - vm_offset_t up; - vm_page_t m; + contigfree(td->td_md.md_kstackvirt, KSTACK_PAGES * PAGE_SIZE, M_PMAP); + td->td_md.md_kstackvirt = 0; + td->td_kstack = 0; +} - upobj = p->p_upages_obj; - up = (vm_offset_t)p->p_addr; - for (i = 0; i < UPAGES; 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) { - rv = vm_pager_get_pages(upobj, &m, 1, 0); - if (rv != VM_PAGER_OK) - panic("pmap_swapin_proc: cannot get upages for proc: %d\n", p->p_pid); - m = vm_page_lookup(upobj, i); - m->valid = VM_PAGE_BITS_ALL; - } - vm_page_wire(m); - vm_page_wakeup(m); - vm_page_flag_set(m, PG_MAPPED | PG_WRITEABLE); - } -#endif +/* + * Allow the KSTACK for a thread to be prejudicially paged out. + */ +void +pmap_swapout_thread(td) + struct thread *td; +{ } +/* + * Bring the KSTACK for a specified thread back in. + */ +void +pmap_swapin_thread(td) + struct thread *td; +{ +} /*************************************************** * Page table page management routines..... ***************************************************/ @@ -1149,7 +1159,7 @@ pmap_collect() { int i; vm_page_t m; - static int warningdone=0; + static int warningdone = 0; if (pmap_pagedaemon_waken == 0) return; @@ -2199,9 +2209,9 @@ pmap_mincore(pmap, addr) } void -pmap_activate(struct proc *p) +pmap_activate(struct thread *td) { - pmap_install(vmspace_pmap(p->p_vmspace)); + pmap_install(vmspace_pmap(td->td_proc->p_vmspace)); } pmap_t @@ -2281,14 +2291,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/ia64/ia64/procfs_machdep.c b/sys/ia64/ia64/procfs_machdep.c index e623e49..08582fb 100644 --- a/sys/ia64/ia64/procfs_machdep.c +++ b/sys/ia64/ia64/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/ia64/ia64/ssc.c b/sys/ia64/ia64/ssc.c index ecc593e..52eb48f 100644 --- a/sys/ia64/ia64/ssc.c +++ b/sys/ia64/ia64/ssc.c @@ -124,7 +124,7 @@ ssccncheckc(dev_t dev) } static int -sscopen(dev_t dev, int flag, int mode, struct proc *p) +sscopen(dev_t dev, int flag, int mode, struct thread *td) { struct tty *tp; int s; @@ -148,7 +148,7 @@ sscopen(dev_t dev, int flag, int mode, struct proc *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; } @@ -167,7 +167,7 @@ sscopen(dev_t dev, int flag, int mode, struct proc *p) } static int -sscclose(dev_t dev, int flag, int mode, struct proc *p) +sscclose(dev_t dev, int flag, int mode, struct thread *td) { int unit = minor(dev); struct tty *tp = ssc_tp; @@ -182,7 +182,7 @@ sscclose(dev_t dev, int flag, int mode, struct proc *p) } static int -sscioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +sscioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int unit = minor(dev); struct tty *tp = ssc_tp; @@ -191,7 +191,7 @@ sscioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *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/ia64/ia64/sscdisk.c b/sys/ia64/ia64/sscdisk.c index 5b7bd09..8e473ad 100644 --- a/sys/ia64/ia64/sscdisk.c +++ b/sys/ia64/ia64/sscdisk.c @@ -121,14 +121,14 @@ struct ssc_s { static int sscunits; static int -sscopen(dev_t dev, int flag, int fmt, struct proc *p) +sscopen(dev_t dev, int flag, int fmt, struct thread *td) { struct ssc_s *sc; struct disklabel *dl; if (ssc_debug) printf("sscopen(%s %x %x %p)\n", - devtoname(dev), flag, fmt, p); + devtoname(dev), flag, fmt, td); sc = dev->si_drv1; @@ -144,12 +144,12 @@ sscopen(dev_t dev, int flag, int fmt, struct proc *p) } static int -sscioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p) +sscioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td) { if (ssc_debug) printf("sscioctl(%s %lx %p %x %p)\n", - devtoname(dev), cmd, addr, flags, p); + devtoname(dev), cmd, addr, flags, td); return (ENOIOCTL); } diff --git a/sys/ia64/ia64/support.S b/sys/ia64/ia64/support.S index 2e18b9c..d6c71d5 100644 --- a/sys/ia64/ia64/support.S +++ b/sys/ia64/ia64/support.S @@ -70,15 +70,15 @@ ENTRY(suword, 2) (p6) br.dpnt.few fusufault movl r14=fusufault // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add r15=U_PCB_ONFAULT,r15 + add r15=PCB_ONFAULT,r15 ;; st8 [r15]=r14 ;; @@ -98,15 +98,15 @@ ENTRY(subyte, 2) (p6) br.dpnt.few fusufault movl r14=fusufault // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add r15=U_PCB_ONFAULT,r15 + add r15=PCB_ONFAULT,r15 ;; st8 [r15]=r14 ;; @@ -126,15 +126,15 @@ ENTRY(fuword, 1) (p6) br.dpnt.few fusufault movl r14=fusufault // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add r15=U_PCB_ONFAULT,r15 + add r15=PCB_ONFAULT,r15 ;; st8 [r15]=r14 ;; @@ -153,15 +153,15 @@ ENTRY(fubyte, 1) (p6) br.dpnt.few fusufault movl r14=fusufault // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add r15=U_PCB_ONFAULT,r15 + add r15=PCB_ONFAULT,r15 ;; st8 [r15]=r14 ;; @@ -242,15 +242,15 @@ ENTRY(copyinstr, 4) ;; (p6) br.cond.spnt.few copyerr // if it's not, error out. movl r14=copyerr // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add loc2=U_PCB_ONFAULT,r15 + add loc2=PCB_ONFAULT,r15 ;; st8 [loc2]=r14 ;; @@ -277,15 +277,15 @@ ENTRY(copyoutstr, 4) ;; (p6) br.cond.spnt.few copyerr // if it's not, error out. movl r14=copyerr // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add loc2=U_PCB_ONFAULT,r15 + add loc2=PCB_ONFAULT,r15 ;; st8 [loc2]=r14 ;; @@ -392,15 +392,15 @@ ENTRY(copyin, 3) ;; (p6) br.cond.spnt.few copyerr // if it's not, error out. movl r14=copyerr // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add loc2=U_PCB_ONFAULT,r15 + add loc2=PCB_ONFAULT,r15 ;; st8 [loc2]=r14 ;; @@ -427,15 +427,15 @@ ENTRY(copyout, 3) ;; (p6) br.cond.spnt.few copyerr // if it's not, error out. movl r14=copyerr // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add loc2=U_PCB_ONFAULT,r15 + add loc2=PCB_ONFAULT,r15 ;; st8 [loc2]=r14 ;; @@ -453,11 +453,11 @@ END(copyout) ENTRY(copyerr, 0) - add r14=GD_CURPROC,r13 ;; // find curproc + add r14=GD_CURTHREAD,r13 ;; // find curthread ld8 r14=[r14] ;; - add r14=P_ADDR,r14 ;; // curproc->p_addr + add r14=TD_PCB,r14 ;; // curthread->td_addr ld8 r14=[r14] ;; - add r14=U_PCB_ONFAULT,r14 ;; // &curproc->p_addr->u_pcb.pcb_onfault + add r14=PCB_ONFAULT,r14 ;; // &curthread->td_pcb->pcb_onfault st8 [r14]=r0 // reset fault handler mov ret0=EFAULT // return EFAULT diff --git a/sys/ia64/ia64/support.s b/sys/ia64/ia64/support.s index 2e18b9c..d6c71d5 100644 --- a/sys/ia64/ia64/support.s +++ b/sys/ia64/ia64/support.s @@ -70,15 +70,15 @@ ENTRY(suword, 2) (p6) br.dpnt.few fusufault movl r14=fusufault // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add r15=U_PCB_ONFAULT,r15 + add r15=PCB_ONFAULT,r15 ;; st8 [r15]=r14 ;; @@ -98,15 +98,15 @@ ENTRY(subyte, 2) (p6) br.dpnt.few fusufault movl r14=fusufault // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add r15=U_PCB_ONFAULT,r15 + add r15=PCB_ONFAULT,r15 ;; st8 [r15]=r14 ;; @@ -126,15 +126,15 @@ ENTRY(fuword, 1) (p6) br.dpnt.few fusufault movl r14=fusufault // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add r15=U_PCB_ONFAULT,r15 + add r15=PCB_ONFAULT,r15 ;; st8 [r15]=r14 ;; @@ -153,15 +153,15 @@ ENTRY(fubyte, 1) (p6) br.dpnt.few fusufault movl r14=fusufault // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add r15=U_PCB_ONFAULT,r15 + add r15=PCB_ONFAULT,r15 ;; st8 [r15]=r14 ;; @@ -242,15 +242,15 @@ ENTRY(copyinstr, 4) ;; (p6) br.cond.spnt.few copyerr // if it's not, error out. movl r14=copyerr // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add loc2=U_PCB_ONFAULT,r15 + add loc2=PCB_ONFAULT,r15 ;; st8 [loc2]=r14 ;; @@ -277,15 +277,15 @@ ENTRY(copyoutstr, 4) ;; (p6) br.cond.spnt.few copyerr // if it's not, error out. movl r14=copyerr // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add loc2=U_PCB_ONFAULT,r15 + add loc2=PCB_ONFAULT,r15 ;; st8 [loc2]=r14 ;; @@ -392,15 +392,15 @@ ENTRY(copyin, 3) ;; (p6) br.cond.spnt.few copyerr // if it's not, error out. movl r14=copyerr // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add loc2=U_PCB_ONFAULT,r15 + add loc2=PCB_ONFAULT,r15 ;; st8 [loc2]=r14 ;; @@ -427,15 +427,15 @@ ENTRY(copyout, 3) ;; (p6) br.cond.spnt.few copyerr // if it's not, error out. movl r14=copyerr // set up fault handler. - add r15=GD_CURPROC,r13 // find curproc + add r15=GD_CURTHREAD,r13 // find curthread ;; ld8 r15=[r15] ;; - add r15=P_ADDR,r15 // find pcb + add r15=TD_PCB,r15 // find pcb ;; ld8 r15=[r15] ;; - add loc2=U_PCB_ONFAULT,r15 + add loc2=PCB_ONFAULT,r15 ;; st8 [loc2]=r14 ;; @@ -453,11 +453,11 @@ END(copyout) ENTRY(copyerr, 0) - add r14=GD_CURPROC,r13 ;; // find curproc + add r14=GD_CURTHREAD,r13 ;; // find curthread ld8 r14=[r14] ;; - add r14=P_ADDR,r14 ;; // curproc->p_addr + add r14=TD_PCB,r14 ;; // curthread->td_addr ld8 r14=[r14] ;; - add r14=U_PCB_ONFAULT,r14 ;; // &curproc->p_addr->u_pcb.pcb_onfault + add r14=PCB_ONFAULT,r14 ;; // &curthread->td_pcb->pcb_onfault st8 [r14]=r0 // reset fault handler mov ret0=EFAULT // return EFAULT diff --git a/sys/ia64/ia64/swtch.s b/sys/ia64/ia64/swtch.s index 10f568e..e26cdb2 100644 --- a/sys/ia64/ia64/swtch.s +++ b/sys/ia64/ia64/swtch.s @@ -105,7 +105,7 @@ ENTRY(savectx, 1) ENTRY(restorectx, 1) - add r3=U_PCB_UNAT,in0 // point at NaT for r4..r7 + add r3=PCB_UNAT,in0 // point at NaT for r4..r7 mov ar.rsc=0 ;; // switch off the RSE ld8 r16=[r3] // load NaT for r4..r7 ;; @@ -158,9 +158,9 @@ ENTRY(restorectx, 1) ENTRY(cpu_switch, 0) - add r16=GD_CURPROC,r13 ;; + add r16=GD_CURTHREAD,r13 ;; ld8 r17=[r16] ;; - add r17=P_ADDR,r17 ;; + add r17=TD_PCB,r17 ;; ld8 r17=[r17] flushrs // push out caller's dirty regs @@ -209,18 +209,18 @@ ENTRY(cpu_switch, 0) mov ar.rsc=3 // turn RSE back on - br.call.sptk.few rp=chooseproc + br.call.sptk.few rp=choosethread - add r14=GD_CURPROC,r13 ;; + add r14=GD_CURTHREAD,r13 ;; ld8 r15=[r14] ;; #if 0 - cmp.ne p6,p0=r15,ret0 // chooseproc() == curproc ? + cmp.ne p6,p0=r15,ret0 // chooseproc() == curthread ? (p6) br.dptk.few 1f ;; - add r17=P_ADDR,r15 ;; // restore b0 + add r17=TD_PCB,r15 ;; // restore b0 ld8 r17=[r17] ;; - add r17=U_PCB_B0,r17 ;; + add r17=PCB_B0,r17 ;; ld8 r17=[r17] ;; mov b0=r17 @@ -228,7 +228,7 @@ ENTRY(cpu_switch, 0) #endif 1: - st8 [r14]=ret0 // set r13->gd_curproc + st8 [r14]=ret0 // set r13->gd_curthread mov ar.k7=ret0 mov r4=ret0 // save from call ;; @@ -237,12 +237,13 @@ ENTRY(cpu_switch, 0) mov out0=r4 br.call.sptk.few rp=pmap_activate // install RIDs etc. - add r15=P_ADDR,r4 ;; - ld8 r15=[r15] ;; - add r16=SIZEOF_USER,r15 ;; + add r15=TD_PCB,r4 + add r16=TD_KSTACK,r4 ;; + ld8 r15=[r15] + ld8 r16=[r16] ;; mov ar.k5=r16 - add r3=U_PCB_UNAT,r15 // point at NaT for r4..r7 + add r3=PCB_UNAT,r15 // point at NaT for r4..r7 mov ar.rsc=0 ;; // switch off the RSE ld8 r16=[r3] // load NaT for r4..r7 ;; diff --git a/sys/ia64/ia64/sys_machdep.c b/sys/ia64/ia64/sys_machdep.c index 84e7620..097dc02 100644 --- a/sys/ia64/ia64/sys_machdep.c +++ b/sys/ia64/ia64/sys_machdep.c @@ -64,8 +64,8 @@ struct sysarch_args { #endif int -sysarch(p, uap) - struct proc *p; +sysarch(td, uap) + struct thread *td; register struct sysarch_args *uap; { int error = 0; diff --git a/sys/ia64/ia64/trap.c b/sys/ia64/ia64/trap.c index 9baf9e1..c21cdf4 100644 --- a/sys/ia64/ia64/trap.c +++ b/sys/ia64/ia64/trap.c @@ -69,7 +69,7 @@ #include <ddb/ddb.h> #endif -static int unaligned_fixup(struct trapframe *framep, struct proc *p); +static int unaligned_fixup(struct trapframe *framep, struct thread *td); #ifdef WITNESS extern char *syscallnames[]; @@ -160,10 +160,10 @@ printtrap(int vector, int imm, struct trapframe *framep, int isfatal, int user) printf(" cr.isr = 0x%lx\n", framep->tf_cr_isr); printf(" cr.ifa = 0x%lx\n", framep->tf_cr_ifa); printf(" cr.iim = 0x%x\n", imm); - printf(" curproc = %p\n", curproc); - if (curproc != NULL) - printf(" pid = %d, comm = %s\n", curproc->p_pid, - curproc->p_comm); + printf(" curthread = %p\n", curthread); + if (curthread != NULL) + printf(" pid = %d, comm = %s\n", + curthread->td_proc->p_pid, curthread->td_proc->p_comm); printf("\n"); } @@ -177,6 +177,7 @@ printtrap(int vector, int imm, struct trapframe *framep, int isfatal, int user) void trap(int vector, int imm, struct trapframe *framep) { + struct thread *td; struct proc *p; int i; u_int64_t ucode; @@ -184,13 +185,14 @@ trap(int vector, int imm, struct trapframe *framep) int user; cnt.v_trap++; - p = curproc; + td = curthread; + p = td->td_proc; ucode = 0; user = ((framep->tf_cr_ipsr & IA64_PSR_CPL) == IA64_PSR_CPL_USER); 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 */ } @@ -204,7 +206,7 @@ trap(int vector, int imm, struct trapframe *framep) */ if (user) { mtx_lock(&Giant); - if ((i = unaligned_fixup(framep, p)) == 0) { + if ((i = unaligned_fixup(framep, td)) == 0) { mtx_unlock(&Giant); goto out; } @@ -246,15 +248,15 @@ trap(int vector, int imm, struct trapframe *framep) case IA64_VEC_DISABLED_FP: /* - * 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; } - ia64_fpstate_switch(p); + ia64_fpstate_switch(td); goto out; break; @@ -276,12 +278,11 @@ trap(int vector, int imm, struct trapframe *framep) * when they are running. */ if (!user && - p != NULL && - p->p_addr->u_pcb.pcb_onfault == - (unsigned long)fswintrberr && - p->p_addr->u_pcb.pcb_accessaddr == va) { - framep->tf_cr_iip = p->p_addr->u_pcb.pcb_onfault; - p->p_addr->u_pcb.pcb_onfault = 0; + td != NULL && + td->td_pcb->pcb_onfault == (unsigned long)fswintrberr && + td->td_pcb->pcb_accessaddr == va) { + framep->tf_cr_iip = td->td_pcb->pcb_onfault; + td->td_pcb->pcb_onfault = 0; goto out; } mtx_lock(&Giant); @@ -301,8 +302,8 @@ trap(int vector, int imm, struct trapframe *framep) */ if (!user && ((va >= VM_MIN_KERNEL_ADDRESS) - || (p == NULL) - || (p->p_addr->u_pcb.pcb_onfault == 0))) { + || (td == NULL) + || (td->td_pcb->pcb_onfault == 0))) { if (va >= trunc_page(PS_STRINGS - szsigcode - SPARE_USRSPACE) @@ -405,7 +406,7 @@ trap(int vector, int imm, struct trapframe *framep) trapsignal(p, i, ucode); out: if (user) - userret(p, framep, sticks); + userret(td, framep, sticks); if (mtx_owned(&Giant)) mtx_unlock(&Giant); return; @@ -439,15 +440,18 @@ void syscall(int code, u_int64_t *args, struct trapframe *framep) { struct sysent *callp; + struct thread *td; struct proc *p; int error = 0; u_int64_t oldip, oldri; u_int sticks; cnt.v_syscall++; - p = curproc; - p->p_frame = framep; - sticks = p->p_sticks; + td = curthread; + p = td->td_proc; + + td->td_frame = framep; + sticks = td->td_kse->ke_sticks; mtx_lock(&Giant); /* @@ -463,7 +467,7 @@ syscall(int code, u_int64_t *args, struct trapframe *framep) } #ifdef DIAGNOSTIC - ia64_fpstate_check(p); + ia64_fpstate_check(td); #endif if (p->p_sysent->sv_prepsyscall) { @@ -496,19 +500,19 @@ syscall(int code, u_int64_t *args, struct trapframe *framep) ktrsyscall(p->p_tracep, code, (callp->sy_narg & SYF_ARGMASK), args); #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); + error = (*callp->sy_call)(td, args); } switch (error) { case 0: - framep->tf_r[FRAME_R8] = p->p_retval[0]; - framep->tf_r[FRAME_R9] = p->p_retval[1]; + framep->tf_r[FRAME_R8] = td->td_retval[0]; + framep->tf_r[FRAME_R9] = td->td_retval[1]; framep->tf_r[FRAME_R10] = 0; break; case ERESTART: @@ -530,10 +534,10 @@ syscall(int code, u_int64_t *args, struct trapframe *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 mtx_unlock(&Giant); @@ -545,7 +549,7 @@ syscall(int code, u_int64_t *args, struct trapframe *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]); } @@ -558,21 +562,25 @@ extern int ia64_unaligned_print, ia64_unaligned_fix; extern int ia64_unaligned_sigbus; static int -unaligned_fixup(struct trapframe *framep, struct proc *p) +unaligned_fixup(struct trapframe *framep, struct thread *td) { vm_offset_t va = framep->tf_cr_ifa; int doprint, dofix, dosigbus; int signal, size = 0; unsigned long uac; + struct proc *p; /* * Figure out what actions to take. */ - 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 = ia64_unaligned_print && !(uac & MDP_UAC_NOPRINT); dofix = ia64_unaligned_fix && !(uac & MDP_UAC_NOFIX); @@ -593,7 +601,7 @@ unaligned_fixup(struct trapframe *framep, struct proc *p) */ if (doprint) { uprintf("pid %d (%s): unaligned access: va=0x%lx pc=0x%lx\n", - p->p_pid, p->p_comm, va, p->p_frame->tf_cr_iip); + p->p_pid, p->p_comm, va, td->td_frame->tf_cr_iip); } /* diff --git a/sys/ia64/ia64/vm_machdep.c b/sys/ia64/ia64/vm_machdep.c index 3774212..492b8ec 100644 --- a/sys/ia64/ia64/vm_machdep.c +++ b/sys/ia64/ia64/vm_machdep.c @@ -124,25 +124,30 @@ struct ia64_fdesc { * 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; u_int64_t bspstore, *p1bs, *p2bs, rnatloc, rnat; 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); /* * Copy floating point state from the FP chip to the PCB * if this process has state stored there. */ - ia64_fpstate_save(p1, 0); + ia64_fpstate_save(td1, 0); /* * Copy pcb and stack from proc p1 to p2. We do this as @@ -150,15 +155,15 @@ 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; + bcopy(td1->td_pcb, td2->td_pcb, sizeof(struct pcb)); /* * Set the floating point state. */ #if 0 - 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); @@ -170,9 +175,9 @@ cpu_fork(p1, p2, flags) * is started, to resume here, returning nonzero from setjmp. */ #ifdef DIAGNOSTIC - if (p1 != curproc) + if (td1 != curthread) panic("cpu_fork: curproc"); - ia64_fpstate_check(p1); + ia64_fpstate_check(td1); #endif /* @@ -182,25 +187,24 @@ 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 = td2->td_frame; p2tf->tf_r[FRAME_R8] = 0; /* child's pid (linux) */ p2tf->tf_r[FRAME_R9] = 1; /* is child (FreeBSD) */ p2tf->tf_r[FRAME_R10] = 0; /* no error */ /* * Turn off RSE for a moment and work out our current - * ar.bspstore. This assumes that p1==curproc. Also + * ar.bspstore. This assumes that td1==curthread. Also * flush dirty regs to ensure that the user's stacked * regs are written out to backing store. * - * We could cope with p1!=curproc by digging values + * We could cope with td1!=curthread by digging values * out of its PCB but I don't see the point since * current usage never allows it. */ @@ -208,23 +212,23 @@ cpu_fork(p1, p2, flags) __asm __volatile("flushrs;;" ::: "memory"); __asm __volatile("mov %0=ar.bspstore" : "=r"(bspstore)); - p1bs = (u_int64_t *) (p1->p_addr + 1); - p2bs = (u_int64_t *) (p2->p_addr + 1); + p1bs = (u_int64_t *)td1->td_kstack; + p2bs = (u_int64_t *)td2->td_kstack; /* - * Copy enough of p1's backing store to include all + * Copy enough of td1's backing store to include all * the user's stacked regs. */ - bcopy(p1bs, p2bs, p1->p_frame->tf_ndirty); + bcopy(p1bs, p2bs, td1->td_frame->tf_ndirty); /* - * To calculate the ar.rnat for p2, we need to decide - * if p1's ar.bspstore has advanced past the place + * To calculate the ar.rnat for td2, we need to decide + * if td1's ar.bspstore has advanced past the place * where the last ar.rnat which covers the user's * saved registers would be placed. If so, we read - * that one from memory, otherwise we take p1's + * that one from memory, otherwise we take td1's * current ar.rnat. */ - rnatloc = (u_int64_t)p1bs + p1->p_frame->tf_ndirty; + rnatloc = (u_int64_t)p1bs + td1->td_frame->tf_ndirty; rnatloc |= 0x1f8; if (bspstore > rnatloc) rnat = *(u_int64_t *) rnatloc; @@ -242,21 +246,22 @@ cpu_fork(p1, p2, flags) * should work since the child will normally return * straight into exception_restore. */ - up = p2->p_addr; - up->u_pcb.pcb_bspstore = (u_int64_t)p2bs + p1->p_frame->tf_ndirty; - up->u_pcb.pcb_rnat = rnat; - up->u_pcb.pcb_pfs = 0; + td2->td_pcb->pcb_bspstore = (u_int64_t)p2bs + td1->td_frame->tf_ndirty; + td2->td_pcb->pcb_rnat = rnat; + td2->td_pcb->pcb_pfs = 0; /* * Arrange for continuation at fork_return(), which * will return to exception_restore(). Note that the * child process doesn't stay in the kernel for long! + * + * XXX what is this +/- 16 stuff here? */ - up->u_pcb.pcb_sp = (u_int64_t)p2tf - 16; - up->u_pcb.pcb_r4 = (u_int64_t)fork_return; - up->u_pcb.pcb_r5 = FDESC_FUNC(exception_restore); - up->u_pcb.pcb_r6 = (u_int64_t)p2; - up->u_pcb.pcb_b0 = FDESC_FUNC(fork_trampoline); + td2->td_pcb->pcb_sp = (u_int64_t)p2tf - 16; + td2->td_pcb->pcb_r4 = (u_int64_t)fork_return; + td2->td_pcb->pcb_r5 = FDESC_FUNC(exception_restore); + td2->td_pcb->pcb_r6 = (u_int64_t)td2; + td2->td_pcb->pcb_b0 = FDESC_FUNC(fork_trampoline); } /* @@ -266,13 +271,13 @@ 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; { - p->p_addr->u_pcb.pcb_r4 = (u_int64_t) func; - p->p_addr->u_pcb.pcb_r6 = (u_int64_t) arg; + td->td_pcb->pcb_r4 = (u_int64_t) func; + td->td_pcb->pcb_r6 = (u_int64_t) arg; } /* @@ -281,11 +286,11 @@ cpu_set_fork_handler(p, func, arg) * When the proc is reaped, cpu_wait() will gc the VM state. */ void -cpu_exit(p) - register struct proc *p; +cpu_exit(td) + register struct thread *td; { - ia64_fpstate_drop(p); + ia64_fpstate_drop(td); } void @@ -307,14 +312,22 @@ cpu_throw(void) * 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; + + 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)0, + UIO_SYSSPACE, IO_UNIT, cred, (int *)NULL, td); + return error; } /* diff --git a/sys/ia64/include/cpu.h b/sys/ia64/include/cpu.h index 062bebc..d7dfde8 100644 --- a/sys/ia64/include/cpu.h +++ b/sys/ia64/include/cpu.h @@ -52,7 +52,7 @@ #include <machine/frame.h> -#define cpu_getstack(p) ((p)->p_frame->tf_r[FRAME_SP]) +#define cpu_getstack(td) ((td)->td_frame->tf_r[FRAME_SP]) /* * 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; @@ -109,7 +109,6 @@ extern volatile int mc_expected, mc_received; int badaddr __P((void *, size_t)); int badaddr_read __P((void *, size_t, void *)); -void child_return __P((struct proc *p)); u_int64_t console_restart __P((u_int64_t, u_int64_t, u_int64_t)); void do_sir __P((void)); void dumpconf __P((void)); @@ -118,10 +117,10 @@ void frametoreg __P((struct trapframe *, struct reg *)); long fswintrberr __P((void)); /* MAGIC */ int ia64_pa_access __P((u_long)); void ia64_init __P((void)); -void ia64_fpstate_check __P((struct proc *p)); -void ia64_fpstate_save __P((struct proc *p, int write)); -void ia64_fpstate_drop __P((struct proc *p)); -void ia64_fpstate_switch __P((struct proc *p)); +void ia64_fpstate_check __P((struct thread *p)); +void ia64_fpstate_save __P((struct thread *p, int write)); +void ia64_fpstate_drop __P((struct thread *p)); +void ia64_fpstate_switch __P((struct thread *p)); void init_prom_interface __P((struct rpb*)); void interrupt __P((u_int64_t, struct trapframe *)); void machine_check @@ -133,7 +132,6 @@ void regtoframe __P((struct reg *, struct trapframe *)); int savectx __P((struct pcb *)); void restorectx __P((struct pcb *)); void set_iointr __P((void (*)(void *, unsigned long))); -void switch_exit __P((struct proc *)); /* MAGIC */ void fork_trampoline __P((void)); /* MAGIC */ void syscall __P((int, u_int64_t *, struct trapframe *)); void trap __P((int vector, int imm, struct trapframe *framep)); diff --git a/sys/ia64/include/globaldata.h b/sys/ia64/include/globaldata.h index 308086c..50f4990 100644 --- a/sys/ia64/include/globaldata.h +++ b/sys/ia64/include/globaldata.h @@ -44,15 +44,14 @@ * point at the globaldata structure. */ struct globaldata { - 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 */ - u_int64_t gd_idlepcbphys; /* pa of gd_idlepcb */ + 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_pending_ipis; /* pending IPI events */ struct pmap *gd_current_pmap; /* which pmap is active */ u_int32_t gd_next_asn; /* next ASN to allocate */ diff --git a/sys/ia64/include/globals.h b/sys/ia64/include/globals.h index 20ca26e..b953cf1 100644 --- a/sys/ia64/include/globals.h +++ b/sys/ia64/include/globals.h @@ -40,9 +40,11 @@ register struct globaldata *globalp __asm__("r13"); #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/ia64/include/md_var.h b/sys/ia64/include/md_var.h index 2154611..789b389 100644 --- a/sys/ia64/include/md_var.h +++ b/sys/ia64/include/md_var.h @@ -39,7 +39,7 @@ extern int szsigcode; extern int Maxmem; struct fpreg; -struct proc; +struct thread; struct reg; void busdma_swi __P((void)); @@ -47,9 +47,9 @@ 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 *)); #endif /* !_MACHINE_MD_VAR_H_ */ diff --git a/sys/ia64/include/mutex.h b/sys/ia64/include/mutex.h index 2e7916c..6581d70 100644 --- a/sys/ia64/include/mutex.h +++ b/sys/ia64/include/mutex.h @@ -55,7 +55,7 @@ add rLCK=MTX_LOCK,rLCK ;; \ rsm psr.i ; \ mov ar.ccv=MTX_UNOWNED ; \ - add rNEW=PC_CURPROC,rNEW ;; \ + add rNEW=PC_CURTHREAD,rNEW ;; \ ld8 rNEW=[rNEW] ;; \ 1: cmpxchg8.acq rOLD=[rLCK],rNEW,ar.ccv ;; \ cmp.eq p1,p0=MTX_UNOWNED,rOLD ;; \ diff --git a/sys/ia64/include/param.h b/sys/ia64/include/param.h index 8c8f91d..db87619 100644 --- a/sys/ia64/include/param.h +++ b/sys/ia64/include/param.h @@ -152,8 +152,10 @@ #define SSIZE 1 /* initial stack size/NBPG */ #define SINCR 1 /* increment of stack/NBPG */ -#define UPAGES 4 /* pages of u-area */ -#define USPACE (UPAGES * PAGE_SIZE) /* total size of u-area */ +#define KSTACK_PAGES 4 /* pages of kernel stack */ +#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/ia64/include/pcpu.h b/sys/ia64/include/pcpu.h index 308086c..50f4990 100644 --- a/sys/ia64/include/pcpu.h +++ b/sys/ia64/include/pcpu.h @@ -44,15 +44,14 @@ * point at the globaldata structure. */ struct globaldata { - 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 */ - u_int64_t gd_idlepcbphys; /* pa of gd_idlepcb */ + 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_pending_ipis; /* pending IPI events */ struct pmap *gd_current_pmap; /* which pmap is active */ u_int32_t gd_next_asn; /* next ASN to allocate */ diff --git a/sys/ia64/include/proc.h b/sys/ia64/include/proc.h index 9d900f0..aeacc2a 100644 --- a/sys/ia64/include/proc.h +++ b/sys/ia64/include/proc.h @@ -35,9 +35,9 @@ * Machine-dependent part of the proc struct for the Alpha. */ -struct mdproc { +struct mdthread { u_long md_flags; - struct user *md_uservirt; /* virtual address of p_addr */ + void *md_kstackvirt; /* virtual address of td_kstack */ vm_offset_t md_bspstore; /* initial ar.bspstore */ }; @@ -47,3 +47,7 @@ struct mdproc { #define MDP_UAC_SIGBUS 0x0040 /* Deliver SIGBUS upon unaligned access */ #define MDP_UAC_MASK (MDP_UAC_NOPRINT | MDP_UAC_NOFIX | MDP_UAC_SIGBUS) + +struct mdproc { + struct user *md_uservirt; /* virtual address of p_addr */ +}; diff --git a/sys/ia64/include/reg.h b/sys/ia64/include/reg.h index 31a06af..5ac4bfa 100644 --- a/sys/ia64/include/reg.h +++ b/sys/ia64/include/reg.h @@ -54,11 +54,11 @@ struct dbreg { #ifdef _KERNEL -struct proc; +struct thread; void restorehighfp __P((struct ia64_fpreg *)); void savehighfp __P((struct ia64_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 /* _MACHINE_REG_H_ */ diff --git a/sys/isa/fd.c b/sys/isa/fd.c index f896b33..845f520 100644 --- a/sys/isa/fd.c +++ b/sys/isa/fd.c @@ -1519,7 +1519,7 @@ out_fdc(struct fdc_data *fdc, int x) * auxiliary functions). */ int -Fdopen(dev_t dev, int flags, int mode, struct proc *p) +Fdopen(dev_t dev, int flags, int mode, struct thread *td) { fdu_t fdu = FDUNIT(minor(dev)); int type = FDTYPE(minor(dev)); @@ -1614,7 +1614,7 @@ Fdopen(dev_t dev, int flags, int mode, struct proc *p) } int -fdclose(dev_t dev, int flags, int mode, struct proc *p) +fdclose(dev_t dev, int flags, int mode, struct thread *td) { fdu_t fdu = FDUNIT(minor(dev)); struct fd_data *fd; @@ -2473,7 +2473,7 @@ fdmisccmd(dev_t dev, u_int cmd, void *data) } static int -fdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +fdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { fdu_t fdu; fd_p fd; @@ -2545,7 +2545,7 @@ fdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) case FD_STYPE: /* set drive type */ /* this is considered harmful; only allow for superuser */ - if (suser(p) != 0) + if (suser_td(td) != 0) return (EPERM); *fd->ft = *(struct fd_type *)addr; break; @@ -2569,7 +2569,7 @@ fdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) #endif case FD_CLRERR: - if (suser(p) != 0) + if (suser_td(td) != 0) return (EPERM); fd->fdc->fdc_errs = 0; break; diff --git a/sys/isa/joy.c b/sys/isa/joy.c index beda4de..0f3f11d 100644 --- a/sys/isa/joy.c +++ b/sys/isa/joy.c @@ -159,7 +159,7 @@ DRIVER_MODULE(joy, isa, joy_isa_driver, joy_devclass, 0, 0); DRIVER_MODULE(joy, acpi, joy_isa_driver, joy_devclass, 0, 0); static int -joyopen(dev_t dev, int flags, int fmt, struct proc *p) +joyopen(dev_t dev, int flags, int fmt, struct thread *td) { int i = joypart (dev); struct joy_softc *joy = JOY_SOFTC(UNIT(dev)); @@ -172,7 +172,7 @@ joyopen(dev_t dev, int flags, int fmt, struct proc *p) } static int -joyclose(dev_t dev, int flags, int fmt, struct proc *p) +joyclose(dev_t dev, int flags, int fmt, struct thread *td) { int i = joypart (dev); struct joy_softc *joy = JOY_SOFTC(UNIT(dev)); @@ -240,7 +240,7 @@ joyread(dev_t dev, struct uio *uio, int flag) } static int -joyioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +joyioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { struct joy_softc *joy = JOY_SOFTC(UNIT(dev)); int i = joypart (dev); diff --git a/sys/isa/psm.c b/sys/isa/psm.c index 1bb5b71..1fb37ea 100644 --- a/sys/isa/psm.c +++ b/sys/isa/psm.c @@ -1164,7 +1164,7 @@ psmdetach(device_t dev) } static int -psmopen(dev_t dev, int flag, int fmt, struct proc *p) +psmopen(dev_t dev, int flag, int fmt, struct thread *td) { int unit = PSM_UNIT(dev); struct psm_softc *sc; @@ -1248,7 +1248,7 @@ psmopen(dev_t dev, int flag, int fmt, struct proc *p) } static int -psmclose(dev_t dev, int flag, int fmt, struct proc *p) +psmclose(dev_t dev, int flag, int fmt, struct thread *td) { int unit = PSM_UNIT(dev); struct psm_softc *sc = PSM_SOFTC(unit); @@ -1516,7 +1516,7 @@ unblock_mouse_data(struct psm_softc *sc, int c) } static int -psmioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) +psmioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) { struct psm_softc *sc = PSM_SOFTC(PSM_UNIT(dev)); mousemode_t mode; @@ -2237,7 +2237,7 @@ psmintr(void *arg) } static int -psmpoll(dev_t dev, int events, struct proc *p) +psmpoll(dev_t dev, int events, struct thread *td) { struct psm_softc *sc = PSM_SOFTC(PSM_UNIT(dev)); int s; @@ -2249,7 +2249,7 @@ psmpoll(dev_t dev, int events, struct proc *p) if (sc->queue.count > 0) revents |= events & (POLLIN | POLLRDNORM); else - selrecord(p, &sc->rsel); + selrecord(td, &sc->rsel); } splx(s); diff --git a/sys/isa/sio.c b/sys/isa/sio.c index 3c68d7c..05d8f35 100644 --- a/sys/isa/sio.c +++ b/sys/isa/sio.c @@ -1378,11 +1378,11 @@ determined_type: ; } static int -sioopen(dev, flag, mode, p) +sioopen(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct com_s *com; int error; @@ -1440,7 +1440,7 @@ open_top: } } if (tp->t_state & TS_XCLUDE && - suser(p)) { + suser_td(td)) { error = EBUSY; goto out; } @@ -1560,11 +1560,11 @@ out: } static int -sioclose(dev, flag, mode, p) +sioclose(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct com_s *com; int mynor; @@ -2114,12 +2114,12 @@ cont: } static int -sioioctl(dev, cmd, data, flag, p) +sioioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct com_s *com; int error; @@ -2150,7 +2150,7 @@ sioioctl(dev, cmd, data, flag, p) } switch (cmd) { case TIOCSETA: - error = suser(p); + error = suser_td(td); if (error != 0) return (error); *ct = *(struct termios *)data; @@ -2200,7 +2200,7 @@ sioioctl(dev, cmd, data, flag, p) if (lt->c_ospeed != 0) dt->c_ospeed = tp->t_ospeed; } - 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); s = spltty(); @@ -2241,7 +2241,7 @@ sioioctl(dev, cmd, data, flag, p) break; case TIOCMSDTRWAIT: /* must be root since the wait applies to following logins */ - error = suser(p); + error = suser_td(td); if (error != 0) { splx(s); return (error); diff --git a/sys/isa/vga_isa.c b/sys/isa/vga_isa.c index 0cc754a..101dc55 100644 --- a/sys/isa/vga_isa.c +++ b/sys/isa/vga_isa.c @@ -166,15 +166,15 @@ isavga_attach(device_t dev) #ifdef FB_INSTALL_CDEV static int -isavga_open(dev_t dev, int flag, int mode, struct proc *p) +isavga_open(dev_t dev, int flag, int mode, struct thread *td) { - return vga_open(dev, VGA_SOFTC(VGA_UNIT(dev)), flag, mode, p); + return vga_open(dev, VGA_SOFTC(VGA_UNIT(dev)), flag, mode, td); } static int -isavga_close(dev_t dev, int flag, int mode, struct proc *p) +isavga_close(dev_t dev, int flag, int mode, struct thread *td) { - return vga_close(dev, VGA_SOFTC(VGA_UNIT(dev)), flag, mode, p); + return vga_close(dev, VGA_SOFTC(VGA_UNIT(dev)), flag, mode, td); } static int @@ -190,9 +190,9 @@ isavga_write(dev_t dev, struct uio *uio, int flag) } static int -isavga_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *p) +isavga_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct thread *td) { - return vga_ioctl(dev, VGA_SOFTC(VGA_UNIT(dev)), cmd, arg, flag, p); + return vga_ioctl(dev, VGA_SOFTC(VGA_UNIT(dev)), cmd, arg, flag, td); } static int diff --git a/sys/isofs/cd9660/cd9660_lookup.c b/sys/isofs/cd9660/cd9660_lookup.c index b2d5057..979c0bd 100644 --- a/sys/isofs/cd9660/cd9660_lookup.c +++ b/sys/isofs/cd9660/cd9660_lookup.c @@ -120,7 +120,7 @@ cd9660_lookup(ap) struct componentname *cnp = ap->a_cnp; int flags = cnp->cn_flags; int nameiop = cnp->cn_nameiop; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; bp = NULL; *vpp = NULL; @@ -351,16 +351,16 @@ found: * it's a relocated directory. */ if (flags & ISDOTDOT) { - VOP_UNLOCK(pdp, 0, p); /* race to get the inode */ + VOP_UNLOCK(pdp, 0, td); /* race to get the inode */ error = cd9660_vget_internal(vdp->v_mount, dp->i_ino, &tdp, dp->i_ino != ino, ep); brelse(bp); if (error) { - vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, td); return (error); } if (lockparent && (flags & ISLASTCN)) { - if ((error = vn_lock(pdp, LK_EXCLUSIVE, p)) != 0) { + if ((error = vn_lock(pdp, LK_EXCLUSIVE, td)) != 0) { cnp->cn_flags |= PDIRUNLOCK; vput(tdp); return (error); @@ -380,7 +380,7 @@ found: return (error); if (!lockparent || !(flags & ISLASTCN)) { cnp->cn_flags |= PDIRUNLOCK; - VOP_UNLOCK(pdp, 0, p); + VOP_UNLOCK(pdp, 0, td); } *vpp = tdp; } diff --git a/sys/isofs/cd9660/cd9660_node.c b/sys/isofs/cd9660/cd9660_node.c index 00f79e8..53ffeca 100644 --- a/sys/isofs/cd9660/cd9660_node.c +++ b/sys/isofs/cd9660/cd9660_node.c @@ -97,7 +97,7 @@ cd9660_ihashget(dev, inum) dev_t dev; ino_t inum; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct iso_node *ip; struct vnode *vp; @@ -108,7 +108,7 @@ loop: vp = ITOV(ip); mtx_lock(&vp->v_interlock); mtx_unlock(&cd9660_ihash_mtx); - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) goto loop; return (vp); } @@ -124,7 +124,6 @@ void cd9660_ihashins(ip) struct iso_node *ip; { - struct proc *p = curproc; /* XXX */ struct iso_node **ipp, *iq; mtx_lock(&cd9660_ihash_mtx); @@ -136,7 +135,7 @@ cd9660_ihashins(ip) *ipp = ip; mtx_unlock(&cd9660_ihash_mtx); - lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, p); + lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, curthread); } /* @@ -167,11 +166,11 @@ int cd9660_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; register struct iso_node *ip = VTOI(vp); int error = 0; @@ -179,13 +178,13 @@ cd9660_inactive(ap) vprint("cd9660_inactive: pushing active", vp); ip->i_flag = 0; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); /* * If we are done with the inode, reclaim it * so that it can be reused immediately. */ if (ip->inode.iso_mode == 0) - vrecycle(vp, NULL, p); + vrecycle(vp, NULL, td); return error; } @@ -196,7 +195,7 @@ int cd9660_reclaim(ap) struct vop_reclaim_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; diff --git a/sys/isofs/cd9660/cd9660_vfsops.c b/sys/isofs/cd9660/cd9660_vfsops.c index 0b42933..73a5bce 100644 --- a/sys/isofs/cd9660/cd9660_vfsops.c +++ b/sys/isofs/cd9660/cd9660_vfsops.c @@ -65,10 +65,10 @@ MALLOC_DEFINE(M_ISOFSMNT, "ISOFS mount", "ISOFS mount structure"); MALLOC_DEFINE(M_ISOFSNODE, "ISOFS node", "ISOFS vnode private part"); static int cd9660_mount __P((struct mount *, - char *, caddr_t, struct nameidata *, struct proc *)); -static int cd9660_unmount __P((struct mount *, int, struct proc *)); + char *, caddr_t, struct nameidata *, struct thread *)); +static int cd9660_unmount __P((struct mount *, int, struct thread *)); static int cd9660_root __P((struct mount *, struct vnode **)); -static int cd9660_statfs __P((struct mount *, struct statfs *, struct proc *)); +static int cd9660_statfs __P((struct mount *, struct statfs *, struct thread *)); static int cd9660_vget __P((struct mount *, ino_t, struct vnode **)); static int cd9660_fhtovp __P((struct mount *, struct fid *, struct vnode **)); static int cd9660_vptofh __P((struct vnode *, struct fid *)); @@ -97,9 +97,9 @@ MODULE_VERSION(cd9660, 1); * Called by vfs_mountroot when iso is going to be mounted as root. */ -static int iso_get_ssector __P((dev_t dev, struct proc *p)); +static int iso_get_ssector __P((dev_t dev, struct thread *td)); static int iso_mountfs __P((struct vnode *devvp, struct mount *mp, - struct proc *p, struct iso_args *argp)); + struct thread *td, struct iso_args *argp)); /* * Try to find the start of the last data track on this CD-ROM. This @@ -107,9 +107,9 @@ static int iso_mountfs __P((struct vnode *devvp, struct mount *mp, * and return 0 if we fail, this is always a safe bet. */ static int -iso_get_ssector(dev, p) +iso_get_ssector(dev, td) dev_t dev; - struct proc *p; + struct thread *td; { struct ioc_toc_header h; struct ioc_read_toc_single_entry t; @@ -122,13 +122,13 @@ iso_get_ssector(dev, p) if (ioctlp == NULL) return 0; - if (ioctlp(dev, CDIOREADTOCHEADER, (caddr_t)&h, FREAD, p) != 0) + if (ioctlp(dev, CDIOREADTOCHEADER, (caddr_t)&h, FREAD, td) != 0) return 0; for (i = h.ending_track; i >= 0; i--) { t.address_format = CD_LBA_FORMAT; t.track = i; - if (ioctlp(dev, CDIOREADTOCENTRY, (caddr_t)&t, FREAD, p) != 0) + if (ioctlp(dev, CDIOREADTOCENTRY, (caddr_t)&t, FREAD, td) != 0) return 0; if ((t.entry.control & 4) != 0) /* found a data track */ @@ -141,12 +141,12 @@ iso_get_ssector(dev, p) return ntohl(t.entry.addr.lba); } -static int iso_mountroot __P((struct mount *mp, struct proc *p)); +static int iso_mountroot __P((struct mount *mp, struct thread *td)); static int -iso_mountroot(mp, p) +iso_mountroot(mp, td) struct mount *mp; - struct proc *p; + struct thread *td; { struct iso_args args; int error; @@ -156,14 +156,14 @@ iso_mountroot(mp, p) return (error); } args.flags = ISOFSMNT_ROOT; - args.ssector = iso_get_ssector(rootdev, p); + args.ssector = iso_get_ssector(rootdev, td); if (bootverbose) printf("iso_mountroot(): using session at block %d\n", args.ssector); - if ((error = iso_mountfs(rootvp, mp, p, &args)) != 0) + if ((error = iso_mountfs(rootvp, mp, td, &args)) != 0) return (error); - (void)cd9660_statfs(mp, &mp->mnt_stat, p); + (void)cd9660_statfs(mp, &mp->mnt_stat, td); return (0); } @@ -173,12 +173,12 @@ iso_mountroot(mp, p) * mount system call */ static int -cd9660_mount(mp, path, data, ndp, p) +cd9660_mount(mp, path, data, ndp, td) register struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { struct vnode *devvp; struct iso_args args; @@ -188,7 +188,7 @@ cd9660_mount(mp, path, data, ndp, p) struct iso_mnt *imp = 0; if ((mp->mnt_flag & MNT_ROOTFS) != 0) { - return (iso_mountroot(mp, p)); + return (iso_mountroot(mp, td)); } if ((error = copyin(data, (caddr_t)&args, sizeof (struct iso_args)))) return (error); @@ -209,7 +209,7 @@ cd9660_mount(mp, path, data, ndp, p) * Not an update, or updating the name: look up the name * and verify that it refers to a sensible block device. */ - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, td); if ((error = namei(ndp))) return (error); NDFREE(ndp, NDF_ONLY_PNBUF); @@ -225,18 +225,18 @@ cd9660_mount(mp, path, data, ndp, p) * or has superuser abilities */ accessmode = VREAD; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_ACCESS(devvp, accessmode, td->td_proc->p_ucred, td); if (error) - error = suser(p); + error = suser_td(td); if (error) { vput(devvp); return (error); } - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); if ((mp->mnt_flag & MNT_UPDATE) == 0) { - error = iso_mountfs(devvp, mp, p, &args); + error = iso_mountfs(devvp, mp, td, &args); } else { if (devvp != imp->im_devvp) error = EINVAL; /* needs translation */ @@ -251,7 +251,7 @@ cd9660_mount(mp, path, data, ndp, p) (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); - (void) cd9660_statfs(mp, &mp->mnt_stat, p); + (void) cd9660_statfs(mp, &mp->mnt_stat, td); return 0; } @@ -259,10 +259,10 @@ cd9660_mount(mp, path, data, ndp, p) * Common code for mount and mountroot */ static int -iso_mountfs(devvp, mp, p, argp) +iso_mountfs(devvp, mp, td, argp) register struct vnode *devvp; struct mount *mp; - struct proc *p; + struct thread *td; struct iso_args *argp; { register struct iso_mnt *isomp = (struct iso_mnt *)0; @@ -295,12 +295,12 @@ iso_mountfs(devvp, mp, p, argp) return error; if (vcount(devvp) > 1 && devvp != rootvp) return EBUSY; - if ((error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0))) + if ((error = vinvalbuf(devvp, V_SAVE, td->td_proc->p_ucred, td, 0, 0))) return (error); - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_OPEN(devvp, FREAD, FSCRED, p); - VOP_UNLOCK(devvp, 0, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(devvp, FREAD, FSCRED, td); + VOP_UNLOCK(devvp, 0, td); if (error) return error; @@ -510,7 +510,7 @@ out: if (supbp) brelse(supbp); if (needclose) - (void)VOP_CLOSE(devvp, FREAD, NOCRED, p); + (void)VOP_CLOSE(devvp, FREAD, NOCRED, td); if (isomp) { free((caddr_t)isomp, M_ISOFSMNT); mp->mnt_data = (qaddr_t)0; @@ -522,10 +522,10 @@ out: * unmount system call */ static int -cd9660_unmount(mp, mntflags, p) +cd9660_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { register struct iso_mnt *isomp; int error, flags = 0; @@ -543,7 +543,7 @@ cd9660_unmount(mp, mntflags, p) isomp = VFSTOISOFS(mp); isomp->im_devvp->v_rdev->si_mountpoint = NULL; - error = VOP_CLOSE(isomp->im_devvp, FREAD, NOCRED, p); + error = VOP_CLOSE(isomp->im_devvp, FREAD, NOCRED, td); vrele(isomp->im_devvp); free((caddr_t)isomp, M_ISOFSMNT); mp->mnt_data = (qaddr_t)0; @@ -576,10 +576,10 @@ cd9660_root(mp, vpp) * Get file system statistics. */ int -cd9660_statfs(mp, sbp, p) +cd9660_statfs(mp, sbp, td) struct mount *mp; register struct statfs *sbp; - struct proc *p; + struct thread *td; { register struct iso_mnt *isomp; diff --git a/sys/isofs/cd9660/cd9660_vnops.c b/sys/isofs/cd9660/cd9660_vnops.c index 702823e..a902b58 100644 --- a/sys/isofs/cd9660/cd9660_vnops.c +++ b/sys/isofs/cd9660/cd9660_vnops.c @@ -87,7 +87,7 @@ cd9660_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -128,7 +128,7 @@ cd9660_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -162,7 +162,7 @@ cd9660_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { @@ -197,7 +197,7 @@ cd9660_getattr(ap) auio.uio_offset = 0; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = ap->a_p; + auio.uio_td = ap->a_td; auio.uio_resid = MAXPATHLEN; rdlnk.a_uio = &auio; rdlnk.a_vp = ap->a_vp; @@ -226,7 +226,7 @@ cd9660_ioctl(ap) caddr_t a_data; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; diff --git a/sys/kern/imgact_aout.c b/sys/kern/imgact_aout.c index 9aa8b3d..3ec8f5f 100644 --- a/sys/kern/imgact_aout.c +++ b/sys/kern/imgact_aout.c @@ -26,7 +26,7 @@ * $FreeBSD$ */ -#include "opt_upages.h" +#include "opt_kstack_pages.h" #include <sys/param.h> #include <sys/exec.h> @@ -250,29 +250,33 @@ exec_aout_imgact(imgp) * expand_name(), unless the process was setuid/setgid. */ int -aout_coredump(p, vp, limit) - register struct proc *p; +aout_coredump(td, vp, limit) + register struct thread *td; register struct vnode *vp; off_t limit; { + struct proc *p = td->td_proc; register struct ucred *cred = p->p_ucred; register struct vmspace *vm = p->p_vmspace; int error; - if (ctob(UPAGES + vm->vm_dsize + vm->vm_ssize) >= limit) + if (ctob((UAREA_PAGES + KSTACK_PAGES) + + vm->vm_dsize + vm->vm_ssize) >= limit) return (EFAULT); - fill_kinfo_proc(p, &p->p_addr->u_kproc); - error = cpu_coredump(p, vp, cred); + fill_kinfo_proc(p, &p->p_uarea->u_kproc); + error = cpu_coredump(td, vp, cred); if (error == 0) - error = vn_rdwr_inchunks(UIO_WRITE, vp, vm->vm_daddr, - (int)ctob(vm->vm_dsize), (off_t)ctob(UPAGES), UIO_USERSPACE, - IO_UNIT, cred, (int *) NULL, p); + error = vn_rdwr(UIO_WRITE, vp, vm->vm_daddr, + (int)ctob(vm->vm_dsize), + (off_t)ctob(UAREA_PAGES + KSTACK_PAGES), UIO_USERSPACE, + IO_UNIT, cred, (int *) NULL, td); if (error == 0) error = vn_rdwr_inchunks(UIO_WRITE, vp, (caddr_t) trunc_page(USRSTACK - ctob(vm->vm_ssize)), round_page(ctob(vm->vm_ssize)), - (off_t)ctob(UPAGES) + ctob(vm->vm_dsize), UIO_USERSPACE, - IO_UNIT, cred, (int *) NULL, p); + (off_t)ctob(UAREA_PAGES + KSTACK_PAGES) + + ctob(vm->vm_dsize), UIO_USERSPACE, + IO_UNIT, cred, (int *) NULL, td); return (error); } diff --git a/sys/kern/imgact_elf.c b/sys/kern/imgact_elf.c index 63999d1..66a3a34 100644 --- a/sys/kern/imgact_elf.c +++ b/sys/kern/imgact_elf.c @@ -342,6 +342,9 @@ elf_load_file(struct proc *p, const char *file, u_long *addr, u_long *entry) u_long base_addr = 0; int error, i, numsegs; + if (curthread->td_proc != p) + panic("elf_load_file - thread"); /* XXXKSE DIAGNOSTIC */ + tempdata = malloc(sizeof(*tempdata), M_TEMP, M_WAITOK); nd = &tempdata->nd; attr = &tempdata->attr; @@ -362,7 +365,8 @@ elf_load_file(struct proc *p, const char *file, u_long *addr, u_long *entry) goto fail; } - NDINIT(nd, LOOKUP, LOCKLEAF|FOLLOW, UIO_SYSSPACE, file, p); + /* XXXKSE */ + NDINIT(nd, LOOKUP, LOCKLEAF|FOLLOW, UIO_SYSSPACE, file, curthread); if ((error = namei(nd)) != 0) { nd->ni_vp = NULL; @@ -376,7 +380,7 @@ elf_load_file(struct proc *p, const char *file, u_long *addr, u_long *entry) */ error = exec_check_permissions(imgp); if (error) { - VOP_UNLOCK(nd->ni_vp, 0, p); + VOP_UNLOCK(nd->ni_vp, 0, curthread); /* XXXKSE */ goto fail; } @@ -387,7 +391,7 @@ elf_load_file(struct proc *p, const char *file, u_long *addr, u_long *entry) */ if (error == 0) nd->ni_vp->v_flag |= VTEXT; - VOP_UNLOCK(nd->ni_vp, 0, p); + VOP_UNLOCK(nd->ni_vp, 0, curthread); /* XXXKSE */ if (error) goto fail; @@ -736,7 +740,7 @@ static void cb_put_phdr __P((vm_map_entry_t, void *)); static void cb_size_segment __P((vm_map_entry_t, void *)); static void each_writable_segment __P((struct proc *, segment_callback, void *)); -static int elf_corehdr __P((struct proc *, struct vnode *, struct ucred *, +static int elf_corehdr __P((struct thread *, struct vnode *, struct ucred *, int, void *, size_t)); static void elf_puthdr __P((struct proc *, void *, size_t *, const prstatus_t *, const prfpregset_t *, const prpsinfo_t *, int)); @@ -746,11 +750,12 @@ static void elf_putnote __P((void *, size_t *, const char *, int, extern int osreldate; int -elf_coredump(p, vp, limit) - register struct proc *p; +elf_coredump(td, vp, limit) + struct thread *td; register struct vnode *vp; off_t limit; { + register struct proc *p = td->td_proc; register struct ucred *cred = p->p_ucred; int error = 0; struct sseg_closure seginfo; @@ -783,7 +788,7 @@ elf_coredump(p, vp, limit) if (hdr == NULL) { return EINVAL; } - error = elf_corehdr(p, vp, cred, seginfo.count, hdr, hdrsize); + error = elf_corehdr(td, vp, cred, seginfo.count, hdr, hdrsize); /* Write the contents of all of the writable segments. */ if (error == 0) { @@ -797,7 +802,7 @@ elf_coredump(p, vp, limit) error = vn_rdwr_inchunks(UIO_WRITE, vp, (caddr_t)php->p_vaddr, php->p_filesz, offset, UIO_USERSPACE, - IO_UNIT, cred, (int *)NULL, p); + IO_UNIT, cred, (int *)NULL, curthread); /* XXXKSE */ if (error != 0) break; offset += php->p_filesz; @@ -909,8 +914,8 @@ each_writable_segment(p, func, closure) * the page boundary. */ static int -elf_corehdr(p, vp, cred, numsegs, hdr, hdrsize) - struct proc *p; +elf_corehdr(td, vp, cred, numsegs, hdr, hdrsize) + struct thread *td; struct vnode *vp; struct ucred *cred; int numsegs; @@ -922,6 +927,7 @@ elf_corehdr(p, vp, cred, numsegs, hdr, hdrsize) prfpregset_t fpregset; prpsinfo_t psinfo; } *tempdata; + struct proc *p = td->td_proc; size_t off; prstatus_t *status; prfpregset_t *fpregset; @@ -940,9 +946,9 @@ elf_corehdr(p, vp, cred, numsegs, hdr, hdrsize) status->pr_osreldate = osreldate; status->pr_cursig = p->p_sig; status->pr_pid = p->p_pid; - fill_regs(p, &status->pr_reg); + fill_regs(td, &status->pr_reg); - fill_fpregs(p, fpregset); + fill_fpregs(td, fpregset); psinfo->pr_version = PRPSINFO_VERSION; psinfo->pr_psinfosz = sizeof(prpsinfo_t); @@ -960,7 +966,7 @@ elf_corehdr(p, vp, cred, numsegs, hdr, hdrsize) /* Write it to the core file. */ return vn_rdwr_inchunks(UIO_WRITE, vp, hdr, hdrsize, (off_t)0, - UIO_SYSSPACE, IO_UNIT, cred, NULL, p); + UIO_SYSSPACE, IO_UNIT, cred, NULL, td); /* XXXKSE */ } static void diff --git a/sys/kern/init_main.c b/sys/kern/init_main.c index 3859c5b..62d1655 100644 --- a/sys/kern/init_main.c +++ b/sys/kern/init_main.c @@ -83,6 +83,7 @@ void mi_startup(void); /* Should be elsewhere */ static struct session session0; static struct pgrp pgrp0; struct proc proc0; +struct thread *thread0; static struct procsig procsig0; static struct filedesc0 filedesc0; static struct plimit limit0; @@ -90,7 +91,6 @@ static struct vmspace vmspace0; struct proc *initproc; int cmask = CMASK; -extern struct user *proc0paddr; extern int fallback_elf_brand; struct vnode *rootvp; @@ -273,10 +273,17 @@ proc0_init(void *dummy __unused) register struct proc *p; register struct filedesc0 *fdp; register unsigned i; + struct thread *td; GIANT_REQUIRED; - + /* + * This assumes the proc0 struct has already been linked + * using proc_linkup() in the machine specific initialisation + * e.g. i386_init() + */ p = &proc0; + td = thread0; + mtx_init(&p->p_mtx, "process lock", MTX_DEF); /* * Initialize magic number. @@ -321,11 +328,11 @@ proc0_init(void *dummy __unused) p->p_flag = P_SYSTEM; p->p_sflag = PS_INMEM; p->p_stat = SRUN; - p->p_nice = NZERO; - p->p_pri.pri_class = PRI_TIMESHARE; - p->p_pri.pri_level = PVM; - p->p_pri.pri_native = PUSER; - p->p_pri.pri_user = PUSER; + p->p_ksegrp.kg_nice = NZERO; + p->p_ksegrp.kg_pri.pri_class = PRI_TIMESHARE; + p->p_ksegrp.kg_pri.pri_level = PVM; + p->p_ksegrp.kg_pri.pri_native = PUSER; + p->p_ksegrp.kg_pri.pri_user = PUSER; p->p_peers = 0; p->p_leader = p; @@ -333,7 +340,7 @@ proc0_init(void *dummy __unused) bcopy("swapper", p->p_comm, sizeof ("swapper")); callout_init(&p->p_itcallout, 0); - callout_init(&p->p_slpcallout, 1); + callout_init(&td->td_slpcallout, 1); /* Create credentials. */ p->p_ucred = crget(); @@ -381,14 +388,13 @@ proc0_init(void *dummy __unused) vm_map_init(&vmspace0.vm_map, round_page(VM_MIN_ADDRESS), trunc_page(VM_MAXUSER_ADDRESS)); vmspace0.vm_map.pmap = vmspace_pmap(&vmspace0); - p->p_addr = proc0paddr; /* XXX */ /* * We continue to place resource usage info and signal * actions in the user struct so they're pageable. */ - p->p_stats = &p->p_addr->u_stats; - p->p_sigacts = &p->p_addr->u_sigacts; + p->p_stats = &p->p_uarea->u_stats; + p->p_sigacts = &p->p_uarea->u_sigacts; /* * Charge root for one process. @@ -467,13 +473,15 @@ start_init(void *dummy) int options, error; char *var, *path, *next, *s; char *ucp, **uap, *arg0, *arg1; + struct thread *td; struct proc *p; mtx_lock(&Giant); GIANT_REQUIRED; - p = curproc; + td = curthread; + p = td->td_proc; /* Get the vnode for '/'. Set p->p_fd->fd_cdir to reference it. */ if (VFS_ROOT(TAILQ_FIRST(&mountlist), &rootvnode)) @@ -482,7 +490,7 @@ start_init(void *dummy) VREF(p->p_fd->fd_cdir); p->p_fd->fd_rdir = rootvnode; VREF(p->p_fd->fd_rdir); - VOP_UNLOCK(rootvnode, 0, p); + VOP_UNLOCK(rootvnode, 0, td); /* * Need just enough stack to hold the faked-up "execve()" arguments. @@ -573,7 +581,7 @@ start_init(void *dummy) * Otherwise, return via fork_trampoline() all the way * to user mode as init! */ - if ((error = execve(p, &args)) == 0) { + if ((error = execve(td, &args)) == 0) { mtx_unlock(&Giant); return; } @@ -597,7 +605,7 @@ create_init(const void *udata __unused) { int error; - error = fork1(&proc0, RFFDG | RFPROC | RFSTOPPED, &initproc); + error = fork1(thread0, RFFDG | RFPROC | RFSTOPPED, &initproc); if (error) panic("cannot fork init: %d\n", error); PROC_LOCK(initproc); @@ -606,7 +614,7 @@ create_init(const void *udata __unused) mtx_lock_spin(&sched_lock); initproc->p_sflag |= PS_INMEM; mtx_unlock_spin(&sched_lock); - cpu_set_fork_handler(initproc, start_init, NULL); + cpu_set_fork_handler(&initproc->p_thread, start_init, NULL); } SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL) @@ -619,7 +627,7 @@ kick_init(const void *udata __unused) mtx_lock_spin(&sched_lock); initproc->p_stat = SRUN; - setrunqueue(initproc); + setrunqueue(&initproc->p_thread); /* XXXKSE */ mtx_unlock_spin(&sched_lock); } SYSINIT(kickinit, SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, kick_init, NULL) diff --git a/sys/kern/kern_acct.c b/sys/kern/kern_acct.c index 9a2ebab..8c319f7 100644 --- a/sys/kern/kern_acct.c +++ b/sys/kern/kern_acct.c @@ -110,20 +110,20 @@ SYSCTL_INT(_kern, OID_AUTO, acct_chkfreq, CTLFLAG_RW, * MPSAFE */ int -acct(a1, uap) - struct proc *a1; +acct(td, uap) + struct thread *td; struct acct_args /* { syscallarg(char *) path; } */ *uap; { - struct proc *p = curproc; /* XXX */ struct nameidata nd; int error, flags; mtx_lock(&Giant); - + if (td != curthread) + panic("acct"); /* XXXKSE DIAGNOSTIC */ /* Make sure that the caller is root. */ - error = suser(p); + error = suser(td->td_proc); if (error) goto done2; @@ -133,15 +133,15 @@ acct(a1, uap) */ if (SCARG(uap, path) != NULL) { NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), - p); + td); flags = FWRITE; error = vn_open(&nd, &flags, 0); if (error) goto done2; NDFREE(&nd, NDF_ONLY_PNBUF); - VOP_UNLOCK(nd.ni_vp, 0, p); + VOP_UNLOCK(nd.ni_vp, 0, td); if (nd.ni_vp->v_type != VREG) { - vn_close(nd.ni_vp, FWRITE, p->p_ucred, p); + vn_close(nd.ni_vp, FWRITE, td->td_proc->p_ucred, td); error = EACCES; goto done2; } @@ -154,7 +154,7 @@ acct(a1, uap) if (acctp != NULLVP || savacctp != NULLVP) { callout_stop(&acctwatch_callout); error = vn_close((acctp != NULLVP ? acctp : savacctp), FWRITE, - p->p_ucred, p); + td->td_proc->p_ucred, td); acctp = savacctp = NULLVP; } if (SCARG(uap, path) == NULL) @@ -180,9 +180,10 @@ done2: */ int -acct_process(p) - struct proc *p; +acct_process(td) + struct thread *td; { + struct proc *p = td->td_proc; struct acct acct; struct rusage *r; struct timeval ut, st, tmp; @@ -253,10 +254,10 @@ acct_process(p) /* * Write the accounting information to the file. */ - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); return (vn_rdwr(UIO_WRITE, vp, (caddr_t)&acct, sizeof (acct), - (off_t)0, UIO_SYSSPACE, IO_APPEND|IO_UNIT, p->p_ucred, - (int *)0, p)); + (off_t)0, UIO_SYSSPACE, IO_APPEND|IO_UNIT, td->td_proc->p_ucred, + (int *)0, td)); } /* @@ -317,7 +318,7 @@ acctwatch(a) savacctp = NULLVP; return; } - (void)VFS_STATFS(savacctp->v_mount, &sb, (struct proc *)0); + (void)VFS_STATFS(savacctp->v_mount, &sb, (struct thread *)0); if (sb.f_bavail > acctresume * sb.f_blocks / 100) { acctp = savacctp; savacctp = NULLVP; @@ -331,7 +332,7 @@ acctwatch(a) acctp = NULLVP; return; } - (void)VFS_STATFS(acctp->v_mount, &sb, (struct proc *)0); + (void)VFS_STATFS(acctp->v_mount, &sb, (struct thread *)0); if (sb.f_bavail <= acctsuspend * sb.f_blocks / 100) { savacctp = acctp; acctp = NULLVP; diff --git a/sys/kern/kern_acl.c b/sys/kern/kern_acl.c index 69dbe85..045d1a8 100644 --- a/sys/kern/kern_acl.c +++ b/sys/kern/kern_acl.c @@ -48,11 +48,11 @@ MALLOC_DEFINE(M_ACL, "acl", "access control list"); -static int vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, +static int vacl_set_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp); -static int vacl_get_acl(struct proc *p, struct vnode *vp, acl_type_t type, +static int vacl_get_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp); -static int vacl_aclcheck(struct proc *p, struct vnode *vp, +static int vacl_aclcheck( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp); /* @@ -562,7 +562,7 @@ acl_posix1e_check(struct acl *acl) * Given a vnode, set its ACL. */ static int -vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, +vacl_set_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp) { struct acl inkernacl; @@ -571,10 +571,10 @@ vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, error = copyin(aclp, &inkernacl, sizeof(struct acl)); if (error) return(error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_SETACL(vp, type, &inkernacl, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_SETACL(vp, type, &inkernacl, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); return(error); } @@ -582,16 +582,16 @@ vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, * Given a vnode, get its ACL. */ static int -vacl_get_acl(struct proc *p, struct vnode *vp, acl_type_t type, +vacl_get_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp) { struct acl inkernelacl; int error; - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_GETACL(vp, type, &inkernelacl, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_GETACL(vp, type, &inkernelacl, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); if (error == 0) error = copyout(&inkernelacl, aclp, sizeof(struct acl)); return (error); @@ -601,14 +601,14 @@ vacl_get_acl(struct proc *p, struct vnode *vp, acl_type_t type, * Given a vnode, delete its ACL. */ static int -vacl_delete(struct proc *p, struct vnode *vp, acl_type_t type) +vacl_delete( struct thread *td, struct vnode *vp, acl_type_t type) { int error; - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_SETACL(vp, ACL_TYPE_DEFAULT, 0, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_SETACL(vp, ACL_TYPE_DEFAULT, 0, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); return (error); } @@ -616,7 +616,7 @@ vacl_delete(struct proc *p, struct vnode *vp, acl_type_t type) * Given a vnode, check whether an ACL is appropriate for it */ static int -vacl_aclcheck(struct proc *p, struct vnode *vp, acl_type_t type, +vacl_aclcheck( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp) { struct acl inkernelacl; @@ -625,7 +625,7 @@ vacl_aclcheck(struct proc *p, struct vnode *vp, acl_type_t type, error = copyin(aclp, &inkernelacl, sizeof(struct acl)); if (error) return(error); - error = VOP_ACLCHECK(vp, type, &inkernelacl, p->p_ucred, p); + error = VOP_ACLCHECK(vp, type, &inkernelacl, td->td_proc->p_ucred, td); return (error); } @@ -641,17 +641,17 @@ vacl_aclcheck(struct proc *p, struct vnode *vp, acl_type_t type, * MPSAFE */ int -__acl_get_file(struct proc *p, struct __acl_get_file_args *uap) +__acl_get_file( struct thread *td, struct __acl_get_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); /* what flags are required here -- possible not LOCKLEAF? */ - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_get_acl(p, nd.ni_vp, SCARG(uap, type), + error = vacl_get_acl(td, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp)); NDFREE(&nd, 0); } @@ -665,16 +665,16 @@ __acl_get_file(struct proc *p, struct __acl_get_file_args *uap) * MPSAFE */ int -__acl_set_file(struct proc *p, struct __acl_set_file_args *uap) +__acl_set_file( struct thread *td, struct __acl_set_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_set_acl(p, nd.ni_vp, SCARG(uap, type), + error = vacl_set_acl(td, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp)); NDFREE(&nd, 0); } @@ -688,15 +688,15 @@ __acl_set_file(struct proc *p, struct __acl_set_file_args *uap) * MPSAFE */ int -__acl_get_fd(struct proc *p, struct __acl_get_fd_args *uap) +__acl_get_fd( struct thread *td, struct __acl_get_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_get_acl(p, (struct vnode *)fp->f_data, + error = vacl_get_acl(td, (struct vnode *)fp->f_data, SCARG(uap, type), SCARG(uap, aclp)); } mtx_unlock(&Giant); @@ -709,15 +709,15 @@ __acl_get_fd(struct proc *p, struct __acl_get_fd_args *uap) * MPSAFE */ int -__acl_set_fd(struct proc *p, struct __acl_set_fd_args *uap) +__acl_set_fd( struct thread *td, struct __acl_set_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_set_acl(p, (struct vnode *)fp->f_data, + error = vacl_set_acl(td, (struct vnode *)fp->f_data, SCARG(uap, type), SCARG(uap, aclp)); } mtx_unlock(&Giant); @@ -730,16 +730,16 @@ __acl_set_fd(struct proc *p, struct __acl_set_fd_args *uap) * MPSAFE */ int -__acl_delete_file(struct proc *p, struct __acl_delete_file_args *uap) +__acl_delete_file( struct thread *td, struct __acl_delete_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_delete(p, nd.ni_vp, SCARG(uap, type)); + error = vacl_delete(td, nd.ni_vp, SCARG(uap, type)); NDFREE(&nd, 0); } mtx_unlock(&Giant); @@ -752,15 +752,15 @@ __acl_delete_file(struct proc *p, struct __acl_delete_file_args *uap) * MPSAFE */ int -__acl_delete_fd(struct proc *p, struct __acl_delete_fd_args *uap) +__acl_delete_fd( struct thread *td, struct __acl_delete_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_delete(p, (struct vnode *)fp->f_data, + error = vacl_delete(td, (struct vnode *)fp->f_data, SCARG(uap, type)); } mtx_unlock(&Giant); @@ -773,16 +773,16 @@ __acl_delete_fd(struct proc *p, struct __acl_delete_fd_args *uap) * MPSAFE */ int -__acl_aclcheck_file(struct proc *p, struct __acl_aclcheck_file_args *uap) +__acl_aclcheck_file( struct thread *td, struct __acl_aclcheck_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_aclcheck(p, nd.ni_vp, SCARG(uap, type), + error = vacl_aclcheck(td, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp)); NDFREE(&nd, 0); } @@ -796,15 +796,15 @@ __acl_aclcheck_file(struct proc *p, struct __acl_aclcheck_file_args *uap) * MPSAFE */ int -__acl_aclcheck_fd(struct proc *p, struct __acl_aclcheck_fd_args *uap) +__acl_aclcheck_fd( struct thread *td, struct __acl_aclcheck_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_aclcheck(p, (struct vnode *)fp->f_data, + error = vacl_aclcheck(td, (struct vnode *)fp->f_data, SCARG(uap, type), SCARG(uap, aclp)); } mtx_unlock(&Giant); diff --git a/sys/kern/kern_cap.c b/sys/kern/kern_cap.c index b8f0c42..45a2509 100644 --- a/sys/kern/kern_cap.c +++ b/sys/kern/kern_cap.c @@ -54,7 +54,7 @@ * Syscall to allow a process to get it's currently capability set */ int -__cap_get_proc(struct proc *p, struct __cap_get_proc_args *uap) +__cap_get_proc(struct thread *td, struct __cap_get_proc_args *uap) { return (ENOSYS); @@ -65,7 +65,7 @@ __cap_get_proc(struct proc *p, struct __cap_get_proc_args *uap) * permitted. */ int -__cap_set_proc(struct proc *p, struct __cap_set_proc_args *uap) +__cap_set_proc(struct thread *td, struct __cap_set_proc_args *uap) { return (ENOSYS); @@ -76,14 +76,14 @@ __cap_set_proc(struct proc *p, struct __cap_set_proc_args *uap) * files, if permitted. */ int -__cap_get_fd(struct proc *p, struct __cap_get_fd_args *uap) +__cap_get_fd(struct thread *td, struct __cap_get_fd_args *uap) { return (ENOSYS); } int -__cap_get_file(struct proc *p, struct __cap_get_file_args *uap) +__cap_get_file(struct thread *td, struct __cap_get_file_args *uap) { return (ENOSYS); @@ -94,14 +94,14 @@ __cap_get_file(struct proc *p, struct __cap_get_file_args *uap) * if permitted. */ int -__cap_set_fd(struct proc *p, struct __cap_set_fd_args *uap) +__cap_set_fd(struct thread *td, struct __cap_set_fd_args *uap) { return (ENOSYS); } int -__cap_set_file(struct proc *p, struct __cap_set_file_args *uap) +__cap_set_file(struct thread *td, struct __cap_set_file_args *uap) { return (ENOSYS); diff --git a/sys/kern/kern_clock.c b/sys/kern/kern_clock.c index f48b212..9ac63ad 100644 --- a/sys/kern/kern_clock.c +++ b/sys/kern/kern_clock.c @@ -150,7 +150,7 @@ initclocks(dummy) /* * Each time the real-time timer fires, this function is called on all CPUs - * with each CPU passing in its curproc as the first argument. If possible + * with each CPU passing in its curthread as the first argument. If possible * a nice optimization in the future would be to allow the CPU receiving the * actual real-time timer interrupt to call this function on behalf of the * other CPUs rather than sending an IPI to all other CPUs so that they @@ -159,24 +159,33 @@ initclocks(dummy) * system need to call this function (or have it called on their behalf. */ void -hardclock_process(p, user) - struct proc *p; +hardclock_process(td, user) + struct thread *td; int user; { struct pstats *pstats; + struct proc *p = td->td_proc; /* * Run current process's virtual and profile time, as needed. */ mtx_assert(&sched_lock, MA_OWNED); - pstats = p->p_stats; - if (user && - timevalisset(&pstats->p_timer[ITIMER_VIRTUAL].it_value) && - itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL], tick) == 0) - p->p_sflag |= PS_ALRMPEND | PS_ASTPENDING; - if (timevalisset(&pstats->p_timer[ITIMER_PROF].it_value) && - itimerdecr(&pstats->p_timer[ITIMER_PROF], tick) == 0) - p->p_sflag |= PS_PROFPEND | PS_ASTPENDING; + if (p->p_flag & P_KSES) { + /* XXXKSE What to do? */ + } else { + pstats = p->p_stats; + if (user && + timevalisset(&pstats->p_timer[ITIMER_VIRTUAL].it_value) && + itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL], tick) == 0) { + p->p_sflag |= PS_ALRMPEND; + td->td_kse->ke_flags |= KEF_ASTPENDING; + } + if (timevalisset(&pstats->p_timer[ITIMER_PROF].it_value) && + itimerdecr(&pstats->p_timer[ITIMER_PROF], tick) == 0) { + p->p_sflag |= PS_PROFPEND; + td->td_kse->ke_flags |= KEF_ASTPENDING; + } + } } /* @@ -190,7 +199,7 @@ hardclock(frame) CTR0(KTR_INTR, "hardclock fired"); mtx_lock_spin(&sched_lock); - hardclock_process(curproc, CLKF_USERMODE(frame)); + hardclock_process(curthread, CLKF_USERMODE(frame)); mtx_unlock_spin(&sched_lock); /* @@ -337,14 +346,14 @@ stopprofclock(p) /* * Do process and kernel statistics. Most of the statistics are only * used by user-level statistics programs. The main exceptions are - * p->p_uticks, p->p_sticks, p->p_iticks, and p->p_estcpu. This function + * ke->ke_uticks, p->p_sticks, p->p_iticks, and p->p_estcpu. This function * should be called by all CPUs in the system for each statistics clock * interrupt. See the description of hardclock_process for more detail on * this function's relationship to statclock. */ void -statclock_process(p, pc, user) - struct proc *p; +statclock_process(ke, pc, user) + struct kse *ke; register_t pc; int user; { @@ -356,8 +365,10 @@ statclock_process(p, pc, user) long rss; struct rusage *ru; struct vmspace *vm; + struct proc *p = ke->ke_proc; + struct thread *td = ke->ke_thread; /* current thread */ - KASSERT(p == curproc, ("statclock_process: p != curproc")); + KASSERT(ke == curthread->td_kse, ("statclock_process: td != curthread")); mtx_assert(&sched_lock, MA_OWNED); if (user) { /* @@ -365,14 +376,14 @@ statclock_process(p, pc, user) * If this process is being profiled, record the tick. */ if (p->p_sflag & PS_PROFIL) - addupc_intr(p, pc, 1); + addupc_intr(ke, pc, 1); if (pscnt < psdiv) return; /* * Charge the time as appropriate. */ - p->p_uticks++; - if (p->p_nice > NZERO) + ke->ke_uticks++; + if (ke->ke_ksegrp->kg_nice > NZERO) cp_time[CP_NICE]++; else cp_time[CP_USER]++; @@ -404,19 +415,19 @@ statclock_process(p, pc, user) * so that we know how much of its real time was spent * in ``non-process'' (i.e., interrupt) work. */ - if ((p->p_ithd != NULL) || p->p_intr_nesting_level >= 2) { - p->p_iticks++; + if ((td->td_ithd != NULL) || td->td_intr_nesting_level >= 2) { + ke->ke_iticks++; cp_time[CP_INTR]++; } else { - p->p_sticks++; - if (p != PCPU_GET(idleproc)) + ke->ke_sticks++; + if (p != PCPU_GET(idlethread)->td_proc) cp_time[CP_SYS]++; else cp_time[CP_IDLE]++; } } - schedclock(p); + schedclock(ke->ke_thread); /* Update resource usage integrals and maximums. */ if ((pstats = p->p_stats) != NULL && @@ -435,7 +446,7 @@ statclock_process(p, pc, user) * Statistics clock. Grab profile sample, and if divider reaches 0, * do process and kernel statistics. Most of the statistics are only * used by user-level statistics programs. The main exceptions are - * p->p_uticks, p->p_sticks, p->p_iticks, and p->p_estcpu. + * ke->ke_uticks, p->p_sticks, p->p_iticks, and p->p_estcpu. */ void statclock(frame) @@ -446,7 +457,7 @@ statclock(frame) mtx_lock_spin(&sched_lock); if (--pscnt == 0) pscnt = psdiv; - statclock_process(curproc, CLKF_PC(frame), CLKF_USERMODE(frame)); + statclock_process(curthread->td_kse, CLKF_PC(frame), CLKF_USERMODE(frame)); mtx_unlock_spin(&sched_lock); } diff --git a/sys/kern/kern_condvar.c b/sys/kern/kern_condvar.c index 4e26f2e..7a8b376 100644 --- a/sys/kern/kern_condvar.c +++ b/sys/kern/kern_condvar.c @@ -46,9 +46,9 @@ /* * Common sanity checks for cv_wait* functions. */ -#define CV_ASSERT(cvp, mp, p) do { \ - KASSERT((p) != NULL, ("%s: curproc NULL", __FUNCTION__)); \ - KASSERT((p)->p_stat == SRUN, ("%s: not SRUN", __FUNCTION__)); \ +#define CV_ASSERT(cvp, mp, td) do { \ + KASSERT((td) != NULL, ("%s: curthread NULL", __FUNCTION__)); \ + KASSERT((td)->td_proc->p_stat == SRUN, ("%s: not SRUN", __FUNCTION__)); \ KASSERT((cvp) != NULL, ("%s: cvp NULL", __FUNCTION__)); \ KASSERT((mp) != NULL, ("%s: mp NULL", __FUNCTION__)); \ mtx_assert((mp), MA_OWNED | MA_NOTRECURSED); \ @@ -112,21 +112,23 @@ cv_destroy(struct cv *cvp) * Switch context. */ static __inline void -cv_switch(struct proc *p) +cv_switch(struct thread *td) { - p->p_stat = SSLEEP; - p->p_stats->p_ru.ru_nvcsw++; + td->td_proc->p_stat = SSLEEP; + td->td_proc->p_stats->p_ru.ru_nvcsw++; mi_switch(); - CTR3(KTR_PROC, "cv_switch: resume proc %p (pid %d, %s)", p, p->p_pid, - p->p_comm); + CTR3(KTR_PROC, "cv_switch: resume thread %p (pid %d, %s)", + td, + td->td_proc->p_pid, + td->td_proc->p_comm); } /* * Switch context, catching signals. */ static __inline int -cv_switch_catch(struct proc *p) +cv_switch_catch(struct thread *td) { int sig; @@ -136,69 +138,71 @@ cv_switch_catch(struct proc *p) * both) could occur while we were stopped. A SIGCONT would cause us to * be marked as SSLEEP without resuming us, thus we must be ready for * sleep when CURSIG is called. If the wakeup happens while we're - * stopped, p->p_wchan will be 0 upon return from CURSIG. + * stopped, td->td_wchan will be 0 upon return from CURSIG. */ - p->p_sflag |= PS_SINTR; + td->td_flags |= TDF_SINTR; mtx_unlock_spin(&sched_lock); - PROC_LOCK(p); - sig = CURSIG(p); + PROC_LOCK(td->td_proc); + sig = CURSIG(td->td_proc); /* XXXKSE */ mtx_lock_spin(&sched_lock); - PROC_UNLOCK_NOSWITCH(p); + PROC_UNLOCK_NOSWITCH(td->td_proc); if (sig != 0) { - if (p->p_wchan != NULL) - cv_waitq_remove(p); - p->p_stat = SRUN; - } else if (p->p_wchan != NULL) { - cv_switch(p); + if (td->td_wchan != NULL) + cv_waitq_remove(td); + td->td_proc->p_stat = SRUN; + } else if (td->td_wchan != NULL) { + cv_switch(td); } - p->p_sflag &= ~PS_SINTR; + td->td_flags &= ~TDF_SINTR; return sig; } /* - * Add a process to the wait queue of a condition variable. + * Add a thread to the wait queue of a condition variable. */ static __inline void -cv_waitq_add(struct cv *cvp, struct proc *p) +cv_waitq_add(struct cv *cvp, struct thread *td) { /* * Process may be sitting on a slpque if asleep() was called, remove it * before re-adding. */ - if (p->p_wchan != NULL) - unsleep(p); - - p->p_sflag |= PS_CVWAITQ; - p->p_wchan = cvp; - p->p_wmesg = cvp->cv_description; - p->p_slptime = 0; - p->p_pri.pri_native = p->p_pri.pri_level; - CTR3(KTR_PROC, "cv_waitq_add: proc %p (pid %d, %s)", p, p->p_pid, - p->p_comm); - TAILQ_INSERT_TAIL(&cvp->cv_waitq, p, p_slpq); + if (td->td_wchan != NULL) + unsleep(td); + + td->td_flags |= TDF_CVWAITQ; + td->td_wchan = cvp; + td->td_wmesg = cvp->cv_description; + td->td_kse->ke_slptime = 0; /* XXXKSE */ + td->td_ksegrp->kg_slptime = 0; /* XXXKSE */ + td->td_ksegrp->kg_pri.pri_native = td->td_ksegrp->kg_pri.pri_level; + CTR3(KTR_PROC, "cv_waitq_add: thread %p (pid %d, %s)", td, + td->td_proc->p_pid, + td->td_proc->p_comm); + TAILQ_INSERT_TAIL(&cvp->cv_waitq, td, td_slpq); } /* - * Wait on a condition variable. The current process is placed on the condition + * Wait on a condition variable. The current thread is placed on the condition * variable's wait queue and suspended. A cv_signal or cv_broadcast on the same - * condition variable will resume the process. The mutex is released before + * condition variable will resume the thread. The mutex is released before * sleeping and will be held on return. It is recommended that the mutex be * held when cv_signal or cv_broadcast are called. */ void cv_wait(struct cv *cvp, struct mtx *mp) { - struct proc *p; + struct thread *td; WITNESS_SAVE_DECL(mp); - p = CURPROC; + td = curthread; #ifdef KTRACE - if (p && KTRPOINT(p, KTR_CSW)) - ktrcsw(p->p_tracep, 1, 0); + if (td->td_proc && KTRPOINT(td->td_proc, KTR_CSW)) + ktrcsw(td->td_proc->p_tracep, 1, 0); #endif - CV_ASSERT(cvp, mp, p); + CV_ASSERT(cvp, mp, td); WITNESS_SLEEP(0, &mp->mtx_object); WITNESS_SAVE(&mp->mtx_object, mp); @@ -207,7 +211,7 @@ cv_wait(struct cv *cvp, struct mtx *mp) /* * After a panic, or during autoconfiguration, just give * interrupts a chance, then just return; don't run any other - * procs or panic below, in case this is the idle process and + * thread or panic below, in case this is the idle process and * already asleep. */ mtx_unlock_spin(&sched_lock); @@ -218,13 +222,13 @@ cv_wait(struct cv *cvp, struct mtx *mp) DROP_GIANT_NOSWITCH(); mtx_unlock_flags(mp, MTX_NOSWITCH); - cv_waitq_add(cvp, p); - cv_switch(p); + cv_waitq_add(cvp, td); + cv_switch(td); mtx_unlock_spin(&sched_lock); #ifdef KTRACE - if (KTRPOINT(p, KTR_CSW)) - ktrcsw(p->p_tracep, 0, 0); + if (KTRPOINT(td->td_proc, KTR_CSW)) + ktrcsw(td->td_proc->p_tracep, 0, 0); #endif PICKUP_GIANT(); mtx_lock(mp); @@ -233,25 +237,25 @@ cv_wait(struct cv *cvp, struct mtx *mp) /* * Wait on a condition variable, allowing interruption by signals. Return 0 if - * the process was resumed with cv_signal or cv_broadcast, EINTR or ERESTART if + * the thread was resumed with cv_signal or cv_broadcast, EINTR or ERESTART if * a signal was caught. If ERESTART is returned the system call should be * restarted if possible. */ int cv_wait_sig(struct cv *cvp, struct mtx *mp) { - struct proc *p; + struct thread *td; int rval; int sig; WITNESS_SAVE_DECL(mp); - p = CURPROC; + td = curthread; rval = 0; #ifdef KTRACE - if (p && KTRPOINT(p, KTR_CSW)) - ktrcsw(p->p_tracep, 1, 0); + if (td->td_proc && KTRPOINT(td->td_proc, KTR_CSW)) + ktrcsw(td->td_proc->p_tracep, 1, 0); #endif - CV_ASSERT(cvp, mp, p); + CV_ASSERT(cvp, mp, td); WITNESS_SLEEP(0, &mp->mtx_object); WITNESS_SAVE(&mp->mtx_object, mp); @@ -271,27 +275,27 @@ cv_wait_sig(struct cv *cvp, struct mtx *mp) DROP_GIANT_NOSWITCH(); mtx_unlock_flags(mp, MTX_NOSWITCH); - cv_waitq_add(cvp, p); - sig = cv_switch_catch(p); + cv_waitq_add(cvp, td); + sig = cv_switch_catch(td); mtx_unlock_spin(&sched_lock); PICKUP_GIANT(); - PROC_LOCK(p); + PROC_LOCK(td->td_proc); if (sig == 0) - sig = CURSIG(p); + sig = CURSIG(td->td_proc); /* XXXKSE */ if (sig != 0) { - if (SIGISMEMBER(p->p_sigacts->ps_sigintr, sig)) + if (SIGISMEMBER(td->td_proc->p_sigacts->ps_sigintr, sig)) rval = EINTR; else rval = ERESTART; } - PROC_UNLOCK(p); + PROC_UNLOCK(td->td_proc); #ifdef KTRACE mtx_lock(&Giant); - if (KTRPOINT(p, KTR_CSW)) - ktrcsw(p->p_tracep, 0, 0); + if (KTRPOINT(td->td_proc, KTR_CSW)) + ktrcsw(td->td_proc->p_tracep, 0, 0); mtx_unlock(&Giant); #endif mtx_lock(mp); @@ -308,17 +312,16 @@ cv_wait_sig(struct cv *cvp, struct mtx *mp) int cv_timedwait(struct cv *cvp, struct mtx *mp, int timo) { - struct proc *p; + struct thread *td; int rval; WITNESS_SAVE_DECL(mp); - p = CURPROC; + td = curthread; rval = 0; #ifdef KTRACE - if (p && KTRPOINT(p, KTR_CSW)) - ktrcsw(p->p_tracep, 1, 0); + ktrcsw(td->td_proc->p_tracep, 1, 0); #endif - CV_ASSERT(cvp, mp, p); + CV_ASSERT(cvp, mp, td); WITNESS_SLEEP(0, &mp->mtx_object); WITNESS_SAVE(&mp->mtx_object, mp); @@ -327,7 +330,7 @@ cv_timedwait(struct cv *cvp, struct mtx *mp, int timo) /* * After a panic, or during autoconfiguration, just give * interrupts a chance, then just return; don't run any other - * procs or panic below, in case this is the idle process and + * thread or panic below, in case this is the idle process and * already asleep. */ mtx_unlock_spin(&sched_lock); @@ -338,29 +341,29 @@ cv_timedwait(struct cv *cvp, struct mtx *mp, int timo) DROP_GIANT_NOSWITCH(); mtx_unlock_flags(mp, MTX_NOSWITCH); - cv_waitq_add(cvp, p); - callout_reset(&p->p_slpcallout, timo, cv_timedwait_end, p); - cv_switch(p); + cv_waitq_add(cvp, td); + callout_reset(&td->td_slpcallout, timo, cv_timedwait_end, td); + cv_switch(td); - if (p->p_sflag & PS_TIMEOUT) { - p->p_sflag &= ~PS_TIMEOUT; + if (td->td_flags & TDF_TIMEOUT) { + td->td_flags &= ~TDF_TIMEOUT; rval = EWOULDBLOCK; - } else if (p->p_sflag & PS_TIMOFAIL) - p->p_sflag &= ~PS_TIMOFAIL; - else if (callout_stop(&p->p_slpcallout) == 0) { + } else if (td->td_flags & TDF_TIMOFAIL) + td->td_flags &= ~TDF_TIMOFAIL; + else if (callout_stop(&td->td_slpcallout) == 0) { /* * Work around race with cv_timedwait_end similar to that * between msleep and endtsleep. */ - p->p_sflag |= PS_TIMEOUT; - p->p_stats->p_ru.ru_nivcsw++; + td->td_flags |= TDF_TIMEOUT; + td->td_proc->p_stats->p_ru.ru_nivcsw++; mi_switch(); } mtx_unlock_spin(&sched_lock); #ifdef KTRACE - if (KTRPOINT(p, KTR_CSW)) - ktrcsw(p->p_tracep, 0, 0); + if (KTRPOINT(td->td_proc, KTR_CSW)) + ktrcsw(td->td_proc->p_tracep, 0, 0); #endif PICKUP_GIANT(); mtx_lock(mp); @@ -371,25 +374,25 @@ cv_timedwait(struct cv *cvp, struct mtx *mp, int timo) /* * Wait on a condition variable for at most timo/hz seconds, allowing - * interruption by signals. Returns 0 if the process was resumed by cv_signal + * interruption by signals. Returns 0 if the thread was resumed by cv_signal * or cv_broadcast, EWOULDBLOCK if the timeout expires, and EINTR or ERESTART if * a signal was caught. */ int cv_timedwait_sig(struct cv *cvp, struct mtx *mp, int timo) { - struct proc *p; + struct thread *td; int rval; int sig; WITNESS_SAVE_DECL(mp); - p = CURPROC; + td = curthread; rval = 0; #ifdef KTRACE - if (p && KTRPOINT(p, KTR_CSW)) - ktrcsw(p->p_tracep, 1, 0); + if (td->td_proc && KTRPOINT(td->td_proc, KTR_CSW)) + ktrcsw(td->td_proc->p_tracep, 1, 0); #endif - CV_ASSERT(cvp, mp, p); + CV_ASSERT(cvp, mp, td); WITNESS_SLEEP(0, &mp->mtx_object); WITNESS_SAVE(&mp->mtx_object, mp); @@ -398,7 +401,7 @@ cv_timedwait_sig(struct cv *cvp, struct mtx *mp, int timo) /* * After a panic, or during autoconfiguration, just give * interrupts a chance, then just return; don't run any other - * procs or panic below, in case this is the idle process and + * thread or panic below, in case this is the idle process and * already asleep. */ mtx_unlock_spin(&sched_lock); @@ -409,43 +412,43 @@ cv_timedwait_sig(struct cv *cvp, struct mtx *mp, int timo) DROP_GIANT_NOSWITCH(); mtx_unlock_flags(mp, MTX_NOSWITCH); - cv_waitq_add(cvp, p); - callout_reset(&p->p_slpcallout, timo, cv_timedwait_end, p); - sig = cv_switch_catch(p); + cv_waitq_add(cvp, td); + callout_reset(&td->td_slpcallout, timo, cv_timedwait_end, td); + sig = cv_switch_catch(td); - if (p->p_sflag & PS_TIMEOUT) { - p->p_sflag &= ~PS_TIMEOUT; + if (td->td_flags & TDF_TIMEOUT) { + td->td_flags &= ~TDF_TIMEOUT; rval = EWOULDBLOCK; - } else if (p->p_sflag & PS_TIMOFAIL) - p->p_sflag &= ~PS_TIMOFAIL; - else if (callout_stop(&p->p_slpcallout) == 0) { + } else if (td->td_flags & TDF_TIMOFAIL) + td->td_flags &= ~TDF_TIMOFAIL; + else if (callout_stop(&td->td_slpcallout) == 0) { /* * Work around race with cv_timedwait_end similar to that * between msleep and endtsleep. */ - p->p_sflag |= PS_TIMEOUT; - p->p_stats->p_ru.ru_nivcsw++; + td->td_flags |= TDF_TIMEOUT; + td->td_proc->p_stats->p_ru.ru_nivcsw++; mi_switch(); } mtx_unlock_spin(&sched_lock); PICKUP_GIANT(); - PROC_LOCK(p); + PROC_LOCK(td->td_proc); if (sig == 0) - sig = CURSIG(p); + sig = CURSIG(td->td_proc); if (sig != 0) { - if (SIGISMEMBER(p->p_sigacts->ps_sigintr, sig)) + if (SIGISMEMBER(td->td_proc->p_sigacts->ps_sigintr, sig)) rval = EINTR; else rval = ERESTART; } - PROC_UNLOCK(p); + PROC_UNLOCK(td->td_proc); #ifdef KTRACE mtx_lock(&Giant); - if (KTRPOINT(p, KTR_CSW)) - ktrcsw(p->p_tracep, 0, 0); + if (KTRPOINT(td->td_proc, KTR_CSW)) + ktrcsw(td->td_proc->p_tracep, 0, 0); mtx_unlock(&Giant); #endif mtx_lock(mp); @@ -461,38 +464,39 @@ cv_timedwait_sig(struct cv *cvp, struct mtx *mp, int timo) static __inline void cv_wakeup(struct cv *cvp) { - struct proc *p; + struct thread *td; mtx_assert(&sched_lock, MA_OWNED); - p = TAILQ_FIRST(&cvp->cv_waitq); - KASSERT(p->p_wchan == cvp, ("%s: bogus wchan", __FUNCTION__)); - KASSERT(p->p_sflag & PS_CVWAITQ, ("%s: not on waitq", __FUNCTION__)); - TAILQ_REMOVE(&cvp->cv_waitq, p, p_slpq); - p->p_sflag &= ~PS_CVWAITQ; - p->p_wchan = 0; - if (p->p_stat == SSLEEP) { - /* OPTIMIZED EXPANSION OF setrunnable(p); */ - CTR3(KTR_PROC, "cv_signal: proc %p (pid %d, %s)", - p, p->p_pid, p->p_comm); - if (p->p_slptime > 1) - updatepri(p); - p->p_slptime = 0; - p->p_stat = SRUN; - if (p->p_sflag & PS_INMEM) { - setrunqueue(p); - maybe_resched(p); + td = TAILQ_FIRST(&cvp->cv_waitq); + KASSERT(td->td_wchan == cvp, ("%s: bogus wchan", __FUNCTION__)); + KASSERT(td->td_flags & TDF_CVWAITQ, ("%s: not on waitq", __FUNCTION__)); + TAILQ_REMOVE(&cvp->cv_waitq, td, td_slpq); + td->td_flags &= ~TDF_CVWAITQ; + td->td_wchan = 0; + if (td->td_proc->p_stat == SSLEEP) { + /* OPTIMIZED EXPANSION OF setrunnable(td); */ + CTR3(KTR_PROC, "cv_signal: thread %p (pid %d, %s)", + td, td->td_proc->p_pid, td->td_proc->p_comm); + if (td->td_ksegrp->kg_slptime > 1) /* XXXKSE */ + updatepri(td); + td->td_kse->ke_slptime = 0; + td->td_ksegrp->kg_slptime = 0; + td->td_proc->p_stat = SRUN; + if (td->td_proc->p_sflag & PS_INMEM) { + setrunqueue(td); + maybe_resched(td->td_ksegrp); } else { - p->p_sflag |= PS_SWAPINREQ; - wakeup(&proc0); + td->td_proc->p_sflag |= PS_SWAPINREQ; + wakeup(&proc0); /* XXXKSE */ } /* END INLINE EXPANSION */ } } /* - * Signal a condition variable, wakes up one waiting process. Will also wakeup + * Signal a condition variable, wakes up one waiting thread. Will also wakeup * the swapper if the process is not in memory, so that it can bring the - * sleeping process in. Note that this may also result in additional processes + * sleeping process in. Note that this may also result in additional threads * being made runnable. Should be called with the same mutex as was passed to * cv_wait held. */ @@ -510,7 +514,7 @@ cv_signal(struct cv *cvp) } /* - * Broadcast a signal to a condition variable. Wakes up all waiting processes. + * Broadcast a signal to a condition variable. Wakes up all waiting threads. * Should be called with the same mutex as was passed to cv_wait held. */ void @@ -526,46 +530,46 @@ cv_broadcast(struct cv *cvp) } /* - * Remove a process from the wait queue of its condition variable. This may be + * Remove a thread from the wait queue of its condition variable. This may be * called externally. */ void -cv_waitq_remove(struct proc *p) +cv_waitq_remove(struct thread *td) { struct cv *cvp; mtx_lock_spin(&sched_lock); - if ((cvp = p->p_wchan) != NULL && p->p_sflag & PS_CVWAITQ) { - TAILQ_REMOVE(&cvp->cv_waitq, p, p_slpq); - p->p_sflag &= ~PS_CVWAITQ; - p->p_wchan = NULL; + if ((cvp = td->td_wchan) != NULL && td->td_flags & TDF_CVWAITQ) { + TAILQ_REMOVE(&cvp->cv_waitq, td, td_slpq); + td->td_flags &= ~TDF_CVWAITQ; + td->td_wchan = NULL; } mtx_unlock_spin(&sched_lock); } /* - * Timeout function for cv_timedwait. Put the process on the runqueue and set + * Timeout function for cv_timedwait. Put the thread on the runqueue and set * its timeout flag. */ static void cv_timedwait_end(void *arg) { - struct proc *p; + struct thread *td; - p = arg; - CTR3(KTR_PROC, "cv_timedwait_end: proc %p (pid %d, %s)", p, p->p_pid, - p->p_comm); + td = arg; + CTR3(KTR_PROC, "cv_timedwait_end: thread %p (pid %d, %s)", td, td->td_proc->p_pid, + td->td_proc->p_comm); mtx_lock_spin(&sched_lock); - if (p->p_sflag & PS_TIMEOUT) { - p->p_sflag &= ~PS_TIMEOUT; - setrunqueue(p); - } else if (p->p_wchan != NULL) { - if (p->p_stat == SSLEEP) - setrunnable(p); + if (td->td_flags & TDF_TIMEOUT) { + td->td_flags &= ~TDF_TIMEOUT; + setrunqueue(td); + } else if (td->td_wchan != NULL) { + if (td->td_proc->p_stat == SSLEEP) /* XXXKSE */ + setrunnable(td); else - cv_waitq_remove(p); - p->p_sflag |= PS_TIMEOUT; + cv_waitq_remove(td); + td->td_flags |= TDF_TIMEOUT; } else - p->p_sflag |= PS_TIMOFAIL; + td->td_flags |= TDF_TIMOFAIL; mtx_unlock_spin(&sched_lock); } diff --git a/sys/kern/kern_conf.c b/sys/kern/kern_conf.c index 35cffc2..2f3bf92 100644 --- a/sys/kern/kern_conf.c +++ b/sys/kern/kern_conf.c @@ -35,8 +35,8 @@ #include <sys/param.h> #include <sys/kernel.h> -#include <sys/sysctl.h> #include <sys/systm.h> +#include <sys/sysctl.h> #include <sys/module.h> #include <sys/malloc.h> #include <sys/conf.h> diff --git a/sys/kern/kern_descrip.c b/sys/kern/kern_descrip.c index a09c8c2..da3bf4c 100644 --- a/sys/kern/kern_descrip.c +++ b/sys/kern/kern_descrip.c @@ -90,16 +90,16 @@ static struct cdevsw fildesc_cdevsw = { /* flags */ 0, }; -static int do_dup __P((struct filedesc *fdp, int old, int new, register_t *retval, struct proc *p)); +static int do_dup __P((struct filedesc *fdp, int old, int new, register_t *retval, struct thread *td)); static int badfo_readwrite __P((struct file *fp, struct uio *uio, - struct ucred *cred, int flags, struct proc *p)); + struct ucred *cred, int flags, struct thread *td)); static int badfo_ioctl __P((struct file *fp, u_long com, caddr_t data, - struct proc *p)); + struct thread *td)); static int badfo_poll __P((struct file *fp, int events, - struct ucred *cred, struct proc *p)); + struct ucred *cred, struct thread *td)); static int badfo_kqfilter __P((struct file *fp, struct knote *kn)); -static int badfo_stat __P((struct file *fp, struct stat *sb, struct proc *p)); -static int badfo_close __P((struct file *fp, struct proc *p)); +static int badfo_stat __P((struct file *fp, struct stat *sb, struct thread *td)); +static int badfo_close __P((struct file *fp, struct thread *td)); /* * Descriptor management. @@ -121,13 +121,14 @@ struct getdtablesize_args { */ /* ARGSUSED */ int -getdtablesize(p, uap) - struct proc *p; +getdtablesize(td, uap) + struct thread *td; struct getdtablesize_args *uap; { + struct proc *p = td->td_proc; mtx_lock(&Giant); - p->p_retval[0] = + td->td_retval[0] = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfilesperproc); mtx_unlock(&Giant); return (0); @@ -150,11 +151,12 @@ struct dup2_args { */ /* ARGSUSED */ int -dup2(p, uap) - struct proc *p; +dup2(td, uap) + struct thread *td; struct dup2_args *uap; { - register struct filedesc *fdp = p->p_fd; + struct proc *p = td->td_proc; + register struct filedesc *fdp = td->td_proc->p_fd; register u_int old = uap->from, new = uap->to; int i, error; @@ -168,12 +170,12 @@ retry: goto done2; } if (old == new) { - p->p_retval[0] = new; + td->td_retval[0] = new; error = 0; goto done2; } if (new >= fdp->fd_nfiles) { - if ((error = fdalloc(p, new, &i))) + if ((error = fdalloc(td, new, &i))) goto done2; if (new != i) panic("dup2: fdalloc"); @@ -182,7 +184,7 @@ retry: */ goto retry; } - error = do_dup(fdp, (int)old, (int)new, p->p_retval, p); + error = do_dup(fdp, (int)old, (int)new, td->td_retval, td); done2: mtx_unlock(&Giant); return(error); @@ -201,8 +203,8 @@ struct dup_args { */ /* ARGSUSED */ int -dup(p, uap) - struct proc *p; +dup(td, uap) + struct thread *td; struct dup_args *uap; { register struct filedesc *fdp; @@ -211,14 +213,14 @@ dup(p, uap) mtx_lock(&Giant); old = uap->fd; - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if (old >= fdp->fd_nfiles || fdp->fd_ofiles[old] == NULL) { error = EBADF; goto done2; } - if ((error = fdalloc(p, 0, &new))) + if ((error = fdalloc(td, 0, &new))) goto done2; - error = do_dup(fdp, (int)old, new, p->p_retval, p); + error = do_dup(fdp, (int)old, new, td->td_retval, td); done2: mtx_unlock(&Giant); return (error); @@ -239,10 +241,11 @@ struct fcntl_args { */ /* ARGSUSED */ int -fcntl(p, uap) - struct proc *p; +fcntl(td, uap) + struct thread *td; register struct fcntl_args *uap; { + register struct proc *p = td->td_proc; register struct filedesc *fdp; register struct file *fp; register char *pop; @@ -269,13 +272,13 @@ fcntl(p, uap) error = EINVAL; break; } - if ((error = fdalloc(p, newmin, &i))) + if ((error = fdalloc(td, newmin, &i))) break; - error = do_dup(fdp, uap->fd, i, p->p_retval, p); + error = do_dup(fdp, uap->fd, i, td->td_retval, td); break; case F_GETFD: - p->p_retval[0] = *pop & 1; + td->td_retval[0] = *pop & 1; break; case F_SETFD: @@ -283,7 +286,7 @@ fcntl(p, uap) break; case F_GETFL: - p->p_retval[0] = OFLAGS(fp->f_flag); + td->td_retval[0] = OFLAGS(fp->f_flag); break; case F_SETFL: @@ -291,33 +294,33 @@ fcntl(p, uap) fp->f_flag &= ~FCNTLFLAGS; fp->f_flag |= FFLAGS(uap->arg & ~O_ACCMODE) & FCNTLFLAGS; tmp = fp->f_flag & FNONBLOCK; - error = fo_ioctl(fp, FIONBIO, (caddr_t)&tmp, p); + error = fo_ioctl(fp, FIONBIO, (caddr_t)&tmp, td); if (error) { - fdrop(fp, p); + fdrop(fp, td); break; } tmp = fp->f_flag & FASYNC; - error = fo_ioctl(fp, FIOASYNC, (caddr_t)&tmp, p); + error = fo_ioctl(fp, FIOASYNC, (caddr_t)&tmp, td); if (!error) { - fdrop(fp, p); + fdrop(fp, td); break; } fp->f_flag &= ~FNONBLOCK; tmp = 0; - (void)fo_ioctl(fp, FIONBIO, (caddr_t)&tmp, p); - fdrop(fp, p); + (void)fo_ioctl(fp, FIONBIO, (caddr_t)&tmp, td); + fdrop(fp, td); break; case F_GETOWN: fhold(fp); - error = fo_ioctl(fp, FIOGETOWN, (caddr_t)p->p_retval, p); - fdrop(fp, p); + error = fo_ioctl(fp, FIOGETOWN, (caddr_t)td->td_retval, td); + fdrop(fp, td); break; case F_SETOWN: fhold(fp); - error = fo_ioctl(fp, FIOSETOWN, (caddr_t)&uap->arg, p); - fdrop(fp, p); + error = fo_ioctl(fp, FIOSETOWN, (caddr_t)&uap->arg, td); + fdrop(fp, td); break; case F_SETLKW: @@ -339,14 +342,14 @@ fcntl(p, uap) error = copyin((caddr_t)(intptr_t)uap->arg, (caddr_t)&fl, sizeof(fl)); if (error) { - fdrop(fp, p); + fdrop(fp, td); break; } if (fl.l_whence == SEEK_CUR) { if (fp->f_offset < 0 || (fl.l_start > 0 && fp->f_offset > OFF_MAX - fl.l_start)) { - fdrop(fp, p); + fdrop(fp, td); error = EOVERFLOW; break; } @@ -380,8 +383,9 @@ fcntl(p, uap) error = EINVAL; break; } - fdrop(fp, p); + fdrop(fp, td); break; + case F_GETLK: if (fp->f_type != DTYPE_VNODE) { error = EBADF; @@ -396,12 +400,12 @@ fcntl(p, uap) error = copyin((caddr_t)(intptr_t)uap->arg, (caddr_t)&fl, sizeof(fl)); if (error) { - fdrop(fp, p); + fdrop(fp, td); break; } if (fl.l_type != F_RDLCK && fl.l_type != F_WRLCK && fl.l_type != F_UNLCK) { - fdrop(fp, p); + fdrop(fp, td); error = EINVAL; break; } @@ -410,7 +414,7 @@ fcntl(p, uap) fp->f_offset > OFF_MAX - fl.l_start) || (fl.l_start < 0 && fp->f_offset < OFF_MIN - fl.l_start)) { - fdrop(fp, p); + fdrop(fp, td); error = EOVERFLOW; break; } @@ -418,7 +422,7 @@ fcntl(p, uap) } error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_GETLK, &fl, F_POSIX); - fdrop(fp, p); + fdrop(fp, td); if (error == 0) { error = copyout((caddr_t)&fl, (caddr_t)(intptr_t)uap->arg, sizeof(fl)); @@ -437,11 +441,11 @@ done2: * Common code for dup, dup2, and fcntl(F_DUPFD). */ static int -do_dup(fdp, old, new, retval, p) +do_dup(fdp, old, new, retval, td) register struct filedesc *fdp; register int old, new; register_t *retval; - struct proc *p; + struct thread *td; { struct file *fp; struct file *delfp; @@ -454,7 +458,7 @@ do_dup(fdp, old, new, retval, p) delfp = fdp->fd_ofiles[new]; #if 0 if (delfp && (fdp->fd_ofileflags[new] & UF_MAPPED)) - (void) munmapfd(p, new); + (void) munmapfd(td, new); #endif /* @@ -474,7 +478,7 @@ do_dup(fdp, old, new, retval, p) * close() were performed on it). */ if (delfp) - (void) closef(delfp, p); + (void) closef(delfp, td); return (0); } @@ -549,7 +553,7 @@ fsetown(pgid, sigiop) * restrict FSETOWN to the current process or process * group for maximum safety. */ - if (proc->p_session != curproc->p_session) { + if (proc->p_session != curthread->td_proc->p_session) { PROC_UNLOCK(proc); return (EPERM); } @@ -569,7 +573,7 @@ fsetown(pgid, sigiop) * restrict FSETOWN to the current process or process * group for maximum safety. */ - if (pgrp->pg_session != curproc->p_session) + if (pgrp->pg_session != curthread->td_proc->p_session) return (EPERM); proc = NULL; @@ -584,8 +588,8 @@ fsetown(pgid, sigiop) sigio->sio_pgrp = pgrp; } sigio->sio_pgid = pgid; - crhold(curproc->p_ucred); - sigio->sio_ucred = curproc->p_ucred; + crhold(curthread->td_proc->p_ucred); + sigio->sio_ucred = curthread->td_proc->p_ucred; sigio->sio_myref = sigiop; s = splhigh(); *sigiop = sigio; @@ -616,8 +620,8 @@ struct close_args { */ /* ARGSUSED */ int -close(p, uap) - struct proc *p; +close(td, uap) + struct thread *td; struct close_args *uap; { register struct filedesc *fdp; @@ -626,7 +630,7 @@ close(p, uap) int error = 0; mtx_lock(&Giant); - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if ((unsigned)fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL) { error = EBADF; @@ -634,7 +638,7 @@ close(p, uap) } #if 0 if (fdp->fd_ofileflags[fd] & UF_MAPPED) - (void) munmapfd(p, fd); + (void) munmapfd(td, fd); #endif fdp->fd_ofiles[fd] = NULL; fdp->fd_ofileflags[fd] = 0; @@ -648,8 +652,8 @@ close(p, uap) if (fd < fdp->fd_freefile) fdp->fd_freefile = fd; if (fd < fdp->fd_knlistsize) - knote_fdclose(p, fd); - error = closef(fp, p); + knote_fdclose(td, fd); + error = closef(fp, td); done2: mtx_unlock(&Giant); return(error); @@ -670,11 +674,11 @@ struct ofstat_args { */ /* ARGSUSED */ int -ofstat(p, uap) - struct proc *p; +ofstat(td, uap) + struct thread *td; register struct ofstat_args *uap; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; register struct file *fp; struct stat ub; struct ostat oub; @@ -688,12 +692,12 @@ ofstat(p, uap) goto done2; } fhold(fp); - error = fo_stat(fp, &ub, p); + error = fo_stat(fp, &ub, td); if (error == 0) { cvtstat(&ub, &oub); error = copyout((caddr_t)&oub, (caddr_t)uap->sb, sizeof (oub)); } - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return (error); @@ -714,8 +718,8 @@ struct fstat_args { */ /* ARGSUSED */ int -fstat(p, uap) - struct proc *p; +fstat(td, uap) + struct thread *td; register struct fstat_args *uap; { register struct filedesc *fdp; @@ -724,7 +728,7 @@ fstat(p, uap) int error; mtx_lock(&Giant); - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if ((unsigned)uap->fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[uap->fd]) == NULL) { @@ -732,10 +736,10 @@ fstat(p, uap) goto done2; } fhold(fp); - error = fo_stat(fp, &ub, p); + error = fo_stat(fp, &ub, td); if (error == 0) error = copyout((caddr_t)&ub, (caddr_t)uap->sb, sizeof (ub)); - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return (error); @@ -755,8 +759,8 @@ struct nfstat_args { */ /* ARGSUSED */ int -nfstat(p, uap) - struct proc *p; +nfstat(td, uap) + struct thread *td; register struct nfstat_args *uap; { register struct filedesc *fdp; @@ -767,19 +771,19 @@ nfstat(p, uap) mtx_lock(&Giant); - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if ((unsigned)uap->fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[uap->fd]) == NULL) { error = EBADF; goto done2; } fhold(fp); - error = fo_stat(fp, &ub, p); + error = fo_stat(fp, &ub, td); if (error == 0) { cvtnstat(&ub, &nub); error = copyout((caddr_t)&nub, (caddr_t)uap->sb, sizeof (nub)); } - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return (error); @@ -799,8 +803,8 @@ struct fpathconf_args { */ /* ARGSUSED */ int -fpathconf(p, uap) - struct proc *p; +fpathconf(td, uap) + struct thread *td; register struct fpathconf_args *uap; { struct filedesc *fdp; @@ -809,7 +813,7 @@ fpathconf(p, uap) int error = 0; mtx_lock(&Giant); - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if ((unsigned)uap->fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[uap->fd]) == NULL) { @@ -826,19 +830,19 @@ fpathconf(p, uap) error = EINVAL; goto done2; } - p->p_retval[0] = PIPE_BUF; + td->td_retval[0] = PIPE_BUF; error = 0; break; case DTYPE_FIFO: case DTYPE_VNODE: vp = (struct vnode *)fp->f_data; - error = VOP_PATHCONF(vp, uap->name, p->p_retval); + error = VOP_PATHCONF(vp, uap->name, td->td_retval); break; default: error = EOPNOTSUPP; break; } - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return(error); @@ -851,12 +855,13 @@ static int fdexpand; SYSCTL_INT(_debug, OID_AUTO, fdexpand, CTLFLAG_RD, &fdexpand, 0, ""); int -fdalloc(p, want, result) - struct proc *p; +fdalloc(td, want, result) + struct thread *td; int want; int *result; { - register struct filedesc *fdp = p->p_fd; + struct proc *p = td->td_proc; + register struct filedesc *fdp = td->td_proc->p_fd; register int i; int lim, last, nfiles; struct file **newofile; @@ -930,11 +935,12 @@ fdalloc(p, want, result) * are available to the process p. */ int -fdavail(p, n) - struct proc *p; +fdavail(td, n) + struct thread *td; register int n; { - register struct filedesc *fdp = p->p_fd; + struct proc *p = td->td_proc; + register struct filedesc *fdp = td->td_proc->p_fd; register struct file **fpp; register int i, lim, last; @@ -956,11 +962,12 @@ fdavail(p, n) * a file decriptor for the process that refers to it. */ int -falloc(p, resultfp, resultfd) - register struct proc *p; +falloc(td, resultfp, resultfd) + register struct thread *td; struct file **resultfp; int *resultfd; { + struct proc *p = td->td_proc; register struct file *fp, *fq; int error, i; @@ -982,7 +989,7 @@ falloc(p, resultfp, resultfd) * allocating the slot, else a race might have shrunk it if we had * allocated it before the malloc. */ - if ((error = fdalloc(p, 0, &i))) { + if ((error = fdalloc(td, 0, &i))) { nfiles--; FREE(fp, M_FILE); return (error); @@ -1023,11 +1030,11 @@ ffree(fp) * Build a new filedesc structure. */ struct filedesc * -fdinit(p) - struct proc *p; +fdinit(td) + struct thread *td; { register struct filedesc0 *newfdp; - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; MALLOC(newfdp, struct filedesc0 *, sizeof(struct filedesc0), M_FILEDESC, M_WAITOK | M_ZERO); @@ -1067,10 +1074,10 @@ fdshare(p) * Copy a filedesc structure. */ struct filedesc * -fdcopy(p) - struct proc *p; +fdcopy(td) + struct thread *td; { - register struct filedesc *newfdp, *fdp = p->p_fd; + register struct filedesc *newfdp, *fdp = td->td_proc->p_fd; register struct file **fpp; register int i; @@ -1144,10 +1151,10 @@ fdcopy(p) * Release a filedesc structure. */ void -fdfree(p) - struct proc *p; +fdfree(td) + struct thread *td; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; struct file **fpp; register int i; @@ -1164,7 +1171,7 @@ fdfree(p) fpp = fdp->fd_ofiles; for (i = fdp->fd_lastfile; i-- >= 0; fpp++) { if (*fpp) - (void) closef(*fpp, p); + (void) closef(*fpp, td); } if (fdp->fd_nfiles > NDFILE) FREE(fdp->fd_ofiles, M_FILEDESC); @@ -1206,10 +1213,10 @@ is_unsafe(struct file *fp) * Make this setguid thing safe, if at all possible. */ void -setugidsafety(p) - struct proc *p; +setugidsafety(td) + struct thread *td; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; register int i; /* Certain daemons might not have file descriptors. */ @@ -1228,10 +1235,10 @@ setugidsafety(p) #if 0 if ((fdp->fd_ofileflags[i] & UF_MAPPED) != 0) - (void) munmapfd(p, i); + (void) munmapfd(td, i); #endif if (i < fdp->fd_knlistsize) - knote_fdclose(p, i); + knote_fdclose(td, i); /* * NULL-out descriptor prior to close to avoid * a race while close blocks. @@ -1241,7 +1248,7 @@ setugidsafety(p) fdp->fd_ofileflags[i] = 0; if (i < fdp->fd_freefile) fdp->fd_freefile = i; - (void) closef(fp, p); + (void) closef(fp, td); } } while (fdp->fd_lastfile > 0 && fdp->fd_ofiles[fdp->fd_lastfile] == NULL) @@ -1252,10 +1259,10 @@ setugidsafety(p) * Close any files on exec? */ void -fdcloseexec(p) - struct proc *p; +fdcloseexec(td) + struct thread *td; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; register int i; /* Certain daemons might not have file descriptors. */ @@ -1273,10 +1280,10 @@ fdcloseexec(p) #if 0 if (fdp->fd_ofileflags[i] & UF_MAPPED) - (void) munmapfd(p, i); + (void) munmapfd(td, i); #endif if (i < fdp->fd_knlistsize) - knote_fdclose(p, i); + knote_fdclose(td, i); /* * NULL-out descriptor prior to close to avoid * a race while close blocks. @@ -1286,7 +1293,7 @@ fdcloseexec(p) fdp->fd_ofileflags[i] = 0; if (i < fdp->fd_freefile) fdp->fd_freefile = i; - (void) closef(fp, p); + (void) closef(fp, td); } } while (fdp->fd_lastfile > 0 && fdp->fd_ofiles[fdp->fd_lastfile] == NULL) @@ -1300,10 +1307,11 @@ fdcloseexec(p) * that was being passed in a message. */ int -closef(fp, p) +closef(fp, td) register struct file *fp; - register struct proc *p; + register struct thread *td; { + struct proc *p = td->td_proc; struct vnode *vp; struct flock lf; @@ -1325,13 +1333,13 @@ closef(fp, p) vp = (struct vnode *)fp->f_data; (void) VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_UNLCK, &lf, F_POSIX); } - return (fdrop(fp, p)); + return (fdrop(fp, td)); } int -fdrop(fp, p) +fdrop(fp, td) struct file *fp; - struct proc *p; + struct thread *td; { struct flock lf; struct vnode *vp; @@ -1350,7 +1358,7 @@ fdrop(fp, p) (void) VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK); } if (fp->f_ops != &badfileops) - error = fo_close(fp, p); + error = fo_close(fp, td); else error = 0; ffree(fp); @@ -1374,11 +1382,11 @@ struct flock_args { */ /* ARGSUSED */ int -flock(p, uap) - struct proc *p; +flock(td, uap) + struct thread *td; register struct flock_args *uap; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; register struct file *fp; struct vnode *vp; struct flock lf; @@ -1433,21 +1441,21 @@ done2: */ /* ARGSUSED */ static int -fdopen(dev, mode, type, p) +fdopen(dev, mode, type, td) dev_t dev; int mode, type; - struct proc *p; + struct thread *td; { /* - * XXX Kludge: set curproc->p_dupfd to contain the value of the + * XXX Kludge: set curthread->td_dupfd to contain the value of the * the file descriptor being sought for duplication. The error * return ensures that the vnode for this device will be released * by vn_open. Open will detect this special error and take the * actions in dupfdopen below. Other callers of vn_open or VOP_OPEN * will simply report the error. */ - p->p_dupfd = dev2unit(dev); + td->td_dupfd = dev2unit(dev); return (ENODEV); } @@ -1455,8 +1463,8 @@ fdopen(dev, mode, type, p) * Duplicate the specified descriptor to a free descriptor. */ int -dupfdopen(p, fdp, indx, dfd, mode, error) - struct proc *p; +dupfdopen(td, fdp, indx, dfd, mode, error) + struct thread *td; struct filedesc *fdp; int indx, dfd; int mode; @@ -1498,7 +1506,7 @@ dupfdopen(p, fdp, indx, dfd, mode, error) fp = fdp->fd_ofiles[indx]; #if 0 if (fp && fdp->fd_ofileflags[indx] & UF_MAPPED) - (void) munmapfd(p, indx); + (void) munmapfd(td, indx); #endif fdp->fd_ofiles[indx] = wfp; fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd]; @@ -1510,7 +1518,7 @@ dupfdopen(p, fdp, indx, dfd, mode, error) * used to own. Release it. */ if (fp) - fdrop(fp, p); + fdrop(fp, td); return (0); case ENXIO: @@ -1520,7 +1528,7 @@ dupfdopen(p, fdp, indx, dfd, mode, error) fp = fdp->fd_ofiles[indx]; #if 0 if (fp && fdp->fd_ofileflags[indx] & UF_MAPPED) - (void) munmapfd(p, indx); + (void) munmapfd(td, indx); #endif fdp->fd_ofiles[indx] = fdp->fd_ofiles[dfd]; fdp->fd_ofiles[dfd] = NULL; @@ -1532,7 +1540,7 @@ dupfdopen(p, fdp, indx, dfd, mode, error) * used to own. Release it. */ if (fp) - fdrop(fp, p); + fdrop(fp, td); /* * Complete the clean up of the filedesc structure by * recomputing the various hints. @@ -1630,11 +1638,11 @@ struct fileops badfileops = { }; static int -badfo_readwrite(fp, uio, cred, flags, p) +badfo_readwrite(fp, uio, cred, flags, td) struct file *fp; struct uio *uio; struct ucred *cred; - struct proc *p; + struct thread *td; int flags; { @@ -1642,22 +1650,22 @@ badfo_readwrite(fp, uio, cred, flags, p) } static int -badfo_ioctl(fp, com, data, p) +badfo_ioctl(fp, com, data, td) struct file *fp; u_long com; caddr_t data; - struct proc *p; + struct thread *td; { return (EBADF); } static int -badfo_poll(fp, events, cred, p) +badfo_poll(fp, events, cred, td) struct file *fp; int events; struct ucred *cred; - struct proc *p; + struct thread *td; { return (0); @@ -1673,19 +1681,19 @@ badfo_kqfilter(fp, kn) } static int -badfo_stat(fp, sb, p) +badfo_stat(fp, sb, td) struct file *fp; struct stat *sb; - struct proc *p; + struct thread *td; { return (EBADF); } static int -badfo_close(fp, p) +badfo_close(fp, td) struct file *fp; - struct proc *p; + struct thread *td; { return (EBADF); diff --git a/sys/kern/kern_event.c b/sys/kern/kern_event.c index 6f871b6..35391b0 100644 --- a/sys/kern/kern_event.c +++ b/sys/kern/kern_event.c @@ -52,18 +52,18 @@ static int kqueue_scan(struct file *fp, int maxevents, struct kevent *ulistp, const struct timespec *timeout, - struct proc *p); + struct thread *td); static int kqueue_read(struct file *fp, struct uio *uio, - struct ucred *cred, int flags, struct proc *p); + struct ucred *cred, int flags, struct thread *td); static int kqueue_write(struct file *fp, struct uio *uio, - struct ucred *cred, int flags, struct proc *p); + struct ucred *cred, int flags, struct thread *td); static int kqueue_ioctl(struct file *fp, u_long com, caddr_t data, - struct proc *p); + struct thread *td); static int kqueue_poll(struct file *fp, int events, struct ucred *cred, - struct proc *p); + struct thread *td); static int kqueue_kqfilter(struct file *fp, struct knote *kn); -static int kqueue_stat(struct file *fp, struct stat *st, struct proc *p); -static int kqueue_close(struct file *fp, struct proc *p); +static int kqueue_stat(struct file *fp, struct stat *st, struct thread *td); +static int kqueue_close(struct file *fp, struct thread *td); static void kqueue_wakeup(struct kqueue *kq); static struct fileops kqueueops = { @@ -77,7 +77,7 @@ static struct fileops kqueueops = { }; static void knote_attach(struct knote *kn, struct filedesc *fdp); -static void knote_drop(struct knote *kn, struct proc *p); +static void knote_drop(struct knote *kn, struct thread *td); static void knote_enqueue(struct knote *kn); static void knote_dequeue(struct knote *kn); static void knote_init(void); @@ -335,7 +335,7 @@ filt_timer(struct knote *kn, long hint) * MPSAFE */ int -kqueue(struct proc *p, struct kqueue_args *uap) +kqueue(struct thread *td, struct kqueue_args *uap) { struct filedesc *fdp; struct kqueue *kq; @@ -343,8 +343,8 @@ kqueue(struct proc *p, struct kqueue_args *uap) int fd, error; mtx_lock(&Giant); - fdp = p->p_fd; - error = falloc(p, &fp, &fd); + fdp = td->td_proc->p_fd; + error = falloc(td, &fp, &fd); if (error) goto done2; fp->f_flag = FREAD | FWRITE; @@ -353,7 +353,7 @@ kqueue(struct proc *p, struct kqueue_args *uap) kq = malloc(sizeof(struct kqueue), M_TEMP, M_WAITOK | M_ZERO); TAILQ_INIT(&kq->kq_head); fp->f_data = (caddr_t)kq; - p->p_retval[0] = fd; + td->td_retval[0] = fd; if (fdp->fd_knlistsize < 0) fdp->fd_knlistsize = 0; /* this process has a kq */ kq->kq_fdp = fdp; @@ -376,7 +376,7 @@ struct kevent_args { * MPSAFE */ int -kevent(struct proc *p, struct kevent_args *uap) +kevent(struct thread *td, struct kevent_args *uap) { struct filedesc *fdp; struct kevent *kevp; @@ -386,7 +386,7 @@ kevent(struct proc *p, struct kevent_args *uap) int i, n, nerrors, error; mtx_lock(&Giant); - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if (((u_int)uap->fd) >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[uap->fd]) == NULL || (fp->f_type != DTYPE_KQUEUE)) { @@ -414,7 +414,7 @@ kevent(struct proc *p, struct kevent_args *uap) for (i = 0; i < n; i++) { kevp = &kq->kq_kev[i]; kevp->flags &= ~EV_SYSFLAGS; - error = kqueue_register(kq, kevp, p); + error = kqueue_register(kq, kevp, td); if (error) { if (uap->nevents != 0) { kevp->flags = EV_ERROR; @@ -434,21 +434,21 @@ kevent(struct proc *p, struct kevent_args *uap) uap->changelist += n; } if (nerrors) { - p->p_retval[0] = nerrors; + td->td_retval[0] = nerrors; error = 0; goto done; } - error = kqueue_scan(fp, uap->nevents, uap->eventlist, uap->timeout, p); + error = kqueue_scan(fp, uap->nevents, uap->eventlist, uap->timeout, td); done: if (fp != NULL) - fdrop(fp, p); + fdrop(fp, td); mtx_unlock(&Giant); return (error); } int -kqueue_register(struct kqueue *kq, struct kevent *kev, struct proc *p) +kqueue_register(struct kqueue *kq, struct kevent *kev, struct thread *td) { struct filedesc *fdp = kq->kq_fdp; struct filterops *fops; @@ -531,7 +531,7 @@ kqueue_register(struct kqueue *kq, struct kevent *kev, struct proc *p) knote_attach(kn, fdp); if ((error = fops->f_attach(kn)) != 0) { - knote_drop(kn, p); + knote_drop(kn, td); goto done; } } else { @@ -552,7 +552,7 @@ kqueue_register(struct kqueue *kq, struct kevent *kev, struct proc *p) } else if (kev->flags & EV_DELETE) { kn->kn_fop->f_detach(kn); - knote_drop(kn, p); + knote_drop(kn, td); goto done; } @@ -574,13 +574,13 @@ kqueue_register(struct kqueue *kq, struct kevent *kev, struct proc *p) done: if (fp != NULL) - fdrop(fp, p); + fdrop(fp, td); return (error); } static int kqueue_scan(struct file *fp, int maxevents, struct kevent *ulistp, - const struct timespec *tsp, struct proc *p) + const struct timespec *tsp, struct thread *td) { struct kqueue *kq = (struct kqueue *)fp->f_data; struct kevent *kevp; @@ -673,7 +673,7 @@ start: kq->kq_count--; splx(s); kn->kn_fop->f_detach(kn); - knote_drop(kn, p); + knote_drop(kn, td); s = splhigh(); } else if (kn->kn_flags & EV_CLEAR) { kn->kn_data = 0; @@ -702,7 +702,7 @@ done: if (nkev != 0) error = copyout((caddr_t)&kq->kq_kev, (caddr_t)ulistp, sizeof(struct kevent) * nkev); - p->p_retval[0] = maxevents - count; + td->td_retval[0] = maxevents - count; return (error); } @@ -713,7 +713,7 @@ done: /*ARGSUSED*/ static int kqueue_read(struct file *fp, struct uio *uio, struct ucred *cred, - int flags, struct proc *p) + int flags, struct thread *td) { return (ENXIO); } @@ -721,21 +721,21 @@ kqueue_read(struct file *fp, struct uio *uio, struct ucred *cred, /*ARGSUSED*/ static int kqueue_write(struct file *fp, struct uio *uio, struct ucred *cred, - int flags, struct proc *p) + int flags, struct thread *td) { return (ENXIO); } /*ARGSUSED*/ static int -kqueue_ioctl(struct file *fp, u_long com, caddr_t data, struct proc *p) +kqueue_ioctl(struct file *fp, u_long com, caddr_t data, struct thread *td) { return (ENOTTY); } /*ARGSUSED*/ static int -kqueue_poll(struct file *fp, int events, struct ucred *cred, struct proc *p) +kqueue_poll(struct file *fp, int events, struct ucred *cred, struct thread *td) { struct kqueue *kq = (struct kqueue *)fp->f_data; int revents = 0; @@ -745,7 +745,7 @@ kqueue_poll(struct file *fp, int events, struct ucred *cred, struct proc *p) if (kq->kq_count) { revents |= events & (POLLIN | POLLRDNORM); } else { - selrecord(p, &kq->kq_sel); + selrecord(curthread, &kq->kq_sel); kq->kq_state |= KQ_SEL; } } @@ -755,7 +755,7 @@ kqueue_poll(struct file *fp, int events, struct ucred *cred, struct proc *p) /*ARGSUSED*/ static int -kqueue_stat(struct file *fp, struct stat *st, struct proc *p) +kqueue_stat(struct file *fp, struct stat *st, struct thread *td) { struct kqueue *kq = (struct kqueue *)fp->f_data; @@ -768,10 +768,10 @@ kqueue_stat(struct file *fp, struct stat *st, struct proc *p) /*ARGSUSED*/ static int -kqueue_close(struct file *fp, struct proc *p) +kqueue_close(struct file *fp, struct thread *td) { struct kqueue *kq = (struct kqueue *)fp->f_data; - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct knote **knp, *kn, *kn0; int i; @@ -782,7 +782,7 @@ kqueue_close(struct file *fp, struct proc *p) kn0 = SLIST_NEXT(kn, kn_link); if (kq == kn->kn_kq) { kn->kn_fop->f_detach(kn); - fdrop(kn->kn_fp, p); + fdrop(kn->kn_fp, td); knote_free(kn); *knp = kn0; } else { @@ -847,13 +847,13 @@ knote(struct klist *list, long hint) * remove all knotes from a specified klist */ void -knote_remove(struct proc *p, struct klist *list) +knote_remove(struct thread *td, struct klist *list) { struct knote *kn; while ((kn = SLIST_FIRST(list)) != NULL) { kn->kn_fop->f_detach(kn); - knote_drop(kn, p); + knote_drop(kn, td); } } @@ -861,12 +861,12 @@ knote_remove(struct proc *p, struct klist *list) * remove all knotes referencing a specified fd */ void -knote_fdclose(struct proc *p, int fd) +knote_fdclose(struct thread *td, int fd) { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct klist *list = &fdp->fd_knlist[fd]; - knote_remove(p, list); + knote_remove(td, list); } static void @@ -910,9 +910,9 @@ done: * while calling fdrop and free. */ static void -knote_drop(struct knote *kn, struct proc *p) +knote_drop(struct knote *kn, struct thread *td) { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct klist *list; if (kn->kn_fop->f_isfd) @@ -924,7 +924,7 @@ knote_drop(struct knote *kn, struct proc *p) if (kn->kn_status & KN_QUEUED) knote_dequeue(kn); if (kn->kn_fop->f_isfd) - fdrop(kn->kn_fp, p); + fdrop(kn->kn_fp, td); knote_free(kn); } diff --git a/sys/kern/kern_exec.c b/sys/kern/kern_exec.c index 90a4f4c..0091d09 100644 --- a/sys/kern/kern_exec.c +++ b/sys/kern/kern_exec.c @@ -102,10 +102,11 @@ struct execve_args { * MPSAFE */ int -execve(p, uap) - struct proc *p; +execve(td, uap) + struct thread *td; register struct execve_args *uap; { + struct proc *p = td->td_proc; struct nameidata nd, *ndp; struct ucred *newcred, *oldcred; register_t *stack_base; @@ -117,6 +118,10 @@ execve(p, uap) imgp = &image_params; +/* XXXKSE */ +/* !!!!!!!! we need abort all the other threads of this process before we */ +/* proceed beyond his point! */ + /* * Initialize part of the common data */ @@ -156,7 +161,7 @@ execve(p, uap) */ ndp = &nd; NDINIT(ndp, LOOKUP, LOCKLEAF | FOLLOW | SAVENAME, - UIO_USERSPACE, uap->fname, p); + UIO_USERSPACE, uap->fname, td); interpret: @@ -175,12 +180,12 @@ interpret: */ error = exec_check_permissions(imgp); if (error) { - VOP_UNLOCK(imgp->vp, 0, p); + VOP_UNLOCK(imgp->vp, 0, td); goto exec_fail_dealloc; } error = exec_map_first_page(imgp); - VOP_UNLOCK(imgp->vp, 0, p); + VOP_UNLOCK(imgp->vp, 0, td); if (error) goto exec_fail_dealloc; @@ -223,7 +228,7 @@ interpret: vrele(ndp->ni_vp); /* set new name to that of the interpreter */ NDINIT(ndp, LOOKUP, LOCKLEAF | FOLLOW | SAVENAME, - UIO_SYSSPACE, imgp->interpreter_name, p); + UIO_SYSSPACE, imgp->interpreter_name, td); goto interpret; } @@ -250,8 +255,8 @@ interpret: if (p->p_fd->fd_refcnt > 1) { struct filedesc *tmp; - tmp = fdcopy(p); - fdfree(p); + tmp = fdcopy(td); + fdfree(td); p->p_fd = tmp; } @@ -270,17 +275,17 @@ interpret: p->p_procsig->ps_refcnt--; p->p_procsig = newprocsig; p->p_procsig->ps_refcnt = 1; - if (p->p_sigacts == &p->p_addr->u_sigacts) + if (p->p_sigacts == &p->p_uarea->u_sigacts) panic("shared procsig but private sigacts?"); - p->p_addr->u_sigacts = *p->p_sigacts; - p->p_sigacts = &p->p_addr->u_sigacts; + p->p_uarea->u_sigacts = *p->p_sigacts; + p->p_sigacts = &p->p_uarea->u_sigacts; } /* Stop profiling */ stopprofclock(p); /* close files on exec */ - fdcloseexec(p); + fdcloseexec(td); /* reset caught signals */ execsigs(p); @@ -342,7 +347,7 @@ interpret: change_euid(newcred, attr.va_uid); if (attr.va_mode & VSGID) change_egid(newcred, attr.va_gid); - setugidsafety(p); + setugidsafety(td); } else { if (oldcred->cr_uid == oldcred->cr_ruid && oldcred->cr_gid == oldcred->cr_rgid) @@ -408,7 +413,7 @@ interpret: p->p_acflag &= ~AFORK; /* Set values passed into the program in registers. */ - setregs(p, imgp->entry_addr, (u_long)(uintptr_t)stack_base, + setregs(td, imgp->entry_addr, (u_long)(uintptr_t)stack_base, imgp->ps_strings); /* Free any previous argument cache */ @@ -454,7 +459,7 @@ exec_fail_dealloc: exec_fail: if (imgp->vmspace_destroyed) { /* sorry, no more process anymore. exit gracefully */ - exit1(p, W_EXITCODE(0, SIGABRT)); + exit1(td, W_EXITCODE(0, SIGABRT)); /* NOT REACHED */ error = 0; } @@ -587,7 +592,7 @@ exec_new_vmspace(imgp) error = vm_map_find(&vmspace->vm_map, 0, 0, &bsaddr, 4*PAGE_SIZE, 0, VM_PROT_ALL, VM_PROT_ALL, 0); - imgp->proc->p_md.md_bspstore = bsaddr; + imgp->proc->p_thread.td_md.md_bspstore = bsaddr; } #endif @@ -798,7 +803,7 @@ exec_check_permissions(imgp) int error; /* Get file attributes */ - error = VOP_GETATTR(vp, attr, p->p_ucred, p); + error = VOP_GETATTR(vp, attr, p->p_ucred, curthread); /* XXXKSE */ if (error) return (error); @@ -825,7 +830,7 @@ exec_check_permissions(imgp) /* * Check for execute permission to file based on current credentials. */ - error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); + error = VOP_ACCESS(vp, VEXEC, p->p_ucred, curthread); /* XXXKSE */ if (error) return (error); @@ -840,7 +845,7 @@ exec_check_permissions(imgp) * Call filesystem specific open routine (which does nothing in the * general case). */ - error = VOP_OPEN(vp, FREAD, p->p_ucred, p); + error = VOP_OPEN(vp, FREAD, p->p_ucred, curthread); /* XXXKSE */ if (error) return (error); diff --git a/sys/kern/kern_exit.c b/sys/kern/kern_exit.c index 812b20e..80da053 100644 --- a/sys/kern/kern_exit.c +++ b/sys/kern/kern_exit.c @@ -79,7 +79,7 @@ MALLOC_DEFINE(M_ZOMBIE, "zombie", "zombie proc status"); static MALLOC_DEFINE(M_ATEXIT, "atexit", "atexit callback"); -static int wait1 __P((struct proc *, struct wait_args *, int)); +static int wait1 __P((struct thread *, struct wait_args *, int)); /* * callout list for things to do at exit time @@ -99,14 +99,15 @@ static struct exit_list_head exit_list = TAILQ_HEAD_INITIALIZER(exit_list); * MPSAFE */ void -sys_exit(p, uap) - struct proc *p; +sys_exit(td, uap) + struct thread *td; struct sys_exit_args /* { int rval; } */ *uap; { + mtx_lock(&Giant); - exit1(p, W_EXITCODE(uap->rval, 0)); + exit1(td, W_EXITCODE(uap->rval, 0)); /* NOTREACHED */ } @@ -116,10 +117,11 @@ sys_exit(p, uap) * status and rusage for wait(). Check for child processes and orphan them. */ void -exit1(p, rv) - register struct proc *p; +exit1(td, rv) + register struct thread *td; int rv; { + struct proc *p = td->td_proc; register struct proc *q, *nq; register struct vmspace *vm; struct exitlist *ep; @@ -132,6 +134,9 @@ exit1(p, rv) panic("Going nowhere without my init!"); } +/* XXXXKSE */ +/* MUST abort all other threads before proceeding past this point */ + aio_proc_rundown(p); /* are we a task leader? */ @@ -189,7 +194,7 @@ exit1(p, rv) * Close open files and release open-file table. * This may block! */ - fdfree(p); + fdfree(&p->p_thread); /* XXXKSE */ /* * Remove ourself from our leader's peer list and wake our leader. @@ -264,7 +269,7 @@ exit1(p, rv) } else PROC_UNLOCK(p); fixjobc(p, p->p_pgrp, 0); - (void)acct_process(p); + (void)acct_process(td); #ifdef KTRACE /* * release trace file @@ -385,7 +390,7 @@ exit1(p, rv) * The address space is released by "vmspace_free(p->p_vmspace)" * in vm_waitproc(); */ - cpu_exit(p); + cpu_exit(td); PROC_LOCK(p); mtx_lock_spin(&sched_lock); @@ -413,8 +418,8 @@ exit1(p, rv) * MPSAFE, the dirty work is handled by wait1(). */ int -owait(p, uap) - struct proc *p; +owait(td, uap) + struct thread *td; register struct owait_args /* { int dummy; } */ *uap; @@ -425,7 +430,7 @@ owait(p, uap) w.rusage = NULL; w.pid = WAIT_ANY; w.status = NULL; - return (wait1(p, &w, 1)); + return (wait1(td, &w, 1)); } #endif /* COMPAT_43 */ @@ -433,19 +438,20 @@ owait(p, uap) * MPSAFE, the dirty work is handled by wait1(). */ int -wait4(p, uap) - struct proc *p; +wait4(td, uap) + struct thread *td; struct wait_args *uap; { - return (wait1(p, uap, 0)); + + return (wait1(td, uap, 0)); } /* * MPSAFE */ static int -wait1(q, uap, compat) - register struct proc *q; +wait1(td, uap, compat) + register struct thread *td; register struct wait_args /* { int pid; int *status; @@ -455,10 +461,11 @@ wait1(q, uap, compat) int compat; { register int nfound; - register struct proc *p, *t; + register struct proc *q, *p, *t; int status, error; mtx_lock(&Giant); + q = td->td_proc; if (uap->pid == 0) uap->pid = -q->p_pgid; if (uap->options &~ (WUNTRACED|WNOHANG|WLINUXCLONE)) { @@ -491,20 +498,31 @@ loop: nfound++; mtx_lock_spin(&sched_lock); if (p->p_stat == SZOMB) { - /* charge childs scheduling cpu usage to parent */ - if (curproc->p_pid != 1) { - curproc->p_estcpu = - ESTCPULIM(curproc->p_estcpu + p->p_estcpu); + /* + * charge childs scheduling cpu usage to parent + * XXXKSE assume only one thread & kse & ksegrp + * keep estcpu in each ksegrp + * so charge it to the ksegrp that did the wait + * since process estcpu is sum of all ksegrps, + * this is strictly as expected. + * Assume that the child process aggregated all + * tke estcpu into the 'build-in' ksegrp. + * XXXKSE + */ + if (curthread->td_proc->p_pid != 1) { + curthread->td_ksegrp->kg_estcpu = + ESTCPULIM(curthread->td_ksegrp->kg_estcpu + + p->p_ksegrp.kg_estcpu); } mtx_unlock_spin(&sched_lock); PROC_UNLOCK(p); sx_sunlock(&proctree_lock); - q->p_retval[0] = p->p_pid; + td->td_retval[0] = p->p_pid; #ifdef COMPAT_43 if (compat) - q->p_retval[1] = p->p_xstat; + td->td_retval[1] = p->p_xstat; else #endif if (uap->status) { @@ -583,7 +601,7 @@ loop: FREE(p->p_args, M_PARGS); if (--p->p_procsig->ps_refcnt == 0) { - if (p->p_sigacts != &p->p_addr->u_sigacts) + if (p->p_sigacts != &p->p_uarea->u_sigacts) FREE(p->p_sigacts, M_SUBPROC); FREE(p->p_procsig, M_SUBPROC); p->p_procsig = NULL; @@ -607,10 +625,10 @@ loop: p->p_flag |= P_WAITED; PROC_UNLOCK(p); sx_sunlock(&proctree_lock); - q->p_retval[0] = p->p_pid; + td->td_retval[0] = p->p_pid; #ifdef COMPAT_43 if (compat) { - q->p_retval[1] = W_STOPCODE(p->p_xstat); + td->td_retval[1] = W_STOPCODE(p->p_xstat); error = 0; } else #endif @@ -631,7 +649,7 @@ loop: goto done2; } if (uap->options & WNOHANG) { - q->p_retval[0] = 0; + td->td_retval[0] = 0; error = 0; goto done2; } diff --git a/sys/kern/kern_fork.c b/sys/kern/kern_fork.c index af154c3..f5ae42c 100644 --- a/sys/kern/kern_fork.c +++ b/sys/kern/kern_fork.c @@ -110,18 +110,18 @@ SYSINIT(fork_list, SI_SUB_INTRINSIC, SI_ORDER_ANY, init_fork_list, NULL); */ /* ARGSUSED */ int -fork(p, uap) - struct proc *p; +fork(td, uap) + struct thread *td; struct fork_args *uap; { int error; struct proc *p2; mtx_lock(&Giant); - error = fork1(p, RFFDG | RFPROC, &p2); + error = fork1(td, RFFDG | RFPROC, &p2); if (error == 0) { - p->p_retval[0] = p2->p_pid; - p->p_retval[1] = 0; + td->td_retval[0] = p2->p_pid; + td->td_retval[1] = 0; } mtx_unlock(&Giant); return error; @@ -132,18 +132,18 @@ fork(p, uap) */ /* ARGSUSED */ int -vfork(p, uap) - struct proc *p; +vfork(td, uap) + struct thread *td; struct vfork_args *uap; { int error; struct proc *p2; mtx_lock(&Giant); - error = fork1(p, RFFDG | RFPROC | RFPPWAIT | RFMEM, &p2); + error = fork1(td, RFFDG | RFPROC | RFPPWAIT | RFMEM, &p2); if (error == 0) { - p->p_retval[0] = p2->p_pid; - p->p_retval[1] = 0; + td->td_retval[0] = p2->p_pid; + td->td_retval[1] = 0; } mtx_unlock(&Giant); return error; @@ -153,8 +153,8 @@ vfork(p, uap) * MPSAFE */ int -rfork(p, uap) - struct proc *p; +rfork(td, uap) + struct thread *td; struct rfork_args *uap; { int error; @@ -162,10 +162,10 @@ rfork(p, uap) /* mask kernel only flags out of the user flags */ mtx_lock(&Giant); - error = fork1(p, uap->flags & ~RFKERNELONLY, &p2); + error = fork1(td, uap->flags & ~RFKERNELONLY, &p2); if (error == 0) { - p->p_retval[0] = p2 ? p2->p_pid : 0; - p->p_retval[1] = 0; + td->td_retval[0] = p2 ? p2->p_pid : 0; + td->td_retval[1] = 0; } mtx_unlock(&Giant); return error; @@ -209,9 +209,26 @@ sysctl_kern_randompid(SYSCTL_HANDLER_ARGS) SYSCTL_PROC(_kern, OID_AUTO, randompid, CTLTYPE_INT|CTLFLAG_RW, 0, 0, sysctl_kern_randompid, "I", "Random PID modulus"); +#if 0 +void +kse_init(struct kse *kse1, struct kse *kse2) +{ +} + +void +thread_init(struct thread *thread1, struct thread *thread2) +{ +} + +void +ksegrp_init(struct ksegrp *ksegrp1, struct ksegrp *ksegrp2) +{ +} +#endif + int -fork1(p1, flags, procp) - struct proc *p1; /* parent proc */ +fork1(td, flags, procp) + struct thread *td; /* parent proc */ int flags; struct proc **procp; /* child proc */ { @@ -223,6 +240,7 @@ fork1(p1, flags, procp) static int pidchecked = 0; struct forklist *ep; struct filedesc *fd; + struct proc *p1 = td->td_proc; GIANT_REQUIRED; @@ -235,16 +253,16 @@ fork1(p1, flags, procp) * certain parts of a process from itself. */ if ((flags & RFPROC) == 0) { - vm_forkproc(p1, 0, flags); + vm_forkproc(td, 0, flags); /* * Close all file descriptors. */ if (flags & RFCFDG) { struct filedesc *fdtmp; - fdtmp = fdinit(p1); + fdtmp = fdinit(td); /* XXXKSE */ PROC_LOCK(p1); - fdfree(p1); + fdfree(td); /* XXXKSE */ p1->p_fd = fdtmp; PROC_UNLOCK(p1); } @@ -255,9 +273,9 @@ fork1(p1, flags, procp) if (flags & RFFDG) { if (p1->p_fd->fd_refcnt > 1) { struct filedesc *newfd; - newfd = fdcopy(p1); + newfd = fdcopy(td); PROC_LOCK(p1); - fdfree(p1); + fdfree(td); p1->p_fd = newfd; PROC_UNLOCK(p1); } @@ -401,13 +419,42 @@ again: */ bzero(&p2->p_startzero, (unsigned) ((caddr_t)&p2->p_endzero - (caddr_t)&p2->p_startzero)); + bzero(&p2->p_kse.ke_startzero, + (unsigned) ((caddr_t)&p2->p_kse.ke_endzero + - (caddr_t)&p2->p_kse.ke_startzero)); + bzero(&p2->p_thread.td_startzero, + (unsigned) ((caddr_t)&p2->p_thread.td_endzero + - (caddr_t)&p2->p_thread.td_startzero)); + bzero(&p2->p_ksegrp.kg_startzero, + (unsigned) ((caddr_t)&p2->p_ksegrp.kg_endzero + - (caddr_t)&p2->p_ksegrp.kg_startzero)); PROC_LOCK(p1); bcopy(&p1->p_startcopy, &p2->p_startcopy, (unsigned) ((caddr_t)&p2->p_endcopy - (caddr_t)&p2->p_startcopy)); + + bcopy(&p1->p_kse.ke_startcopy, &p2->p_kse.ke_startcopy, + (unsigned) ((caddr_t)&p2->p_kse.ke_endcopy + - (caddr_t)&p2->p_kse.ke_startcopy)); + + bcopy(&p1->p_thread.td_startcopy, &p2->p_thread.td_startcopy, + (unsigned) ((caddr_t)&p2->p_thread.td_endcopy + - (caddr_t)&p2->p_thread.td_startcopy)); + + bcopy(&p1->p_ksegrp.kg_startcopy, &p2->p_ksegrp.kg_startcopy, + (unsigned) ((caddr_t)&p2->p_ksegrp.kg_endcopy + - (caddr_t)&p2->p_ksegrp.kg_startcopy)); PROC_UNLOCK(p1); + /* + * XXXKSE Theoretically only the running thread would get copied + * Others in the kernel would be 'aborted' in the child. + * i.e return E*something* + */ + proc_linkup(p2); + mtx_init(&p2->p_mtx, "process lock", MTX_DEF); PROC_LOCK(p2); + /* note.. XXXKSE no pcb or u-area yet */ /* * Duplicate sub-structures as needed. @@ -433,7 +480,7 @@ again: if (flags & RFSIGSHARE) { p2->p_procsig = p1->p_procsig; p2->p_procsig->ps_refcnt++; - if (p1->p_sigacts == &p1->p_addr->u_sigacts) { + if (p1->p_sigacts == &p1->p_uarea->u_sigacts) { struct sigacts *newsigacts; PROC_UNLOCK(p1); @@ -450,7 +497,7 @@ again: * the shared p_procsig->ps_sigacts. */ p2->p_sigacts = newsigacts; - *p2->p_sigacts = p1->p_addr->u_sigacts; + *p2->p_sigacts = p1->p_uarea->u_sigacts; } } else { PROC_UNLOCK(p1); @@ -476,9 +523,9 @@ again: VREF(p2->p_textvp); if (flags & RFCFDG) - fd = fdinit(p1); + fd = fdinit(td); else if (flags & RFFDG) - fd = fdcopy(p1); + fd = fdcopy(td); else fd = fdshare(p1); PROC_LOCK(p2); @@ -531,10 +578,10 @@ again: sx_xunlock(&proctree_lock); PROC_LOCK(p2); LIST_INIT(&p2->p_children); - LIST_INIT(&p2->p_contested); + LIST_INIT(&p2->p_thread.td_contested); /* XXXKSE only 1 thread? */ callout_init(&p2->p_itcallout, 0); - callout_init(&p2->p_slpcallout, 1); + callout_init(&p2->p_thread.td_slpcallout, 1); /* XXXKSE */ PROC_LOCK(p1); #ifdef KTRACE @@ -556,9 +603,10 @@ again: /* * set priority of child to be that of parent + * XXXKSE hey! copying the estcpu seems dodgy.. should split it.. */ mtx_lock_spin(&sched_lock); - p2->p_estcpu = p1->p_estcpu; + p2->p_ksegrp.kg_estcpu = p1->p_ksegrp.kg_estcpu; mtx_unlock_spin(&sched_lock); /* @@ -573,7 +621,7 @@ again: * Finish creating the child process. It will return via a different * execution path later. (ie: directly into user mode) */ - vm_forkproc(p1, p2, flags); + vm_forkproc(td, p2, flags); if (flags == (RFFDG | RFPROC)) { cnt.v_forks++; @@ -609,7 +657,7 @@ again: if ((flags & RFSTOPPED) == 0) { mtx_lock_spin(&sched_lock); p2->p_stat = SRUN; - setrunqueue(p2); + setrunqueue(&p2->p_thread); mtx_unlock_spin(&sched_lock); } @@ -708,14 +756,13 @@ fork_exit(callout, arg, frame) void *arg; struct trapframe *frame; { - struct proc *p; - - p = curproc; + struct thread *td = curthread; + struct proc *p = td->td_proc; /* * Setup the sched_lock state so that we can release it. */ - sched_lock.mtx_lock = (uintptr_t)p; + sched_lock.mtx_lock = (uintptr_t)td; sched_lock.mtx_recurse = 0; /* * XXX: We really shouldn't have to do this. @@ -760,15 +807,15 @@ fork_exit(callout, arg, frame) * first parameter and is called when returning to a new userland process. */ void -fork_return(p, frame) - struct proc *p; +fork_return(td, frame) + struct thread *td; struct trapframe *frame; { - userret(p, frame, 0); + userret(td, frame, 0); #ifdef KTRACE - if (KTRPOINT(p, KTR_SYSRET)) { - ktrsysret(p->p_tracep, SYS_fork, 0, 0); + if (KTRPOINT(td->td_proc, KTR_SYSRET)) { + ktrsysret(td->td_proc->p_tracep, SYS_fork, 0, 0); } #endif mtx_assert(&Giant, MA_NOTOWNED); diff --git a/sys/kern/kern_idle.c b/sys/kern/kern_idle.c index c1482bb..b37e27a 100644 --- a/sys/kern/kern_idle.c +++ b/sys/kern/kern_idle.c @@ -46,13 +46,13 @@ idle_setup(void *dummy) SLIST_FOREACH(gd, &cpuhead, gd_allcpu) { error = kthread_create(idle_proc, NULL, &p, RFSTOPPED | RFHIGHPID, "idle: cpu%d", gd->gd_cpuid); - gd->gd_idleproc = p; - if (gd->gd_curproc == NULL) - gd->gd_curproc = p; + gd->gd_idlethread = &p->p_thread; + if (gd->gd_curthread == NULL) + gd->gd_curthread = gd->gd_idlethread; #else error = kthread_create(idle_proc, NULL, &p, RFSTOPPED | RFHIGHPID, "idle"); - PCPU_SET(idleproc, p); + PCPU_SET(idlethread, &p->p_thread); #endif if (error) panic("idle_setup: kthread_create error %d\n", error); diff --git a/sys/kern/kern_intr.c b/sys/kern/kern_intr.c index f5ba010..15ae4ff 100644 --- a/sys/kern/kern_intr.c +++ b/sys/kern/kern_intr.c @@ -118,25 +118,27 @@ static void ithread_update(struct ithd *ithd) { struct intrhand *ih; + struct thread *td; struct proc *p; int entropy; mtx_assert(&ithd->it_lock, MA_OWNED); - p = ithd->it_proc; - if (p == NULL) + td = ithd->it_td; + if (td == NULL) return; + p = td->td_proc; strncpy(p->p_comm, ithd->it_name, sizeof(ithd->it_name)); ih = TAILQ_FIRST(&ithd->it_handlers); if (ih == NULL) { - p->p_pri.pri_level = PRI_MAX_ITHD; + td->td_ksegrp->kg_pri.pri_level = PRI_MAX_ITHD; ithd->it_flags &= ~IT_ENTROPY; return; } entropy = 0; - p->p_pri.pri_level = ih->ih_pri; - p->p_pri.pri_native = ih->ih_pri; + td->td_ksegrp->kg_pri.pri_level = ih->ih_pri; + td->td_ksegrp->kg_pri.pri_native = ih->ih_pri; TAILQ_FOREACH(ih, &ithd->it_handlers, ih_next) { if (strlen(p->p_comm) + strlen(ih->ih_name) + 1 < sizeof(p->p_comm)) { @@ -166,6 +168,7 @@ ithread_create(struct ithd **ithread, int vector, int flags, void (*disable)(int), void (*enable)(int), const char *fmt, ...) { struct ithd *ithd; + struct thread *td; struct proc *p; int error; va_list ap; @@ -194,11 +197,12 @@ ithread_create(struct ithd **ithread, int vector, int flags, free(ithd, M_ITHREAD); return (error); } - p->p_pri.pri_class = PRI_ITHD; - p->p_pri.pri_level = PRI_MAX_ITHD; + td = &p->p_thread; /* XXXKSE */ + td->td_ksegrp->kg_pri.pri_class = PRI_ITHD; + td->td_ksegrp->kg_pri.pri_level = PRI_MAX_ITHD; p->p_stat = SWAIT; - ithd->it_proc = p; - p->p_ithd = ithd; + ithd->it_td = td; + td->td_ithd = ithd; if (ithread != NULL) *ithread = ithd; mtx_unlock(&ithd->it_lock); @@ -211,9 +215,13 @@ int ithread_destroy(struct ithd *ithread) { + struct thread *td; + struct proc *p; if (ithread == NULL) return (EINVAL); + td = ithread->it_td; + p = td->td_proc; mtx_lock(&ithread->it_lock); if (!TAILQ_EMPTY(&ithread->it_handlers)) { mtx_unlock(&ithread->it_lock); @@ -221,9 +229,9 @@ ithread_destroy(struct ithd *ithread) } ithread->it_flags |= IT_DEAD; mtx_lock_spin(&sched_lock); - if (ithread->it_proc->p_stat == SWAIT) { - ithread->it_proc->p_stat = SRUN; - setrunqueue(ithread->it_proc); + if (p->p_stat == SWAIT) { + p->p_stat = SRUN; /* XXXKSE */ + setrunqueue(td); } mtx_unlock_spin(&sched_lock); mtx_unlock(&ithread->it_lock); @@ -319,7 +327,7 @@ ok: * handler as being dead and let the ithread do the actual removal. */ mtx_lock_spin(&sched_lock); - if (ithread->it_proc->p_stat != SWAIT) { + if (ithread->it_td->td_proc->p_stat != SWAIT) { handler->ih_flags |= IH_DEAD; /* @@ -343,6 +351,7 @@ int ithread_schedule(struct ithd *ithread, int do_switch) { struct int_entropy entropy; + struct thread *td; struct proc *p; /* @@ -357,12 +366,13 @@ ithread_schedule(struct ithd *ithread, int do_switch) */ if (harvest.interrupt && ithread->it_flags & IT_ENTROPY) { entropy.vector = ithread->it_vector; - entropy.proc = CURPROC; + entropy.proc = curthread->td_proc;; random_harvest(&entropy, sizeof(entropy), 2, 0, RANDOM_INTERRUPT); } - p = ithread->it_proc; + td = ithread->it_td; + p = td->td_proc; KASSERT(p != NULL, ("ithread %s has no process", ithread->it_name)); CTR3(KTR_INTR, __func__ ": pid %d: (%s) need = %d", p->p_pid, p->p_comm, ithread->it_need); @@ -380,14 +390,14 @@ ithread_schedule(struct ithd *ithread, int do_switch) if (p->p_stat == SWAIT) { CTR1(KTR_INTR, __func__ ": setrunqueue %d", p->p_pid); p->p_stat = SRUN; - setrunqueue(p); - if (do_switch && curproc->p_stat == SRUN) { - if (curproc != PCPU_GET(idleproc)) - setrunqueue(curproc); - curproc->p_stats->p_ru.ru_nivcsw++; + setrunqueue(td); /* XXXKSE */ + if (do_switch && curthread->td_proc->p_stat == SRUN) { + if (curthread != PCPU_GET(idlethread)) + setrunqueue(curthread); + curthread->td_proc->p_stats->p_ru.ru_nivcsw++; mi_switch(); } else - curproc->p_sflag |= PS_NEEDRESCHED; + curthread->td_kse->ke_flags |= KEF_NEEDRESCHED; } else { CTR3(KTR_INTR, __func__ ": pid %d: it_need %d, state %d", p->p_pid, ithread->it_need, p->p_stat); @@ -439,7 +449,7 @@ swi_sched(void *cookie, int flags) atomic_add_int(&cnt.v_intr, 1); /* one more global interrupt */ CTR3(KTR_INTR, "swi_sched pid %d(%s) need=%d", - it->it_proc->p_pid, it->it_proc->p_comm, it->it_need); + it->it_td->td_proc->p_pid, it->it_td->td_proc->p_comm, it->it_need); /* * Set ih_need for this handler so that if the ithread is already @@ -461,11 +471,13 @@ ithread_loop(void *arg) { struct ithd *ithd; /* our thread context */ struct intrhand *ih; /* and our interrupt handler chain */ + struct thread *td; struct proc *p; - p = curproc; + td = curthread; + p = td->td_proc; ithd = (struct ithd *)arg; /* point to myself */ - KASSERT(ithd->it_proc == p && p->p_ithd == ithd, + KASSERT(ithd->it_td == td && td->td_ithd == ithd, (__func__ ": ithread and proc linkage out of sync")); /* @@ -479,7 +491,7 @@ ithread_loop(void *arg) if (ithd->it_flags & IT_DEAD) { CTR2(KTR_INTR, __func__ ": pid %d: (%s) exiting", p->p_pid, p->p_comm); - p->p_ithd = NULL; + td->td_ithd = NULL; mtx_destroy(&ithd->it_lock); mtx_lock(&Giant); free(ithd, M_ITHREAD); @@ -559,9 +571,9 @@ start_softintr(void *dummy) swi_add(NULL, "vm", swi_vm, NULL, SWI_VM, 0, &vm_ih)) panic("died while creating standard software ithreads"); - PROC_LOCK(clk_ithd->it_proc); - clk_ithd->it_proc->p_flag |= P_NOLOAD; - PROC_UNLOCK(clk_ithd->it_proc); + PROC_LOCK(clk_ithd->it_td->td_proc); + clk_ithd->it_td->td_proc->p_flag |= P_NOLOAD; + PROC_UNLOCK(clk_ithd->it_td->td_proc); } SYSINIT(start_softintr, SI_SUB_SOFTINTR, SI_ORDER_FIRST, start_softintr, NULL) diff --git a/sys/kern/kern_jail.c b/sys/kern/kern_jail.c index abe5e0f..c1d9470 100644 --- a/sys/kern/kern_jail.c +++ b/sys/kern/kern_jail.c @@ -48,12 +48,13 @@ SYSCTL_INT(_jail, OID_AUTO, sysvipc_allowed, CTLFLAG_RW, * MPSAFE */ int -jail(p, uap) - struct proc *p; +jail(td, uap) + struct thread *td; struct jail_args /* { syscallarg(struct jail *) jail; } */ *uap; { + struct proc *p = td->td_proc; int error; struct prison *pr; struct jail j; @@ -79,7 +80,7 @@ jail(p, uap) pr->pr_ip = j.ip_number; ca.path = j.path; - error = chroot(p, &ca); + error = chroot(td, &ca); if (error) goto bail; diff --git a/sys/kern/kern_kthread.c b/sys/kern/kern_kthread.c index 7e8e702..cb715da 100644 --- a/sys/kern/kern_kthread.c +++ b/sys/kern/kern_kthread.c @@ -81,7 +81,7 @@ kthread_create(void (*func)(void *), void *arg, if (!proc0.p_stats /* || proc0.p_stats->p_start.tv_sec == 0 */) panic("kthread_create called too soon"); - error = fork1(&proc0, RFMEM | RFFDG | RFPROC | RFSTOPPED | flags, &p2); + error = fork1(thread0, RFMEM | RFFDG | RFPROC | RFSTOPPED | flags, &p2); if (error) return error; @@ -102,14 +102,14 @@ kthread_create(void (*func)(void *), void *arg, va_end(ap); /* call the processes' main()... */ - cpu_set_fork_handler(p2, func, arg); + cpu_set_fork_handler(&p2->p_thread, func, arg); /* XXXKSE */ /* Delay putting it on the run queue until now. */ mtx_lock_spin(&sched_lock); p2->p_sflag |= PS_INMEM; if (!(flags & RFSTOPPED)) { p2->p_stat = SRUN; - setrunqueue(p2); + setrunqueue(&p2->p_thread); /* XXXKSE */ } mtx_unlock_spin(&sched_lock); @@ -125,7 +125,7 @@ kthread_exit(int ecode) proc_reparent(curproc, initproc); PROC_UNLOCK(curproc); sx_xunlock(&proctree_lock); - exit1(curproc, W_EXITCODE(ecode, 0)); + exit1(curthread, W_EXITCODE(ecode, 0)); } /* diff --git a/sys/kern/kern_ktrace.c b/sys/kern/kern_ktrace.c index 9b97944..6297f9b 100644 --- a/sys/kern/kern_ktrace.c +++ b/sys/kern/kern_ktrace.c @@ -251,11 +251,12 @@ struct ktrace_args { #endif /* ARGSUSED */ int -ktrace(curp, uap) - struct proc *curp; +ktrace(td, uap) + struct thread *td; register struct ktrace_args *uap; { #ifdef KTRACE + struct proc *curp = td->td_proc; register struct vnode *vp = NULL; register struct proc *p; struct pgrp *pg; @@ -271,7 +272,7 @@ ktrace(curp, uap) /* * an operation which requires a file argument. */ - NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->fname, curp); + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->fname, td); flags = FREAD | FWRITE | O_NOFOLLOW; error = vn_open(&nd, &flags, 0); if (error) { @@ -280,9 +281,9 @@ ktrace(curp, uap) } NDFREE(&nd, NDF_ONLY_PNBUF); vp = nd.ni_vp; - VOP_UNLOCK(vp, 0, curp); + VOP_UNLOCK(vp, 0, td); if (vp->v_type != VREG) { - (void) vn_close(vp, FREAD|FWRITE, curp->p_ucred, curp); + (void) vn_close(vp, FREAD|FWRITE, curp->p_ucred, td); curp->p_traceflag &= ~KTRFAC_ACTIVE; return (EACCES); } @@ -298,7 +299,7 @@ ktrace(curp, uap) p->p_tracep = NULL; p->p_traceflag = 0; (void) vn_close(vp, FREAD|FWRITE, - p->p_ucred, p); + p->p_ucred, td); } else error = EPERM; } @@ -349,7 +350,7 @@ ktrace(curp, uap) error = EPERM; done: if (vp != NULL) - (void) vn_close(vp, FWRITE, curp->p_ucred, curp); + (void) vn_close(vp, FWRITE, curp->p_ucred, td); curp->p_traceflag &= ~KTRFAC_ACTIVE; return (error); #else @@ -362,10 +363,11 @@ done: */ /* ARGSUSED */ int -utrace(curp, uap) - struct proc *curp; +utrace(td, uap) + struct thread *td; register struct utrace_args *uap; { + #ifdef KTRACE struct ktr_header *kth; struct proc *p = curproc; /* XXX */ @@ -474,7 +476,8 @@ ktrwrite(vp, kth, uio) { struct uio auio; struct iovec aiov[2]; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ + struct proc *p = td->td_proc; /* XXX */ struct mount *mp; int error; @@ -488,7 +491,7 @@ ktrwrite(vp, kth, uio) aiov[0].iov_len = sizeof(struct ktr_header); auio.uio_resid = sizeof(struct ktr_header); auio.uio_iovcnt = 1; - auio.uio_procp = curproc; + auio.uio_td = curthread; if (kth->ktr_len > 0) { auio.uio_iovcnt++; aiov[1].iov_base = kth->ktr_buffer; @@ -498,14 +501,14 @@ ktrwrite(vp, kth, uio) kth->ktr_len += uio->uio_resid; } vn_start_write(vp, &mp, V_WAIT); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - (void)VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + (void)VOP_LEASE(vp, td, p->p_ucred, LEASE_WRITE); error = VOP_WRITE(vp, &auio, IO_UNIT | IO_APPEND, p->p_ucred); if (error == 0 && uio != NULL) { - (void)VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); + (void)VOP_LEASE(vp, td, p->p_ucred, LEASE_WRITE); error = VOP_WRITE(vp, uio, IO_UNIT | IO_APPEND, p->p_ucred); } - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); if (!error) return; diff --git a/sys/kern/kern_linker.c b/sys/kern/kern_linker.c index bf6face..353d811 100644 --- a/sys/kern/kern_linker.c +++ b/sys/kern/kern_linker.c @@ -354,14 +354,14 @@ linker_find_file_by_name(const char* filename) goto out; sprintf(koname, "%s.ko", filename); - lockmgr(&lock, LK_SHARED, 0, curproc); + lockmgr(&lock, LK_SHARED, 0, curthread); TAILQ_FOREACH(lf, &linker_files, link) { if (!strcmp(lf->filename, koname)) break; if (!strcmp(lf->filename, filename)) break; } - lockmgr(&lock, LK_RELEASE, 0, curproc); + lockmgr(&lock, LK_RELEASE, 0, curthread); out: if (koname) @@ -374,11 +374,11 @@ linker_find_file_by_id(int fileid) { linker_file_t lf = 0; - lockmgr(&lock, LK_SHARED, 0, curproc); + lockmgr(&lock, LK_SHARED, 0, curthread); TAILQ_FOREACH(lf, &linker_files, link) if (lf->id == fileid) break; - lockmgr(&lock, LK_RELEASE, 0, curproc); + lockmgr(&lock, LK_RELEASE, 0, curthread); return lf; } @@ -392,7 +392,7 @@ linker_make_file(const char* pathname, linker_class_t lc) filename = linker_basename(pathname); KLD_DPF(FILE, ("linker_make_file: new file, filename=%s\n", filename)); - lockmgr(&lock, LK_EXCLUSIVE, 0, curproc); + lockmgr(&lock, LK_EXCLUSIVE, 0, curthread); lf = (linker_file_t) kobj_create((kobj_class_t) lc, M_LINKER, M_WAITOK); if (!lf) goto out; @@ -410,7 +410,7 @@ linker_make_file(const char* pathname, linker_class_t lc) TAILQ_INSERT_TAIL(&linker_files, lf, link); out: - lockmgr(&lock, LK_RELEASE, 0, curproc); + lockmgr(&lock, LK_RELEASE, 0, curthread); return lf; } @@ -428,7 +428,7 @@ linker_file_unload(linker_file_t file) return EPERM; KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs)); - lockmgr(&lock, LK_EXCLUSIVE, 0, curproc); + lockmgr(&lock, LK_EXCLUSIVE, 0, curthread); if (file->refs == 1) { KLD_DPF(FILE, ("linker_file_unload: file is unloading, informing modules\n")); /* @@ -443,7 +443,7 @@ linker_file_unload(linker_file_t file) if ((error = module_unload(mod)) != 0) { KLD_DPF(FILE, ("linker_file_unload: module %x vetoes unload\n", mod)); - lockmgr(&lock, LK_RELEASE, 0, curproc); + lockmgr(&lock, LK_RELEASE, 0, curthread); goto out; } @@ -453,7 +453,7 @@ linker_file_unload(linker_file_t file) file->refs--; if (file->refs > 0) { - lockmgr(&lock, LK_RELEASE, 0, curproc); + lockmgr(&lock, LK_RELEASE, 0, curthread); goto out; } @@ -471,7 +471,7 @@ linker_file_unload(linker_file_t file) } TAILQ_REMOVE(&linker_files, file, link); - lockmgr(&lock, LK_RELEASE, 0, curproc); + lockmgr(&lock, LK_RELEASE, 0, curthread); if (file->deps) { for (i = 0; i < file->ndeps; i++) @@ -683,21 +683,21 @@ linker_ddb_symbol_values(c_linker_sym_t sym, linker_symval_t *symval) * MPSAFE */ int -kldload(struct proc* p, struct kldload_args* uap) +kldload(struct thread* td, struct kldload_args* uap) { char *kldname, *modname; char *pathname = NULL; linker_file_t lf; int error = 0; - p->p_retval[0] = -1; + td->td_retval[0] = -1; if (securelevel > 0) /* redundant, but that's OK */ return EPERM; mtx_lock(&Giant); - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) goto out; pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK); @@ -720,7 +720,7 @@ kldload(struct proc* p, struct kldload_args* uap) goto out; lf->userrefs++; - p->p_retval[0] = lf->id; + td->td_retval[0] = lf->id; out: if (pathname) @@ -733,7 +733,7 @@ out: * MPSAFE */ int -kldunload(struct proc* p, struct kldunload_args* uap) +kldunload(struct thread* td, struct kldunload_args* uap) { linker_file_t lf; int error = 0; @@ -743,7 +743,7 @@ kldunload(struct proc* p, struct kldunload_args* uap) mtx_lock(&Giant); - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) goto out; lf = linker_find_file_by_id(SCARG(uap, fileid)); @@ -770,7 +770,7 @@ out: * MPSAFE */ int -kldfind(struct proc* p, struct kldfind_args* uap) +kldfind(struct thread* td, struct kldfind_args* uap) { char* pathname; const char *filename; @@ -778,8 +778,7 @@ kldfind(struct proc* p, struct kldfind_args* uap) int error = 0; mtx_lock(&Giant); - - p->p_retval[0] = -1; + td->td_retval[0] = -1; pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK); if ((error = copyinstr(SCARG(uap, file), pathname, MAXPATHLEN, NULL)) != 0) @@ -789,7 +788,7 @@ kldfind(struct proc* p, struct kldfind_args* uap) lf = linker_find_file_by_name(filename); if (lf) - p->p_retval[0] = lf->id; + td->td_retval[0] = lf->id; else error = ENOENT; @@ -804,7 +803,7 @@ out: * MPSAFE */ int -kldnext(struct proc* p, struct kldnext_args* uap) +kldnext(struct thread* td, struct kldnext_args* uap) { linker_file_t lf; int error = 0; @@ -813,18 +812,18 @@ kldnext(struct proc* p, struct kldnext_args* uap) if (SCARG(uap, fileid) == 0) { if (TAILQ_FIRST(&linker_files)) - p->p_retval[0] = TAILQ_FIRST(&linker_files)->id; + td->td_retval[0] = TAILQ_FIRST(&linker_files)->id; else - p->p_retval[0] = 0; + td->td_retval[0] = 0; goto out; } lf = linker_find_file_by_id(SCARG(uap, fileid)); if (lf) { if (TAILQ_NEXT(lf, link)) - p->p_retval[0] = TAILQ_NEXT(lf, link)->id; + td->td_retval[0] = TAILQ_NEXT(lf, link)->id; else - p->p_retval[0] = 0; + td->td_retval[0] = 0; } else { error = ENOENT; } @@ -837,7 +836,7 @@ out: * MPSAFE */ int -kldstat(struct proc* p, struct kldstat_args* uap) +kldstat(struct thread* td, struct kldstat_args* uap) { linker_file_t lf; int error = 0; @@ -879,7 +878,7 @@ kldstat(struct proc* p, struct kldstat_args* uap) if ((error = copyout(&lf->size, &stat->size, sizeof(size_t))) != 0) goto out; - p->p_retval[0] = 0; + td->td_retval[0] = 0; out: mtx_unlock(&Giant); @@ -890,7 +889,7 @@ out: * MPSAFE */ int -kldfirstmod(struct proc* p, struct kldfirstmod_args* uap) +kldfirstmod(struct thread* td, struct kldfirstmod_args* uap) { linker_file_t lf; int error = 0; @@ -899,9 +898,9 @@ kldfirstmod(struct proc* p, struct kldfirstmod_args* uap) lf = linker_find_file_by_id(SCARG(uap, fileid)); if (lf) { if (TAILQ_FIRST(&lf->modules)) - p->p_retval[0] = module_getid(TAILQ_FIRST(&lf->modules)); + td->td_retval[0] = module_getid(TAILQ_FIRST(&lf->modules)); else - p->p_retval[0] = 0; + td->td_retval[0] = 0; } else { error = ENOENT; } @@ -913,7 +912,7 @@ kldfirstmod(struct proc* p, struct kldfirstmod_args* uap) * MPSAFE */ int -kldsym(struct proc *p, struct kldsym_args *uap) +kldsym(struct thread *td, struct kldsym_args *uap) { char *symstr = NULL; c_linker_sym_t sym; @@ -1309,7 +1308,7 @@ linker_lookup_file(const char *path, int pathlen, const char *name, int namelen, struct vattr *vap) { struct nameidata nd; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ char *result, **cpp, *sep; int error, len, extlen, reclen, flags; enum vtype type; @@ -1332,16 +1331,16 @@ linker_lookup_file(const char *path, int pathlen, * Attempt to open the file, and return the path if we succeed * and it's a regular file. */ - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, result, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, result, td); flags = FREAD; error = vn_open(&nd, &flags, 0); if (error == 0) { NDFREE(&nd, NDF_ONLY_PNBUF); type = nd.ni_vp->v_type; if (vap) - VOP_GETATTR(nd.ni_vp, vap, p->p_ucred, p); - VOP_UNLOCK(nd.ni_vp, 0, p); - vn_close(nd.ni_vp, FREAD, p->p_ucred, p); + VOP_GETATTR(nd.ni_vp, vap, td->td_proc->p_ucred, td); + VOP_UNLOCK(nd.ni_vp, 0, td); + vn_close(nd.ni_vp, FREAD, td->td_proc->p_ucred, td); if (type == VREG) return(result); } @@ -1363,8 +1362,8 @@ linker_hints_lookup(const char *path, int pathlen, const char *modname, int modnamelen, struct mod_depend *verinfo) { - struct proc *p = curproc; - struct ucred *cred = p ? p->p_ucred : NULL; + struct thread *td = curthread; /* XXX */ + struct ucred *cred = td ? td->td_proc->p_ucred : NULL; struct nameidata nd; struct vattr vattr, mattr; u_char *hints = NULL; @@ -1380,17 +1379,17 @@ linker_hints_lookup(const char *path, int pathlen, pathbuf = malloc(reclen, M_LINKER, M_WAITOK); snprintf(pathbuf, reclen, "%.*s%s%s", pathlen, path, sep, linker_hintfile); - NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, pathbuf, p); + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, pathbuf, td); flags = FREAD; error = vn_open(&nd, &flags, 0); if (error) goto bad; NDFREE(&nd, NDF_ONLY_PNBUF); - VOP_UNLOCK(nd.ni_vp, 0, p); + VOP_UNLOCK(nd.ni_vp, 0, td); if (nd.ni_vp->v_type != VREG) goto bad; best = cp = NULL; - error = VOP_GETATTR(nd.ni_vp, &vattr, cred, p); + error = VOP_GETATTR(nd.ni_vp, &vattr, cred, td); if (error) goto bad; /* @@ -1404,10 +1403,10 @@ linker_hints_lookup(const char *path, int pathlen, if (hints == NULL) goto bad; error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)hints, vattr.va_size, 0, - UIO_SYSSPACE, IO_NODELOCKED, cred, &reclen, p); + UIO_SYSSPACE, IO_NODELOCKED, cred, &reclen, td); if (error) goto bad; - vn_close(nd.ni_vp, FREAD, cred, p); + vn_close(nd.ni_vp, FREAD, cred, td); nd.ni_vp = NULL; if (reclen != 0) { printf("can't read %d\n", reclen); @@ -1472,7 +1471,7 @@ bad: if (hints) free(hints, M_TEMP); if (nd.ni_vp != NULL) - vn_close(nd.ni_vp, FREAD, cred, p); + vn_close(nd.ni_vp, FREAD, cred, td); /* * If nothing found or hints is absent - fallback to the old way * by using "kldname[.ko]" as module name. diff --git a/sys/kern/kern_lock.c b/sys/kern/kern_lock.c index 147508c..3f8373b 100644 --- a/sys/kern/kern_lock.c +++ b/sys/kern/kern_lock.c @@ -208,14 +208,14 @@ acquire(struct lock *lkp, int extflags, int wanted) { */ int #ifndef DEBUG_LOCKS -lockmgr(lkp, flags, interlkp, p) +lockmgr(lkp, flags, interlkp, td) #else -debuglockmgr(lkp, flags, interlkp, p, name, file, line) +debuglockmgr(lkp, flags, interlkp, td, name, file, line) #endif struct lock *lkp; u_int flags; struct mtx *interlkp; - struct proc *p; + struct thread *td; #ifdef DEBUG_LOCKS const char *name; /* Name of lock function */ const char *file; /* Name of file call is from */ @@ -228,13 +228,13 @@ debuglockmgr(lkp, flags, interlkp, p, name, file, line) CTR5(KTR_LOCKMGR, "lockmgr(): lkp == %p (lk_wmesg == \"%s\"), flags == 0x%x, " - "interlkp == %p, p == %p", lkp, lkp->lk_wmesg, flags, interlkp, p); + "interlkp == %p, td == %p", lkp, lkp->lk_wmesg, flags, interlkp, td); error = 0; - if (p == NULL) + if (td == NULL) pid = LK_KERNPROC; else - pid = p->p_pid; + pid = td->td_proc->p_pid; mtx_lock(lkp->lk_interlock); if (flags & LK_INTERLOCK) { @@ -257,19 +257,19 @@ debuglockmgr(lkp, flags, interlkp, p, name, file, line) * while there is an exclusive lock holder or while an * exclusive lock request or upgrade request is in progress. * - * However, if P_DEADLKTREAT is set, we override exclusive + * However, if TDF_DEADLKTREAT is set, we override exclusive * lock requests or upgrade requests ( but not the exclusive * lock itself ). */ if (lkp->lk_lockholder != pid) { lockflags = LK_HAVE_EXCL; - if (p) { - PROC_LOCK(p); - if (!(p->p_flag & P_DEADLKTREAT)) { + if (td) { + PROC_LOCK(td->td_proc); + if (!(td->td_flags & TDF_DEADLKTREAT)) { lockflags |= LK_WANT_EXCL | LK_WANT_UPGRADE; } - PROC_UNLOCK(p); + PROC_UNLOCK(td->td_proc); } error = acquire(lkp, extflags, lockflags); if (error) @@ -560,15 +560,15 @@ lockdestroy(lkp) * Determine the status of a lock. */ int -lockstatus(lkp, p) +lockstatus(lkp, td) struct lock *lkp; - struct proc *p; + struct thread *td; { int lock_type = 0; mtx_lock(lkp->lk_interlock); if (lkp->lk_exclusivecount != 0) { - if (p == NULL || lkp->lk_lockholder == p->p_pid) + if (td == NULL || lkp->lk_lockholder == td->td_proc->p_pid) lock_type = LK_EXCLUSIVE; else lock_type = LK_EXCLOTHER; diff --git a/sys/kern/kern_lockf.c b/sys/kern/kern_lockf.c index c60705f..3bbb4d0 100644 --- a/sys/kern/kern_lockf.c +++ b/sys/kern/kern_lockf.c @@ -242,25 +242,29 @@ lf_setlock(lock) if ((lock->lf_flags & F_POSIX) && (block->lf_flags & F_POSIX)) { register struct proc *wproc; + struct thread *td; register struct lockf *waitblock; int i = 0; /* The block is waiting on something */ + /* XXXKSE this is not complete under threads */ wproc = (struct proc *)block->lf_id; mtx_lock_spin(&sched_lock); - while (wproc->p_wchan && - (wproc->p_wmesg == lockstr) && - (i++ < maxlockdepth)) { - waitblock = (struct lockf *)wproc->p_wchan; - /* Get the owner of the blocking lock */ - waitblock = waitblock->lf_next; - if ((waitblock->lf_flags & F_POSIX) == 0) - break; - wproc = (struct proc *)waitblock->lf_id; - if (wproc == (struct proc *)lock->lf_id) { - mtx_unlock_spin(&sched_lock); - free(lock, M_LOCKF); - return (EDEADLK); + FOREACH_THREAD_IN_PROC(wproc, td) { + while (td->td_wchan && + (td->td_wmesg == lockstr) && + (i++ < maxlockdepth)) { + waitblock = (struct lockf *)td->td_wchan; + /* Get the owner of the blocking lock */ + waitblock = waitblock->lf_next; + if ((waitblock->lf_flags & F_POSIX) == 0) + break; + wproc = (struct proc *)waitblock->lf_id; + if (wproc == (struct proc *)lock->lf_id) { + mtx_unlock_spin(&sched_lock); + free(lock, M_LOCKF); + return (EDEADLK); + } } } mtx_unlock_spin(&sched_lock); diff --git a/sys/kern/kern_malloc.c b/sys/kern/kern_malloc.c index 5f9ca0c..0446b1f 100644 --- a/sys/kern/kern_malloc.c +++ b/sys/kern/kern_malloc.c @@ -144,7 +144,7 @@ malloc(size, type, flags) #if defined(INVARIANTS) if (flags == M_WAITOK) - KASSERT(curproc->p_intr_nesting_level == 0, + KASSERT(curthread->td_intr_nesting_level == 0, ("malloc(M_WAITOK) in interrupt context")); #endif indx = BUCKETINDX(size); diff --git a/sys/kern/kern_module.c b/sys/kern/kern_module.c index 3fbdb72..f3651d2 100644 --- a/sys/kern/kern_module.c +++ b/sys/kern/kern_module.c @@ -222,18 +222,18 @@ module_setspecific(module_t mod, modspecific_t *datap) * MPSAFE */ int -modnext(struct proc* p, struct modnext_args* uap) +modnext(struct thread *td, struct modnext_args *uap) { module_t mod; int error = 0; mtx_lock(&Giant); - p->p_retval[0] = -1; + td->td_retval[0] = -1; if (SCARG(uap, modid) == 0) { mod = TAILQ_FIRST(&modules); if (mod) - p->p_retval[0] = mod->id; + td->td_retval[0] = mod->id; else error = ENOENT; goto done2; @@ -246,9 +246,9 @@ modnext(struct proc* p, struct modnext_args* uap) } if (TAILQ_NEXT(mod, link)) - p->p_retval[0] = TAILQ_NEXT(mod, link)->id; + td->td_retval[0] = TAILQ_NEXT(mod, link)->id; else - p->p_retval[0] = 0; + td->td_retval[0] = 0; done2: mtx_unlock(&Giant); return (error); @@ -258,12 +258,12 @@ done2: * MPSAFE */ int -modfnext(struct proc* p, struct modfnext_args* uap) +modfnext(struct thread *td, struct modfnext_args *uap) { module_t mod; int error; - p->p_retval[0] = -1; + td->td_retval[0] = -1; mtx_lock(&Giant); @@ -273,9 +273,9 @@ modfnext(struct proc* p, struct modfnext_args* uap) } else { error = 0; if (TAILQ_NEXT(mod, flink)) - p->p_retval[0] = TAILQ_NEXT(mod, flink)->id; + td->td_retval[0] = TAILQ_NEXT(mod, flink)->id; else - p->p_retval[0] = 0; + td->td_retval[0] = 0; } mtx_unlock(&Giant); return (error); @@ -292,7 +292,7 @@ struct module_stat_v1 { * MPSAFE */ int -modstat(struct proc* p, struct modstat_args* uap) +modstat(struct thread *td, struct modstat_args *uap) { module_t mod; int error = 0; @@ -340,7 +340,7 @@ modstat(struct proc* p, struct modstat_args* uap) goto out; } - p->p_retval[0] = 0; + td->td_retval[0] = 0; out: mtx_unlock(&Giant); @@ -351,7 +351,7 @@ out: * MPSAFE */ int -modfind(struct proc* p, struct modfind_args* uap) +modfind(struct thread *td, struct modfind_args *uap) { int error = 0; char name[MAXMODNAME]; @@ -365,7 +365,7 @@ modfind(struct proc* p, struct modfind_args* uap) if (mod == NULL) error = ENOENT; else - p->p_retval[0] = mod->id; + td->td_retval[0] = mod->id; mtx_unlock(&Giant); out: return error; diff --git a/sys/kern/kern_mutex.c b/sys/kern/kern_mutex.c index 646d99a..bbcac94 100644 --- a/sys/kern/kern_mutex.c +++ b/sys/kern/kern_mutex.c @@ -86,9 +86,9 @@ #define mtx_unowned(m) ((m)->mtx_lock == MTX_UNOWNED) #define mtx_owner(m) (mtx_unowned((m)) ? NULL \ - : (struct proc *)((m)->mtx_lock & MTX_FLAGMASK)) + : (struct thread *)((m)->mtx_lock & MTX_FLAGMASK)) -#define SET_PRIO(p, pri) (p)->p_pri.pri_level = (pri) +#define SET_PRIO(td, pri) (td)->td_ksegrp->kg_pri.pri_level = (pri) /* * Lock classes for sleep and spin mutexes. @@ -105,113 +105,118 @@ struct lock_class lock_class_mtx_spin = { /* * Prototypes for non-exported routines. */ -static void propagate_priority(struct proc *); +static void propagate_priority(struct thread *); static void -propagate_priority(struct proc *p) +propagate_priority(struct thread *td) { - int pri = p->p_pri.pri_level; - struct mtx *m = p->p_blocked; + struct ksegrp *kg = td->td_ksegrp; + int pri = kg->kg_pri.pri_level; + struct mtx *m = td->td_blocked; mtx_assert(&sched_lock, MA_OWNED); for (;;) { - struct proc *p1; + struct thread *td1; - p = mtx_owner(m); + td = mtx_owner(m); - if (p == NULL) { + if (td == NULL) { /* * This really isn't quite right. Really - * ought to bump priority of process that + * ought to bump priority of thread that * next acquires the mutex. */ MPASS(m->mtx_lock == MTX_CONTESTED); return; } - MPASS(p->p_magic == P_MAGIC); - KASSERT(p->p_stat != SSLEEP, ("sleeping process owns a mutex")); - if (p->p_pri.pri_level <= pri) + MPASS(td->td_proc->p_magic == P_MAGIC); + KASSERT(td->td_proc->p_stat != SSLEEP, ("sleeping thread owns a mutex")); + if (kg->kg_pri.pri_level <= pri) /* lower is higher priority */ return; /* - * Bump this process' priority. + * Bump this thread's priority. */ - SET_PRIO(p, pri); + SET_PRIO(td, pri); /* * If lock holder is actually running, just bump priority. */ - if (p->p_oncpu != NOCPU) { - MPASS(p->p_stat == SRUN || p->p_stat == SZOMB || p->p_stat == SSTOP); + /* XXXKSE this test is not sufficient */ + if (td->td_kse && (td->td_kse->ke_oncpu != NOCPU)) { + MPASS(td->td_proc->p_stat == SRUN + || td->td_proc->p_stat == SZOMB + || td->td_proc->p_stat == SSTOP); return; } #ifndef SMP /* - * For UP, we check to see if p is curproc (this shouldn't + * For UP, we check to see if td is curthread (this shouldn't * ever happen however as it would mean we are in a deadlock.) */ - KASSERT(p != curproc, ("Deadlock detected")); + KASSERT(td != curthread, ("Deadlock detected")); #endif /* - * If on run queue move to new run queue, and - * quit. + * If on run queue move to new run queue, and quit. + * XXXKSE this gets a lot more complicated under threads + * but try anyhow. */ - if (p->p_stat == SRUN) { - MPASS(p->p_blocked == NULL); - remrunqueue(p); - setrunqueue(p); + if (td->td_proc->p_stat == SRUN) { + MPASS(td->td_blocked == NULL); + remrunqueue(td); + setrunqueue(td); return; } /* * If we aren't blocked on a mutex, we should be. */ - KASSERT(p->p_stat == SMTX, ( + KASSERT(td->td_proc->p_stat == SMTX, ( "process %d(%s):%d holds %s but isn't blocked on a mutex\n", - p->p_pid, p->p_comm, p->p_stat, + td->td_proc->p_pid, td->td_proc->p_comm, td->td_proc->p_stat, m->mtx_object.lo_name)); /* - * Pick up the mutex that p is blocked on. + * Pick up the mutex that td is blocked on. */ - m = p->p_blocked; + m = td->td_blocked; MPASS(m != NULL); /* - * Check if the proc needs to be moved up on + * Check if the thread needs to be moved up on * the blocked chain */ - if (p == TAILQ_FIRST(&m->mtx_blocked)) { + if (td == TAILQ_FIRST(&m->mtx_blocked)) { continue; } - p1 = TAILQ_PREV(p, procqueue, p_procq); - if (p1->p_pri.pri_level <= pri) { + td1 = TAILQ_PREV(td, threadqueue, td_blkq); + if (td1->td_ksegrp->kg_pri.pri_level <= pri) { continue; } /* - * Remove proc from blocked chain and determine where - * it should be moved up to. Since we know that p1 has - * a lower priority than p, we know that at least one - * process in the chain has a lower priority and that - * p1 will thus not be NULL after the loop. + * Remove thread from blocked chain and determine where + * it should be moved up to. Since we know that td1 has + * a lower priority than td, we know that at least one + * thread in the chain has a lower priority and that + * td1 will thus not be NULL after the loop. */ - TAILQ_REMOVE(&m->mtx_blocked, p, p_procq); - TAILQ_FOREACH(p1, &m->mtx_blocked, p_procq) { - MPASS(p1->p_magic == P_MAGIC); - if (p1->p_pri.pri_level > pri) + TAILQ_REMOVE(&m->mtx_blocked, td, td_blkq); + TAILQ_FOREACH(td1, &m->mtx_blocked, td_blkq) { + MPASS(td1->td_proc->p_magic == P_MAGIC); + if (td1->td_ksegrp->kg_pri.pri_level > pri) break; } - MPASS(p1 != NULL); - TAILQ_INSERT_BEFORE(p1, p, p_procq); + MPASS(td1 != NULL); + TAILQ_INSERT_BEFORE(td1, td, td_blkq); CTR4(KTR_LOCK, "propagate_priority: p %p moved before %p on [%p] %s", - p, p1, m, m->mtx_object.lo_name); + td, td1, m, m->mtx_object.lo_name); } } @@ -257,7 +262,7 @@ _mtx_trylock(struct mtx *m, int opts, const char *file, int line) { int rval; - MPASS(curproc != NULL); + MPASS(curthread != NULL); /* * _mtx_trylock does not accept MTX_NOSWITCH option. @@ -265,7 +270,7 @@ _mtx_trylock(struct mtx *m, int opts, const char *file, int line) KASSERT((opts & MTX_NOSWITCH) == 0, ("mtx_trylock() called with invalid option flag(s) %d", opts)); - rval = _obtain_lock(m, curproc); + rval = _obtain_lock(m, curthread); LOCK_LOG_TRY("LOCK", &m->mtx_object, opts, rval, file, line); if (rval) { @@ -291,9 +296,10 @@ _mtx_trylock(struct mtx *m, int opts, const char *file, int line) void _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line) { - struct proc *p = curproc; + struct thread *td = curthread; + struct ksegrp *kg = td->td_ksegrp; - if ((m->mtx_lock & MTX_FLAGMASK) == (uintptr_t)p) { + if ((m->mtx_lock & MTX_FLAGMASK) == (uintptr_t)td) { m->mtx_recurse++; atomic_set_ptr(&m->mtx_lock, MTX_RECURSED); if (LOCK_LOG_TEST(&m->mtx_object, opts)) @@ -306,9 +312,9 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line) "_mtx_lock_sleep: %s contested (lock=%p) at %s:%d", m->mtx_object.lo_name, (void *)m->mtx_lock, file, line); - while (!_obtain_lock(m, p)) { + while (!_obtain_lock(m, td)) { uintptr_t v; - struct proc *p1; + struct thread *td1; mtx_lock_spin(&sched_lock); /* @@ -322,15 +328,15 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line) /* * The mutex was marked contested on release. This means that - * there are processes blocked on it. + * there are threads blocked on it. */ if (v == MTX_CONTESTED) { - p1 = TAILQ_FIRST(&m->mtx_blocked); - MPASS(p1 != NULL); - m->mtx_lock = (uintptr_t)p | MTX_CONTESTED; + td1 = TAILQ_FIRST(&m->mtx_blocked); + MPASS(td1 != NULL); + m->mtx_lock = (uintptr_t)td | MTX_CONTESTED; - if (p1->p_pri.pri_level < p->p_pri.pri_level) - SET_PRIO(p, p1->p_pri.pri_level); + if (td1->td_ksegrp->kg_pri.pri_level < kg->kg_pri.pri_level) + SET_PRIO(td, td1->td_ksegrp->kg_pri.pri_level); mtx_unlock_spin(&sched_lock); return; } @@ -357,8 +363,8 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line) * If we're borrowing an interrupted thread's VM context, we * must clean up before going to sleep. */ - if (p->p_ithd != NULL) { - struct ithd *it = p->p_ithd; + if (td->td_ithd != NULL) { + struct ithd *it = td->td_ithd; if (it->it_interrupted) { if (LOCK_LOG_TEST(&m->mtx_object, opts)) @@ -374,39 +380,39 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line) * Put us on the list of threads blocked on this mutex. */ if (TAILQ_EMPTY(&m->mtx_blocked)) { - p1 = (struct proc *)(m->mtx_lock & MTX_FLAGMASK); - LIST_INSERT_HEAD(&p1->p_contested, m, mtx_contested); - TAILQ_INSERT_TAIL(&m->mtx_blocked, p, p_procq); + td1 = (struct thread *)(m->mtx_lock & MTX_FLAGMASK); + LIST_INSERT_HEAD(&td1->td_contested, m, mtx_contested); + TAILQ_INSERT_TAIL(&m->mtx_blocked, td, td_blkq); } else { - TAILQ_FOREACH(p1, &m->mtx_blocked, p_procq) - if (p1->p_pri.pri_level > p->p_pri.pri_level) + TAILQ_FOREACH(td1, &m->mtx_blocked, td_blkq) + if (td1->td_ksegrp->kg_pri.pri_level > kg->kg_pri.pri_level) break; - if (p1) - TAILQ_INSERT_BEFORE(p1, p, p_procq); + if (td1) + TAILQ_INSERT_BEFORE(td1, td, td_blkq); else - TAILQ_INSERT_TAIL(&m->mtx_blocked, p, p_procq); + TAILQ_INSERT_TAIL(&m->mtx_blocked, td, td_blkq); } /* * Save who we're blocked on. */ - p->p_blocked = m; - p->p_mtxname = m->mtx_object.lo_name; - p->p_stat = SMTX; - propagate_priority(p); + td->td_blocked = m; + td->td_mtxname = m->mtx_object.lo_name; + td->td_proc->p_stat = SMTX; + propagate_priority(td); if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR3(KTR_LOCK, - "_mtx_lock_sleep: p %p blocked on [%p] %s", p, m, + "_mtx_lock_sleep: p %p blocked on [%p] %s", td, m, m->mtx_object.lo_name); - p->p_stats->p_ru.ru_nvcsw++; + td->td_proc->p_stats->p_ru.ru_nvcsw++; mi_switch(); if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR3(KTR_LOCK, "_mtx_lock_sleep: p %p free from blocked on [%p] %s", - p, m, m->mtx_object.lo_name); + td, m, m->mtx_object.lo_name); mtx_unlock_spin(&sched_lock); } @@ -430,7 +436,7 @@ _mtx_lock_spin(struct mtx *m, int opts, critical_t mtx_crit, const char *file, CTR1(KTR_LOCK, "_mtx_lock_spin: %p spinning", m); for (;;) { - if (_obtain_lock(m, curproc)) + if (_obtain_lock(m, curthread)) break; /* Give interrupts a chance while we spin. */ @@ -467,11 +473,13 @@ _mtx_lock_spin(struct mtx *m, int opts, critical_t mtx_crit, const char *file, void _mtx_unlock_sleep(struct mtx *m, int opts, const char *file, int line) { - struct proc *p, *p1; + struct thread *td, *td1; struct mtx *m1; int pri; + struct ksegrp *kg; - p = curproc; + td = curthread; + kg = td->td_ksegrp; if (mtx_recursed(m)) { if (--(m->mtx_recurse) == 0) @@ -485,11 +493,11 @@ _mtx_unlock_sleep(struct mtx *m, int opts, const char *file, int line) if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR1(KTR_LOCK, "_mtx_unlock_sleep: %p contested", m); - p1 = TAILQ_FIRST(&m->mtx_blocked); - MPASS(p->p_magic == P_MAGIC); - MPASS(p1->p_magic == P_MAGIC); + td1 = TAILQ_FIRST(&m->mtx_blocked); + MPASS(td->td_proc->p_magic == P_MAGIC); + MPASS(td1->td_proc->p_magic == P_MAGIC); - TAILQ_REMOVE(&m->mtx_blocked, p1, p_procq); + TAILQ_REMOVE(&m->mtx_blocked, td1, td_blkq); if (TAILQ_EMPTY(&m->mtx_blocked)) { LIST_REMOVE(m, mtx_contested); @@ -500,28 +508,28 @@ _mtx_unlock_sleep(struct mtx *m, int opts, const char *file, int line) atomic_store_rel_ptr(&m->mtx_lock, (void *)MTX_CONTESTED); pri = PRI_MAX; - LIST_FOREACH(m1, &p->p_contested, mtx_contested) { - int cp = TAILQ_FIRST(&m1->mtx_blocked)->p_pri.pri_level; + LIST_FOREACH(m1, &td->td_contested, mtx_contested) { + int cp = TAILQ_FIRST(&m1->mtx_blocked)->td_ksegrp->kg_pri.pri_level; if (cp < pri) pri = cp; } - if (pri > p->p_pri.pri_native) - pri = p->p_pri.pri_native; - SET_PRIO(p, pri); + if (pri > kg->kg_pri.pri_native) + pri = kg->kg_pri.pri_native; + SET_PRIO(td, pri); if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR2(KTR_LOCK, "_mtx_unlock_sleep: %p contested setrunqueue %p", - m, p1); + m, td1); - p1->p_blocked = NULL; - p1->p_stat = SRUN; - setrunqueue(p1); + td1->td_blocked = NULL; + td1->td_proc->p_stat = SRUN; + setrunqueue(td1); - if ((opts & MTX_NOSWITCH) == 0 && p1->p_pri.pri_level < pri) { + if ((opts & MTX_NOSWITCH) == 0 && td1->td_ksegrp->kg_pri.pri_level < pri) { #ifdef notyet - if (p->p_ithd != NULL) { - struct ithd *it = p->p_ithd; + if (td->td_ithd != NULL) { + struct ithd *it = td->td_ithd; if (it->it_interrupted) { if (LOCK_LOG_TEST(&m->mtx_object, opts)) @@ -532,13 +540,13 @@ _mtx_unlock_sleep(struct mtx *m, int opts, const char *file, int line) } } #endif - setrunqueue(p); + setrunqueue(td); if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR2(KTR_LOCK, "_mtx_unlock_sleep: %p switching out lock=%p", m, (void *)m->mtx_lock); - p->p_stats->p_ru.ru_nivcsw++; + td->td_proc->p_stats->p_ru.ru_nivcsw++; mi_switch(); if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR2(KTR_LOCK, "_mtx_unlock_sleep: %p resuming lock=%p", diff --git a/sys/kern/kern_ntptime.c b/sys/kern/kern_ntptime.c index 3d689db..4701d2f 100644 --- a/sys/kern/kern_ntptime.c +++ b/sys/kern/kern_ntptime.c @@ -276,7 +276,7 @@ struct ntp_adjtime_args { * MPSAFE */ int -ntp_adjtime(struct proc *p, struct ntp_adjtime_args *uap) +ntp_adjtime(struct thread *td, struct ntp_adjtime_args *uap) { struct timex ntv; /* temporary structure */ long freq; /* frequency ns/s) */ @@ -300,7 +300,7 @@ ntp_adjtime(struct proc *p, struct ntp_adjtime_args *uap) mtx_lock(&Giant); modes = ntv.modes; if (modes) - error = suser(p); + error = suser_td(td); if (error) goto done2; s = splclock(); @@ -416,9 +416,9 @@ ntp_adjtime(struct proc *p, struct ntp_adjtime_args *uap) time_status & STA_PPSJITTER) || (time_status & STA_PPSFREQ && time_status & (STA_PPSWANDER | STA_PPSERROR))) { - p->p_retval[0] = TIME_ERROR; + td->td_retval[0] = TIME_ERROR; } else { - p->p_retval[0] = time_state; + td->td_retval[0] = time_state; } done2: mtx_unlock(&Giant); diff --git a/sys/kern/kern_proc.c b/sys/kern/kern_proc.c index 858b37a..5b0e960 100644 --- a/sys/kern/kern_proc.c +++ b/sys/kern/kern_proc.c @@ -115,6 +115,72 @@ procinit() } /* + * link up a process structure and it's inbuilt threads etc. + */ +void +proc_linkup(struct proc *p) +{ + struct thread *td; + + td = &p->p_thread; + + /**** lists headed in the proc structure ****/ + /* ALL KSEGRPs in this process */ + TAILQ_INIT( &p->p_ksegrps); /* all ksegrps in proc */ + TAILQ_INSERT_HEAD(&p->p_ksegrps, &p->p_ksegrp, kg_ksegrp); + + /* All threads in this process (an optimisation) */ + TAILQ_INIT( &p->p_threads); /* all threads in proc */ + TAILQ_INSERT_HEAD(&p->p_threads, &p->p_thread, td_plist); + + /**** Lists headed in the KSEGROUP structure ****/ + /* all thread in this ksegroup */ + TAILQ_INIT( &p->p_ksegrp.kg_threads); + TAILQ_INSERT_HEAD(&p->p_ksegrp.kg_threads, &p->p_thread, td_kglist); + + /* All runnable threads not assigned to a particular KSE */ + /* XXXKSE THIS MAY GO AWAY.. KSEs are never unassigned */ + TAILQ_INIT( &p->p_ksegrp.kg_runq); /* links with td_runq */ + + /* All threads presently not runnable (Thread starts this way) */ + TAILQ_INIT( &p->p_ksegrp.kg_slpq); /* links with td_runq */ + TAILQ_INSERT_HEAD(&p->p_ksegrp.kg_slpq, &p->p_thread, td_runq); + /*p->p_thread.td_flags &= ~TDF_ONRUNQ;*/ + + /* all KSEs in this ksegroup */ + TAILQ_INIT( &p->p_ksegrp.kg_kseq); /* all kses in ksegrp */ + TAILQ_INSERT_HEAD(&p->p_ksegrp.kg_kseq, &p->p_kse, ke_kglist); + + /* KSE starts out idle *//* XXXKSE */ + TAILQ_INIT( &p->p_ksegrp.kg_rq); /* all kses in ksegrp */ + TAILQ_INIT( &p->p_ksegrp.kg_iq); /* all kses in ksegrp */ +#if 0 + TAILQ_INSERT_HEAD(&p->p_ksegrp.kg_iq, &p->p_kse, ke_kgrlist); +#endif /* is running, not idle */ + /*p->p_kse.ke_flags &= &KEF_ONRUNQ;*/ + + /**** Lists headed in the KSE structure ****/ + /* runnable threads assigned to this kse */ + TAILQ_INIT( &p->p_kse.ke_runq); /* links with td_runq */ + + p->p_thread.td_proc = p; + p->p_kse.ke_proc = p; + p->p_ksegrp.kg_proc = p; + + p->p_thread.td_ksegrp = &p->p_ksegrp; + p->p_kse.ke_ksegrp = &p->p_ksegrp; + + p->p_thread.td_last_kse = &p->p_kse; + p->p_thread.td_kse = &p->p_kse; + + p->p_kse.ke_thread = &p->p_thread; + + p->p_ksegrp.kg_runnable = 1; + p->p_ksegrp.kg_kses = 1; + p->p_ksegrp.kg_runq_kses = 1; /* XXXKSE change name */ +} + +/* * Is p an inferior of the current process? */ int @@ -410,6 +476,7 @@ fill_kinfo_proc(p, kp) struct proc *p; struct kinfo_proc *kp; { + struct thread *td; struct tty *tp; struct session *sp; @@ -418,7 +485,7 @@ fill_kinfo_proc(p, kp) kp->ki_structsize = sizeof(*kp); kp->ki_paddr = p; PROC_LOCK(p); - kp->ki_addr = p->p_addr; + kp->ki_addr =/* p->p_addr; */0; /* XXXKSE */ kp->ki_args = p->p_args; kp->ki_tracep = p->p_tracep; kp->ki_textvp = p->p_textvp; @@ -446,7 +513,9 @@ fill_kinfo_proc(p, kp) kp->ki_size = vm->vm_map.size; kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/ if (p->p_sflag & PS_INMEM) - kp->ki_rssize += UPAGES; + kp->ki_rssize += UAREA_PAGES; + FOREACH_THREAD_IN_PROC(p, td) /* XXXKSE: thread swapout check */ + kp->ki_rssize += KSTACK_PAGES; kp->ki_swrss = vm->vm_swrss; kp->ki_tsize = vm->vm_tsize; kp->ki_dsize = vm->vm_dsize; @@ -460,28 +529,33 @@ fill_kinfo_proc(p, kp) kp->ki_childtime.tv_usec = p->p_stats->p_cru.ru_utime.tv_usec + p->p_stats->p_cru.ru_stime.tv_usec; } - if (p->p_wmesg != NULL) - strncpy(kp->ki_wmesg, p->p_wmesg, sizeof(kp->ki_wmesg) - 1); + if (p->p_thread.td_wmesg != NULL) + strncpy(kp->ki_wmesg, p->p_thread.td_wmesg, sizeof(kp->ki_wmesg) - 1); if (p->p_stat == SMTX) { kp->ki_kiflag |= KI_MTXBLOCK; - strncpy(kp->ki_mtxname, p->p_mtxname, + strncpy(kp->ki_mtxname, p->p_thread.td_mtxname, sizeof(kp->ki_mtxname) - 1); } kp->ki_stat = p->p_stat; kp->ki_sflag = p->p_sflag; - kp->ki_pctcpu = p->p_pctcpu; - kp->ki_estcpu = p->p_estcpu; - kp->ki_slptime = p->p_slptime; kp->ki_swtime = p->p_swtime; - kp->ki_wchan = p->p_wchan; kp->ki_traceflag = p->p_traceflag; - kp->ki_pri = p->p_pri; - kp->ki_nice = p->p_nice; - kp->ki_runtime = p->p_runtime; kp->ki_pid = p->p_pid; - kp->ki_rqindex = p->p_rqindex; - kp->ki_oncpu = p->p_oncpu; - kp->ki_lastcpu = p->p_lastcpu; + /* vvv XXXKSE */ + kp->ki_runtime = p->p_runtime; + kp->ki_pctcpu = p->p_kse.ke_pctcpu; + kp->ki_estcpu = p->p_ksegrp.kg_estcpu; + kp->ki_slptime = p->p_ksegrp.kg_slptime; + kp->ki_wchan = p->p_thread.td_wchan; + kp->ki_pri = p->p_ksegrp.kg_pri; + kp->ki_nice = p->p_ksegrp.kg_nice; + kp->ki_rqindex = p->p_kse.ke_rqindex; + kp->ki_oncpu = p->p_kse.ke_oncpu; + kp->ki_lastcpu = p->p_thread.td_lastcpu; + kp->ki_tdflags = p->p_thread.td_flags; + kp->ki_pcb = p->p_thread.td_pcb; + kp->ki_kstack = (void *)p->p_thread.td_kstack; + /* ^^^ XXXKSE */ mtx_unlock_spin(&sched_lock); sp = NULL; if (p->p_pgrp) { diff --git a/sys/kern/kern_prot.c b/sys/kern/kern_prot.c index baa73dd..0c2939c 100644 --- a/sys/kern/kern_prot.c +++ b/sys/kern/kern_prot.c @@ -81,16 +81,17 @@ struct getpid_args { */ /* ARGSUSED */ int -getpid(p, uap) - struct proc *p; +getpid(td, uap) + struct thread *td; struct getpid_args *uap; { + struct proc *p = td->td_proc; mtx_lock(&Giant); - p->p_retval[0] = p->p_pid; + td->td_retval[0] = p->p_pid; #if defined(COMPAT_43) || defined(COMPAT_SUNOS) PROC_LOCK(p); - p->p_retval[1] = p->p_pptr->p_pid; + td->td_retval[1] = p->p_pptr->p_pid; PROC_UNLOCK(p); #endif mtx_unlock(&Giant); @@ -111,14 +112,15 @@ struct getppid_args { */ /* ARGSUSED */ int -getppid(p, uap) - struct proc *p; +getppid(td, uap) + struct thread *td; struct getppid_args *uap; { + struct proc *p = td->td_proc; mtx_lock(&Giant); PROC_LOCK(p); - p->p_retval[0] = p->p_pptr->p_pid; + td->td_retval[0] = p->p_pptr->p_pid; PROC_UNLOCK(p); mtx_unlock(&Giant); return (0); @@ -138,13 +140,14 @@ struct getpgrp_args { * MPSAFE */ int -getpgrp(p, uap) - struct proc *p; +getpgrp(td, uap) + struct thread *td; struct getpgrp_args *uap; { + struct proc *p = td->td_proc; mtx_lock(&Giant); - p->p_retval[0] = p->p_pgrp->pg_id; + td->td_retval[0] = p->p_pgrp->pg_id; mtx_unlock(&Giant); return (0); } @@ -160,16 +163,17 @@ struct getpgid_args { * MPSAFE */ int -getpgid(p, uap) - struct proc *p; +getpgid(td, uap) + struct thread *td; struct getpgid_args *uap; { + struct proc *p = td->td_proc; struct proc *pt; int error = 0; mtx_lock(&Giant); if (uap->pid == 0) - p->p_retval[0] = p->p_pgrp->pg_id; + td->td_retval[0] = p->p_pgrp->pg_id; else { if ((pt = pfind(uap->pid)) == NULL) { error = ESRCH; @@ -179,7 +183,7 @@ getpgid(p, uap) PROC_UNLOCK(pt); goto done2; } - p->p_retval[0] = pt->p_pgrp->pg_id; + td->td_retval[0] = pt->p_pgrp->pg_id; PROC_UNLOCK(pt); } done2: @@ -200,16 +204,17 @@ struct getsid_args { * MPSAFE */ int -getsid(p, uap) - struct proc *p; +getsid(td, uap) + struct thread *td; struct getsid_args *uap; { + struct proc *p = td->td_proc; struct proc *pt; int error = 0; mtx_lock(&Giant); if (uap->pid == 0) { - p->p_retval[0] = p->p_session->s_sid; + td->td_retval[0] = p->p_session->s_sid; } else { if ((pt = pfind(uap->pid)) == NULL) { error = ESRCH; @@ -219,7 +224,7 @@ getsid(p, uap) PROC_UNLOCK(pt); goto done2; } - p->p_retval[0] = pt->p_session->s_sid; + td->td_retval[0] = pt->p_session->s_sid; PROC_UNLOCK(pt); } done2: @@ -242,15 +247,16 @@ struct getuid_args { */ /* ARGSUSED */ int -getuid(p, uap) - struct proc *p; +getuid(td, uap) + struct thread *td; struct getuid_args *uap; { + struct proc *p = td->td_proc; mtx_lock(&Giant); - p->p_retval[0] = p->p_ucred->cr_ruid; + td->td_retval[0] = p->p_ucred->cr_ruid; #if defined(COMPAT_43) || defined(COMPAT_SUNOS) - p->p_retval[1] = p->p_ucred->cr_uid; + td->td_retval[1] = p->p_ucred->cr_uid; #endif mtx_unlock(&Giant); return (0); @@ -267,13 +273,12 @@ struct geteuid_args { /* ARGSUSED */ int -geteuid(p, uap) - struct proc *p; +geteuid(td, uap) + struct thread *td; struct geteuid_args *uap; { - mtx_lock(&Giant); - p->p_retval[0] = p->p_ucred->cr_uid; + td->td_retval[0] = td->td_proc->p_ucred->cr_uid; mtx_unlock(&Giant); return (0); } @@ -292,15 +297,16 @@ struct getgid_args { */ /* ARGSUSED */ int -getgid(p, uap) - struct proc *p; +getgid(td, uap) + struct thread *td; struct getgid_args *uap; { + struct proc *p = td->td_proc; mtx_lock(&Giant); - p->p_retval[0] = p->p_ucred->cr_rgid; + td->td_retval[0] = p->p_ucred->cr_rgid; #if defined(COMPAT_43) || defined(COMPAT_SUNOS) - p->p_retval[1] = p->p_ucred->cr_groups[0]; + td->td_retval[1] = p->p_ucred->cr_groups[0]; #endif mtx_unlock(&Giant); return (0); @@ -322,13 +328,14 @@ struct getegid_args { */ /* ARGSUSED */ int -getegid(p, uap) - struct proc *p; +getegid(td, uap) + struct thread *td; struct getegid_args *uap; { + struct proc *p = td->td_proc; mtx_lock(&Giant); - p->p_retval[0] = p->p_ucred->cr_groups[0]; + td->td_retval[0] = p->p_ucred->cr_groups[0]; mtx_unlock(&Giant); return (0); } @@ -343,18 +350,19 @@ struct getgroups_args { * MPSAFE */ int -getgroups(p, uap) - struct proc *p; +getgroups(td, uap) + struct thread *td; register struct getgroups_args *uap; { struct ucred *cred; + struct proc *p = td->td_proc; u_int ngrp; int error = 0; mtx_lock(&Giant); cred = p->p_ucred; if ((ngrp = uap->gidsetsize) == 0) { - p->p_retval[0] = cred->cr_ngroups; + td->td_retval[0] = cred->cr_ngroups; error = 0; goto done2; } @@ -367,7 +375,7 @@ getgroups(p, uap) (caddr_t)uap->gidset, ngrp * sizeof(gid_t)))) { goto done2; } - p->p_retval[0] = ngrp; + td->td_retval[0] = ngrp; done2: mtx_unlock(&Giant); return (error); @@ -384,18 +392,19 @@ struct setsid_args { */ /* ARGSUSED */ int -setsid(p, uap) - register struct proc *p; +setsid(td, uap) + register struct thread *td; struct setsid_args *uap; { int error; + struct proc *p = td->td_proc; mtx_lock(&Giant); if (p->p_pgid == p->p_pid || pgfind(p->p_pid)) { error = EPERM; } else { (void)enterpgrp(p, p->p_pid, 1); - p->p_retval[0] = p->p_pid; + td->td_retval[0] = p->p_pid; error = 0; } mtx_unlock(&Giant); @@ -426,10 +435,11 @@ struct setpgid_args { */ /* ARGSUSED */ int -setpgid(curp, uap) - struct proc *curp; +setpgid(td, uap) + struct thread *td; register struct setpgid_args *uap; { + struct proc *curp = td->td_proc; register struct proc *targp; /* target process */ register struct pgrp *pgrp; /* target pgrp */ int error; @@ -510,10 +520,11 @@ struct setuid_args { */ /* ARGSUSED */ int -setuid(p, uap) - struct proc *p; +setuid(td, uap) + struct thread *td; struct setuid_args *uap; { + struct proc *p = td->td_proc; struct ucred *newcred, *oldcred; uid_t uid; int error = 0; @@ -607,10 +618,11 @@ struct seteuid_args { */ /* ARGSUSED */ int -seteuid(p, uap) - struct proc *p; +seteuid(td, uap) + struct thread *td; struct seteuid_args *uap; { + struct proc *p = td->td_proc; struct ucred *newcred, *oldcred; uid_t euid; int error = 0; @@ -650,10 +662,11 @@ struct setgid_args { */ /* ARGSUSED */ int -setgid(p, uap) - struct proc *p; +setgid(td, uap) + struct thread *td; struct setgid_args *uap; { + struct proc *p = td->td_proc; struct ucred *newcred, *oldcred; gid_t gid; int error = 0; @@ -741,10 +754,11 @@ struct setegid_args { */ /* ARGSUSED */ int -setegid(p, uap) - struct proc *p; +setegid(td, uap) + struct thread *td; struct setegid_args *uap; { + struct proc *p = td->td_proc; struct ucred *newcred, *oldcred; gid_t egid; int error = 0; @@ -781,10 +795,11 @@ struct setgroups_args { */ /* ARGSUSED */ int -setgroups(p, uap) - struct proc *p; +setgroups(td, uap) + struct thread *td; struct setgroups_args *uap; { + struct proc *p = td->td_proc; struct ucred *newcred, *oldcred; u_int ngrp; int error; @@ -839,10 +854,11 @@ struct setreuid_args { */ /* ARGSUSED */ int -setreuid(p, uap) - register struct proc *p; +setreuid(td, uap) + register struct thread *td; struct setreuid_args *uap; { + struct proc *p = td->td_proc; struct ucred *newcred, *oldcred; uid_t ruid, euid; int error = 0; @@ -892,10 +908,11 @@ struct setregid_args { */ /* ARGSUSED */ int -setregid(p, uap) - register struct proc *p; +setregid(td, uap) + register struct thread *td; struct setregid_args *uap; { + struct proc *p = td->td_proc; struct ucred *newcred, *oldcred; gid_t rgid, egid; int error = 0; @@ -952,10 +969,11 @@ struct setresuid_args { */ /* ARGSUSED */ int -setresuid(p, uap) - register struct proc *p; +setresuid(td, uap) + register struct thread *td; struct setresuid_args *uap; { + struct proc *p = td->td_proc; struct ucred *newcred, *oldcred; uid_t ruid, euid, suid; int error; @@ -1017,10 +1035,11 @@ struct setresgid_args { */ /* ARGSUSED */ int -setresgid(p, uap) - register struct proc *p; +setresgid(td, uap) + register struct thread *td; struct setresgid_args *uap; { + struct proc *p = td->td_proc; struct ucred *newcred, *oldcred; gid_t rgid, egid, sgid; int error; @@ -1076,11 +1095,12 @@ struct getresuid_args { */ /* ARGSUSED */ int -getresuid(p, uap) - register struct proc *p; +getresuid(td, uap) + register struct thread *td; struct getresuid_args *uap; { struct ucred *cred; + struct proc *p = td->td_proc; int error1 = 0, error2 = 0, error3 = 0; mtx_lock(&Giant); @@ -1111,11 +1131,12 @@ struct getresgid_args { */ /* ARGSUSED */ int -getresgid(p, uap) - register struct proc *p; +getresgid(td, uap) + register struct thread *td; struct getresgid_args *uap; { struct ucred *cred; + struct proc *p = td->td_proc; int error1 = 0, error2 = 0, error3 = 0; mtx_lock(&Giant); @@ -1142,10 +1163,12 @@ struct issetugid_args { #endif /* ARGSUSED */ int -issetugid(p, uap) - register struct proc *p; +issetugid(td, uap) + register struct thread *td; struct issetugid_args *uap; { + struct proc *p = td->td_proc; + /* * Note: OpenBSD sets a P_SUGIDEXEC flag set at execve() time, * we use P_SUGID because we consider changing the owners as @@ -1154,7 +1177,7 @@ issetugid(p, uap) * a user without an exec - programs cannot know *everything* * that libc *might* have put in their data segment. */ - p->p_retval[0] = (p->p_flag & P_SUGID) ? 1 : 0; + td->td_retval[0] = (p->p_flag & P_SUGID) ? 1 : 0; return (0); } @@ -1162,8 +1185,8 @@ issetugid(p, uap) * MPSAFE */ int -__setugid(p, uap) - struct proc *p; +__setugid(td, uap) + struct thread *td; struct __setugid_args *uap; { #ifdef REGRESSION @@ -1172,10 +1195,10 @@ __setugid(p, uap) mtx_lock(&Giant); switch (uap->flag) { case 0: - p->p_flag &= ~P_SUGID; + td->td_proc->p_flag &= ~P_SUGID; break; case 1: - p->p_flag |= P_SUGID; + td->td_proc->p_flag |= P_SUGID; break; default: error = EINVAL; @@ -1231,6 +1254,30 @@ suser(p) return suser_xxx(0, p, 0); } +/* + * version for when the thread pointer is available and not the proc. + * (saves having to include proc.h into every file that needs to do the change.) + */ +int +suser_td(td) + + struct thread *td; +{ + return suser_xxx(0, td->td_proc, 0); +} + +/* + * wrapper to use if you have the thread on hand but not the proc. + */ +int +suser_xxx_td(cred, td, flag) + struct ucred *cred; + struct thread *td; + int flag; +{ + return(suser_xxx(cred, td->td_proc, flag)); +} + int suser_xxx(cred, proc, flag) struct ucred *cred; @@ -1566,11 +1613,12 @@ struct getlogin_args { */ /* ARGSUSED */ int -getlogin(p, uap) - struct proc *p; +getlogin(td, uap) + struct thread *td; struct getlogin_args *uap; { int error; + struct proc *p = td->td_proc; mtx_lock(&Giant); if (uap->namelen > MAXLOGNAME) @@ -1594,10 +1642,11 @@ struct setlogin_args { */ /* ARGSUSED */ int -setlogin(p, uap) - struct proc *p; +setlogin(td, uap) + struct thread *td; struct setlogin_args *uap; { + struct proc *p = td->td_proc; int error; char logintmp[MAXLOGNAME]; diff --git a/sys/kern/kern_resource.c b/sys/kern/kern_resource.c index 3b65ace..093e4c2 100644 --- a/sys/kern/kern_resource.c +++ b/sys/kern/kern_resource.c @@ -84,10 +84,11 @@ struct getpriority_args { * MPSAFE */ int -getpriority(curp, uap) - struct proc *curp; +getpriority(td, uap) + struct thread *td; register struct getpriority_args *uap; { + struct proc *curp = td->td_proc; register struct proc *p; register int low = PRIO_MAX + 1; int error = 0; @@ -97,13 +98,13 @@ getpriority(curp, uap) switch (uap->which) { case PRIO_PROCESS: if (uap->who == 0) - low = curp->p_nice; + low = td->td_ksegrp->kg_nice; else { p = pfind(uap->who); if (p == NULL) break; if (p_cansee(curp, p) == 0) - low = p->p_nice; + low = p->p_ksegrp.kg_nice /* XXXKSE */ ; PROC_UNLOCK(p); } break; @@ -116,8 +117,8 @@ getpriority(curp, uap) else if ((pg = pgfind(uap->who)) == NULL) break; LIST_FOREACH(p, &pg->pg_members, p_pglist) { - if (!p_cansee(curp, p) && p->p_nice < low) - low = p->p_nice; + if (!p_cansee(curp, p) && p->p_ksegrp.kg_nice /* XXXKSE */ < low) + low = p->p_ksegrp.kg_nice /* XXXKSE */ ; } break; } @@ -129,8 +130,8 @@ getpriority(curp, uap) LIST_FOREACH(p, &allproc, p_list) if (!p_cansee(curp, p) && p->p_ucred->cr_uid == uap->who && - p->p_nice < low) - low = p->p_nice; + p->p_ksegrp.kg_nice /* XXXKSE */ < low) + low = p->p_ksegrp.kg_nice /* XXXKSE */ ; sx_sunlock(&allproc_lock); break; @@ -140,7 +141,7 @@ getpriority(curp, uap) } if (low == PRIO_MAX + 1 && error == 0) error = ESRCH; - curp->p_retval[0] = low; + td->td_retval[0] = low; mtx_unlock(&Giant); return (error); } @@ -157,10 +158,11 @@ struct setpriority_args { */ /* ARGSUSED */ int -setpriority(curp, uap) - struct proc *curp; +setpriority(td, uap) + struct thread *td; register struct setpriority_args *uap; { + struct proc *curp = td->td_proc; register struct proc *p; int found = 0, error = 0; @@ -201,12 +203,13 @@ setpriority(curp, uap) if (uap->who == 0) uap->who = curp->p_ucred->cr_uid; sx_slock(&allproc_lock); - LIST_FOREACH(p, &allproc, p_list) + FOREACH_PROC_IN_SYSTEM(p) { if (p->p_ucred->cr_uid == uap->who && !p_cansee(curp, p)) { error = donice(curp, p, uap->prio); found++; } + } sx_sunlock(&allproc_lock); break; @@ -233,10 +236,10 @@ donice(curp, chgp, n) n = PRIO_MAX; if (n < PRIO_MIN) n = PRIO_MIN; - if (n < chgp->p_nice && suser(curp)) + if (n < chgp->p_ksegrp.kg_nice /* XXXKSE */ && suser(curp)) return (EACCES); - chgp->p_nice = n; - (void)resetpriority(chgp); + chgp->p_ksegrp.kg_nice /* XXXKSE */ = n; + (void)resetpriority(&chgp->p_ksegrp); /* XXXKSE */ return (0); } @@ -258,10 +261,11 @@ struct rtprio_args { */ /* ARGSUSED */ int -rtprio(curp, uap) - struct proc *curp; +rtprio(td, uap) + struct thread *td; register struct rtprio_args *uap; { + struct proc *curp = td->td_proc; register struct proc *p; struct rtprio rtp; int error; @@ -285,7 +289,7 @@ rtprio(curp, uap) if ((error = p_cansee(curp, p))) break; mtx_lock_spin(&sched_lock); - pri_to_rtp(&p->p_pri, &rtp); + pri_to_rtp(&p->p_ksegrp.kg_pri /* XXXKSE */ , &rtp); mtx_unlock_spin(&sched_lock); error = copyout(&rtp, uap->rtp, sizeof(struct rtprio)); break; @@ -317,7 +321,7 @@ rtprio(curp, uap) } } mtx_lock_spin(&sched_lock); - error = rtp_to_pri(&rtp, &p->p_pri); + error = rtp_to_pri(&rtp, &p->p_ksegrp.kg_pri); mtx_unlock_spin(&sched_lock); break; default: @@ -387,8 +391,8 @@ struct osetrlimit_args { */ /* ARGSUSED */ int -osetrlimit(p, uap) - struct proc *p; +osetrlimit(td, uap) + struct thread *td; register struct osetrlimit_args *uap; { struct orlimit olim; @@ -401,7 +405,7 @@ osetrlimit(p, uap) lim.rlim_cur = olim.rlim_cur; lim.rlim_max = olim.rlim_max; mtx_lock(&Giant); - error = dosetrlimit(p, uap->which, &lim); + error = dosetrlimit(td, uap->which, &lim); mtx_unlock(&Giant); return (error); } @@ -417,10 +421,11 @@ struct ogetrlimit_args { */ /* ARGSUSED */ int -ogetrlimit(p, uap) - struct proc *p; +ogetrlimit(td, uap) + struct thread *td; register struct ogetrlimit_args *uap; { + struct proc *p = td->td_proc; struct orlimit olim; int error; @@ -450,8 +455,8 @@ struct __setrlimit_args { */ /* ARGSUSED */ int -setrlimit(p, uap) - struct proc *p; +setrlimit(td, uap) + struct thread *td; register struct __setrlimit_args *uap; { struct rlimit alim; @@ -461,17 +466,18 @@ setrlimit(p, uap) copyin((caddr_t)uap->rlp, (caddr_t)&alim, sizeof (struct rlimit)))) return (error); mtx_lock(&Giant); - error = dosetrlimit(p, uap->which, &alim); + error = dosetrlimit(td, uap->which, &alim); mtx_unlock(&Giant); return (error); } int -dosetrlimit(p, which, limp) - struct proc *p; +dosetrlimit(td, which, limp) + struct thread *td; u_int which; struct rlimit *limp; { + struct proc *p = td->td_proc; register struct rlimit *alimp; int error; @@ -582,11 +588,12 @@ struct __getrlimit_args { */ /* ARGSUSED */ int -getrlimit(p, uap) - struct proc *p; +getrlimit(td, uap) + struct thread *td; register struct __getrlimit_args *uap; { int error; + struct proc *p = td->td_proc; if (uap->which >= RLIM_NLIMITS) return (EINVAL); @@ -610,85 +617,102 @@ calcru(p, up, sp, ip) { /* {user, system, interrupt, total} {ticks, usec}; previous tu: */ u_int64_t ut, uu, st, su, it, iu, tt, tu, ptu; + u_int64_t uut = 0, sut = 0, iut = 0; int s; struct timeval tv; + struct kse *ke; + struct ksegrp *kg; mtx_assert(&sched_lock, MA_OWNED); /* XXX: why spl-protect ? worst case is an off-by-one report */ - s = splstatclock(); - ut = p->p_uticks; - st = p->p_sticks; - it = p->p_iticks; - splx(s); - tt = ut + st + it; - if (tt == 0) { - st = 1; - tt = 1; - } - - tu = p->p_runtime; - if (p == curproc) { + FOREACH_KSEGRP_IN_PROC(p, kg) { + /* we could accumulate per ksegrp and per process here*/ + FOREACH_KSE_IN_GROUP(kg, ke) { + s = splstatclock(); + ut = ke->ke_uticks; + st = ke->ke_sticks; + it = ke->ke_iticks; + splx(s); + + tt = ut + st + it; + if (tt == 0) { + st = 1; + tt = 1; + } + + tu = p->p_runtime; + if (ke == curthread->td_kse) { /* * Adjust for the current time slice. This is actually fairly * important since the error here is on the order of a time * quantum, which is much greater than the sampling error. + * XXXKSE use a different test due to threads on other + * processors also being 'current'. */ - microuptime(&tv); - if (timevalcmp(&tv, PCPU_PTR(switchtime), <)) - printf("microuptime() went backwards (%ld.%06ld -> %ld.%06ld)\n", - PCPU_GET(switchtime.tv_sec), PCPU_GET(switchtime.tv_usec), - tv.tv_sec, tv.tv_usec); - else - tu += (tv.tv_usec - PCPU_GET(switchtime.tv_usec)) + - (tv.tv_sec - PCPU_GET(switchtime.tv_sec)) * - (int64_t)1000000; - } - ptu = p->p_uu + p->p_su + p->p_iu; - if (tu < ptu || (int64_t)tu < 0) { - /* XXX no %qd in kernel. Truncate. */ - printf("calcru: negative time of %ld usec for pid %d (%s)\n", - (long)tu, p->p_pid, p->p_comm); - tu = ptu; - } + microuptime(&tv); + if (timevalcmp(&tv, PCPU_PTR(switchtime), <)) + printf("microuptime() went backwards (%ld.%06ld -> %ld.%06ld)\n", + PCPU_GET(switchtime.tv_sec), + PCPU_GET(switchtime.tv_usec), + tv.tv_sec, tv.tv_usec); + else + tu += (tv.tv_usec + - PCPU_GET(switchtime.tv_usec)) + + (tv.tv_sec + - PCPU_GET(switchtime.tv_sec)) + * (int64_t)1000000; + } + ptu = ke->ke_uu + ke->ke_su + ke->ke_iu; + if (tu < ptu || (int64_t)tu < 0) { + /* XXX no %qd in kernel. Truncate. */ + printf("calcru: negative time of %ld usec for pid %d (%s)\n", + (long)tu, p->p_pid, p->p_comm); + tu = ptu; + } - /* Subdivide tu. */ - uu = (tu * ut) / tt; - su = (tu * st) / tt; - iu = tu - uu - su; - - /* Enforce monotonicity. */ - if (uu < p->p_uu || su < p->p_su || iu < p->p_iu) { - if (uu < p->p_uu) - uu = p->p_uu; - else if (uu + p->p_su + p->p_iu > tu) - uu = tu - p->p_su - p->p_iu; - if (st == 0) - su = p->p_su; - else { - su = ((tu - uu) * st) / (st + it); - if (su < p->p_su) - su = p->p_su; - else if (uu + su + p->p_iu > tu) - su = tu - uu - p->p_iu; - } - KASSERT(uu + su + p->p_iu <= tu, - ("calcru: monotonisation botch 1")); - iu = tu - uu - su; - KASSERT(iu >= p->p_iu, - ("calcru: monotonisation botch 2")); - } - p->p_uu = uu; - p->p_su = su; - p->p_iu = iu; - - up->tv_sec = uu / 1000000; - up->tv_usec = uu % 1000000; - sp->tv_sec = su / 1000000; - sp->tv_usec = su % 1000000; + /* Subdivide tu. */ + uu = (tu * ut) / tt; + su = (tu * st) / tt; + iu = tu - uu - su; + + /* Enforce monotonicity. */ + if (uu < ke->ke_uu || su < ke->ke_su || iu < ke->ke_iu) { + if (uu < ke->ke_uu) + uu = ke->ke_uu; + else if (uu + ke->ke_su + ke->ke_iu > tu) + uu = tu - ke->ke_su - ke->ke_iu; + if (st == 0) + su = ke->ke_su; + else { + su = ((tu - uu) * st) / (st + it); + if (su < ke->ke_su) + su = ke->ke_su; + else if (uu + su + ke->ke_iu > tu) + su = tu - uu - ke->ke_iu; + } + KASSERT(uu + su + ke->ke_iu <= tu, + ("calcru: monotonisation botch 1")); + iu = tu - uu - su; + KASSERT(iu >= ke->ke_iu, + ("calcru: monotonisation botch 2")); + } + ke->ke_uu = uu; + ke->ke_su = su; + ke->ke_iu = iu; + uut += uu; + sut += su; + iut += iu; + + } /* end kse loop */ + } /* end kseg loop */ + up->tv_sec = uut / 1000000; + up->tv_usec = uut % 1000000; + sp->tv_sec = sut / 1000000; + sp->tv_usec = sut % 1000000; if (ip != NULL) { - ip->tv_sec = iu / 1000000; - ip->tv_usec = iu % 1000000; + ip->tv_sec = iut / 1000000; + ip->tv_usec = iut % 1000000; } } @@ -703,10 +727,11 @@ struct getrusage_args { */ /* ARGSUSED */ int -getrusage(p, uap) - register struct proc *p; +getrusage(td, uap) + register struct thread *td; register struct getrusage_args *uap; { + struct proc *p = td->td_proc; register struct rusage *rup; int error = 0; diff --git a/sys/kern/kern_shutdown.c b/sys/kern/kern_shutdown.c index 4dd9c62..61efa8d 100644 --- a/sys/kern/kern_shutdown.c +++ b/sys/kern/kern_shutdown.c @@ -138,12 +138,12 @@ SYSINIT(shutdown_conf, SI_SUB_INTRINSIC, SI_ORDER_ANY, shutdown_conf, NULL) */ /* ARGSUSED */ int -reboot(struct proc *p, struct reboot_args *uap) +reboot(struct thread *td, struct reboot_args *uap) { int error; mtx_lock(&Giant); - if ((error = suser(p)) == 0) + if ((error = suser_td(td)) == 0) boot(uap->opt); mtx_unlock(&Giant); return (error); @@ -237,7 +237,7 @@ boot(int howto) waittime = 0; printf("\nsyncing disks... "); - sync(&proc0, NULL); + sync(thread0, NULL); /* * With soft updates, some buffers that are @@ -262,13 +262,13 @@ boot(int howto) if (nbusy < pbusy) iter = 0; pbusy = nbusy; - sync(&proc0, NULL); - if (curproc != NULL) { + sync(thread0, NULL); + if (curthread != NULL) { DROP_GIANT_NOSWITCH(); for (subiter = 0; subiter < 50 * iter; subiter++) { mtx_lock_spin(&sched_lock); - setrunqueue(curproc); - curproc->p_stats->p_ru.ru_nvcsw++; + setrunqueue(curthread); + curthread->td_proc->p_stats->p_ru.ru_nvcsw++; mi_switch(); /* Allow interrupt threads to run */ mtx_unlock_spin(&sched_lock); DELAY(1000); diff --git a/sys/kern/kern_sig.c b/sys/kern/kern_sig.c index 607c78c..233bdbe 100644 --- a/sys/kern/kern_sig.c +++ b/sys/kern/kern_sig.c @@ -74,7 +74,7 @@ #define ONSIG 32 /* NSIG for osig* syscalls. XXX. */ -static int coredump __P((struct proc *)); +static int coredump __P((struct thread *)); static int do_sigaction __P((struct proc *p, int sig, struct sigaction *act, struct sigaction *oact, int old)); static int do_sigprocmask __P((struct proc *p, int how, sigset_t *set, @@ -351,10 +351,11 @@ struct sigaction_args { */ /* ARGSUSED */ int -sigaction(p, uap) - struct proc *p; +sigaction(td, uap) + struct thread *td; register struct sigaction_args *uap; { + struct proc *p = td->td_proc; struct sigaction act, oact; register struct sigaction *actp, *oactp; int error; @@ -390,10 +391,11 @@ struct osigaction_args { */ /* ARGSUSED */ int -osigaction(p, uap) - struct proc *p; +osigaction(td, uap) + struct thread *td; register struct osigaction_args *uap; { + struct proc *p = td->td_proc; struct osigaction sa; struct sigaction nsa, osa; register struct sigaction *nsap, *osap; @@ -534,7 +536,7 @@ do_sigprocmask(p, how, set, oset, old) } /* - * sigprocmask() - MP SAFE + * sigprocmask() - MP SAFE (XXXKSE not under KSE it isn't) */ #ifndef _SYS_SYSPROTO_H_ @@ -545,10 +547,11 @@ struct sigprocmask_args { }; #endif int -sigprocmask(p, uap) - register struct proc *p; +sigprocmask(td, uap) + register struct thread *td; struct sigprocmask_args *uap; { + struct proc *p = td->td_proc; sigset_t set, oset; sigset_t *setp, *osetp; int error; @@ -578,16 +581,17 @@ struct osigprocmask_args { }; #endif int -osigprocmask(p, uap) - register struct proc *p; +osigprocmask(td, uap) + register struct thread *td; struct osigprocmask_args *uap; { + struct proc *p = td->td_proc; sigset_t set, oset; int error; OSIG2SIG(uap->mask, set); error = do_sigprocmask(p, uap->how, &set, &oset, 1); - SIG2OSIG(oset, p->p_retval[0]); + SIG2OSIG(oset, td->td_retval[0]); return (error); } #endif /* COMPAT_43 */ @@ -602,10 +606,11 @@ struct sigpending_args { */ /* ARGSUSED */ int -sigpending(p, uap) - struct proc *p; +sigpending(td, uap) + struct thread *td; struct sigpending_args *uap; { + struct proc *p = td->td_proc; sigset_t siglist; int error; @@ -629,13 +634,15 @@ struct osigpending_args { */ /* ARGSUSED */ int -osigpending(p, uap) - struct proc *p; +osigpending(td, uap) + struct thread *td; struct osigpending_args *uap; { + struct proc *p = td->td_proc; + mtx_lock(&Giant); PROC_LOCK(p); - SIG2OSIG(p->p_siglist, p->p_retval[0]); + SIG2OSIG(p->p_siglist, td->td_retval[0]); PROC_UNLOCK(p); mtx_unlock(&Giant); return (0); @@ -658,10 +665,11 @@ struct osigvec_args { */ /* ARGSUSED */ int -osigvec(p, uap) - struct proc *p; +osigvec(td, uap) + struct thread *td; register struct osigvec_args *uap; { + struct proc *p = td->td_proc; struct sigvec vec; struct sigaction nsa, osa; register struct sigaction *nsap, *osap; @@ -709,17 +717,18 @@ struct osigblock_args { * MPSAFE */ int -osigblock(p, uap) - register struct proc *p; +osigblock(td, uap) + register struct thread *td; struct osigblock_args *uap; { + struct proc *p = td->td_proc; sigset_t set; OSIG2SIG(uap->mask, set); SIG_CANTMASK(set); mtx_lock(&Giant); PROC_LOCK(p); - SIG2OSIG(p->p_sigmask, p->p_retval[0]); + SIG2OSIG(p->p_sigmask, td->td_retval[0]); SIGSETOR(p->p_sigmask, set); PROC_UNLOCK(p); mtx_unlock(&Giant); @@ -735,17 +744,18 @@ struct osigsetmask_args { * MPSAFE */ int -osigsetmask(p, uap) - struct proc *p; +osigsetmask(td, uap) + struct thread *td; struct osigsetmask_args *uap; { + struct proc *p = td->td_proc; sigset_t set; OSIG2SIG(uap->mask, set); SIG_CANTMASK(set); mtx_lock(&Giant); PROC_LOCK(p); - SIG2OSIG(p->p_sigmask, p->p_retval[0]); + SIG2OSIG(p->p_sigmask, td->td_retval[0]); SIGSETLO(p->p_sigmask, set); PROC_UNLOCK(p); mtx_unlock(&Giant); @@ -757,6 +767,9 @@ osigsetmask(p, uap) * Suspend process until signal, providing mask to be set * in the meantime. Note nonstandard calling convention: * libc stub passes mask, not pointer, to save a copyin. + ***** XXXKSE this doesn't make sense under KSE. + ***** Do we suspend the thread or all threads in the process? + ***** How do we suspend threads running NOW on another processor? */ #ifndef _SYS_SYSPROTO_H_ struct sigsuspend_args { @@ -768,10 +781,11 @@ struct sigsuspend_args { */ /* ARGSUSED */ int -sigsuspend(p, uap) - register struct proc *p; +sigsuspend(td, uap) + struct thread *td; struct sigsuspend_args *uap; { + struct proc *p = td->td_proc; sigset_t mask; register struct sigacts *ps; int error; @@ -814,10 +828,11 @@ struct osigsuspend_args { */ /* ARGSUSED */ int -osigsuspend(p, uap) - register struct proc *p; +osigsuspend(td, uap) + struct thread *td; struct osigsuspend_args *uap; { + struct proc *p = td->td_proc; sigset_t mask; register struct sigacts *ps; @@ -850,10 +865,11 @@ struct osigstack_args { */ /* ARGSUSED */ int -osigstack(p, uap) - struct proc *p; +osigstack(td, uap) + struct thread *td; register struct osigstack_args *uap; { + struct proc *p = td->td_proc; struct sigstack ss; int error = 0; @@ -862,7 +878,7 @@ osigstack(p, uap) if (uap->oss != NULL) { PROC_LOCK(p); ss.ss_sp = p->p_sigstk.ss_sp; - ss.ss_onstack = sigonstack(cpu_getstack(p)); + ss.ss_onstack = sigonstack(cpu_getstack(td)); PROC_UNLOCK(p); error = copyout(&ss, uap->oss, sizeof(struct sigstack)); if (error) @@ -896,17 +912,18 @@ struct sigaltstack_args { */ /* ARGSUSED */ int -sigaltstack(p, uap) - struct proc *p; +sigaltstack(td, uap) + struct thread *td; register struct sigaltstack_args *uap; { + struct proc *p = td->td_proc; stack_t ss; int oonstack; int error = 0; mtx_lock(&Giant); - oonstack = sigonstack(cpu_getstack(p)); + oonstack = sigonstack(cpu_getstack(td)); if (uap->oss != NULL) { PROC_LOCK(p); @@ -1027,10 +1044,11 @@ struct kill_args { */ /* ARGSUSED */ int -kill(cp, uap) - register struct proc *cp; +kill(td, uap) + register struct thread *td; register struct kill_args *uap; { + register struct proc *cp = td->td_proc; register struct proc *p; int error = 0; @@ -1080,8 +1098,8 @@ struct okillpg_args { */ /* ARGSUSED */ int -okillpg(p, uap) - struct proc *p; +okillpg(td, uap) + struct thread *td; register struct okillpg_args *uap; { int error; @@ -1089,7 +1107,7 @@ okillpg(p, uap) if ((u_int)uap->signum > _SIG_MAXSIG) return (EINVAL); mtx_lock(&Giant); - error = killpg1(p, uap->signum, uap->pgid, 0); + error = killpg1(td->td_proc, uap->signum, uap->pgid, 0); mtx_unlock(&Giant); return (error); } @@ -1198,6 +1216,8 @@ psignal(p, sig) { register int prop; register sig_t action; + struct thread *td; + struct ksegrp *kg; if (sig > _SIG_MAXSIG || sig <= 0) { printf("psignal: signal %d\n", sig); @@ -1214,9 +1234,9 @@ psignal(p, sig) * if signal event is tracked by procfs, give *that* * a chance, as well. */ - if ((p->p_flag & P_TRACED) || (p->p_stops & S_SIG)) + if ((p->p_flag & P_TRACED) || (p->p_stops & S_SIG)) { action = SIG_DFL; - else { + } else { /* * If the signal is being ignored, * then we forget about it immediately. @@ -1234,10 +1254,27 @@ psignal(p, sig) action = SIG_DFL; } + /* + * bring the priority of a process up if we want it to get + * killed in this lifetime. + * XXXKSE think if a better way to do this. + * + * What we need to do is see if there is a thread that will + * be able to accept the signal. e.g. + * FOREACH_THREAD_IN_PROC() { + * if runnable, we're done + * else pick one at random. + * } + */ + /* XXXKSE + * For now there is one thread per proc. + * Effectively select one sucker thread.. + */ + td = &p->p_thread; mtx_lock_spin(&sched_lock); - if (p->p_nice > NZERO && action == SIG_DFL && (prop & SA_KILL) && - (p->p_flag & P_TRACED) == 0) - p->p_nice = NZERO; + if ((p->p_ksegrp.kg_nice > NZERO) && (action == SIG_DFL) && + (prop & SA_KILL) && ((p->p_flag & P_TRACED) == 0)) + p->p_ksegrp.kg_nice = NZERO; /* XXXKSE */ mtx_unlock_spin(&sched_lock); if (prop & SA_CONT) @@ -1266,6 +1303,7 @@ psignal(p, sig) mtx_unlock_spin(&sched_lock); return; } + switch (p->p_stat) { case SSLEEP: @@ -1275,7 +1313,7 @@ psignal(p, sig) * be noticed when the process returns through * trap() or syscall(). */ - if ((p->p_sflag & PS_SINTR) == 0) { + if ((td->td_flags & TDF_SINTR) == 0) { mtx_unlock_spin(&sched_lock); goto out; } @@ -1357,11 +1395,28 @@ psignal(p, sig) if (action == SIG_CATCH) goto runfast; mtx_lock_spin(&sched_lock); - if (p->p_wchan == NULL) - goto run; - p->p_stat = SSLEEP; - mtx_unlock_spin(&sched_lock); - goto out; + /* + * XXXKSE + * do this for each thread. + */ + if (p->p_flag & P_KSES) { + mtx_assert(&sched_lock, + MA_OWNED | MA_NOTRECURSED); + FOREACH_THREAD_IN_PROC(p, td) { + if (td->td_wchan == NULL) { + setrunnable(td); /* XXXKSE */ + } else { + /* mark it as sleeping */ + } + } + mtx_unlock_spin(&sched_lock); + goto out; + } else { + if (p->p_thread.td_wchan == NULL) + goto run; + p->p_stat = SSLEEP; + mtx_unlock_spin(&sched_lock); + } } if (prop & SA_STOP) { @@ -1378,13 +1433,25 @@ psignal(p, sig) * wakeup so that when it is continued, it will be made * runnable and can look at the signal. But don't make * the process runnable, leave it stopped. + * XXXKSE should we wake ALL blocked threads? */ mtx_lock_spin(&sched_lock); - if (p->p_wchan && p->p_sflag & PS_SINTR) { - if (p->p_sflag & PS_CVWAITQ) - cv_waitq_remove(p); - else - unsleep(p); + if (p->p_flag & P_KSES) { + FOREACH_THREAD_IN_PROC(p, td) { + if (td->td_wchan && (td->td_flags & TDF_SINTR)){ + if (td->td_flags & TDF_CVWAITQ) + cv_waitq_remove(td); + else + unsleep(td); /* XXXKSE */ + } + } + } else { + if (td->td_wchan && td->td_flags & TDF_SINTR) { + if (td->td_flags & TDF_CVWAITQ) + cv_waitq_remove(td); + else + unsleep(td); /* XXXKSE */ + } } mtx_unlock_spin(&sched_lock); goto out; @@ -1396,9 +1463,21 @@ psignal(p, sig) * It will either never be noticed, or noticed very soon. */ if (p->p_stat == SRUN) { - signotify(p); #ifdef SMP - forward_signal(p); + struct kse *ke; + struct thread *td = curthread; + signotify(&p->p_kse); /* XXXKSE */ +/* we should only deliver to one thread.. but which one? */ + FOREACH_KSEGRP_IN_PROC(p, kg) { + FOREACH_KSE_IN_GROUP(kg, ke) { + if (ke->ke_thread == td) { + continue; + } + forward_signal(ke->ke_thread); + } + } +#else + signotify(&p->p_kse); /* XXXKSE */ #endif } mtx_unlock_spin(&sched_lock); @@ -1409,14 +1488,19 @@ psignal(p, sig) runfast: /* * Raise priority to at least PUSER. + * XXXKSE Should we make them all run fast? + * Maybe just one would be enough? */ mtx_lock_spin(&sched_lock); - if (p->p_pri.pri_level > PUSER) - p->p_pri.pri_level = PUSER; + FOREACH_KSEGRP_IN_PROC(p, kg) { + if (kg->kg_pri.pri_level > PUSER) { + kg->kg_pri.pri_level = PUSER; + } + } run: /* If we jump here, sched_lock has to be owned. */ mtx_assert(&sched_lock, MA_OWNED | MA_NOTRECURSED); - setrunnable(p); + setrunnable(td); /* XXXKSE */ mtx_unlock_spin(&sched_lock); out: /* If we jump here, sched_lock should not be owned. */ @@ -1623,7 +1707,8 @@ void postsig(sig) register int sig; { - register struct proc *p = curproc; + struct thread *td = curthread; + register struct proc *p = td->td_proc; struct sigacts *ps; sig_t action; sigset_t returnmask; @@ -1647,7 +1732,7 @@ postsig(sig) * Default action, where the default is to kill * the process. (Other cases were ignored above.) */ - sigexit(p, sig); + sigexit(td, sig); /* NOTREACHED */ } else { /* @@ -1722,10 +1807,11 @@ killproc(p, why) * does not return. */ void -sigexit(p, sig) - register struct proc *p; +sigexit(td, sig) + struct thread *td; int sig; { + struct proc *p = td->td_proc; PROC_LOCK_ASSERT(p, MA_OWNED); p->p_acflag |= AXSIG; @@ -1740,7 +1826,7 @@ sigexit(p, sig) PROC_UNLOCK(p); if (!mtx_owned(&Giant)) mtx_lock(&Giant); - if (coredump(p) == 0) + if (coredump(td) == 0) sig |= WCOREFLAG; if (kern_logsigexit) log(LOG_INFO, @@ -1754,7 +1840,7 @@ sigexit(p, sig) if (!mtx_owned(&Giant)) mtx_lock(&Giant); } - exit1(p, W_EXITCODE(0, sig)); + exit1(td, W_EXITCODE(0, sig)); /* NOTREACHED */ } @@ -1849,9 +1935,9 @@ const char *name; uid_t uid; pid_t pid; { */ static int -coredump(p) - register struct proc *p; +coredump(struct thread *td) { + struct proc *p = td->td_proc; register struct vnode *vp; register struct ucred *cred = p->p_ucred; struct flock lf; @@ -1889,7 +1975,7 @@ restart: name = expand_name(p->p_comm, p->p_ucred->cr_uid, p->p_pid); if (name == NULL) return (EINVAL); - NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, name, p); + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, name, td); /* XXXKSE */ flags = O_CREAT | FWRITE | O_NOFOLLOW; error = vn_open(&nd, &flags, S_IRUSR | S_IWUSR); free(name, M_TEMP); @@ -1898,7 +1984,7 @@ restart: NDFREE(&nd, NDF_ONLY_PNBUF); vp = nd.ni_vp; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); lf.l_whence = SEEK_SET; lf.l_start = 0; lf.l_len = 0; @@ -1910,7 +1996,7 @@ restart: if (vn_start_write(vp, &mp, V_NOWAIT) != 0) { lf.l_type = F_UNLCK; VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_FLOCK); - if ((error = vn_close(vp, FWRITE, cred, p)) != 0) + if ((error = vn_close(vp, FWRITE, cred, td)) != 0) return (error); if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) return (error); @@ -1919,20 +2005,20 @@ restart: /* Don't dump to non-regular files or files with links. */ if (vp->v_type != VREG || - VOP_GETATTR(vp, &vattr, cred, p) || vattr.va_nlink != 1) { + VOP_GETATTR(vp, &vattr, cred, td) || vattr.va_nlink != 1) { error = EFAULT; goto out1; } VATTR_NULL(&vattr); vattr.va_size = 0; - VOP_LEASE(vp, p, cred, LEASE_WRITE); - VOP_SETATTR(vp, &vattr, cred, p); + VOP_LEASE(vp, td, cred, LEASE_WRITE); + VOP_SETATTR(vp, &vattr, cred, td); PROC_LOCK(p); p->p_acflag |= ACORE; PROC_UNLOCK(p); error = p->p_sysent->sv_coredump ? - p->p_sysent->sv_coredump(p, vp, limit) : + p->p_sysent->sv_coredump(td, vp, limit) : ENOSYS; out1: @@ -1940,7 +2026,7 @@ out1: VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_FLOCK); vn_finished_write(mp); out2: - error1 = vn_close(vp, FWRITE, cred, p); + error1 = vn_close(vp, FWRITE, cred, td); if (error == 0) error = error1; return (error); @@ -1960,10 +2046,12 @@ struct nosys_args { */ /* ARGSUSED */ int -nosys(p, args) - struct proc *p; +nosys(td, args) + struct thread *td; struct nosys_args *args; { + struct proc *p = td->td_proc; + mtx_lock(&Giant); PROC_LOCK(p); psignal(p, SIGSYS); diff --git a/sys/kern/kern_subr.c b/sys/kern/kern_subr.c index 48364ad..31cde4f 100644 --- a/sys/kern/kern_subr.c +++ b/sys/kern/kern_subr.c @@ -66,6 +66,7 @@ uiomove(cp, n, uio) register int n; register struct uio *uio; { + struct thread *td = curthread; register struct iovec *iov; u_int cnt; int error = 0; @@ -73,12 +74,12 @@ uiomove(cp, n, uio) KASSERT(uio->uio_rw == UIO_READ || uio->uio_rw == UIO_WRITE, ("uiomove: mode")); - KASSERT(uio->uio_segflg != UIO_USERSPACE || uio->uio_procp == curproc, + KASSERT(uio->uio_segflg != UIO_USERSPACE || uio->uio_td == curthread, ("uiomove proc")); - if (curproc) { - save = curproc->p_flag & P_DEADLKTREAT; - curproc->p_flag |= P_DEADLKTREAT; + if (td) { + save = td->td_flags & TDF_DEADLKTREAT; + td->td_flags |= TDF_DEADLKTREAT; } while (n > 0 && uio->uio_resid) { @@ -122,8 +123,10 @@ uiomove(cp, n, uio) cp += cnt; n -= cnt; } - if (curproc) - curproc->p_flag = (curproc->p_flag & ~P_DEADLKTREAT) | save; + if (td != curthread) printf("uiomove: IT CHANGED!"); + td = curthread; /* Might things have changed in copyin/copyout? */ + if (td) + td->td_flags = (td->td_flags & ~TDF_DEADLKTREAT) | save; return (error); } @@ -140,7 +143,7 @@ uiomoveco(cp, n, uio, obj) KASSERT(uio->uio_rw == UIO_READ || uio->uio_rw == UIO_WRITE, ("uiomoveco: mode")); - KASSERT(uio->uio_segflg != UIO_USERSPACE || uio->uio_procp == curproc, + KASSERT(uio->uio_segflg != UIO_USERSPACE || uio->uio_td == curthread, ("uiomoveco proc")); while (n > 0 && uio->uio_resid) { @@ -376,14 +379,14 @@ phashinit(elements, type, nentries) static void uio_yield() { - struct proc *p; + struct thread *td; - p = curproc; + td = curthread; mtx_lock_spin(&sched_lock); DROP_GIANT_NOSWITCH(); - p->p_pri.pri_level = p->p_pri.pri_user; - setrunqueue(p); - p->p_stats->p_ru.ru_nivcsw++; + td->td_ksegrp->kg_pri.pri_level = td->td_ksegrp->kg_pri.pri_user; + setrunqueue(td); + td->td_proc->p_stats->p_ru.ru_nivcsw++; mi_switch(); mtx_unlock_spin(&sched_lock); PICKUP_GIANT(); diff --git a/sys/kern/kern_switch.c b/sys/kern/kern_switch.c index a1eaf98..f61c47c 100644 --- a/sys/kern/kern_switch.c +++ b/sys/kern/kern_switch.c @@ -45,10 +45,10 @@ SYSINIT(runq, SI_SUB_RUN_QUEUE, SI_ORDER_FIRST, runq_init, &runq) * Wrappers which implement old interface; act on global run queue. */ -struct proc * -chooseproc(void) +struct thread * +choosethread(void) { - return runq_choose(&runq); + return (runq_choose(&runq)->ke_thread); } int @@ -58,15 +58,15 @@ procrunnable(void) } void -remrunqueue(struct proc *p) +remrunqueue(struct thread *td) { - runq_remove(&runq, p); + runq_remove(&runq, td->td_kse); } void -setrunqueue(struct proc *p) +setrunqueue(struct thread *td) { - runq_add(&runq, p); + runq_add(&runq, td->td_kse); } /* @@ -132,15 +132,15 @@ runq_setbit(struct runq *rq, int pri) * Return true if the specified process is already in the run queue. */ static __inline int -runq_find(struct runq *rq, struct proc *p) +runq_find(struct runq *rq, struct kse *ke) { - struct proc *p2; + struct kse *ke2; int i; mtx_assert(&sched_lock, MA_OWNED); for (i = 0; i < RQB_LEN; i++) - TAILQ_FOREACH(p2, &rq->rq_queues[i], p_procq) - if (p2 == p) + TAILQ_FOREACH(ke2, &rq->rq_queues[i], ke_procq) + if (ke2 == ke) return 1; return 0; } @@ -151,23 +151,30 @@ runq_find(struct runq *rq, struct proc *p) * corresponding status bit. */ void -runq_add(struct runq *rq, struct proc *p) +runq_add(struct runq *rq, struct kse *ke) { struct rqhead *rqh; int pri; + struct ksegrp *kg = ke->ke_ksegrp; +#ifdef INVARIANTS + struct proc *p = ke->ke_proc; +#endif + if (ke->ke_flags & KEF_ONRUNQ) + return; mtx_assert(&sched_lock, MA_OWNED); KASSERT(p->p_stat == SRUN, ("runq_add: proc %p (%s) not SRUN", p, p->p_comm)); - KASSERT(runq_find(rq, p) == 0, - ("runq_add: proc %p (%s) already in run queue", p, p->p_comm)); - pri = p->p_pri.pri_level / RQ_PPQ; - p->p_rqindex = pri; + KASSERT(runq_find(rq, ke) == 0, + ("runq_add: proc %p (%s) already in run queue", ke, p->p_comm)); + pri = kg->kg_pri.pri_level / RQ_PPQ; + ke->ke_rqindex = pri; runq_setbit(rq, pri); rqh = &rq->rq_queues[pri]; CTR4(KTR_RUNQ, "runq_add: p=%p pri=%d %d rqh=%p", - p, p->p_pri.pri_level, pri, rqh); - TAILQ_INSERT_TAIL(rqh, p, p_procq); + p, kg->kg_pri.pri_level, pri, rqh); + TAILQ_INSERT_TAIL(rqh, ke, ke_procq); + ke->ke_flags |= KEF_ONRUNQ; } /* @@ -198,32 +205,33 @@ runq_check(struct runq *rq) * If there are no runnable processes, the per-cpu idle process is * returned. Will not return NULL under any circumstances. */ -struct proc * +struct kse * runq_choose(struct runq *rq) { struct rqhead *rqh; - struct proc *p; + struct kse *ke; int pri; mtx_assert(&sched_lock, MA_OWNED); if ((pri = runq_findbit(rq)) != -1) { rqh = &rq->rq_queues[pri]; - p = TAILQ_FIRST(rqh); - KASSERT(p != NULL, ("runq_choose: no proc on busy queue")); - KASSERT(p->p_stat == SRUN, - ("runq_choose: process %d(%s) in state %d", p->p_pid, - p->p_comm, p->p_stat)); - CTR3(KTR_RUNQ, "runq_choose: pri=%d p=%p rqh=%p", pri, p, rqh); - TAILQ_REMOVE(rqh, p, p_procq); + ke = TAILQ_FIRST(rqh); + KASSERT(ke != NULL, ("runq_choose: no proc on busy queue")); + KASSERT(ke->ke_proc->p_stat == SRUN, + ("runq_choose: process %d(%s) in state %d", ke->ke_proc->p_pid, + ke->ke_proc->p_comm, ke->ke_proc->p_stat)); + CTR3(KTR_RUNQ, "runq_choose: pri=%d kse=%p rqh=%p", pri, ke, rqh); + TAILQ_REMOVE(rqh, ke, ke_procq); if (TAILQ_EMPTY(rqh)) { CTR0(KTR_RUNQ, "runq_choose: empty"); runq_clrbit(rq, pri); } - return (p); + ke->ke_flags &= ~KEF_ONRUNQ; + return (ke); } CTR1(KTR_RUNQ, "runq_choose: idleproc pri=%d", pri); - return (PCPU_GET(idleproc)); + return (PCPU_GET(idlethread)->td_kse); } /* @@ -244,20 +252,26 @@ runq_init(struct runq *rq) * corresponding status bit if the queue becomes empty. */ void -runq_remove(struct runq *rq, struct proc *p) +runq_remove(struct runq *rq, struct kse *ke) { +#ifdef KTR + struct ksegrp *kg = ke->ke_ksegrp; +#endif struct rqhead *rqh; int pri; + if (!(ke->ke_flags & KEF_ONRUNQ)) + return; mtx_assert(&sched_lock, MA_OWNED); - pri = p->p_rqindex; + pri = ke->ke_rqindex; rqh = &rq->rq_queues[pri]; CTR4(KTR_RUNQ, "runq_remove: p=%p pri=%d %d rqh=%p", - p, p->p_pri.pri_level, pri, rqh); - KASSERT(p != NULL, ("runq_remove: no proc on busy queue")); - TAILQ_REMOVE(rqh, p, p_procq); + ke, kg->kg_pri.pri_level, pri, rqh); + KASSERT(ke != NULL, ("runq_remove: no proc on busy queue")); + TAILQ_REMOVE(rqh, ke, ke_procq); if (TAILQ_EMPTY(rqh)) { CTR0(KTR_RUNQ, "runq_remove: empty"); runq_clrbit(rq, pri); } + ke->ke_flags &= ~KEF_ONRUNQ; } diff --git a/sys/kern/kern_sx.c b/sys/kern/kern_sx.c index e1d1ce6..df18c1e 100644 --- a/sys/kern/kern_sx.c +++ b/sys/kern/kern_sx.c @@ -95,7 +95,7 @@ _sx_slock(struct sx *sx, const char *file, int line) { mtx_lock(&sx->sx_lock); - KASSERT(sx->sx_xholder != curproc, + KASSERT(sx->sx_xholder != curthread, ("%s (%s): slock while xlock is held @ %s:%d\n", __FUNCTION__, sx->sx_object.lo_name, file, line)); @@ -148,7 +148,7 @@ _sx_xlock(struct sx *sx, const char *file, int line) * xlock while in here, we consider it API abuse and put it under * INVARIANTS. */ - KASSERT(sx->sx_xholder != curproc, + KASSERT(sx->sx_xholder != curthread, ("%s (%s): xlock already held @ %s:%d", __FUNCTION__, sx->sx_object.lo_name, file, line)); @@ -163,7 +163,7 @@ _sx_xlock(struct sx *sx, const char *file, int line) /* Acquire an exclusive lock. */ sx->sx_cnt--; - sx->sx_xholder = curproc; + sx->sx_xholder = curthread; LOCK_LOG_LOCK("XLOCK", &sx->sx_object, 0, 0, file, line); WITNESS_LOCK(&sx->sx_object, LOP_EXCLUSIVE, file, line); @@ -178,7 +178,7 @@ _sx_try_xlock(struct sx *sx, const char *file, int line) mtx_lock(&sx->sx_lock); if (sx->sx_cnt == 0) { sx->sx_cnt--; - sx->sx_xholder = curproc; + sx->sx_xholder = curthread; LOCK_LOG_TRY("XLOCK", &sx->sx_object, 0, 1, file, line); WITNESS_LOCK(&sx->sx_object, LOP_EXCLUSIVE | LOP_TRYLOCK, file, line); @@ -256,7 +256,7 @@ _sx_try_upgrade(struct sx *sx, const char *file, int line) if (sx->sx_cnt == 1) { sx->sx_cnt = -1; - sx->sx_xholder = curproc; + sx->sx_xholder = curthread; LOCK_LOG_TRY("XUPGRADE", &sx->sx_object, 0, 1, file, line); WITNESS_UPGRADE(&sx->sx_object, LOP_EXCLUSIVE | LOP_TRYLOCK, diff --git a/sys/kern/kern_synch.c b/sys/kern/kern_synch.c index 24da6e9..5278d17 100644 --- a/sys/kern/kern_synch.c +++ b/sys/kern/kern_synch.c @@ -107,13 +107,13 @@ SYSCTL_PROC(_kern, OID_AUTO, quantum, CTLTYPE_INT|CTLFLAG_RW, * schedulers into account. */ void -maybe_resched(p) - struct proc *p; +maybe_resched(kg) + struct ksegrp *kg; { mtx_assert(&sched_lock, MA_OWNED); - if (p->p_pri.pri_level < curproc->p_pri.pri_level) - curproc->p_sflag |= PS_NEEDRESCHED; + if (kg->kg_pri.pri_level < curthread->td_ksegrp->kg_pri.pri_level) + curthread->td_kse->ke_flags |= KEF_NEEDRESCHED; } int @@ -245,59 +245,88 @@ schedcpu(arg) { register fixpt_t loadfac = loadfactor(averunnable.ldavg[0]); register struct proc *p; + register struct kse *ke; + register struct ksegrp *kg; register int realstathz; + int awake; realstathz = stathz ? stathz : hz; sx_slock(&allproc_lock); - LIST_FOREACH(p, &allproc, p_list) { - /* - * Increment time in/out of memory and sleep time - * (if sleeping). We ignore overflow; with 16-bit int's - * (remember them?) overflow takes 45 days. - */ + FOREACH_PROC_IN_SYSTEM(p) { mtx_lock_spin(&sched_lock); p->p_swtime++; - if (p->p_stat == SSLEEP || p->p_stat == SSTOP) - p->p_slptime++; - p->p_pctcpu = (p->p_pctcpu * ccpu) >> FSHIFT; - /* - * If the process has slept the entire second, - * stop recalculating its priority until it wakes up. - */ - if (p->p_slptime > 1) { - mtx_unlock_spin(&sched_lock); - continue; - } + FOREACH_KSEGRP_IN_PROC(p, kg) { + awake = 0; + FOREACH_KSE_IN_GROUP(kg, ke) { + /* + * Increment time in/out of memory and sleep + * time (if sleeping). We ignore overflow; + * with 16-bit int's (remember them?) + * overflow takes 45 days. + */ + /* XXXKSE */ + /* if ((ke->ke_flags & KEF_ONRUNQ) == 0) */ + if (p->p_stat == SSLEEP || p->p_stat == SSTOP) { + ke->ke_slptime++; + } else { + ke->ke_slptime = 0; + awake = 1; + } + + /* + * pctcpu is only for ps? + * Do it per kse.. and add them up at the end? + * XXXKSE + */ + ke->ke_pctcpu = (ke->ke_pctcpu * ccpu) >> FSHIFT; + /* + * If the kse has been idle the entire second, + * stop recalculating its priority until + * it wakes up. + */ + if (ke->ke_slptime > 1) { + continue; + } - /* - * p_pctcpu is only for ps. - */ #if (FSHIFT >= CCPU_SHIFT) - p->p_pctcpu += (realstathz == 100)? - ((fixpt_t) p->p_cpticks) << (FSHIFT - CCPU_SHIFT): - 100 * (((fixpt_t) p->p_cpticks) - << (FSHIFT - CCPU_SHIFT)) / realstathz; + ke->ke_pctcpu += (realstathz == 100) ? + ((fixpt_t) ke->ke_cpticks) << + (FSHIFT - CCPU_SHIFT) : + 100 * (((fixpt_t) ke->ke_cpticks) << + (FSHIFT - CCPU_SHIFT)) / realstathz; #else - p->p_pctcpu += ((FSCALE - ccpu) * - (p->p_cpticks * FSCALE / realstathz)) >> FSHIFT; + ke->ke_pctcpu += ((FSCALE - ccpu) * + (ke->ke_cpticks * FSCALE / realstathz)) >> + FSHIFT; #endif - p->p_cpticks = 0; - p->p_estcpu = decay_cpu(loadfac, p->p_estcpu); - resetpriority(p); - if (p->p_pri.pri_level >= PUSER) { - if (p->p_oncpu == NOCPU && /* idle */ - p->p_stat == SRUN && - (p->p_sflag & PS_INMEM) && - (p->p_pri.pri_level / RQ_PPQ) != - (p->p_pri.pri_user / RQ_PPQ)) { - remrunqueue(p); - p->p_pri.pri_level = p->p_pri.pri_user; - setrunqueue(p); - } else - p->p_pri.pri_level = p->p_pri.pri_user; - } + ke->ke_cpticks = 0; + } /* end of kse loop */ + if (awake == 0) { + kg->kg_slptime++; + } else { + kg->kg_slptime = 0; + } + kg->kg_estcpu = decay_cpu(loadfac, kg->kg_estcpu); + resetpriority(kg); + if (kg->kg_pri.pri_level >= PUSER && + (p->p_sflag & PS_INMEM)) { + int changedqueue = + ((kg->kg_pri.pri_level / RQ_PPQ) != + (kg->kg_pri.pri_user / RQ_PPQ)); + + kg->kg_pri.pri_level = kg->kg_pri.pri_user; + FOREACH_KSE_IN_GROUP(kg, ke) { + if ((ke->ke_oncpu == NOCPU) && /* idle */ + (p->p_stat == SRUN) && /* XXXKSE */ + changedqueue) { + remrunqueue(ke->ke_thread); + setrunqueue(ke->ke_thread); + } + } + } + } /* end of ksegrp loop */ mtx_unlock_spin(&sched_lock); - } + } /* end of process loop */ sx_sunlock(&allproc_lock); vmmeter(); wakeup((caddr_t)&lbolt); @@ -310,21 +339,26 @@ schedcpu(arg) * least six times the loadfactor will decay p_estcpu to zero. */ void -updatepri(p) - register struct proc *p; +updatepri(td) + register struct thread *td; { - register unsigned int newcpu = p->p_estcpu; + register struct ksegrp *kg; + register unsigned int newcpu; register fixpt_t loadfac = loadfactor(averunnable.ldavg[0]); - if (p->p_slptime > 5 * loadfac) - p->p_estcpu = 0; + if (td == NULL) + return; + kg = td->td_ksegrp; + newcpu = kg->kg_estcpu; + if (kg->kg_slptime > 5 * loadfac) + kg->kg_estcpu = 0; else { - p->p_slptime--; /* the first time was done in schedcpu */ - while (newcpu && --p->p_slptime) + kg->kg_slptime--; /* the first time was done in schedcpu */ + while (newcpu && --kg->kg_slptime) newcpu = decay_cpu(loadfac, newcpu); - p->p_estcpu = newcpu; + kg->kg_estcpu = newcpu; } - resetpriority(p); + resetpriority(td->td_ksegrp); } /* @@ -333,7 +367,7 @@ updatepri(p) * of 2. Shift right by 8, i.e. drop the bottom 256 worth. */ #define TABLESIZE 128 -static TAILQ_HEAD(slpquehead, proc) slpque[TABLESIZE]; +static TAILQ_HEAD(slpquehead, thread) slpque[TABLESIZE]; #define LOOKUP(x) (((intptr_t)(x) >> 8) & (TABLESIZE - 1)) void @@ -370,6 +404,7 @@ msleep(ident, mtx, priority, wmesg, timo) const char *wmesg; { struct proc *p = curproc; + struct thread *td = curthread; int sig, catch = priority & PCATCH; int rval = 0; WITNESS_SAVE_DECL(mtx); @@ -406,17 +441,18 @@ msleep(ident, mtx, priority, wmesg, timo) } KASSERT(p != NULL, ("msleep1")); - KASSERT(ident != NULL && p->p_stat == SRUN, ("msleep")); - - p->p_wchan = ident; - p->p_wmesg = wmesg; - p->p_slptime = 0; - p->p_pri.pri_level = priority & PRIMASK; - CTR5(KTR_PROC, "msleep: proc %p (pid %d, %s) on %s (%p)", p, p->p_pid, - p->p_comm, wmesg, ident); - TAILQ_INSERT_TAIL(&slpque[LOOKUP(ident)], p, p_slpq); + KASSERT(ident != NULL && td->td_proc->p_stat == SRUN, ("msleep")); + + td->td_wchan = ident; + td->td_wmesg = wmesg; + td->td_kse->ke_slptime = 0; /* XXXKSE */ + td->td_ksegrp->kg_slptime = 0; + td->td_ksegrp->kg_pri.pri_level = priority & PRIMASK; + CTR5(KTR_PROC, "msleep: thread %p (pid %d, %s) on %s (%p)", + td, p->p_pid, p->p_comm, wmesg, ident); + TAILQ_INSERT_TAIL(&slpque[LOOKUP(ident)], td, td_slpq); if (timo) - callout_reset(&p->p_slpcallout, timo, endtsleep, p); + callout_reset(&td->td_slpcallout, timo, endtsleep, td); /* * We put ourselves on the sleep queue and start our timeout * before calling CURSIG, as we could stop there, and a wakeup @@ -424,40 +460,40 @@ msleep(ident, mtx, priority, wmesg, timo) * A SIGCONT would cause us to be marked as SSLEEP * without resuming us, thus we must be ready for sleep * when CURSIG is called. If the wakeup happens while we're - * stopped, p->p_wchan will be 0 upon return from CURSIG. + * stopped, td->td_wchan will be 0 upon return from CURSIG. */ if (catch) { CTR3(KTR_PROC, "msleep caught: proc %p (pid %d, %s)", p, p->p_pid, p->p_comm); - p->p_sflag |= PS_SINTR; + td->td_flags |= TDF_SINTR; mtx_unlock_spin(&sched_lock); PROC_LOCK(p); sig = CURSIG(p); mtx_lock_spin(&sched_lock); PROC_UNLOCK_NOSWITCH(p); if (sig != 0) { - if (p->p_wchan != NULL) - unsleep(p); - } else if (p->p_wchan == NULL) + if (td->td_wchan != NULL) + unsleep(td); + } else if (td->td_wchan == NULL) catch = 0; } else sig = 0; - if (p->p_wchan != NULL) { - p->p_stat = SSLEEP; + if (td->td_wchan != NULL) { + td->td_proc->p_stat = SSLEEP; p->p_stats->p_ru.ru_nvcsw++; mi_switch(); } - CTR3(KTR_PROC, "msleep resume: proc %p (pid %d, %s)", p, p->p_pid, + CTR3(KTR_PROC, "msleep resume: proc %p (pid %d, %s)", td, p->p_pid, p->p_comm); - KASSERT(p->p_stat == SRUN, ("running but not SRUN")); - p->p_sflag &= ~PS_SINTR; - if (p->p_sflag & PS_TIMEOUT) { - p->p_sflag &= ~PS_TIMEOUT; + KASSERT(td->td_proc->p_stat == SRUN, ("running but not SRUN")); + td->td_flags &= ~TDF_SINTR; + if (td->td_flags & TDF_TIMEOUT) { + td->td_flags &= ~TDF_TIMEOUT; if (sig == 0) rval = EWOULDBLOCK; - } else if (p->p_sflag & PS_TIMOFAIL) - p->p_sflag &= ~PS_TIMOFAIL; - else if (timo && callout_stop(&p->p_slpcallout) == 0) { + } else if (td->td_flags & TDF_TIMOFAIL) + td->td_flags &= ~TDF_TIMOFAIL; + else if (timo && callout_stop(&td->td_slpcallout) == 0) { /* * This isn't supposed to be pretty. If we are here, then * the endtsleep() callout is currently executing on another @@ -467,7 +503,7 @@ msleep(ident, mtx, priority, wmesg, timo) * has a chance to run and the callout may end up waking up * the wrong msleep(). Yuck. */ - p->p_sflag |= PS_TIMEOUT; + td->td_flags |= TDF_TIMEOUT; p->p_stats->p_ru.ru_nivcsw++; mi_switch(); } @@ -510,28 +546,28 @@ static void endtsleep(arg) void *arg; { - register struct proc *p; + register struct thread *td = arg; - p = (struct proc *)arg; - CTR3(KTR_PROC, "endtsleep: proc %p (pid %d, %s)", p, p->p_pid, - p->p_comm); + CTR3(KTR_PROC, "endtsleep: thread %p (pid %d, %s)", td, td->td_proc->p_pid, + td->td_proc->p_comm); mtx_lock_spin(&sched_lock); /* * This is the other half of the synchronization with msleep() * described above. If the PS_TIMEOUT flag is set, we lost the * race and just need to put the process back on the runqueue. */ - if ((p->p_sflag & PS_TIMEOUT) != 0) { - p->p_sflag &= ~PS_TIMEOUT; - setrunqueue(p); - } else if (p->p_wchan != NULL) { - if (p->p_stat == SSLEEP) - setrunnable(p); + if ((td->td_flags & TDF_TIMEOUT) != 0) { + td->td_flags &= ~TDF_TIMEOUT; + setrunqueue(td); + } else if (td->td_wchan != NULL) { + if (td->td_proc->p_stat == SSLEEP) /* XXXKSE */ + setrunnable(td); else - unsleep(p); - p->p_sflag |= PS_TIMEOUT; - } else - p->p_sflag |= PS_TIMOFAIL; + unsleep(td); + td->td_flags |= TDF_TIMEOUT; + } else { + td->td_flags |= TDF_TIMOFAIL; + } mtx_unlock_spin(&sched_lock); } @@ -539,14 +575,13 @@ endtsleep(arg) * Remove a process from its wait queue */ void -unsleep(p) - register struct proc *p; +unsleep(struct thread *td) { mtx_lock_spin(&sched_lock); - if (p->p_wchan != NULL) { - TAILQ_REMOVE(&slpque[LOOKUP(p->p_wchan)], p, p_slpq); - p->p_wchan = NULL; + if (td->td_wchan != NULL) { + TAILQ_REMOVE(&slpque[LOOKUP(td->td_wchan)], td, td_slpq); + td->td_wchan = NULL; } mtx_unlock_spin(&sched_lock); } @@ -559,26 +594,29 @@ wakeup(ident) register void *ident; { register struct slpquehead *qp; - register struct proc *p; + register struct thread *td; + struct proc *p; mtx_lock_spin(&sched_lock); qp = &slpque[LOOKUP(ident)]; restart: - TAILQ_FOREACH(p, qp, p_slpq) { - if (p->p_wchan == ident) { - TAILQ_REMOVE(qp, p, p_slpq); - p->p_wchan = NULL; - if (p->p_stat == SSLEEP) { + TAILQ_FOREACH(td, qp, td_slpq) { + p = td->td_proc; + if (td->td_wchan == ident) { + TAILQ_REMOVE(qp, td, td_slpq); + td->td_wchan = NULL; + if (td->td_proc->p_stat == SSLEEP) { /* OPTIMIZED EXPANSION OF setrunnable(p); */ - CTR3(KTR_PROC, "wakeup: proc %p (pid %d, %s)", - p, p->p_pid, p->p_comm); - if (p->p_slptime > 1) - updatepri(p); - p->p_slptime = 0; - p->p_stat = SRUN; + CTR3(KTR_PROC, "wakeup: thread %p (pid %d, %s)", + td, p->p_pid, p->p_comm); + if (td->td_ksegrp->kg_slptime > 1) + updatepri(td); + td->td_ksegrp->kg_slptime = 0; + td->td_kse->ke_slptime = 0; + td->td_proc->p_stat = SRUN; if (p->p_sflag & PS_INMEM) { - setrunqueue(p); - maybe_resched(p); + setrunqueue(td); + maybe_resched(td->td_ksegrp); } else { p->p_sflag |= PS_SWAPINREQ; wakeup((caddr_t)&proc0); @@ -601,26 +639,29 @@ wakeup_one(ident) register void *ident; { register struct slpquehead *qp; + register struct thread *td; register struct proc *p; mtx_lock_spin(&sched_lock); qp = &slpque[LOOKUP(ident)]; - TAILQ_FOREACH(p, qp, p_slpq) { - if (p->p_wchan == ident) { - TAILQ_REMOVE(qp, p, p_slpq); - p->p_wchan = NULL; - if (p->p_stat == SSLEEP) { + TAILQ_FOREACH(td, qp, td_slpq) { + p = td->td_proc; + if (td->td_wchan == ident) { + TAILQ_REMOVE(qp, td, td_slpq); + td->td_wchan = NULL; + if (td->td_proc->p_stat == SSLEEP) { /* OPTIMIZED EXPANSION OF setrunnable(p); */ CTR3(KTR_PROC, "wakeup1: proc %p (pid %d, %s)", p, p->p_pid, p->p_comm); - if (p->p_slptime > 1) - updatepri(p); - p->p_slptime = 0; - p->p_stat = SRUN; + if (td->td_ksegrp->kg_slptime > 1) + updatepri(td); + td->td_ksegrp->kg_slptime = 0; + td->td_kse->ke_slptime = 0; + td->td_proc->p_stat = SRUN; if (p->p_sflag & PS_INMEM) { - setrunqueue(p); - maybe_resched(p); + setrunqueue(td); + maybe_resched(td->td_ksegrp); break; } else { p->p_sflag |= PS_SWAPINREQ; @@ -640,7 +681,8 @@ void mi_switch() { struct timeval new_switchtime; - register struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ + register struct proc *p = td->td_proc; /* XXX */ #if 0 register struct rlimit *rlim; #endif @@ -717,14 +759,14 @@ mi_switch() p->p_comm); sched_crit = sched_lock.mtx_savecrit; sched_nest = sched_lock.mtx_recurse; - p->p_lastcpu = p->p_oncpu; - p->p_oncpu = NOCPU; - p->p_sflag &= ~PS_NEEDRESCHED; + td->td_lastcpu = td->td_kse->ke_oncpu; + td->td_kse->ke_oncpu = NOCPU; + td->td_kse->ke_flags &= ~KEF_NEEDRESCHED; cpu_switch(); - p->p_oncpu = PCPU_GET(cpuid); + td->td_kse->ke_oncpu = PCPU_GET(cpuid); sched_lock.mtx_savecrit = sched_crit; sched_lock.mtx_recurse = sched_nest; - sched_lock.mtx_lock = (uintptr_t)p; + sched_lock.mtx_lock = (uintptr_t)td; CTR3(KTR_PROC, "mi_switch: new proc %p (pid %d, %s)", p, p->p_pid, p->p_comm); if (PCPU_GET(switchtime.tv_sec) == 0) @@ -738,39 +780,42 @@ mi_switch() * and awakening the swapper if it isn't in memory. */ void -setrunnable(p) - register struct proc *p; +setrunnable(struct thread *td) { - + struct proc *p = td->td_proc; mtx_lock_spin(&sched_lock); switch (p->p_stat) { + case SZOMB: /* not a thread flag XXXKSE */ + panic("setrunnabl(1)"); + } + switch (td->td_proc->p_stat) { case 0: case SRUN: - case SZOMB: case SWAIT: default: - panic("setrunnable"); + panic("setrunnable(2)"); case SSTOP: case SSLEEP: /* e.g. when sending signals */ - if (p->p_sflag & PS_CVWAITQ) - cv_waitq_remove(p); + if (td->td_flags & TDF_CVWAITQ) + cv_waitq_remove(td); else - unsleep(p); + unsleep(td); break; case SIDL: break; } - p->p_stat = SRUN; - if (p->p_slptime > 1) - updatepri(p); - p->p_slptime = 0; + td->td_proc->p_stat = SRUN; + if (td->td_ksegrp->kg_slptime > 1) + updatepri(td); + td->td_ksegrp->kg_slptime = 0; + td->td_kse->ke_slptime = 0; if ((p->p_sflag & PS_INMEM) == 0) { p->p_sflag |= PS_SWAPINREQ; wakeup((caddr_t)&proc0); } else { - setrunqueue(p); - maybe_resched(p); + setrunqueue(td); + maybe_resched(td->td_ksegrp); } mtx_unlock_spin(&sched_lock); } @@ -781,20 +826,20 @@ setrunnable(p) * than that of the current process. */ void -resetpriority(p) - register struct proc *p; +resetpriority(kg) + register struct ksegrp *kg; { register unsigned int newpriority; mtx_lock_spin(&sched_lock); - if (p->p_pri.pri_class == PRI_TIMESHARE) { - newpriority = PUSER + p->p_estcpu / INVERSE_ESTCPU_WEIGHT + - NICE_WEIGHT * (p->p_nice - PRIO_MIN); + if (kg->kg_pri.pri_class == PRI_TIMESHARE) { + newpriority = PUSER + kg->kg_estcpu / INVERSE_ESTCPU_WEIGHT + + NICE_WEIGHT * (kg->kg_nice - PRIO_MIN); newpriority = min(max(newpriority, PRI_MIN_TIMESHARE), PRI_MAX_TIMESHARE); - p->p_pri.pri_user = newpriority; + kg->kg_pri.pri_user = newpriority; } - maybe_resched(p); + maybe_resched(kg); mtx_unlock_spin(&sched_lock); } @@ -827,16 +872,22 @@ sched_setup(dummy) * run much recently, and to round-robin among other processes. */ void -schedclock(p) - struct proc *p; +schedclock(td) + struct thread *td; { - - p->p_cpticks++; - p->p_estcpu = ESTCPULIM(p->p_estcpu + 1); - if ((p->p_estcpu % INVERSE_ESTCPU_WEIGHT) == 0) { - resetpriority(p); - if (p->p_pri.pri_level >= PUSER) - p->p_pri.pri_level = p->p_pri.pri_user; + struct kse *ke = td->td_kse; + struct ksegrp *kg = td->td_ksegrp; + + if (td) { + ke->ke_cpticks++; + kg->kg_estcpu = ESTCPULIM(kg->kg_estcpu + 1); + if ((kg->kg_estcpu % INVERSE_ESTCPU_WEIGHT) == 0) { + resetpriority(td->td_ksegrp); + if (kg->kg_pri.pri_level >= PUSER) + kg->kg_pri.pri_level = kg->kg_pri.pri_user; + } + } else { + panic("schedclock"); } } @@ -844,18 +895,20 @@ schedclock(p) * General purpose yield system call */ int -yield(struct proc *p, struct yield_args *uap) +yield(struct thread *td, struct yield_args *uap) { - p->p_retval[0] = 0; + + struct ksegrp *kg = td->td_ksegrp; + td->td_retval[0] = 0; mtx_lock_spin(&sched_lock); mtx_assert(&Giant, MA_NOTOWNED); #if 0 DROP_GIANT_NOSWITCH(); #endif - p->p_pri.pri_level = PRI_MAX_TIMESHARE; - setrunqueue(p); - p->p_stats->p_ru.ru_nvcsw++; + kg->kg_pri.pri_level = PRI_MAX_TIMESHARE; + setrunqueue(td); + kg->kg_proc->p_stats->p_ru.ru_nvcsw++; mi_switch(); mtx_unlock_spin(&sched_lock); #if 0 diff --git a/sys/kern/kern_syscalls.c b/sys/kern/kern_syscalls.c index 633406a..4dd623e 100644 --- a/sys/kern/kern_syscalls.c +++ b/sys/kern/kern_syscalls.c @@ -39,15 +39,15 @@ * Place holder for system call slots reserved for loadable modules. */ int -lkmnosys(struct proc *p, struct nosys_args *args) +lkmnosys(struct thread *td, struct nosys_args *args) { - return(nosys(p, args)); + return(nosys(td, args)); } int -lkmressys(struct proc *p, struct nosys_args *args) +lkmressys(struct thread *td, struct nosys_args *args) { - return(nosys(p, args)); + return(nosys(td, args)); } int diff --git a/sys/kern/kern_sysctl.c b/sys/kern/kern_sysctl.c index ce5ba3d..34fcb68 100644 --- a/sys/kern/kern_sysctl.c +++ b/sys/kern/kern_sysctl.c @@ -836,7 +836,7 @@ sysctl_new_kernel(struct sysctl_req *req, void *p, size_t l) } int -kernel_sysctl(struct proc *p, int *name, u_int namelen, void *old, +kernel_sysctl(struct thread *td, int *name, u_int namelen, void *old, size_t *oldlenp, void *new, size_t newlen, size_t *retval) { int error = 0; @@ -844,7 +844,7 @@ kernel_sysctl(struct proc *p, int *name, u_int namelen, void *old, bzero(&req, sizeof req); - req.p = p; + req.p = td->td_proc; if (oldlenp) { req.oldlen = *oldlenp; @@ -896,7 +896,7 @@ kernel_sysctl(struct proc *p, int *name, u_int namelen, void *old, } int -kernel_sysctlbyname(struct proc *p, char *name, void *old, size_t *oldlenp, +kernel_sysctlbyname(struct thread *td, char *name, void *old, size_t *oldlenp, void *new, size_t newlen, size_t *retval) { int oid[CTL_MAXNAME]; @@ -907,12 +907,12 @@ kernel_sysctlbyname(struct proc *p, char *name, void *old, size_t *oldlenp, oid[1] = 3; /* name2oid */ oidlen = sizeof(oid); - error = kernel_sysctl(p, oid, 2, oid, &oidlen, + error = kernel_sysctl(td, oid, 2, oid, &oidlen, (void *)name, strlen(name), &plen); if (error) return (error); - error = kernel_sysctl(p, oid, plen / sizeof(int), old, oldlenp, + error = kernel_sysctl(td, oid, plen / sizeof(int), old, oldlenp, new, newlen, retval); return (error); } @@ -1066,7 +1066,7 @@ struct sysctl_args { * MPSAFE */ int -__sysctl(struct proc *p, struct sysctl_args *uap) +__sysctl(struct thread *td, struct sysctl_args *uap) { int error, name[CTL_MAXNAME]; size_t j; @@ -1080,7 +1080,7 @@ __sysctl(struct proc *p, struct sysctl_args *uap) mtx_lock(&Giant); - error = userland_sysctl(p, name, uap->namelen, + error = userland_sysctl(td, name, uap->namelen, uap->old, uap->oldlenp, 0, uap->new, uap->newlen, &j); if (error && error != ENOMEM) @@ -1100,7 +1100,7 @@ done2: * must be in kernel space. */ int -userland_sysctl(struct proc *p, int *name, u_int namelen, void *old, +userland_sysctl(struct thread *td, int *name, u_int namelen, void *old, size_t *oldlenp, int inkernel, void *new, size_t newlen, size_t *retval) { int error = 0; @@ -1108,7 +1108,7 @@ userland_sysctl(struct proc *p, int *name, u_int namelen, void *old, bzero(&req, sizeof req); - req.p = p; + req.p = td->td_proc; if (oldlenp) { if (inkernel) { @@ -1245,7 +1245,7 @@ struct getkerninfo_args { * MPSAFE */ int -ogetkerninfo(struct proc *p, struct getkerninfo_args *uap) +ogetkerninfo(struct thread *td, struct getkerninfo_args *uap) { int error, name[6]; size_t size; @@ -1262,14 +1262,14 @@ ogetkerninfo(struct proc *p, struct getkerninfo_args *uap) name[3] = (uap->op & 0xff0000) >> 16; name[4] = uap->op & 0xff; name[5] = uap->arg; - error = userland_sysctl(p, name, 6, uap->where, uap->size, + error = userland_sysctl(td, name, 6, uap->where, uap->size, 0, 0, 0, &size); break; case KINFO_VNODE: name[0] = CTL_KERN; name[1] = KERN_VNODE; - error = userland_sysctl(p, name, 2, uap->where, uap->size, + error = userland_sysctl(td, name, 2, uap->where, uap->size, 0, 0, 0, &size); break; @@ -1278,35 +1278,35 @@ ogetkerninfo(struct proc *p, struct getkerninfo_args *uap) name[1] = KERN_PROC; name[2] = uap->op & 0xff; name[3] = uap->arg; - error = userland_sysctl(p, name, 4, uap->where, uap->size, + error = userland_sysctl(td, name, 4, uap->where, uap->size, 0, 0, 0, &size); break; case KINFO_FILE: name[0] = CTL_KERN; name[1] = KERN_FILE; - error = userland_sysctl(p, name, 2, uap->where, uap->size, + error = userland_sysctl(td, name, 2, uap->where, uap->size, 0, 0, 0, &size); break; case KINFO_METER: name[0] = CTL_VM; name[1] = VM_METER; - error = userland_sysctl(p, name, 2, uap->where, uap->size, + error = userland_sysctl(td, name, 2, uap->where, uap->size, 0, 0, 0, &size); break; case KINFO_LOADAVG: name[0] = CTL_VM; name[1] = VM_LOADAVG; - error = userland_sysctl(p, name, 2, uap->where, uap->size, + error = userland_sysctl(td, name, 2, uap->where, uap->size, 0, 0, 0, &size); break; case KINFO_CLOCKRATE: name[0] = CTL_KERN; name[1] = KERN_CLOCKRATE; - error = userland_sysctl(p, name, 2, uap->where, uap->size, + error = userland_sysctl(td, name, 2, uap->where, uap->size, 0, 0, 0, &size); break; @@ -1380,7 +1380,7 @@ ogetkerninfo(struct proc *p, struct getkerninfo_args *uap) break; } if (error == 0) { - p->p_retval[0] = needed ? needed : size; + td->td_retval[0] = needed ? needed : size; if (uap->size) { error = copyout((caddr_t)&size, (caddr_t)uap->size, sizeof(size)); diff --git a/sys/kern/kern_time.c b/sys/kern/kern_time.c index 545479d..17e3a46 100644 --- a/sys/kern/kern_time.c +++ b/sys/kern/kern_time.c @@ -64,7 +64,7 @@ struct timezone tz; * timers when they expire. */ -static int nanosleep1 __P((struct proc *p, struct timespec *rqt, +static int nanosleep1 __P((struct thread *td, struct timespec *rqt, struct timespec *rmt)); static int settime __P((struct timeval *)); static void timevalfix __P((struct timeval *)); @@ -151,8 +151,8 @@ struct clock_gettime_args { */ /* ARGSUSED */ int -clock_gettime(p, uap) - struct proc *p; +clock_gettime(td, uap) + struct thread *td; struct clock_gettime_args *uap; { struct timespec ats; @@ -177,8 +177,8 @@ struct clock_settime_args { */ /* ARGSUSED */ int -clock_settime(p, uap) - struct proc *p; +clock_settime(td, uap) + struct thread *td; struct clock_settime_args *uap; { struct timeval atv; @@ -186,7 +186,7 @@ clock_settime(p, uap) int error; mtx_lock(&Giant); - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) goto done2; if (SCARG(uap, clock_id) != CLOCK_REALTIME) { error = EINVAL; @@ -214,8 +214,8 @@ struct clock_getres_args { #endif int -clock_getres(p, uap) - struct proc *p; +clock_getres(td, uap) + struct thread *td; struct clock_getres_args *uap; { struct timespec ts; @@ -235,8 +235,8 @@ clock_getres(p, uap) static int nanowait; static int -nanosleep1(p, rqt, rmt) - struct proc *p; +nanosleep1(td, rqt, rmt) + struct thread *td; struct timespec *rqt, *rmt; { struct timespec ts, ts2, ts3; @@ -285,8 +285,8 @@ struct nanosleep_args { */ /* ARGSUSED */ int -nanosleep(p, uap) - struct proc *p; +nanosleep(td, uap) + struct thread *td; struct nanosleep_args *uap; { struct timespec rmt, rqt; @@ -304,7 +304,7 @@ nanosleep(p, uap) goto done2; } } - error = nanosleep1(p, &rqt, &rmt); + error = nanosleep1(td, &rqt, &rmt); if (error && SCARG(uap, rmtp)) { int error2; @@ -328,8 +328,8 @@ struct gettimeofday_args { */ /* ARGSUSED */ int -gettimeofday(p, uap) - struct proc *p; +gettimeofday(td, uap) + struct thread *td; register struct gettimeofday_args *uap; { struct timeval atv; @@ -363,8 +363,8 @@ struct settimeofday_args { */ /* ARGSUSED */ int -settimeofday(p, uap) - struct proc *p; +settimeofday(td, uap) + struct thread *td; struct settimeofday_args *uap; { struct timeval atv; @@ -373,7 +373,7 @@ settimeofday(p, uap) mtx_lock(&Giant); - if ((error = suser(p))) + if ((error = suser_td(td))) goto done2; /* Verify all parameters before changing time. */ if (uap->tv) { @@ -414,8 +414,8 @@ struct adjtime_args { */ /* ARGSUSED */ int -adjtime(p, uap) - struct proc *p; +adjtime(td, uap) + struct thread *td; register struct adjtime_args *uap; { struct timeval atv; @@ -424,7 +424,7 @@ adjtime(p, uap) mtx_lock(&Giant); - if ((error = suser(p))) + if ((error = suser_td(td))) goto done2; error = copyin((caddr_t)uap->delta, (caddr_t)&atv, sizeof(struct timeval)); @@ -502,10 +502,11 @@ struct getitimer_args { */ /* ARGSUSED */ int -getitimer(p, uap) - struct proc *p; +getitimer(td, uap) + struct thread *td; register struct getitimer_args *uap; { + struct proc *p = td->td_proc; struct timeval ctv; struct itimerval aitv; int s; @@ -553,10 +554,11 @@ struct setitimer_args { */ /* ARGSUSED */ int -setitimer(p, uap) - struct proc *p; +setitimer(td, uap) + struct thread *td; register struct setitimer_args *uap; { + struct proc *p = td->td_proc; struct itimerval aitv; struct timeval ctv; register struct itimerval *itvp; @@ -572,7 +574,7 @@ setitimer(p, uap) mtx_lock(&Giant); if ((uap->itv = uap->oitv) && - (error = getitimer(p, (struct getitimer_args *)uap))) { + (error = getitimer(td, (struct getitimer_args *)uap))) { goto done2; } if (itvp == 0) { diff --git a/sys/kern/kern_xxx.c b/sys/kern/kern_xxx.c index 84d88ce..f3f19ee 100644 --- a/sys/kern/kern_xxx.c +++ b/sys/kern/kern_xxx.c @@ -60,8 +60,8 @@ struct gethostname_args { */ /* ARGSUSED */ int -ogethostname(p, uap) - struct proc *p; +ogethostname(td, uap) + struct thread *td; struct gethostname_args *uap; { int name[2]; @@ -71,7 +71,7 @@ ogethostname(p, uap) name[0] = CTL_KERN; name[1] = KERN_HOSTNAME; mtx_lock(&Giant); - error = userland_sysctl(p, name, 2, uap->hostname, &len, 1, 0, 0, 0); + error = userland_sysctl(td, name, 2, uap->hostname, &len, 1, 0, 0, 0); mtx_unlock(&Giant); return(error); } @@ -87,8 +87,8 @@ struct sethostname_args { */ /* ARGSUSED */ int -osethostname(p, uap) - struct proc *p; +osethostname(td, uap) + struct thread *td; register struct sethostname_args *uap; { int name[2]; @@ -97,8 +97,8 @@ osethostname(p, uap) name[0] = CTL_KERN; name[1] = KERN_HOSTNAME; mtx_lock(&Giant); - if ((error = suser_xxx(0, p, PRISON_ROOT)) == 0) { - error = userland_sysctl(p, name, 2, 0, 0, 0, + if ((error = suser_xxx(0, td->td_proc, PRISON_ROOT)) == 0) { + error = userland_sysctl(td, name, 2, 0, 0, 0, uap->hostname, uap->len, 0); } mtx_unlock(&Giant); @@ -115,12 +115,12 @@ struct ogethostid_args { */ /* ARGSUSED */ int -ogethostid(p, uap) - struct proc *p; +ogethostid(td, uap) + struct thread *td; struct ogethostid_args *uap; { - *(long *)(p->p_retval) = hostid; + *(long *)(td->td_retval) = hostid; return (0); } #endif /* COMPAT_43 || COMPAT_SUNOS */ @@ -136,14 +136,14 @@ struct osethostid_args { */ /* ARGSUSED */ int -osethostid(p, uap) - struct proc *p; +osethostid(td, uap) + struct thread *td; struct osethostid_args *uap; { int error; mtx_lock(&Giant); - if ((error = suser(p)) == 0) + if ((error = suser_td(td))) hostid = uap->hostid; mtx_unlock(&Giant); return (error); @@ -153,8 +153,8 @@ osethostid(p, uap) * MPSAFE */ int -oquota(p, uap) - struct proc *p; +oquota(td, uap) + struct thread *td; struct oquota_args *uap; { return (ENOSYS); @@ -180,8 +180,8 @@ struct uname_args { */ /* ARGSUSED */ int -uname(p, uap) - struct proc *p; +uname(td, uap) + struct thread *td; struct uname_args *uap; { int name[2], error; @@ -192,7 +192,7 @@ uname(p, uap) name[1] = KERN_OSTYPE; len = sizeof (uap->name->sysname); mtx_lock(&Giant); - error = userland_sysctl(p, name, 2, uap->name->sysname, &len, + error = userland_sysctl(td, name, 2, uap->name->sysname, &len, 1, 0, 0, 0); if (error) goto done2; @@ -200,7 +200,7 @@ uname(p, uap) name[1] = KERN_HOSTNAME; len = sizeof uap->name->nodename; - error = userland_sysctl(p, name, 2, uap->name->nodename, &len, + error = userland_sysctl(td, name, 2, uap->name->nodename, &len, 1, 0, 0, 0); if (error) goto done2; @@ -208,7 +208,7 @@ uname(p, uap) name[1] = KERN_OSRELEASE; len = sizeof uap->name->release; - error = userland_sysctl(p, name, 2, uap->name->release, &len, + error = userland_sysctl(td, name, 2, uap->name->release, &len, 1, 0, 0, 0); if (error) goto done2; @@ -217,7 +217,7 @@ uname(p, uap) /* name = KERN_VERSION; len = sizeof uap->name->version; - error = userland_sysctl(p, name, 2, uap->name->version, &len, + error = userland_sysctl(td, name, 2, uap->name->version, &len, 1, 0, 0, 0); if (error) goto done2; @@ -241,7 +241,7 @@ uname(p, uap) name[0] = CTL_HW; name[1] = HW_MACHINE; len = sizeof uap->name->machine; - error = userland_sysctl(p, name, 2, uap->name->machine, &len, + error = userland_sysctl(td, name, 2, uap->name->machine, &len, 1, 0, 0, 0); if (error) goto done2; @@ -263,8 +263,8 @@ struct getdomainname_args { */ /* ARGSUSED */ int -getdomainname(p, uap) - struct proc *p; +getdomainname(td, uap) + struct thread *td; struct getdomainname_args *uap; { int domainnamelen; @@ -291,14 +291,14 @@ struct setdomainname_args { */ /* ARGSUSED */ int -setdomainname(p, uap) - struct proc *p; +setdomainname(td, uap) + struct thread *td; struct setdomainname_args *uap; { int error, domainnamelen; mtx_lock(&Giant); - if ((error = suser(p))) + if ((error = suser_td(td))) goto done2; if ((u_int)uap->len > sizeof (domainname) - 1) { error = EINVAL; diff --git a/sys/kern/ksched.c b/sys/kern/ksched.c index d118b93..6ad2a07 100644 --- a/sys/kern/ksched.c +++ b/sys/kern/ksched.c @@ -62,9 +62,9 @@ int ksched_attach(struct ksched **p) return 0; } -int ksched_detach(struct ksched *p) +int ksched_detach(struct ksched *ks) { - p31b_free(p); + p31b_free(ks); return 0; } @@ -94,13 +94,13 @@ int ksched_detach(struct ksched *p) #define P1B_PRIO_MAX rtpprio_to_p4prio(RTP_PRIO_MIN) static __inline int -getscheduler(register_t *ret, struct ksched *ksched, struct proc *p) +getscheduler(register_t *ret, struct ksched *ksched, struct thread *td) { struct rtprio rtp; int e = 0; mtx_lock_spin(&sched_lock); - pri_to_rtp(&p->p_pri, &rtp); + pri_to_rtp(&td->td_ksegrp->kg_pri, &rtp); mtx_unlock_spin(&sched_lock); switch (rtp.type) { @@ -121,31 +121,31 @@ getscheduler(register_t *ret, struct ksched *ksched, struct proc *p) } int ksched_setparam(register_t *ret, struct ksched *ksched, - struct proc *p, const struct sched_param *param) + struct thread *td, const struct sched_param *param) { register_t policy; int e; - e = getscheduler(&policy, ksched, p); + e = getscheduler(&policy, ksched, td); if (e == 0) { if (policy == SCHED_OTHER) e = EINVAL; else - e = ksched_setscheduler(ret, ksched, p, policy, param); + e = ksched_setscheduler(ret, ksched, td, policy, param); } return e; } int ksched_getparam(register_t *ret, struct ksched *ksched, - struct proc *p, struct sched_param *param) + struct thread *td, struct sched_param *param) { struct rtprio rtp; mtx_lock_spin(&sched_lock); - pri_to_rtp(&p->p_pri, &rtp); + pri_to_rtp(&td->td_ksegrp->kg_pri, &rtp); mtx_unlock_spin(&sched_lock); if (RTP_PRIO_IS_REALTIME(rtp.type)) param->sched_priority = rtpprio_to_p4prio(rtp.prio); @@ -161,7 +161,7 @@ int ksched_getparam(register_t *ret, struct ksched *ksched, * */ int ksched_setscheduler(register_t *ret, struct ksched *ksched, - struct proc *p, int policy, const struct sched_param *param) + struct thread *td, int policy, const struct sched_param *param) { int e = 0; struct rtprio rtp; @@ -179,8 +179,8 @@ int ksched_setscheduler(register_t *ret, struct ksched *ksched, ? RTP_PRIO_FIFO : RTP_PRIO_REALTIME; mtx_lock_spin(&sched_lock); - rtp_to_pri(&rtp, &p->p_pri); - p->p_sflag |= PS_NEEDRESCHED; + rtp_to_pri(&rtp, &td->td_ksegrp->kg_pri); + td->td_last_kse->ke_flags |= KEF_NEEDRESCHED; /* XXXKSE */ mtx_unlock_spin(&sched_lock); } else @@ -194,7 +194,7 @@ int ksched_setscheduler(register_t *ret, struct ksched *ksched, rtp.type = RTP_PRIO_NORMAL; rtp.prio = p4prio_to_rtpprio(param->sched_priority); mtx_lock_spin(&sched_lock); - rtp_to_pri(&rtp, &p->p_pri); + rtp_to_pri(&rtp, &td->td_ksegrp->kg_pri); /* XXX Simply revert to whatever we had for last * normal scheduler priorities. @@ -202,7 +202,7 @@ int ksched_setscheduler(register_t *ret, struct ksched *ksched, * on the scheduling code: You must leave the * scheduling info alone. */ - p->p_sflag |= PS_NEEDRESCHED; + td->td_last_kse->ke_flags |= KEF_NEEDRESCHED; /* XXXKSE */ mtx_unlock_spin(&sched_lock); } break; @@ -211,9 +211,9 @@ int ksched_setscheduler(register_t *ret, struct ksched *ksched, return e; } -int ksched_getscheduler(register_t *ret, struct ksched *ksched, struct proc *p) +int ksched_getscheduler(register_t *ret, struct ksched *ksched, struct thread *td) { - return getscheduler(ret, ksched, p); + return getscheduler(ret, ksched, td); } /* ksched_yield: Yield the CPU. @@ -221,7 +221,7 @@ int ksched_getscheduler(register_t *ret, struct ksched *ksched, struct proc *p) int ksched_yield(register_t *ret, struct ksched *ksched) { mtx_lock_spin(&sched_lock); - curproc->p_sflag |= PS_NEEDRESCHED; + curthread->td_kse->ke_flags |= KEF_NEEDRESCHED; mtx_unlock_spin(&sched_lock); return 0; } @@ -271,7 +271,7 @@ int ksched_get_priority_min(register_t *ret, struct ksched *ksched, int policy) } int ksched_rr_get_interval(register_t *ret, struct ksched *ksched, - struct proc *p, struct timespec *timespec) + struct thread *td, struct timespec *timespec) { *timespec = ksched->rr_interval; diff --git a/sys/kern/link_aout.c b/sys/kern/link_aout.c index 1218e22..e410b20 100644 --- a/sys/kern/link_aout.c +++ b/sys/kern/link_aout.c @@ -193,14 +193,15 @@ static int link_aout_load_file(linker_class_t lc, const char* filename, linker_file_t* result) { struct nameidata nd; - struct proc* p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ + struct proc *p = td->td_proc; int error = 0; int resid, flags; struct exec header; aout_file_t af; linker_file_t lf = 0; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td); flags = FREAD; error = vn_open(&nd, &flags, 0); if (error) @@ -211,7 +212,7 @@ link_aout_load_file(linker_class_t lc, const char* filename, linker_file_t* resu * Read the a.out header from the file. */ error = vn_rdwr(UIO_READ, nd.ni_vp, (void*) &header, sizeof header, 0, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); if (error) goto out; @@ -236,7 +237,7 @@ link_aout_load_file(linker_class_t lc, const char* filename, linker_file_t* resu */ error = vn_rdwr(UIO_READ, nd.ni_vp, (void*) af->address, header.a_text + header.a_data, 0, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); if (error) goto out; bzero(af->address + header.a_text + header.a_data, header.a_bss); @@ -267,8 +268,8 @@ link_aout_load_file(linker_class_t lc, const char* filename, linker_file_t* resu out: if (error && lf) linker_file_unload(lf); - VOP_UNLOCK(nd.ni_vp, 0, p); - vn_close(nd.ni_vp, FREAD, p->p_ucred, p); + VOP_UNLOCK(nd.ni_vp, 0, td); + vn_close(nd.ni_vp, FREAD, p->p_ucred, td); return error; } diff --git a/sys/kern/link_elf.c b/sys/kern/link_elf.c index 0abf96c..db29c37 100644 --- a/sys/kern/link_elf.c +++ b/sys/kern/link_elf.c @@ -513,7 +513,8 @@ static int link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* result) { struct nameidata nd; - struct proc* p = curproc; /* XXX */ + struct thread* td = curthread; /* XXX */ + struct proc* p = td->td_proc; /* XXX */ Elf_Ehdr *hdr; caddr_t firstpage; int nbytes, i; @@ -546,7 +547,7 @@ link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* resu shdr = NULL; lf = NULL; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td); flags = FREAD; error = vn_open(&nd, &flags, 0); if (error) @@ -563,7 +564,7 @@ link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* resu } hdr = (Elf_Ehdr *)firstpage; error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); nbytes = PAGE_SIZE - resid; if (error) goto out; @@ -702,7 +703,7 @@ link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* resu caddr_t segbase = mapbase + segs[i]->p_vaddr - base_vaddr; error = vn_rdwr(UIO_READ, nd.ni_vp, segbase, segs[i]->p_filesz, segs[i]->p_offset, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); if (error) { goto out; } @@ -756,7 +757,7 @@ link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* resu } error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)shdr, nbytes, hdr->e_shoff, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); if (error) goto out; symtabindex = -1; @@ -781,12 +782,12 @@ link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* resu } error = vn_rdwr(UIO_READ, nd.ni_vp, ef->symbase, symcnt, shdr[symtabindex].sh_offset, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); if (error) goto out; error = vn_rdwr(UIO_READ, nd.ni_vp, ef->strbase, strcnt, shdr[symstrindex].sh_offset, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); if (error) goto out; @@ -817,8 +818,8 @@ out: free(shdr, M_LINKER); if (firstpage) free(firstpage, M_LINKER); - VOP_UNLOCK(nd.ni_vp, 0, p); - vn_close(nd.ni_vp, FREAD, p->p_ucred, p); + VOP_UNLOCK(nd.ni_vp, 0, td); + vn_close(nd.ni_vp, FREAD, p->p_ucred, td); return error; } diff --git a/sys/kern/link_elf_obj.c b/sys/kern/link_elf_obj.c index 0abf96c..db29c37 100644 --- a/sys/kern/link_elf_obj.c +++ b/sys/kern/link_elf_obj.c @@ -513,7 +513,8 @@ static int link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* result) { struct nameidata nd; - struct proc* p = curproc; /* XXX */ + struct thread* td = curthread; /* XXX */ + struct proc* p = td->td_proc; /* XXX */ Elf_Ehdr *hdr; caddr_t firstpage; int nbytes, i; @@ -546,7 +547,7 @@ link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* resu shdr = NULL; lf = NULL; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td); flags = FREAD; error = vn_open(&nd, &flags, 0); if (error) @@ -563,7 +564,7 @@ link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* resu } hdr = (Elf_Ehdr *)firstpage; error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); nbytes = PAGE_SIZE - resid; if (error) goto out; @@ -702,7 +703,7 @@ link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* resu caddr_t segbase = mapbase + segs[i]->p_vaddr - base_vaddr; error = vn_rdwr(UIO_READ, nd.ni_vp, segbase, segs[i]->p_filesz, segs[i]->p_offset, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); if (error) { goto out; } @@ -756,7 +757,7 @@ link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* resu } error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)shdr, nbytes, hdr->e_shoff, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); if (error) goto out; symtabindex = -1; @@ -781,12 +782,12 @@ link_elf_load_file(linker_class_t cls, const char* filename, linker_file_t* resu } error = vn_rdwr(UIO_READ, nd.ni_vp, ef->symbase, symcnt, shdr[symtabindex].sh_offset, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); if (error) goto out; error = vn_rdwr(UIO_READ, nd.ni_vp, ef->strbase, strcnt, shdr[symstrindex].sh_offset, - UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); + UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, td); if (error) goto out; @@ -817,8 +818,8 @@ out: free(shdr, M_LINKER); if (firstpage) free(firstpage, M_LINKER); - VOP_UNLOCK(nd.ni_vp, 0, p); - vn_close(nd.ni_vp, FREAD, p->p_ucred, p); + VOP_UNLOCK(nd.ni_vp, 0, td); + vn_close(nd.ni_vp, FREAD, p->p_ucred, td); return error; } diff --git a/sys/kern/makesyscalls.sh b/sys/kern/makesyscalls.sh index e505379..5134275 100644 --- a/sys/kern/makesyscalls.sh +++ b/sys/kern/makesyscalls.sh @@ -114,6 +114,7 @@ s/\$//g printf "#include <sys/signal.h>\n\n" > sysarg printf "#include <sys/acl.h>\n\n" > sysarg printf "struct proc;\n\n" > sysarg + printf "struct thread;\n\n" > sysarg printf "#define\tPAD_(t)\t(sizeof(register_t) <= sizeof(t) ? \\\n" > sysarg printf "\t\t0 : sizeof(register_t) - sizeof(t))\n\n" > sysarg printf "#if BYTE_ORDER == LITTLE_ENDIAN\n"> sysarg @@ -320,7 +321,7 @@ s/\$//g } if ($2 != "NOPROTO" && (!nosys || funcname != "nosys") && \ (!lkmnosys || funcname != "lkmnosys")) { - printf("%s\t%s __P((struct proc *, struct %s *))", + printf("%s\t%s __P((struct thread *, struct %s *))", rettype, funcname, argalias) > sysdcl printf(";\n") > sysdcl } @@ -370,7 +371,7 @@ s/\$//g else if($2 != "CPT_NOA") printf("struct %s {\n\tregister_t dummy;\n};\n", argalias) > sysarg - printf("%s\to%s __P((struct proc *, struct %s *));\n", + printf("%s\to%s __P((struct thread *, struct %s *));\n", rettype, funcname, argalias) > syscompatdcl printf("\t{ compat(%s%s,%s) },", mpsafe, argssize, funcname) > sysent diff --git a/sys/kern/p1003_1b.c b/sys/kern/p1003_1b.c index 4e43b22..0409d63 100644 --- a/sys/kern/p1003_1b.c +++ b/sys/kern/p1003_1b.c @@ -56,10 +56,10 @@ MALLOC_DEFINE(M_P31B, "p1003.1b", "Posix 1003.1B"); * start to use this when they shouldn't. That will be removed if annoying. */ int -syscall_not_present(struct proc *p, const char *s, struct nosys_args *uap) +syscall_not_present(struct thread *td, const char *s, struct nosys_args *uap) { log(LOG_ERR, "cmd %s pid %d tried to use non-present %s\n", - p->p_comm, p->p_pid, s); + td->td_proc->p_comm, td->td_proc->p_pid, s); /* a " return nosys(p, uap); " here causes a core dump. */ @@ -105,9 +105,10 @@ static int sched_attach(void) /* * MPSAFE */ -int sched_setparam(struct proc *p, +int sched_setparam(struct thread *td, struct sched_setparam_args *uap) { + struct thread *targettd; struct proc *targetp; int e; struct sched_param sched_param; @@ -118,7 +119,8 @@ int sched_setparam(struct proc *p, mtx_lock(&Giant); if (uap->pid == 0) { - targetp = p; + targetp = td->td_proc; + targettd = td; PROC_LOCK(targetp); } else { targetp = pfind(uap->pid); @@ -126,12 +128,13 @@ int sched_setparam(struct proc *p, e = ESRCH; goto done2; } + targettd = &targetp->p_thread; /* XXXKSE */ } - e = p_cansched(p, targetp); + e = p_cansched(td->td_proc, targetp); PROC_UNLOCK(targetp); if (e == 0) { - e = ksched_setparam(&p->p_retval[0], ksched, targetp, + e = ksched_setparam(&td->td_retval[0], ksched, targettd, (const struct sched_param *)&sched_param); } done2: @@ -142,16 +145,18 @@ done2: /* * MPSAFE */ -int sched_getparam(struct proc *p, +int sched_getparam(struct thread *td, struct sched_getparam_args *uap) { int e; struct sched_param sched_param; + struct thread *targettd; struct proc *targetp; mtx_lock(&Giant); if (uap->pid == 0) { - targetp = p; + targetp = td->td_proc; + targettd = td; PROC_LOCK(targetp); } else { targetp = pfind(uap->pid); @@ -159,28 +164,31 @@ int sched_getparam(struct proc *p, e = ESRCH; goto done2; } + targettd = &targetp->p_thread; /* XXXKSE */ } - e = p_cansee(p, targetp); + e = p_cansee(td->td_proc, targetp); PROC_UNLOCK(targetp); if (e) goto done2; - e = ksched_getparam(&p->p_retval[0], ksched, targetp, &sched_param); + e = ksched_getparam(&td->td_retval[0], ksched, targettd, &sched_param); if (e == 0) e = copyout(&sched_param, uap->param, sizeof(sched_param)); done2: mtx_unlock(&Giant); return (e); } + /* * MPSAFE */ -int sched_setscheduler(struct proc *p, +int sched_setscheduler(struct thread *td, struct sched_setscheduler_args *uap) { int e; struct sched_param sched_param; + struct thread *targettd; struct proc *targetp; e = copyin(uap->param, &sched_param, sizeof(sched_param)); @@ -189,7 +197,8 @@ int sched_setscheduler(struct proc *p, mtx_lock(&Giant); if (uap->pid == 0) { - targetp = p; + targetp = td->td_proc; + targettd = td; PROC_LOCK(targetp); } else { targetp = pfind(uap->pid); @@ -197,31 +206,34 @@ int sched_setscheduler(struct proc *p, e = ESRCH; goto done2; } + targettd = &targetp->p_thread; /* XXXKSE */ } - e = p_cansched(p, targetp); + e = p_cansched(td->td_proc, targetp); PROC_UNLOCK(targetp); if (e == 0) { - e = ksched_setscheduler(&p->p_retval[0], ksched, - targetp, uap->policy, - (const struct sched_param *)&sched_param); + e = ksched_setscheduler(&td->td_retval[0], ksched, targettd, + uap->policy, (const struct sched_param *)&sched_param); } done2: mtx_unlock(&Giant); return (e); } + /* * MPSAFE */ -int sched_getscheduler(struct proc *p, +int sched_getscheduler(struct thread *td, struct sched_getscheduler_args *uap) { int e; + struct thread *targettd; struct proc *targetp; mtx_lock(&Giant); if (uap->pid == 0) { - targetp = p; + targetp = td->td_proc; + targettd = td; PROC_LOCK(targetp); } else { targetp = pfind(uap->pid); @@ -229,67 +241,75 @@ int sched_getscheduler(struct proc *p, e = ESRCH; goto done2; } + targettd = &targetp->p_thread; /* XXXKSE */ } - e = p_cansee(p, targetp); + e = p_cansee(td->td_proc, targetp); PROC_UNLOCK(targetp); if (e == 0) - e = ksched_getscheduler(&p->p_retval[0], ksched, targetp); + e = ksched_getscheduler(&td->td_retval[0], ksched, targettd); done2: mtx_unlock(&Giant); return (e); } + /* * MPSAFE */ -int sched_yield(struct proc *p, +int sched_yield(struct thread *td, struct sched_yield_args *uap) { int error; mtx_lock(&Giant); - error = ksched_yield(&p->p_retval[0], ksched); + error = ksched_yield(&td->td_retval[0], ksched); mtx_unlock(&Giant); return (error); } + /* * MPSAFE */ -int sched_get_priority_max(struct proc *p, +int sched_get_priority_max(struct thread *td, struct sched_get_priority_max_args *uap) { int error; mtx_lock(&Giant); - error = ksched_get_priority_max(&p->p_retval[0], ksched, uap->policy); + error = ksched_get_priority_max(&td->td_retval[0], ksched, uap->policy); mtx_unlock(&Giant); return (error); } + /* * MPSAFE */ -int sched_get_priority_min(struct proc *p, +int sched_get_priority_min(struct thread *td, struct sched_get_priority_min_args *uap) { int error; + mtx_lock(&Giant); - error = ksched_get_priority_min(&p->p_retval[0], ksched, uap->policy); + error = ksched_get_priority_min(&td->td_retval[0], ksched, uap->policy); mtx_unlock(&Giant); return (error); } + /* * MPSAFE */ -int sched_rr_get_interval(struct proc *p, +int sched_rr_get_interval(struct thread *td, struct sched_rr_get_interval_args *uap) { int e; + struct thread *targettd; struct proc *targetp; mtx_lock(&Giant); if (uap->pid == 0) { - targetp = p; + targettd = td; + targetp = td->td_proc; PROC_LOCK(targetp); } else { targetp = pfind(uap->pid); @@ -297,12 +317,13 @@ int sched_rr_get_interval(struct proc *p, e = ESRCH; goto done2; } + targettd = &targetp->p_thread; /* XXXKSE */ } - e = p_cansee(p, targetp); + e = p_cansee(td->td_proc, targetp); PROC_UNLOCK(targetp); if (e == 0) { - e = ksched_rr_get_interval(&p->p_retval[0], ksched, targetp, + e = ksched_rr_get_interval(&td->td_retval[0], ksched, targettd, uap->interval); } done2: diff --git a/sys/kern/subr_acl_posix1e.c b/sys/kern/subr_acl_posix1e.c index 69dbe85..045d1a8 100644 --- a/sys/kern/subr_acl_posix1e.c +++ b/sys/kern/subr_acl_posix1e.c @@ -48,11 +48,11 @@ MALLOC_DEFINE(M_ACL, "acl", "access control list"); -static int vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, +static int vacl_set_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp); -static int vacl_get_acl(struct proc *p, struct vnode *vp, acl_type_t type, +static int vacl_get_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp); -static int vacl_aclcheck(struct proc *p, struct vnode *vp, +static int vacl_aclcheck( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp); /* @@ -562,7 +562,7 @@ acl_posix1e_check(struct acl *acl) * Given a vnode, set its ACL. */ static int -vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, +vacl_set_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp) { struct acl inkernacl; @@ -571,10 +571,10 @@ vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, error = copyin(aclp, &inkernacl, sizeof(struct acl)); if (error) return(error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_SETACL(vp, type, &inkernacl, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_SETACL(vp, type, &inkernacl, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); return(error); } @@ -582,16 +582,16 @@ vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, * Given a vnode, get its ACL. */ static int -vacl_get_acl(struct proc *p, struct vnode *vp, acl_type_t type, +vacl_get_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp) { struct acl inkernelacl; int error; - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_GETACL(vp, type, &inkernelacl, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_GETACL(vp, type, &inkernelacl, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); if (error == 0) error = copyout(&inkernelacl, aclp, sizeof(struct acl)); return (error); @@ -601,14 +601,14 @@ vacl_get_acl(struct proc *p, struct vnode *vp, acl_type_t type, * Given a vnode, delete its ACL. */ static int -vacl_delete(struct proc *p, struct vnode *vp, acl_type_t type) +vacl_delete( struct thread *td, struct vnode *vp, acl_type_t type) { int error; - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_SETACL(vp, ACL_TYPE_DEFAULT, 0, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_SETACL(vp, ACL_TYPE_DEFAULT, 0, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); return (error); } @@ -616,7 +616,7 @@ vacl_delete(struct proc *p, struct vnode *vp, acl_type_t type) * Given a vnode, check whether an ACL is appropriate for it */ static int -vacl_aclcheck(struct proc *p, struct vnode *vp, acl_type_t type, +vacl_aclcheck( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp) { struct acl inkernelacl; @@ -625,7 +625,7 @@ vacl_aclcheck(struct proc *p, struct vnode *vp, acl_type_t type, error = copyin(aclp, &inkernelacl, sizeof(struct acl)); if (error) return(error); - error = VOP_ACLCHECK(vp, type, &inkernelacl, p->p_ucred, p); + error = VOP_ACLCHECK(vp, type, &inkernelacl, td->td_proc->p_ucred, td); return (error); } @@ -641,17 +641,17 @@ vacl_aclcheck(struct proc *p, struct vnode *vp, acl_type_t type, * MPSAFE */ int -__acl_get_file(struct proc *p, struct __acl_get_file_args *uap) +__acl_get_file( struct thread *td, struct __acl_get_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); /* what flags are required here -- possible not LOCKLEAF? */ - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_get_acl(p, nd.ni_vp, SCARG(uap, type), + error = vacl_get_acl(td, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp)); NDFREE(&nd, 0); } @@ -665,16 +665,16 @@ __acl_get_file(struct proc *p, struct __acl_get_file_args *uap) * MPSAFE */ int -__acl_set_file(struct proc *p, struct __acl_set_file_args *uap) +__acl_set_file( struct thread *td, struct __acl_set_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_set_acl(p, nd.ni_vp, SCARG(uap, type), + error = vacl_set_acl(td, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp)); NDFREE(&nd, 0); } @@ -688,15 +688,15 @@ __acl_set_file(struct proc *p, struct __acl_set_file_args *uap) * MPSAFE */ int -__acl_get_fd(struct proc *p, struct __acl_get_fd_args *uap) +__acl_get_fd( struct thread *td, struct __acl_get_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_get_acl(p, (struct vnode *)fp->f_data, + error = vacl_get_acl(td, (struct vnode *)fp->f_data, SCARG(uap, type), SCARG(uap, aclp)); } mtx_unlock(&Giant); @@ -709,15 +709,15 @@ __acl_get_fd(struct proc *p, struct __acl_get_fd_args *uap) * MPSAFE */ int -__acl_set_fd(struct proc *p, struct __acl_set_fd_args *uap) +__acl_set_fd( struct thread *td, struct __acl_set_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_set_acl(p, (struct vnode *)fp->f_data, + error = vacl_set_acl(td, (struct vnode *)fp->f_data, SCARG(uap, type), SCARG(uap, aclp)); } mtx_unlock(&Giant); @@ -730,16 +730,16 @@ __acl_set_fd(struct proc *p, struct __acl_set_fd_args *uap) * MPSAFE */ int -__acl_delete_file(struct proc *p, struct __acl_delete_file_args *uap) +__acl_delete_file( struct thread *td, struct __acl_delete_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_delete(p, nd.ni_vp, SCARG(uap, type)); + error = vacl_delete(td, nd.ni_vp, SCARG(uap, type)); NDFREE(&nd, 0); } mtx_unlock(&Giant); @@ -752,15 +752,15 @@ __acl_delete_file(struct proc *p, struct __acl_delete_file_args *uap) * MPSAFE */ int -__acl_delete_fd(struct proc *p, struct __acl_delete_fd_args *uap) +__acl_delete_fd( struct thread *td, struct __acl_delete_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_delete(p, (struct vnode *)fp->f_data, + error = vacl_delete(td, (struct vnode *)fp->f_data, SCARG(uap, type)); } mtx_unlock(&Giant); @@ -773,16 +773,16 @@ __acl_delete_fd(struct proc *p, struct __acl_delete_fd_args *uap) * MPSAFE */ int -__acl_aclcheck_file(struct proc *p, struct __acl_aclcheck_file_args *uap) +__acl_aclcheck_file( struct thread *td, struct __acl_aclcheck_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_aclcheck(p, nd.ni_vp, SCARG(uap, type), + error = vacl_aclcheck(td, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp)); NDFREE(&nd, 0); } @@ -796,15 +796,15 @@ __acl_aclcheck_file(struct proc *p, struct __acl_aclcheck_file_args *uap) * MPSAFE */ int -__acl_aclcheck_fd(struct proc *p, struct __acl_aclcheck_fd_args *uap) +__acl_aclcheck_fd( struct thread *td, struct __acl_aclcheck_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_aclcheck(p, (struct vnode *)fp->f_data, + error = vacl_aclcheck(td, (struct vnode *)fp->f_data, SCARG(uap, type), SCARG(uap, aclp)); } mtx_unlock(&Giant); diff --git a/sys/kern/subr_disk.c b/sys/kern/subr_disk.c index da961ba..4efc5b2 100644 --- a/sys/kern/subr_disk.c +++ b/sys/kern/subr_disk.c @@ -225,7 +225,7 @@ SYSCTL_PROC(_kern, OID_AUTO, disks, CTLTYPE_STRING | CTLFLAG_RD, 0, NULL, */ static int -diskopen(dev_t dev, int oflags, int devtype, struct proc *p) +diskopen(dev_t dev, int oflags, int devtype, struct thread *td) { dev_t pdev; struct disk *dp; @@ -249,7 +249,7 @@ diskopen(dev_t dev, int oflags, int devtype, struct proc *p) if (!dsisopen(dp->d_slice)) { if (!pdev->si_iosize_max) pdev->si_iosize_max = dev->si_iosize_max; - error = dp->d_devsw->d_open(pdev, oflags, devtype, p); + error = dp->d_devsw->d_open(pdev, oflags, devtype, td); } /* Inherit properties from the whole/raw dev_t */ @@ -261,7 +261,7 @@ diskopen(dev_t dev, int oflags, int devtype, struct proc *p) error = dsopen(dev, devtype, dp->d_dsflags, &dp->d_slice, &dp->d_label); if (!dsisopen(dp->d_slice)) - dp->d_devsw->d_close(pdev, oflags, devtype, p); + dp->d_devsw->d_close(pdev, oflags, devtype, td); out: dp->d_flags &= ~DISKFLAG_LOCK; if (dp->d_flags & DISKFLAG_WANTED) { @@ -273,7 +273,7 @@ out: } static int -diskclose(dev_t dev, int fflag, int devtype, struct proc *p) +diskclose(dev_t dev, int fflag, int devtype, struct thread *td) { struct disk *dp; int error; @@ -286,7 +286,7 @@ diskclose(dev_t dev, int fflag, int devtype, struct proc *p) return (ENXIO); dsclose(dev, devtype, dp->d_slice); if (!dsisopen(dp->d_slice)) - error = dp->d_devsw->d_close(dp->d_dev, fflag, devtype, p); + error = dp->d_devsw->d_close(dp->d_dev, fflag, devtype, td); return (error); } @@ -325,7 +325,7 @@ diskstrategy(struct bio *bp) } static int -diskioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) +diskioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct thread *td) { struct disk *dp; int error; @@ -337,7 +337,7 @@ diskioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) return (ENXIO); error = dsioctl(dev, cmd, data, fflag, &dp->d_slice); if (error == ENOIOCTL) - error = dp->d_devsw->d_ioctl(dev, cmd, data, fflag, p); + error = dp->d_devsw->d_ioctl(dev, cmd, data, fflag, td); return (error); } diff --git a/sys/kern/subr_diskslice.c b/sys/kern/subr_diskslice.c index 0e20032..76adaa9 100644 --- a/sys/kern/subr_diskslice.c +++ b/sys/kern/subr_diskslice.c @@ -816,9 +816,9 @@ dssize(dev, sspp) if (ssp == NULL || slice >= ssp->dss_nslices || !(ssp->dss_slices[slice].ds_openmask & (1 << part))) { if (devsw(dev)->d_open(dev, FREAD, S_IFCHR, - (struct proc *)NULL) != 0) + (struct thread *)NULL) != 0) return (-1); - devsw(dev)->d_close(dev, FREAD, S_IFCHR, (struct proc *)NULL); + devsw(dev)->d_close(dev, FREAD, S_IFCHR, (struct thread *)NULL); ssp = *sspp; } lp = ssp->dss_slices[slice].ds_label; diff --git a/sys/kern/subr_eventhandler.c b/sys/kern/subr_eventhandler.c index 7d9fcca..f02fb33 100644 --- a/sys/kern/subr_eventhandler.c +++ b/sys/kern/subr_eventhandler.c @@ -112,7 +112,7 @@ eventhandler_register(struct eventhandler_list *list, char *name, eg->ee.ee_priority = priority; /* sort it into the list */ - lockmgr(&list->el_lock, LK_EXCLUSIVE, NULL, CURPROC); + lockmgr(&list->el_lock, LK_EXCLUSIVE, NULL, curthread); for (ep = TAILQ_FIRST(&list->el_entries); ep != NULL; ep = TAILQ_NEXT(ep, ee_link)) { @@ -123,7 +123,7 @@ eventhandler_register(struct eventhandler_list *list, char *name, } if (ep == NULL) TAILQ_INSERT_TAIL(&list->el_entries, &eg->ee, ee_link); - lockmgr(&list->el_lock, LK_RELEASE, NULL, CURPROC); + lockmgr(&list->el_lock, LK_RELEASE, NULL, curthread); mtx_unlock(&eventhandler_mutex); return(&eg->ee); } @@ -134,7 +134,7 @@ eventhandler_deregister(struct eventhandler_list *list, eventhandler_tag tag) struct eventhandler_entry *ep = tag; /* XXX insert diagnostic check here? */ - lockmgr(&list->el_lock, LK_EXCLUSIVE, NULL, CURPROC); + lockmgr(&list->el_lock, LK_EXCLUSIVE, NULL, curthread); if (ep != NULL) { /* remove just this entry */ TAILQ_REMOVE(&list->el_entries, ep, ee_link); @@ -147,7 +147,7 @@ eventhandler_deregister(struct eventhandler_list *list, eventhandler_tag tag) free(ep, M_EVENTHANDLER); } } - lockmgr(&list->el_lock, LK_RELEASE, NULL, CURPROC); + lockmgr(&list->el_lock, LK_RELEASE, NULL, curthread); } struct eventhandler_list * diff --git a/sys/kern/subr_log.c b/sys/kern/subr_log.c index afcf63f..7fa5618 100644 --- a/sys/kern/subr_log.c +++ b/sys/kern/subr_log.c @@ -98,13 +98,13 @@ SYSCTL_INT(_kern, OID_AUTO, log_wakeups_per_second, CTLFLAG_RW, /*ARGSUSED*/ static int -logopen(dev_t dev, int flags, int mode, struct proc *p) +logopen(dev_t dev, int flags, int mode, struct thread *td) { if (log_open) return (EBUSY); log_open = 1; callout_init(&logsoftc.sc_callout, 0); - fsetown(p->p_pid, &logsoftc.sc_sigio); /* signal process only */ + fsetown(td->td_proc->p_pid, &logsoftc.sc_sigio); /* signal process only */ callout_reset(&logsoftc.sc_callout, hz / log_wakeups_per_second, logtimeout, NULL); return (0); @@ -112,7 +112,7 @@ logopen(dev_t dev, int flags, int mode, struct proc *p) /*ARGSUSED*/ static int -logclose(dev_t dev, int flag, int mode, struct proc *p) +logclose(dev_t dev, int flag, int mode, struct thread *td) { log_open = 0; @@ -167,7 +167,7 @@ logread(dev_t dev, struct uio *uio, int flag) /*ARGSUSED*/ static int -logpoll(dev_t dev, int events, struct proc *p) +logpoll(dev_t dev, int events, struct thread *td) { int s; int revents = 0; @@ -178,7 +178,7 @@ logpoll(dev_t dev, int events, struct proc *p) if (msgbufp->msg_bufr != msgbufp->msg_bufx) revents |= events & (POLLIN | POLLRDNORM); else - selrecord(p, &logsoftc.sc_selp); + selrecord(curthread, &logsoftc.sc_selp); } splx(s); return (revents); @@ -209,7 +209,7 @@ logtimeout(void *arg) /*ARGSUSED*/ static int -logioctl(dev_t dev, u_long com, caddr_t data, int flag, struct proc *p) +logioctl(dev_t dev, u_long com, caddr_t data, int flag, struct thread *td) { long l; int s; diff --git a/sys/kern/subr_mbuf.c b/sys/kern/subr_mbuf.c index 08def9c..65095e0 100644 --- a/sys/kern/subr_mbuf.c +++ b/sys/kern/subr_mbuf.c @@ -862,7 +862,7 @@ mb_reclaim(void) * XXX: to avoid this. */ #ifdef WITNESS - KASSERT(witness_list(curproc) == 0, + KASSERT(witness_list(curthread) == 0, ("mb_reclaim() called with locks held")); #endif diff --git a/sys/kern/subr_prf.c b/sys/kern/subr_prf.c index 3ce2d7d..8708704 100644 --- a/sys/kern/subr_prf.c +++ b/sys/kern/subr_prf.c @@ -109,12 +109,13 @@ tablefull(const char *tab) int uprintf(const char *fmt, ...) { - struct proc *p = curproc; + struct thread *td = curthread; + struct proc *p = td->td_proc; va_list ap; struct putchar_arg pca; int retval = 0; - if (p && p != PCPU_GET(idleproc) && p->p_flag & P_CONTROLT && + if (td && td != PCPU_GET(idlethread) && p->p_flag & P_CONTROLT && p->p_session->s_ttyvp) { va_start(ap, fmt); pca.tty = p->p_session->s_ttyp; diff --git a/sys/kern/subr_prof.c b/sys/kern/subr_prof.c index e177065..ae1d5c3 100644 --- a/sys/kern/subr_prof.c +++ b/sys/kern/subr_prof.c @@ -356,8 +356,8 @@ struct profil_args { */ /* ARGSUSED */ int -profil(p, uap) - struct proc *p; +profil(td, uap) + struct thread *td; register struct profil_args *uap; { register struct uprof *upp; @@ -371,10 +371,10 @@ profil(p, uap) goto done2; } if (uap->scale == 0) { - stopprofclock(p); + stopprofclock(td->td_proc); goto done2; } - upp = &p->p_stats->p_prof; + upp = &td->td_proc->p_stats->p_prof; /* Block profile interrupts while changing state. */ s = splstatclock(); @@ -382,7 +382,7 @@ profil(p, uap) upp->pr_scale = uap->scale; upp->pr_base = uap->samples; upp->pr_size = uap->size; - startprofclock(p); + startprofclock(td->td_proc); splx(s); done2: @@ -413,8 +413,8 @@ done2: * inaccurate. */ void -addupc_intr(p, pc, ticks) - register struct proc *p; +addupc_intr(ke, pc, ticks) + register struct kse *ke; register uintptr_t pc; u_int ticks; { @@ -425,7 +425,7 @@ addupc_intr(p, pc, ticks) if (ticks == 0) return; - prof = &p->p_stats->p_prof; + prof = &ke->ke_proc->p_stats->p_prof; if (pc < prof->pr_off || (i = PC_TO_INDEX(pc, prof)) >= prof->pr_size) return; /* out of range; ignore */ @@ -435,7 +435,7 @@ addupc_intr(p, pc, ticks) mtx_lock_spin(&sched_lock); prof->pr_addr = pc; prof->pr_ticks = ticks; - p->p_sflag |= PS_OWEUPC | PS_ASTPENDING; + ke->ke_flags |= KEF_OWEUPC | KEF_ASTPENDING ; mtx_unlock_spin(&sched_lock); } } @@ -445,11 +445,12 @@ addupc_intr(p, pc, ticks) * update fails, we simply turn off profiling. */ void -addupc_task(p, pc, ticks) - register struct proc *p; +addupc_task(ke, pc, ticks) + register struct kse *ke; register uintptr_t pc; u_int ticks; { + struct proc *p = ke->ke_proc; register struct uprof *prof; register caddr_t addr; register u_int i; diff --git a/sys/kern/subr_smp.c b/sys/kern/subr_smp.c index c107442..03c6612 100644 --- a/sys/kern/subr_smp.c +++ b/sys/kern/subr_smp.c @@ -100,7 +100,7 @@ mp_start(void *dummy) SYSINIT(cpu_mp, SI_SUB_CPU, SI_ORDER_SECOND, mp_start, NULL) void -forward_signal(struct proc *p) +forward_signal(struct thread *td) { int id; @@ -110,9 +110,9 @@ forward_signal(struct proc *p) * executes ast(). */ mtx_assert(&sched_lock, MA_OWNED); - KASSERT(p->p_stat == SRUN, ("forward_signal: process is not SRUN")); + KASSERT(td->td_proc->p_stat == SRUN, ("forward_signal: process is not SRUN")); - CTR1(KTR_SMP, "forward_signal(%p)", p); + CTR1(KTR_SMP, "forward_signal(%p)", td->td_proc); if (!smp_started || cold || panicstr) return; @@ -120,10 +120,10 @@ forward_signal(struct proc *p) return; /* No need to IPI ourself. */ - if (p == curproc) + if (td == curthread) return; - id = p->p_oncpu; + id = td->td_kse->ke_oncpu; if (id == NOCPU) return; ipi_selected(1 << id, IPI_AST); @@ -133,7 +133,7 @@ void forward_roundrobin(void) { struct globaldata *gd; - struct proc *p; + struct thread *td; u_int id, map; mtx_assert(&sched_lock, MA_OWNED); @@ -146,11 +146,11 @@ forward_roundrobin(void) return; map = 0; SLIST_FOREACH(gd, &cpuhead, gd_allcpu) { - p = gd->gd_curproc; + td = gd->gd_curthread; id = gd->gd_cpuid; if (id != PCPU_GET(cpuid) && (id & stopped_cpus) == 0 && - p != gd->gd_idleproc) { - p->p_sflag |= PS_NEEDRESCHED; + td != gd->gd_idlethread) { + td->td_kse->ke_flags |= KEF_NEEDRESCHED; map |= id; } } diff --git a/sys/kern/subr_trap.c b/sys/kern/subr_trap.c index 727fe69..ad96be7 100644 --- a/sys/kern/subr_trap.c +++ b/sys/kern/subr_trap.c @@ -62,11 +62,14 @@ * MPSAFE */ void -userret(p, frame, oticks) - struct proc *p; +userret(td, frame, oticks) + struct thread *td; struct trapframe *frame; u_int oticks; { + struct proc *p = td->td_proc; + struct kse *ke = td->td_kse; + struct ksegrp *kg = td->td_ksegrp; int sig; mtx_lock(&Giant); @@ -77,8 +80,8 @@ userret(p, frame, oticks) mtx_unlock(&Giant); mtx_lock_spin(&sched_lock); - p->p_pri.pri_level = p->p_pri.pri_user; - if (p->p_sflag & PS_NEEDRESCHED) { + kg->kg_pri.pri_level = kg->kg_pri.pri_user; + if (ke->ke_flags & KEF_NEEDRESCHED) { /* * Since we are curproc, a clock interrupt could * change our priority without changing run queues @@ -88,7 +91,7 @@ userret(p, frame, oticks) * indicated by our priority. */ DROP_GIANT_NOSWITCH(); - setrunqueue(p); + setrunqueue(td); p->p_stats->p_ru.ru_nivcsw++; mi_switch(); mtx_unlock_spin(&sched_lock); @@ -105,9 +108,10 @@ userret(p, frame, oticks) /* * Charge system time if profiling. */ - if (p->p_sflag & PS_PROFIL) - addupc_task(p, TRAPF_PC(frame), - ((u_int)p->p_sticks - oticks) * psratio); + if (p->p_sflag & PS_PROFIL) { + addupc_task(ke, TRAPF_PC(frame), + (u_int)(ke->ke_sticks - oticks) * psratio); + } } /* @@ -119,42 +123,47 @@ void ast(framep) struct trapframe *framep; { - struct proc *p = CURPROC; + struct thread *td = curthread; + struct proc *p = td->td_proc; + struct kse *ke = td->td_kse; u_int prticks, sticks; critical_t s; int sflag; + int flags; #if defined(DEV_NPX) && !defined(SMP) int ucode; #endif KASSERT(TRAPF_USERMODE(framep), ("ast in kernel mode")); #ifdef WITNESS - if (witness_list(p)) + if (witness_list(td)) panic("Returning to user mode with mutex(s) held"); #endif mtx_assert(&Giant, MA_NOTOWNED); s = critical_enter(); - while ((p->p_sflag & (PS_ASTPENDING | PS_NEEDRESCHED)) != 0) { + while ((ke->ke_flags & (KEF_ASTPENDING | KEF_NEEDRESCHED)) != 0) { critical_exit(s); - p->p_frame = framep; + td->td_frame = framep; /* * This updates the p_sflag's for the checks below in one * "atomic" operation with turning off the astpending flag. * If another AST is triggered while we are handling the * AST's saved in sflag, the astpending flag will be set and * we will loop again. + * XXXKSE Can't do it atomically in KSE */ mtx_lock_spin(&sched_lock); - sticks = p->p_sticks; + sticks = ke->ke_sticks; sflag = p->p_sflag; - p->p_sflag &= ~(PS_OWEUPC | PS_ALRMPEND | PS_PROFPEND | - PS_ASTPENDING); + flags = ke->ke_flags; + p->p_sflag &= ~(PS_PROFPEND | PS_ALRMPEND); + ke->ke_flags &= ~(KEF_OWEUPC | KEF_ASTPENDING); cnt.v_soft++; - if (sflag & PS_OWEUPC) { + if (flags & KEF_OWEUPC) { prticks = p->p_stats->p_prof.pr_ticks; p->p_stats->p_prof.pr_ticks = 0; mtx_unlock_spin(&sched_lock); - addupc_task(p, p->p_stats->p_prof.pr_addr, prticks); + addupc_task(ke, p->p_stats->p_prof.pr_addr, prticks); } else mtx_unlock_spin(&sched_lock); if (sflag & PS_ALRMPEND) { @@ -178,7 +187,7 @@ ast(framep) PROC_UNLOCK(p); } - userret(p, framep, sticks); + userret(td, framep, sticks); s = critical_enter(); } mtx_assert(&Giant, MA_NOTOWNED); diff --git a/sys/kern/subr_turnstile.c b/sys/kern/subr_turnstile.c index 646d99a..bbcac94 100644 --- a/sys/kern/subr_turnstile.c +++ b/sys/kern/subr_turnstile.c @@ -86,9 +86,9 @@ #define mtx_unowned(m) ((m)->mtx_lock == MTX_UNOWNED) #define mtx_owner(m) (mtx_unowned((m)) ? NULL \ - : (struct proc *)((m)->mtx_lock & MTX_FLAGMASK)) + : (struct thread *)((m)->mtx_lock & MTX_FLAGMASK)) -#define SET_PRIO(p, pri) (p)->p_pri.pri_level = (pri) +#define SET_PRIO(td, pri) (td)->td_ksegrp->kg_pri.pri_level = (pri) /* * Lock classes for sleep and spin mutexes. @@ -105,113 +105,118 @@ struct lock_class lock_class_mtx_spin = { /* * Prototypes for non-exported routines. */ -static void propagate_priority(struct proc *); +static void propagate_priority(struct thread *); static void -propagate_priority(struct proc *p) +propagate_priority(struct thread *td) { - int pri = p->p_pri.pri_level; - struct mtx *m = p->p_blocked; + struct ksegrp *kg = td->td_ksegrp; + int pri = kg->kg_pri.pri_level; + struct mtx *m = td->td_blocked; mtx_assert(&sched_lock, MA_OWNED); for (;;) { - struct proc *p1; + struct thread *td1; - p = mtx_owner(m); + td = mtx_owner(m); - if (p == NULL) { + if (td == NULL) { /* * This really isn't quite right. Really - * ought to bump priority of process that + * ought to bump priority of thread that * next acquires the mutex. */ MPASS(m->mtx_lock == MTX_CONTESTED); return; } - MPASS(p->p_magic == P_MAGIC); - KASSERT(p->p_stat != SSLEEP, ("sleeping process owns a mutex")); - if (p->p_pri.pri_level <= pri) + MPASS(td->td_proc->p_magic == P_MAGIC); + KASSERT(td->td_proc->p_stat != SSLEEP, ("sleeping thread owns a mutex")); + if (kg->kg_pri.pri_level <= pri) /* lower is higher priority */ return; /* - * Bump this process' priority. + * Bump this thread's priority. */ - SET_PRIO(p, pri); + SET_PRIO(td, pri); /* * If lock holder is actually running, just bump priority. */ - if (p->p_oncpu != NOCPU) { - MPASS(p->p_stat == SRUN || p->p_stat == SZOMB || p->p_stat == SSTOP); + /* XXXKSE this test is not sufficient */ + if (td->td_kse && (td->td_kse->ke_oncpu != NOCPU)) { + MPASS(td->td_proc->p_stat == SRUN + || td->td_proc->p_stat == SZOMB + || td->td_proc->p_stat == SSTOP); return; } #ifndef SMP /* - * For UP, we check to see if p is curproc (this shouldn't + * For UP, we check to see if td is curthread (this shouldn't * ever happen however as it would mean we are in a deadlock.) */ - KASSERT(p != curproc, ("Deadlock detected")); + KASSERT(td != curthread, ("Deadlock detected")); #endif /* - * If on run queue move to new run queue, and - * quit. + * If on run queue move to new run queue, and quit. + * XXXKSE this gets a lot more complicated under threads + * but try anyhow. */ - if (p->p_stat == SRUN) { - MPASS(p->p_blocked == NULL); - remrunqueue(p); - setrunqueue(p); + if (td->td_proc->p_stat == SRUN) { + MPASS(td->td_blocked == NULL); + remrunqueue(td); + setrunqueue(td); return; } /* * If we aren't blocked on a mutex, we should be. */ - KASSERT(p->p_stat == SMTX, ( + KASSERT(td->td_proc->p_stat == SMTX, ( "process %d(%s):%d holds %s but isn't blocked on a mutex\n", - p->p_pid, p->p_comm, p->p_stat, + td->td_proc->p_pid, td->td_proc->p_comm, td->td_proc->p_stat, m->mtx_object.lo_name)); /* - * Pick up the mutex that p is blocked on. + * Pick up the mutex that td is blocked on. */ - m = p->p_blocked; + m = td->td_blocked; MPASS(m != NULL); /* - * Check if the proc needs to be moved up on + * Check if the thread needs to be moved up on * the blocked chain */ - if (p == TAILQ_FIRST(&m->mtx_blocked)) { + if (td == TAILQ_FIRST(&m->mtx_blocked)) { continue; } - p1 = TAILQ_PREV(p, procqueue, p_procq); - if (p1->p_pri.pri_level <= pri) { + td1 = TAILQ_PREV(td, threadqueue, td_blkq); + if (td1->td_ksegrp->kg_pri.pri_level <= pri) { continue; } /* - * Remove proc from blocked chain and determine where - * it should be moved up to. Since we know that p1 has - * a lower priority than p, we know that at least one - * process in the chain has a lower priority and that - * p1 will thus not be NULL after the loop. + * Remove thread from blocked chain and determine where + * it should be moved up to. Since we know that td1 has + * a lower priority than td, we know that at least one + * thread in the chain has a lower priority and that + * td1 will thus not be NULL after the loop. */ - TAILQ_REMOVE(&m->mtx_blocked, p, p_procq); - TAILQ_FOREACH(p1, &m->mtx_blocked, p_procq) { - MPASS(p1->p_magic == P_MAGIC); - if (p1->p_pri.pri_level > pri) + TAILQ_REMOVE(&m->mtx_blocked, td, td_blkq); + TAILQ_FOREACH(td1, &m->mtx_blocked, td_blkq) { + MPASS(td1->td_proc->p_magic == P_MAGIC); + if (td1->td_ksegrp->kg_pri.pri_level > pri) break; } - MPASS(p1 != NULL); - TAILQ_INSERT_BEFORE(p1, p, p_procq); + MPASS(td1 != NULL); + TAILQ_INSERT_BEFORE(td1, td, td_blkq); CTR4(KTR_LOCK, "propagate_priority: p %p moved before %p on [%p] %s", - p, p1, m, m->mtx_object.lo_name); + td, td1, m, m->mtx_object.lo_name); } } @@ -257,7 +262,7 @@ _mtx_trylock(struct mtx *m, int opts, const char *file, int line) { int rval; - MPASS(curproc != NULL); + MPASS(curthread != NULL); /* * _mtx_trylock does not accept MTX_NOSWITCH option. @@ -265,7 +270,7 @@ _mtx_trylock(struct mtx *m, int opts, const char *file, int line) KASSERT((opts & MTX_NOSWITCH) == 0, ("mtx_trylock() called with invalid option flag(s) %d", opts)); - rval = _obtain_lock(m, curproc); + rval = _obtain_lock(m, curthread); LOCK_LOG_TRY("LOCK", &m->mtx_object, opts, rval, file, line); if (rval) { @@ -291,9 +296,10 @@ _mtx_trylock(struct mtx *m, int opts, const char *file, int line) void _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line) { - struct proc *p = curproc; + struct thread *td = curthread; + struct ksegrp *kg = td->td_ksegrp; - if ((m->mtx_lock & MTX_FLAGMASK) == (uintptr_t)p) { + if ((m->mtx_lock & MTX_FLAGMASK) == (uintptr_t)td) { m->mtx_recurse++; atomic_set_ptr(&m->mtx_lock, MTX_RECURSED); if (LOCK_LOG_TEST(&m->mtx_object, opts)) @@ -306,9 +312,9 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line) "_mtx_lock_sleep: %s contested (lock=%p) at %s:%d", m->mtx_object.lo_name, (void *)m->mtx_lock, file, line); - while (!_obtain_lock(m, p)) { + while (!_obtain_lock(m, td)) { uintptr_t v; - struct proc *p1; + struct thread *td1; mtx_lock_spin(&sched_lock); /* @@ -322,15 +328,15 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line) /* * The mutex was marked contested on release. This means that - * there are processes blocked on it. + * there are threads blocked on it. */ if (v == MTX_CONTESTED) { - p1 = TAILQ_FIRST(&m->mtx_blocked); - MPASS(p1 != NULL); - m->mtx_lock = (uintptr_t)p | MTX_CONTESTED; + td1 = TAILQ_FIRST(&m->mtx_blocked); + MPASS(td1 != NULL); + m->mtx_lock = (uintptr_t)td | MTX_CONTESTED; - if (p1->p_pri.pri_level < p->p_pri.pri_level) - SET_PRIO(p, p1->p_pri.pri_level); + if (td1->td_ksegrp->kg_pri.pri_level < kg->kg_pri.pri_level) + SET_PRIO(td, td1->td_ksegrp->kg_pri.pri_level); mtx_unlock_spin(&sched_lock); return; } @@ -357,8 +363,8 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line) * If we're borrowing an interrupted thread's VM context, we * must clean up before going to sleep. */ - if (p->p_ithd != NULL) { - struct ithd *it = p->p_ithd; + if (td->td_ithd != NULL) { + struct ithd *it = td->td_ithd; if (it->it_interrupted) { if (LOCK_LOG_TEST(&m->mtx_object, opts)) @@ -374,39 +380,39 @@ _mtx_lock_sleep(struct mtx *m, int opts, const char *file, int line) * Put us on the list of threads blocked on this mutex. */ if (TAILQ_EMPTY(&m->mtx_blocked)) { - p1 = (struct proc *)(m->mtx_lock & MTX_FLAGMASK); - LIST_INSERT_HEAD(&p1->p_contested, m, mtx_contested); - TAILQ_INSERT_TAIL(&m->mtx_blocked, p, p_procq); + td1 = (struct thread *)(m->mtx_lock & MTX_FLAGMASK); + LIST_INSERT_HEAD(&td1->td_contested, m, mtx_contested); + TAILQ_INSERT_TAIL(&m->mtx_blocked, td, td_blkq); } else { - TAILQ_FOREACH(p1, &m->mtx_blocked, p_procq) - if (p1->p_pri.pri_level > p->p_pri.pri_level) + TAILQ_FOREACH(td1, &m->mtx_blocked, td_blkq) + if (td1->td_ksegrp->kg_pri.pri_level > kg->kg_pri.pri_level) break; - if (p1) - TAILQ_INSERT_BEFORE(p1, p, p_procq); + if (td1) + TAILQ_INSERT_BEFORE(td1, td, td_blkq); else - TAILQ_INSERT_TAIL(&m->mtx_blocked, p, p_procq); + TAILQ_INSERT_TAIL(&m->mtx_blocked, td, td_blkq); } /* * Save who we're blocked on. */ - p->p_blocked = m; - p->p_mtxname = m->mtx_object.lo_name; - p->p_stat = SMTX; - propagate_priority(p); + td->td_blocked = m; + td->td_mtxname = m->mtx_object.lo_name; + td->td_proc->p_stat = SMTX; + propagate_priority(td); if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR3(KTR_LOCK, - "_mtx_lock_sleep: p %p blocked on [%p] %s", p, m, + "_mtx_lock_sleep: p %p blocked on [%p] %s", td, m, m->mtx_object.lo_name); - p->p_stats->p_ru.ru_nvcsw++; + td->td_proc->p_stats->p_ru.ru_nvcsw++; mi_switch(); if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR3(KTR_LOCK, "_mtx_lock_sleep: p %p free from blocked on [%p] %s", - p, m, m->mtx_object.lo_name); + td, m, m->mtx_object.lo_name); mtx_unlock_spin(&sched_lock); } @@ -430,7 +436,7 @@ _mtx_lock_spin(struct mtx *m, int opts, critical_t mtx_crit, const char *file, CTR1(KTR_LOCK, "_mtx_lock_spin: %p spinning", m); for (;;) { - if (_obtain_lock(m, curproc)) + if (_obtain_lock(m, curthread)) break; /* Give interrupts a chance while we spin. */ @@ -467,11 +473,13 @@ _mtx_lock_spin(struct mtx *m, int opts, critical_t mtx_crit, const char *file, void _mtx_unlock_sleep(struct mtx *m, int opts, const char *file, int line) { - struct proc *p, *p1; + struct thread *td, *td1; struct mtx *m1; int pri; + struct ksegrp *kg; - p = curproc; + td = curthread; + kg = td->td_ksegrp; if (mtx_recursed(m)) { if (--(m->mtx_recurse) == 0) @@ -485,11 +493,11 @@ _mtx_unlock_sleep(struct mtx *m, int opts, const char *file, int line) if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR1(KTR_LOCK, "_mtx_unlock_sleep: %p contested", m); - p1 = TAILQ_FIRST(&m->mtx_blocked); - MPASS(p->p_magic == P_MAGIC); - MPASS(p1->p_magic == P_MAGIC); + td1 = TAILQ_FIRST(&m->mtx_blocked); + MPASS(td->td_proc->p_magic == P_MAGIC); + MPASS(td1->td_proc->p_magic == P_MAGIC); - TAILQ_REMOVE(&m->mtx_blocked, p1, p_procq); + TAILQ_REMOVE(&m->mtx_blocked, td1, td_blkq); if (TAILQ_EMPTY(&m->mtx_blocked)) { LIST_REMOVE(m, mtx_contested); @@ -500,28 +508,28 @@ _mtx_unlock_sleep(struct mtx *m, int opts, const char *file, int line) atomic_store_rel_ptr(&m->mtx_lock, (void *)MTX_CONTESTED); pri = PRI_MAX; - LIST_FOREACH(m1, &p->p_contested, mtx_contested) { - int cp = TAILQ_FIRST(&m1->mtx_blocked)->p_pri.pri_level; + LIST_FOREACH(m1, &td->td_contested, mtx_contested) { + int cp = TAILQ_FIRST(&m1->mtx_blocked)->td_ksegrp->kg_pri.pri_level; if (cp < pri) pri = cp; } - if (pri > p->p_pri.pri_native) - pri = p->p_pri.pri_native; - SET_PRIO(p, pri); + if (pri > kg->kg_pri.pri_native) + pri = kg->kg_pri.pri_native; + SET_PRIO(td, pri); if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR2(KTR_LOCK, "_mtx_unlock_sleep: %p contested setrunqueue %p", - m, p1); + m, td1); - p1->p_blocked = NULL; - p1->p_stat = SRUN; - setrunqueue(p1); + td1->td_blocked = NULL; + td1->td_proc->p_stat = SRUN; + setrunqueue(td1); - if ((opts & MTX_NOSWITCH) == 0 && p1->p_pri.pri_level < pri) { + if ((opts & MTX_NOSWITCH) == 0 && td1->td_ksegrp->kg_pri.pri_level < pri) { #ifdef notyet - if (p->p_ithd != NULL) { - struct ithd *it = p->p_ithd; + if (td->td_ithd != NULL) { + struct ithd *it = td->td_ithd; if (it->it_interrupted) { if (LOCK_LOG_TEST(&m->mtx_object, opts)) @@ -532,13 +540,13 @@ _mtx_unlock_sleep(struct mtx *m, int opts, const char *file, int line) } } #endif - setrunqueue(p); + setrunqueue(td); if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR2(KTR_LOCK, "_mtx_unlock_sleep: %p switching out lock=%p", m, (void *)m->mtx_lock); - p->p_stats->p_ru.ru_nivcsw++; + td->td_proc->p_stats->p_ru.ru_nivcsw++; mi_switch(); if (LOCK_LOG_TEST(&m->mtx_object, opts)) CTR2(KTR_LOCK, "_mtx_unlock_sleep: %p resuming lock=%p", diff --git a/sys/kern/subr_witness.c b/sys/kern/subr_witness.c index ecbafd0..51ccd49 100644 --- a/sys/kern/subr_witness.c +++ b/sys/kern/subr_witness.c @@ -464,6 +464,7 @@ witness_lock(struct lock_object *lock, int flags, const char *file, int line) struct lock_class *class; struct witness *w, *w1; struct proc *p; + struct thread *td; int i, j; #ifdef DDB int go_into_ddb = 0; @@ -474,7 +475,8 @@ witness_lock(struct lock_object *lock, int flags, const char *file, int line) return; w = lock->lo_witness; class = lock->lo_class; - p = curproc; + td = curthread; + p = td->td_proc; /* * We have to hold a spinlock to keep lock_list valid across the check @@ -493,7 +495,7 @@ witness_lock(struct lock_object *lock, int flags, const char *file, int line) panic("blockable sleep lock (%s) %s @ %s:%d", class->lc_name, lock->lo_name, file, line); } - lock_list = &p->p_sleeplocks; + lock_list = &td->td_sleeplocks; } mtx_unlock_spin(&w_mtx); @@ -732,7 +734,7 @@ witness_upgrade(struct lock_object *lock, int flags, const char *file, int line) if ((lock->lo_class->lc_flags & LC_SLEEPLOCK) == 0) panic("upgrade of non-sleep lock (%s) %s @ %s:%d", class->lc_name, lock->lo_name, file, line); - instance = find_instance(curproc->p_sleeplocks, lock); + instance = find_instance(curthread->td_sleeplocks, lock); if (instance == NULL) panic("upgrade of unlocked lock (%s) %s @ %s:%d", class->lc_name, lock->lo_name, file, line); @@ -763,7 +765,7 @@ witness_downgrade(struct lock_object *lock, int flags, const char *file, if ((lock->lo_class->lc_flags & LC_SLEEPLOCK) == 0) panic("downgrade of non-sleep lock (%s) %s @ %s:%d", class->lc_name, lock->lo_name, file, line); - instance = find_instance(curproc->p_sleeplocks, lock); + instance = find_instance(curthread->td_sleeplocks, lock); if (instance == NULL) panic("downgrade of unlocked lock (%s) %s @ %s:%d", class->lc_name, lock->lo_name, file, line); @@ -784,16 +786,18 @@ witness_unlock(struct lock_object *lock, int flags, const char *file, int line) struct lock_instance *instance; struct lock_class *class; struct proc *p; + struct thread *td; critical_t s; int i, j; if (witness_cold || witness_dead || lock->lo_witness == NULL || panicstr != NULL) return; - p = curproc; + td = curthread; + p = td->td_proc; class = lock->lo_class; if (class->lc_flags & LC_SLEEPLOCK) - lock_list = &p->p_sleeplocks; + lock_list = &td->td_sleeplocks; else lock_list = PCPU_PTR(spinlocks); for (; *lock_list != NULL; lock_list = &(*lock_list)->ll_next) @@ -883,6 +887,7 @@ witness_sleep(int check_only, struct lock_object *lock, const char *file, struct lock_list_entry **lock_list, *lle; struct lock_instance *lock1; struct proc *p; + struct thread *td; critical_t savecrit; int i, n; @@ -894,8 +899,9 @@ witness_sleep(int check_only, struct lock_object *lock, const char *file, * Preemption bad because we need PCPU_PTR(spinlocks) to not change. */ savecrit = critical_enter(); - p = curproc; - lock_list = &p->p_sleeplocks; + td = curthread; + p = td->td_proc; + lock_list = &td->td_sleeplocks; again: for (lle = *lock_list; lle != NULL; lle = lle->ll_next) for (i = lle->ll_count - 1; i >= 0; i--) { @@ -920,7 +926,7 @@ again: lock1->li_lock->lo_name, lock1->li_file, lock1->li_line); } - if (lock_list == &p->p_sleeplocks) { + if (lock_list == &td->td_sleeplocks) { lock_list = PCPU_PTR(spinlocks); goto again; } @@ -1323,35 +1329,35 @@ witness_list_locks(struct lock_list_entry **lock_list) } /* - * Calling this on p != curproc is bad unless we are in ddb. + * Calling this on td != curthread is bad unless we are in ddb. */ int -witness_list(struct proc *p) +witness_list(struct thread *td) { critical_t savecrit; int nheld; KASSERT(!witness_cold, ("%s: witness_cold", __func__)); #ifdef DDB - KASSERT(p == curproc || db_active, - ("%s: p != curproc and we aren't in the debugger", __func__)); + KASSERT(td == curthread || db_active, + ("%s: td != curthread and we aren't in the debugger", __func__)); if (!db_active && witness_dead) return (0); #else - KASSERT(p == curproc, ("%s: p != curproc", __func__)); + KASSERT(td == curthread, ("%s: p != curthread", __func__)); if (witness_dead) return (0); #endif - nheld = witness_list_locks(&p->p_sleeplocks); + nheld = witness_list_locks(&td->td_sleeplocks); /* - * We only handle spinlocks if p == curproc. This is somewhat broken + * We only handle spinlocks if td == curthread. This is somewhat broken * if p is currently executing on some other CPU and holds spin locks * as we won't display those locks. If we had a MI way of getting * the per-cpu data for a given cpu then we could use p->p_oncpu to * get the list of spinlocks for this process and "fix" this. */ - if (p == curproc) { + if (td == curthread) { /* * Preemption bad because we need PCPU_PTR(spinlocks) to not * change. @@ -1374,7 +1380,7 @@ witness_save(struct lock_object *lock, const char **filep, int *linep) if ((lock->lo_class->lc_flags & LC_SLEEPLOCK) == 0) panic("%s: lock (%s) %s is not a sleep lock", __func__, lock->lo_class->lc_name, lock->lo_name); - instance = find_instance(curproc->p_sleeplocks, lock); + instance = find_instance(curthread->td_sleeplocks, lock); if (instance == NULL) panic("%s: lock (%s) %s not locked", __func__, lock->lo_class->lc_name, lock->lo_name); @@ -1393,7 +1399,7 @@ witness_restore(struct lock_object *lock, const char *file, int line) if ((lock->lo_class->lc_flags & LC_SLEEPLOCK) == 0) panic("%s: lock (%s) %s is not a sleep lock", __func__, lock->lo_class->lc_name, lock->lo_name); - instance = find_instance(curproc->p_sleeplocks, lock); + instance = find_instance(curthread->td_sleeplocks, lock); if (instance == NULL) panic("%s: lock (%s) %s not locked", __func__, lock->lo_class->lc_name, lock->lo_name); @@ -1412,7 +1418,7 @@ witness_assert(struct lock_object *lock, int flags, const char *file, int line) if (lock->lo_witness == NULL || witness_dead || panicstr != NULL) return; if ((lock->lo_class->lc_flags & LC_SLEEPLOCK) != 0) - instance = find_instance(curproc->p_sleeplocks, lock); + instance = find_instance(curthread->td_sleeplocks, lock); else if ((lock->lo_class->lc_flags & LC_SPINLOCK) != 0) instance = find_instance(PCPU_GET(spinlocks), lock); else @@ -1464,15 +1470,16 @@ witness_assert(struct lock_object *lock, int flags, const char *file, int line) DB_SHOW_COMMAND(locks, db_witness_list) { - struct proc *p; + struct thread *td; pid_t pid; + struct proc *p; if (have_addr) { pid = (addr % 16) + ((addr >> 4) % 16) * 10 + ((addr >> 8) % 16) * 100 + ((addr >> 12) % 16) * 1000 + ((addr >> 16) % 16) * 10000; /* sx_slock(&allproc_lock); */ - LIST_FOREACH(p, &allproc, p_list) { + FOREACH_PROC_IN_SYSTEM(p) { if (p->p_pid == pid) break; } @@ -1481,9 +1488,11 @@ DB_SHOW_COMMAND(locks, db_witness_list) db_printf("pid %d not found\n", pid); return; } - } else - p = curproc; - witness_list(p); + td = &p->p_thread; /* XXXKSE */ + } else { + td = curthread; + } + witness_list(td); } DB_SHOW_COMMAND(witness, db_witness_display) diff --git a/sys/kern/subr_xxx.c b/sys/kern/subr_xxx.c index f3fd2ed..094b67c 100644 --- a/sys/kern/subr_xxx.c +++ b/sys/kern/subr_xxx.c @@ -80,22 +80,22 @@ nullop() */ int -noopen(dev, flags, fmt, p) +noopen(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { return (ENODEV); } int -noclose(dev, flags, fmt, p) +noclose(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { return (ENODEV); @@ -122,12 +122,12 @@ nowrite(dev, uio, ioflag) } int -noioctl(dev, cmd, data, flags, p) +noioctl(dev, cmd, data, flags, td) dev_t dev; u_long cmd; caddr_t data; int flags; - struct proc *p; + struct thread *td; { return (ENODEV); @@ -172,22 +172,22 @@ nodump(dev) * minor number. */ int -nullopen(dev, flags, fmt, p) +nullopen(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { return (0); } int -nullclose(dev, flags, fmt, p) +nullclose(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { return (0); diff --git a/sys/kern/sys_generic.c b/sys/kern/sys_generic.c index 945530a..a897979 100644 --- a/sys/kern/sys_generic.c +++ b/sys/kern/sys_generic.c @@ -74,13 +74,13 @@ static MALLOC_DEFINE(M_IOCTLOPS, "ioctlops", "ioctl data buffer"); static MALLOC_DEFINE(M_SELECT, "select", "select() buffer"); MALLOC_DEFINE(M_IOV, "iov", "large iov's"); -static int pollscan __P((struct proc *, struct pollfd *, u_int)); -static int pollholddrop __P((struct proc *, struct pollfd *, u_int, int)); -static int selscan __P((struct proc *, fd_mask **, fd_mask **, int)); -static int selholddrop __P((struct proc *, fd_mask *, fd_mask *, int, int)); -static int dofileread __P((struct proc *, struct file *, int, void *, +static int pollscan __P((struct thread *, struct pollfd *, u_int)); +static int pollholddrop __P((struct thread *, struct pollfd *, u_int, int)); +static int selscan __P((struct thread *, fd_mask **, fd_mask **, int)); +static int selholddrop __P((struct thread *, fd_mask *, fd_mask *, int, int)); +static int dofileread __P((struct thread *, struct file *, int, void *, size_t, off_t, int)); -static int dofilewrite __P((struct proc *, struct file *, int, +static int dofilewrite __P((struct thread *, struct file *, int, const void *, size_t, off_t, int)); struct file* @@ -113,18 +113,18 @@ struct read_args { * MPSAFE */ int -read(p, uap) - struct proc *p; +read(td, uap) + struct thread *td; register struct read_args *uap; { register struct file *fp; int error; mtx_lock(&Giant); - if ((fp = holdfp(p->p_fd, uap->fd, FREAD)) != NULL) { - error = dofileread(p, fp, uap->fd, uap->buf, + if ((fp = holdfp(td->td_proc->p_fd, uap->fd, FREAD)) != NULL) { + error = dofileread(td, fp, uap->fd, uap->buf, uap->nbyte, (off_t)-1, 0); - fdrop(fp, p); + fdrop(fp, td); } else { error = EBADF; } @@ -148,23 +148,23 @@ struct pread_args { * MPSAFE */ int -pread(p, uap) - struct proc *p; +pread(td, uap) + struct thread *td; register struct pread_args *uap; { register struct file *fp; int error; mtx_lock(&Giant); - if ((fp = holdfp(p->p_fd, uap->fd, FREAD)) == NULL) { + if ((fp = holdfp(td->td_proc->p_fd, uap->fd, FREAD)) == NULL) { error = EBADF; } else if (fp->f_type != DTYPE_VNODE) { error = ESPIPE; - fdrop(fp, p); + fdrop(fp, td); } else { - error = dofileread(p, fp, uap->fd, uap->buf, uap->nbyte, + error = dofileread(td, fp, uap->fd, uap->buf, uap->nbyte, uap->offset, FOF_OFFSET); - fdrop(fp, p); + fdrop(fp, td); } mtx_unlock(&Giant); return(error); @@ -174,8 +174,8 @@ pread(p, uap) * Code common for read and pread */ int -dofileread(p, fp, fd, buf, nbyte, offset, flags) - struct proc *p; +dofileread(td, fp, fd, buf, nbyte, offset, flags) + struct thread *td; struct file *fp; int fd, flags; void *buf; @@ -201,12 +201,12 @@ dofileread(p, fp, fd, buf, nbyte, offset, flags) auio.uio_resid = nbyte; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; #ifdef KTRACE /* * if tracing, save a copy of iovec */ - if (KTRPOINT(p, KTR_GENIO)) { + if (KTRPOINT(td->td_proc, KTR_GENIO)) { ktriov = aiov; ktruio = auio; didktr = 1; @@ -214,7 +214,7 @@ dofileread(p, fp, fd, buf, nbyte, offset, flags) #endif cnt = nbyte; - if ((error = fo_read(fp, &auio, fp->f_cred, flags, p))) { + if ((error = fo_read(fp, &auio, fp->f_cred, flags, td))) { if (auio.uio_resid != cnt && (error == ERESTART || error == EINTR || error == EWOULDBLOCK)) error = 0; @@ -224,10 +224,10 @@ dofileread(p, fp, fd, buf, nbyte, offset, flags) if (didktr && error == 0) { ktruio.uio_iov = &ktriov; ktruio.uio_resid = cnt; - ktrgenio(p->p_tracep, fd, UIO_READ, &ktruio, error); + ktrgenio(td->td_proc->p_tracep, fd, UIO_READ, &ktruio, error); } #endif - p->p_retval[0] = cnt; + td->td_retval[0] = cnt; return (error); } @@ -245,8 +245,8 @@ struct readv_args { * MPSAFE */ int -readv(p, uap) - struct proc *p; +readv(td, uap) + struct thread *td; register struct readv_args *uap; { register struct file *fp; @@ -262,7 +262,7 @@ readv(p, uap) struct uio ktruio; #endif mtx_lock(&Giant); - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if ((fp = holdfp(fdp, uap->fd, FREAD)) == NULL) { error = EBADF; @@ -285,7 +285,7 @@ readv(p, uap) auio.uio_iovcnt = uap->iovcnt; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = -1; if ((error = copyin((caddr_t)uap->iovp, (caddr_t)iov, iovlen))) goto done; @@ -302,14 +302,14 @@ readv(p, uap) /* * if tracing, save a copy of iovec */ - if (KTRPOINT(p, KTR_GENIO)) { + if (KTRPOINT(td->td_proc, KTR_GENIO)) { MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen); ktruio = auio; } #endif cnt = auio.uio_resid; - if ((error = fo_read(fp, &auio, fp->f_cred, 0, p))) { + if ((error = fo_read(fp, &auio, fp->f_cred, 0, td))) { if (auio.uio_resid != cnt && (error == ERESTART || error == EINTR || error == EWOULDBLOCK)) error = 0; @@ -320,15 +320,15 @@ readv(p, uap) if (error == 0) { ktruio.uio_iov = ktriov; ktruio.uio_resid = cnt; - ktrgenio(p->p_tracep, uap->fd, UIO_READ, &ktruio, + ktrgenio(td->td_proc->p_tracep, uap->fd, UIO_READ, &ktruio, error); } FREE(ktriov, M_TEMP); } #endif - p->p_retval[0] = cnt; + td->td_retval[0] = cnt; done: - fdrop(fp, p); + fdrop(fp, td); if (needfree) FREE(needfree, M_IOV); done2: @@ -350,18 +350,18 @@ struct write_args { * MPSAFE */ int -write(p, uap) - struct proc *p; +write(td, uap) + struct thread *td; register struct write_args *uap; { register struct file *fp; int error; mtx_lock(&Giant); - if ((fp = holdfp(p->p_fd, uap->fd, FWRITE)) != NULL) { - error = dofilewrite(p, fp, uap->fd, uap->buf, uap->nbyte, + if ((fp = holdfp(td->td_proc->p_fd, uap->fd, FWRITE)) != NULL) { + error = dofilewrite(td, fp, uap->fd, uap->buf, uap->nbyte, (off_t)-1, 0); - fdrop(fp, p); + fdrop(fp, td); } else { error = EBADF; } @@ -385,31 +385,31 @@ struct pwrite_args { * MPSAFE */ int -pwrite(p, uap) - struct proc *p; +pwrite(td, uap) + struct thread *td; register struct pwrite_args *uap; { register struct file *fp; int error; mtx_lock(&Giant); - if ((fp = holdfp(p->p_fd, uap->fd, FWRITE)) == NULL) { + if ((fp = holdfp(td->td_proc->p_fd, uap->fd, FWRITE)) == NULL) { error = EBADF; } else if (fp->f_type != DTYPE_VNODE) { error = ESPIPE; - fdrop(fp, p); + fdrop(fp, td); } else { - error = dofilewrite(p, fp, uap->fd, uap->buf, uap->nbyte, + error = dofilewrite(td, fp, uap->fd, uap->buf, uap->nbyte, uap->offset, FOF_OFFSET); - fdrop(fp, p); + fdrop(fp, td); } mtx_unlock(&Giant); return(error); } static int -dofilewrite(p, fp, fd, buf, nbyte, offset, flags) - struct proc *p; +dofilewrite(td, fp, fd, buf, nbyte, offset, flags) + struct thread *td; struct file *fp; int fd, flags; const void *buf; @@ -435,12 +435,12 @@ dofilewrite(p, fp, fd, buf, nbyte, offset, flags) auio.uio_resid = nbyte; auio.uio_rw = UIO_WRITE; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; #ifdef KTRACE /* * if tracing, save a copy of iovec and uio */ - if (KTRPOINT(p, KTR_GENIO)) { + if (KTRPOINT(td->td_proc, KTR_GENIO)) { ktriov = aiov; ktruio = auio; didktr = 1; @@ -449,14 +449,14 @@ dofilewrite(p, fp, fd, buf, nbyte, offset, flags) cnt = nbyte; if (fp->f_type == DTYPE_VNODE) bwillwrite(); - if ((error = fo_write(fp, &auio, fp->f_cred, flags, p))) { + if ((error = fo_write(fp, &auio, fp->f_cred, flags, td))) { if (auio.uio_resid != cnt && (error == ERESTART || error == EINTR || error == EWOULDBLOCK)) error = 0; if (error == EPIPE) { - PROC_LOCK(p); - psignal(p, SIGPIPE); - PROC_UNLOCK(p); + PROC_LOCK(td->td_proc); + psignal(td->td_proc, SIGPIPE); + PROC_UNLOCK(td->td_proc); } } cnt -= auio.uio_resid; @@ -464,10 +464,10 @@ dofilewrite(p, fp, fd, buf, nbyte, offset, flags) if (didktr && error == 0) { ktruio.uio_iov = &ktriov; ktruio.uio_resid = cnt; - ktrgenio(p->p_tracep, fd, UIO_WRITE, &ktruio, error); + ktrgenio(td->td_proc->p_tracep, fd, UIO_WRITE, &ktruio, error); } #endif - p->p_retval[0] = cnt; + td->td_retval[0] = cnt; return (error); } @@ -485,8 +485,8 @@ struct writev_args { * MPSAFE */ int -writev(p, uap) - struct proc *p; +writev(td, uap) + struct thread *td; register struct writev_args *uap; { register struct file *fp; @@ -503,7 +503,7 @@ writev(p, uap) #endif mtx_lock(&Giant); - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if ((fp = holdfp(fdp, uap->fd, FWRITE)) == NULL) { error = EBADF; goto done2; @@ -526,7 +526,7 @@ writev(p, uap) auio.uio_iovcnt = uap->iovcnt; auio.uio_rw = UIO_WRITE; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = -1; if ((error = copyin((caddr_t)uap->iovp, (caddr_t)iov, iovlen))) goto done; @@ -543,7 +543,7 @@ writev(p, uap) /* * if tracing, save a copy of iovec and uio */ - if (KTRPOINT(p, KTR_GENIO)) { + if (KTRPOINT(td->td_proc, KTR_GENIO)) { MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen); ktruio = auio; @@ -552,14 +552,14 @@ writev(p, uap) cnt = auio.uio_resid; if (fp->f_type == DTYPE_VNODE) bwillwrite(); - if ((error = fo_write(fp, &auio, fp->f_cred, 0, p))) { + if ((error = fo_write(fp, &auio, fp->f_cred, 0, td))) { if (auio.uio_resid != cnt && (error == ERESTART || error == EINTR || error == EWOULDBLOCK)) error = 0; if (error == EPIPE) { - PROC_LOCK(p); - psignal(p, SIGPIPE); - PROC_UNLOCK(p); + PROC_LOCK(td->td_proc); + psignal(td->td_proc, SIGPIPE); + PROC_UNLOCK(td->td_proc); } } cnt -= auio.uio_resid; @@ -568,15 +568,15 @@ writev(p, uap) if (error == 0) { ktruio.uio_iov = ktriov; ktruio.uio_resid = cnt; - ktrgenio(p->p_tracep, uap->fd, UIO_WRITE, &ktruio, + ktrgenio(td->td_proc->p_tracep, uap->fd, UIO_WRITE, &ktruio, error); } FREE(ktriov, M_TEMP); } #endif - p->p_retval[0] = cnt; + td->td_retval[0] = cnt; done: - fdrop(fp, p); + fdrop(fp, td); if (needfree) FREE(needfree, M_IOV); done2: @@ -599,8 +599,8 @@ struct ioctl_args { */ /* ARGSUSED */ int -ioctl(p, uap) - struct proc *p; +ioctl(td, uap) + struct thread *td; register struct ioctl_args *uap; { register struct file *fp; @@ -617,7 +617,7 @@ ioctl(p, uap) } ubuf; mtx_lock(&Giant); - fdp = p->p_fd; + fdp = td->td_proc->p_fd; if ((u_int)uap->fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[uap->fd]) == NULL) { error = EBADF; @@ -663,7 +663,7 @@ ioctl(p, uap) if (error) { if (memp) free(memp, M_IOCTLOPS); - fdrop(fp, p); + fdrop(fp, td); goto done2; } } else { @@ -686,7 +686,7 @@ ioctl(p, uap) fp->f_flag |= FNONBLOCK; else fp->f_flag &= ~FNONBLOCK; - error = fo_ioctl(fp, FIONBIO, (caddr_t)&tmp, p); + error = fo_ioctl(fp, FIONBIO, (caddr_t)&tmp, td); break; case FIOASYNC: @@ -694,11 +694,11 @@ ioctl(p, uap) fp->f_flag |= FASYNC; else fp->f_flag &= ~FASYNC; - error = fo_ioctl(fp, FIOASYNC, (caddr_t)&tmp, p); + error = fo_ioctl(fp, FIOASYNC, (caddr_t)&tmp, td); break; default: - error = fo_ioctl(fp, com, data, p); + error = fo_ioctl(fp, com, data, td); /* * Copy any data to user, size was * already set and checked above. @@ -709,7 +709,7 @@ ioctl(p, uap) } if (memp) free(memp, M_IOCTLOPS); - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return (error); @@ -733,8 +733,8 @@ struct select_args { * MPSAFE */ int -select(p, uap) - register struct proc *p; +select(td, uap) + register struct thread *td; register struct select_args *uap; { /* @@ -755,8 +755,8 @@ select(p, uap) mtx_lock(&Giant); - if (uap->nd > p->p_fd->fd_nfiles) - uap->nd = p->p_fd->fd_nfiles; /* forgiving; slightly wrong */ + if (uap->nd > td->td_proc->p_fd->fd_nfiles) + uap->nd = td->td_proc->p_fd->fd_nfiles; /* forgiving; slightly wrong */ /* * Allocate just enough bits for the non-null fd_sets. Use the @@ -828,16 +828,16 @@ select(p, uap) atv.tv_sec = 0; atv.tv_usec = 0; } - selholddrop(p, hibits, hobits, uap->nd, 1); + selholddrop(td, hibits, hobits, uap->nd, 1); timo = 0; - PROC_LOCK(p); + PROC_LOCK(td->td_proc); retry: ncoll = nselcoll; - p->p_flag |= P_SELECT; - PROC_UNLOCK(p); - error = selscan(p, ibits, obits, uap->nd); - PROC_LOCK(p); - if (error || p->p_retval[0]) + td->td_flags |= TDF_SELECT; + PROC_UNLOCK(td->td_proc); + error = selscan(td, ibits, obits, uap->nd); + PROC_LOCK(td->td_proc); + if (error || td->td_retval[0]) goto done; if (atv.tv_sec || atv.tv_usec) { getmicrouptime(&rtv); @@ -845,15 +845,15 @@ retry: /* * An event of our interest may occur during locking a process. * In order to avoid missing the event that occured during locking - * the process, test P_SELECT and rescan file descriptors if + * the process, test TDF_SELECT and rescan file descriptors if * necessary. */ - if ((p->p_flag & P_SELECT) == 0 || nselcoll != ncoll) { + if ((td->td_flags & TDF_SELECT) == 0 || nselcoll != ncoll) { ncoll = nselcoll; - p->p_flag |= P_SELECT; - PROC_UNLOCK(p); - error = selscan(p, ibits, obits, uap->nd); - PROC_LOCK(p); + td->td_flags |= TDF_SELECT; + PROC_UNLOCK(td->td_proc); + error = selscan(td, ibits, obits, uap->nd); + PROC_LOCK(td->td_proc); } goto done; } @@ -862,20 +862,20 @@ retry: timo = ttv.tv_sec > 24 * 60 * 60 ? 24 * 60 * 60 * hz : tvtohz(&ttv); } - p->p_flag &= ~P_SELECT; + td->td_flags &= ~TDF_SELECT; if (timo > 0) - error = cv_timedwait_sig(&selwait, &p->p_mtx, timo); + error = cv_timedwait_sig(&selwait, &td->td_proc->p_mtx, timo); else - error = cv_wait_sig(&selwait, &p->p_mtx); + error = cv_wait_sig(&selwait, &td->td_proc->p_mtx); if (error == 0) goto retry; done: - p->p_flag &= ~P_SELECT; - PROC_UNLOCK(p); - selholddrop(p, hibits, hobits, uap->nd, 0); + td->td_flags &= ~TDF_SELECT; + PROC_UNLOCK(td->td_proc); + selholddrop(td, hibits, hobits, uap->nd, 0); done_noproclock: /* select is not restarted after signals... */ if (error == ERESTART) @@ -903,12 +903,12 @@ done_noproclock: } static int -selholddrop(p, ibits, obits, nfd, hold) - struct proc *p; +selholddrop(td, ibits, obits, nfd, hold) + struct thread *td; fd_mask *ibits, *obits; int nfd, hold; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; int i, fd; fd_mask bits; struct file *fp; @@ -930,19 +930,19 @@ selholddrop(p, ibits, obits, nfd, hold) obits[(fd)/NFDBITS] |= ((fd_mask)1 << ((fd) % NFDBITS)); } else - fdrop(fp, p); + fdrop(fp, td); } } return (0); } static int -selscan(p, ibits, obits, nfd) - struct proc *p; +selscan(td, ibits, obits, nfd) + struct thread *td; fd_mask **ibits, **obits; int nfd; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; int msk, i, fd; fd_mask bits; struct file *fp; @@ -962,7 +962,7 @@ selscan(p, ibits, obits, nfd) fp = fdp->fd_ofiles[fd]; if (fp == NULL) return (EBADF); - if (fo_poll(fp, flag[msk], fp->f_cred, p)) { + if (fo_poll(fp, flag[msk], fp->f_cred, td)) { obits[msk][(fd)/NFDBITS] |= ((fd_mask)1 << ((fd) % NFDBITS)); n++; @@ -970,7 +970,7 @@ selscan(p, ibits, obits, nfd) } } } - p->p_retval[0] = n; + td->td_retval[0] = n; return (0); } @@ -988,8 +988,8 @@ struct poll_args { * MPSAFE */ int -poll(p, uap) - struct proc *p; +poll(td, uap) + struct thread *td; struct poll_args *uap; { caddr_t bits; @@ -1011,7 +1011,8 @@ poll(p, uap) * least enough for the current limits. We want to be reasonably * safe, but not overly restrictive. */ - if (nfds > p->p_rlimit[RLIMIT_NOFILE].rlim_cur && nfds > FD_SETSIZE) { + if ((nfds > td->td_proc->p_rlimit[RLIMIT_NOFILE].rlim_cur) && + (nfds > FD_SETSIZE)) { error = EINVAL; goto done2; } @@ -1043,16 +1044,16 @@ poll(p, uap) atv.tv_sec = 0; atv.tv_usec = 0; } - pollholddrop(p, heldbits, nfds, 1); + pollholddrop(td, heldbits, nfds, 1); timo = 0; - PROC_LOCK(p); + PROC_LOCK(td->td_proc); retry: ncoll = nselcoll; - p->p_flag |= P_SELECT; - PROC_UNLOCK(p); - error = pollscan(p, (struct pollfd *)bits, nfds); - PROC_LOCK(p); - if (error || p->p_retval[0]) + td->td_flags |= TDF_SELECT; + PROC_UNLOCK(td->td_proc); + error = pollscan(td, (struct pollfd *)bits, nfds); + PROC_LOCK(td->td_proc); + if (error || td->td_retval[0]) goto done; if (atv.tv_sec || atv.tv_usec) { getmicrouptime(&rtv); @@ -1060,15 +1061,15 @@ retry: /* * An event of our interest may occur during locking a process. * In order to avoid missing the event that occured during locking - * the process, test P_SELECT and rescan file descriptors if + * the process, test TDF_SELECT and rescan file descriptors if * necessary. */ - if ((p->p_flag & P_SELECT) == 0 || nselcoll != ncoll) { + if ((td->td_flags & TDF_SELECT) == 0 || nselcoll != ncoll) { ncoll = nselcoll; - p->p_flag |= P_SELECT; - PROC_UNLOCK(p); - error = pollscan(p, (struct pollfd *)bits, nfds); - PROC_LOCK(p); + td->td_flags |= TDF_SELECT; + PROC_UNLOCK(td->td_proc); + error = pollscan(td, (struct pollfd *)bits, nfds); + PROC_LOCK(td->td_proc); } goto done; } @@ -1077,18 +1078,18 @@ retry: timo = ttv.tv_sec > 24 * 60 * 60 ? 24 * 60 * 60 * hz : tvtohz(&ttv); } - p->p_flag &= ~P_SELECT; + td->td_flags &= ~TDF_SELECT; if (timo > 0) - error = cv_timedwait_sig(&selwait, &p->p_mtx, timo); + error = cv_timedwait_sig(&selwait, &td->td_proc->p_mtx, timo); else - error = cv_wait_sig(&selwait, &p->p_mtx); + error = cv_wait_sig(&selwait, &td->td_proc->p_mtx); if (error == 0) goto retry; done: - p->p_flag &= ~P_SELECT; - PROC_UNLOCK(p); - pollholddrop(p, heldbits, nfds, 0); + td->td_flags &= ~TDF_SELECT; + PROC_UNLOCK(td->td_proc); + pollholddrop(td, heldbits, nfds, 0); done_noproclock: /* poll is not restarted after signals... */ if (error == ERESTART) @@ -1111,13 +1112,13 @@ done2: } static int -pollholddrop(p, fds, nfd, hold) - struct proc *p; +pollholddrop(td, fds, nfd, hold) + struct thread *td; struct pollfd *fds; u_int nfd; int hold; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; int i; struct file *fp; @@ -1131,19 +1132,19 @@ pollholddrop(p, fds, nfd, hold) } else fds->revents = 0; } else if(fp != NULL && fds->revents) - fdrop(fp, p); + fdrop(fp, td); } } return (0); } static int -pollscan(p, fds, nfd) - struct proc *p; +pollscan(td, fds, nfd) + struct thread *td; struct pollfd *fds; u_int nfd; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; int i; struct file *fp; int n = 0; @@ -1165,13 +1166,13 @@ pollscan(p, fds, nfd) * POLLERR if appropriate. */ fds->revents = fo_poll(fp, fds->events, - fp->f_cred, p); + fp->f_cred, td); if (fds->revents != 0) n++; } } } - p->p_retval[0] = n; + td->td_retval[0] = n; return (0); } @@ -1190,41 +1191,57 @@ struct openbsd_poll_args { * MPSAFE */ int -openbsd_poll(p, uap) - register struct proc *p; +openbsd_poll(td, uap) + register struct thread *td; register struct openbsd_poll_args *uap; { - return (poll(p, (struct poll_args *)uap)); + return (poll(td, (struct poll_args *)uap)); } /*ARGSUSED*/ int -seltrue(dev, events, p) +seltrue(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { return (events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)); } +static int +find_thread_in_proc(struct proc *p, struct thread *td) +{ + struct thread *td2; + FOREACH_THREAD_IN_PROC(p, td2) { + if (td2 == td) { + return (1); + } + } + return (0); +} + /* * Record a select request. */ void selrecord(selector, sip) - struct proc *selector; + struct thread *selector; struct selinfo *sip; { struct proc *p; pid_t mypid; - mypid = selector->p_pid; - if (sip->si_pid == mypid) + mypid = selector->td_proc->p_pid; + if ((sip->si_pid == mypid) && + (sip->si_thread == selector)) { /* XXXKSE should be an ID? */ return; - if (sip->si_pid && (p = pfind(sip->si_pid))) { + } + if (sip->si_pid && + (p = pfind(sip->si_pid)) && + (find_thread_in_proc(p, sip->si_thread))) { mtx_lock_spin(&sched_lock); - if (p->p_wchan == (caddr_t)&selwait) { + if (sip->si_thread->td_wchan == (caddr_t)&selwait) { mtx_unlock_spin(&sched_lock); PROC_UNLOCK(p); sip->si_flags |= SI_COLL; @@ -1234,6 +1251,7 @@ selrecord(selector, sip) PROC_UNLOCK(p); } sip->si_pid = mypid; + sip->si_thread = selector; } /* @@ -1243,6 +1261,7 @@ void selwakeup(sip) register struct selinfo *sip; { + struct thread *td; register struct proc *p; if (sip->si_pid == 0) @@ -1254,17 +1273,22 @@ selwakeup(sip) } p = pfind(sip->si_pid); sip->si_pid = 0; + td = sip->si_thread; if (p != NULL) { + if (!find_thread_in_proc(p, td)) { + PROC_UNLOCK(p); /* lock is in pfind() */; + return; + } mtx_lock_spin(&sched_lock); - if (p->p_wchan == (caddr_t)&selwait) { - if (p->p_stat == SSLEEP) - setrunnable(p); + if (td->td_wchan == (caddr_t)&selwait) { + if (td->td_proc->p_stat == SSLEEP) + setrunnable(td); else - cv_waitq_remove(p); + cv_waitq_remove(td); } else - p->p_flag &= ~P_SELECT; + td->td_flags &= ~TDF_SELECT; mtx_unlock_spin(&sched_lock); - PROC_UNLOCK(p); + PROC_UNLOCK(p); /* Lock is in pfind() */ } } diff --git a/sys/kern/sys_pipe.c b/sys/kern/sys_pipe.c index dcc57d8..b543ddf 100644 --- a/sys/kern/sys_pipe.c +++ b/sys/kern/sys_pipe.c @@ -90,15 +90,15 @@ * interfaces to the outside world */ static int pipe_read __P((struct file *fp, struct uio *uio, - struct ucred *cred, int flags, struct proc *p)); + struct ucred *cred, int flags, struct thread *td)); static int pipe_write __P((struct file *fp, struct uio *uio, - struct ucred *cred, int flags, struct proc *p)); -static int pipe_close __P((struct file *fp, struct proc *p)); + struct ucred *cred, int flags, struct thread *td)); +static int pipe_close __P((struct file *fp, struct thread *td)); static int pipe_poll __P((struct file *fp, int events, struct ucred *cred, - struct proc *p)); + struct thread *td)); static int pipe_kqfilter __P((struct file *fp, struct knote *kn)); -static int pipe_stat __P((struct file *fp, struct stat *sb, struct proc *p)); -static int pipe_ioctl __P((struct file *fp, u_long cmd, caddr_t data, struct proc *p)); +static int pipe_stat __P((struct file *fp, struct stat *sb, struct thread *td)); +static int pipe_ioctl __P((struct file *fp, u_long cmd, caddr_t data, struct thread *td)); static struct fileops pipeops = { pipe_read, pipe_write, pipe_ioctl, pipe_poll, pipe_kqfilter, @@ -166,13 +166,13 @@ static vm_zone_t pipe_zone; /* ARGSUSED */ int -pipe(p, uap) - struct proc *p; +pipe(td, uap) + struct thread *td; struct pipe_args /* { int dummy; } */ *uap; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct file *rf, *wf; struct pipe *rpipe, *wpipe; int fd, error; @@ -190,14 +190,14 @@ pipe(p, uap) rpipe->pipe_state |= PIPE_DIRECTOK; wpipe->pipe_state |= PIPE_DIRECTOK; - error = falloc(p, &rf, &fd); + error = falloc(td, &rf, &fd); if (error) { pipeclose(rpipe); pipeclose(wpipe); return (error); } fhold(rf); - p->p_retval[0] = fd; + td->td_retval[0] = fd; /* * Warning: once we've gotten past allocation of the fd for the @@ -209,13 +209,13 @@ pipe(p, uap) rf->f_type = DTYPE_PIPE; rf->f_data = (caddr_t)rpipe; rf->f_ops = &pipeops; - error = falloc(p, &wf, &fd); + error = falloc(td, &wf, &fd); if (error) { - if (fdp->fd_ofiles[p->p_retval[0]] == rf) { - fdp->fd_ofiles[p->p_retval[0]] = NULL; - fdrop(rf, p); + if (fdp->fd_ofiles[td->td_retval[0]] == rf) { + fdp->fd_ofiles[td->td_retval[0]] = NULL; + fdrop(rf, td); } - fdrop(rf, p); + fdrop(rf, td); /* rpipe has been closed by fdrop(). */ pipeclose(wpipe); return (error); @@ -224,11 +224,11 @@ pipe(p, uap) wf->f_type = DTYPE_PIPE; wf->f_data = (caddr_t)wpipe; wf->f_ops = &pipeops; - p->p_retval[1] = fd; + td->td_retval[1] = fd; rpipe->pipe_peer = wpipe; wpipe->pipe_peer = rpipe; - fdrop(rf, p); + fdrop(rf, td); return (0); } @@ -390,11 +390,11 @@ pipeselwakeup(cpipe) /* ARGSUSED */ static int -pipe_read(fp, uio, cred, flags, p) +pipe_read(fp, uio, cred, flags, td) struct file *fp; struct uio *uio; struct ucred *cred; - struct proc *p; + struct thread *td; int flags; { struct pipe *rpipe = (struct pipe *) fp->f_data; @@ -755,11 +755,11 @@ error1: #endif static int -pipe_write(fp, uio, cred, flags, p) +pipe_write(fp, uio, cred, flags, td) struct file *fp; struct uio *uio; struct ucred *cred; - struct proc *p; + struct thread *td; int flags; { int error = 0; @@ -1029,11 +1029,11 @@ pipe_write(fp, uio, cred, flags, p) * we implement a very minimal set of ioctls for compatibility with sockets. */ int -pipe_ioctl(fp, cmd, data, p) +pipe_ioctl(fp, cmd, data, td) struct file *fp; u_long cmd; caddr_t data; - struct proc *p; + struct thread *td; { struct pipe *mpipe = (struct pipe *)fp->f_data; @@ -1078,11 +1078,11 @@ pipe_ioctl(fp, cmd, data, p) } int -pipe_poll(fp, events, cred, p) +pipe_poll(fp, events, cred, td) struct file *fp; int events; struct ucred *cred; - struct proc *p; + struct thread *td; { struct pipe *rpipe = (struct pipe *)fp->f_data; struct pipe *wpipe; @@ -1108,12 +1108,12 @@ pipe_poll(fp, events, cred, p) if (revents == 0) { if (events & (POLLIN | POLLRDNORM)) { - selrecord(p, &rpipe->pipe_sel); + selrecord(curthread, &rpipe->pipe_sel); rpipe->pipe_state |= PIPE_SEL; } if (events & (POLLOUT | POLLWRNORM)) { - selrecord(p, &wpipe->pipe_sel); + selrecord(curthread, &wpipe->pipe_sel); wpipe->pipe_state |= PIPE_SEL; } } @@ -1122,10 +1122,10 @@ pipe_poll(fp, events, cred, p) } static int -pipe_stat(fp, ub, p) +pipe_stat(fp, ub, td) struct file *fp; struct stat *ub; - struct proc *p; + struct thread *td; { struct pipe *pipe = (struct pipe *)fp->f_data; @@ -1148,9 +1148,9 @@ pipe_stat(fp, ub, p) /* ARGSUSED */ static int -pipe_close(fp, p) +pipe_close(fp, td) struct file *fp; - struct proc *p; + struct thread *td; { struct pipe *cpipe = (struct pipe *)fp->f_data; diff --git a/sys/kern/sys_process.c b/sys/kern/sys_process.c index a81a768..96b38a0 100644 --- a/sys/kern/sys_process.c +++ b/sys/kern/sys_process.c @@ -202,10 +202,11 @@ struct ptrace_args { #endif int -ptrace(curp, uap) - struct proc *curp; +ptrace(td, uap) + struct thread *td; struct ptrace_args *uap; { + struct proc *curp = td->td_proc; struct proc *p; struct iovec iov; struct uio uio; @@ -314,14 +315,14 @@ ptrace(curp, uap) /* * Single step fixup ala procfs */ - FIX_SSTEP(p); + FIX_SSTEP(&p->p_thread); /* XXXKSE */ #endif /* * Actually do the requests */ - curp->p_retval[0] = 0; + td->td_retval[0] = 0; switch (uap->req) { case PT_TRACE_ME: @@ -356,15 +357,15 @@ ptrace(curp, uap) PHOLD(p); if (uap->req == PT_STEP) { - if ((error = ptrace_single_step (p))) { + if ((error = ptrace_single_step (td))) { PRELE(p); return error; } } if (uap->addr != (caddr_t)1) { - fill_kinfo_proc (p, &p->p_addr->u_kproc); - if ((error = ptrace_set_pc (p, + fill_kinfo_proc (p, &p->p_uarea->u_kproc); + if ((error = ptrace_set_pc (td, (u_long)(uintfptr_t)uap->addr))) { PRELE(p); return error; @@ -403,7 +404,7 @@ ptrace(curp, uap) mtx_lock_spin(&sched_lock); if (p->p_stat == SSTOP) { p->p_xstat = uap->data; - setrunnable(p); + setrunnable(&p->p_thread); /* XXXKSE */ mtx_unlock_spin(&sched_lock); } else { mtx_unlock_spin(&sched_lock); @@ -421,7 +422,7 @@ ptrace(curp, uap) case PT_READ_I: case PT_READ_D: /* write = 0 set above */ - iov.iov_base = write ? (caddr_t)&uap->data : (caddr_t)curp->p_retval; + iov.iov_base = write ? (caddr_t)&uap->data : (caddr_t)td->td_retval; iov.iov_len = sizeof(int); uio.uio_iov = &iov; uio.uio_iovcnt = 1; @@ -429,7 +430,7 @@ ptrace(curp, uap) uio.uio_resid = sizeof(int); uio.uio_segflg = UIO_SYSSPACE; /* ie: the uap */ uio.uio_rw = write ? UIO_WRITE : UIO_READ; - uio.uio_procp = p; + uio.uio_td = td; error = procfs_domem(curp, p, NULL, &uio); if (uio.uio_resid != 0) { /* @@ -460,7 +461,7 @@ ptrace(curp, uap) /* write = 0 above */ #endif /* PT_SETREGS */ #if defined(PT_SETREGS) || defined(PT_GETREGS) - if (!procfs_validregs(p)) /* no P_SYSTEM procs please */ + if (!procfs_validregs(td)) /* no P_SYSTEM procs please */ return EINVAL; else { iov.iov_base = uap->addr; @@ -471,7 +472,7 @@ ptrace(curp, uap) uio.uio_resid = sizeof(struct reg); uio.uio_segflg = UIO_USERSPACE; uio.uio_rw = write ? UIO_WRITE : UIO_READ; - uio.uio_procp = curp; + uio.uio_td = td; return (procfs_doregs(curp, p, NULL, &uio)); } #endif /* defined(PT_SETREGS) || defined(PT_GETREGS) */ @@ -486,7 +487,7 @@ ptrace(curp, uap) /* write = 0 above */ #endif /* PT_SETFPREGS */ #if defined(PT_SETFPREGS) || defined(PT_GETFPREGS) - if (!procfs_validfpregs(p)) /* no P_SYSTEM procs please */ + if (!procfs_validfpregs(td)) /* no P_SYSTEM procs please */ return EINVAL; else { iov.iov_base = uap->addr; @@ -497,7 +498,7 @@ ptrace(curp, uap) uio.uio_resid = sizeof(struct fpreg); uio.uio_segflg = UIO_USERSPACE; uio.uio_rw = write ? UIO_WRITE : UIO_READ; - uio.uio_procp = curp; + uio.uio_td = td; return (procfs_dofpregs(curp, p, NULL, &uio)); } #endif /* defined(PT_SETFPREGS) || defined(PT_GETFPREGS) */ @@ -512,7 +513,7 @@ ptrace(curp, uap) /* write = 0 above */ #endif /* PT_SETDBREGS */ #if defined(PT_SETDBREGS) || defined(PT_GETDBREGS) - if (!procfs_validdbregs(p)) /* no P_SYSTEM procs please */ + if (!procfs_validdbregs(td)) /* no P_SYSTEM procs please */ return EINVAL; else { iov.iov_base = uap->addr; @@ -523,7 +524,7 @@ ptrace(curp, uap) uio.uio_resid = sizeof(struct dbreg); uio.uio_segflg = UIO_USERSPACE; uio.uio_rw = write ? UIO_WRITE : UIO_READ; - uio.uio_procp = curp; + uio.uio_td = td; return (procfs_dodbregs(curp, p, NULL, &uio)); } #endif /* defined(PT_SETDBREGS) || defined(PT_GETDBREGS) */ diff --git a/sys/kern/sys_socket.c b/sys/kern/sys_socket.c index dc72a8a..8822fcb 100644 --- a/sys/kern/sys_socket.c +++ b/sys/kern/sys_socket.c @@ -57,11 +57,11 @@ struct fileops socketops = { /* ARGSUSED */ int -soo_read(fp, uio, cred, flags, p) +soo_read(fp, uio, cred, flags, td) struct file *fp; struct uio *uio; struct ucred *cred; - struct proc *p; + struct thread *td; int flags; { struct socket *so = (struct socket *)fp->f_data; @@ -70,24 +70,24 @@ soo_read(fp, uio, cred, flags, p) /* ARGSUSED */ int -soo_write(fp, uio, cred, flags, p) +soo_write(fp, uio, cred, flags, td) struct file *fp; struct uio *uio; struct ucred *cred; - struct proc *p; + struct thread *td; int flags; { struct socket *so = (struct socket *)fp->f_data; return so->so_proto->pr_usrreqs->pru_sosend(so, 0, uio, 0, 0, 0, - uio->uio_procp); + uio->uio_td); } int -soo_ioctl(fp, cmd, data, p) +soo_ioctl(fp, cmd, data, td) struct file *fp; u_long cmd; register caddr_t data; - struct proc *p; + struct thread *td; { register struct socket *so = (struct socket *)fp->f_data; @@ -140,28 +140,28 @@ soo_ioctl(fp, cmd, data, p) * different entry since a socket's unnecessary */ if (IOCGROUP(cmd) == 'i') - return (ifioctl(so, cmd, data, p)); + return (ifioctl(so, cmd, data, td)); if (IOCGROUP(cmd) == 'r') return (rtioctl(cmd, data)); - return ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, data, 0, p)); + return ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, data, 0, td)); } int -soo_poll(fp, events, cred, p) +soo_poll(fp, events, cred, td) struct file *fp; int events; struct ucred *cred; - struct proc *p; + struct thread *td; { struct socket *so = (struct socket *)fp->f_data; - return so->so_proto->pr_usrreqs->pru_sopoll(so, events, cred, p); + return so->so_proto->pr_usrreqs->pru_sopoll(so, events, cred, td); } int -soo_stat(fp, ub, p) +soo_stat(fp, ub, td) struct file *fp; struct stat *ub; - struct proc *p; + struct thread *td; { struct socket *so = (struct socket *)fp->f_data; @@ -184,9 +184,9 @@ soo_stat(fp, ub, p) /* ARGSUSED */ int -soo_close(fp, p) +soo_close(fp, td) struct file *fp; - struct proc *p; + struct thread *td; { int error = 0; diff --git a/sys/kern/sysv_ipc.c b/sys/kern/sysv_ipc.c index f28d660..70e2f4b 100644 --- a/sys/kern/sysv_ipc.c +++ b/sys/kern/sysv_ipc.c @@ -83,11 +83,12 @@ shmexit(p) */ int -ipcperm(p, perm, mode) - struct proc *p; +ipcperm(td, perm, mode) + struct thread *td; struct ipc_perm *perm; int mode; { + struct proc *p = td->td_proc; struct ucred *cred = p->p_ucred; /* Check for user match. */ diff --git a/sys/kern/sysv_msg.c b/sys/kern/sysv_msg.c index d6badbe..76bb22c 100644 --- a/sys/kern/sysv_msg.c +++ b/sys/kern/sysv_msg.c @@ -269,8 +269,8 @@ MODULE_VERSION(sysvmsg, 1); * MPSAFE */ int -msgsys(p, uap) - struct proc *p; +msgsys(td, uap) + struct thread *td; /* XXX actually varargs. */ struct msgsys_args /* { u_int which; @@ -284,8 +284,7 @@ msgsys(p, uap) int error; mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } @@ -293,7 +292,7 @@ msgsys(p, uap) error = EINVAL; goto done2; } - error = (*msgcalls[uap->which])(p, &uap->a2); + error = (*msgcalls[uap->which])(td, &uap->a2); done2: mtx_unlock(&Giant); return (error); @@ -335,8 +334,8 @@ struct msgctl_args { * MPSAFE */ int -msgctl(p, uap) - struct proc *p; +msgctl(td, uap) + struct thread *td; register struct msgctl_args *uap; { int msqid = uap->msqid; @@ -350,8 +349,7 @@ msgctl(p, uap) printf("call to msgctl(%d, %d, 0x%x)\n", msqid, cmd, user_msqptr); #endif mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } @@ -392,7 +390,7 @@ msgctl(p, uap) case IPC_RMID: { struct msg *msghdr; - if ((error = ipcperm(p, &msqptr->msg_perm, IPC_M))) + if ((error = ipcperm(td, &msqptr->msg_perm, IPC_M))) goto done2; /* Free the message headers */ msghdr = msqptr->msg_first; @@ -420,12 +418,12 @@ msgctl(p, uap) break; case IPC_SET: - if ((error = ipcperm(p, &msqptr->msg_perm, IPC_M))) + if ((error = ipcperm(td, &msqptr->msg_perm, IPC_M))) goto done2; if ((error = copyin(user_msqptr, &msqbuf, sizeof(msqbuf))) != 0) goto done2; if (msqbuf.msg_qbytes > msqptr->msg_qbytes) { - error = suser(p); + error = suser_td(td); if (error) goto done2; } @@ -452,7 +450,7 @@ msgctl(p, uap) break; case IPC_STAT: - if ((error = ipcperm(p, &msqptr->msg_perm, IPC_R))) { + if ((error = ipcperm(td, &msqptr->msg_perm, IPC_R))) { #ifdef MSG_DEBUG_OK printf("requester doesn't have read access\n"); #endif @@ -471,7 +469,7 @@ msgctl(p, uap) } if (error == 0) - p->p_retval[0] = rval; + td->td_retval[0] = rval; done2: mtx_unlock(&Giant); return(error); @@ -488,14 +486,14 @@ struct msgget_args { * MPSAFE */ int -msgget(p, uap) - struct proc *p; +msgget(td, uap) + struct thread *td; register struct msgget_args *uap; { int msqid, error = 0; int key = uap->key; int msgflg = uap->msgflg; - struct ucred *cred = p->p_ucred; + struct ucred *cred = td->td_proc->p_ucred; register struct msqid_ds *msqptr = NULL; #ifdef MSG_DEBUG_OK @@ -503,8 +501,7 @@ msgget(p, uap) #endif mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } @@ -527,7 +524,7 @@ msgget(p, uap) error = EEXIST; goto done2; } - if ((error = ipcperm(p, &msqptr->msg_perm, msgflg & 0700 ))) { + if ((error = ipcperm(td, &msqptr->msg_perm, msgflg & 0700 ))) { #ifdef MSG_DEBUG_OK printf("requester doesn't have 0%o access\n", msgflg & 0700); @@ -592,7 +589,7 @@ msgget(p, uap) found: /* Construct the unique msqid */ - p->p_retval[0] = IXSEQ_TO_IPCID(msqid, msqptr->msg_perm); + td->td_retval[0] = IXSEQ_TO_IPCID(msqid, msqptr->msg_perm); done2: mtx_unlock(&Giant); return (error); @@ -611,8 +608,8 @@ struct msgsnd_args { * MPSAFE */ int -msgsnd(p, uap) - struct proc *p; +msgsnd(td, uap) + struct thread *td; register struct msgsnd_args *uap; { int msqid = uap->msqid; @@ -629,8 +626,7 @@ msgsnd(p, uap) msgflg); #endif mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } @@ -662,7 +658,7 @@ msgsnd(p, uap) goto done2; } - if ((error = ipcperm(p, &msqptr->msg_perm, IPC_W))) { + if ((error = ipcperm(td, &msqptr->msg_perm, IPC_W))) { #ifdef MSG_DEBUG_OK printf("requester doesn't have write access\n"); #endif @@ -929,11 +925,11 @@ msgsnd(p, uap) msqptr->msg_cbytes += msghdr->msg_ts; msqptr->msg_qnum++; - msqptr->msg_lspid = p->p_pid; + msqptr->msg_lspid = td->td_proc->p_pid; msqptr->msg_stime = time_second; wakeup((caddr_t)msqptr); - p->p_retval[0] = 0; + td->td_retval[0] = 0; done2: mtx_unlock(&Giant); return (error); @@ -953,8 +949,8 @@ struct msgrcv_args { * MPSAFE */ int -msgrcv(p, uap) - struct proc *p; +msgrcv(td, uap) + struct thread *td; register struct msgrcv_args *uap; { int msqid = uap->msqid; @@ -974,8 +970,7 @@ msgrcv(p, uap) #endif mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } @@ -1007,7 +1002,7 @@ msgrcv(p, uap) goto done2; } - if ((error = ipcperm(p, &msqptr->msg_perm, IPC_R))) { + if ((error = ipcperm(td, &msqptr->msg_perm, IPC_R))) { #ifdef MSG_DEBUG_OK printf("requester doesn't have read access\n"); #endif @@ -1159,7 +1154,7 @@ msgrcv(p, uap) msqptr->msg_cbytes -= msghdr->msg_ts; msqptr->msg_qnum--; - msqptr->msg_lrpid = p->p_pid; + msqptr->msg_lrpid = td->td_proc->p_pid; msqptr->msg_rtime = time_second; /* @@ -1228,7 +1223,7 @@ msgrcv(p, uap) msg_freehdr(msghdr); wakeup((caddr_t)msqptr); - p->p_retval[0] = msgsz; + td->td_retval[0] = msgsz; done2: mtx_unlock(&Giant); return (error); diff --git a/sys/kern/sysv_sem.c b/sys/kern/sysv_sem.c index 0b9a0b6..b8bf079 100644 --- a/sys/kern/sysv_sem.c +++ b/sys/kern/sysv_sem.c @@ -34,15 +34,15 @@ static int sysctl_sema __P((SYSCTL_HANDLER_ARGS)); #ifndef _SYS_SYSPROTO_H_ struct __semctl_args; -int __semctl __P((struct proc *p, struct __semctl_args *uap)); +int __semctl __P((struct thread *td, struct __semctl_args *uap)); struct semget_args; -int semget __P((struct proc *p, struct semget_args *uap)); +int semget __P((struct thread *td, struct semget_args *uap)); struct semop_args; -int semop __P((struct proc *p, struct semop_args *uap)); +int semop __P((struct thread *td, struct semop_args *uap)); #endif -static struct sem_undo *semu_alloc __P((struct proc *p)); -static int semundo_adjust __P((struct proc *p, struct sem_undo **supptr, +static struct sem_undo *semu_alloc __P((struct thread *td)); +static int semundo_adjust __P((struct thread *td, struct sem_undo **supptr, int semid, int semnum, int adjval)); static void semundo_clear __P((int semid, int semnum)); @@ -250,8 +250,8 @@ MODULE_VERSION(sysvsem, 1); * MPSAFE */ int -semsys(p, uap) - struct proc *p; +semsys(td, uap) + struct thread *td; /* XXX actually varargs. */ struct semsys_args /* { u_int which; @@ -264,17 +264,15 @@ semsys(p, uap) int error; mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } - if (uap->which >= sizeof(semcalls)/sizeof(semcalls[0])) { error = EINVAL; goto done2; } - error = (*semcalls[uap->which])(p, &uap->a2); + error = (*semcalls[uap->which])(td, &uap->a2); done2: mtx_unlock(&Giant); return (error); @@ -286,8 +284,8 @@ done2: */ static struct sem_undo * -semu_alloc(p) - struct proc *p; +semu_alloc(td) + struct thread *td; { register int i; register struct sem_undo *suptr; @@ -312,7 +310,7 @@ semu_alloc(p) suptr->un_next = semu_list; semu_list = suptr; suptr->un_cnt = 0; - suptr->un_proc = p; + suptr->un_proc = td->td_proc; return(suptr); } } @@ -356,12 +354,13 @@ semu_alloc(p) */ static int -semundo_adjust(p, supptr, semid, semnum, adjval) - register struct proc *p; +semundo_adjust(td, supptr, semid, semnum, adjval) + register struct thread *td; struct sem_undo **supptr; int semid, semnum; int adjval; { + struct proc *p = td->td_proc; register struct sem_undo *suptr; register struct undo *sunptr; int i; @@ -381,7 +380,7 @@ semundo_adjust(p, supptr, semid, semnum, adjval) if (suptr == NULL) { if (adjval == 0) return(0); - suptr = semu_alloc(p); + suptr = semu_alloc(td); if (suptr == NULL) return(ENOSPC); *supptr = suptr; @@ -466,8 +465,8 @@ struct __semctl_args { * MPSAFE */ int -__semctl(p, uap) - struct proc *p; +__semctl(td, uap) + struct thread *td; register struct __semctl_args *uap; { int semid = uap->semid; @@ -475,7 +474,7 @@ __semctl(p, uap) int cmd = uap->cmd; union semun *arg = uap->arg; union semun real_arg; - struct ucred *cred = p->p_ucred; + struct ucred *cred = td->td_proc->p_ucred; int i, rval, error; struct semid_ds sbuf; register struct semid_ds *semaptr; @@ -484,8 +483,7 @@ __semctl(p, uap) printf("call to semctl(%d, %d, %d, 0x%x)\n", semid, semnum, cmd, arg); #endif mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } @@ -508,7 +506,7 @@ __semctl(p, uap) switch (cmd) { case IPC_RMID: - if ((error = ipcperm(p, &semaptr->sem_perm, IPC_M))) + if ((error = ipcperm(td, &semaptr->sem_perm, IPC_M))) goto done2; semaptr->sem_perm.cuid = cred->cr_uid; semaptr->sem_perm.uid = cred->cr_uid; @@ -526,7 +524,7 @@ __semctl(p, uap) break; case IPC_SET: - if ((error = ipcperm(p, &semaptr->sem_perm, IPC_M))) + if ((error = ipcperm(td, &semaptr->sem_perm, IPC_M))) goto done2; if ((error = copyin(arg, &real_arg, sizeof(real_arg))) != 0) goto done2; @@ -542,7 +540,7 @@ __semctl(p, uap) break; case IPC_STAT: - if ((error = ipcperm(p, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(td, &semaptr->sem_perm, IPC_R))) goto done2; if ((error = copyin(arg, &real_arg, sizeof(real_arg))) != 0) goto done2; @@ -551,7 +549,7 @@ __semctl(p, uap) break; case GETNCNT: - if ((error = ipcperm(p, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(td, &semaptr->sem_perm, IPC_R))) goto done2; if (semnum < 0 || semnum >= semaptr->sem_nsems) { error = EINVAL; @@ -561,7 +559,7 @@ __semctl(p, uap) break; case GETPID: - if ((error = ipcperm(p, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(td, &semaptr->sem_perm, IPC_R))) goto done2; if (semnum < 0 || semnum >= semaptr->sem_nsems) { error = EINVAL; @@ -571,7 +569,7 @@ __semctl(p, uap) break; case GETVAL: - if ((error = ipcperm(p, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(td, &semaptr->sem_perm, IPC_R))) goto done2; if (semnum < 0 || semnum >= semaptr->sem_nsems) { error = EINVAL; @@ -581,7 +579,7 @@ __semctl(p, uap) break; case GETALL: - if ((error = ipcperm(p, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(td, &semaptr->sem_perm, IPC_R))) goto done2; if ((error = copyin(arg, &real_arg, sizeof(real_arg))) != 0) goto done2; @@ -594,7 +592,7 @@ __semctl(p, uap) break; case GETZCNT: - if ((error = ipcperm(p, &semaptr->sem_perm, IPC_R))) + if ((error = ipcperm(td, &semaptr->sem_perm, IPC_R))) goto done2; if (semnum < 0 || semnum >= semaptr->sem_nsems) { error = EINVAL; @@ -604,7 +602,7 @@ __semctl(p, uap) break; case SETVAL: - if ((error = ipcperm(p, &semaptr->sem_perm, IPC_W))) + if ((error = ipcperm(td, &semaptr->sem_perm, IPC_W))) goto done2; if (semnum < 0 || semnum >= semaptr->sem_nsems) { error = EINVAL; @@ -618,7 +616,7 @@ __semctl(p, uap) break; case SETALL: - if ((error = ipcperm(p, &semaptr->sem_perm, IPC_W))) + if ((error = ipcperm(td, &semaptr->sem_perm, IPC_W))) goto done2; if ((error = copyin(arg, &real_arg, sizeof(real_arg))) != 0) goto done2; @@ -639,7 +637,7 @@ __semctl(p, uap) } if (error == 0) - p->p_retval[0] = rval; + td->td_retval[0] = rval; done2: mtx_unlock(&Giant); return(error); @@ -657,22 +655,21 @@ struct semget_args { * MPSAFE */ int -semget(p, uap) - struct proc *p; +semget(td, uap) + struct thread *td; register struct semget_args *uap; { int semid, error = 0; int key = uap->key; int nsems = uap->nsems; int semflg = uap->semflg; - struct ucred *cred = p->p_ucred; + struct ucred *cred = td->td_proc->p_ucred; #ifdef SEM_DEBUG printf("semget(0x%x, %d, 0%o)\n", key, nsems, semflg); #endif mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } @@ -687,7 +684,7 @@ semget(p, uap) #ifdef SEM_DEBUG printf("found public key\n"); #endif - if ((error = ipcperm(p, &sema[semid].sem_perm, + if ((error = ipcperm(td, &sema[semid].sem_perm, semflg & 0700))) { goto done2; } @@ -771,7 +768,7 @@ semget(p, uap) } found: - p->p_retval[0] = IXSEQ_TO_IPCID(semid, sema[semid].sem_perm); + td->td_retval[0] = IXSEQ_TO_IPCID(semid, sema[semid].sem_perm); done2: mtx_unlock(&Giant); return (error); @@ -789,8 +786,8 @@ struct semop_args { * MPSAFE */ int -semop(p, uap) - struct proc *p; +semop(td, uap) + struct thread *td; register struct semop_args *uap; { int semid = uap->semid; @@ -808,8 +805,7 @@ semop(p, uap) #endif mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } @@ -831,7 +827,7 @@ semop(p, uap) goto done2; } - if ((error = ipcperm(p, &semaptr->sem_perm, IPC_W))) { + if ((error = ipcperm(td, &semaptr->sem_perm, IPC_W))) { #ifdef SEM_DEBUG printf("error = %d from ipcperm\n", error); #endif @@ -1000,7 +996,7 @@ done: adjval = sops[i].sem_op; if (adjval == 0) continue; - error = semundo_adjust(p, &suptr, semid, + error = semundo_adjust(td, &suptr, semid, sops[i].sem_num, -adjval); if (error == 0) continue; @@ -1020,7 +1016,7 @@ done: adjval = sops[j].sem_op; if (adjval == 0) continue; - if (semundo_adjust(p, &suptr, semid, + if (semundo_adjust(td, &suptr, semid, sops[j].sem_num, adjval) != 0) panic("semop - can't undo undos"); } @@ -1040,7 +1036,7 @@ done: for (i = 0; i < nsops; i++) { sopptr = &sops[i]; semptr = &semaptr->sem_base[sopptr->sem_num]; - semptr->sempid = p->p_pid; + semptr->sempid = td->td_proc->p_pid; } /* Do a wakeup if any semaphore was up'd. */ @@ -1056,7 +1052,7 @@ done: #ifdef SEM_DEBUG printf("semop: done\n"); #endif - p->p_retval[0] = 0; + td->td_retval[0] = 0; done2: mtx_unlock(&Giant); return (error); diff --git a/sys/kern/sysv_shm.c b/sys/kern/sysv_shm.c index ce9574c..649308d 100644 --- a/sys/kern/sysv_shm.c +++ b/sys/kern/sysv_shm.c @@ -62,11 +62,11 @@ static MALLOC_DEFINE(M_SHM, "shm", "SVID compatible shared memory segments"); struct oshmctl_args; -static int oshmctl __P((struct proc *p, struct oshmctl_args *uap)); +static int oshmctl __P((struct thread *td, struct oshmctl_args *uap)); -static int shmget_allocate_segment __P((struct proc *p, +static int shmget_allocate_segment __P((struct thread *td, struct shmget_args *uap, int mode)); -static int shmget_existing __P((struct proc *p, struct shmget_args *uap, +static int shmget_existing __P((struct thread *td, struct shmget_args *uap, int mode, int segnum)); /* XXX casting to (sy_call_t *) is bogus, as usual. */ @@ -97,7 +97,7 @@ struct shmmap_state { static void shm_deallocate_segment __P((struct shmid_ds *)); static int shm_find_segment_by_key __P((key_t)); static struct shmid_ds *shm_find_segment_by_shmid __P((int)); -static int shm_delete_mapping __P((struct proc *, struct shmmap_state *)); +static int shm_delete_mapping __P((struct proc *p, struct shmmap_state *)); static void shmrealloc __P((void)); static void shminit __P((void)); static int sysvshm_modload __P((struct module *, int, void *)); @@ -237,21 +237,20 @@ struct shmdt_args { * MPSAFE */ int -shmdt(p, uap) - struct proc *p; +shmdt(td, uap) + struct thread *td; struct shmdt_args *uap; { + struct proc *p = td->td_proc; struct shmmap_state *shmmap_s; int i; int error = 0; mtx_lock(&Giant); - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { error = ENOSYS; goto done2; } - shmmap_s = (struct shmmap_state *)p->p_vmspace->vm_shm; if (shmmap_s == NULL) { error = EINVAL; @@ -285,10 +284,11 @@ struct shmat_args { * MPSAFE */ int -shmat(p, uap) - struct proc *p; +shmat(td, uap) + struct thread *td; struct shmat_args *uap; { + struct proc *p = td->td_proc; int i, flags; struct shmid_ds *shmseg; struct shmmap_state *shmmap_s = NULL; @@ -300,12 +300,10 @@ shmat(p, uap) int error = 0; mtx_lock(&Giant); - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { error = ENOSYS; goto done2; } - shmmap_s = (struct shmmap_state *)p->p_vmspace->vm_shm; if (shmmap_s == NULL) { size = shminfo.shmseg * sizeof(struct shmmap_state); @@ -319,7 +317,7 @@ shmat(p, uap) error = EINVAL; goto done2; } - error = ipcperm(p, &shmseg->shm_perm, + error = ipcperm(td, &shmseg->shm_perm, (uap->shmflg & SHM_RDONLY) ? IPC_R : IPC_R|IPC_W); if (error) goto done2; @@ -376,7 +374,7 @@ shmat(p, uap) shmseg->shm_lpid = p->p_pid; shmseg->shm_atime = time_second; shmseg->shm_nattch++; - p->p_retval[0] = attach_va; + td->td_retval[0] = attach_va; done2: mtx_unlock(&Giant); return (error); @@ -404,8 +402,8 @@ struct oshmctl_args { * MPSAFE */ static int -oshmctl(p, uap) - struct proc *p; +oshmctl(td, uap) + struct thread *td; struct oshmctl_args *uap; { #ifdef COMPAT_43 @@ -414,12 +412,10 @@ oshmctl(p, uap) struct oshmid_ds outbuf; mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } - shmseg = shm_find_segment_by_shmid(uap->shmid); if (shmseg == NULL) { error = EINVAL; @@ -427,7 +423,7 @@ oshmctl(p, uap) } switch (uap->cmd) { case IPC_STAT: - error = ipcperm(p, &shmseg->shm_perm, IPC_R); + error = ipcperm(td, &shmseg->shm_perm, IPC_R); if (error) goto done2; outbuf.shm_perm = shmseg->shm_perm; @@ -445,7 +441,7 @@ oshmctl(p, uap) break; default: /* XXX casting to (sy_call_t *) is bogus, as usual. */ - error = ((sy_call_t *)shmctl)(p, uap); + error = ((sy_call_t *)shmctl)(td, uap); break; } done2: @@ -468,8 +464,8 @@ struct shmctl_args { * MPSAFE */ int -shmctl(p, uap) - struct proc *p; +shmctl(td, uap) + struct thread *td; struct shmctl_args *uap; { int error = 0; @@ -477,12 +473,10 @@ shmctl(p, uap) struct shmid_ds *shmseg; mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } - shmseg = shm_find_segment_by_shmid(uap->shmid); if (shmseg == NULL) { error = EINVAL; @@ -490,7 +484,7 @@ shmctl(p, uap) } switch (uap->cmd) { case IPC_STAT: - error = ipcperm(p, &shmseg->shm_perm, IPC_R); + error = ipcperm(td, &shmseg->shm_perm, IPC_R); if (error) goto done2; error = copyout((caddr_t)shmseg, uap->buf, sizeof(inbuf)); @@ -498,7 +492,7 @@ shmctl(p, uap) goto done2; break; case IPC_SET: - error = ipcperm(p, &shmseg->shm_perm, IPC_M); + error = ipcperm(td, &shmseg->shm_perm, IPC_M); if (error) goto done2; error = copyin(uap->buf, (caddr_t)&inbuf, sizeof(inbuf)); @@ -512,7 +506,7 @@ shmctl(p, uap) shmseg->shm_ctime = time_second; break; case IPC_RMID: - error = ipcperm(p, &shmseg->shm_perm, IPC_M); + error = ipcperm(td, &shmseg->shm_perm, IPC_M); if (error) goto done2; shmseg->shm_perm.key = IPC_PRIVATE; @@ -544,8 +538,8 @@ struct shmget_args { #endif static int -shmget_existing(p, uap, mode, segnum) - struct proc *p; +shmget_existing(td, uap, mode, segnum) + struct thread *td; struct shmget_args *uap; int mode; int segnum; @@ -568,23 +562,23 @@ shmget_existing(p, uap, mode, segnum) } if ((uap->shmflg & (IPC_CREAT | IPC_EXCL)) == (IPC_CREAT | IPC_EXCL)) return EEXIST; - error = ipcperm(p, &shmseg->shm_perm, mode); + error = ipcperm(td, &shmseg->shm_perm, mode); if (error) return error; if (uap->size && uap->size > shmseg->shm_segsz) return EINVAL; - p->p_retval[0] = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm); + td->td_retval[0] = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm); return 0; } static int -shmget_allocate_segment(p, uap, mode) - struct proc *p; +shmget_allocate_segment(td, uap, mode) + struct thread *td; struct shmget_args *uap; int mode; { int i, segnum, shmid, size; - struct ucred *cred = p->p_ucred; + struct ucred *cred = td->td_proc->p_ucred; struct shmid_ds *shmseg; struct shm_handle *shm_handle; @@ -641,7 +635,7 @@ shmget_allocate_segment(p, uap, mode) shmseg->shm_perm.mode = (shmseg->shm_perm.mode & SHMSEG_WANTED) | (mode & ACCESSPERMS) | SHMSEG_ALLOCATED; shmseg->shm_segsz = uap->size; - shmseg->shm_cpid = p->p_pid; + shmseg->shm_cpid = td->td_proc->p_pid; shmseg->shm_lpid = shmseg->shm_nattch = 0; shmseg->shm_atime = shmseg->shm_dtime = 0; shmseg->shm_ctime = time_second; @@ -655,7 +649,7 @@ shmget_allocate_segment(p, uap, mode) shmseg->shm_perm.mode &= ~SHMSEG_WANTED; wakeup((caddr_t)shmseg); } - p->p_retval[0] = shmid; + td->td_retval[0] = shmid; return 0; } @@ -663,26 +657,24 @@ shmget_allocate_segment(p, uap, mode) * MPSAFE */ int -shmget(p, uap) - struct proc *p; +shmget(td, uap) + struct thread *td; struct shmget_args *uap; { int segnum, mode; int error; mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } - mode = uap->shmflg & ACCESSPERMS; if (uap->key != IPC_PRIVATE) { again: segnum = shm_find_segment_by_key(uap->key); if (segnum >= 0) { - error = shmget_existing(p, uap, mode, segnum); + error = shmget_existing(td, uap, mode, segnum); if (error == EAGAIN) goto again; goto done2; @@ -692,7 +684,7 @@ shmget(p, uap) goto done2; } } - error = shmget_allocate_segment(p, uap, mode); + error = shmget_allocate_segment(td, uap, mode); done2: mtx_unlock(&Giant); return (error); @@ -702,8 +694,8 @@ done2: * MPSAFE */ int -shmsys(p, uap) - struct proc *p; +shmsys(td, uap) + struct thread *td; /* XXX actually varargs. */ struct shmsys_args /* { u_int which; @@ -715,17 +707,15 @@ shmsys(p, uap) int error; mtx_lock(&Giant); - - if (!jail_sysvipc_allowed && jailed(p->p_ucred)) { + if (!jail_sysvipc_allowed && jailed(td->td_proc->p_ucred)) { error = ENOSYS; goto done2; } - if (uap->which >= sizeof(shmcalls)/sizeof(shmcalls[0])) { error = EINVAL; goto done2; } - error = (*shmcalls[uap->which])(p, &uap->a2); + error = (*shmcalls[uap->which])(td, &uap->a2); done2: mtx_unlock(&Giant); return (error); diff --git a/sys/kern/tty.c b/sys/kern/tty.c index 1095864..a4d42fc 100644 --- a/sys/kern/tty.c +++ b/sys/kern/tty.c @@ -1065,10 +1065,10 @@ ttioctl(tp, cmd, data, flag) } int -ttypoll(dev, events, p) +ttypoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { int s; int revents = 0; @@ -1084,7 +1084,7 @@ ttypoll(dev, events, p) if (ttnread(tp) > 0 || ISSET(tp->t_state, TS_ZOMBIE)) revents |= events & (POLLIN | POLLRDNORM); else - selrecord(p, &tp->t_rsel); + selrecord(td, &tp->t_rsel); } if (events & (POLLOUT | POLLWRNORM)) { if ((tp->t_outq.c_cc <= tp->t_olowat && @@ -1092,7 +1092,7 @@ ttypoll(dev, events, p) || ISSET(tp->t_state, TS_ZOMBIE)) revents |= events & (POLLOUT | POLLWRNORM); else - selrecord(p, &tp->t_wsel); + selrecord(td, &tp->t_wsel); } splx(s); return (revents); @@ -2337,8 +2337,8 @@ ttyinfo(tp) if (proc_compare(pick, p)) pick = p; - stmp = pick->p_stat == SRUN ? "running" : - pick->p_wmesg ? pick->p_wmesg : "iowait"; + stmp = pick->p_stat == SRUN ? "running" : /* XXXKSE */ + pick->p_thread.td_wmesg ? pick->p_thread.td_wmesg : "iowait"; calcru(pick, &utime, &stime, NULL); ltmp = pick->p_stat == SIDL || pick->p_stat == SWAIT || pick->p_stat == SZOMB ? 0 : @@ -2386,6 +2386,8 @@ proc_compare(p1, p2) register struct proc *p1, *p2; { + int esta, estb; + struct ksegrp *kg; mtx_assert(&sched_lock, MA_OWNED); if (p1 == NULL) return (1); @@ -2402,9 +2404,16 @@ proc_compare(p1, p2) /* * tie - favor one with highest recent cpu utilization */ - if (p2->p_estcpu > p1->p_estcpu) + esta = estb = 0; + FOREACH_KSEGRP_IN_PROC(p1,kg) { + esta += kg->kg_estcpu; + } + FOREACH_KSEGRP_IN_PROC(p2,kg) { + estb += kg->kg_estcpu; + } + if (estb > esta) return (1); - if (p1->p_estcpu > p2->p_estcpu) + if (esta > estb) return (0); return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ } @@ -2420,6 +2429,7 @@ proc_compare(p1, p2) return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ } +#if 0 /* XXXKSE */ /* * pick the one with the smallest sleep time */ @@ -2434,6 +2444,7 @@ proc_compare(p1, p2) return (1); if (p2->p_sflag & PS_SINTR && (p1->p_sflag & PS_SINTR) == 0) return (0); +#endif return (p2->p_pid > p1->p_pid); /* tie - return highest pid */ } diff --git a/sys/kern/tty_conf.c b/sys/kern/tty_conf.c index ba3d785..0609dc9 100644 --- a/sys/kern/tty_conf.c +++ b/sys/kern/tty_conf.c @@ -198,12 +198,12 @@ l_nostart(tp) * discipline specific ioctl command. */ int -l_nullioctl(tp, cmd, data, flags, p) +l_nullioctl(tp, cmd, data, flags, td) struct tty *tp; u_long cmd; char *data; int flags; - struct proc *p; + struct thread *td; { return (ENOIOCTL); diff --git a/sys/kern/tty_cons.c b/sys/kern/tty_cons.c index 478c7e9..70c7fee 100644 --- a/sys/kern/tty_cons.c +++ b/sys/kern/tty_cons.c @@ -219,9 +219,9 @@ sysctl_kern_consmute(SYSCTL_HANDLER_ARGS) */ cninit_finish(); if(cn_is_open) - /* XXX curproc is not what we want really */ + /* XXX curthread is not what we want really */ error = cnopen(cn_dev_t, openflag, - openmode, curproc); + openmode, curthread); /* if it failed, back it out */ if ( error != 0) cnuninit(); } else if (!ocn_mute && cn_mute) { @@ -231,7 +231,7 @@ sysctl_kern_consmute(SYSCTL_HANDLER_ARGS) */ if(cn_is_open) error = cnclose(cn_dev_t, openflag, - openmode, curproc); + openmode, curthread); if ( error == 0) cnuninit(); } if (error != 0) { @@ -248,10 +248,10 @@ SYSCTL_PROC(_kern, OID_AUTO, consmute, CTLTYPE_INT|CTLFLAG_RW, 0, sizeof cn_mute, sysctl_kern_consmute, "I", ""); static int -cnopen(dev, flag, mode, p) +cnopen(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { dev_t cndev, physdev; int retval = 0; @@ -266,7 +266,7 @@ cnopen(dev, flag, mode, p) * bypass this and go straight to the device. */ if(!cn_mute) - retval = (*cn_phys_open)(physdev, flag, mode, p); + retval = (*cn_phys_open)(physdev, flag, mode, td); if (retval == 0) { /* * check if we openned it via /dev/console or @@ -285,10 +285,10 @@ cnopen(dev, flag, mode, p) } static int -cnclose(dev, flag, mode, p) +cnclose(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { dev_t cndev; struct tty *cn_tp; @@ -323,7 +323,7 @@ cnclose(dev, flag, mode, p) dev = cndev; } if(cn_phys_close) - return ((*cn_phys_close)(dev, flag, mode, p)); + return ((*cn_phys_close)(dev, flag, mode, td)); return (0); } @@ -360,12 +360,12 @@ cnwrite(dev, uio, flag) } static int -cnioctl(dev, cmd, data, flag, p) +cnioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { int error; @@ -376,28 +376,28 @@ cnioctl(dev, cmd, data, flag, p) * output from the "virtual" console. */ if (cmd == TIOCCONS && constty) { - error = suser(p); + error = suser_td(td); if (error) return (error); constty = NULL; return (0); } dev = cn_tab->cn_dev; - return ((*devsw(dev)->d_ioctl)(dev, cmd, data, flag, p)); + return ((*devsw(dev)->d_ioctl)(dev, cmd, data, flag, td)); } static int -cnpoll(dev, events, p) +cnpoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { if ((cn_tab == NULL) || cn_mute) return (1); dev = cn_tab->cn_dev; - return ((*devsw(dev)->d_poll)(dev, events, p)); + return ((*devsw(dev)->d_poll)(dev, events, td)); } static int diff --git a/sys/kern/tty_pty.c b/sys/kern/tty_pty.c index 8672077..68e93a9 100644 --- a/sys/kern/tty_pty.c +++ b/sys/kern/tty_pty.c @@ -164,11 +164,12 @@ ptyinit(dev_t devc) /*ARGSUSED*/ static int -ptsopen(dev, flag, devtype, p) +ptsopen(dev, flag, devtype, td) dev_t dev; int flag, devtype; - struct proc *p; + struct thread *td; { + struct proc *p = td->td_proc; register struct tty *tp; int error; struct pt_ioctl *pti; @@ -206,10 +207,10 @@ ptsopen(dev, flag, devtype, p) } static int -ptsclose(dev, flag, mode, p) +ptsclose(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { register struct tty *tp; int err; @@ -227,7 +228,8 @@ ptsread(dev, uio, flag) struct uio *uio; int flag; { - struct proc *p = curproc; + struct thread *td = curthread; + struct proc *p = td->td_proc; register struct tty *tp = dev->si_tty; register struct pt_ioctl *pti = dev->si_drv1; int error = 0; @@ -326,11 +328,12 @@ ptcwakeup(tp, flag) } static int -ptcopen(dev, flag, devtype, p) +ptcopen(dev, flag, devtype, td) dev_t dev; int flag, devtype; - struct proc *p; + struct thread *td; { + struct proc *p = td->td_proc; register struct tty *tp; struct pt_ioctl *pti; @@ -355,11 +358,11 @@ ptcopen(dev, flag, devtype, p) } static int -ptcclose(dev, flags, fmt, p) +ptcclose(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { register struct tty *tp; @@ -471,10 +474,10 @@ ptsstop(tp, flush) } static int -ptcpoll(dev, events, p) +ptcpoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { register struct tty *tp = dev->si_tty; struct pt_ioctl *pti = dev->si_drv1; @@ -482,7 +485,7 @@ ptcpoll(dev, events, p) int s; if ((tp->t_state & TS_CONNECTED) == 0) - return (seltrue(dev, events, p) | POLLHUP); + return (seltrue(dev, events, td) | POLLHUP); /* * Need to block timeouts (ttrstart). @@ -510,10 +513,10 @@ ptcpoll(dev, events, p) if (revents == 0) { if (events & (POLLIN | POLLRDNORM)) - selrecord(p, &pti->pt_selr); + selrecord(curthread, &pti->pt_selr); if (events & (POLLOUT | POLLWRNORM)) - selrecord(p, &pti->pt_selw); + selrecord(curthread, &pti->pt_selw); } splx(s); @@ -632,12 +635,12 @@ block: /*ARGSUSED*/ static int -ptyioctl(dev, cmd, data, flag, p) +ptyioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { register struct tty *tp = dev->si_tty; register struct pt_ioctl *pti = dev->si_drv1; @@ -741,7 +744,7 @@ ptyioctl(dev, cmd, data, flag, p) } return(0); } - 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) error = ttioctl(tp, cmd, data, flag); if (error == ENOIOCTL) { diff --git a/sys/kern/tty_tty.c b/sys/kern/tty_tty.c index b175719..1c6635c 100644 --- a/sys/kern/tty_tty.c +++ b/sys/kern/tty_tty.c @@ -71,23 +71,23 @@ static struct cdevsw ctty_cdevsw = { /* flags */ D_TTY, }; -#define cttyvp(p) ((p)->p_flag & P_CONTROLT ? (p)->p_session->s_ttyvp : NULL) +#define cttyvp(td) ((td)->td_proc->p_flag & P_CONTROLT ? (td)->td_proc->p_session->s_ttyvp : NULL) /*ARGSUSED*/ static int -cttyopen(dev, flag, mode, p) +cttyopen(dev, flag, mode, td) dev_t dev; int flag, mode; - struct proc *p; + struct thread *td; { - struct vnode *ttyvp = cttyvp(p); + struct vnode *ttyvp = cttyvp(td); int error; if (ttyvp == NULL) return (ENXIO); - vn_lock(ttyvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_OPEN(ttyvp, flag, NOCRED, p); - VOP_UNLOCK(ttyvp, 0, p); + vn_lock(ttyvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(ttyvp, flag, NOCRED, td); + VOP_UNLOCK(ttyvp, 0, td); return (error); } @@ -98,15 +98,15 @@ cttyread(dev, uio, flag) struct uio *uio; int flag; { - struct proc *p = uio->uio_procp; - register struct vnode *ttyvp = cttyvp(p); + struct thread *td = uio->uio_td; + register struct vnode *ttyvp = cttyvp(td); int error; if (ttyvp == NULL) return (EIO); - vn_lock(ttyvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(ttyvp, LK_EXCLUSIVE | LK_RETRY, td); error = VOP_READ(ttyvp, uio, flag, NOCRED); - VOP_UNLOCK(ttyvp, 0, p); + VOP_UNLOCK(ttyvp, 0, td); return (error); } @@ -117,8 +117,8 @@ cttywrite(dev, uio, flag) struct uio *uio; int flag; { - struct proc *p = uio->uio_procp; - struct vnode *ttyvp = cttyvp(uio->uio_procp); + struct thread *td = uio->uio_td; + struct vnode *ttyvp = cttyvp(uio->uio_td); struct mount *mp; int error; @@ -128,51 +128,51 @@ cttywrite(dev, uio, flag) if (ttyvp->v_type != VCHR && (error = vn_start_write(ttyvp, &mp, V_WAIT | PCATCH)) != 0) return (error); - vn_lock(ttyvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(ttyvp, LK_EXCLUSIVE | LK_RETRY, td); error = VOP_WRITE(ttyvp, uio, flag, NOCRED); - VOP_UNLOCK(ttyvp, 0, p); + VOP_UNLOCK(ttyvp, 0, td); vn_finished_write(mp); return (error); } /*ARGSUSED*/ static int -cttyioctl(dev, cmd, addr, flag, p) +cttyioctl(dev, cmd, addr, flag, td) dev_t dev; u_long cmd; caddr_t addr; int flag; - struct proc *p; + struct thread *td; { - struct vnode *ttyvp = cttyvp(p); + struct vnode *ttyvp = cttyvp(td); if (ttyvp == NULL) return (EIO); if (cmd == TIOCSCTTY) /* don't allow controlling tty to be set */ return EINVAL; /* to controlling tty -- infinite recursion */ if (cmd == TIOCNOTTY) { - if (!SESS_LEADER(p)) { - p->p_flag &= ~P_CONTROLT; + if (!SESS_LEADER(td->td_proc)) { + td->td_proc->p_flag &= ~P_CONTROLT; return (0); } else return (EINVAL); } - return (VOP_IOCTL(ttyvp, cmd, addr, flag, NOCRED, p)); + return (VOP_IOCTL(ttyvp, cmd, addr, flag, NOCRED, td)); } /*ARGSUSED*/ static int -cttypoll(dev, events, p) +cttypoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { - struct vnode *ttyvp = cttyvp(p); + struct vnode *ttyvp = cttyvp(td); if (ttyvp == NULL) /* try operation to get EOF/failure */ - return (seltrue(dev, events, p)); - return (VOP_POLL(ttyvp, events, p->p_ucred, p)); + return (seltrue(dev, events, td)); + return (VOP_POLL(ttyvp, events, td->td_proc->p_ucred, td)); } static void ctty_clone __P((void *arg, char *name, int namelen, dev_t *dev)); @@ -188,7 +188,7 @@ ctty_clone(void *arg, char *name, int namelen, dev_t *dev) return; if (strcmp(name, "tty")) return; - vp = cttyvp(curproc); + vp = cttyvp(curthread); if (vp == NULL) { if (ctty) *dev = ctty; diff --git a/sys/kern/uipc_sockbuf.c b/sys/kern/uipc_sockbuf.c index e352e36..b7042ff 100644 --- a/sys/kern/uipc_sockbuf.c +++ b/sys/kern/uipc_sockbuf.c @@ -221,10 +221,10 @@ sonewconn(head, connstatus) } struct socket * -sonewconn3(head, connstatus, p) +sonewconn3(head, connstatus, td) register struct socket *head; int connstatus; - struct proc *p; + struct thread *td; { register struct socket *so; @@ -240,7 +240,7 @@ sonewconn3(head, connstatus, p) so->so_state = head->so_state | SS_NOFDREF; so->so_proto = head->so_proto; so->so_timeo = head->so_timeo; - so->so_cred = p ? p->p_ucred : head->so_cred; + so->so_cred = td ? td->td_proc->p_ucred : head->so_cred; crhold(so->so_cred); if (soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat) || (*so->so_proto->pr_usrreqs->pru_attach)(so, 0, NULL)) { @@ -391,11 +391,11 @@ soreserve(so, sndcc, rcvcc) register struct socket *so; u_long sndcc, rcvcc; { - struct proc *p = curproc; + struct thread *td = curthread; - if (sbreserve(&so->so_snd, sndcc, so, p) == 0) + if (sbreserve(&so->so_snd, sndcc, so, td) == 0) goto bad; - if (sbreserve(&so->so_rcv, rcvcc, so, p) == 0) + if (sbreserve(&so->so_rcv, rcvcc, so, td) == 0) goto bad2; if (so->so_rcv.sb_lowat == 0) so->so_rcv.sb_lowat = 1; @@ -416,21 +416,21 @@ bad: * if buffering efficiency is near the normal case. */ int -sbreserve(sb, cc, so, p) +sbreserve(sb, cc, so, td) struct sockbuf *sb; u_long cc; struct socket *so; - struct proc *p; + struct thread *td; { /* - * p will only be NULL when we're in an interrupt + * td will only be NULL when we're in an interrupt * (e.g. in tcp_input()) */ if ((u_quad_t)cc > (u_quad_t)sb_max * MCLBYTES / (MSIZE + MCLBYTES)) return (0); if (!chgsbsize(so->so_cred->cr_uidinfo, &sb->sb_hiwat, cc, - p ? p->p_rlimit[RLIMIT_SBSIZE].rlim_cur : RLIM_INFINITY)) { + td ? td->td_proc->p_rlimit[RLIMIT_SBSIZE].rlim_cur : RLIM_INFINITY)) { return (0); } sb->sb_mbmax = min(cc * sb_efficiency, sb_max); @@ -876,7 +876,7 @@ pru_accept_notsupp(struct socket *so, struct sockaddr **nam) } int -pru_connect_notsupp(struct socket *so, struct sockaddr *nam, struct proc *p) +pru_connect_notsupp(struct socket *so, struct sockaddr *nam, struct thread *td) { return EOPNOTSUPP; } @@ -889,13 +889,13 @@ pru_connect2_notsupp(struct socket *so1, struct socket *so2) int pru_control_notsupp(struct socket *so, u_long cmd, caddr_t data, - struct ifnet *ifp, struct proc *p) + struct ifnet *ifp, struct thread *td) { return EOPNOTSUPP; } int -pru_listen_notsupp(struct socket *so, struct proc *p) +pru_listen_notsupp(struct socket *so, struct thread *td) { return EOPNOTSUPP; } diff --git a/sys/kern/uipc_socket.c b/sys/kern/uipc_socket.c index 9a2cb93..f4edaaf 100644 --- a/sys/kern/uipc_socket.c +++ b/sys/kern/uipc_socket.c @@ -125,12 +125,12 @@ soalloc(waitok) } int -socreate(dom, aso, type, proto, p) +socreate(dom, aso, type, proto, td) int dom; struct socket **aso; register int type; int proto; - struct proc *p; + struct thread *td; { register struct protosw *prp; register struct socket *so; @@ -144,7 +144,7 @@ socreate(dom, aso, type, proto, p) if (prp == 0 || prp->pr_usrreqs->pru_attach == 0) return (EPROTONOSUPPORT); - if (jailed(p->p_ucred) && jail_socket_unixiproute_only && + if (jailed(td->td_proc->p_ucred) && jail_socket_unixiproute_only && prp->pr_domain->dom_family != PF_LOCAL && prp->pr_domain->dom_family != PF_INET && prp->pr_domain->dom_family != PF_ROUTE) { @@ -153,17 +153,17 @@ socreate(dom, aso, type, proto, p) if (prp->pr_type != type) return (EPROTOTYPE); - so = soalloc(p != 0); + so = soalloc(td != 0); if (so == 0) return (ENOBUFS); TAILQ_INIT(&so->so_incomp); TAILQ_INIT(&so->so_comp); so->so_type = type; - so->so_cred = p->p_ucred; + so->so_cred = td->td_proc->p_ucred; crhold(so->so_cred); so->so_proto = prp; - error = (*prp->pr_usrreqs->pru_attach)(so, proto, p); + error = (*prp->pr_usrreqs->pru_attach)(so, proto, td); if (error) { so->so_state |= SS_NOFDREF; sofree(so); @@ -174,15 +174,15 @@ socreate(dom, aso, type, proto, p) } int -sobind(so, nam, p) +sobind(so, nam, td) struct socket *so; struct sockaddr *nam; - struct proc *p; + struct thread *td; { int s = splnet(); int error; - error = (*so->so_proto->pr_usrreqs->pru_bind)(so, nam, p); + error = (*so->so_proto->pr_usrreqs->pru_bind)(so, nam, td); splx(s); return (error); } @@ -215,15 +215,15 @@ sodealloc(so) } int -solisten(so, backlog, p) +solisten(so, backlog, td) register struct socket *so; int backlog; - struct proc *p; + struct thread *td; { int s, error; s = splnet(); - error = (*so->so_proto->pr_usrreqs->pru_listen)(so, p); + error = (*so->so_proto->pr_usrreqs->pru_listen)(so, td); if (error) { splx(s); return (error); @@ -369,10 +369,10 @@ soaccept(so, nam) } int -soconnect(so, nam, p) +soconnect(so, nam, td) register struct socket *so; struct sockaddr *nam; - struct proc *p; + struct thread *td; { int s; int error; @@ -391,7 +391,7 @@ soconnect(so, nam, p) (error = sodisconnect(so)))) error = EISCONN; else - error = (*so->so_proto->pr_usrreqs->pru_connect)(so, nam, p); + error = (*so->so_proto->pr_usrreqs->pru_connect)(so, nam, td); splx(s); return (error); } @@ -449,14 +449,14 @@ bad: * Data and control buffers are freed on return. */ int -sosend(so, addr, uio, top, control, flags, p) +sosend(so, addr, uio, top, control, flags, td) register struct socket *so; struct sockaddr *addr; struct uio *uio; struct mbuf *top; struct mbuf *control; int flags; - struct proc *p; + struct thread *td; { struct mbuf **mp; register struct mbuf *m; @@ -486,8 +486,8 @@ sosend(so, addr, uio, top, control, flags, p) dontroute = (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 && (so->so_proto->pr_flags & PR_ATOMIC); - if (p) - p->p_stats->p_ru.ru_msgsnd++; + if (td) + td->td_proc->p_stats->p_ru.ru_msgsnd++; if (control) clen = control->m_len; #define snderr(errno) { error = errno; splx(s); goto release; } @@ -624,7 +624,7 @@ nopages: PRUS_EOF : /* If there is more to send set PRUS_MORETOCOME */ (resid > 0 && space > 0) ? PRUS_MORETOCOME : 0, - top, addr, control, p); + top, addr, control, td); splx(s); if (dontroute) so->so_options &= ~SO_DONTROUTE; @@ -774,8 +774,8 @@ restart: goto restart; } dontblock: - if (uio->uio_procp) - uio->uio_procp->p_stats->p_ru.ru_msgrcv++; + if (uio->uio_td) + uio->uio_td->td_proc->p_stats->p_ru.ru_msgrcv++; nextrecord = m->m_nextpkt; if (pr->pr_flags & PR_ADDR) { KASSERT(m->m_type == MT_SONAME, ("receive 1a")); @@ -1103,7 +1103,7 @@ sooptcopyin(sopt, buf, len, minlen) if (valsize > len) sopt->sopt_valsize = valsize = len; - if (sopt->sopt_p != 0) + if (sopt->sopt_td != 0) return (copyin(sopt->sopt_val, buf, valsize)); bcopy(sopt->sopt_val, buf, valsize); @@ -1189,7 +1189,7 @@ sosetopt(so, sopt) case SO_RCVBUF: if (sbreserve(sopt->sopt_name == SO_SNDBUF ? &so->so_snd : &so->so_rcv, (u_long)optval, - so, curproc) == 0) { + so, curthread) == 0) { error = ENOBUFS; goto bad; } @@ -1279,7 +1279,7 @@ sooptcopyout(sopt, buf, len) valsize = min(len, sopt->sopt_valsize); sopt->sopt_valsize = valsize; if (sopt->sopt_val != 0) { - if (sopt->sopt_p != 0) + if (sopt->sopt_td != 0) error = copyout(buf, sopt->sopt_val, valsize); else bcopy(buf, sopt->sopt_val, valsize); @@ -1394,11 +1394,11 @@ soopt_getm(struct sockopt *sopt, struct mbuf **mp) struct mbuf *m, *m_prev; int sopt_size = sopt->sopt_valsize; - MGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT, MT_DATA); + MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_DATA); if (m == 0) return ENOBUFS; if (sopt_size > MLEN) { - MCLGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT); + MCLGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT); if ((m->m_flags & M_EXT) == 0) { m_free(m); return ENOBUFS; @@ -1412,13 +1412,13 @@ soopt_getm(struct sockopt *sopt, struct mbuf **mp) m_prev = m; while (sopt_size) { - MGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT, MT_DATA); + MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_DATA); if (m == 0) { m_freem(*mp); return ENOBUFS; } if (sopt_size > MLEN) { - MCLGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT); + MCLGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT); if ((m->m_flags & M_EXT) == 0) { m_freem(*mp); return ENOBUFS; @@ -1443,7 +1443,7 @@ soopt_mcopyin(struct sockopt *sopt, struct mbuf *m) if (sopt->sopt_val == NULL) return 0; while (m != NULL && sopt->sopt_valsize >= m->m_len) { - if (sopt->sopt_p != NULL) { + if (sopt->sopt_td != NULL) { int error; error = copyin(sopt->sopt_val, mtod(m, char *), @@ -1473,7 +1473,7 @@ soopt_mcopyout(struct sockopt *sopt, struct mbuf *m) if (sopt->sopt_val == NULL) return 0; while (m != NULL && sopt->sopt_valsize >= m->m_len) { - if (sopt->sopt_p != NULL) { + if (sopt->sopt_td != NULL) { int error; error = copyout(mtod(m, char *), sopt->sopt_val, @@ -1508,7 +1508,7 @@ sohasoutofband(so) } int -sopoll(struct socket *so, int events, struct ucred *cred, struct proc *p) +sopoll(struct socket *so, int events, struct ucred *cred, struct thread *td) { int revents = 0; int s = splnet(); @@ -1527,12 +1527,12 @@ sopoll(struct socket *so, int events, struct ucred *cred, struct proc *p) if (revents == 0) { if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) { - selrecord(p, &so->so_rcv.sb_sel); + selrecord(curthread, &so->so_rcv.sb_sel); so->so_rcv.sb_flags |= SB_SEL; } if (events & (POLLOUT | POLLWRNORM)) { - selrecord(p, &so->so_snd.sb_sel); + selrecord(curthread, &so->so_snd.sb_sel); so->so_snd.sb_flags |= SB_SEL; } } diff --git a/sys/kern/uipc_socket2.c b/sys/kern/uipc_socket2.c index e352e36..b7042ff 100644 --- a/sys/kern/uipc_socket2.c +++ b/sys/kern/uipc_socket2.c @@ -221,10 +221,10 @@ sonewconn(head, connstatus) } struct socket * -sonewconn3(head, connstatus, p) +sonewconn3(head, connstatus, td) register struct socket *head; int connstatus; - struct proc *p; + struct thread *td; { register struct socket *so; @@ -240,7 +240,7 @@ sonewconn3(head, connstatus, p) so->so_state = head->so_state | SS_NOFDREF; so->so_proto = head->so_proto; so->so_timeo = head->so_timeo; - so->so_cred = p ? p->p_ucred : head->so_cred; + so->so_cred = td ? td->td_proc->p_ucred : head->so_cred; crhold(so->so_cred); if (soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat) || (*so->so_proto->pr_usrreqs->pru_attach)(so, 0, NULL)) { @@ -391,11 +391,11 @@ soreserve(so, sndcc, rcvcc) register struct socket *so; u_long sndcc, rcvcc; { - struct proc *p = curproc; + struct thread *td = curthread; - if (sbreserve(&so->so_snd, sndcc, so, p) == 0) + if (sbreserve(&so->so_snd, sndcc, so, td) == 0) goto bad; - if (sbreserve(&so->so_rcv, rcvcc, so, p) == 0) + if (sbreserve(&so->so_rcv, rcvcc, so, td) == 0) goto bad2; if (so->so_rcv.sb_lowat == 0) so->so_rcv.sb_lowat = 1; @@ -416,21 +416,21 @@ bad: * if buffering efficiency is near the normal case. */ int -sbreserve(sb, cc, so, p) +sbreserve(sb, cc, so, td) struct sockbuf *sb; u_long cc; struct socket *so; - struct proc *p; + struct thread *td; { /* - * p will only be NULL when we're in an interrupt + * td will only be NULL when we're in an interrupt * (e.g. in tcp_input()) */ if ((u_quad_t)cc > (u_quad_t)sb_max * MCLBYTES / (MSIZE + MCLBYTES)) return (0); if (!chgsbsize(so->so_cred->cr_uidinfo, &sb->sb_hiwat, cc, - p ? p->p_rlimit[RLIMIT_SBSIZE].rlim_cur : RLIM_INFINITY)) { + td ? td->td_proc->p_rlimit[RLIMIT_SBSIZE].rlim_cur : RLIM_INFINITY)) { return (0); } sb->sb_mbmax = min(cc * sb_efficiency, sb_max); @@ -876,7 +876,7 @@ pru_accept_notsupp(struct socket *so, struct sockaddr **nam) } int -pru_connect_notsupp(struct socket *so, struct sockaddr *nam, struct proc *p) +pru_connect_notsupp(struct socket *so, struct sockaddr *nam, struct thread *td) { return EOPNOTSUPP; } @@ -889,13 +889,13 @@ pru_connect2_notsupp(struct socket *so1, struct socket *so2) int pru_control_notsupp(struct socket *so, u_long cmd, caddr_t data, - struct ifnet *ifp, struct proc *p) + struct ifnet *ifp, struct thread *td) { return EOPNOTSUPP; } int -pru_listen_notsupp(struct socket *so, struct proc *p) +pru_listen_notsupp(struct socket *so, struct thread *td) { return EOPNOTSUPP; } diff --git a/sys/kern/uipc_syscalls.c b/sys/kern/uipc_syscalls.c index ecf4406..e09951f 100644 --- a/sys/kern/uipc_syscalls.c +++ b/sys/kern/uipc_syscalls.c @@ -77,14 +77,14 @@ SYSINIT(sock_sf, SI_SUB_MBUF, SI_ORDER_ANY, sf_buf_init, NULL) static struct sf_buf *sf_buf_alloc(void); static void sf_buf_free(caddr_t addr, void *args); -static int sendit __P((struct proc *p, int s, struct msghdr *mp, int flags)); -static int recvit __P((struct proc *p, int s, struct msghdr *mp, +static int sendit __P((struct thread *td, int s, struct msghdr *mp, int flags)); +static int recvit __P((struct thread *td, int s, struct msghdr *mp, caddr_t namelenp)); -static int accept1 __P((struct proc *p, struct accept_args *uap, int compat)); -static int getsockname1 __P((struct proc *p, struct getsockname_args *uap, +static int accept1 __P((struct thread *td, struct accept_args *uap, int compat)); +static int getsockname1 __P((struct thread *td, struct getsockname_args *uap, int compat)); -static int getpeername1 __P((struct proc *p, struct getpeername_args *uap, +static int getpeername1 __P((struct thread *td, struct getpeername_args *uap, int compat)); /* @@ -113,8 +113,8 @@ extern struct fileops socketops; * MPSAFE */ int -socket(p, uap) - struct proc *p; +socket(td, uap) + struct thread *td; register struct socket_args /* { int domain; int type; @@ -127,26 +127,25 @@ socket(p, uap) int fd, error; mtx_lock(&Giant); - - fdp = p->p_fd; - error = falloc(p, &fp, &fd); + fdp = td->td_proc->p_fd; + error = falloc(td, &fp, &fd); if (error) goto done2; fhold(fp); - error = socreate(uap->domain, &so, uap->type, uap->protocol, p); + error = socreate(uap->domain, &so, uap->type, uap->protocol, td); if (error) { if (fdp->fd_ofiles[fd] == fp) { fdp->fd_ofiles[fd] = NULL; - fdrop(fp, p); + fdrop(fp, td); } } else { fp->f_data = (caddr_t)so; fp->f_flag = FREAD|FWRITE; fp->f_ops = &socketops; fp->f_type = DTYPE_SOCKET; - p->p_retval[0] = fd; + td->td_retval[0] = fd; } - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return (error); @@ -157,8 +156,8 @@ done2: */ /* ARGSUSED */ int -bind(p, uap) - struct proc *p; +bind(td, uap) + struct thread *td; register struct bind_args /* { int s; caddr_t name; @@ -170,18 +169,17 @@ bind(p, uap) int error; mtx_lock(&Giant); - - error = holdsock(p->p_fd, uap->s, &fp); + error = holdsock(td->td_proc->p_fd, uap->s, &fp); if (error) goto done2; error = getsockaddr(&sa, uap->name, uap->namelen); if (error) { - fdrop(fp, p); + fdrop(fp, td); goto done2; } - error = sobind((struct socket *)fp->f_data, sa, p); + error = sobind((struct socket *)fp->f_data, sa, td); FREE(sa, M_SONAME); - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return (error); @@ -192,8 +190,8 @@ done2: */ /* ARGSUSED */ int -listen(p, uap) - struct proc *p; +listen(td, uap) + struct thread *td; register struct listen_args /* { int s; int backlog; @@ -203,10 +201,10 @@ listen(p, uap) int error; mtx_lock(&Giant); - error = holdsock(p->p_fd, uap->s, &fp); + error = holdsock(td->td_proc->p_fd, uap->s, &fp); if (error == 0) { - error = solisten((struct socket *)fp->f_data, uap->backlog, p); - fdrop(fp, p); + error = solisten((struct socket *)fp->f_data, uap->backlog, td); + fdrop(fp, td); } mtx_unlock(&Giant); return(error); @@ -217,8 +215,8 @@ listen(p, uap) * MPSAFE */ static int -accept1(p, uap, compat) - struct proc *p; +accept1(td, uap, compat) + struct thread *td; register struct accept_args /* { int s; caddr_t name; @@ -236,8 +234,7 @@ accept1(p, uap, compat) short fflag; /* type must match fp->f_flag */ mtx_lock(&Giant); - fdp = p->p_fd; - + fdp = td->td_proc->p_fd; if (uap->name) { error = copyin((caddr_t)uap->anamelen, (caddr_t)&namelen, sizeof (namelen)); @@ -290,7 +287,7 @@ accept1(p, uap, compat) head->so_qlen--; fflag = lfp->f_flag; - error = falloc(p, &nfp, &fd); + error = falloc(td, &nfp, &fd); if (error) { /* * Probably ran out of file descriptors. Put the @@ -305,7 +302,7 @@ accept1(p, uap, compat) goto done; } fhold(nfp); - p->p_retval[0] = fd; + td->td_retval[0] = fd; /* connection has been removed from the listen queue */ KNOTE(&head->so_rcv.sb_sel.si_note, 0); @@ -367,7 +364,7 @@ noconnection: if (error) { if (fdp->fd_ofiles[fd] == nfp) { fdp->fd_ofiles[fd] = NULL; - fdrop(nfp, p); + fdrop(nfp, td); } } splx(s); @@ -377,8 +374,8 @@ noconnection: */ done: if (nfp != NULL) - fdrop(nfp, p); - fdrop(lfp, p); + fdrop(nfp, td); + fdrop(lfp, td); done2: mtx_unlock(&Giant); return (error); @@ -388,11 +385,12 @@ done2: * MPSAFE (accept1() is MPSAFE) */ int -accept(p, uap) - struct proc *p; +accept(td, uap) + struct thread *td; struct accept_args *uap; { - return (accept1(p, uap, 0)); + + return (accept1(td, uap, 0)); } #ifdef COMPAT_OLDSOCK @@ -400,11 +398,12 @@ accept(p, uap) * MPSAFE (accept1() is MPSAFE) */ int -oaccept(p, uap) - struct proc *p; +oaccept(td, uap) + struct thread *td; struct accept_args *uap; { - return (accept1(p, uap, 1)); + + return (accept1(td, uap, 1)); } #endif /* COMPAT_OLDSOCK */ @@ -413,8 +412,8 @@ oaccept(p, uap) */ /* ARGSUSED */ int -connect(p, uap) - struct proc *p; +connect(td, uap) + struct thread *td; register struct connect_args /* { int s; caddr_t name; @@ -427,8 +426,7 @@ connect(p, uap) int error, s; mtx_lock(&Giant); - - error = holdsock(p->p_fd, uap->s, &fp); + error = holdsock(td->td_proc->p_fd, uap->s, &fp); if (error) goto done2; so = (struct socket *)fp->f_data; @@ -439,7 +437,7 @@ connect(p, uap) error = getsockaddr(&sa, uap->name, uap->namelen); if (error) goto done; - error = soconnect(so, sa, p); + error = soconnect(so, sa, td); if (error) goto bad; if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) { @@ -465,7 +463,7 @@ bad: if (error == ERESTART) error = EINTR; done: - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return (error); @@ -475,8 +473,8 @@ done2: * MPSAFE */ int -socketpair(p, uap) - struct proc *p; +socketpair(td, uap) + struct thread *td; register struct socketpair_args /* { int domain; int type; @@ -484,26 +482,25 @@ socketpair(p, uap) int *rsv; } */ *uap; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; struct file *fp1, *fp2; struct socket *so1, *so2; int fd, error, sv[2]; mtx_lock(&Giant); - - error = socreate(uap->domain, &so1, uap->type, uap->protocol, p); + error = socreate(uap->domain, &so1, uap->type, uap->protocol, td); if (error) goto done2; - error = socreate(uap->domain, &so2, uap->type, uap->protocol, p); + error = socreate(uap->domain, &so2, uap->type, uap->protocol, td); if (error) goto free1; - error = falloc(p, &fp1, &fd); + error = falloc(td, &fp1, &fd); if (error) goto free2; fhold(fp1); sv[0] = fd; fp1->f_data = (caddr_t)so1; - error = falloc(p, &fp2, &fd); + error = falloc(td, &fp2, &fd); if (error) goto free3; fhold(fp2); @@ -524,21 +521,21 @@ socketpair(p, uap) fp1->f_ops = fp2->f_ops = &socketops; fp1->f_type = fp2->f_type = DTYPE_SOCKET; error = copyout((caddr_t)sv, (caddr_t)uap->rsv, 2 * sizeof (int)); - fdrop(fp1, p); - fdrop(fp2, p); + fdrop(fp1, td); + fdrop(fp2, td); goto done2; free4: if (fdp->fd_ofiles[sv[1]] == fp2) { fdp->fd_ofiles[sv[1]] = NULL; - fdrop(fp2, p); + fdrop(fp2, td); } - fdrop(fp2, p); + fdrop(fp2, td); free3: if (fdp->fd_ofiles[sv[0]] == fp1) { fdp->fd_ofiles[sv[0]] = NULL; - fdrop(fp1, p); + fdrop(fp1, td); } - fdrop(fp1, p); + fdrop(fp1, td); free2: (void)soclose(so2); free1: @@ -549,8 +546,8 @@ done2: } static int -sendit(p, s, mp, flags) - register struct proc *p; +sendit(td, s, mp, flags) + register struct thread *td; int s; register struct msghdr *mp; int flags; @@ -568,27 +565,27 @@ sendit(p, s, mp, flags) struct uio ktruio; #endif - error = holdsock(p->p_fd, s, &fp); + error = holdsock(td->td_proc->p_fd, s, &fp); if (error) return (error); auio.uio_iov = mp->msg_iov; auio.uio_iovcnt = mp->msg_iovlen; auio.uio_segflg = UIO_USERSPACE; auio.uio_rw = UIO_WRITE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; /* XXX */ auio.uio_resid = 0; iov = mp->msg_iov; for (i = 0; i < mp->msg_iovlen; i++, iov++) { if ((auio.uio_resid += iov->iov_len) < 0) { - fdrop(fp, p); + fdrop(fp, td); return (EINVAL); } } if (mp->msg_name) { error = getsockaddr(&to, mp->msg_name, mp->msg_namelen); if (error) { - fdrop(fp, p); + fdrop(fp, td); return (error); } } else { @@ -627,7 +624,7 @@ sendit(p, s, mp, flags) control = 0; } #ifdef KTRACE - if (KTRPOINT(p, KTR_GENIO)) { + if (KTRPOINT(td->td_proc, KTR_GENIO)) { int iovlen = auio.uio_iovcnt * sizeof (struct iovec); MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); @@ -638,31 +635,31 @@ sendit(p, s, mp, flags) len = auio.uio_resid; so = (struct socket *)fp->f_data; error = so->so_proto->pr_usrreqs->pru_sosend(so, to, &auio, 0, control, - flags, p); + flags, td); if (error) { if (auio.uio_resid != len && (error == ERESTART || error == EINTR || error == EWOULDBLOCK)) error = 0; if (error == EPIPE) { - PROC_LOCK(p); - psignal(p, SIGPIPE); - PROC_UNLOCK(p); + PROC_LOCK(td->td_proc); + psignal(td->td_proc, SIGPIPE); + PROC_UNLOCK(td->td_proc); } } if (error == 0) - p->p_retval[0] = len - auio.uio_resid; + td->td_retval[0] = len - auio.uio_resid; #ifdef KTRACE if (ktriov != NULL) { if (error == 0) { ktruio.uio_iov = ktriov; - ktruio.uio_resid = p->p_retval[0]; - ktrgenio(p->p_tracep, s, UIO_WRITE, &ktruio, error); + ktruio.uio_resid = td->td_retval[0]; + ktrgenio(td->td_proc->p_tracep, s, UIO_WRITE, &ktruio, error); } FREE(ktriov, M_TEMP); } #endif bad: - fdrop(fp, p); + fdrop(fp, td); if (to) FREE(to, M_SONAME); return (error); @@ -672,8 +669,8 @@ bad: * MPSAFE */ int -sendto(p, uap) - struct proc *p; +sendto(td, uap) + struct thread *td; register struct sendto_args /* { int s; caddr_t buf; @@ -698,7 +695,7 @@ sendto(p, uap) aiov.iov_base = uap->buf; aiov.iov_len = uap->len; mtx_lock(&Giant); - error = sendit(p, uap->s, &msg, uap->flags); + error = sendit(td, uap->s, &msg, uap->flags); mtx_unlock(&Giant); return (error); } @@ -708,8 +705,8 @@ sendto(p, uap) * MPSAFE */ int -osend(p, uap) - struct proc *p; +osend(td, uap) + struct thread *td; register struct osend_args /* { int s; caddr_t buf; @@ -730,7 +727,7 @@ osend(p, uap) msg.msg_control = 0; msg.msg_flags = 0; mtx_lock(&Giant); - error = sendit(p, uap->s, &msg, uap->flags); + error = sendit(td, uap->s, &msg, uap->flags); mtx_unlock(&Giant); return (error); } @@ -739,8 +736,8 @@ osend(p, uap) * MPSAFE */ int -osendmsg(p, uap) - struct proc *p; +osendmsg(td, uap) + struct thread *td; register struct osendmsg_args /* { int s; caddr_t msg; @@ -772,7 +769,7 @@ osendmsg(p, uap) goto done; msg.msg_flags = MSG_COMPAT; msg.msg_iov = iov; - error = sendit(p, uap->s, &msg, uap->flags); + error = sendit(td, uap->s, &msg, uap->flags); done: if (iov != aiov) FREE(iov, M_IOV); @@ -786,8 +783,8 @@ done2: * MPSAFE */ int -sendmsg(p, uap) - struct proc *p; +sendmsg(td, uap) + struct thread *td; register struct sendmsg_args /* { int s; caddr_t msg; @@ -799,7 +796,6 @@ sendmsg(p, uap) int error; mtx_lock(&Giant); - error = copyin(uap->msg, (caddr_t)&msg, sizeof (msg)); if (error) goto done2; @@ -822,7 +818,7 @@ sendmsg(p, uap) #ifdef COMPAT_OLDSOCK msg.msg_flags = 0; #endif - error = sendit(p, uap->s, &msg, uap->flags); + error = sendit(td, uap->s, &msg, uap->flags); done: if (iov != aiov) FREE(iov, M_IOV); @@ -832,8 +828,8 @@ done2: } static int -recvit(p, s, mp, namelenp) - register struct proc *p; +recvit(td, s, mp, namelenp) + register struct thread *td; int s; register struct msghdr *mp; caddr_t namelenp; @@ -852,25 +848,25 @@ recvit(p, s, mp, namelenp) struct uio ktruio; #endif - error = holdsock(p->p_fd, s, &fp); + error = holdsock(td->td_proc->p_fd, s, &fp); if (error) return (error); auio.uio_iov = mp->msg_iov; auio.uio_iovcnt = mp->msg_iovlen; auio.uio_segflg = UIO_USERSPACE; auio.uio_rw = UIO_READ; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; /* XXX */ auio.uio_resid = 0; iov = mp->msg_iov; for (i = 0; i < mp->msg_iovlen; i++, iov++) { if ((auio.uio_resid += iov->iov_len) < 0) { - fdrop(fp, p); + fdrop(fp, td); return (EINVAL); } } #ifdef KTRACE - if (KTRPOINT(p, KTR_GENIO)) { + if (KTRPOINT(td->td_proc, KTR_GENIO)) { int iovlen = auio.uio_iovcnt * sizeof (struct iovec); MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK); @@ -893,14 +889,14 @@ recvit(p, s, mp, namelenp) if (error == 0) { ktruio.uio_iov = ktriov; ktruio.uio_resid = len - auio.uio_resid; - ktrgenio(p->p_tracep, s, UIO_READ, &ktruio, error); + ktrgenio(td->td_proc->p_tracep, s, UIO_READ, &ktruio, error); } FREE(ktriov, M_TEMP); } #endif if (error) goto out; - p->p_retval[0] = len - auio.uio_resid; + td->td_retval[0] = len - auio.uio_resid; if (mp->msg_name) { len = mp->msg_namelen; if (len <= 0 || fromsa == 0) @@ -979,7 +975,7 @@ recvit(p, s, mp, namelenp) mp->msg_controllen = ctlbuf - (caddr_t)mp->msg_control; } out: - fdrop(fp, p); + fdrop(fp, td); if (fromsa) FREE(fromsa, M_SONAME); if (control) @@ -991,8 +987,8 @@ out: * MPSAFE */ int -recvfrom(p, uap) - struct proc *p; +recvfrom(td, uap) + struct thread *td; register struct recvfrom_args /* { int s; caddr_t buf; @@ -1007,7 +1003,6 @@ recvfrom(p, uap) int error; mtx_lock(&Giant); - if (uap->fromlenaddr) { error = copyin((caddr_t)uap->fromlenaddr, (caddr_t)&msg.msg_namelen, sizeof (msg.msg_namelen)); @@ -1023,7 +1018,7 @@ recvfrom(p, uap) aiov.iov_len = uap->len; msg.msg_control = 0; msg.msg_flags = uap->flags; - error = recvit(p, uap->s, &msg, (caddr_t)uap->fromlenaddr); + error = recvit(td, uap->s, &msg, (caddr_t)uap->fromlenaddr); done2: mtx_unlock(&Giant); return(error); @@ -1034,13 +1029,13 @@ done2: * MPSAFE */ int -orecvfrom(p, uap) - struct proc *p; +orecvfrom(td, uap) + struct thread *td; struct recvfrom_args *uap; { uap->flags |= MSG_COMPAT; - return (recvfrom(p, uap)); + return (recvfrom(td, uap)); } #endif @@ -1050,8 +1045,8 @@ orecvfrom(p, uap) * MPSAFE */ int -orecv(p, uap) - struct proc *p; +orecv(td, uap) + struct thread *td; register struct orecv_args /* { int s; caddr_t buf; @@ -1072,7 +1067,7 @@ orecv(p, uap) aiov.iov_len = uap->len; msg.msg_control = 0; msg.msg_flags = uap->flags; - error = recvit(p, uap->s, &msg, (caddr_t)0); + error = recvit(td, uap->s, &msg, (caddr_t)0); mtx_unlock(&Giant); return (error); } @@ -1085,8 +1080,8 @@ orecv(p, uap) * MPSAFE */ int -orecvmsg(p, uap) - struct proc *p; +orecvmsg(td, uap) + struct thread *td; register struct orecvmsg_args /* { int s; struct omsghdr *msg; @@ -1120,7 +1115,7 @@ orecvmsg(p, uap) if (error) goto done; msg.msg_iov = iov; - error = recvit(p, uap->s, &msg, (caddr_t)&uap->msg->msg_namelen); + error = recvit(td, uap->s, &msg, (caddr_t)&uap->msg->msg_namelen); if (msg.msg_controllen && error == 0) error = copyout((caddr_t)&msg.msg_controllen, @@ -1138,8 +1133,8 @@ done2: * MPSAFE */ int -recvmsg(p, uap) - struct proc *p; +recvmsg(td, uap) + struct thread *td; register struct recvmsg_args /* { int s; struct msghdr *msg; @@ -1151,7 +1146,6 @@ recvmsg(p, uap) register int error; mtx_lock(&Giant); - error = copyin((caddr_t)uap->msg, (caddr_t)&msg, sizeof (msg)); if (error) goto done2; @@ -1177,7 +1171,7 @@ recvmsg(p, uap) (unsigned)(msg.msg_iovlen * sizeof (struct iovec))); if (error) goto done; - error = recvit(p, uap->s, &msg, (caddr_t)0); + error = recvit(td, uap->s, &msg, (caddr_t)0); if (!error) { msg.msg_iov = uiov; error = copyout((caddr_t)&msg, (caddr_t)uap->msg, sizeof(msg)); @@ -1195,8 +1189,8 @@ done2: */ /* ARGSUSED */ int -shutdown(p, uap) - struct proc *p; +shutdown(td, uap) + struct thread *td; register struct shutdown_args /* { int s; int how; @@ -1206,11 +1200,10 @@ shutdown(p, uap) int error; mtx_lock(&Giant); - - error = holdsock(p->p_fd, uap->s, &fp); + error = holdsock(td->td_proc->p_fd, uap->s, &fp); if (error == 0) { error = soshutdown((struct socket *)fp->f_data, uap->how); - fdrop(fp, p); + fdrop(fp, td); } mtx_unlock(&Giant); return(error); @@ -1221,8 +1214,8 @@ shutdown(p, uap) */ /* ARGSUSED */ int -setsockopt(p, uap) - struct proc *p; +setsockopt(td, uap) + struct thread *td; register struct setsockopt_args /* { int s; int level; @@ -1241,16 +1234,16 @@ setsockopt(p, uap) return (EINVAL); mtx_lock(&Giant); - error = holdsock(p->p_fd, uap->s, &fp); + error = holdsock(td->td_proc->p_fd, uap->s, &fp); if (error == 0) { sopt.sopt_dir = SOPT_SET; sopt.sopt_level = uap->level; sopt.sopt_name = uap->name; sopt.sopt_val = uap->val; sopt.sopt_valsize = uap->valsize; - sopt.sopt_p = p; + sopt.sopt_td = td; error = sosetopt((struct socket *)fp->f_data, &sopt); - fdrop(fp, p); + fdrop(fp, td); } mtx_unlock(&Giant); return(error); @@ -1261,8 +1254,8 @@ setsockopt(p, uap) */ /* ARGSUSED */ int -getsockopt(p, uap) - struct proc *p; +getsockopt(td, uap) + struct thread *td; register struct getsockopt_args /* { int s; int level; @@ -1276,19 +1269,18 @@ getsockopt(p, uap) struct sockopt sopt; mtx_lock(&Giant); - - error = holdsock(p->p_fd, uap->s, &fp); + error = holdsock(td->td_proc->p_fd, uap->s, &fp); if (error) goto done2; if (uap->val) { error = copyin((caddr_t)uap->avalsize, (caddr_t)&valsize, sizeof (valsize)); if (error) { - fdrop(fp, p); + fdrop(fp, td); goto done2; } if (valsize < 0) { - fdrop(fp, p); + fdrop(fp, td); error = EINVAL; goto done2; } @@ -1301,7 +1293,7 @@ getsockopt(p, uap) sopt.sopt_name = uap->name; sopt.sopt_val = uap->val; sopt.sopt_valsize = (size_t)valsize; /* checked non-negative above */ - sopt.sopt_p = p; + sopt.sopt_td = td; error = sogetopt((struct socket *)fp->f_data, &sopt); if (error == 0) { @@ -1309,7 +1301,7 @@ getsockopt(p, uap) error = copyout((caddr_t)&valsize, (caddr_t)uap->avalsize, sizeof (valsize)); } - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return (error); @@ -1322,8 +1314,8 @@ done2: */ /* ARGSUSED */ static int -getsockname1(p, uap, compat) - struct proc *p; +getsockname1(td, uap, compat) + struct thread *td; register struct getsockname_args /* { int fdes; caddr_t asa; @@ -1337,13 +1329,12 @@ getsockname1(p, uap, compat) int len, error; mtx_lock(&Giant); - - error = holdsock(p->p_fd, uap->fdes, &fp); + error = holdsock(td->td_proc->p_fd, uap->fdes, &fp); if (error) goto done2; error = copyin((caddr_t)uap->alen, (caddr_t)&len, sizeof (len)); if (error) { - fdrop(fp, p); + fdrop(fp, td); goto done2; } so = (struct socket *)fp->f_data; @@ -1369,7 +1360,7 @@ gotnothing: bad: if (sa) FREE(sa, M_SONAME); - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return (error); @@ -1379,11 +1370,12 @@ done2: * MPSAFE */ int -getsockname(p, uap) - struct proc *p; +getsockname(td, uap) + struct thread *td; struct getsockname_args *uap; { - return (getsockname1(p, uap, 0)); + + return (getsockname1(td, uap, 0)); } #ifdef COMPAT_OLDSOCK @@ -1391,11 +1383,12 @@ getsockname(p, uap) * MPSAFE */ int -ogetsockname(p, uap) - struct proc *p; +ogetsockname(td, uap) + struct thread *td; struct getsockname_args *uap; { - return (getsockname1(p, uap, 1)); + + return (getsockname1(td, uap, 1)); } #endif /* COMPAT_OLDSOCK */ @@ -1406,8 +1399,8 @@ ogetsockname(p, uap) */ /* ARGSUSED */ static int -getpeername1(p, uap, compat) - struct proc *p; +getpeername1(td, uap, compat) + struct thread *td; register struct getpeername_args /* { int fdes; caddr_t asa; @@ -1421,19 +1414,18 @@ getpeername1(p, uap, compat) int len, error; mtx_lock(&Giant); - - error = holdsock(p->p_fd, uap->fdes, &fp); + error = holdsock(td->td_proc->p_fd, uap->fdes, &fp); if (error) goto done2; so = (struct socket *)fp->f_data; if ((so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0) { - fdrop(fp, p); + fdrop(fp, td); error = ENOTCONN; goto done2; } error = copyin((caddr_t)uap->alen, (caddr_t)&len, sizeof (len)); if (error) { - fdrop(fp, p); + fdrop(fp, td); goto done2; } sa = 0; @@ -1458,7 +1450,7 @@ gotnothing: bad: if (sa) FREE(sa, M_SONAME); - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return (error); @@ -1468,11 +1460,12 @@ done2: * MPSAFE */ int -getpeername(p, uap) - struct proc *p; +getpeername(td, uap) + struct thread *td; struct getpeername_args *uap; { - return (getpeername1(p, uap, 0)); + + return (getpeername1(td, uap, 0)); } #ifdef COMPAT_OLDSOCK @@ -1480,12 +1473,13 @@ getpeername(p, uap) * MPSAFE */ int -ogetpeername(p, uap) - struct proc *p; +ogetpeername(td, uap) + struct thread *td; struct ogetpeername_args *uap; { + /* XXX uap should have type `getpeername_args *' to begin with. */ - return (getpeername1(p, (struct getpeername_args *)uap, 1)); + return (getpeername1(td, (struct getpeername_args *)uap, 1)); } #endif /* COMPAT_OLDSOCK */ @@ -1682,10 +1676,10 @@ sf_buf_free(caddr_t addr, void *args) * */ int -sendfile(struct proc *p, struct sendfile_args *uap) +sendfile(struct thread *td, struct sendfile_args *uap) { struct file *fp; - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct vnode *vp; struct vm_object *obj; struct socket *so; @@ -1698,7 +1692,6 @@ sendfile(struct proc *p, struct sendfile_args *uap) int error = 0, s; mtx_lock(&Giant); - vp = NULL; /* * Do argument checking. Must be a regular file in, stream @@ -1719,8 +1712,8 @@ sendfile(struct proc *p, struct sendfile_args *uap) error = EINVAL; goto done; } - fdrop(fp, p); - error = holdsock(p->p_fd, uap->s, &fp); + fdrop(fp, td); + error = holdsock(td->td_proc->p_fd, uap->s, &fp); if (error) goto done; so = (struct socket *)fp->f_data; @@ -1752,10 +1745,10 @@ sendfile(struct proc *p, struct sendfile_args *uap) nuap.fd = uap->s; nuap.iovp = hdtr.headers; nuap.iovcnt = hdtr.hdr_cnt; - error = writev(p, &nuap); + error = writev(td, &nuap); if (error) goto done; - sbytes += p->p_retval[0]; + sbytes += td->td_retval[0]; } } @@ -1856,11 +1849,11 @@ retry_lookup: auio.uio_offset = trunc_page(off); auio.uio_segflg = UIO_NOCOPY; auio.uio_rw = UIO_READ; - auio.uio_procp = p; - vn_lock(vp, LK_SHARED | LK_NOPAUSE | LK_RETRY, p); + auio.uio_td = td; + vn_lock(vp, LK_SHARED | LK_NOPAUSE | LK_RETRY, td); error = VOP_READ(vp, &auio, IO_VMIO | ((MAXBSIZE / bsize) << 16), - p->p_ucred); - VOP_UNLOCK(vp, 0, p); + td->td_proc->p_ucred); + VOP_UNLOCK(vp, 0, td); vm_page_flag_clear(pg, PG_ZERO); vm_page_io_finish(pg); if (error) { @@ -1972,7 +1965,7 @@ retry_space: } goto retry_space; } - error = (*so->so_proto->pr_usrreqs->pru_send)(so, 0, m, 0, 0, p); + error = (*so->so_proto->pr_usrreqs->pru_send)(so, 0, m, 0, 0, td); splx(s); if (error) { sbunlock(&so->so_snd); @@ -1988,19 +1981,19 @@ retry_space: nuap.fd = uap->s; nuap.iovp = hdtr.trailers; nuap.iovcnt = hdtr.trl_cnt; - error = writev(p, &nuap); + error = writev(td, &nuap); if (error) goto done; - sbytes += p->p_retval[0]; + sbytes += td->td_retval[0]; } done: /* - * If there was no error we have to clear p->p_retval[0] + * If there was no error we have to clear td->td_retval[0] * because it may have been set by writev. */ if (error == 0) { - p->p_retval[0] = 0; + td->td_retval[0] = 0; } if (uap->sbytes != NULL) { copyout(&sbytes, uap->sbytes, sizeof(off_t)); @@ -2008,8 +2001,7 @@ done: if (vp) vrele(vp); if (fp) - fdrop(fp, p); + fdrop(fp, td); mtx_unlock(&Giant); return (error); } - diff --git a/sys/kern/uipc_usrreq.c b/sys/kern/uipc_usrreq.c index 043bc6b..52c60cf 100644 --- a/sys/kern/uipc_usrreq.c +++ b/sys/kern/uipc_usrreq.c @@ -80,9 +80,9 @@ static ino_t unp_ino; /* prototype for fake inode numbers */ static int unp_attach __P((struct socket *)); static void unp_detach __P((struct unpcb *)); -static int unp_bind __P((struct unpcb *,struct sockaddr *, struct proc *)); +static int unp_bind __P((struct unpcb *,struct sockaddr *, struct thread *)); static int unp_connect __P((struct socket *,struct sockaddr *, - struct proc *)); + struct thread *)); static void unp_disconnect __P((struct unpcb *)); static void unp_shutdown __P((struct unpcb *)); static void unp_drop __P((struct unpcb *, int)); @@ -90,7 +90,7 @@ static void unp_gc __P((void)); static void unp_scan __P((struct mbuf *, void (*)(struct file *))); static void unp_mark __P((struct file *)); static void unp_discard __P((struct file *)); -static int unp_internalize __P((struct mbuf *, struct proc *)); +static int unp_internalize __P((struct mbuf *, struct thread *)); static int unp_listen __P((struct unpcb *, struct proc *)); static int @@ -127,7 +127,7 @@ uipc_accept(struct socket *so, struct sockaddr **nam) } static int -uipc_attach(struct socket *so, int proto, struct proc *p) +uipc_attach(struct socket *so, int proto, struct thread *td) { struct unpcb *unp = sotounpcb(so); @@ -137,24 +137,24 @@ uipc_attach(struct socket *so, int proto, struct proc *p) } static int -uipc_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +uipc_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { struct unpcb *unp = sotounpcb(so); if (unp == 0) return EINVAL; - return unp_bind(unp, nam, p); + return unp_bind(unp, nam, td); } static int -uipc_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +uipc_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { struct unpcb *unp = sotounpcb(so); if (unp == 0) return EINVAL; - return unp_connect(so, nam, curproc); + return unp_connect(so, nam, curthread); } static int @@ -194,13 +194,13 @@ uipc_disconnect(struct socket *so) } static int -uipc_listen(struct socket *so, struct proc *p) +uipc_listen(struct socket *so, struct thread *td) { struct unpcb *unp = sotounpcb(so); if (unp == 0 || unp->unp_vnode == 0) return EINVAL; - return unp_listen(unp, p); + return unp_listen(unp, td->td_proc); } static int @@ -258,7 +258,7 @@ uipc_rcvd(struct socket *so, int flags) static int uipc_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { int error = 0; struct unpcb *unp = sotounpcb(so); @@ -274,7 +274,7 @@ uipc_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, goto release; } - if (control && (error = unp_internalize(control, p))) + if (control && (error = unp_internalize(control, td))) goto release; switch (so->so_type) { @@ -287,7 +287,7 @@ uipc_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, error = EISCONN; break; } - error = unp_connect(so, nam, p); + error = unp_connect(so, nam, td); if (error) break; } else { @@ -320,7 +320,7 @@ uipc_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, */ if ((so->so_state & SS_ISCONNECTED) == 0) { if (nam) { - error = unp_connect(so, nam, p); + error = unp_connect(so, nam, td); if (error) break; /* XXX */ } else { @@ -534,7 +534,7 @@ unp_attach(so) unp_count++; LIST_INIT(&unp->unp_refs); unp->unp_socket = so; - unp->unp_rvnode = curproc->p_fd->fd_rdir; + unp->unp_rvnode = curthread->td_proc->p_fd->fd_rdir; LIST_INSERT_HEAD(so->so_type == SOCK_DGRAM ? &unp_dhead : &unp_shead, unp, unp_link); so->so_pcb = (caddr_t)unp; @@ -576,10 +576,10 @@ unp_detach(unp) } static int -unp_bind(unp, nam, p) +unp_bind(unp, nam, td) struct unpcb *unp; struct sockaddr *nam; - struct proc *p; + struct thread *td; { struct sockaddr_un *soun = (struct sockaddr_un *)nam; struct vnode *vp; @@ -599,7 +599,7 @@ unp_bind(unp, nam, p) buf[namelen] = 0; /* null-terminate the string */ restart: NDINIT(&nd, CREATE, NOFOLLOW | LOCKPARENT, UIO_SYSSPACE, - buf, p); + buf, td); /* SHOULD BE ABLE TO ADOPT EXISTING AND wakeup() ALA FIFO's */ error = namei(&nd); if (error) { @@ -627,8 +627,8 @@ restart: } VATTR_NULL(&vattr); vattr.va_type = VSOCK; - vattr.va_mode = (ACCESSPERMS & ~p->p_fd->fd_cmask); - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + vattr.va_mode = (ACCESSPERMS & ~td->td_proc->p_fd->fd_cmask); + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); NDFREE(&nd, NDF_ONLY_PNBUF); vput(nd.ni_dvp); @@ -640,17 +640,17 @@ restart: vp->v_socket = unp->unp_socket; unp->unp_vnode = vp; unp->unp_addr = (struct sockaddr_un *)dup_sockaddr(nam, 1); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); free(buf, M_TEMP); return (0); } static int -unp_connect(so, nam, p) +unp_connect(so, nam, td) struct socket *so; struct sockaddr *nam; - struct proc *p; + struct thread *td; { register struct sockaddr_un *soun = (struct sockaddr_un *)nam; register struct vnode *vp; @@ -666,7 +666,7 @@ unp_connect(so, nam, p) strncpy(buf, soun->sun_path, len); buf[len] = 0; - NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, buf, p); + NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, buf, td); error = namei(&nd); if (error) return (error); @@ -676,7 +676,7 @@ unp_connect(so, nam, p) error = ENOTSOCK; goto bad; } - error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p); + error = VOP_ACCESS(vp, VWRITE, td->td_proc->p_ucred, td); if (error) goto bad; so2 = vp->v_socket; @@ -690,7 +690,7 @@ unp_connect(so, nam, p) } if (so->so_proto->pr_flags & PR_CONNREQUIRED) { if ((so2->so_options & SO_ACCEPTCONN) == 0 || - (so3 = sonewconn3(so2, 0, p)) == 0) { + (so3 = sonewconn3(so2, 0, td)) == 0) { error = ECONNREFUSED; goto bad; } @@ -710,9 +710,9 @@ unp_connect(so, nam, p) * (which is now). */ memset(&unp3->unp_peercred, '\0', sizeof(unp3->unp_peercred)); - unp3->unp_peercred.cr_uid = p->p_ucred->cr_uid; - unp3->unp_peercred.cr_ngroups = p->p_ucred->cr_ngroups; - memcpy(unp3->unp_peercred.cr_groups, p->p_ucred->cr_groups, + unp3->unp_peercred.cr_uid = td->td_proc->p_ucred->cr_uid; + unp3->unp_peercred.cr_ngroups = td->td_proc->p_ucred->cr_ngroups; + memcpy(unp3->unp_peercred.cr_groups, td->td_proc->p_ucred->cr_groups, sizeof(unp3->unp_peercred.cr_groups)); unp3->unp_flags |= UNP_HAVEPC; /* @@ -956,7 +956,7 @@ int unp_externalize(rights) struct mbuf *rights; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ register int i; register struct cmsghdr *cm = mtod(rights, struct cmsghdr *); register int *fdp; @@ -969,7 +969,7 @@ unp_externalize(rights) /* * if the new FD's will not fit, then we free them all */ - if (!fdavail(p, newfds)) { + if (!fdavail(td, newfds)) { rp = (struct file **)CMSG_DATA(cm); for (i = 0; i < newfds; i++) { fp = *rp; @@ -997,10 +997,10 @@ unp_externalize(rights) fdp = (int *)(cm + 1); rp = (struct file **)CMSG_DATA(cm); for (i = 0; i < newfds; i++) { - if (fdalloc(p, 0, &f)) + if (fdalloc(td, 0, &f)) panic("unp_externalize"); fp = *rp++; - p->p_fd->fd_ofiles[f] = fp; + td->td_proc->p_fd->fd_ofiles[f] = fp; fp->f_msgcount--; unp_rights--; *fdp++ = f; @@ -1009,10 +1009,10 @@ unp_externalize(rights) fdp = (int *)(cm + 1) + newfds - 1; rp = (struct file **)CMSG_DATA(cm) + newfds - 1; for (i = 0; i < newfds; i++) { - if (fdalloc(p, 0, &f)) + if (fdalloc(td, 0, &f)) panic("unp_externalize"); fp = *rp--; - p->p_fd->fd_ofiles[f] = fp; + td->td_proc->p_fd->fd_ofiles[f] = fp; fp->f_msgcount--; unp_rights--; *fdp-- = f; @@ -1043,10 +1043,11 @@ unp_init(void) #endif static int -unp_internalize(control, p) +unp_internalize(control, td) struct mbuf *control; - struct proc *p; + struct thread *td; { + struct proc *p = td->td_proc; struct filedesc *fdescp = p->p_fd; register struct cmsghdr *cm = mtod(control, struct cmsghdr *); register struct file **rp; @@ -1308,7 +1309,7 @@ unp_gc() sorflush((struct socket *)(tfp->f_data)); } for (i = nunref, fpp = extra_ref; --i >= 0; ++fpp) - closef(*fpp, (struct proc *) NULL); + closef(*fpp, (struct thread *) NULL); free((caddr_t)extra_ref, M_FILE); unp_gcing = 0; } @@ -1386,5 +1387,5 @@ unp_discard(fp) fp->f_msgcount--; unp_rights--; - (void) closef(fp, (struct proc *)NULL); + (void) closef(fp, (struct thread *)NULL); } diff --git a/sys/kern/vfs_acl.c b/sys/kern/vfs_acl.c index 69dbe85..045d1a8 100644 --- a/sys/kern/vfs_acl.c +++ b/sys/kern/vfs_acl.c @@ -48,11 +48,11 @@ MALLOC_DEFINE(M_ACL, "acl", "access control list"); -static int vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, +static int vacl_set_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp); -static int vacl_get_acl(struct proc *p, struct vnode *vp, acl_type_t type, +static int vacl_get_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp); -static int vacl_aclcheck(struct proc *p, struct vnode *vp, +static int vacl_aclcheck( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp); /* @@ -562,7 +562,7 @@ acl_posix1e_check(struct acl *acl) * Given a vnode, set its ACL. */ static int -vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, +vacl_set_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp) { struct acl inkernacl; @@ -571,10 +571,10 @@ vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, error = copyin(aclp, &inkernacl, sizeof(struct acl)); if (error) return(error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_SETACL(vp, type, &inkernacl, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_SETACL(vp, type, &inkernacl, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); return(error); } @@ -582,16 +582,16 @@ vacl_set_acl(struct proc *p, struct vnode *vp, acl_type_t type, * Given a vnode, get its ACL. */ static int -vacl_get_acl(struct proc *p, struct vnode *vp, acl_type_t type, +vacl_get_acl( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp) { struct acl inkernelacl; int error; - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_GETACL(vp, type, &inkernelacl, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_GETACL(vp, type, &inkernelacl, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); if (error == 0) error = copyout(&inkernelacl, aclp, sizeof(struct acl)); return (error); @@ -601,14 +601,14 @@ vacl_get_acl(struct proc *p, struct vnode *vp, acl_type_t type, * Given a vnode, delete its ACL. */ static int -vacl_delete(struct proc *p, struct vnode *vp, acl_type_t type) +vacl_delete( struct thread *td, struct vnode *vp, acl_type_t type) { int error; - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_SETACL(vp, ACL_TYPE_DEFAULT, 0, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_SETACL(vp, ACL_TYPE_DEFAULT, 0, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); return (error); } @@ -616,7 +616,7 @@ vacl_delete(struct proc *p, struct vnode *vp, acl_type_t type) * Given a vnode, check whether an ACL is appropriate for it */ static int -vacl_aclcheck(struct proc *p, struct vnode *vp, acl_type_t type, +vacl_aclcheck( struct thread *td, struct vnode *vp, acl_type_t type, struct acl *aclp) { struct acl inkernelacl; @@ -625,7 +625,7 @@ vacl_aclcheck(struct proc *p, struct vnode *vp, acl_type_t type, error = copyin(aclp, &inkernelacl, sizeof(struct acl)); if (error) return(error); - error = VOP_ACLCHECK(vp, type, &inkernelacl, p->p_ucred, p); + error = VOP_ACLCHECK(vp, type, &inkernelacl, td->td_proc->p_ucred, td); return (error); } @@ -641,17 +641,17 @@ vacl_aclcheck(struct proc *p, struct vnode *vp, acl_type_t type, * MPSAFE */ int -__acl_get_file(struct proc *p, struct __acl_get_file_args *uap) +__acl_get_file( struct thread *td, struct __acl_get_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); /* what flags are required here -- possible not LOCKLEAF? */ - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_get_acl(p, nd.ni_vp, SCARG(uap, type), + error = vacl_get_acl(td, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp)); NDFREE(&nd, 0); } @@ -665,16 +665,16 @@ __acl_get_file(struct proc *p, struct __acl_get_file_args *uap) * MPSAFE */ int -__acl_set_file(struct proc *p, struct __acl_set_file_args *uap) +__acl_set_file( struct thread *td, struct __acl_set_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_set_acl(p, nd.ni_vp, SCARG(uap, type), + error = vacl_set_acl(td, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp)); NDFREE(&nd, 0); } @@ -688,15 +688,15 @@ __acl_set_file(struct proc *p, struct __acl_set_file_args *uap) * MPSAFE */ int -__acl_get_fd(struct proc *p, struct __acl_get_fd_args *uap) +__acl_get_fd( struct thread *td, struct __acl_get_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_get_acl(p, (struct vnode *)fp->f_data, + error = vacl_get_acl(td, (struct vnode *)fp->f_data, SCARG(uap, type), SCARG(uap, aclp)); } mtx_unlock(&Giant); @@ -709,15 +709,15 @@ __acl_get_fd(struct proc *p, struct __acl_get_fd_args *uap) * MPSAFE */ int -__acl_set_fd(struct proc *p, struct __acl_set_fd_args *uap) +__acl_set_fd( struct thread *td, struct __acl_set_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_set_acl(p, (struct vnode *)fp->f_data, + error = vacl_set_acl(td, (struct vnode *)fp->f_data, SCARG(uap, type), SCARG(uap, aclp)); } mtx_unlock(&Giant); @@ -730,16 +730,16 @@ __acl_set_fd(struct proc *p, struct __acl_set_fd_args *uap) * MPSAFE */ int -__acl_delete_file(struct proc *p, struct __acl_delete_file_args *uap) +__acl_delete_file( struct thread *td, struct __acl_delete_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_delete(p, nd.ni_vp, SCARG(uap, type)); + error = vacl_delete(td, nd.ni_vp, SCARG(uap, type)); NDFREE(&nd, 0); } mtx_unlock(&Giant); @@ -752,15 +752,15 @@ __acl_delete_file(struct proc *p, struct __acl_delete_file_args *uap) * MPSAFE */ int -__acl_delete_fd(struct proc *p, struct __acl_delete_fd_args *uap) +__acl_delete_fd( struct thread *td, struct __acl_delete_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_delete(p, (struct vnode *)fp->f_data, + error = vacl_delete(td, (struct vnode *)fp->f_data, SCARG(uap, type)); } mtx_unlock(&Giant); @@ -773,16 +773,16 @@ __acl_delete_fd(struct proc *p, struct __acl_delete_fd_args *uap) * MPSAFE */ int -__acl_aclcheck_file(struct proc *p, struct __acl_aclcheck_file_args *uap) +__acl_aclcheck_file( struct thread *td, struct __acl_aclcheck_file_args *uap) { struct nameidata nd; int error; mtx_lock(&Giant); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); error = namei(&nd); if (error == 0) { - error = vacl_aclcheck(p, nd.ni_vp, SCARG(uap, type), + error = vacl_aclcheck(td, nd.ni_vp, SCARG(uap, type), SCARG(uap, aclp)); NDFREE(&nd, 0); } @@ -796,15 +796,15 @@ __acl_aclcheck_file(struct proc *p, struct __acl_aclcheck_file_args *uap) * MPSAFE */ int -__acl_aclcheck_fd(struct proc *p, struct __acl_aclcheck_fd_args *uap) +__acl_aclcheck_fd( struct thread *td, struct __acl_aclcheck_fd_args *uap) { struct file *fp; int error; mtx_lock(&Giant); - error = getvnode(p->p_fd, SCARG(uap, filedes), &fp); + error = getvnode(td->td_proc->p_fd, SCARG(uap, filedes), &fp); if (error == 0) { - error = vacl_aclcheck(p, (struct vnode *)fp->f_data, + error = vacl_aclcheck(td, (struct vnode *)fp->f_data, SCARG(uap, type), SCARG(uap, aclp)); } mtx_unlock(&Giant); diff --git a/sys/kern/vfs_aio.c b/sys/kern/vfs_aio.c index a695e5d..89a0c65 100644 --- a/sys/kern/vfs_aio.c +++ b/sys/kern/vfs_aio.c @@ -153,10 +153,10 @@ SYSCTL_INT(_vfs_aio, OID_AUTO, aiod_timeout, #define AIOP_FREE 0x1 /* proc on free queue */ #define AIOP_SCHED 0x2 /* proc explicitly scheduled */ -struct aioproclist { - int aioprocflags; /* AIO proc flags */ - TAILQ_ENTRY(aioproclist) list; /* List of processes */ - struct proc *aioproc; /* The AIO thread */ +struct aiothreadlist { + int aiothreadflags; /* AIO proc flags */ + TAILQ_ENTRY(aiothreadlist) list; /* List of processes */ + struct thread *aiothread; /* The AIO thread */ TAILQ_HEAD (,aiocblist) jobtorun; /* suggested job to run */ }; @@ -201,7 +201,7 @@ struct kaioinfo { #define KAIO_RUNDOWN 0x1 /* process is being run down */ #define KAIO_WAKEUP 0x2 /* wakeup process when there is a significant event */ -static TAILQ_HEAD(,aioproclist) aio_freeproc, aio_activeproc; +static TAILQ_HEAD(,aiothreadlist) aio_freeproc, aio_activeproc; static TAILQ_HEAD(,aiocblist) aio_jobs; /* Async job list */ static TAILQ_HEAD(,aiocblist) aio_bufjobs; /* Phys I/O job list */ @@ -210,7 +210,7 @@ static void aio_onceonly(void *); static int aio_free_entry(struct aiocblist *aiocbe); static void aio_process(struct aiocblist *aiocbe); static int aio_newproc(void); -static int aio_aqueue(struct proc *p, struct aiocb *job, int type); +static int aio_aqueue(struct thread *td, struct aiocb *job, int type); static void aio_physwakeup(struct buf *bp); static int aio_fphysio(struct proc *p, struct aiocblist *aiocbe); static int aio_qphysio(struct proc *p, struct aiocblist *iocb); @@ -233,7 +233,7 @@ aio_onceonly(void *na) TAILQ_INIT(&aio_jobs); TAILQ_INIT(&aio_bufjobs); kaio_zone = zinit("AIO", sizeof (struct kaioinfo), 0, 0, 1); - aiop_zone = zinit("AIOP", sizeof (struct aioproclist), 0, 0, 1); + aiop_zone = zinit("AIOP", sizeof (struct aiothreadlist), 0, 0, 1); aiocb_zone = zinit("AIOCB", sizeof (struct aiocblist), 0, 0, 1); aiol_zone = zinit("AIOL", AIO_LISTIO_MAX * sizeof (int), 0, 0, 1); aiolio_zone = zinit("AIOLIO", AIO_LISTIO_MAX * sizeof (struct @@ -284,7 +284,7 @@ static int aio_free_entry(struct aiocblist *aiocbe) { struct kaioinfo *ki; - struct aioproclist *aiop; + struct aiothreadlist *aiop; struct aio_liojob *lj; struct proc *p; int error; @@ -335,7 +335,13 @@ aio_free_entry(struct aiocblist *aiocbe) } /* aiocbe is going away, we need to destroy any knotes */ - knote_remove(p, &aiocbe->klist); + knote_remove(&p->p_thread, &aiocbe->klist); /* XXXKSE */ + /* XXXKSE Note the thread here is used to eventually find the + * owning process again, but it is also used to do a fo_close + * and that requires the thread. (but does it require the + * OWNING thread? (or maby the running thread?) + * There is a semantic problem here... + */ if ((ki->kaio_flags & KAIO_WAKEUP) || ((ki->kaio_flags & KAIO_RUNDOWN) && ((ki->kaio_buffer_count == 0) && (ki->kaio_queue_count == 0)))) { @@ -352,7 +358,7 @@ aio_free_entry(struct aiocblist *aiocbe) TAILQ_REMOVE(&ki->kaio_bufdone, aiocbe, plist); splx(s); } else if (aiocbe->jobstate == JOBST_JOBQPROC) { - aiop = aiocbe->jobaioproc; + aiop = aiocbe->jobaiothread; TAILQ_REMOVE(&aiop->jobtorun, aiocbe, list); } else if (aiocbe->jobstate == JOBST_JOBQGLOBAL) { TAILQ_REMOVE(&aio_jobs, aiocbe, list); @@ -521,7 +527,7 @@ restart4: * Select a job to run (called by an AIO daemon). */ static struct aiocblist * -aio_selectjob(struct aioproclist *aiop) +aio_selectjob(struct aiothreadlist *aiop) { int s; struct aiocblist *aiocbe; @@ -561,7 +567,9 @@ static void aio_process(struct aiocblist *aiocbe) { struct filedesc *fdp; - struct proc *userp, *mycp; + struct thread *td; + struct proc *userp; + struct proc *mycp; struct aiocb *cb; struct file *fp; struct uio auio; @@ -574,10 +582,10 @@ aio_process(struct aiocblist *aiocbe) int inblock_st, inblock_end; userp = aiocbe->userproc; + td = curthread; + mycp = td->td_proc; cb = &aiocbe->uaiocb; - mycp = curproc; - fdp = mycp->p_fd; fd = cb->aio_fildes; fp = fdp->fd_ofiles[fd]; @@ -588,7 +596,7 @@ aio_process(struct aiocblist *aiocbe) return; } - aiov.iov_base = (void *)cb->aio_buf; + aiov.iov_base = cb->aio_buf; aiov.iov_len = cb->aio_nbytes; auio.uio_iov = &aiov; @@ -597,7 +605,7 @@ aio_process(struct aiocblist *aiocbe) auio.uio_resid = cb->aio_nbytes; cnt = cb->aio_nbytes; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = mycp; + auio.uio_td = td; inblock_st = mycp->p_stats->p_ru.ru_inblock; oublock_st = mycp->p_stats->p_ru.ru_oublock; @@ -608,12 +616,12 @@ aio_process(struct aiocblist *aiocbe) fhold(fp); if (cb->aio_lio_opcode == LIO_READ) { auio.uio_rw = UIO_READ; - error = fo_read(fp, &auio, fp->f_cred, FOF_OFFSET, mycp); + error = fo_read(fp, &auio, fp->f_cred, FOF_OFFSET, td); } else { auio.uio_rw = UIO_WRITE; - error = fo_write(fp, &auio, fp->f_cred, FOF_OFFSET, mycp); + error = fo_write(fp, &auio, fp->f_cred, FOF_OFFSET, td); } - fdrop(fp, mycp); + fdrop(fp, td); inblock_end = mycp->p_stats->p_ru.ru_inblock; oublock_end = mycp->p_stats->p_ru.ru_oublock; @@ -646,16 +654,17 @@ aio_daemon(void *uproc) struct aio_liojob *lj; struct aiocb *cb; struct aiocblist *aiocbe; - struct aioproclist *aiop; + struct aiothreadlist *aiop; struct kaioinfo *ki; struct proc *curcp, *mycp, *userp; struct vmspace *myvm, *tmpvm; + struct thread *td = curthread; mtx_lock(&Giant); /* * Local copies of curproc (cp) and vmspace (myvm) */ - mycp = curproc; + mycp = td->td_proc; myvm = mycp->p_vmspace; if (mycp->p_textvp) { @@ -668,8 +677,8 @@ aio_daemon(void *uproc) * per daemon. */ aiop = zalloc(aiop_zone); - aiop->aioproc = mycp; - aiop->aioprocflags |= AIOP_FREE; + aiop->aiothread = td; + aiop->aiothreadflags |= AIOP_FREE; TAILQ_INIT(&aiop->jobtorun); s = splnet(); @@ -688,7 +697,7 @@ aio_daemon(void *uproc) * filedescriptors, except as temporarily inherited from the client. * Credentials are also cloned, and made equivalent to "root". */ - fdfree(mycp); + fdfree(td); mycp->p_fd = NULL; mycp->p_ucred = crcopy(mycp->p_ucred); mycp->p_ucred->cr_uid = 0; @@ -705,7 +714,7 @@ aio_daemon(void *uproc) /* * Wakeup parent process. (Parent sleeps to keep from blasting away - * creating to many daemons.) + * and creating too many daemons.) */ wakeup(mycp); @@ -719,14 +728,14 @@ aio_daemon(void *uproc) /* * Take daemon off of free queue */ - if (aiop->aioprocflags & AIOP_FREE) { + if (aiop->aiothreadflags & AIOP_FREE) { s = splnet(); TAILQ_REMOVE(&aio_freeproc, aiop, list); TAILQ_INSERT_TAIL(&aio_activeproc, aiop, list); - aiop->aioprocflags &= ~AIOP_FREE; + aiop->aiothreadflags &= ~AIOP_FREE; splx(s); } - aiop->aioprocflags &= ~AIOP_SCHED; + aiop->aiothreadflags &= ~AIOP_SCHED; /* * Check for jobs. @@ -755,7 +764,7 @@ aio_daemon(void *uproc) mycp->p_vmspace->vm_refcnt++; /* Activate the new mapping. */ - pmap_activate(mycp); + pmap_activate(&mycp->p_thread); /* * If the old address space wasn't the daemons @@ -775,7 +784,7 @@ aio_daemon(void *uproc) * because they were originally freed. */ if (mycp->p_fd) - fdfree(mycp); + fdfree(td); mycp->p_fd = fdshare(userp); curcp = userp; } @@ -787,7 +796,7 @@ aio_daemon(void *uproc) ki->kaio_active_count++; /* Do the I/O function. */ - aiocbe->jobaioproc = aiop; + aiocbe->jobaiothread = aiop; aio_process(aiocbe); /* Decrement the active job count. */ @@ -866,7 +875,7 @@ aio_daemon(void *uproc) mycp->p_vmspace = myvm; /* Activate the daemon's address space. */ - pmap_activate(mycp); + pmap_activate(&mycp->p_thread); #ifdef DIAGNOSTIC if (tmpvm == myvm) { printf("AIOD: vmspace problem -- %d\n", @@ -881,7 +890,7 @@ aio_daemon(void *uproc) * descriptors. */ if (mycp->p_fd) - fdfree(mycp); + fdfree(td); mycp->p_fd = NULL; curcp = mycp; } @@ -895,19 +904,19 @@ aio_daemon(void *uproc) if (TAILQ_EMPTY(&aio_freeproc)) wakeup(&aio_freeproc); TAILQ_INSERT_HEAD(&aio_freeproc, aiop, list); - aiop->aioprocflags |= AIOP_FREE; + aiop->aiothreadflags |= AIOP_FREE; splx(s); /* * If daemon is inactive for a long time, allow it to exit, * thereby freeing resources. */ - if (((aiop->aioprocflags & AIOP_SCHED) == 0) && tsleep(mycp, + if (((aiop->aiothreadflags & AIOP_SCHED) == 0) && tsleep(mycp, PRIBIO, "aiordy", aiod_lifetime)) { s = splnet(); if ((TAILQ_FIRST(&aio_jobs) == NULL) && (TAILQ_FIRST(&aiop->jobtorun) == NULL)) { - if ((aiop->aioprocflags & AIOP_FREE) && + if ((aiop->aiothreadflags & AIOP_FREE) && (num_aio_procs > target_aio_procs)) { TAILQ_REMOVE(&aio_freeproc, aiop, list); splx(s); @@ -1033,7 +1042,7 @@ aio_qphysio(struct proc *p, struct aiocblist *aiocbe) bp->b_flags = B_PHYS; bp->b_iodone = aio_physwakeup; bp->b_saveaddr = bp->b_data; - bp->b_data = (void *)cb->aio_buf; + bp->b_data = cb->aio_buf; bp->b_blkno = btodb(cb->aio_offset); if (cb->aio_lio_opcode == LIO_WRITE) { @@ -1163,7 +1172,7 @@ aio_swake(struct socket *so, struct sockbuf *sb) struct proc *p; struct kaioinfo *ki = NULL; int opcode, wakecount = 0; - struct aioproclist *aiop; + struct aiothreadlist *aiop; if (sb == &so->so_snd) { opcode = LIO_WRITE; @@ -1192,8 +1201,8 @@ aio_swake(struct socket *so, struct sockbuf *sb) if ((aiop = TAILQ_FIRST(&aio_freeproc)) != 0) { TAILQ_REMOVE(&aio_freeproc, aiop, list); TAILQ_INSERT_TAIL(&aio_activeproc, aiop, list); - aiop->aioprocflags &= ~AIOP_FREE; - wakeup(aiop->aioproc); + aiop->aiothreadflags &= ~AIOP_FREE; + wakeup(aiop->aiothread); } } #endif /* VFS_AIO */ @@ -1205,8 +1214,9 @@ aio_swake(struct socket *so, struct sockbuf *sb) * technique is done in this code. */ static int -_aio_aqueue(struct proc *p, struct aiocb *job, struct aio_liojob *lj, int type) +_aio_aqueue(struct thread *td, struct aiocb *job, struct aio_liojob *lj, int type) { + struct proc *p = td->td_proc; struct filedesc *fdp; struct file *fp; unsigned int fd; @@ -1215,7 +1225,7 @@ _aio_aqueue(struct proc *p, struct aiocb *job, struct aio_liojob *lj, int type) int error; int opcode; struct aiocblist *aiocbe; - struct aioproclist *aiop; + struct aiothreadlist *aiop; struct kaioinfo *ki; struct kevent kev; struct kqueue *kq; @@ -1347,7 +1357,7 @@ _aio_aqueue(struct proc *p, struct aiocb *job, struct aio_liojob *lj, int type) kev.ident = (uintptr_t)aiocbe; kev.filter = EVFILT_AIO; kev.flags = EV_ADD | EV_ENABLE | EV_FLAG1; - error = kqueue_register(kq, &kev, p); + error = kqueue_register(kq, &kev, td); aqueue_fail: if (error) { zfree(aiocb_zone, aiocbe); @@ -1431,22 +1441,22 @@ retryproc: if ((aiop = TAILQ_FIRST(&aio_freeproc)) != NULL) { TAILQ_REMOVE(&aio_freeproc, aiop, list); TAILQ_INSERT_TAIL(&aio_activeproc, aiop, list); - aiop->aioprocflags &= ~AIOP_FREE; - wakeup(aiop->aioproc); + aiop->aiothreadflags &= ~AIOP_FREE; + wakeup(aiop->aiothread); } else if (((num_aio_resv_start + num_aio_procs) < max_aio_procs) && ((ki->kaio_active_count + num_aio_resv_start) < ki->kaio_maxactive_count)) { num_aio_resv_start++; if ((error = aio_newproc()) == 0) { num_aio_resv_start--; - p->p_retval[0] = 0; + td->td_retval[0] = 0; goto retryproc; } num_aio_resv_start--; } splx(s); done: - fdrop(fp, p); + fdrop(fp, td); return error; } @@ -1454,8 +1464,9 @@ done: * This routine queues an AIO request, checking for quotas. */ static int -aio_aqueue(struct proc *p, struct aiocb *job, int type) +aio_aqueue(struct thread *td, struct aiocb *job, int type) { + struct proc *p = td->td_proc; struct kaioinfo *ki; if (p->p_aioinfo == NULL) @@ -1468,7 +1479,7 @@ aio_aqueue(struct proc *p, struct aiocb *job, int type) if (ki->kaio_queue_count >= ki->kaio_qallowed_count) return EAGAIN; - return _aio_aqueue(p, job, NULL, type); + return _aio_aqueue(td, job, NULL, type); } #endif /* VFS_AIO */ @@ -1477,11 +1488,12 @@ aio_aqueue(struct proc *p, struct aiocb *job, int type) * released. */ int -aio_return(struct proc *p, struct aio_return_args *uap) +aio_return(struct thread *td, struct aio_return_args *uap) { #ifndef VFS_AIO return ENOSYS; #else + struct proc *p = td->td_proc; int s; int jobref; struct aiocblist *cb, *ncb; @@ -1505,10 +1517,10 @@ aio_return(struct proc *p, struct aio_return_args *uap) jobref) { splx(s); if (ujob == cb->uuaiocb) { - p->p_retval[0] = + td->td_retval[0] = cb->uaiocb._aiocb_private.status; } else - p->p_retval[0] = EFAULT; + td->td_retval[0] = EFAULT; if (cb->uaiocb.aio_lio_opcode == LIO_WRITE) { curproc->p_stats->p_ru.ru_oublock += cb->outputcharge; @@ -1531,10 +1543,10 @@ aio_return(struct proc *p, struct aio_return_args *uap) == jobref) { splx(s); if (ujob == cb->uuaiocb) { - p->p_retval[0] = + td->td_retval[0] = cb->uaiocb._aiocb_private.status; } else - p->p_retval[0] = EFAULT; + td->td_retval[0] = EFAULT; aio_free_entry(cb); return 0; } @@ -1549,11 +1561,12 @@ aio_return(struct proc *p, struct aio_return_args *uap) * Allow a process to wakeup when any of the I/O requests are completed. */ int -aio_suspend(struct proc *p, struct aio_suspend_args *uap) +aio_suspend(struct thread *td, struct aio_suspend_args *uap) { #ifndef VFS_AIO return ENOSYS; #else + struct proc *p = td->td_proc; struct timeval atv; struct timespec ts; struct aiocb *const *cbptr, *cbp; @@ -1666,11 +1679,12 @@ aio_suspend(struct proc *p, struct aio_suspend_args *uap) * progress. */ int -aio_cancel(struct proc *p, struct aio_cancel_args *uap) +aio_cancel(struct thread *td, struct aio_cancel_args *uap) { #ifndef VFS_AIO return ENOSYS; #else + struct proc *p = td->td_proc; struct kaioinfo *ki; struct aiocblist *cbe, *cbn; struct file *fp; @@ -1694,7 +1708,7 @@ aio_cancel(struct proc *p, struct aio_cancel_args *uap) vp = (struct vnode *)fp->f_data; if (vn_isdisk(vp,&error)) { - p->p_retval[0] = AIO_NOTCANCELED; + td->td_retval[0] = AIO_NOTCANCELED; return 0; } } else if (fp->f_type == DTYPE_SOCKET) { @@ -1733,7 +1747,7 @@ aio_cancel(struct proc *p, struct aio_cancel_args *uap) splx(s); if ((cancelled) && (uap->aiocbp)) { - p->p_retval[0] = AIO_CANCELED; + td->td_retval[0] = AIO_CANCELED; return 0; } @@ -1777,16 +1791,16 @@ aio_cancel(struct proc *p, struct aio_cancel_args *uap) if (notcancelled) { - p->p_retval[0] = AIO_NOTCANCELED; + td->td_retval[0] = AIO_NOTCANCELED; return 0; } if (cancelled) { - p->p_retval[0] = AIO_CANCELED; + td->td_retval[0] = AIO_CANCELED; return 0; } - p->p_retval[0] = AIO_ALLDONE; + td->td_retval[0] = AIO_ALLDONE; return 0; #endif /* VFS_AIO */ @@ -1798,11 +1812,12 @@ aio_cancel(struct proc *p, struct aio_cancel_args *uap) * subroutine. */ int -aio_error(struct proc *p, struct aio_error_args *uap) +aio_error(struct thread *td, struct aio_error_args *uap) { #ifndef VFS_AIO return ENOSYS; #else + struct proc *p = td->td_proc; int s; struct aiocblist *cb; struct kaioinfo *ki; @@ -1820,7 +1835,7 @@ aio_error(struct proc *p, struct aio_error_args *uap) plist)) { if (((intptr_t)cb->uaiocb._aiocb_private.kernelinfo) == jobref) { - p->p_retval[0] = cb->uaiocb._aiocb_private.error; + td->td_retval[0] = cb->uaiocb._aiocb_private.error; return 0; } } @@ -1831,7 +1846,7 @@ aio_error(struct proc *p, struct aio_error_args *uap) plist)) { if (((intptr_t)cb->uaiocb._aiocb_private.kernelinfo) == jobref) { - p->p_retval[0] = EINPROGRESS; + td->td_retval[0] = EINPROGRESS; splx(s); return 0; } @@ -1841,7 +1856,7 @@ aio_error(struct proc *p, struct aio_error_args *uap) plist)) { if (((intptr_t)cb->uaiocb._aiocb_private.kernelinfo) == jobref) { - p->p_retval[0] = EINPROGRESS; + td->td_retval[0] = EINPROGRESS; splx(s); return 0; } @@ -1853,7 +1868,7 @@ aio_error(struct proc *p, struct aio_error_args *uap) plist)) { if (((intptr_t)cb->uaiocb._aiocb_private.kernelinfo) == jobref) { - p->p_retval[0] = cb->uaiocb._aiocb_private.error; + td->td_retval[0] = cb->uaiocb._aiocb_private.error; splx(s); return 0; } @@ -1863,7 +1878,7 @@ aio_error(struct proc *p, struct aio_error_args *uap) plist)) { if (((intptr_t)cb->uaiocb._aiocb_private.kernelinfo) == jobref) { - p->p_retval[0] = EINPROGRESS; + td->td_retval[0] = EINPROGRESS; splx(s); return 0; } @@ -1883,31 +1898,32 @@ aio_error(struct proc *p, struct aio_error_args *uap) } int -aio_read(struct proc *p, struct aio_read_args *uap) +aio_read(struct thread *td, struct aio_read_args *uap) { #ifndef VFS_AIO return ENOSYS; #else - return aio_aqueue(p, uap->aiocbp, LIO_READ); + return aio_aqueue(td, uap->aiocbp, LIO_READ); #endif /* VFS_AIO */ } int -aio_write(struct proc *p, struct aio_write_args *uap) +aio_write(struct thread *td, struct aio_write_args *uap) { #ifndef VFS_AIO return ENOSYS; #else - return aio_aqueue(p, uap->aiocbp, LIO_WRITE); + return aio_aqueue(td, uap->aiocbp, LIO_WRITE); #endif /* VFS_AIO */ } int -lio_listio(struct proc *p, struct lio_listio_args *uap) +lio_listio(struct thread *td, struct lio_listio_args *uap) { #ifndef VFS_AIO return ENOSYS; #else + struct proc *p = td->td_proc; int nent, nentqueued; struct aiocb *iocb, * const *cbptr; struct aiocblist *cb; @@ -1975,7 +1991,7 @@ lio_listio(struct proc *p, struct lio_listio_args *uap) for (i = 0; i < uap->nent; i++) { iocb = (struct aiocb *)(intptr_t)fuword((caddr_t)&cbptr[i]); if (((intptr_t)iocb != -1) && ((intptr_t)iocb != NULL)) { - error = _aio_aqueue(p, iocb, lj, 0); + error = _aio_aqueue(td, iocb, lj, 0); if (error == 0) nentqueued++; else @@ -2173,11 +2189,12 @@ aio_physwakeup(struct buf *bp) #endif /* VFS_AIO */ int -aio_waitcomplete(struct proc *p, struct aio_waitcomplete_args *uap) +aio_waitcomplete(struct thread *td, struct aio_waitcomplete_args *uap) { #ifndef VFS_AIO return ENOSYS; #else + struct proc *p = td->td_proc; struct timeval atv; struct timespec ts; struct aiocb **cbptr; @@ -2212,7 +2229,7 @@ aio_waitcomplete(struct proc *p, struct aio_waitcomplete_args *uap) for (;;) { if ((cb = TAILQ_FIRST(&ki->kaio_jobdone)) != 0) { suword(uap->aiocbp, (int)cb->uuaiocb); - p->p_retval[0] = cb->uaiocb._aiocb_private.status; + td->td_retval[0] = cb->uaiocb._aiocb_private.status; if (cb->uaiocb.aio_lio_opcode == LIO_WRITE) { curproc->p_stats->p_ru.ru_oublock += cb->outputcharge; @@ -2230,7 +2247,7 @@ aio_waitcomplete(struct proc *p, struct aio_waitcomplete_args *uap) if ((cb = TAILQ_FIRST(&ki->kaio_bufdone)) != 0 ) { splx(s); suword(uap->aiocbp, (int)cb->uuaiocb); - p->p_retval[0] = cb->uaiocb._aiocb_private.status; + td->td_retval[0] = cb->uaiocb._aiocb_private.status; aio_free_entry(cb); return cb->uaiocb._aiocb_private.error; } diff --git a/sys/kern/vfs_bio.c b/sys/kern/vfs_bio.c index e66a93e..39e09b3 100644 --- a/sys/kern/vfs_bio.c +++ b/sys/kern/vfs_bio.c @@ -594,8 +594,8 @@ breadn(struct vnode * vp, daddr_t blkno, int size, /* if not found in cache, do some I/O */ if ((bp->b_flags & B_CACHE) == 0) { - if (curproc != PCPU_GET(idleproc)) - curproc->p_stats->p_ru.ru_inblock++; + if (curthread != PCPU_GET(idlethread)) + curthread->td_proc->p_stats->p_ru.ru_inblock++; bp->b_iocmd = BIO_READ; bp->b_flags &= ~B_INVAL; bp->b_ioflags &= ~BIO_ERROR; @@ -615,8 +615,8 @@ breadn(struct vnode * vp, daddr_t blkno, int size, rabp = getblk(vp, *rablkno, *rabsize, 0, 0); if ((rabp->b_flags & B_CACHE) == 0) { - if (curproc != PCPU_GET(idleproc)) - curproc->p_stats->p_ru.ru_inblock++; + if (curthread != PCPU_GET(idlethread)) + curthread->td_proc->p_stats->p_ru.ru_inblock++; rabp->b_flags |= B_ASYNC; rabp->b_flags &= ~B_INVAL; rabp->b_ioflags &= ~BIO_ERROR; @@ -753,8 +753,8 @@ bwrite(struct buf * bp) bp->b_runningbufspace = bp->b_bufsize; runningbufspace += bp->b_runningbufspace; - if (curproc != PCPU_GET(idleproc)) - curproc->p_stats->p_ru.ru_oublock++; + if (curthread != PCPU_GET(idlethread)) + curthread->td_proc->p_stats->p_ru.ru_oublock++; splx(s); if (oldflags & B_ASYNC) BUF_KERNPROC(bp); @@ -2183,7 +2183,7 @@ loop: * XXX remove if 0 sections (clean this up after its proven) */ if (numfreebuffers == 0) { - if (curproc == PCPU_GET(idleproc)) + if (curthread == PCPU_GET(idlethread)) return NULL; needsbuffer |= VFS_BIO_NEED_ANY; } diff --git a/sys/kern/vfs_cache.c b/sys/kern/vfs_cache.c index af3035a..9483b9b 100644 --- a/sys/kern/vfs_cache.c +++ b/sys/kern/vfs_cache.c @@ -575,7 +575,7 @@ vfs_cache_lookup(ap) struct componentname *cnp = ap->a_cnp; struct ucred *cred = cnp->cn_cred; int flags = cnp->cn_flags; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; u_long vpid; /* capability number of vnode */ *vpp = NULL; @@ -589,7 +589,7 @@ vfs_cache_lookup(ap) (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) return (EROFS); - error = VOP_ACCESS(dvp, VEXEC, cred, p); + error = VOP_ACCESS(dvp, VEXEC, cred, td); if (error) return (error); @@ -609,17 +609,17 @@ vfs_cache_lookup(ap) VREF(vp); error = 0; } else if (flags & ISDOTDOT) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); cnp->cn_flags |= PDIRUNLOCK; - error = vget(vp, LK_EXCLUSIVE, p); + error = vget(vp, LK_EXCLUSIVE, td); if (!error && lockparent && (flags & ISLASTCN)) { - if ((error = vn_lock(dvp, LK_EXCLUSIVE, p)) == 0) + if ((error = vn_lock(dvp, LK_EXCLUSIVE, td)) == 0) cnp->cn_flags &= ~PDIRUNLOCK; } } else { - error = vget(vp, LK_EXCLUSIVE, p); + error = vget(vp, LK_EXCLUSIVE, td); if (!lockparent || error || !(flags & ISLASTCN)) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } } @@ -632,12 +632,12 @@ vfs_cache_lookup(ap) return (0); vput(vp); if (lockparent && dvp != vp && (flags & ISLASTCN)) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } } if (cnp->cn_flags & PDIRUNLOCK) { - error = vn_lock(dvp, LK_EXCLUSIVE, p); + error = vn_lock(dvp, LK_EXCLUSIVE, td); if (error) return (error); cnp->cn_flags &= ~PDIRUNLOCK; @@ -663,8 +663,8 @@ static u_long numcwdfail3; STATNODE(CTLFLAG_RD, numcwdfail3, &numcwdfail3); static u_long numcwdfail4; STATNODE(CTLFLAG_RD, numcwdfail4, &numcwdfail4); static u_long numcwdfound; STATNODE(CTLFLAG_RD, numcwdfound, &numcwdfound); int -__getcwd(p, uap) - struct proc *p; +__getcwd(td, uap) + struct thread *td; struct __getcwd_args *uap; { char *bp, *buf; @@ -683,7 +683,7 @@ __getcwd(p, uap) buf = bp = malloc(uap->buflen, M_TEMP, M_WAITOK); bp += uap->buflen - 1; *bp = '\0'; - fdp = p->p_fd; + fdp = td->td_proc->p_fd; slash_prefixed = 0; for (vp = fdp->fd_cdir; vp != fdp->fd_rdir && vp != rootvnode;) { if (vp->v_flag & VROOT) { diff --git a/sys/kern/vfs_conf.c b/sys/kern/vfs_conf.c index e651ef0..98c3f13 100644 --- a/sys/kern/vfs_conf.c +++ b/sys/kern/vfs_conf.c @@ -227,7 +227,7 @@ vfs_mountroot_try(char *mountfrom) */ strncpy(mp->mnt_stat.f_mntonname, "/", MNAMELEN); - error = VFS_MOUNT(mp, NULL, NULL, NULL, curproc); + error = VFS_MOUNT(mp, NULL, NULL, NULL, curthread); done: if (vfsname != NULL) @@ -236,7 +236,7 @@ done: free(path, M_MOUNT); if (error != 0) { if (mp != NULL) { - vfs_unbusy(mp, curproc); + vfs_unbusy(mp, curthread); free(mp, M_MOUNT); } printf("Root mount failed: %d\n", error); @@ -249,7 +249,7 @@ done: /* sanity check system clock against root filesystem timestamp */ inittodr(mp->mnt_time); - vfs_unbusy(mp, curproc); + vfs_unbusy(mp, curthread); } return(error); } diff --git a/sys/kern/vfs_default.c b/sys/kern/vfs_default.c index 1a1f55b..c5d1f02 100644 --- a/sys/kern/vfs_default.c +++ b/sys/kern/vfs_default.c @@ -243,16 +243,16 @@ vop_stdlock(ap) struct vop_lock_args /* { struct vnode *a_vp; int a_flags; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; #ifndef DEBUG_LOCKS - return (lockmgr(&vp->v_lock, ap->a_flags, &vp->v_interlock, ap->a_p)); + return (lockmgr(&vp->v_lock, ap->a_flags, &vp->v_interlock, ap->a_td)); #else return (debuglockmgr(&vp->v_lock, ap->a_flags, &vp->v_interlock, - ap->a_p, "vop_stdlock", vp->filename, vp->line)); + ap->a_td, "vop_stdlock", vp->filename, vp->line)); #endif } @@ -261,35 +261,35 @@ vop_stdunlock(ap) struct vop_unlock_args /* { struct vnode *a_vp; int a_flags; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; return (lockmgr(&vp->v_lock, ap->a_flags | LK_RELEASE, &vp->v_interlock, - ap->a_p)); + ap->a_td)); } int vop_stdislocked(ap) struct vop_islocked_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { - return (lockstatus(&ap->a_vp->v_lock, ap->a_p)); + return (lockstatus(&ap->a_vp->v_lock, ap->a_td)); } int vop_stdinactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { - VOP_UNLOCK(ap->a_vp, 0, ap->a_p); + VOP_UNLOCK(ap->a_vp, 0, ap->a_td); return (0); } @@ -302,7 +302,7 @@ vop_nopoll(ap) struct vnode *a_vp; int a_events; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { /* @@ -327,11 +327,11 @@ vop_stdpoll(ap) struct vnode *a_vp; int a_events; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { if (ap->a_events & ~POLLSTANDARD) - return (vn_pollrecord(ap->a_vp, ap->a_p, ap->a_events)); + return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events)); return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)); } @@ -346,7 +346,7 @@ vop_sharedlock(ap) struct vop_lock_args /* { struct vnode *a_vp; int a_flags; - struct proc *a_p; + struct thread *a_td; } */ *ap; { /* @@ -393,9 +393,9 @@ vop_sharedlock(ap) if (flags & LK_INTERLOCK) vnflags |= LK_INTERLOCK; #ifndef DEBUG_LOCKS - return (lockmgr(&vp->v_lock, vnflags, &vp->v_interlock, ap->a_p)); + return (lockmgr(&vp->v_lock, vnflags, &vp->v_interlock, ap->a_td)); #else - return (debuglockmgr(&vp->v_lock, vnflags, &vp->v_interlock, ap->a_p, + return (debuglockmgr(&vp->v_lock, vnflags, &vp->v_interlock, ap->a_td, "vop_sharedlock", vp->filename, vp->line)); #endif } @@ -411,7 +411,7 @@ vop_nolock(ap) struct vop_lock_args /* { struct vnode *a_vp; int a_flags; - struct proc *a_p; + struct thread *a_td; } */ *ap; { #ifdef notyet @@ -450,7 +450,7 @@ vop_nolock(ap) } if (flags & LK_INTERLOCK) vnflags |= LK_INTERLOCK; - return(lockmgr(&vp->v_lock, vnflags, &vp->v_interlock, ap->a_p)); + return(lockmgr(&vp->v_lock, vnflags, &vp->v_interlock, ap->a_td)); #else /* for now */ /* * Since we are not using the lock manager, we must clear @@ -470,7 +470,7 @@ vop_nounlock(ap) struct vop_unlock_args /* { struct vnode *a_vp; int a_flags; - struct proc *a_p; + struct thread *a_td; } */ *ap; { @@ -490,7 +490,7 @@ int vop_noislocked(ap) struct vop_islocked_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { @@ -517,12 +517,12 @@ vop_stdcreatevobject(ap) struct vop_createvobject_args /* { struct vnode *vp; struct ucred *cred; - struct proc *p; + struct thread *td; } */ *ap; { struct vnode *vp = ap->a_vp; struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; struct vattr vat; vm_object_t object; int error = 0; @@ -535,7 +535,7 @@ vop_stdcreatevobject(ap) retry: if ((object = vp->v_object) == NULL) { if (vp->v_type == VREG || vp->v_type == VDIR) { - if ((error = VOP_GETATTR(vp, &vat, cred, p)) != 0) + if ((error = VOP_GETATTR(vp, &vat, cred, td)) != 0) goto retn; object = vnode_pager_alloc(vp, vat.va_size, 0, 0); } else if (devsw(vp->v_rdev) != NULL) { @@ -556,9 +556,9 @@ retry: vp->v_usecount--; } else { if (object->flags & OBJ_DEAD) { - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); tsleep(object, PVM, "vodead", 0); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); goto retry; } } @@ -677,21 +677,21 @@ vop_stdputpages(ap) * used to fill the vfs fucntion table to get reasonable default return values. */ int -vfs_stdmount (mp, path, data, ndp, p) +vfs_stdmount (mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { return (0); } int -vfs_stdunmount (mp, mntflags, p) +vfs_stdunmount (mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { return (0); } @@ -705,10 +705,10 @@ vfs_stdroot (mp, vpp) } int -vfs_stdstatfs (mp, sbp, p) +vfs_stdstatfs (mp, sbp, td) struct mount *mp; struct statfs *sbp; - struct proc *p; + struct thread *td; { return (EOPNOTSUPP); } @@ -722,31 +722,31 @@ vfs_stdvptofh (vp, fhp) } int -vfs_stdstart (mp, flags, p) +vfs_stdstart (mp, flags, td) struct mount *mp; int flags; - struct proc *p; + struct thread *td; { return (0); } int -vfs_stdquotactl (mp, cmds, uid, arg, p) +vfs_stdquotactl (mp, cmds, uid, arg, td) struct mount *mp; int cmds; uid_t uid; caddr_t arg; - struct proc *p; + struct thread *td; { return (EOPNOTSUPP); } int -vfs_stdsync (mp, waitfor, cred, p) +vfs_stdsync (mp, waitfor, cred, td) struct mount *mp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { return (0); } @@ -784,13 +784,13 @@ vfs_stduninit (vfsp) } int -vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname, p) +vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname, td) struct mount *mp; int cmd; struct vnode *filename_vp; int attrnamespace; const char *attrname; - struct proc *p; + struct thread *td; { return(EOPNOTSUPP); } diff --git a/sys/kern/vfs_extattr.c b/sys/kern/vfs_extattr.c index bb39292..4e05b8d 100644 --- a/sys/kern/vfs_extattr.c +++ b/sys/kern/vfs_extattr.c @@ -75,18 +75,18 @@ #include <vm/vm_zone.h> #include <vm/vm_page.h> -static int change_dir __P((struct nameidata *ndp, struct proc *p)); +static int change_dir __P((struct nameidata *ndp, struct thread *td)); static void checkdirs __P((struct vnode *olddp, struct vnode *newdp)); static int chroot_refuse_vdir_fds __P((struct filedesc *fdp)); static int getutimes __P((const struct timeval *, struct timespec *)); -static int setfown __P((struct proc *, struct vnode *, uid_t, gid_t)); -static int setfmode __P((struct proc *, struct vnode *, int)); -static int setfflags __P((struct proc *, struct vnode *, int)); -static int setutimes __P((struct proc *, struct vnode *, +static int setfown __P((struct thread *td, struct vnode *, uid_t, gid_t)); +static int setfmode __P((struct thread *td, struct vnode *, int)); +static int setfflags __P((struct thread *td, struct vnode *, int)); +static int setutimes __P((struct thread *td, struct vnode *, const struct timespec *, int)); static int usermount = 0; /* if 1, non-root can mount fs. */ -int (*union_dircheckp) __P((struct proc *, struct vnode **, struct file *)); +int (*union_dircheckp) __P((struct thread *td, struct vnode **, struct file *)); SYSCTL_INT(_vfs, OID_AUTO, usermount, CTLFLAG_RW, &usermount, 0, ""); @@ -107,8 +107,8 @@ struct mount_args { #endif /* ARGSUSED */ int -mount(p, uap) - struct proc *p; +mount(td, uap) + struct thread *td; struct mount_args /* { syscallarg(char *) type; syscallarg(char *) path; @@ -133,7 +133,7 @@ mount(p, uap) error = copyinstr(SCARG(uap, path), fspath, MNAMELEN, NULL); if (error) goto finish; - error = vfs_mount(p, fstype, fspath, SCARG(uap, flags), + error = vfs_mount(td, fstype, fspath, SCARG(uap, flags), SCARG(uap, data)); finish: free(fstype, M_TEMP); @@ -150,8 +150,8 @@ finish: * into userspace. */ int -vfs_mount(p, fstype, fspath, fsflags, fsdata) - struct proc *p; +vfs_mount(td, fstype, fspath, fsflags, fsdata) + struct thread *td; const char *fstype; char *fspath; int fsflags; @@ -163,6 +163,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) int error, flag = 0, flag2 = 0; struct vattr va; struct nameidata nd; + struct proc *p = td->td_proc; /* * Be ultra-paranoid about making sure the type and fspath @@ -173,13 +174,13 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) (strlen(fspath) >= MNAMELEN - 1)) return (ENAMETOOLONG); - if (usermount == 0 && (error = suser(p))) + if (usermount == 0 && (error = suser_td(td))) return (error); /* * Do not allow NFS export by non-root users. */ if (fsflags & MNT_EXPORTED) { - error = suser(p); + error = suser_td(td); if (error) return (error); } @@ -191,7 +192,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) /* * Get vnode to be covered */ - NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspath, p); + NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspath, td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); @@ -218,11 +219,11 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) * permitted to update it. */ if (mp->mnt_stat.f_owner != p->p_ucred->cr_uid && - (error = suser(p))) { + (error = suser_td(td))) { vput(vp); return (error); } - if (vfs_busy(mp, LK_NOWAIT, 0, p)) { + if (vfs_busy(mp, LK_NOWAIT, 0, td)) { vput(vp); return (EBUSY); } @@ -230,7 +231,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) if ((vp->v_flag & VMOUNT) != 0 || vp->v_mountedhere != NULL) { mtx_unlock(&vp->v_interlock); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); vput(vp); return (EBUSY); } @@ -238,20 +239,20 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) mtx_unlock(&vp->v_interlock); mp->mnt_flag |= fsflags & (MNT_RELOAD | MNT_FORCE | MNT_UPDATE | MNT_SNAPSHOT); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); goto update; } /* * If the user is not root, ensure that they own the directory * onto which we are attempting to mount. */ - if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) || + if ((error = VOP_GETATTR(vp, &va, p->p_ucred, td)) || (va.va_uid != p->p_ucred->cr_uid && - (error = suser(p)))) { + (error = suser_td(td)))) { vput(vp); return (error); } - if ((error = vinvalbuf(vp, V_SAVE, p->p_ucred, p, 0, 0)) != 0) { + if ((error = vinvalbuf(vp, V_SAVE, p->p_ucred, td, 0, 0)) != 0) { vput(vp); return (error); } @@ -266,7 +267,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) linker_file_t lf; /* Only load modules for root (very important!) */ - if ((error = suser(p)) != 0) { + if ((error = suser_td(td)) != 0) { vput(vp); return error; } @@ -304,7 +305,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) */ mp = malloc(sizeof(struct mount), M_MOUNT, M_WAITOK | M_ZERO); lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, LK_NOPAUSE); - (void)vfs_busy(mp, LK_NOWAIT, 0, p); + (void)vfs_busy(mp, LK_NOWAIT, 0, td); mp->mnt_op = vfsp->vfc_vfsops; mp->mnt_vfc = vfsp; vfsp->vfc_refcount++; @@ -317,7 +318,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) strncpy(mp->mnt_stat.f_mntonname, fspath, MNAMELEN); mp->mnt_stat.f_mntonname[MNAMELEN - 1] = '\0'; mp->mnt_iosize_max = DFLTPHYS; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); update: /* * Set the mount level flags. @@ -339,7 +340,7 @@ update: * XXX The final recipients of VFS_MOUNT just overwrite the ndp they * get. No freeing of cn_pnbuf. */ - error = VFS_MOUNT(mp, fspath, fsdata, &nd, p); + error = VFS_MOUNT(mp, fspath, fsdata, &nd, td); if (mp->mnt_flag & MNT_UPDATE) { if (mp->mnt_kern_flag & MNTK_WANTRDWR) mp->mnt_flag &= ~MNT_RDONLY; @@ -358,14 +359,14 @@ update: vrele(mp->mnt_syncer); mp->mnt_syncer = NULL; } - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); mtx_lock(&vp->v_interlock); vp->v_flag &= ~VMOUNT; mtx_unlock(&vp->v_interlock); vrele(vp); return (error); } - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); /* * Put the new filesystem on the mount list after root. */ @@ -384,18 +385,18 @@ update: panic("mount: lost mount"); checkdirs(vp, newdp); vput(newdp); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if ((mp->mnt_flag & MNT_RDONLY) == 0) error = vfs_allocate_syncvnode(mp); - vfs_unbusy(mp, p); - if ((error = VFS_START(mp, 0, p)) != 0) + vfs_unbusy(mp, td); + if ((error = VFS_START(mp, 0, td)) != 0) vrele(vp); } else { mtx_lock(&vp->v_interlock); vp->v_flag &= ~VMOUNT; mtx_unlock(&vp->v_interlock); mp->mnt_vfc->vfc_refcount--; - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); free((caddr_t)mp, M_MOUNT); vput(vp); } @@ -454,8 +455,8 @@ struct unmount_args { #endif /* ARGSUSED */ int -unmount(p, uap) - struct proc *p; +unmount(td, uap) + struct thread *td; register struct unmount_args /* { syscallarg(char *) path; syscallarg(int) flags; @@ -467,7 +468,7 @@ unmount(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -478,8 +479,8 @@ unmount(p, uap) * Only root, or the user that did the original mount is * permitted to unmount this filesystem. */ - if ((mp->mnt_stat.f_owner != p->p_ucred->cr_uid) && - (error = suser(p))) { + if ((mp->mnt_stat.f_owner != td->td_proc->p_ucred->cr_uid) && + (error = suser_td(td))) { vput(vp); return (error); } @@ -500,17 +501,17 @@ unmount(p, uap) return (EINVAL); } vput(vp); - return (dounmount(mp, SCARG(uap, flags), p)); + return (dounmount(mp, SCARG(uap, flags), td)); } /* * Do the actual file system unmount. */ int -dounmount(mp, flags, p) +dounmount(mp, flags, td) struct mount *mp; int flags; - struct proc *p; + struct thread *td; { struct vnode *coveredvp, *fsrootvp; int error; @@ -518,7 +519,7 @@ dounmount(mp, flags, p) mtx_lock(&mountlist_mtx); mp->mnt_kern_flag |= MNTK_UNMOUNT; - lockmgr(&mp->mnt_lock, LK_DRAIN | LK_INTERLOCK, &mountlist_mtx, p); + lockmgr(&mp->mnt_lock, LK_DRAIN | LK_INTERLOCK, &mountlist_mtx, td); vn_start_write(NULL, &mp, V_WAIT); if (mp->mnt_flag & MNT_EXPUBLIC) @@ -541,9 +542,9 @@ dounmount(mp, flags, p) vput(fsrootvp); } if (((mp->mnt_flag & MNT_RDONLY) || - (error = VFS_SYNC(mp, MNT_WAIT, p->p_ucred, p)) == 0) || + (error = VFS_SYNC(mp, MNT_WAIT, td->td_proc->p_ucred, td)) == 0) || (flags & MNT_FORCE)) { - error = VFS_UNMOUNT(mp, flags, p); + error = VFS_UNMOUNT(mp, flags, td); } vn_finished_write(mp); if (error) { @@ -563,7 +564,7 @@ dounmount(mp, flags, p) mp->mnt_kern_flag &= ~MNTK_UNMOUNT; mp->mnt_flag |= async_flag; lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK, - &mountlist_mtx, p); + &mountlist_mtx, td); if (mp->mnt_kern_flag & MNTK_MWAIT) wakeup((caddr_t)mp); return (error); @@ -575,7 +576,7 @@ dounmount(mp, flags, p) mp->mnt_vfc->vfc_refcount--; if (!LIST_EMPTY(&mp->mnt_vnodelist)) panic("unmount: dangling vnode"); - lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK, &mountlist_mtx, p); + lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK, &mountlist_mtx, td); lockdestroy(&mp->mnt_lock); if (coveredvp != NULL) vrele(coveredvp); @@ -601,8 +602,8 @@ SYSCTL_INT(_debug, OID_AUTO, syncprt, CTLFLAG_RW, &syncprt, 0, ""); /* ARGSUSED */ int -sync(p, uap) - struct proc *p; +sync(td, uap) + struct thread *td; struct sync_args *uap; { struct mount *mp, *nmp; @@ -610,7 +611,7 @@ sync(p, uap) mtx_lock(&mountlist_mtx); for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) { - if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, p)) { + if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) { nmp = TAILQ_NEXT(mp, mnt_list); continue; } @@ -620,13 +621,13 @@ sync(p, uap) mp->mnt_flag &= ~MNT_ASYNC; vfs_msync(mp, MNT_NOWAIT); VFS_SYNC(mp, MNT_NOWAIT, - ((p != NULL) ? p->p_ucred : NOCRED), p); + ((td != NULL) ? td->td_proc->p_ucred : NOCRED), td); mp->mnt_flag |= asyncflag; vn_finished_write(mp); } mtx_lock(&mountlist_mtx); nmp = TAILQ_NEXT(mp, mnt_list); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); } mtx_unlock(&mountlist_mtx); #if 0 @@ -661,8 +662,8 @@ struct quotactl_args { #endif /* ARGSUSED */ int -quotactl(p, uap) - struct proc *p; +quotactl(td, uap) + struct thread *td; register struct quotactl_args /* { syscallarg(char *) path; syscallarg(int) cmd; @@ -674,9 +675,9 @@ quotactl(p, uap) int error; struct nameidata nd; - if (jailed(p->p_ucred) && !prison_quotas) + if (jailed(td->td_proc->p_ucred) && !prison_quotas) return (EPERM); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); @@ -685,7 +686,7 @@ quotactl(p, uap) if (error) return (error); error = VFS_QUOTACTL(mp, SCARG(uap, cmd), SCARG(uap, uid), - SCARG(uap, arg), p); + SCARG(uap, arg), td); vn_finished_write(mp); return (error); } @@ -701,8 +702,8 @@ struct statfs_args { #endif /* ARGSUSED */ int -statfs(p, uap) - struct proc *p; +statfs(td, uap) + struct thread *td; register struct statfs_args /* { syscallarg(char *) path; syscallarg(struct statfs *) buf; @@ -714,18 +715,18 @@ statfs(p, uap) struct nameidata nd; struct statfs sb; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); mp = nd.ni_vp->v_mount; sp = &mp->mnt_stat; NDFREE(&nd, NDF_ONLY_PNBUF); vrele(nd.ni_vp); - error = VFS_STATFS(mp, sp, p); + error = VFS_STATFS(mp, sp, td); if (error) return (error); sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; - if (suser_xxx(p->p_ucred, 0, 0)) { + if (suser_xxx(td->td_proc->p_ucred, 0, 0)) { bcopy((caddr_t)sp, (caddr_t)&sb, sizeof(sb)); sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0; sp = &sb; @@ -744,8 +745,8 @@ struct fstatfs_args { #endif /* ARGSUSED */ int -fstatfs(p, uap) - struct proc *p; +fstatfs(td, uap) + struct thread *td; register struct fstatfs_args /* { syscallarg(int) fd; syscallarg(struct statfs *) buf; @@ -757,15 +758,15 @@ fstatfs(p, uap) int error; struct statfs sb; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); mp = ((struct vnode *)fp->f_data)->v_mount; sp = &mp->mnt_stat; - error = VFS_STATFS(mp, sp, p); + error = VFS_STATFS(mp, sp, td); if (error) return (error); sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; - if (suser_xxx(p->p_ucred, 0, 0)) { + if (suser_xxx(td->td_proc->p_ucred, 0, 0)) { bcopy((caddr_t)sp, (caddr_t)&sb, sizeof(sb)); sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0; sp = &sb; @@ -784,8 +785,8 @@ struct getfsstat_args { }; #endif int -getfsstat(p, uap) - struct proc *p; +getfsstat(td, uap) + struct thread *td; register struct getfsstat_args /* { syscallarg(struct statfs *) buf; syscallarg(long) bufsize; @@ -802,7 +803,7 @@ getfsstat(p, uap) count = 0; mtx_lock(&mountlist_mtx); for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) { - if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, p)) { + if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) { nmp = TAILQ_NEXT(mp, mnt_list); continue; } @@ -815,16 +816,16 @@ getfsstat(p, uap) */ if (((SCARG(uap, flags) & (MNT_LAZY|MNT_NOWAIT)) == 0 || (SCARG(uap, flags) & MNT_WAIT)) && - (error = VFS_STATFS(mp, sp, p))) { + (error = VFS_STATFS(mp, sp, td))) { mtx_lock(&mountlist_mtx); nmp = TAILQ_NEXT(mp, mnt_list); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); continue; } sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; error = copyout((caddr_t)sp, sfsp, sizeof(*sp)); if (error) { - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); return (error); } sfsp += sizeof(*sp); @@ -832,13 +833,13 @@ getfsstat(p, uap) count++; mtx_lock(&mountlist_mtx); nmp = TAILQ_NEXT(mp, mnt_list); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); } mtx_unlock(&mountlist_mtx); if (sfsp && count > maxcount) - p->p_retval[0] = maxcount; + td->td_retval[0] = maxcount; else - p->p_retval[0] = count; + td->td_retval[0] = count; return (0); } @@ -852,13 +853,13 @@ struct fchdir_args { #endif /* ARGSUSED */ int -fchdir(p, uap) - struct proc *p; +fchdir(td, uap) + struct thread *td; struct fchdir_args /* { syscallarg(int) fd; } */ *uap; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; struct vnode *vp, *tdp; struct mount *mp; struct file *fp; @@ -868,16 +869,16 @@ fchdir(p, uap) return (error); vp = (struct vnode *)fp->f_data; VREF(vp); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (vp->v_type != VDIR) error = ENOTDIR; else - error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); + error = VOP_ACCESS(vp, VEXEC, td->td_proc->p_ucred, td); while (!error && (mp = vp->v_mountedhere) != NULL) { - if (vfs_busy(mp, 0, 0, p)) + if (vfs_busy(mp, 0, 0, td)) continue; error = VFS_ROOT(mp, &tdp); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); if (error) break; vput(vp); @@ -887,7 +888,7 @@ fchdir(p, uap) vput(vp); return (error); } - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vrele(fdp->fd_cdir); fdp->fd_cdir = vp; return (0); @@ -903,19 +904,19 @@ struct chdir_args { #endif /* ARGSUSED */ int -chdir(p, uap) - struct proc *p; +chdir(td, uap) + struct thread *td; struct chdir_args /* { syscallarg(char *) path; } */ *uap; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; int error; struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, path), p); - if ((error = change_dir(&nd, p)) != 0) + SCARG(uap, path), td); + if ((error = change_dir(&nd, td)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); vrele(fdp->fd_cdir); @@ -971,17 +972,17 @@ struct chroot_args { #endif /* ARGSUSED */ int -chroot(p, uap) - struct proc *p; +chroot(td, uap) + struct thread *td; struct chroot_args /* { syscallarg(char *) path; } */ *uap; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; int error; struct nameidata nd; - error = suser_xxx(0, p, PRISON_ROOT); + error = suser_xxx(0, td->td_proc, PRISON_ROOT); if (error) return (error); if (chroot_allow_open_directories == 0 || @@ -990,8 +991,8 @@ chroot(p, uap) if (error) return (error); NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, path), p); - if ((error = change_dir(&nd, p)) != 0) + SCARG(uap, path), td); + if ((error = change_dir(&nd, td)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); vrele(fdp->fd_rdir); @@ -1007,9 +1008,9 @@ chroot(p, uap) * Common routine for chroot and chdir. */ static int -change_dir(ndp, p) +change_dir(ndp, td) register struct nameidata *ndp; - struct proc *p; + struct thread *td; { struct vnode *vp; int error; @@ -1021,11 +1022,11 @@ change_dir(ndp, p) if (vp->v_type != VDIR) error = ENOTDIR; else - error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); + error = VOP_ACCESS(vp, VEXEC, td->td_proc->p_ucred, td); if (error) vput(vp); else - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); return (error); } @@ -1041,14 +1042,15 @@ struct open_args { }; #endif int -open(p, uap) - struct proc *p; +open(td, uap) + struct thread *td; register struct open_args /* { syscallarg(char *) path; syscallarg(int) flags; syscallarg(int) mode; } */ *uap; { + struct proc *p = td->td_proc; struct filedesc *fdp = p->p_fd; struct file *fp; struct vnode *vp; @@ -1064,13 +1066,13 @@ open(p, uap) if ((oflags & O_ACCMODE) == O_ACCMODE) return (EINVAL); flags = FFLAGS(oflags); - error = falloc(p, &nfp, &indx); + error = falloc(td, &nfp, &indx); if (error) return (error); fp = nfp; cmode = ((SCARG(uap, mode) &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); - p->p_dupfd = -indx - 1; /* XXX check for fdopen */ + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); + td->td_dupfd = -indx - 1; /* XXX check for fdopen */ /* * Bump the ref count to prevent another process from closing * the descriptor while we are blocked in vn_open() @@ -1081,7 +1083,7 @@ open(p, uap) /* * release our own reference */ - fdrop(fp, p); + fdrop(fp, td); /* * handle special fdopen() case. bleh. dupfdopen() is @@ -1089,10 +1091,10 @@ open(p, uap) * if it succeeds. */ if ((error == ENODEV || error == ENXIO) && - p->p_dupfd >= 0 && /* XXX from fdopen */ + td->td_dupfd >= 0 && /* XXX from fdopen */ (error = - dupfdopen(p, fdp, indx, p->p_dupfd, flags, error)) == 0) { - p->p_retval[0] = indx; + dupfdopen(td, fdp, indx, td->td_dupfd, flags, error)) == 0) { + td->td_retval[0] = indx; return (0); } /* @@ -1101,14 +1103,14 @@ open(p, uap) */ if (fdp->fd_ofiles[indx] == fp) { fdp->fd_ofiles[indx] = NULL; - fdrop(fp, p); + fdrop(fp, td); } if (error == ERESTART) error = EINTR; return (error); } - p->p_dupfd = 0; + td->td_dupfd = 0; NDFREE(&nd, NDF_ONLY_PNBUF); vp = nd.ni_vp; @@ -1123,10 +1125,10 @@ open(p, uap) if (fp->f_count == 1) { KASSERT(fdp->fd_ofiles[indx] != fp, ("Open file descriptor lost all refs")); - VOP_UNLOCK(vp, 0, p); - vn_close(vp, flags & FMASK, fp->f_cred, p); - fdrop(fp, p); - p->p_retval[0] = indx; + VOP_UNLOCK(vp, 0, td); + vn_close(vp, flags & FMASK, fp->f_cred, td); + fdrop(fp, td); + td->td_retval[0] = indx; return 0; } @@ -1134,7 +1136,7 @@ open(p, uap) fp->f_flag = flags & FMASK; fp->f_ops = &vnops; fp->f_type = (vp->v_type == VFIFO ? DTYPE_FIFO : DTYPE_VNODE); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (flags & (O_EXLOCK | O_SHLOCK)) { lf.l_whence = SEEK_SET; lf.l_start = 0; @@ -1153,12 +1155,12 @@ open(p, uap) if (flags & O_TRUNC) { if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) goto bad; - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(vp, td, p->p_ucred, LEASE_WRITE); VATTR_NULL(&vat); vat.va_size = 0; - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_SETATTR(vp, &vat, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_SETATTR(vp, &vat, p->p_ucred, td); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); if (error) goto bad; @@ -1170,15 +1172,15 @@ open(p, uap) * Release our private reference, leaving the one associated with * the descriptor table intact. */ - fdrop(fp, p); - p->p_retval[0] = indx; + fdrop(fp, td); + td->td_retval[0] = indx; return (0); bad: if (fdp->fd_ofiles[indx] == fp) { fdp->fd_ofiles[indx] = NULL; - fdrop(fp, p); + fdrop(fp, td); } - fdrop(fp, p); + fdrop(fp, td); return (error); } @@ -1193,8 +1195,8 @@ struct ocreat_args { }; #endif int -ocreat(p, uap) - struct proc *p; +ocreat(td, uap) + struct thread *td; register struct ocreat_args /* { syscallarg(char *) path; syscallarg(int) mode; @@ -1209,7 +1211,7 @@ ocreat(p, uap) SCARG(&nuap, path) = SCARG(uap, path); SCARG(&nuap, mode) = SCARG(uap, mode); SCARG(&nuap, flags) = O_WRONLY | O_CREAT | O_TRUNC; - return (open(p, &nuap)); + return (open(td, &nuap)); } #endif /* COMPAT_43 */ @@ -1225,8 +1227,8 @@ struct mknod_args { #endif /* ARGSUSED */ int -mknod(p, uap) - struct proc *p; +mknod(td, uap) + struct thread *td; register struct mknod_args /* { syscallarg(char *) path; syscallarg(int) mode; @@ -1243,17 +1245,17 @@ mknod(p, uap) switch (SCARG(uap, mode) & S_IFMT) { case S_IFCHR: case S_IFBLK: - error = suser(p); + error = suser_td(td); break; default: - error = suser_xxx(0, p, PRISON_ROOT); + error = suser_xxx(0, td->td_proc, PRISON_ROOT); break; } if (error) return (error); restart: bwillwrite(); - NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -1262,7 +1264,7 @@ restart: error = EEXIST; } else { VATTR_NULL(&vattr); - vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ p->p_fd->fd_cmask; + vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ td->td_proc->p_fd->fd_cmask; vattr.va_rdev = SCARG(uap, dev); whiteout = 0; @@ -1292,7 +1294,7 @@ restart: goto restart; } if (!error) { - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); if (whiteout) error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, CREATE); else { @@ -1321,8 +1323,8 @@ struct mkfifo_args { #endif /* ARGSUSED */ int -mkfifo(p, uap) - struct proc *p; +mkfifo(td, uap) + struct thread *td; register struct mkfifo_args /* { syscallarg(char *) path; syscallarg(int) mode; @@ -1335,7 +1337,7 @@ mkfifo(p, uap) restart: bwillwrite(); - NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); if (nd.ni_vp != NULL) { @@ -1353,8 +1355,8 @@ restart: } VATTR_NULL(&vattr); vattr.va_type = VFIFO; - vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ p->p_fd->fd_cmask; - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ td->td_proc->p_fd->fd_cmask; + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); if (error == 0) vput(nd.ni_vp); @@ -1375,8 +1377,8 @@ struct link_args { #endif /* ARGSUSED */ int -link(p, uap) - struct proc *p; +link(td, uap) + struct thread *td; register struct link_args /* { syscallarg(char *) path; syscallarg(char *) link; @@ -1388,7 +1390,7 @@ link(p, uap) int error; bwillwrite(); - NDINIT(&nd, LOOKUP, FOLLOW|NOOBJ, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW|NOOBJ, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); @@ -1401,14 +1403,14 @@ link(p, uap) vrele(vp); return (error); } - NDINIT(&nd, CREATE, LOCKPARENT|NOOBJ, UIO_USERSPACE, SCARG(uap, link), p); + NDINIT(&nd, CREATE, LOCKPARENT|NOOBJ, UIO_USERSPACE, SCARG(uap, link), td); if ((error = namei(&nd)) == 0) { if (nd.ni_vp != NULL) { vrele(nd.ni_vp); error = EEXIST; } else { - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd); } NDFREE(&nd, NDF_ONLY_PNBUF); @@ -1432,8 +1434,8 @@ struct symlink_args { #endif /* ARGSUSED */ int -symlink(p, uap) - struct proc *p; +symlink(td, uap) + struct thread *td; register struct symlink_args /* { syscallarg(char *) path; syscallarg(char *) link; @@ -1450,7 +1452,7 @@ symlink(p, uap) goto out; restart: bwillwrite(); - NDINIT(&nd, CREATE, LOCKPARENT|NOOBJ, UIO_USERSPACE, SCARG(uap, link), p); + NDINIT(&nd, CREATE, LOCKPARENT|NOOBJ, UIO_USERSPACE, SCARG(uap, link), td); if ((error = namei(&nd)) != 0) goto out; if (nd.ni_vp) { @@ -1468,8 +1470,8 @@ restart: goto restart; } VATTR_NULL(&vattr); - vattr.va_mode = ACCESSPERMS &~ p->p_fd->fd_cmask; - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + vattr.va_mode = ACCESSPERMS &~ td->td_proc->p_fd->fd_cmask; + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, path); NDFREE(&nd, NDF_ONLY_PNBUF); if (error == 0) @@ -1488,8 +1490,8 @@ out: */ /* ARGSUSED */ int -undelete(p, uap) - struct proc *p; +undelete(td, uap) + struct thread *td; register struct undelete_args /* { syscallarg(char *) path; } */ *uap; @@ -1501,7 +1503,7 @@ undelete(p, uap) restart: bwillwrite(); NDINIT(&nd, DELETE, LOCKPARENT|DOWHITEOUT, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); error = namei(&nd); if (error) return (error); @@ -1520,7 +1522,7 @@ restart: return (error); goto restart; } - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, DELETE); NDFREE(&nd, NDF_ONLY_PNBUF); vput(nd.ni_dvp); @@ -1540,8 +1542,8 @@ struct unlink_args { #endif /* ARGSUSED */ int -unlink(p, uap) - struct proc *p; +unlink(td, uap) + struct thread *td; struct unlink_args /* { syscallarg(char *) path; } */ *uap; @@ -1553,7 +1555,7 @@ unlink(p, uap) restart: bwillwrite(); - NDINIT(&nd, DELETE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, DELETE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -1576,10 +1578,10 @@ restart: return (error); goto restart; } - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (!error) { - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_REMOVE(nd.ni_dvp, vp, &nd.ni_cnd); } NDFREE(&nd, NDF_ONLY_PNBUF); @@ -1603,8 +1605,8 @@ struct lseek_args { }; #endif int -lseek(p, uap) - struct proc *p; +lseek(td, uap) + struct thread *td; register struct lseek_args /* { syscallarg(int) fd; syscallarg(int) pad; @@ -1612,8 +1614,8 @@ lseek(p, uap) syscallarg(int) whence; } */ *uap; { - struct ucred *cred = p->p_ucred; - register struct filedesc *fdp = p->p_fd; + struct ucred *cred = td->td_proc->p_ucred; + register struct filedesc *fdp = td->td_proc->p_fd; register struct file *fp; struct vattr vattr; struct vnode *vp; @@ -1637,7 +1639,7 @@ lseek(p, uap) offset += fp->f_offset; break; case L_XTND: - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); if (noneg && @@ -1654,7 +1656,7 @@ lseek(p, uap) if (noneg && offset < 0) return (EINVAL); fp->f_offset = offset; - *(off_t *)(p->p_retval) = fp->f_offset; + *(off_t *)(td->td_retval) = fp->f_offset; return (0); } @@ -1670,8 +1672,8 @@ struct olseek_args { }; #endif int -olseek(p, uap) - struct proc *p; +olseek(td, uap) + struct thread *td; register struct olseek_args /* { syscallarg(int) fd; syscallarg(long) offset; @@ -1689,7 +1691,7 @@ olseek(p, uap) SCARG(&nuap, fd) = SCARG(uap, fd); SCARG(&nuap, offset) = SCARG(uap, offset); SCARG(&nuap, whence) = SCARG(uap, whence); - error = lseek(p, &nuap); + error = lseek(td, &nuap); return (error); } #endif /* COMPAT_43 */ @@ -1704,8 +1706,8 @@ struct access_args { }; #endif int -access(p, uap) - struct proc *p; +access(td, uap) + struct thread *td; register struct access_args /* { syscallarg(char *) path; syscallarg(int) flags; @@ -1716,7 +1718,7 @@ access(p, uap) int error, flags; struct nameidata nd; - cred = p->p_ucred; + cred = td->td_proc->p_ucred; /* * Create and modify a temporary credential instead of one that * is potentially shared. This could also mess up socket @@ -1729,9 +1731,9 @@ access(p, uap) tmpcred = crdup(cred); tmpcred->cr_uid = cred->cr_ruid; tmpcred->cr_groups[0] = cred->cr_rgid; - p->p_ucred = tmpcred; + td->td_proc->p_ucred = tmpcred; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) goto out1; vp = nd.ni_vp; @@ -1746,12 +1748,12 @@ access(p, uap) if (SCARG(uap, flags) & X_OK) flags |= VEXEC; if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0) - error = VOP_ACCESS(vp, flags, tmpcred, p); + error = VOP_ACCESS(vp, flags, tmpcred, td); } NDFREE(&nd, NDF_ONLY_PNBUF); vput(vp); out1: - p->p_ucred = cred; + td->td_proc->p_ucred = cred; crfree(tmpcred); return (error); } @@ -1768,8 +1770,8 @@ struct ostat_args { #endif /* ARGSUSED */ int -ostat(p, uap) - struct proc *p; +ostat(td, uap) + struct thread *td; register struct ostat_args /* { syscallarg(char *) path; syscallarg(struct ostat *) ub; @@ -1781,11 +1783,11 @@ ostat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = vn_stat(nd.ni_vp, &sb, p); + error = vn_stat(nd.ni_vp, &sb, td); vput(nd.ni_vp); if (error) return (error); @@ -1805,8 +1807,8 @@ struct olstat_args { #endif /* ARGSUSED */ int -olstat(p, uap) - struct proc *p; +olstat(td, uap) + struct thread *td; register struct olstat_args /* { syscallarg(char *) path; syscallarg(struct ostat *) ub; @@ -1819,11 +1821,11 @@ olstat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; - error = vn_stat(vp, &sb, p); + error = vn_stat(vp, &sb, td); NDFREE(&nd, NDF_ONLY_PNBUF); vput(vp); if (error) @@ -1874,8 +1876,8 @@ struct stat_args { #endif /* ARGSUSED */ int -stat(p, uap) - struct proc *p; +stat(td, uap) + struct thread *td; register struct stat_args /* { syscallarg(char *) path; syscallarg(struct stat *) ub; @@ -1886,10 +1888,10 @@ stat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); - error = vn_stat(nd.ni_vp, &sb, p); + error = vn_stat(nd.ni_vp, &sb, td); NDFREE(&nd, NDF_ONLY_PNBUF); vput(nd.ni_vp); if (error) @@ -1909,8 +1911,8 @@ struct lstat_args { #endif /* ARGSUSED */ int -lstat(p, uap) - struct proc *p; +lstat(td, uap) + struct thread *td; register struct lstat_args /* { syscallarg(char *) path; syscallarg(struct stat *) ub; @@ -1922,11 +1924,11 @@ lstat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; - error = vn_stat(vp, &sb, p); + error = vn_stat(vp, &sb, td); NDFREE(&nd, NDF_ONLY_PNBUF); vput(vp); if (error) @@ -1974,8 +1976,8 @@ struct nstat_args { #endif /* ARGSUSED */ int -nstat(p, uap) - struct proc *p; +nstat(td, uap) + struct thread *td; register struct nstat_args /* { syscallarg(char *) path; syscallarg(struct nstat *) ub; @@ -1987,11 +1989,11 @@ nstat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = vn_stat(nd.ni_vp, &sb, p); + error = vn_stat(nd.ni_vp, &sb, td); vput(nd.ni_vp); if (error) return (error); @@ -2011,8 +2013,8 @@ struct lstat_args { #endif /* ARGSUSED */ int -nlstat(p, uap) - struct proc *p; +nlstat(td, uap) + struct thread *td; register struct nlstat_args /* { syscallarg(char *) path; syscallarg(struct nstat *) ub; @@ -2025,12 +2027,12 @@ nlstat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; NDFREE(&nd, NDF_ONLY_PNBUF); - error = vn_stat(vp, &sb, p); + error = vn_stat(vp, &sb, td); vput(vp); if (error) return (error); @@ -2050,8 +2052,8 @@ struct pathconf_args { #endif /* ARGSUSED */ int -pathconf(p, uap) - struct proc *p; +pathconf(td, uap) + struct thread *td; register struct pathconf_args /* { syscallarg(char *) path; syscallarg(int) name; @@ -2061,11 +2063,11 @@ pathconf(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = VOP_PATHCONF(nd.ni_vp, SCARG(uap, name), p->p_retval); + error = VOP_PATHCONF(nd.ni_vp, SCARG(uap, name), td->td_retval); vput(nd.ni_vp); return (error); } @@ -2082,8 +2084,8 @@ struct readlink_args { #endif /* ARGSUSED */ int -readlink(p, uap) - struct proc *p; +readlink(td, uap) + struct thread *td; register struct readlink_args /* { syscallarg(char *) path; syscallarg(char *) buf; @@ -2097,7 +2099,7 @@ readlink(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); @@ -2112,12 +2114,12 @@ readlink(p, uap) auio.uio_offset = 0; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_resid = SCARG(uap, count); - error = VOP_READLINK(vp, &auio, p->p_ucred); + error = VOP_READLINK(vp, &auio, td->td_proc->p_ucred); } vput(vp); - p->p_retval[0] = SCARG(uap, count) - auio.uio_resid; + td->td_retval[0] = SCARG(uap, count) - auio.uio_resid; return (error); } @@ -2125,8 +2127,8 @@ readlink(p, uap) * Common implementation code for chflags() and fchflags(). */ static int -setfflags(p, vp, flags) - struct proc *p; +setfflags(td, vp, flags) + struct thread *td; struct vnode *vp; int flags; { @@ -2141,17 +2143,17 @@ setfflags(p, vp, flags) * chown can't fail when done as root. */ if ((vp->v_type == VCHR || vp->v_type == VBLK) && - ((error = suser_xxx(p->p_ucred, p, PRISON_ROOT)) != 0)) + ((error = suser_xxx(td->td_proc->p_ucred, td->td_proc, PRISON_ROOT)) != 0)) return (error); if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); VATTR_NULL(&vattr); vattr.va_flags = flags; - error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + error = VOP_SETATTR(vp, &vattr, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return (error); } @@ -2167,8 +2169,8 @@ struct chflags_args { #endif /* ARGSUSED */ int -chflags(p, uap) - struct proc *p; +chflags(td, uap) + struct thread *td; register struct chflags_args /* { syscallarg(char *) path; syscallarg(int) flags; @@ -2177,11 +2179,11 @@ chflags(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setfflags(p, nd.ni_vp, SCARG(uap, flags)); + error = setfflags(td, nd.ni_vp, SCARG(uap, flags)); vrele(nd.ni_vp); return error; } @@ -2197,8 +2199,8 @@ struct fchflags_args { #endif /* ARGSUSED */ int -fchflags(p, uap) - struct proc *p; +fchflags(td, uap) + struct thread *td; register struct fchflags_args /* { syscallarg(int) fd; syscallarg(int) flags; @@ -2207,17 +2209,17 @@ fchflags(p, uap) struct file *fp; int error; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); - return setfflags(p, (struct vnode *) fp->f_data, SCARG(uap, flags)); + return setfflags(td, (struct vnode *) fp->f_data, SCARG(uap, flags)); } /* * Common implementation code for chmod(), lchmod() and fchmod(). */ static int -setfmode(p, vp, mode) - struct proc *p; +setfmode(td, vp, mode) + struct thread *td; struct vnode *vp; int mode; { @@ -2227,12 +2229,12 @@ setfmode(p, vp, mode) if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); VATTR_NULL(&vattr); vattr.va_mode = mode & ALLPERMS; - error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + error = VOP_SETATTR(vp, &vattr, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return error; } @@ -2248,8 +2250,8 @@ struct chmod_args { #endif /* ARGSUSED */ int -chmod(p, uap) - struct proc *p; +chmod(td, uap) + struct thread *td; register struct chmod_args /* { syscallarg(char *) path; syscallarg(int) mode; @@ -2258,11 +2260,11 @@ chmod(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setfmode(p, nd.ni_vp, SCARG(uap, mode)); + error = setfmode(td, nd.ni_vp, SCARG(uap, mode)); vrele(nd.ni_vp); return error; } @@ -2278,8 +2280,8 @@ struct lchmod_args { #endif /* ARGSUSED */ int -lchmod(p, uap) - struct proc *p; +lchmod(td, uap) + struct thread *td; register struct lchmod_args /* { syscallarg(char *) path; syscallarg(int) mode; @@ -2288,11 +2290,11 @@ lchmod(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setfmode(p, nd.ni_vp, SCARG(uap, mode)); + error = setfmode(td, nd.ni_vp, SCARG(uap, mode)); vrele(nd.ni_vp); return error; } @@ -2308,8 +2310,8 @@ struct fchmod_args { #endif /* ARGSUSED */ int -fchmod(p, uap) - struct proc *p; +fchmod(td, uap) + struct thread *td; register struct fchmod_args /* { syscallarg(int) fd; syscallarg(int) mode; @@ -2318,17 +2320,17 @@ fchmod(p, uap) struct file *fp; int error; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); - return setfmode(p, (struct vnode *)fp->f_data, SCARG(uap, mode)); + return setfmode(td, (struct vnode *)fp->f_data, SCARG(uap, mode)); } /* * Common implementation for chown(), lchown(), and fchown() */ static int -setfown(p, vp, uid, gid) - struct proc *p; +setfown(td, vp, uid, gid) + struct thread *td; struct vnode *vp; uid_t uid; gid_t gid; @@ -2339,13 +2341,13 @@ setfown(p, vp, uid, gid) if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); VATTR_NULL(&vattr); vattr.va_uid = uid; vattr.va_gid = gid; - error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + error = VOP_SETATTR(vp, &vattr, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return error; } @@ -2362,8 +2364,8 @@ struct chown_args { #endif /* ARGSUSED */ int -chown(p, uap) - struct proc *p; +chown(td, uap) + struct thread *td; register struct chown_args /* { syscallarg(char *) path; syscallarg(int) uid; @@ -2373,11 +2375,11 @@ chown(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setfown(p, nd.ni_vp, SCARG(uap, uid), SCARG(uap, gid)); + error = setfown(td, nd.ni_vp, SCARG(uap, uid), SCARG(uap, gid)); vrele(nd.ni_vp); return (error); } @@ -2394,8 +2396,8 @@ struct lchown_args { #endif /* ARGSUSED */ int -lchown(p, uap) - struct proc *p; +lchown(td, uap) + struct thread *td; register struct lchown_args /* { syscallarg(char *) path; syscallarg(int) uid; @@ -2405,11 +2407,11 @@ lchown(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setfown(p, nd.ni_vp, SCARG(uap, uid), SCARG(uap, gid)); + error = setfown(td, nd.ni_vp, SCARG(uap, uid), SCARG(uap, gid)); vrele(nd.ni_vp); return (error); } @@ -2426,8 +2428,8 @@ struct fchown_args { #endif /* ARGSUSED */ int -fchown(p, uap) - struct proc *p; +fchown(td, uap) + struct thread *td; register struct fchown_args /* { syscallarg(int) fd; syscallarg(int) uid; @@ -2437,9 +2439,9 @@ fchown(p, uap) struct file *fp; int error; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); - return setfown(p, (struct vnode *)fp->f_data, + return setfown(td, (struct vnode *)fp->f_data, SCARG(uap, uid), SCARG(uap, gid)); } @@ -2471,8 +2473,8 @@ getutimes(usrtvp, tsp) * Common implementation code for utimes(), lutimes(), and futimes(). */ static int -setutimes(p, vp, ts, nullflag) - struct proc *p; +setutimes(td, vp, ts, nullflag) + struct thread *td; struct vnode *vp; const struct timespec *ts; int nullflag; @@ -2483,15 +2485,15 @@ setutimes(p, vp, ts, nullflag) if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); VATTR_NULL(&vattr); vattr.va_atime = ts[0]; vattr.va_mtime = ts[1]; if (nullflag) vattr.va_vaflags |= VA_UTIMES_NULL; - error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + error = VOP_SETATTR(vp, &vattr, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return error; } @@ -2507,8 +2509,8 @@ struct utimes_args { #endif /* ARGSUSED */ int -utimes(p, uap) - struct proc *p; +utimes(td, uap) + struct thread *td; register struct utimes_args /* { syscallarg(char *) path; syscallarg(struct timeval *) tptr; @@ -2522,11 +2524,11 @@ utimes(p, uap) usrtvp = SCARG(uap, tptr); if ((error = getutimes(usrtvp, ts)) != 0) return (error); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setutimes(p, nd.ni_vp, ts, usrtvp == NULL); + error = setutimes(td, nd.ni_vp, ts, usrtvp == NULL); vrele(nd.ni_vp); return (error); } @@ -2542,8 +2544,8 @@ struct lutimes_args { #endif /* ARGSUSED */ int -lutimes(p, uap) - struct proc *p; +lutimes(td, uap) + struct thread *td; register struct lutimes_args /* { syscallarg(char *) path; syscallarg(struct timeval *) tptr; @@ -2557,11 +2559,11 @@ lutimes(p, uap) usrtvp = SCARG(uap, tptr); if ((error = getutimes(usrtvp, ts)) != 0) return (error); - NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setutimes(p, nd.ni_vp, ts, usrtvp == NULL); + error = setutimes(td, nd.ni_vp, ts, usrtvp == NULL); vrele(nd.ni_vp); return (error); } @@ -2577,8 +2579,8 @@ struct futimes_args { #endif /* ARGSUSED */ int -futimes(p, uap) - struct proc *p; +futimes(td, uap) + struct thread *td; register struct futimes_args /* { syscallarg(int ) fd; syscallarg(struct timeval *) tptr; @@ -2592,9 +2594,9 @@ futimes(p, uap) usrtvp = SCARG(uap, tptr); if ((error = getutimes(usrtvp, ts)) != 0) return (error); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); - return setutimes(p, (struct vnode *)fp->f_data, ts, usrtvp == NULL); + return setutimes(td, (struct vnode *)fp->f_data, ts, usrtvp == NULL); } /* @@ -2609,8 +2611,8 @@ struct truncate_args { #endif /* ARGSUSED */ int -truncate(p, uap) - struct proc *p; +truncate(td, uap) + struct thread *td; register struct truncate_args /* { syscallarg(char *) path; syscallarg(int) pad; @@ -2625,7 +2627,7 @@ truncate(p, uap) if (uap->length < 0) return(EINVAL); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -2634,15 +2636,15 @@ truncate(p, uap) return (error); } NDFREE(&nd, NDF_ONLY_PNBUF); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (vp->v_type == VDIR) error = EISDIR; else if ((error = vn_writechk(vp)) == 0 && - (error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)) == 0) { + (error = VOP_ACCESS(vp, VWRITE, td->td_proc->p_ucred, td)) == 0) { VATTR_NULL(&vattr); vattr.va_size = SCARG(uap, length); - error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); + error = VOP_SETATTR(vp, &vattr, td->td_proc->p_ucred, td); } vput(vp); vn_finished_write(mp); @@ -2661,8 +2663,8 @@ struct ftruncate_args { #endif /* ARGSUSED */ int -ftruncate(p, uap) - struct proc *p; +ftruncate(td, uap) + struct thread *td; register struct ftruncate_args /* { syscallarg(int) fd; syscallarg(int) pad; @@ -2677,23 +2679,23 @@ ftruncate(p, uap) if (uap->length < 0) return(EINVAL); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); if ((fp->f_flag & FWRITE) == 0) return (EINVAL); vp = (struct vnode *)fp->f_data; if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (vp->v_type == VDIR) error = EISDIR; else if ((error = vn_writechk(vp)) == 0) { VATTR_NULL(&vattr); vattr.va_size = SCARG(uap, length); - error = VOP_SETATTR(vp, &vattr, fp->f_cred, p); + error = VOP_SETATTR(vp, &vattr, fp->f_cred, td); } - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return (error); } @@ -2710,8 +2712,8 @@ struct otruncate_args { #endif /* ARGSUSED */ int -otruncate(p, uap) - struct proc *p; +otruncate(td, uap) + struct thread *td; register struct otruncate_args /* { syscallarg(char *) path; syscallarg(long) length; @@ -2725,7 +2727,7 @@ otruncate(p, uap) SCARG(&nuap, path) = SCARG(uap, path); SCARG(&nuap, length) = SCARG(uap, length); - return (truncate(p, &nuap)); + return (truncate(td, &nuap)); } /* @@ -2739,8 +2741,8 @@ struct oftruncate_args { #endif /* ARGSUSED */ int -oftruncate(p, uap) - struct proc *p; +oftruncate(td, uap) + struct thread *td; register struct oftruncate_args /* { syscallarg(int) fd; syscallarg(long) length; @@ -2754,7 +2756,7 @@ oftruncate(p, uap) SCARG(&nuap, fd) = SCARG(uap, fd); SCARG(&nuap, length) = SCARG(uap, length); - return (ftruncate(p, &nuap)); + return (ftruncate(td, &nuap)); } #endif /* COMPAT_43 || COMPAT_SUNOS */ @@ -2768,8 +2770,8 @@ struct fsync_args { #endif /* ARGSUSED */ int -fsync(p, uap) - struct proc *p; +fsync(td, uap) + struct thread *td; struct fsync_args /* { syscallarg(int) fd; } */ *uap; @@ -2782,22 +2784,22 @@ fsync(p, uap) GIANT_REQUIRED; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); vp = (struct vnode *)fp->f_data; if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (VOP_GETVOBJECT(vp, &obj) == 0) { vm_object_page_clean(obj, 0, 0, 0); } - error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, p); + error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, td); #ifdef SOFTUPDATES if (error == 0 && vp->v_mount && (vp->v_mount->mnt_flag & MNT_SOFTDEP)) error = softdep_fsync(vp); #endif - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return (error); } @@ -2814,8 +2816,8 @@ struct rename_args { #endif /* ARGSUSED */ int -rename(p, uap) - struct proc *p; +rename(td, uap) + struct thread *td; register struct rename_args /* { syscallarg(char *) from; syscallarg(char *) to; @@ -2828,7 +2830,7 @@ rename(p, uap) bwillwrite(); NDINIT(&fromnd, DELETE, WANTPARENT | SAVESTART, UIO_USERSPACE, - SCARG(uap, from), p); + SCARG(uap, from), td); if ((error = namei(&fromnd)) != 0) return (error); fvp = fromnd.ni_vp; @@ -2839,7 +2841,7 @@ rename(p, uap) goto out1; } NDINIT(&tond, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART | NOOBJ, - UIO_USERSPACE, SCARG(uap, to), p); + UIO_USERSPACE, SCARG(uap, to), td); if (fromnd.ni_vp->v_type == VDIR) tond.ni_cnd.cn_flags |= WILLBEDIR; if ((error = namei(&tond)) != 0) { @@ -2876,12 +2878,12 @@ rename(p, uap) error = -1; out: if (!error) { - VOP_LEASE(tdvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(tdvp, td, td->td_proc->p_ucred, LEASE_WRITE); if (fromnd.ni_dvp != tdvp) { - VOP_LEASE(fromnd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(fromnd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); } if (tvp) { - VOP_LEASE(tvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(tvp, td, td->td_proc->p_ucred, LEASE_WRITE); } error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd, tond.ni_dvp, tond.ni_vp, &tond.ni_cnd); @@ -2924,13 +2926,24 @@ struct mkdir_args { #endif /* ARGSUSED */ int -mkdir(p, uap) - struct proc *p; +mkdir(td, uap) + struct thread *td; register struct mkdir_args /* { syscallarg(char *) path; syscallarg(int) mode; } */ *uap; { + + return vn_mkdir(uap->path, uap->mode, UIO_USERSPACE, td); +} + +int +vn_mkdir(path, mode, segflg, td) + char *path; + int mode; + enum uio_seg segflg; + struct thread *td; +{ struct mount *mp; struct vnode *vp; struct vattr vattr; @@ -2939,7 +2952,7 @@ mkdir(p, uap) restart: bwillwrite(); - NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, CREATE, LOCKPARENT, segflg, path, td); nd.ni_cnd.cn_flags |= WILLBEDIR; if ((error = namei(&nd)) != 0) return (error); @@ -2959,8 +2972,8 @@ restart: } VATTR_NULL(&vattr); vattr.va_type = VDIR; - vattr.va_mode = (SCARG(uap, mode) & ACCESSPERMS) &~ p->p_fd->fd_cmask; - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + vattr.va_mode = (mode & ACCESSPERMS) &~ td->td_proc->p_fd->fd_cmask; + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); NDFREE(&nd, NDF_ONLY_PNBUF); vput(nd.ni_dvp); @@ -2982,8 +2995,8 @@ struct rmdir_args { #endif /* ARGSUSED */ int -rmdir(p, uap) - struct proc *p; +rmdir(td, uap) + struct thread *td; struct rmdir_args /* { syscallarg(char *) path; } */ *uap; @@ -2996,7 +3009,7 @@ rmdir(p, uap) restart: bwillwrite(); NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -3029,8 +3042,8 @@ restart: return (error); goto restart; } - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd); vn_finished_write(mp); out: @@ -3058,8 +3071,8 @@ struct ogetdirentries_args { }; #endif int -ogetdirentries(p, uap) - struct proc *p; +ogetdirentries(td, uap) + struct thread *td; register struct ogetdirentries_args /* { syscallarg(int) fd; syscallarg(char *) buf; @@ -3079,7 +3092,7 @@ ogetdirentries(p, uap) /* XXX arbitrary sanity limit on `count'. */ if (SCARG(uap, count) > 64 * 1024) return (EINVAL); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); if ((fp->f_flag & FREAD) == 0) return (EBADF); @@ -3093,9 +3106,9 @@ unionread: auio.uio_iovcnt = 1; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_resid = SCARG(uap, count); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); loff = auio.uio_offset = fp->f_offset; # if (BYTE_ORDER != LITTLE_ENDIAN) if (vp->v_mount->mnt_maxsymlinklen <= 0) { @@ -3148,12 +3161,12 @@ unionread: } FREE(dirbuf, M_TEMP); } - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (error) return (error); if (SCARG(uap, count) == auio.uio_resid) { if (union_dircheckp) { - error = union_dircheckp(p, &vp, fp); + error = union_dircheckp(td, &vp, fp); if (error == -1) goto unionread; if (error) @@ -3172,7 +3185,7 @@ unionread: } error = copyout((caddr_t)&loff, (caddr_t)SCARG(uap, basep), sizeof(long)); - p->p_retval[0] = SCARG(uap, count) - auio.uio_resid; + td->td_retval[0] = SCARG(uap, count) - auio.uio_resid; return (error); } #endif /* COMPAT_43 */ @@ -3189,8 +3202,8 @@ struct getdirentries_args { }; #endif int -getdirentries(p, uap) - struct proc *p; +getdirentries(td, uap) + struct thread *td; register struct getdirentries_args /* { syscallarg(int) fd; syscallarg(char *) buf; @@ -3205,7 +3218,7 @@ getdirentries(p, uap) long loff; int error, eofflag; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); if ((fp->f_flag & FREAD) == 0) return (EBADF); @@ -3219,19 +3232,19 @@ unionread: auio.uio_iovcnt = 1; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_resid = SCARG(uap, count); - /* vn_lock(vp, LK_SHARED | LK_RETRY, p); */ - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + /* vn_lock(vp, LK_SHARED | LK_RETRY, td); */ + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); loff = auio.uio_offset = fp->f_offset; error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, NULL, NULL); fp->f_offset = auio.uio_offset; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (error) return (error); if (SCARG(uap, count) == auio.uio_resid) { if (union_dircheckp) { - error = union_dircheckp(p, &vp, fp); + error = union_dircheckp(td, &vp, fp); if (error == -1) goto unionread; if (error) @@ -3252,7 +3265,7 @@ unionread: error = copyout((caddr_t)&loff, (caddr_t)SCARG(uap, basep), sizeof(long)); } - p->p_retval[0] = SCARG(uap, count) - auio.uio_resid; + td->td_retval[0] = SCARG(uap, count) - auio.uio_resid; return (error); } #ifndef _SYS_SYSPROTO_H_ @@ -3263,8 +3276,8 @@ struct getdents_args { }; #endif int -getdents(p, uap) - struct proc *p; +getdents(td, uap) + struct thread *td; register struct getdents_args /* { syscallarg(int) fd; syscallarg(char *) buf; @@ -3276,7 +3289,7 @@ getdents(p, uap) ap.buf = uap->buf; ap.count = uap->count; ap.basep = NULL; - return getdirentries(p, &ap); + return getdirentries(td, &ap); } /* @@ -3290,16 +3303,16 @@ struct umask_args { }; #endif int -umask(p, uap) - struct proc *p; +umask(td, uap) + struct thread *td; struct umask_args /* { syscallarg(int) newmask; } */ *uap; { register struct filedesc *fdp; - fdp = p->p_fd; - p->p_retval[0] = fdp->fd_cmask; + fdp = td->td_proc->p_fd; + td->td_retval[0] = fdp->fd_cmask; fdp->fd_cmask = SCARG(uap, newmask) & ALLPERMS; return (0); } @@ -3315,8 +3328,8 @@ struct revoke_args { #endif /* ARGSUSED */ int -revoke(p, uap) - struct proc *p; +revoke(td, uap) + struct thread *td; register struct revoke_args /* { syscallarg(char *) path; } */ *uap; @@ -3327,7 +3340,7 @@ revoke(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -3336,10 +3349,10 @@ revoke(p, uap) error = EINVAL; goto out; } - if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) != 0) + if ((error = VOP_GETATTR(vp, &vattr, td->td_proc->p_ucred, td)) != 0) goto out; - if (p->p_ucred->cr_uid != vattr.va_uid && - (error = suser_xxx(0, p, PRISON_ROOT))) + if (td->td_proc->p_ucred->cr_uid != vattr.va_uid && + (error = suser_xxx(0, td->td_proc, PRISON_ROOT))) goto out; if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) goto out; @@ -3380,8 +3393,8 @@ struct getfh_args { }; #endif int -getfh(p, uap) - struct proc *p; +getfh(td, uap) + struct thread *td; register struct getfh_args *uap; { struct nameidata nd; @@ -3392,10 +3405,10 @@ getfh(p, uap) /* * Must be super user */ - error = suser(p); + error = suser_td(td); if (error) return (error); - NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p); + NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, td); error = namei(&nd); if (error) return (error); @@ -3425,13 +3438,14 @@ struct fhopen_args { }; #endif int -fhopen(p, uap) - struct proc *p; +fhopen(td, uap) + struct thread *td; struct fhopen_args /* { syscallarg(const struct fhandle *) u_fhp; syscallarg(int) flags; } */ *uap; { + struct proc *p = td->td_proc; struct mount *mp; struct vnode *vp; struct fhandle fhp; @@ -3447,7 +3461,7 @@ fhopen(p, uap) /* * Must be super user */ - error = suser(p); + error = suser_td(td); if (error) return (error); @@ -3498,33 +3512,33 @@ fhopen(p, uap) if (fmode & FREAD) mode |= VREAD; if (mode) { - error = VOP_ACCESS(vp, mode, p->p_ucred, p); + error = VOP_ACCESS(vp, mode, p->p_ucred, td); if (error) goto bad; } if (fmode & O_TRUNC) { - VOP_UNLOCK(vp, 0, p); /* XXX */ + VOP_UNLOCK(vp, 0, td); /* XXX */ if ((error = vn_start_write(NULL, &mp, V_WAIT | PCATCH)) != 0) { vrele(vp); return (error); } - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); /* XXX */ + VOP_LEASE(vp, td, p->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); /* XXX */ VATTR_NULL(vap); vap->va_size = 0; - error = VOP_SETATTR(vp, vap, p->p_ucred, p); + error = VOP_SETATTR(vp, vap, p->p_ucred, td); vn_finished_write(mp); if (error) goto bad; } - error = VOP_OPEN(vp, fmode, p->p_ucred, p); + error = VOP_OPEN(vp, fmode, p->p_ucred, td); if (error) goto bad; /* * Make sure that a VM object is created for VMIO support. */ if (vn_canvmio(vp) == TRUE) { - if ((error = vfs_object_create(vp, p, p->p_ucred)) != 0) + if ((error = vfs_object_create(vp, td, p->p_ucred)) != 0) goto bad; } if (fmode & FWRITE) @@ -3534,7 +3548,7 @@ fhopen(p, uap) * end of vn_open code */ - if ((error = falloc(p, &nfp, &indx)) != 0) + if ((error = falloc(td, &nfp, &indx)) != 0) goto bad; fp = nfp; @@ -3558,7 +3572,7 @@ fhopen(p, uap) type = F_FLOCK; if ((fmode & FNONBLOCK) == 0) type |= F_WAIT; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if ((error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type)) != 0) { /* * The lock request failed. Normally close the @@ -3567,23 +3581,23 @@ fhopen(p, uap) */ if (fdp->fd_ofiles[indx] == fp) { fdp->fd_ofiles[indx] = NULL; - fdrop(fp, p); + fdrop(fp, td); } /* * release our private reference */ - fdrop(fp, p); + fdrop(fp, td); return(error); } - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); fp->f_flag |= FHASLOCK; } if ((vp->v_type == VREG) && (VOP_GETVOBJECT(vp, NULL) != 0)) - vfs_object_create(vp, p, p->p_ucred); + vfs_object_create(vp, td, p->p_ucred); - VOP_UNLOCK(vp, 0, p); - fdrop(fp, p); - p->p_retval[0] = indx; + VOP_UNLOCK(vp, 0, td); + fdrop(fp, td); + td->td_retval[0] = indx; return (0); bad: @@ -3601,8 +3615,8 @@ struct fhstat_args { }; #endif int -fhstat(p, uap) - struct proc *p; +fhstat(td, uap) + struct thread *td; register struct fhstat_args /* { syscallarg(struct fhandle *) u_fhp; syscallarg(struct stat *) sb; @@ -3617,7 +3631,7 @@ fhstat(p, uap) /* * Must be super user */ - error = suser(p); + error = suser_td(td); if (error) return (error); @@ -3629,7 +3643,7 @@ fhstat(p, uap) return (ESTALE); if ((error = VFS_FHTOVP(mp, &fh.fh_fid, &vp))) return (error); - error = vn_stat(vp, &sb, p); + error = vn_stat(vp, &sb, td); vput(vp); if (error) return (error); @@ -3647,8 +3661,8 @@ struct fhstatfs_args { }; #endif int -fhstatfs(p, uap) - struct proc *p; +fhstatfs(td, uap) + struct thread *td; struct fhstatfs_args /* { syscallarg(struct fhandle) *u_fhp; syscallarg(struct statfs) *buf; @@ -3664,7 +3678,7 @@ fhstatfs(p, uap) /* * Must be super user */ - if ((error = suser(p))) + if ((error = suser_td(td))) return (error); if ((error = copyin(SCARG(uap, u_fhp), &fh, sizeof(fhandle_t))) != 0) @@ -3677,10 +3691,10 @@ fhstatfs(p, uap) mp = vp->v_mount; sp = &mp->mnt_stat; vput(vp); - if ((error = VFS_STATFS(mp, sp, p)) != 0) + if ((error = VFS_STATFS(mp, sp, td)) != 0) return (error); sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; - if (suser_xxx(p->p_ucred, 0, 0)) { + if (suser_xxx(td->td_proc->p_ucred, 0, 0)) { bcopy((caddr_t)sp, (caddr_t)&sb, sizeof(sb)); sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0; sp = &sb; @@ -3700,8 +3714,8 @@ fhstatfs(p, uap) * Currently this is used only by UFS Extended Attributes. */ int -extattrctl(p, uap) - struct proc *p; +extattrctl(td, uap) + struct thread *td; struct extattrctl_args *uap; { struct vnode *filename_vp; @@ -3728,7 +3742,7 @@ extattrctl(p, uap) filename_vp = NULL; if (SCARG(uap, filename) != NULL) { NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, filename), p); + SCARG(uap, filename), td); if ((error = namei(&nd)) != 0) return (error); filename_vp = nd.ni_vp; @@ -3736,7 +3750,7 @@ extattrctl(p, uap) } /* SCARG(uap, path) always defined. */ - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); error = vn_start_write(nd.ni_vp, &mp, V_WAIT | PCATCH); @@ -3749,10 +3763,10 @@ extattrctl(p, uap) if (SCARG(uap, attrname) != NULL) { error = VFS_EXTATTRCTL(mp, SCARG(uap, cmd), filename_vp, - SCARG(uap, attrnamespace), attrname, p); + SCARG(uap, attrnamespace), attrname, td); } else { error = VFS_EXTATTRCTL(mp, SCARG(uap, cmd), filename_vp, - SCARG(uap, attrnamespace), NULL, p); + SCARG(uap, attrnamespace), NULL, td); } vn_finished_write(mp); @@ -3779,7 +3793,7 @@ extattrctl(p, uap) */ static int extattr_set_vp(struct vnode *vp, int attrnamespace, const char *attrname, - struct iovec *iovp, unsigned iovcnt, struct proc *p) + struct iovec *iovp, unsigned iovcnt, struct thread *td) { struct mount *mp; struct uio auio; @@ -3789,8 +3803,8 @@ extattr_set_vp(struct vnode *vp, int attrnamespace, const char *attrname, if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); iovlen = iovcnt * sizeof(struct iovec); if (iovcnt > UIO_SMALLIOV) { @@ -3806,7 +3820,7 @@ extattr_set_vp(struct vnode *vp, int attrnamespace, const char *attrname, auio.uio_iovcnt = iovcnt; auio.uio_rw = UIO_WRITE; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; if ((error = copyin((caddr_t)iovp, (caddr_t)iov, iovlen))) goto done; @@ -3821,20 +3835,20 @@ extattr_set_vp(struct vnode *vp, int attrnamespace, const char *attrname, } cnt = auio.uio_resid; error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio, - p->p_ucred, p); + td->td_proc->p_ucred, td); cnt -= auio.uio_resid; - p->p_retval[0] = cnt; + td->td_retval[0] = cnt; done: if (needfree) FREE(needfree, M_IOV); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return (error); } int -extattr_set_file(p, uap) - struct proc *p; +extattr_set_file(td, uap) + struct thread *td; struct extattr_set_file_args *uap; { struct nameidata nd; @@ -3846,21 +3860,21 @@ extattr_set_file(p, uap) if (error) return (error); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); error = extattr_set_vp(nd.ni_vp, SCARG(uap, attrnamespace), attrname, - SCARG(uap, iovp), SCARG(uap, iovcnt), p); + SCARG(uap, iovp), SCARG(uap, iovcnt), td); vrele(nd.ni_vp); return (error); } int -extattr_set_fd(p, uap) - struct proc *p; +extattr_set_fd(td, uap) + struct thread *td; struct extattr_set_fd_args *uap; { struct file *fp; @@ -3872,12 +3886,12 @@ extattr_set_fd(p, uap) if (error) return (error); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); error = extattr_set_vp((struct vnode *)fp->f_data, SCARG(uap, attrnamespace), attrname, SCARG(uap, iovp), - SCARG(uap, iovcnt), p); + SCARG(uap, iovcnt), td); return (error); } @@ -3895,15 +3909,15 @@ extattr_set_fd(p, uap) */ static int extattr_get_vp(struct vnode *vp, int attrnamespace, const char *attrname, - struct iovec *iovp, unsigned iovcnt, struct proc *p) + struct iovec *iovp, unsigned iovcnt, struct thread *td) { struct uio auio; struct iovec *iov, *needfree = NULL, aiov[UIO_SMALLIOV]; u_int iovlen, cnt; int error, i; - VOP_LEASE(vp, p, p->p_ucred, LEASE_READ); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_READ); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); iovlen = iovcnt * sizeof (struct iovec); if (iovcnt > UIO_SMALLIOV) { @@ -3919,7 +3933,7 @@ extattr_get_vp(struct vnode *vp, int attrnamespace, const char *attrname, auio.uio_iovcnt = iovcnt; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; if ((error = copyin((caddr_t)iovp, (caddr_t)iov, iovlen))) goto done; @@ -3934,19 +3948,19 @@ extattr_get_vp(struct vnode *vp, int attrnamespace, const char *attrname, } cnt = auio.uio_resid; error = VOP_GETEXTATTR(vp, attrnamespace, attrname, &auio, - p->p_ucred, p); + td->td_proc->p_ucred, td); cnt -= auio.uio_resid; - p->p_retval[0] = cnt; + td->td_retval[0] = cnt; done: if (needfree) FREE(needfree, M_IOV); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); return (error); } int -extattr_get_file(p, uap) - struct proc *p; +extattr_get_file(td, uap) + struct thread *td; struct extattr_get_file_args *uap; { struct nameidata nd; @@ -3958,21 +3972,21 @@ extattr_get_file(p, uap) if (error) return (error); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); error = extattr_get_vp(nd.ni_vp, SCARG(uap, attrnamespace), attrname, - SCARG(uap, iovp), SCARG(uap, iovcnt), p); + SCARG(uap, iovp), SCARG(uap, iovcnt), td); vrele(nd.ni_vp); return (error); } int -extattr_get_fd(p, uap) - struct proc *p; +extattr_get_fd(td, uap) + struct thread *td; struct extattr_get_fd_args *uap; { struct file *fp; @@ -3984,12 +3998,12 @@ extattr_get_fd(p, uap) if (error) return (error); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); error = extattr_get_vp((struct vnode *)fp->f_data, SCARG(uap, attrnamespace), attrname, SCARG(uap, iovp), - SCARG(uap, iovcnt), p); + SCARG(uap, iovcnt), td); return (error); } @@ -4006,27 +4020,27 @@ extattr_get_fd(p, uap) */ static int extattr_delete_vp(struct vnode *vp, int attrnamespace, const char *attrname, - struct proc *p) + struct thread *td) { struct mount *mp; int error; if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL, - p->p_ucred, p); + td->td_proc->p_ucred, td); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return (error); } int -extattr_delete_file(p, uap) - struct proc *p; +extattr_delete_file(td, uap) + struct thread *td; struct extattr_delete_file_args *uap; { struct nameidata nd; @@ -4038,21 +4052,21 @@ extattr_delete_file(p, uap) if (error) return(error); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return(error); NDFREE(&nd, NDF_ONLY_PNBUF); error = extattr_delete_vp(nd.ni_vp, SCARG(uap, attrnamespace), - attrname, p); + attrname, td); vrele(nd.ni_vp); return(error); } int -extattr_delete_fd(p, uap) - struct proc *p; +extattr_delete_fd(td, uap) + struct thread *td; struct extattr_delete_fd_args *uap; { struct file *fp; @@ -4064,11 +4078,11 @@ extattr_delete_fd(p, uap) if (error) return (error); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); error = extattr_delete_vp((struct vnode *)fp->f_data, - SCARG(uap, attrnamespace), attrname, p); + SCARG(uap, attrnamespace), attrname, td); return (error); } diff --git a/sys/kern/vfs_lookup.c b/sys/kern/vfs_lookup.c index 4875533..470abba 100644 --- a/sys/kern/vfs_lookup.c +++ b/sys/kern/vfs_lookup.c @@ -100,15 +100,16 @@ namei(ndp) struct uio auio; int error, linklen; struct componentname *cnp = &ndp->ni_cnd; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; + struct proc *p = td->td_proc; - ndp->ni_cnd.cn_cred = ndp->ni_cnd.cn_proc->p_ucred; - KASSERT(cnp->cn_cred && cnp->cn_proc, ("namei: bad cred/proc")); + ndp->ni_cnd.cn_cred = ndp->ni_cnd.cn_thread->td_proc->p_ucred; + KASSERT(cnp->cn_cred && p, ("namei: bad cred/proc")); KASSERT((cnp->cn_nameiop & (~OPMASK)) == 0, ("namei: nameiop contaminated with flags")); KASSERT((cnp->cn_flags & OPMASK) == 0, ("namei: flags contaminated with nameiops")); - fdp = cnp->cn_proc->p_fd; + fdp = p->p_fd; /* * Get a buffer for the name to be translated, and copy the @@ -136,8 +137,8 @@ namei(ndp) } ndp->ni_loopcnt = 0; #ifdef KTRACE - if (KTRPOINT(cnp->cn_proc, KTR_NAMEI)) - ktrnamei(cnp->cn_proc->p_tracep, cnp->cn_pnbuf); + if (KTRPOINT(p, KTR_NAMEI)) + ktrnamei(p->p_tracep, cnp->cn_pnbuf); #endif /* @@ -182,14 +183,13 @@ namei(ndp) (cnp->cn_nameiop != DELETE) && ((cnp->cn_flags & (NOOBJ|LOCKLEAF)) == LOCKLEAF)) - vfs_object_create(ndp->ni_vp, - ndp->ni_cnd.cn_proc, + vfs_object_create(ndp->ni_vp, td, ndp->ni_cnd.cn_cred); return (0); } if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1) - VOP_UNLOCK(ndp->ni_dvp, 0, p); + VOP_UNLOCK(ndp->ni_dvp, 0, td); if (ndp->ni_loopcnt++ >= MAXSYMLINKS) { error = ELOOP; break; @@ -205,7 +205,7 @@ namei(ndp) auio.uio_offset = 0; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = (struct proc *)0; + auio.uio_td = (struct thread *)0; auio.uio_resid = MAXPATHLEN; error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred); if (error) { @@ -296,7 +296,7 @@ lookup(ndp) int error = 0; int dpunlocked = 0; /* dp has already been unlocked */ struct componentname *cnp = &ndp->ni_cnd; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; /* * Setup: break out flag bits into variables. @@ -312,7 +312,7 @@ lookup(ndp) cnp->cn_flags &= ~ISSYMLINK; dp = ndp->ni_startdir; ndp->ni_startdir = NULLVP; - vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td); dirloop: /* @@ -392,7 +392,7 @@ dirloop: } ndp->ni_vp = dp; if (!(cnp->cn_flags & (LOCKPARENT | LOCKLEAF))) - VOP_UNLOCK(dp, 0, p); + VOP_UNLOCK(dp, 0, td); /* XXX This should probably move to the top of function. */ if (cnp->cn_flags & SAVESTART) panic("lookup: SAVESTART"); @@ -432,7 +432,7 @@ dirloop: dp = dp->v_mount->mnt_vnodecovered; vput(tdp); VREF(dp); - vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td); } } @@ -459,7 +459,7 @@ unionlookup: else vput(tdp); VREF(dp); - vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td); goto unionlookup; } @@ -514,11 +514,11 @@ unionlookup: */ while (dp->v_type == VDIR && (mp = dp->v_mountedhere) && (cnp->cn_flags & NOCROSSMOUNT) == 0) { - if (vfs_busy(mp, 0, 0, p)) + if (vfs_busy(mp, 0, 0, td)) continue; - VOP_UNLOCK(dp, 0, p); + VOP_UNLOCK(dp, 0, td); error = VFS_ROOT(mp, &tdp); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); if (error) { dpunlocked = 1; goto bad2; @@ -587,13 +587,13 @@ nextname: vrele(ndp->ni_dvp); if ((cnp->cn_flags & LOCKLEAF) == 0) - VOP_UNLOCK(dp, 0, p); + VOP_UNLOCK(dp, 0, td); return (0); bad2: if ((cnp->cn_flags & (LOCKPARENT | PDIRUNLOCK)) == LOCKPARENT && *ndp->ni_next == '\0') - VOP_UNLOCK(ndp->ni_dvp, 0, p); + VOP_UNLOCK(ndp->ni_dvp, 0, td); vrele(ndp->ni_dvp); bad: if (dpunlocked) @@ -613,7 +613,7 @@ relookup(dvp, vpp, cnp) struct vnode *dvp, **vpp; struct componentname *cnp; { - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct vnode *dp = 0; /* the directory we are searching */ int docache; /* == 0 do not cache last component */ int wantparent; /* 1 => wantparent or lockparent flag */ @@ -635,7 +635,7 @@ relookup(dvp, vpp, cnp) rdonly = cnp->cn_flags & RDONLY; cnp->cn_flags &= ~ISSYMLINK; dp = dvp; - vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td); /* dirloop: */ /* @@ -669,7 +669,7 @@ relookup(dvp, vpp, cnp) goto bad; } if (!(cnp->cn_flags & LOCKLEAF)) - VOP_UNLOCK(dp, 0, p); + VOP_UNLOCK(dp, 0, td); *vpp = dp; /* XXX This should probably move to the top of function. */ if (cnp->cn_flags & SAVESTART) @@ -730,15 +730,15 @@ relookup(dvp, vpp, cnp) if (vn_canvmio(dp) == TRUE && ((cnp->cn_flags & (NOOBJ|LOCKLEAF)) == LOCKLEAF)) - vfs_object_create(dp, cnp->cn_proc, cnp->cn_cred); + vfs_object_create(dp, td, cnp->cn_cred); if ((cnp->cn_flags & LOCKLEAF) == 0) - VOP_UNLOCK(dp, 0, p); + VOP_UNLOCK(dp, 0, td); return (0); bad2: if ((cnp->cn_flags & LOCKPARENT) && (cnp->cn_flags & ISLASTCN)) - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); vrele(dvp); bad: vput(dp); diff --git a/sys/kern/vfs_mount.c b/sys/kern/vfs_mount.c index e651ef0..98c3f13 100644 --- a/sys/kern/vfs_mount.c +++ b/sys/kern/vfs_mount.c @@ -227,7 +227,7 @@ vfs_mountroot_try(char *mountfrom) */ strncpy(mp->mnt_stat.f_mntonname, "/", MNAMELEN); - error = VFS_MOUNT(mp, NULL, NULL, NULL, curproc); + error = VFS_MOUNT(mp, NULL, NULL, NULL, curthread); done: if (vfsname != NULL) @@ -236,7 +236,7 @@ done: free(path, M_MOUNT); if (error != 0) { if (mp != NULL) { - vfs_unbusy(mp, curproc); + vfs_unbusy(mp, curthread); free(mp, M_MOUNT); } printf("Root mount failed: %d\n", error); @@ -249,7 +249,7 @@ done: /* sanity check system clock against root filesystem timestamp */ inittodr(mp->mnt_time); - vfs_unbusy(mp, curproc); + vfs_unbusy(mp, curthread); } return(error); } diff --git a/sys/kern/vfs_subr.c b/sys/kern/vfs_subr.c index b38bc16..8c67662 100644 --- a/sys/kern/vfs_subr.c +++ b/sys/kern/vfs_subr.c @@ -74,7 +74,7 @@ static MALLOC_DEFINE(M_NETADDR, "Export Host", "Export host address structure"); static void addalias __P((struct vnode *vp, dev_t nvp_rdev)); static void insmntque __P((struct vnode *vp, struct mount *mp)); -static void vclean __P((struct vnode *vp, int flags, struct proc *p)); +static void vclean __P((struct vnode *vp, int flags, struct thread *td)); /* * Number of vnodes in existence. Increased whenever getnewvnode() @@ -269,11 +269,11 @@ SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_FIRST, vntblinit, NULL) * unmounting. Interlock is not released on failure. */ int -vfs_busy(mp, flags, interlkp, p) +vfs_busy(mp, flags, interlkp, td) struct mount *mp; int flags; struct mtx *interlkp; - struct proc *p; + struct thread *td; { int lkflags; @@ -293,7 +293,7 @@ vfs_busy(mp, flags, interlkp, p) lkflags = LK_SHARED | LK_NOPAUSE; if (interlkp) lkflags |= LK_INTERLOCK; - if (lockmgr(&mp->mnt_lock, lkflags, interlkp, p)) + if (lockmgr(&mp->mnt_lock, lkflags, interlkp, td)) panic("vfs_busy: unexpected lock failure"); return (0); } @@ -302,12 +302,12 @@ vfs_busy(mp, flags, interlkp, p) * Free a busy filesystem. */ void -vfs_unbusy(mp, p) +vfs_unbusy(mp, td) struct mount *mp; - struct proc *p; + struct thread *td; { - lockmgr(&mp->mnt_lock, LK_RELEASE, NULL, p); + lockmgr(&mp->mnt_lock, LK_RELEASE, NULL, td); } /* @@ -322,7 +322,7 @@ vfs_rootmountalloc(fstypename, devname, mpp) char *devname; struct mount **mpp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct vfsconf *vfsp; struct mount *mp; @@ -335,7 +335,7 @@ vfs_rootmountalloc(fstypename, devname, mpp) return (ENODEV); mp = malloc((u_long)sizeof(struct mount), M_MOUNT, M_WAITOK | M_ZERO); lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, LK_NOPAUSE); - (void)vfs_busy(mp, LK_NOWAIT, 0, p); + (void)vfs_busy(mp, LK_NOWAIT, 0, td); LIST_INIT(&mp->mnt_vnodelist); mp->mnt_vfc = vfsp; mp->mnt_op = vfsp->vfc_vfsops; @@ -524,7 +524,7 @@ getnewvnode(tag, mp, vops, vpp) struct vnode **vpp; { int s, count; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct vnode *vp = NULL; struct mount *vnmp; vm_object_t object; @@ -582,7 +582,7 @@ getnewvnode(tag, mp, vops, vpp) cache_purge(vp); vp->v_lease = NULL; if (vp->v_type != VBAD) { - vgonel(vp, p); + vgonel(vp, td); } else { mtx_unlock(&vp->v_interlock); } @@ -634,7 +634,7 @@ getnewvnode(tag, mp, vops, vpp) splx(s); - vfs_object_create(vp, p, p->p_ucred); + vfs_object_create(vp, td, td->td_proc->p_ucred); vnodeallocs++; if (vnodeallocs % vnoderecycleperiod == 0 && @@ -699,11 +699,11 @@ vwakeup(bp) * Called with the underlying object locked. */ int -vinvalbuf(vp, flags, cred, p, slpflag, slptimeo) +vinvalbuf(vp, flags, cred, td, slpflag, slptimeo) register struct vnode *vp; int flags; struct ucred *cred; - struct proc *p; + struct thread *td; int slpflag, slptimeo; { register struct buf *bp; @@ -726,7 +726,7 @@ vinvalbuf(vp, flags, cred, p, slpflag, slptimeo) } if (!TAILQ_EMPTY(&vp->v_dirtyblkhd)) { splx(s); - if ((error = VOP_FSYNC(vp, cred, MNT_WAIT, p)) != 0) + if ((error = VOP_FSYNC(vp, cred, MNT_WAIT, td)) != 0) return (error); s = splbio(); if (vp->v_numoutput > 0 || @@ -815,10 +815,10 @@ vinvalbuf(vp, flags, cred, p, slpflag, slptimeo) * sync activity. */ int -vtruncbuf(vp, cred, p, length, blksize) +vtruncbuf(vp, cred, td, length, blksize) register struct vnode *vp; struct ucred *cred; - struct proc *p; + struct thread *td; off_t length; int blksize; { @@ -1020,15 +1020,15 @@ sched_sync(void) struct mount *mp; long starttime; int s; - struct proc *p = updateproc; + struct thread *td = &updateproc->p_thread; /* XXXKSE */ mtx_lock(&Giant); - EVENTHANDLER_REGISTER(shutdown_pre_sync, kproc_shutdown, p, + EVENTHANDLER_REGISTER(shutdown_pre_sync, kproc_shutdown, td->td_proc, SHUTDOWN_PRI_LAST); for (;;) { - kthread_suspend_check(p); + kthread_suspend_check(td->td_proc); starttime = time_second; @@ -1046,9 +1046,9 @@ sched_sync(void) while ((vp = LIST_FIRST(slp)) != NULL) { if (VOP_ISLOCKED(vp, NULL) == 0 && vn_start_write(vp, &mp, V_NOWAIT) == 0) { - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - (void) VOP_FSYNC(vp, p->p_ucred, MNT_LAZY, p); - VOP_UNLOCK(vp, 0, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + (void) VOP_FSYNC(vp, td->td_proc->p_ucred, MNT_LAZY, td); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); } s = splbio(); @@ -1111,14 +1111,15 @@ sched_sync(void) * Request the syncer daemon to speed up its work. * We never push it to speed up more than half of its * normal turn time, otherwise it could take over the cpu. + * XXXKSE only one update? */ int speedup_syncer() { mtx_lock_spin(&sched_lock); - if (updateproc->p_wchan == &lbolt) - setrunnable(updateproc); + if (updateproc->p_thread.td_wchan == &lbolt) /* XXXKSE */ + setrunnable(&updateproc->p_thread); mtx_unlock_spin(&sched_lock); if (rushjob < syncdelay / 2) { rushjob += 1; @@ -1398,9 +1399,9 @@ addaliasu(nvp, nvp_rdev) ovp->v_vnlock = &ovp->v_lock; ops = ovp->v_op; ovp->v_op = nvp->v_op; - if (VOP_ISLOCKED(nvp, curproc)) { - VOP_UNLOCK(nvp, 0, curproc); - vn_lock(ovp, LK_EXCLUSIVE | LK_RETRY, curproc); + if (VOP_ISLOCKED(nvp, curthread)) { + VOP_UNLOCK(nvp, 0, curthread); + vn_lock(ovp, LK_EXCLUSIVE | LK_RETRY, curthread); } nvp->v_op = ops; insmntque(ovp, nvp->v_mount); @@ -1433,10 +1434,10 @@ addalias(nvp, dev) * been changed to a new file system type). */ int -vget(vp, flags, p) +vget(vp, flags, td) register struct vnode *vp; int flags; - struct proc *p; + struct thread *td; { int error; @@ -1449,7 +1450,7 @@ vget(vp, flags, p) if ((flags & LK_INTERLOCK) == 0) mtx_lock(&vp->v_interlock); if (vp->v_flag & VXLOCK) { - if (vp->v_vxproc == curproc) { + if (vp->v_vxproc == curthread) { printf("VXLOCK interlock avoided\n"); } else { vp->v_flag |= VXWANT; @@ -1464,7 +1465,7 @@ vget(vp, flags, p) if (VSHOULDBUSY(vp)) vbusy(vp); if (flags & LK_TYPE_MASK) { - if ((error = vn_lock(vp, flags | LK_INTERLOCK, p)) != 0) { + if ((error = vn_lock(vp, flags | LK_INTERLOCK, td)) != 0) { /* * must expand vrele here because we do not want * to call VOP_INACTIVE if the reference count @@ -1504,7 +1505,7 @@ void vrele(vp) struct vnode *vp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ KASSERT(vp != NULL, ("vrele: null vp")); @@ -1532,8 +1533,8 @@ vrele(vp) * call VOP_INACTIVE with the node locked. So, in the case of * vrele, we explicitly lock the vnode before calling VOP_INACTIVE. */ - if (vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, p) == 0) { - VOP_INACTIVE(vp, p); + if (vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, td) == 0) { + VOP_INACTIVE(vp, td); } } else { @@ -1554,7 +1555,7 @@ void vput(vp) struct vnode *vp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ GIANT_REQUIRED; @@ -1567,7 +1568,7 @@ vput(vp) if (vp->v_usecount > 1) { vp->v_usecount--; - VOP_UNLOCK(vp, LK_INTERLOCK, p); + VOP_UNLOCK(vp, LK_INTERLOCK, td); return; } @@ -1583,7 +1584,7 @@ vput(vp) * vrele, we explicitly lock the vnode before calling VOP_INACTIVE. */ mtx_unlock(&vp->v_interlock); - VOP_INACTIVE(vp, p); + VOP_INACTIVE(vp, td); } else { #ifdef DIAGNOSTIC @@ -1659,7 +1660,7 @@ vflush(mp, rootrefs, flags) int rootrefs; int flags; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct vnode *vp, *nvp, *rootvp = NULL; int busy = 0, error; @@ -1711,7 +1712,7 @@ loop: * vnode data structures and we are done. */ if (vp->v_usecount == 0) { - vgonel(vp, p); + vgonel(vp, td); mtx_lock(&mntvnode_mtx); continue; } @@ -1723,9 +1724,9 @@ loop: */ if (flags & FORCECLOSE) { if (vp->v_type != VCHR) { - vgonel(vp, p); + vgonel(vp, td); } else { - vclean(vp, 0, p); + vclean(vp, 0, td); vp->v_op = spec_vnodeop_p; insmntque(vp, (struct mount *) 0); } @@ -1750,7 +1751,7 @@ loop: KASSERT(busy > 0, ("vflush: not busy")); KASSERT(rootvp->v_usecount >= rootrefs, ("vflush: rootrefs")); if (busy == 1 && rootvp->v_usecount == rootrefs) { - vgonel(rootvp, p); + vgonel(rootvp, td); busy = 0; } else mtx_unlock(&rootvp->v_interlock); @@ -1766,10 +1767,10 @@ loop: * Disassociate the underlying file system from a vnode. */ static void -vclean(vp, flags, p) +vclean(vp, flags, td) struct vnode *vp; int flags; - struct proc *p; + struct thread *td; { int active; @@ -1788,7 +1789,7 @@ vclean(vp, flags, p) if (vp->v_flag & VXLOCK) panic("vclean: deadlock"); vp->v_flag |= VXLOCK; - vp->v_vxproc = curproc; + vp->v_vxproc = curthread; /* * Even if the count is zero, the VOP_INACTIVE routine may still * have the object locked while it cleans it out. The VOP_LOCK @@ -1796,7 +1797,7 @@ vclean(vp, flags, p) * For active vnodes, it ensures that no other activity can * occur while the underlying object is being cleaned out. */ - VOP_LOCK(vp, LK_DRAIN | LK_INTERLOCK, p); + VOP_LOCK(vp, LK_DRAIN | LK_INTERLOCK, td); /* * Clean out any buffers associated with the vnode. @@ -1805,8 +1806,8 @@ vclean(vp, flags, p) if (flags & DOCLOSE) { if (TAILQ_FIRST(&vp->v_dirtyblkhd) != NULL) (void) vn_write_suspend_wait(vp, NULL, V_WAIT); - if (vinvalbuf(vp, V_SAVE, NOCRED, p, 0, 0) != 0) - vinvalbuf(vp, 0, NOCRED, p, 0, 0); + if (vinvalbuf(vp, V_SAVE, NOCRED, td, 0, 0) != 0) + vinvalbuf(vp, 0, NOCRED, td, 0, 0); } VOP_DESTROYVOBJECT(vp); @@ -1818,19 +1819,19 @@ vclean(vp, flags, p) */ if (active) { if (flags & DOCLOSE) - VOP_CLOSE(vp, FNONBLOCK, NOCRED, p); - VOP_INACTIVE(vp, p); + VOP_CLOSE(vp, FNONBLOCK, NOCRED, td); + VOP_INACTIVE(vp, td); } else { /* * Any other processes trying to obtain this lock must first * wait for VXLOCK to clear, then call the new lock operation. */ - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); } /* * Reclaim the vnode. */ - if (VOP_RECLAIM(vp, p)) + if (VOP_RECLAIM(vp, td)) panic("vclean: cannot reclaim"); if (active) { @@ -1916,10 +1917,10 @@ vop_revoke(ap) * Release the passed interlock if the vnode will be recycled. */ int -vrecycle(vp, inter_lkp, p) +vrecycle(vp, inter_lkp, td) struct vnode *vp; struct mtx *inter_lkp; - struct proc *p; + struct thread *td; { mtx_lock(&vp->v_interlock); @@ -1927,7 +1928,7 @@ vrecycle(vp, inter_lkp, p) if (inter_lkp) { mtx_unlock(inter_lkp); } - vgonel(vp, p); + vgonel(vp, td); return (1); } mtx_unlock(&vp->v_interlock); @@ -1942,19 +1943,19 @@ void vgone(vp) register struct vnode *vp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ mtx_lock(&vp->v_interlock); - vgonel(vp, p); + vgonel(vp, td); } /* * vgone, with the vp interlock held. */ void -vgonel(vp, p) +vgonel(vp, td) struct vnode *vp; - struct proc *p; + struct thread *td; { int s; @@ -1972,7 +1973,7 @@ vgonel(vp, p) /* * Clean out the filesystem specific data. */ - vclean(vp, DOCLOSE, p); + vclean(vp, DOCLOSE, td); mtx_lock(&vp->v_interlock); /* @@ -2132,14 +2133,14 @@ vprint(label, vp) */ DB_SHOW_COMMAND(lockedvnodes, lockedvnodes) { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct mount *mp, *nmp; struct vnode *vp; printf("Locked vnodes\n"); mtx_lock(&mountlist_mtx); for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) { - if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, p)) { + if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) { nmp = TAILQ_NEXT(mp, mnt_list); continue; } @@ -2151,7 +2152,7 @@ DB_SHOW_COMMAND(lockedvnodes, lockedvnodes) mtx_unlock(&mntvnode_mtx); mtx_lock(&mountlist_mtx); nmp = TAILQ_NEXT(mp, mnt_list); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); } mtx_unlock(&mountlist_mtx); } @@ -2187,7 +2188,7 @@ vfs_sysctl(SYSCTL_HANDLER_ARGS) if (vfsp == NULL) return (EOPNOTSUPP); return ((*vfsp->vfc_vfsops->vfs_sysctl)(&name[1], namelen - 1, - oldp, oldlenp, newp, newlen, p)); + oldp, oldlenp, newp, newlen, td)); } #endif switch (name[1]) { @@ -2245,7 +2246,7 @@ sysctl_ovfs_conf(SYSCTL_HANDLER_ARGS) static int sysctl_vnode(SYSCTL_HANDLER_ARGS) { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct mount *mp, *nmp; struct vnode *nvp, *vp; int error; @@ -2260,7 +2261,7 @@ sysctl_vnode(SYSCTL_HANDLER_ARGS) mtx_lock(&mountlist_mtx); for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) { - if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, p)) { + if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) { nmp = TAILQ_NEXT(mp, mnt_list); continue; } @@ -2286,7 +2287,7 @@ again: mtx_unlock(&mntvnode_mtx); mtx_lock(&mountlist_mtx); nmp = TAILQ_NEXT(mp, mnt_list); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); } mtx_unlock(&mountlist_mtx); @@ -2323,19 +2324,19 @@ void vfs_unmountall() { struct mount *mp; - struct proc *p; + struct thread *td; int error; - if (curproc != NULL) - p = curproc; + if (curthread != NULL) + td = curthread; else - p = initproc; /* XXX XXX should this be proc0? */ + td = &initproc->p_thread; /* XXX XXX should this be proc0? */ /* * Since this only runs when rebooting, it is not interlocked. */ while(!TAILQ_EMPTY(&mountlist)) { mp = TAILQ_LAST(&mountlist, mntlist); - error = dounmount(mp, MNT_FORCE, p); + error = dounmount(mp, MNT_FORCE, td); if (error) { TAILQ_REMOVE(&mountlist, mp, mnt_list); printf("unmount of %s failed (", @@ -2394,7 +2395,7 @@ loop: if (VOP_GETVOBJECT(vp, &obj) == 0 && (obj->flags & OBJ_MIGHTBEDIRTY)) { if (!vget(vp, - LK_INTERLOCK | LK_EXCLUSIVE | LK_RETRY | LK_NOOBJ, curproc)) { + LK_INTERLOCK | LK_EXCLUSIVE | LK_RETRY | LK_NOOBJ, curthread)) { if (VOP_GETVOBJECT(vp, &obj) == 0) { vm_object_page_clean(obj, 0, 0, flags == MNT_WAIT ? @@ -2422,13 +2423,13 @@ loop: * vp must be locked when vfs_object_create is called. */ int -vfs_object_create(vp, p, cred) +vfs_object_create(vp, td, cred) struct vnode *vp; - struct proc *p; + struct thread *td; struct ucred *cred; { GIANT_REQUIRED; - return (VOP_CREATEVOBJECT(vp, cred, p)); + return (VOP_CREATEVOBJECT(vp, cred, td)); } /* @@ -2483,9 +2484,9 @@ vbusy(vp) * to avoid race conditions.) */ int -vn_pollrecord(vp, p, events) +vn_pollrecord(vp, td, events) struct vnode *vp; - struct proc *p; + struct thread *td; short events; { mtx_lock(&vp->v_pollinfo.vpi_lock); @@ -2504,7 +2505,7 @@ vn_pollrecord(vp, p, events) return events; } vp->v_pollinfo.vpi_events |= events; - selrecord(p, &vp->v_pollinfo.vpi_selinfo); + selrecord(td, &vp->v_pollinfo.vpi_selinfo); mtx_unlock(&vp->v_pollinfo.vpi_lock); return 0; } @@ -2640,12 +2641,12 @@ sync_fsync(ap) struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *syncvp = ap->a_vp; struct mount *mp = syncvp->v_mount; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; int asyncflag; /* @@ -2664,22 +2665,22 @@ sync_fsync(ap) * not already on the sync list. */ mtx_lock(&mountlist_mtx); - if (vfs_busy(mp, LK_EXCLUSIVE | LK_NOWAIT, &mountlist_mtx, p) != 0) { + if (vfs_busy(mp, LK_EXCLUSIVE | LK_NOWAIT, &mountlist_mtx, td) != 0) { mtx_unlock(&mountlist_mtx); return (0); } if (vn_start_write(NULL, &mp, V_NOWAIT) != 0) { - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); return (0); } asyncflag = mp->mnt_flag & MNT_ASYNC; mp->mnt_flag &= ~MNT_ASYNC; vfs_msync(mp, MNT_NOWAIT); - VFS_SYNC(mp, MNT_LAZY, ap->a_cred, p); + VFS_SYNC(mp, MNT_LAZY, ap->a_cred, td); if (asyncflag) mp->mnt_flag |= MNT_ASYNC; vn_finished_write(mp); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); return (0); } @@ -2690,7 +2691,7 @@ static int sync_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { @@ -2805,7 +2806,7 @@ NDFREE(ndp, flags) if (!(flags & NDF_NO_DVP_UNLOCK) && (ndp->ni_cnd.cn_flags & LOCKPARENT) && ndp->ni_dvp != ndp->ni_vp) - VOP_UNLOCK(ndp->ni_dvp, 0, ndp->ni_cnd.cn_proc); + VOP_UNLOCK(ndp->ni_dvp, 0, ndp->ni_cnd.cn_thread); if (!(flags & NDF_NO_DVP_RELE) && (ndp->ni_cnd.cn_flags & (LOCKPARENT|WANTPARENT))) { vrele(ndp->ni_dvp); @@ -2813,7 +2814,7 @@ NDFREE(ndp, flags) } if (!(flags & NDF_NO_VP_UNLOCK) && (ndp->ni_cnd.cn_flags & LOCKLEAF) && ndp->ni_vp) - VOP_UNLOCK(ndp->ni_vp, 0, ndp->ni_cnd.cn_proc); + VOP_UNLOCK(ndp->ni_vp, 0, ndp->ni_cnd.cn_thread); if (!(flags & NDF_NO_VP_RELE) && ndp->ni_vp) { vrele(ndp->ni_vp); diff --git a/sys/kern/vfs_syscalls.c b/sys/kern/vfs_syscalls.c index bb39292..4e05b8d 100644 --- a/sys/kern/vfs_syscalls.c +++ b/sys/kern/vfs_syscalls.c @@ -75,18 +75,18 @@ #include <vm/vm_zone.h> #include <vm/vm_page.h> -static int change_dir __P((struct nameidata *ndp, struct proc *p)); +static int change_dir __P((struct nameidata *ndp, struct thread *td)); static void checkdirs __P((struct vnode *olddp, struct vnode *newdp)); static int chroot_refuse_vdir_fds __P((struct filedesc *fdp)); static int getutimes __P((const struct timeval *, struct timespec *)); -static int setfown __P((struct proc *, struct vnode *, uid_t, gid_t)); -static int setfmode __P((struct proc *, struct vnode *, int)); -static int setfflags __P((struct proc *, struct vnode *, int)); -static int setutimes __P((struct proc *, struct vnode *, +static int setfown __P((struct thread *td, struct vnode *, uid_t, gid_t)); +static int setfmode __P((struct thread *td, struct vnode *, int)); +static int setfflags __P((struct thread *td, struct vnode *, int)); +static int setutimes __P((struct thread *td, struct vnode *, const struct timespec *, int)); static int usermount = 0; /* if 1, non-root can mount fs. */ -int (*union_dircheckp) __P((struct proc *, struct vnode **, struct file *)); +int (*union_dircheckp) __P((struct thread *td, struct vnode **, struct file *)); SYSCTL_INT(_vfs, OID_AUTO, usermount, CTLFLAG_RW, &usermount, 0, ""); @@ -107,8 +107,8 @@ struct mount_args { #endif /* ARGSUSED */ int -mount(p, uap) - struct proc *p; +mount(td, uap) + struct thread *td; struct mount_args /* { syscallarg(char *) type; syscallarg(char *) path; @@ -133,7 +133,7 @@ mount(p, uap) error = copyinstr(SCARG(uap, path), fspath, MNAMELEN, NULL); if (error) goto finish; - error = vfs_mount(p, fstype, fspath, SCARG(uap, flags), + error = vfs_mount(td, fstype, fspath, SCARG(uap, flags), SCARG(uap, data)); finish: free(fstype, M_TEMP); @@ -150,8 +150,8 @@ finish: * into userspace. */ int -vfs_mount(p, fstype, fspath, fsflags, fsdata) - struct proc *p; +vfs_mount(td, fstype, fspath, fsflags, fsdata) + struct thread *td; const char *fstype; char *fspath; int fsflags; @@ -163,6 +163,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) int error, flag = 0, flag2 = 0; struct vattr va; struct nameidata nd; + struct proc *p = td->td_proc; /* * Be ultra-paranoid about making sure the type and fspath @@ -173,13 +174,13 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) (strlen(fspath) >= MNAMELEN - 1)) return (ENAMETOOLONG); - if (usermount == 0 && (error = suser(p))) + if (usermount == 0 && (error = suser_td(td))) return (error); /* * Do not allow NFS export by non-root users. */ if (fsflags & MNT_EXPORTED) { - error = suser(p); + error = suser_td(td); if (error) return (error); } @@ -191,7 +192,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) /* * Get vnode to be covered */ - NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspath, p); + NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspath, td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); @@ -218,11 +219,11 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) * permitted to update it. */ if (mp->mnt_stat.f_owner != p->p_ucred->cr_uid && - (error = suser(p))) { + (error = suser_td(td))) { vput(vp); return (error); } - if (vfs_busy(mp, LK_NOWAIT, 0, p)) { + if (vfs_busy(mp, LK_NOWAIT, 0, td)) { vput(vp); return (EBUSY); } @@ -230,7 +231,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) if ((vp->v_flag & VMOUNT) != 0 || vp->v_mountedhere != NULL) { mtx_unlock(&vp->v_interlock); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); vput(vp); return (EBUSY); } @@ -238,20 +239,20 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) mtx_unlock(&vp->v_interlock); mp->mnt_flag |= fsflags & (MNT_RELOAD | MNT_FORCE | MNT_UPDATE | MNT_SNAPSHOT); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); goto update; } /* * If the user is not root, ensure that they own the directory * onto which we are attempting to mount. */ - if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) || + if ((error = VOP_GETATTR(vp, &va, p->p_ucred, td)) || (va.va_uid != p->p_ucred->cr_uid && - (error = suser(p)))) { + (error = suser_td(td)))) { vput(vp); return (error); } - if ((error = vinvalbuf(vp, V_SAVE, p->p_ucred, p, 0, 0)) != 0) { + if ((error = vinvalbuf(vp, V_SAVE, p->p_ucred, td, 0, 0)) != 0) { vput(vp); return (error); } @@ -266,7 +267,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) linker_file_t lf; /* Only load modules for root (very important!) */ - if ((error = suser(p)) != 0) { + if ((error = suser_td(td)) != 0) { vput(vp); return error; } @@ -304,7 +305,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) */ mp = malloc(sizeof(struct mount), M_MOUNT, M_WAITOK | M_ZERO); lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, LK_NOPAUSE); - (void)vfs_busy(mp, LK_NOWAIT, 0, p); + (void)vfs_busy(mp, LK_NOWAIT, 0, td); mp->mnt_op = vfsp->vfc_vfsops; mp->mnt_vfc = vfsp; vfsp->vfc_refcount++; @@ -317,7 +318,7 @@ vfs_mount(p, fstype, fspath, fsflags, fsdata) strncpy(mp->mnt_stat.f_mntonname, fspath, MNAMELEN); mp->mnt_stat.f_mntonname[MNAMELEN - 1] = '\0'; mp->mnt_iosize_max = DFLTPHYS; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); update: /* * Set the mount level flags. @@ -339,7 +340,7 @@ update: * XXX The final recipients of VFS_MOUNT just overwrite the ndp they * get. No freeing of cn_pnbuf. */ - error = VFS_MOUNT(mp, fspath, fsdata, &nd, p); + error = VFS_MOUNT(mp, fspath, fsdata, &nd, td); if (mp->mnt_flag & MNT_UPDATE) { if (mp->mnt_kern_flag & MNTK_WANTRDWR) mp->mnt_flag &= ~MNT_RDONLY; @@ -358,14 +359,14 @@ update: vrele(mp->mnt_syncer); mp->mnt_syncer = NULL; } - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); mtx_lock(&vp->v_interlock); vp->v_flag &= ~VMOUNT; mtx_unlock(&vp->v_interlock); vrele(vp); return (error); } - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); /* * Put the new filesystem on the mount list after root. */ @@ -384,18 +385,18 @@ update: panic("mount: lost mount"); checkdirs(vp, newdp); vput(newdp); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if ((mp->mnt_flag & MNT_RDONLY) == 0) error = vfs_allocate_syncvnode(mp); - vfs_unbusy(mp, p); - if ((error = VFS_START(mp, 0, p)) != 0) + vfs_unbusy(mp, td); + if ((error = VFS_START(mp, 0, td)) != 0) vrele(vp); } else { mtx_lock(&vp->v_interlock); vp->v_flag &= ~VMOUNT; mtx_unlock(&vp->v_interlock); mp->mnt_vfc->vfc_refcount--; - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); free((caddr_t)mp, M_MOUNT); vput(vp); } @@ -454,8 +455,8 @@ struct unmount_args { #endif /* ARGSUSED */ int -unmount(p, uap) - struct proc *p; +unmount(td, uap) + struct thread *td; register struct unmount_args /* { syscallarg(char *) path; syscallarg(int) flags; @@ -467,7 +468,7 @@ unmount(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -478,8 +479,8 @@ unmount(p, uap) * Only root, or the user that did the original mount is * permitted to unmount this filesystem. */ - if ((mp->mnt_stat.f_owner != p->p_ucred->cr_uid) && - (error = suser(p))) { + if ((mp->mnt_stat.f_owner != td->td_proc->p_ucred->cr_uid) && + (error = suser_td(td))) { vput(vp); return (error); } @@ -500,17 +501,17 @@ unmount(p, uap) return (EINVAL); } vput(vp); - return (dounmount(mp, SCARG(uap, flags), p)); + return (dounmount(mp, SCARG(uap, flags), td)); } /* * Do the actual file system unmount. */ int -dounmount(mp, flags, p) +dounmount(mp, flags, td) struct mount *mp; int flags; - struct proc *p; + struct thread *td; { struct vnode *coveredvp, *fsrootvp; int error; @@ -518,7 +519,7 @@ dounmount(mp, flags, p) mtx_lock(&mountlist_mtx); mp->mnt_kern_flag |= MNTK_UNMOUNT; - lockmgr(&mp->mnt_lock, LK_DRAIN | LK_INTERLOCK, &mountlist_mtx, p); + lockmgr(&mp->mnt_lock, LK_DRAIN | LK_INTERLOCK, &mountlist_mtx, td); vn_start_write(NULL, &mp, V_WAIT); if (mp->mnt_flag & MNT_EXPUBLIC) @@ -541,9 +542,9 @@ dounmount(mp, flags, p) vput(fsrootvp); } if (((mp->mnt_flag & MNT_RDONLY) || - (error = VFS_SYNC(mp, MNT_WAIT, p->p_ucred, p)) == 0) || + (error = VFS_SYNC(mp, MNT_WAIT, td->td_proc->p_ucred, td)) == 0) || (flags & MNT_FORCE)) { - error = VFS_UNMOUNT(mp, flags, p); + error = VFS_UNMOUNT(mp, flags, td); } vn_finished_write(mp); if (error) { @@ -563,7 +564,7 @@ dounmount(mp, flags, p) mp->mnt_kern_flag &= ~MNTK_UNMOUNT; mp->mnt_flag |= async_flag; lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK, - &mountlist_mtx, p); + &mountlist_mtx, td); if (mp->mnt_kern_flag & MNTK_MWAIT) wakeup((caddr_t)mp); return (error); @@ -575,7 +576,7 @@ dounmount(mp, flags, p) mp->mnt_vfc->vfc_refcount--; if (!LIST_EMPTY(&mp->mnt_vnodelist)) panic("unmount: dangling vnode"); - lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK, &mountlist_mtx, p); + lockmgr(&mp->mnt_lock, LK_RELEASE | LK_INTERLOCK, &mountlist_mtx, td); lockdestroy(&mp->mnt_lock); if (coveredvp != NULL) vrele(coveredvp); @@ -601,8 +602,8 @@ SYSCTL_INT(_debug, OID_AUTO, syncprt, CTLFLAG_RW, &syncprt, 0, ""); /* ARGSUSED */ int -sync(p, uap) - struct proc *p; +sync(td, uap) + struct thread *td; struct sync_args *uap; { struct mount *mp, *nmp; @@ -610,7 +611,7 @@ sync(p, uap) mtx_lock(&mountlist_mtx); for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) { - if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, p)) { + if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) { nmp = TAILQ_NEXT(mp, mnt_list); continue; } @@ -620,13 +621,13 @@ sync(p, uap) mp->mnt_flag &= ~MNT_ASYNC; vfs_msync(mp, MNT_NOWAIT); VFS_SYNC(mp, MNT_NOWAIT, - ((p != NULL) ? p->p_ucred : NOCRED), p); + ((td != NULL) ? td->td_proc->p_ucred : NOCRED), td); mp->mnt_flag |= asyncflag; vn_finished_write(mp); } mtx_lock(&mountlist_mtx); nmp = TAILQ_NEXT(mp, mnt_list); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); } mtx_unlock(&mountlist_mtx); #if 0 @@ -661,8 +662,8 @@ struct quotactl_args { #endif /* ARGSUSED */ int -quotactl(p, uap) - struct proc *p; +quotactl(td, uap) + struct thread *td; register struct quotactl_args /* { syscallarg(char *) path; syscallarg(int) cmd; @@ -674,9 +675,9 @@ quotactl(p, uap) int error; struct nameidata nd; - if (jailed(p->p_ucred) && !prison_quotas) + if (jailed(td->td_proc->p_ucred) && !prison_quotas) return (EPERM); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); @@ -685,7 +686,7 @@ quotactl(p, uap) if (error) return (error); error = VFS_QUOTACTL(mp, SCARG(uap, cmd), SCARG(uap, uid), - SCARG(uap, arg), p); + SCARG(uap, arg), td); vn_finished_write(mp); return (error); } @@ -701,8 +702,8 @@ struct statfs_args { #endif /* ARGSUSED */ int -statfs(p, uap) - struct proc *p; +statfs(td, uap) + struct thread *td; register struct statfs_args /* { syscallarg(char *) path; syscallarg(struct statfs *) buf; @@ -714,18 +715,18 @@ statfs(p, uap) struct nameidata nd; struct statfs sb; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); mp = nd.ni_vp->v_mount; sp = &mp->mnt_stat; NDFREE(&nd, NDF_ONLY_PNBUF); vrele(nd.ni_vp); - error = VFS_STATFS(mp, sp, p); + error = VFS_STATFS(mp, sp, td); if (error) return (error); sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; - if (suser_xxx(p->p_ucred, 0, 0)) { + if (suser_xxx(td->td_proc->p_ucred, 0, 0)) { bcopy((caddr_t)sp, (caddr_t)&sb, sizeof(sb)); sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0; sp = &sb; @@ -744,8 +745,8 @@ struct fstatfs_args { #endif /* ARGSUSED */ int -fstatfs(p, uap) - struct proc *p; +fstatfs(td, uap) + struct thread *td; register struct fstatfs_args /* { syscallarg(int) fd; syscallarg(struct statfs *) buf; @@ -757,15 +758,15 @@ fstatfs(p, uap) int error; struct statfs sb; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); mp = ((struct vnode *)fp->f_data)->v_mount; sp = &mp->mnt_stat; - error = VFS_STATFS(mp, sp, p); + error = VFS_STATFS(mp, sp, td); if (error) return (error); sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; - if (suser_xxx(p->p_ucred, 0, 0)) { + if (suser_xxx(td->td_proc->p_ucred, 0, 0)) { bcopy((caddr_t)sp, (caddr_t)&sb, sizeof(sb)); sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0; sp = &sb; @@ -784,8 +785,8 @@ struct getfsstat_args { }; #endif int -getfsstat(p, uap) - struct proc *p; +getfsstat(td, uap) + struct thread *td; register struct getfsstat_args /* { syscallarg(struct statfs *) buf; syscallarg(long) bufsize; @@ -802,7 +803,7 @@ getfsstat(p, uap) count = 0; mtx_lock(&mountlist_mtx); for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) { - if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, p)) { + if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) { nmp = TAILQ_NEXT(mp, mnt_list); continue; } @@ -815,16 +816,16 @@ getfsstat(p, uap) */ if (((SCARG(uap, flags) & (MNT_LAZY|MNT_NOWAIT)) == 0 || (SCARG(uap, flags) & MNT_WAIT)) && - (error = VFS_STATFS(mp, sp, p))) { + (error = VFS_STATFS(mp, sp, td))) { mtx_lock(&mountlist_mtx); nmp = TAILQ_NEXT(mp, mnt_list); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); continue; } sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; error = copyout((caddr_t)sp, sfsp, sizeof(*sp)); if (error) { - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); return (error); } sfsp += sizeof(*sp); @@ -832,13 +833,13 @@ getfsstat(p, uap) count++; mtx_lock(&mountlist_mtx); nmp = TAILQ_NEXT(mp, mnt_list); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); } mtx_unlock(&mountlist_mtx); if (sfsp && count > maxcount) - p->p_retval[0] = maxcount; + td->td_retval[0] = maxcount; else - p->p_retval[0] = count; + td->td_retval[0] = count; return (0); } @@ -852,13 +853,13 @@ struct fchdir_args { #endif /* ARGSUSED */ int -fchdir(p, uap) - struct proc *p; +fchdir(td, uap) + struct thread *td; struct fchdir_args /* { syscallarg(int) fd; } */ *uap; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; struct vnode *vp, *tdp; struct mount *mp; struct file *fp; @@ -868,16 +869,16 @@ fchdir(p, uap) return (error); vp = (struct vnode *)fp->f_data; VREF(vp); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (vp->v_type != VDIR) error = ENOTDIR; else - error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); + error = VOP_ACCESS(vp, VEXEC, td->td_proc->p_ucred, td); while (!error && (mp = vp->v_mountedhere) != NULL) { - if (vfs_busy(mp, 0, 0, p)) + if (vfs_busy(mp, 0, 0, td)) continue; error = VFS_ROOT(mp, &tdp); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); if (error) break; vput(vp); @@ -887,7 +888,7 @@ fchdir(p, uap) vput(vp); return (error); } - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vrele(fdp->fd_cdir); fdp->fd_cdir = vp; return (0); @@ -903,19 +904,19 @@ struct chdir_args { #endif /* ARGSUSED */ int -chdir(p, uap) - struct proc *p; +chdir(td, uap) + struct thread *td; struct chdir_args /* { syscallarg(char *) path; } */ *uap; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; int error; struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, path), p); - if ((error = change_dir(&nd, p)) != 0) + SCARG(uap, path), td); + if ((error = change_dir(&nd, td)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); vrele(fdp->fd_cdir); @@ -971,17 +972,17 @@ struct chroot_args { #endif /* ARGSUSED */ int -chroot(p, uap) - struct proc *p; +chroot(td, uap) + struct thread *td; struct chroot_args /* { syscallarg(char *) path; } */ *uap; { - register struct filedesc *fdp = p->p_fd; + register struct filedesc *fdp = td->td_proc->p_fd; int error; struct nameidata nd; - error = suser_xxx(0, p, PRISON_ROOT); + error = suser_xxx(0, td->td_proc, PRISON_ROOT); if (error) return (error); if (chroot_allow_open_directories == 0 || @@ -990,8 +991,8 @@ chroot(p, uap) if (error) return (error); NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, path), p); - if ((error = change_dir(&nd, p)) != 0) + SCARG(uap, path), td); + if ((error = change_dir(&nd, td)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); vrele(fdp->fd_rdir); @@ -1007,9 +1008,9 @@ chroot(p, uap) * Common routine for chroot and chdir. */ static int -change_dir(ndp, p) +change_dir(ndp, td) register struct nameidata *ndp; - struct proc *p; + struct thread *td; { struct vnode *vp; int error; @@ -1021,11 +1022,11 @@ change_dir(ndp, p) if (vp->v_type != VDIR) error = ENOTDIR; else - error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); + error = VOP_ACCESS(vp, VEXEC, td->td_proc->p_ucred, td); if (error) vput(vp); else - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); return (error); } @@ -1041,14 +1042,15 @@ struct open_args { }; #endif int -open(p, uap) - struct proc *p; +open(td, uap) + struct thread *td; register struct open_args /* { syscallarg(char *) path; syscallarg(int) flags; syscallarg(int) mode; } */ *uap; { + struct proc *p = td->td_proc; struct filedesc *fdp = p->p_fd; struct file *fp; struct vnode *vp; @@ -1064,13 +1066,13 @@ open(p, uap) if ((oflags & O_ACCMODE) == O_ACCMODE) return (EINVAL); flags = FFLAGS(oflags); - error = falloc(p, &nfp, &indx); + error = falloc(td, &nfp, &indx); if (error) return (error); fp = nfp; cmode = ((SCARG(uap, mode) &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); - p->p_dupfd = -indx - 1; /* XXX check for fdopen */ + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); + td->td_dupfd = -indx - 1; /* XXX check for fdopen */ /* * Bump the ref count to prevent another process from closing * the descriptor while we are blocked in vn_open() @@ -1081,7 +1083,7 @@ open(p, uap) /* * release our own reference */ - fdrop(fp, p); + fdrop(fp, td); /* * handle special fdopen() case. bleh. dupfdopen() is @@ -1089,10 +1091,10 @@ open(p, uap) * if it succeeds. */ if ((error == ENODEV || error == ENXIO) && - p->p_dupfd >= 0 && /* XXX from fdopen */ + td->td_dupfd >= 0 && /* XXX from fdopen */ (error = - dupfdopen(p, fdp, indx, p->p_dupfd, flags, error)) == 0) { - p->p_retval[0] = indx; + dupfdopen(td, fdp, indx, td->td_dupfd, flags, error)) == 0) { + td->td_retval[0] = indx; return (0); } /* @@ -1101,14 +1103,14 @@ open(p, uap) */ if (fdp->fd_ofiles[indx] == fp) { fdp->fd_ofiles[indx] = NULL; - fdrop(fp, p); + fdrop(fp, td); } if (error == ERESTART) error = EINTR; return (error); } - p->p_dupfd = 0; + td->td_dupfd = 0; NDFREE(&nd, NDF_ONLY_PNBUF); vp = nd.ni_vp; @@ -1123,10 +1125,10 @@ open(p, uap) if (fp->f_count == 1) { KASSERT(fdp->fd_ofiles[indx] != fp, ("Open file descriptor lost all refs")); - VOP_UNLOCK(vp, 0, p); - vn_close(vp, flags & FMASK, fp->f_cred, p); - fdrop(fp, p); - p->p_retval[0] = indx; + VOP_UNLOCK(vp, 0, td); + vn_close(vp, flags & FMASK, fp->f_cred, td); + fdrop(fp, td); + td->td_retval[0] = indx; return 0; } @@ -1134,7 +1136,7 @@ open(p, uap) fp->f_flag = flags & FMASK; fp->f_ops = &vnops; fp->f_type = (vp->v_type == VFIFO ? DTYPE_FIFO : DTYPE_VNODE); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (flags & (O_EXLOCK | O_SHLOCK)) { lf.l_whence = SEEK_SET; lf.l_start = 0; @@ -1153,12 +1155,12 @@ open(p, uap) if (flags & O_TRUNC) { if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) goto bad; - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(vp, td, p->p_ucred, LEASE_WRITE); VATTR_NULL(&vat); vat.va_size = 0; - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_SETATTR(vp, &vat, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_SETATTR(vp, &vat, p->p_ucred, td); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); if (error) goto bad; @@ -1170,15 +1172,15 @@ open(p, uap) * Release our private reference, leaving the one associated with * the descriptor table intact. */ - fdrop(fp, p); - p->p_retval[0] = indx; + fdrop(fp, td); + td->td_retval[0] = indx; return (0); bad: if (fdp->fd_ofiles[indx] == fp) { fdp->fd_ofiles[indx] = NULL; - fdrop(fp, p); + fdrop(fp, td); } - fdrop(fp, p); + fdrop(fp, td); return (error); } @@ -1193,8 +1195,8 @@ struct ocreat_args { }; #endif int -ocreat(p, uap) - struct proc *p; +ocreat(td, uap) + struct thread *td; register struct ocreat_args /* { syscallarg(char *) path; syscallarg(int) mode; @@ -1209,7 +1211,7 @@ ocreat(p, uap) SCARG(&nuap, path) = SCARG(uap, path); SCARG(&nuap, mode) = SCARG(uap, mode); SCARG(&nuap, flags) = O_WRONLY | O_CREAT | O_TRUNC; - return (open(p, &nuap)); + return (open(td, &nuap)); } #endif /* COMPAT_43 */ @@ -1225,8 +1227,8 @@ struct mknod_args { #endif /* ARGSUSED */ int -mknod(p, uap) - struct proc *p; +mknod(td, uap) + struct thread *td; register struct mknod_args /* { syscallarg(char *) path; syscallarg(int) mode; @@ -1243,17 +1245,17 @@ mknod(p, uap) switch (SCARG(uap, mode) & S_IFMT) { case S_IFCHR: case S_IFBLK: - error = suser(p); + error = suser_td(td); break; default: - error = suser_xxx(0, p, PRISON_ROOT); + error = suser_xxx(0, td->td_proc, PRISON_ROOT); break; } if (error) return (error); restart: bwillwrite(); - NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -1262,7 +1264,7 @@ restart: error = EEXIST; } else { VATTR_NULL(&vattr); - vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ p->p_fd->fd_cmask; + vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ td->td_proc->p_fd->fd_cmask; vattr.va_rdev = SCARG(uap, dev); whiteout = 0; @@ -1292,7 +1294,7 @@ restart: goto restart; } if (!error) { - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); if (whiteout) error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, CREATE); else { @@ -1321,8 +1323,8 @@ struct mkfifo_args { #endif /* ARGSUSED */ int -mkfifo(p, uap) - struct proc *p; +mkfifo(td, uap) + struct thread *td; register struct mkfifo_args /* { syscallarg(char *) path; syscallarg(int) mode; @@ -1335,7 +1337,7 @@ mkfifo(p, uap) restart: bwillwrite(); - NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); if (nd.ni_vp != NULL) { @@ -1353,8 +1355,8 @@ restart: } VATTR_NULL(&vattr); vattr.va_type = VFIFO; - vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ p->p_fd->fd_cmask; - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ td->td_proc->p_fd->fd_cmask; + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); if (error == 0) vput(nd.ni_vp); @@ -1375,8 +1377,8 @@ struct link_args { #endif /* ARGSUSED */ int -link(p, uap) - struct proc *p; +link(td, uap) + struct thread *td; register struct link_args /* { syscallarg(char *) path; syscallarg(char *) link; @@ -1388,7 +1390,7 @@ link(p, uap) int error; bwillwrite(); - NDINIT(&nd, LOOKUP, FOLLOW|NOOBJ, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW|NOOBJ, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); @@ -1401,14 +1403,14 @@ link(p, uap) vrele(vp); return (error); } - NDINIT(&nd, CREATE, LOCKPARENT|NOOBJ, UIO_USERSPACE, SCARG(uap, link), p); + NDINIT(&nd, CREATE, LOCKPARENT|NOOBJ, UIO_USERSPACE, SCARG(uap, link), td); if ((error = namei(&nd)) == 0) { if (nd.ni_vp != NULL) { vrele(nd.ni_vp); error = EEXIST; } else { - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd); } NDFREE(&nd, NDF_ONLY_PNBUF); @@ -1432,8 +1434,8 @@ struct symlink_args { #endif /* ARGSUSED */ int -symlink(p, uap) - struct proc *p; +symlink(td, uap) + struct thread *td; register struct symlink_args /* { syscallarg(char *) path; syscallarg(char *) link; @@ -1450,7 +1452,7 @@ symlink(p, uap) goto out; restart: bwillwrite(); - NDINIT(&nd, CREATE, LOCKPARENT|NOOBJ, UIO_USERSPACE, SCARG(uap, link), p); + NDINIT(&nd, CREATE, LOCKPARENT|NOOBJ, UIO_USERSPACE, SCARG(uap, link), td); if ((error = namei(&nd)) != 0) goto out; if (nd.ni_vp) { @@ -1468,8 +1470,8 @@ restart: goto restart; } VATTR_NULL(&vattr); - vattr.va_mode = ACCESSPERMS &~ p->p_fd->fd_cmask; - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + vattr.va_mode = ACCESSPERMS &~ td->td_proc->p_fd->fd_cmask; + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, path); NDFREE(&nd, NDF_ONLY_PNBUF); if (error == 0) @@ -1488,8 +1490,8 @@ out: */ /* ARGSUSED */ int -undelete(p, uap) - struct proc *p; +undelete(td, uap) + struct thread *td; register struct undelete_args /* { syscallarg(char *) path; } */ *uap; @@ -1501,7 +1503,7 @@ undelete(p, uap) restart: bwillwrite(); NDINIT(&nd, DELETE, LOCKPARENT|DOWHITEOUT, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); error = namei(&nd); if (error) return (error); @@ -1520,7 +1522,7 @@ restart: return (error); goto restart; } - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_WHITEOUT(nd.ni_dvp, &nd.ni_cnd, DELETE); NDFREE(&nd, NDF_ONLY_PNBUF); vput(nd.ni_dvp); @@ -1540,8 +1542,8 @@ struct unlink_args { #endif /* ARGSUSED */ int -unlink(p, uap) - struct proc *p; +unlink(td, uap) + struct thread *td; struct unlink_args /* { syscallarg(char *) path; } */ *uap; @@ -1553,7 +1555,7 @@ unlink(p, uap) restart: bwillwrite(); - NDINIT(&nd, DELETE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, DELETE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -1576,10 +1578,10 @@ restart: return (error); goto restart; } - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (!error) { - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_REMOVE(nd.ni_dvp, vp, &nd.ni_cnd); } NDFREE(&nd, NDF_ONLY_PNBUF); @@ -1603,8 +1605,8 @@ struct lseek_args { }; #endif int -lseek(p, uap) - struct proc *p; +lseek(td, uap) + struct thread *td; register struct lseek_args /* { syscallarg(int) fd; syscallarg(int) pad; @@ -1612,8 +1614,8 @@ lseek(p, uap) syscallarg(int) whence; } */ *uap; { - struct ucred *cred = p->p_ucred; - register struct filedesc *fdp = p->p_fd; + struct ucred *cred = td->td_proc->p_ucred; + register struct filedesc *fdp = td->td_proc->p_fd; register struct file *fp; struct vattr vattr; struct vnode *vp; @@ -1637,7 +1639,7 @@ lseek(p, uap) offset += fp->f_offset; break; case L_XTND: - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); if (noneg && @@ -1654,7 +1656,7 @@ lseek(p, uap) if (noneg && offset < 0) return (EINVAL); fp->f_offset = offset; - *(off_t *)(p->p_retval) = fp->f_offset; + *(off_t *)(td->td_retval) = fp->f_offset; return (0); } @@ -1670,8 +1672,8 @@ struct olseek_args { }; #endif int -olseek(p, uap) - struct proc *p; +olseek(td, uap) + struct thread *td; register struct olseek_args /* { syscallarg(int) fd; syscallarg(long) offset; @@ -1689,7 +1691,7 @@ olseek(p, uap) SCARG(&nuap, fd) = SCARG(uap, fd); SCARG(&nuap, offset) = SCARG(uap, offset); SCARG(&nuap, whence) = SCARG(uap, whence); - error = lseek(p, &nuap); + error = lseek(td, &nuap); return (error); } #endif /* COMPAT_43 */ @@ -1704,8 +1706,8 @@ struct access_args { }; #endif int -access(p, uap) - struct proc *p; +access(td, uap) + struct thread *td; register struct access_args /* { syscallarg(char *) path; syscallarg(int) flags; @@ -1716,7 +1718,7 @@ access(p, uap) int error, flags; struct nameidata nd; - cred = p->p_ucred; + cred = td->td_proc->p_ucred; /* * Create and modify a temporary credential instead of one that * is potentially shared. This could also mess up socket @@ -1729,9 +1731,9 @@ access(p, uap) tmpcred = crdup(cred); tmpcred->cr_uid = cred->cr_ruid; tmpcred->cr_groups[0] = cred->cr_rgid; - p->p_ucred = tmpcred; + td->td_proc->p_ucred = tmpcred; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) goto out1; vp = nd.ni_vp; @@ -1746,12 +1748,12 @@ access(p, uap) if (SCARG(uap, flags) & X_OK) flags |= VEXEC; if ((flags & VWRITE) == 0 || (error = vn_writechk(vp)) == 0) - error = VOP_ACCESS(vp, flags, tmpcred, p); + error = VOP_ACCESS(vp, flags, tmpcred, td); } NDFREE(&nd, NDF_ONLY_PNBUF); vput(vp); out1: - p->p_ucred = cred; + td->td_proc->p_ucred = cred; crfree(tmpcred); return (error); } @@ -1768,8 +1770,8 @@ struct ostat_args { #endif /* ARGSUSED */ int -ostat(p, uap) - struct proc *p; +ostat(td, uap) + struct thread *td; register struct ostat_args /* { syscallarg(char *) path; syscallarg(struct ostat *) ub; @@ -1781,11 +1783,11 @@ ostat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = vn_stat(nd.ni_vp, &sb, p); + error = vn_stat(nd.ni_vp, &sb, td); vput(nd.ni_vp); if (error) return (error); @@ -1805,8 +1807,8 @@ struct olstat_args { #endif /* ARGSUSED */ int -olstat(p, uap) - struct proc *p; +olstat(td, uap) + struct thread *td; register struct olstat_args /* { syscallarg(char *) path; syscallarg(struct ostat *) ub; @@ -1819,11 +1821,11 @@ olstat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; - error = vn_stat(vp, &sb, p); + error = vn_stat(vp, &sb, td); NDFREE(&nd, NDF_ONLY_PNBUF); vput(vp); if (error) @@ -1874,8 +1876,8 @@ struct stat_args { #endif /* ARGSUSED */ int -stat(p, uap) - struct proc *p; +stat(td, uap) + struct thread *td; register struct stat_args /* { syscallarg(char *) path; syscallarg(struct stat *) ub; @@ -1886,10 +1888,10 @@ stat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); - error = vn_stat(nd.ni_vp, &sb, p); + error = vn_stat(nd.ni_vp, &sb, td); NDFREE(&nd, NDF_ONLY_PNBUF); vput(nd.ni_vp); if (error) @@ -1909,8 +1911,8 @@ struct lstat_args { #endif /* ARGSUSED */ int -lstat(p, uap) - struct proc *p; +lstat(td, uap) + struct thread *td; register struct lstat_args /* { syscallarg(char *) path; syscallarg(struct stat *) ub; @@ -1922,11 +1924,11 @@ lstat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; - error = vn_stat(vp, &sb, p); + error = vn_stat(vp, &sb, td); NDFREE(&nd, NDF_ONLY_PNBUF); vput(vp); if (error) @@ -1974,8 +1976,8 @@ struct nstat_args { #endif /* ARGSUSED */ int -nstat(p, uap) - struct proc *p; +nstat(td, uap) + struct thread *td; register struct nstat_args /* { syscallarg(char *) path; syscallarg(struct nstat *) ub; @@ -1987,11 +1989,11 @@ nstat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = vn_stat(nd.ni_vp, &sb, p); + error = vn_stat(nd.ni_vp, &sb, td); vput(nd.ni_vp); if (error) return (error); @@ -2011,8 +2013,8 @@ struct lstat_args { #endif /* ARGSUSED */ int -nlstat(p, uap) - struct proc *p; +nlstat(td, uap) + struct thread *td; register struct nlstat_args /* { syscallarg(char *) path; syscallarg(struct nstat *) ub; @@ -2025,12 +2027,12 @@ nlstat(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; NDFREE(&nd, NDF_ONLY_PNBUF); - error = vn_stat(vp, &sb, p); + error = vn_stat(vp, &sb, td); vput(vp); if (error) return (error); @@ -2050,8 +2052,8 @@ struct pathconf_args { #endif /* ARGSUSED */ int -pathconf(p, uap) - struct proc *p; +pathconf(td, uap) + struct thread *td; register struct pathconf_args /* { syscallarg(char *) path; syscallarg(int) name; @@ -2061,11 +2063,11 @@ pathconf(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = VOP_PATHCONF(nd.ni_vp, SCARG(uap, name), p->p_retval); + error = VOP_PATHCONF(nd.ni_vp, SCARG(uap, name), td->td_retval); vput(nd.ni_vp); return (error); } @@ -2082,8 +2084,8 @@ struct readlink_args { #endif /* ARGSUSED */ int -readlink(p, uap) - struct proc *p; +readlink(td, uap) + struct thread *td; register struct readlink_args /* { syscallarg(char *) path; syscallarg(char *) buf; @@ -2097,7 +2099,7 @@ readlink(p, uap) struct nameidata nd; NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); @@ -2112,12 +2114,12 @@ readlink(p, uap) auio.uio_offset = 0; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_resid = SCARG(uap, count); - error = VOP_READLINK(vp, &auio, p->p_ucred); + error = VOP_READLINK(vp, &auio, td->td_proc->p_ucred); } vput(vp); - p->p_retval[0] = SCARG(uap, count) - auio.uio_resid; + td->td_retval[0] = SCARG(uap, count) - auio.uio_resid; return (error); } @@ -2125,8 +2127,8 @@ readlink(p, uap) * Common implementation code for chflags() and fchflags(). */ static int -setfflags(p, vp, flags) - struct proc *p; +setfflags(td, vp, flags) + struct thread *td; struct vnode *vp; int flags; { @@ -2141,17 +2143,17 @@ setfflags(p, vp, flags) * chown can't fail when done as root. */ if ((vp->v_type == VCHR || vp->v_type == VBLK) && - ((error = suser_xxx(p->p_ucred, p, PRISON_ROOT)) != 0)) + ((error = suser_xxx(td->td_proc->p_ucred, td->td_proc, PRISON_ROOT)) != 0)) return (error); if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); VATTR_NULL(&vattr); vattr.va_flags = flags; - error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + error = VOP_SETATTR(vp, &vattr, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return (error); } @@ -2167,8 +2169,8 @@ struct chflags_args { #endif /* ARGSUSED */ int -chflags(p, uap) - struct proc *p; +chflags(td, uap) + struct thread *td; register struct chflags_args /* { syscallarg(char *) path; syscallarg(int) flags; @@ -2177,11 +2179,11 @@ chflags(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setfflags(p, nd.ni_vp, SCARG(uap, flags)); + error = setfflags(td, nd.ni_vp, SCARG(uap, flags)); vrele(nd.ni_vp); return error; } @@ -2197,8 +2199,8 @@ struct fchflags_args { #endif /* ARGSUSED */ int -fchflags(p, uap) - struct proc *p; +fchflags(td, uap) + struct thread *td; register struct fchflags_args /* { syscallarg(int) fd; syscallarg(int) flags; @@ -2207,17 +2209,17 @@ fchflags(p, uap) struct file *fp; int error; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); - return setfflags(p, (struct vnode *) fp->f_data, SCARG(uap, flags)); + return setfflags(td, (struct vnode *) fp->f_data, SCARG(uap, flags)); } /* * Common implementation code for chmod(), lchmod() and fchmod(). */ static int -setfmode(p, vp, mode) - struct proc *p; +setfmode(td, vp, mode) + struct thread *td; struct vnode *vp; int mode; { @@ -2227,12 +2229,12 @@ setfmode(p, vp, mode) if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); VATTR_NULL(&vattr); vattr.va_mode = mode & ALLPERMS; - error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + error = VOP_SETATTR(vp, &vattr, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return error; } @@ -2248,8 +2250,8 @@ struct chmod_args { #endif /* ARGSUSED */ int -chmod(p, uap) - struct proc *p; +chmod(td, uap) + struct thread *td; register struct chmod_args /* { syscallarg(char *) path; syscallarg(int) mode; @@ -2258,11 +2260,11 @@ chmod(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setfmode(p, nd.ni_vp, SCARG(uap, mode)); + error = setfmode(td, nd.ni_vp, SCARG(uap, mode)); vrele(nd.ni_vp); return error; } @@ -2278,8 +2280,8 @@ struct lchmod_args { #endif /* ARGSUSED */ int -lchmod(p, uap) - struct proc *p; +lchmod(td, uap) + struct thread *td; register struct lchmod_args /* { syscallarg(char *) path; syscallarg(int) mode; @@ -2288,11 +2290,11 @@ lchmod(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setfmode(p, nd.ni_vp, SCARG(uap, mode)); + error = setfmode(td, nd.ni_vp, SCARG(uap, mode)); vrele(nd.ni_vp); return error; } @@ -2308,8 +2310,8 @@ struct fchmod_args { #endif /* ARGSUSED */ int -fchmod(p, uap) - struct proc *p; +fchmod(td, uap) + struct thread *td; register struct fchmod_args /* { syscallarg(int) fd; syscallarg(int) mode; @@ -2318,17 +2320,17 @@ fchmod(p, uap) struct file *fp; int error; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); - return setfmode(p, (struct vnode *)fp->f_data, SCARG(uap, mode)); + return setfmode(td, (struct vnode *)fp->f_data, SCARG(uap, mode)); } /* * Common implementation for chown(), lchown(), and fchown() */ static int -setfown(p, vp, uid, gid) - struct proc *p; +setfown(td, vp, uid, gid) + struct thread *td; struct vnode *vp; uid_t uid; gid_t gid; @@ -2339,13 +2341,13 @@ setfown(p, vp, uid, gid) if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); VATTR_NULL(&vattr); vattr.va_uid = uid; vattr.va_gid = gid; - error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + error = VOP_SETATTR(vp, &vattr, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return error; } @@ -2362,8 +2364,8 @@ struct chown_args { #endif /* ARGSUSED */ int -chown(p, uap) - struct proc *p; +chown(td, uap) + struct thread *td; register struct chown_args /* { syscallarg(char *) path; syscallarg(int) uid; @@ -2373,11 +2375,11 @@ chown(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setfown(p, nd.ni_vp, SCARG(uap, uid), SCARG(uap, gid)); + error = setfown(td, nd.ni_vp, SCARG(uap, uid), SCARG(uap, gid)); vrele(nd.ni_vp); return (error); } @@ -2394,8 +2396,8 @@ struct lchown_args { #endif /* ARGSUSED */ int -lchown(p, uap) - struct proc *p; +lchown(td, uap) + struct thread *td; register struct lchown_args /* { syscallarg(char *) path; syscallarg(int) uid; @@ -2405,11 +2407,11 @@ lchown(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setfown(p, nd.ni_vp, SCARG(uap, uid), SCARG(uap, gid)); + error = setfown(td, nd.ni_vp, SCARG(uap, uid), SCARG(uap, gid)); vrele(nd.ni_vp); return (error); } @@ -2426,8 +2428,8 @@ struct fchown_args { #endif /* ARGSUSED */ int -fchown(p, uap) - struct proc *p; +fchown(td, uap) + struct thread *td; register struct fchown_args /* { syscallarg(int) fd; syscallarg(int) uid; @@ -2437,9 +2439,9 @@ fchown(p, uap) struct file *fp; int error; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); - return setfown(p, (struct vnode *)fp->f_data, + return setfown(td, (struct vnode *)fp->f_data, SCARG(uap, uid), SCARG(uap, gid)); } @@ -2471,8 +2473,8 @@ getutimes(usrtvp, tsp) * Common implementation code for utimes(), lutimes(), and futimes(). */ static int -setutimes(p, vp, ts, nullflag) - struct proc *p; +setutimes(td, vp, ts, nullflag) + struct thread *td; struct vnode *vp; const struct timespec *ts; int nullflag; @@ -2483,15 +2485,15 @@ setutimes(p, vp, ts, nullflag) if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); VATTR_NULL(&vattr); vattr.va_atime = ts[0]; vattr.va_mtime = ts[1]; if (nullflag) vattr.va_vaflags |= VA_UTIMES_NULL; - error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); - VOP_UNLOCK(vp, 0, p); + error = VOP_SETATTR(vp, &vattr, td->td_proc->p_ucred, td); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return error; } @@ -2507,8 +2509,8 @@ struct utimes_args { #endif /* ARGSUSED */ int -utimes(p, uap) - struct proc *p; +utimes(td, uap) + struct thread *td; register struct utimes_args /* { syscallarg(char *) path; syscallarg(struct timeval *) tptr; @@ -2522,11 +2524,11 @@ utimes(p, uap) usrtvp = SCARG(uap, tptr); if ((error = getutimes(usrtvp, ts)) != 0) return (error); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setutimes(p, nd.ni_vp, ts, usrtvp == NULL); + error = setutimes(td, nd.ni_vp, ts, usrtvp == NULL); vrele(nd.ni_vp); return (error); } @@ -2542,8 +2544,8 @@ struct lutimes_args { #endif /* ARGSUSED */ int -lutimes(p, uap) - struct proc *p; +lutimes(td, uap) + struct thread *td; register struct lutimes_args /* { syscallarg(char *) path; syscallarg(struct timeval *) tptr; @@ -2557,11 +2559,11 @@ lutimes(p, uap) usrtvp = SCARG(uap, tptr); if ((error = getutimes(usrtvp, ts)) != 0) return (error); - NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); - error = setutimes(p, nd.ni_vp, ts, usrtvp == NULL); + error = setutimes(td, nd.ni_vp, ts, usrtvp == NULL); vrele(nd.ni_vp); return (error); } @@ -2577,8 +2579,8 @@ struct futimes_args { #endif /* ARGSUSED */ int -futimes(p, uap) - struct proc *p; +futimes(td, uap) + struct thread *td; register struct futimes_args /* { syscallarg(int ) fd; syscallarg(struct timeval *) tptr; @@ -2592,9 +2594,9 @@ futimes(p, uap) usrtvp = SCARG(uap, tptr); if ((error = getutimes(usrtvp, ts)) != 0) return (error); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); - return setutimes(p, (struct vnode *)fp->f_data, ts, usrtvp == NULL); + return setutimes(td, (struct vnode *)fp->f_data, ts, usrtvp == NULL); } /* @@ -2609,8 +2611,8 @@ struct truncate_args { #endif /* ARGSUSED */ int -truncate(p, uap) - struct proc *p; +truncate(td, uap) + struct thread *td; register struct truncate_args /* { syscallarg(char *) path; syscallarg(int) pad; @@ -2625,7 +2627,7 @@ truncate(p, uap) if (uap->length < 0) return(EINVAL); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -2634,15 +2636,15 @@ truncate(p, uap) return (error); } NDFREE(&nd, NDF_ONLY_PNBUF); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (vp->v_type == VDIR) error = EISDIR; else if ((error = vn_writechk(vp)) == 0 && - (error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)) == 0) { + (error = VOP_ACCESS(vp, VWRITE, td->td_proc->p_ucred, td)) == 0) { VATTR_NULL(&vattr); vattr.va_size = SCARG(uap, length); - error = VOP_SETATTR(vp, &vattr, p->p_ucred, p); + error = VOP_SETATTR(vp, &vattr, td->td_proc->p_ucred, td); } vput(vp); vn_finished_write(mp); @@ -2661,8 +2663,8 @@ struct ftruncate_args { #endif /* ARGSUSED */ int -ftruncate(p, uap) - struct proc *p; +ftruncate(td, uap) + struct thread *td; register struct ftruncate_args /* { syscallarg(int) fd; syscallarg(int) pad; @@ -2677,23 +2679,23 @@ ftruncate(p, uap) if (uap->length < 0) return(EINVAL); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); if ((fp->f_flag & FWRITE) == 0) return (EINVAL); vp = (struct vnode *)fp->f_data; if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (vp->v_type == VDIR) error = EISDIR; else if ((error = vn_writechk(vp)) == 0) { VATTR_NULL(&vattr); vattr.va_size = SCARG(uap, length); - error = VOP_SETATTR(vp, &vattr, fp->f_cred, p); + error = VOP_SETATTR(vp, &vattr, fp->f_cred, td); } - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return (error); } @@ -2710,8 +2712,8 @@ struct otruncate_args { #endif /* ARGSUSED */ int -otruncate(p, uap) - struct proc *p; +otruncate(td, uap) + struct thread *td; register struct otruncate_args /* { syscallarg(char *) path; syscallarg(long) length; @@ -2725,7 +2727,7 @@ otruncate(p, uap) SCARG(&nuap, path) = SCARG(uap, path); SCARG(&nuap, length) = SCARG(uap, length); - return (truncate(p, &nuap)); + return (truncate(td, &nuap)); } /* @@ -2739,8 +2741,8 @@ struct oftruncate_args { #endif /* ARGSUSED */ int -oftruncate(p, uap) - struct proc *p; +oftruncate(td, uap) + struct thread *td; register struct oftruncate_args /* { syscallarg(int) fd; syscallarg(long) length; @@ -2754,7 +2756,7 @@ oftruncate(p, uap) SCARG(&nuap, fd) = SCARG(uap, fd); SCARG(&nuap, length) = SCARG(uap, length); - return (ftruncate(p, &nuap)); + return (ftruncate(td, &nuap)); } #endif /* COMPAT_43 || COMPAT_SUNOS */ @@ -2768,8 +2770,8 @@ struct fsync_args { #endif /* ARGSUSED */ int -fsync(p, uap) - struct proc *p; +fsync(td, uap) + struct thread *td; struct fsync_args /* { syscallarg(int) fd; } */ *uap; @@ -2782,22 +2784,22 @@ fsync(p, uap) GIANT_REQUIRED; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); vp = (struct vnode *)fp->f_data; if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (VOP_GETVOBJECT(vp, &obj) == 0) { vm_object_page_clean(obj, 0, 0, 0); } - error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, p); + error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, td); #ifdef SOFTUPDATES if (error == 0 && vp->v_mount && (vp->v_mount->mnt_flag & MNT_SOFTDEP)) error = softdep_fsync(vp); #endif - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return (error); } @@ -2814,8 +2816,8 @@ struct rename_args { #endif /* ARGSUSED */ int -rename(p, uap) - struct proc *p; +rename(td, uap) + struct thread *td; register struct rename_args /* { syscallarg(char *) from; syscallarg(char *) to; @@ -2828,7 +2830,7 @@ rename(p, uap) bwillwrite(); NDINIT(&fromnd, DELETE, WANTPARENT | SAVESTART, UIO_USERSPACE, - SCARG(uap, from), p); + SCARG(uap, from), td); if ((error = namei(&fromnd)) != 0) return (error); fvp = fromnd.ni_vp; @@ -2839,7 +2841,7 @@ rename(p, uap) goto out1; } NDINIT(&tond, RENAME, LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART | NOOBJ, - UIO_USERSPACE, SCARG(uap, to), p); + UIO_USERSPACE, SCARG(uap, to), td); if (fromnd.ni_vp->v_type == VDIR) tond.ni_cnd.cn_flags |= WILLBEDIR; if ((error = namei(&tond)) != 0) { @@ -2876,12 +2878,12 @@ rename(p, uap) error = -1; out: if (!error) { - VOP_LEASE(tdvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(tdvp, td, td->td_proc->p_ucred, LEASE_WRITE); if (fromnd.ni_dvp != tdvp) { - VOP_LEASE(fromnd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(fromnd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); } if (tvp) { - VOP_LEASE(tvp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(tvp, td, td->td_proc->p_ucred, LEASE_WRITE); } error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd, tond.ni_dvp, tond.ni_vp, &tond.ni_cnd); @@ -2924,13 +2926,24 @@ struct mkdir_args { #endif /* ARGSUSED */ int -mkdir(p, uap) - struct proc *p; +mkdir(td, uap) + struct thread *td; register struct mkdir_args /* { syscallarg(char *) path; syscallarg(int) mode; } */ *uap; { + + return vn_mkdir(uap->path, uap->mode, UIO_USERSPACE, td); +} + +int +vn_mkdir(path, mode, segflg, td) + char *path; + int mode; + enum uio_seg segflg; + struct thread *td; +{ struct mount *mp; struct vnode *vp; struct vattr vattr; @@ -2939,7 +2952,7 @@ mkdir(p, uap) restart: bwillwrite(); - NDINIT(&nd, CREATE, LOCKPARENT, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, CREATE, LOCKPARENT, segflg, path, td); nd.ni_cnd.cn_flags |= WILLBEDIR; if ((error = namei(&nd)) != 0) return (error); @@ -2959,8 +2972,8 @@ restart: } VATTR_NULL(&vattr); vattr.va_type = VDIR; - vattr.va_mode = (SCARG(uap, mode) & ACCESSPERMS) &~ p->p_fd->fd_cmask; - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); + vattr.va_mode = (mode & ACCESSPERMS) &~ td->td_proc->p_fd->fd_cmask; + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); NDFREE(&nd, NDF_ONLY_PNBUF); vput(nd.ni_dvp); @@ -2982,8 +2995,8 @@ struct rmdir_args { #endif /* ARGSUSED */ int -rmdir(p, uap) - struct proc *p; +rmdir(td, uap) + struct thread *td; struct rmdir_args /* { syscallarg(char *) path; } */ *uap; @@ -2996,7 +3009,7 @@ rmdir(p, uap) restart: bwillwrite(); NDINIT(&nd, DELETE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, path), p); + SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -3029,8 +3042,8 @@ restart: return (error); goto restart; } - VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); + VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd); vn_finished_write(mp); out: @@ -3058,8 +3071,8 @@ struct ogetdirentries_args { }; #endif int -ogetdirentries(p, uap) - struct proc *p; +ogetdirentries(td, uap) + struct thread *td; register struct ogetdirentries_args /* { syscallarg(int) fd; syscallarg(char *) buf; @@ -3079,7 +3092,7 @@ ogetdirentries(p, uap) /* XXX arbitrary sanity limit on `count'. */ if (SCARG(uap, count) > 64 * 1024) return (EINVAL); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); if ((fp->f_flag & FREAD) == 0) return (EBADF); @@ -3093,9 +3106,9 @@ unionread: auio.uio_iovcnt = 1; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_resid = SCARG(uap, count); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); loff = auio.uio_offset = fp->f_offset; # if (BYTE_ORDER != LITTLE_ENDIAN) if (vp->v_mount->mnt_maxsymlinklen <= 0) { @@ -3148,12 +3161,12 @@ unionread: } FREE(dirbuf, M_TEMP); } - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (error) return (error); if (SCARG(uap, count) == auio.uio_resid) { if (union_dircheckp) { - error = union_dircheckp(p, &vp, fp); + error = union_dircheckp(td, &vp, fp); if (error == -1) goto unionread; if (error) @@ -3172,7 +3185,7 @@ unionread: } error = copyout((caddr_t)&loff, (caddr_t)SCARG(uap, basep), sizeof(long)); - p->p_retval[0] = SCARG(uap, count) - auio.uio_resid; + td->td_retval[0] = SCARG(uap, count) - auio.uio_resid; return (error); } #endif /* COMPAT_43 */ @@ -3189,8 +3202,8 @@ struct getdirentries_args { }; #endif int -getdirentries(p, uap) - struct proc *p; +getdirentries(td, uap) + struct thread *td; register struct getdirentries_args /* { syscallarg(int) fd; syscallarg(char *) buf; @@ -3205,7 +3218,7 @@ getdirentries(p, uap) long loff; int error, eofflag; - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); if ((fp->f_flag & FREAD) == 0) return (EBADF); @@ -3219,19 +3232,19 @@ unionread: auio.uio_iovcnt = 1; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_resid = SCARG(uap, count); - /* vn_lock(vp, LK_SHARED | LK_RETRY, p); */ - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + /* vn_lock(vp, LK_SHARED | LK_RETRY, td); */ + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); loff = auio.uio_offset = fp->f_offset; error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, NULL, NULL); fp->f_offset = auio.uio_offset; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (error) return (error); if (SCARG(uap, count) == auio.uio_resid) { if (union_dircheckp) { - error = union_dircheckp(p, &vp, fp); + error = union_dircheckp(td, &vp, fp); if (error == -1) goto unionread; if (error) @@ -3252,7 +3265,7 @@ unionread: error = copyout((caddr_t)&loff, (caddr_t)SCARG(uap, basep), sizeof(long)); } - p->p_retval[0] = SCARG(uap, count) - auio.uio_resid; + td->td_retval[0] = SCARG(uap, count) - auio.uio_resid; return (error); } #ifndef _SYS_SYSPROTO_H_ @@ -3263,8 +3276,8 @@ struct getdents_args { }; #endif int -getdents(p, uap) - struct proc *p; +getdents(td, uap) + struct thread *td; register struct getdents_args /* { syscallarg(int) fd; syscallarg(char *) buf; @@ -3276,7 +3289,7 @@ getdents(p, uap) ap.buf = uap->buf; ap.count = uap->count; ap.basep = NULL; - return getdirentries(p, &ap); + return getdirentries(td, &ap); } /* @@ -3290,16 +3303,16 @@ struct umask_args { }; #endif int -umask(p, uap) - struct proc *p; +umask(td, uap) + struct thread *td; struct umask_args /* { syscallarg(int) newmask; } */ *uap; { register struct filedesc *fdp; - fdp = p->p_fd; - p->p_retval[0] = fdp->fd_cmask; + fdp = td->td_proc->p_fd; + td->td_retval[0] = fdp->fd_cmask; fdp->fd_cmask = SCARG(uap, newmask) & ALLPERMS; return (0); } @@ -3315,8 +3328,8 @@ struct revoke_args { #endif /* ARGSUSED */ int -revoke(p, uap) - struct proc *p; +revoke(td, uap) + struct thread *td; register struct revoke_args /* { syscallarg(char *) path; } */ *uap; @@ -3327,7 +3340,7 @@ revoke(p, uap) int error; struct nameidata nd; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); vp = nd.ni_vp; @@ -3336,10 +3349,10 @@ revoke(p, uap) error = EINVAL; goto out; } - if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) != 0) + if ((error = VOP_GETATTR(vp, &vattr, td->td_proc->p_ucred, td)) != 0) goto out; - if (p->p_ucred->cr_uid != vattr.va_uid && - (error = suser_xxx(0, p, PRISON_ROOT))) + if (td->td_proc->p_ucred->cr_uid != vattr.va_uid && + (error = suser_xxx(0, td->td_proc, PRISON_ROOT))) goto out; if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) goto out; @@ -3380,8 +3393,8 @@ struct getfh_args { }; #endif int -getfh(p, uap) - struct proc *p; +getfh(td, uap) + struct thread *td; register struct getfh_args *uap; { struct nameidata nd; @@ -3392,10 +3405,10 @@ getfh(p, uap) /* * Must be super user */ - error = suser(p); + error = suser_td(td); if (error) return (error); - NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p); + NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, td); error = namei(&nd); if (error) return (error); @@ -3425,13 +3438,14 @@ struct fhopen_args { }; #endif int -fhopen(p, uap) - struct proc *p; +fhopen(td, uap) + struct thread *td; struct fhopen_args /* { syscallarg(const struct fhandle *) u_fhp; syscallarg(int) flags; } */ *uap; { + struct proc *p = td->td_proc; struct mount *mp; struct vnode *vp; struct fhandle fhp; @@ -3447,7 +3461,7 @@ fhopen(p, uap) /* * Must be super user */ - error = suser(p); + error = suser_td(td); if (error) return (error); @@ -3498,33 +3512,33 @@ fhopen(p, uap) if (fmode & FREAD) mode |= VREAD; if (mode) { - error = VOP_ACCESS(vp, mode, p->p_ucred, p); + error = VOP_ACCESS(vp, mode, p->p_ucred, td); if (error) goto bad; } if (fmode & O_TRUNC) { - VOP_UNLOCK(vp, 0, p); /* XXX */ + VOP_UNLOCK(vp, 0, td); /* XXX */ if ((error = vn_start_write(NULL, &mp, V_WAIT | PCATCH)) != 0) { vrele(vp); return (error); } - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); /* XXX */ + VOP_LEASE(vp, td, p->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); /* XXX */ VATTR_NULL(vap); vap->va_size = 0; - error = VOP_SETATTR(vp, vap, p->p_ucred, p); + error = VOP_SETATTR(vp, vap, p->p_ucred, td); vn_finished_write(mp); if (error) goto bad; } - error = VOP_OPEN(vp, fmode, p->p_ucred, p); + error = VOP_OPEN(vp, fmode, p->p_ucred, td); if (error) goto bad; /* * Make sure that a VM object is created for VMIO support. */ if (vn_canvmio(vp) == TRUE) { - if ((error = vfs_object_create(vp, p, p->p_ucred)) != 0) + if ((error = vfs_object_create(vp, td, p->p_ucred)) != 0) goto bad; } if (fmode & FWRITE) @@ -3534,7 +3548,7 @@ fhopen(p, uap) * end of vn_open code */ - if ((error = falloc(p, &nfp, &indx)) != 0) + if ((error = falloc(td, &nfp, &indx)) != 0) goto bad; fp = nfp; @@ -3558,7 +3572,7 @@ fhopen(p, uap) type = F_FLOCK; if ((fmode & FNONBLOCK) == 0) type |= F_WAIT; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if ((error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type)) != 0) { /* * The lock request failed. Normally close the @@ -3567,23 +3581,23 @@ fhopen(p, uap) */ if (fdp->fd_ofiles[indx] == fp) { fdp->fd_ofiles[indx] = NULL; - fdrop(fp, p); + fdrop(fp, td); } /* * release our private reference */ - fdrop(fp, p); + fdrop(fp, td); return(error); } - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); fp->f_flag |= FHASLOCK; } if ((vp->v_type == VREG) && (VOP_GETVOBJECT(vp, NULL) != 0)) - vfs_object_create(vp, p, p->p_ucred); + vfs_object_create(vp, td, p->p_ucred); - VOP_UNLOCK(vp, 0, p); - fdrop(fp, p); - p->p_retval[0] = indx; + VOP_UNLOCK(vp, 0, td); + fdrop(fp, td); + td->td_retval[0] = indx; return (0); bad: @@ -3601,8 +3615,8 @@ struct fhstat_args { }; #endif int -fhstat(p, uap) - struct proc *p; +fhstat(td, uap) + struct thread *td; register struct fhstat_args /* { syscallarg(struct fhandle *) u_fhp; syscallarg(struct stat *) sb; @@ -3617,7 +3631,7 @@ fhstat(p, uap) /* * Must be super user */ - error = suser(p); + error = suser_td(td); if (error) return (error); @@ -3629,7 +3643,7 @@ fhstat(p, uap) return (ESTALE); if ((error = VFS_FHTOVP(mp, &fh.fh_fid, &vp))) return (error); - error = vn_stat(vp, &sb, p); + error = vn_stat(vp, &sb, td); vput(vp); if (error) return (error); @@ -3647,8 +3661,8 @@ struct fhstatfs_args { }; #endif int -fhstatfs(p, uap) - struct proc *p; +fhstatfs(td, uap) + struct thread *td; struct fhstatfs_args /* { syscallarg(struct fhandle) *u_fhp; syscallarg(struct statfs) *buf; @@ -3664,7 +3678,7 @@ fhstatfs(p, uap) /* * Must be super user */ - if ((error = suser(p))) + if ((error = suser_td(td))) return (error); if ((error = copyin(SCARG(uap, u_fhp), &fh, sizeof(fhandle_t))) != 0) @@ -3677,10 +3691,10 @@ fhstatfs(p, uap) mp = vp->v_mount; sp = &mp->mnt_stat; vput(vp); - if ((error = VFS_STATFS(mp, sp, p)) != 0) + if ((error = VFS_STATFS(mp, sp, td)) != 0) return (error); sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; - if (suser_xxx(p->p_ucred, 0, 0)) { + if (suser_xxx(td->td_proc->p_ucred, 0, 0)) { bcopy((caddr_t)sp, (caddr_t)&sb, sizeof(sb)); sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0; sp = &sb; @@ -3700,8 +3714,8 @@ fhstatfs(p, uap) * Currently this is used only by UFS Extended Attributes. */ int -extattrctl(p, uap) - struct proc *p; +extattrctl(td, uap) + struct thread *td; struct extattrctl_args *uap; { struct vnode *filename_vp; @@ -3728,7 +3742,7 @@ extattrctl(p, uap) filename_vp = NULL; if (SCARG(uap, filename) != NULL) { NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - SCARG(uap, filename), p); + SCARG(uap, filename), td); if ((error = namei(&nd)) != 0) return (error); filename_vp = nd.ni_vp; @@ -3736,7 +3750,7 @@ extattrctl(p, uap) } /* SCARG(uap, path) always defined. */ - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); error = vn_start_write(nd.ni_vp, &mp, V_WAIT | PCATCH); @@ -3749,10 +3763,10 @@ extattrctl(p, uap) if (SCARG(uap, attrname) != NULL) { error = VFS_EXTATTRCTL(mp, SCARG(uap, cmd), filename_vp, - SCARG(uap, attrnamespace), attrname, p); + SCARG(uap, attrnamespace), attrname, td); } else { error = VFS_EXTATTRCTL(mp, SCARG(uap, cmd), filename_vp, - SCARG(uap, attrnamespace), NULL, p); + SCARG(uap, attrnamespace), NULL, td); } vn_finished_write(mp); @@ -3779,7 +3793,7 @@ extattrctl(p, uap) */ static int extattr_set_vp(struct vnode *vp, int attrnamespace, const char *attrname, - struct iovec *iovp, unsigned iovcnt, struct proc *p) + struct iovec *iovp, unsigned iovcnt, struct thread *td) { struct mount *mp; struct uio auio; @@ -3789,8 +3803,8 @@ extattr_set_vp(struct vnode *vp, int attrnamespace, const char *attrname, if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); iovlen = iovcnt * sizeof(struct iovec); if (iovcnt > UIO_SMALLIOV) { @@ -3806,7 +3820,7 @@ extattr_set_vp(struct vnode *vp, int attrnamespace, const char *attrname, auio.uio_iovcnt = iovcnt; auio.uio_rw = UIO_WRITE; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; if ((error = copyin((caddr_t)iovp, (caddr_t)iov, iovlen))) goto done; @@ -3821,20 +3835,20 @@ extattr_set_vp(struct vnode *vp, int attrnamespace, const char *attrname, } cnt = auio.uio_resid; error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio, - p->p_ucred, p); + td->td_proc->p_ucred, td); cnt -= auio.uio_resid; - p->p_retval[0] = cnt; + td->td_retval[0] = cnt; done: if (needfree) FREE(needfree, M_IOV); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return (error); } int -extattr_set_file(p, uap) - struct proc *p; +extattr_set_file(td, uap) + struct thread *td; struct extattr_set_file_args *uap; { struct nameidata nd; @@ -3846,21 +3860,21 @@ extattr_set_file(p, uap) if (error) return (error); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); error = extattr_set_vp(nd.ni_vp, SCARG(uap, attrnamespace), attrname, - SCARG(uap, iovp), SCARG(uap, iovcnt), p); + SCARG(uap, iovp), SCARG(uap, iovcnt), td); vrele(nd.ni_vp); return (error); } int -extattr_set_fd(p, uap) - struct proc *p; +extattr_set_fd(td, uap) + struct thread *td; struct extattr_set_fd_args *uap; { struct file *fp; @@ -3872,12 +3886,12 @@ extattr_set_fd(p, uap) if (error) return (error); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); error = extattr_set_vp((struct vnode *)fp->f_data, SCARG(uap, attrnamespace), attrname, SCARG(uap, iovp), - SCARG(uap, iovcnt), p); + SCARG(uap, iovcnt), td); return (error); } @@ -3895,15 +3909,15 @@ extattr_set_fd(p, uap) */ static int extattr_get_vp(struct vnode *vp, int attrnamespace, const char *attrname, - struct iovec *iovp, unsigned iovcnt, struct proc *p) + struct iovec *iovp, unsigned iovcnt, struct thread *td) { struct uio auio; struct iovec *iov, *needfree = NULL, aiov[UIO_SMALLIOV]; u_int iovlen, cnt; int error, i; - VOP_LEASE(vp, p, p->p_ucred, LEASE_READ); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_READ); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); iovlen = iovcnt * sizeof (struct iovec); if (iovcnt > UIO_SMALLIOV) { @@ -3919,7 +3933,7 @@ extattr_get_vp(struct vnode *vp, int attrnamespace, const char *attrname, auio.uio_iovcnt = iovcnt; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_USERSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; if ((error = copyin((caddr_t)iovp, (caddr_t)iov, iovlen))) goto done; @@ -3934,19 +3948,19 @@ extattr_get_vp(struct vnode *vp, int attrnamespace, const char *attrname, } cnt = auio.uio_resid; error = VOP_GETEXTATTR(vp, attrnamespace, attrname, &auio, - p->p_ucred, p); + td->td_proc->p_ucred, td); cnt -= auio.uio_resid; - p->p_retval[0] = cnt; + td->td_retval[0] = cnt; done: if (needfree) FREE(needfree, M_IOV); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); return (error); } int -extattr_get_file(p, uap) - struct proc *p; +extattr_get_file(td, uap) + struct thread *td; struct extattr_get_file_args *uap; { struct nameidata nd; @@ -3958,21 +3972,21 @@ extattr_get_file(p, uap) if (error) return (error); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); error = extattr_get_vp(nd.ni_vp, SCARG(uap, attrnamespace), attrname, - SCARG(uap, iovp), SCARG(uap, iovcnt), p); + SCARG(uap, iovp), SCARG(uap, iovcnt), td); vrele(nd.ni_vp); return (error); } int -extattr_get_fd(p, uap) - struct proc *p; +extattr_get_fd(td, uap) + struct thread *td; struct extattr_get_fd_args *uap; { struct file *fp; @@ -3984,12 +3998,12 @@ extattr_get_fd(p, uap) if (error) return (error); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); error = extattr_get_vp((struct vnode *)fp->f_data, SCARG(uap, attrnamespace), attrname, SCARG(uap, iovp), - SCARG(uap, iovcnt), p); + SCARG(uap, iovcnt), td); return (error); } @@ -4006,27 +4020,27 @@ extattr_get_fd(p, uap) */ static int extattr_delete_vp(struct vnode *vp, int attrnamespace, const char *attrname, - struct proc *p) + struct thread *td) { struct mount *mp; int error; if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL, - p->p_ucred, p); + td->td_proc->p_ucred, td); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return (error); } int -extattr_delete_file(p, uap) - struct proc *p; +extattr_delete_file(td, uap) + struct thread *td; struct extattr_delete_file_args *uap; { struct nameidata nd; @@ -4038,21 +4052,21 @@ extattr_delete_file(p, uap) if (error) return(error); - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); if ((error = namei(&nd)) != 0) return(error); NDFREE(&nd, NDF_ONLY_PNBUF); error = extattr_delete_vp(nd.ni_vp, SCARG(uap, attrnamespace), - attrname, p); + attrname, td); vrele(nd.ni_vp); return(error); } int -extattr_delete_fd(p, uap) - struct proc *p; +extattr_delete_fd(td, uap) + struct thread *td; struct extattr_delete_fd_args *uap; { struct file *fp; @@ -4064,11 +4078,11 @@ extattr_delete_fd(p, uap) if (error) return (error); - if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) + if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) return (error); error = extattr_delete_vp((struct vnode *)fp->f_data, - SCARG(uap, attrnamespace), attrname, p); + SCARG(uap, attrnamespace), attrname, td); return (error); } diff --git a/sys/kern/vfs_vnops.c b/sys/kern/vfs_vnops.c index 9a6f87a..b3160b1 100644 --- a/sys/kern/vfs_vnops.c +++ b/sys/kern/vfs_vnops.c @@ -57,17 +57,17 @@ #include <machine/limits.h> -static int vn_closefile __P((struct file *fp, struct proc *p)); +static int vn_closefile __P((struct file *fp, struct thread *td)); static int vn_ioctl __P((struct file *fp, u_long com, caddr_t data, - struct proc *p)); + struct thread *td)); static int vn_read __P((struct file *fp, struct uio *uio, - struct ucred *cred, int flags, struct proc *p)); + struct ucred *cred, int flags, struct thread *td)); static int vn_poll __P((struct file *fp, int events, struct ucred *cred, - struct proc *p)); + struct thread *td)); static int vn_kqfilter __P((struct file *fp, struct knote *kn)); -static int vn_statfile __P((struct file *fp, struct stat *sb, struct proc *p)); +static int vn_statfile __P((struct file *fp, struct stat *sb, struct thread *td)); static int vn_write __P((struct file *fp, struct uio *uio, - struct ucred *cred, int flags, struct proc *p)); + struct ucred *cred, int flags, struct thread *td)); struct fileops vnops = { vn_read, vn_write, vn_ioctl, vn_poll, vn_kqfilter, @@ -88,8 +88,8 @@ vn_open(ndp, flagp, cmode) { struct vnode *vp; struct mount *mp; - struct proc *p = ndp->ni_cnd.cn_proc; - struct ucred *cred = p->p_ucred; + struct thread *td = ndp->ni_cnd.cn_thread; + struct ucred *cred = td->td_proc->p_ucred; struct vattr vat; struct vattr *vap = &vat; int mode, fmode, error; @@ -118,7 +118,7 @@ restart: return (error); goto restart; } - VOP_LEASE(ndp->ni_dvp, p, cred, LEASE_WRITE); + VOP_LEASE(ndp->ni_dvp, td, cred, LEASE_WRITE); error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp, &ndp->ni_cnd, vap); vput(ndp->ni_dvp); @@ -175,18 +175,18 @@ restart: if (fmode & FREAD) mode |= VREAD; if (mode) { - error = VOP_ACCESS(vp, mode, cred, p); + error = VOP_ACCESS(vp, mode, cred, td); if (error) goto bad; } } - if ((error = VOP_OPEN(vp, fmode, cred, p)) != 0) + if ((error = VOP_OPEN(vp, fmode, cred, td)) != 0) goto bad; /* * Make sure that a VM object is created for VMIO support. */ if (vn_canvmio(vp) == TRUE) { - if ((error = vfs_object_create(vp, p, cred)) != 0) + if ((error = vfs_object_create(vp, td, cred)) != 0) goto bad; } @@ -224,17 +224,17 @@ vn_writechk(vp) * Vnode close call */ int -vn_close(vp, flags, cred, p) +vn_close(vp, flags, cred, td) register struct vnode *vp; int flags; struct ucred *cred; - struct proc *p; + struct thread *td; { int error; if (flags & FWRITE) vp->v_writecount--; - error = VOP_CLOSE(vp, flags, cred, p); + error = VOP_CLOSE(vp, flags, cred, td); /* * XXX - In certain instances VOP_CLOSE has to do the vrele * itself. If the vrele has been done, it will return EAGAIN @@ -283,7 +283,7 @@ sequential_heuristic(struct uio *uio, struct file *fp) * Package up an I/O request on a vnode into a uio and do it. */ int -vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p) +vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, td) enum uio_rw rw; struct vnode *vp; caddr_t base; @@ -293,7 +293,7 @@ vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p) int ioflg; struct ucred *cred; int *aresid; - struct proc *p; + struct thread *td; { struct uio auio; struct iovec aiov; @@ -306,7 +306,7 @@ vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p) vp->v_type != VCHR && (error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); } auio.uio_iov = &aiov; auio.uio_iovcnt = 1; @@ -316,7 +316,7 @@ vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p) auio.uio_offset = offset; auio.uio_segflg = segflg; auio.uio_rw = rw; - auio.uio_procp = p; + auio.uio_td = td; if (rw == UIO_READ) { error = VOP_READ(vp, &auio, ioflg, cred); } else { @@ -329,7 +329,7 @@ vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p) error = EIO; if ((ioflg & IO_NODELOCKED) == 0) { vn_finished_write(mp); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); } return (error); } @@ -341,7 +341,7 @@ vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p) * check bwillwrite() before calling vn_rdwr() */ int -vn_rdwr_inchunks(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p) +vn_rdwr_inchunks(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, td) enum uio_rw rw; struct vnode *vp; caddr_t base; @@ -351,7 +351,7 @@ vn_rdwr_inchunks(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p) int ioflg; struct ucred *cred; int *aresid; - struct proc *p; + struct thread *td; { int error = 0; @@ -361,7 +361,7 @@ vn_rdwr_inchunks(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p) if (rw != UIO_READ && vp->v_type == VREG) bwillwrite(); error = vn_rdwr(rw, vp, base, chunk, offset, segflg, - ioflg, cred, aresid, p); + ioflg, cred, aresid, td); len -= chunk; /* aresid calc already includes length */ if (error) break; @@ -377,26 +377,26 @@ vn_rdwr_inchunks(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p) * File table vnode read routine. */ static int -vn_read(fp, uio, cred, flags, p) +vn_read(fp, uio, cred, flags, td) struct file *fp; struct uio *uio; struct ucred *cred; - struct proc *p; + struct thread *td; int flags; { struct vnode *vp; int error, ioflag; - KASSERT(uio->uio_procp == p, ("uio_procp %p is not p %p", - uio->uio_procp, p)); + KASSERT(uio->uio_td == td, ("uio_td %p is not td %p", + uio->uio_td, td)); vp = (struct vnode *)fp->f_data; ioflag = 0; if (fp->f_flag & FNONBLOCK) ioflag |= IO_NDELAY; if (fp->f_flag & O_DIRECT) ioflag |= IO_DIRECT; - VOP_LEASE(vp, p, cred, LEASE_READ); - vn_lock(vp, LK_SHARED | LK_NOPAUSE | LK_RETRY, p); + VOP_LEASE(vp, td, cred, LEASE_READ); + vn_lock(vp, LK_SHARED | LK_NOPAUSE | LK_RETRY, td); if ((flags & FOF_OFFSET) == 0) uio->uio_offset = fp->f_offset; @@ -406,7 +406,7 @@ vn_read(fp, uio, cred, flags, p) if ((flags & FOF_OFFSET) == 0) fp->f_offset = uio->uio_offset; fp->f_nextoff = uio->uio_offset; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); return (error); } @@ -414,19 +414,19 @@ vn_read(fp, uio, cred, flags, p) * File table vnode write routine. */ static int -vn_write(fp, uio, cred, flags, p) +vn_write(fp, uio, cred, flags, td) struct file *fp; struct uio *uio; struct ucred *cred; - struct proc *p; + struct thread *td; int flags; { struct vnode *vp; struct mount *mp; int error, ioflag; - KASSERT(uio->uio_procp == p, ("uio_procp %p is not p %p", - uio->uio_procp, p)); + KASSERT(uio->uio_td == td, ("uio_td %p is not td %p", + uio->uio_td, td)); vp = (struct vnode *)fp->f_data; if (vp->v_type == VREG) bwillwrite(); @@ -445,8 +445,8 @@ vn_write(fp, uio, cred, flags, p) if (vp->v_type != VCHR && (error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) return (error); - VOP_LEASE(vp, p, cred, LEASE_WRITE); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + VOP_LEASE(vp, td, cred, LEASE_WRITE); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if ((flags & FOF_OFFSET) == 0) uio->uio_offset = fp->f_offset; ioflag |= sequential_heuristic(uio, fp); @@ -454,7 +454,7 @@ vn_write(fp, uio, cred, flags, p) if ((flags & FOF_OFFSET) == 0) fp->f_offset = uio->uio_offset; fp->f_nextoff = uio->uio_offset; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(mp); return (error); } @@ -463,21 +463,21 @@ vn_write(fp, uio, cred, flags, p) * File table vnode stat routine. */ static int -vn_statfile(fp, sb, p) +vn_statfile(fp, sb, td) struct file *fp; struct stat *sb; - struct proc *p; + struct thread *td; { struct vnode *vp = (struct vnode *)fp->f_data; - return vn_stat(vp, sb, p); + return vn_stat(vp, sb, td); } int -vn_stat(vp, sb, p) +vn_stat(vp, sb, td) struct vnode *vp; register struct stat *sb; - struct proc *p; + struct thread *td; { struct vattr vattr; register struct vattr *vap; @@ -485,7 +485,7 @@ vn_stat(vp, sb, p) u_short mode; vap = &vattr; - error = VOP_GETATTR(vp, vap, p->p_ucred, p); + error = VOP_GETATTR(vp, vap, td->td_proc->p_ucred, td); if (error) return (error); @@ -568,7 +568,7 @@ vn_stat(vp, sb, p) } sb->st_flags = vap->va_flags; - if (suser_xxx(p->p_ucred, 0, 0)) + if (suser_xxx(td->td_proc->p_ucred, 0, 0)) sb->st_gen = 0; else sb->st_gen = vap->va_gen; @@ -586,11 +586,11 @@ vn_stat(vp, sb, p) * File table vnode ioctl routine. */ static int -vn_ioctl(fp, com, data, p) +vn_ioctl(fp, com, data, td) struct file *fp; u_long com; caddr_t data; - struct proc *p; + struct thread *td; { register struct vnode *vp = ((struct vnode *)fp->f_data); struct vattr vattr; @@ -601,7 +601,7 @@ vn_ioctl(fp, com, data, p) case VREG: case VDIR: if (com == FIONREAD) { - error = VOP_GETATTR(vp, &vattr, p->p_ucred, p); + error = VOP_GETATTR(vp, &vattr, td->td_proc->p_ucred, td); if (error) return (error); *(int *)data = vattr.va_size - fp->f_offset; @@ -624,18 +624,18 @@ vn_ioctl(fp, com, data, p) *(int *)data = devsw(vp->v_rdev)->d_flags & D_TYPEMASK; return (0); } - error = VOP_IOCTL(vp, com, data, fp->f_flag, p->p_ucred, p); + error = VOP_IOCTL(vp, com, data, fp->f_flag, td->td_proc->p_ucred, td); if (error == 0 && com == TIOCSCTTY) { /* Do nothing if reassigning same control tty */ - if (p->p_session->s_ttyvp == vp) + if (td->td_proc->p_session->s_ttyvp == vp) return (0); /* Get rid of reference to old control tty */ - if (p->p_session->s_ttyvp) - vrele(p->p_session->s_ttyvp); + if (td->td_proc->p_session->s_ttyvp) + vrele(td->td_proc->p_session->s_ttyvp); - p->p_session->s_ttyvp = vp; + td->td_proc->p_session->s_ttyvp = vp; VREF(vp); } return (error); @@ -646,14 +646,14 @@ vn_ioctl(fp, com, data, p) * File table vnode poll routine. */ static int -vn_poll(fp, events, cred, p) +vn_poll(fp, events, cred, td) struct file *fp; int events; struct ucred *cred; - struct proc *p; + struct thread *td; { - return (VOP_POLL(((struct vnode *)fp->f_data), events, cred, p)); + return (VOP_POLL(((struct vnode *)fp->f_data), events, cred, td)); } /* @@ -662,13 +662,13 @@ vn_poll(fp, events, cred, p) */ int #ifndef DEBUG_LOCKS -vn_lock(vp, flags, p) +vn_lock(vp, flags, td) #else -debug_vn_lock(vp, flags, p, filename, line) +debug_vn_lock(vp, flags, td, filename, line) #endif struct vnode *vp; int flags; - struct proc *p; + struct thread *td; #ifdef DEBUG_LOCKS const char *filename; int line; @@ -679,7 +679,7 @@ debug_vn_lock(vp, flags, p, filename, line) do { if ((flags & LK_INTERLOCK) == 0) mtx_lock(&vp->v_interlock); - if ((vp->v_flag & VXLOCK) && vp->v_vxproc != curproc) { + if ((vp->v_flag & VXLOCK) && vp->v_vxproc != curthread) { vp->v_flag |= VXWANT; msleep(vp, &vp->v_interlock, PINOD | PDROP, "vn_lock", 0); @@ -692,7 +692,7 @@ debug_vn_lock(vp, flags, p, filename, line) vp->line = line; #endif error = VOP_LOCK(vp, - flags | LK_NOPAUSE | LK_INTERLOCK, p); + flags | LK_NOPAUSE | LK_INTERLOCK, td); if (error == 0) return (error); } @@ -705,14 +705,14 @@ debug_vn_lock(vp, flags, p, filename, line) * File table vnode close routine. */ static int -vn_closefile(fp, p) +vn_closefile(fp, td) struct file *fp; - struct proc *p; + struct thread *td; { fp->f_ops = &badfileops; return (vn_close(((struct vnode *)fp->f_data), fp->f_flag, - fp->f_cred, p)); + fp->f_cred, td)); } /* @@ -825,14 +825,14 @@ void vfs_write_suspend(mp) struct mount *mp; { - struct proc *p = curproc; + struct thread *td = curthread; if (mp->mnt_kern_flag & MNTK_SUSPEND) return; mp->mnt_kern_flag |= MNTK_SUSPEND; if (mp->mnt_writeopcount > 0) (void) tsleep(&mp->mnt_writeopcount, PUSER - 1, "suspwt", 0); - VFS_SYNC(mp, MNT_WAIT, p->p_ucred, p); + VFS_SYNC(mp, MNT_WAIT, td->td_proc->p_ucred, td); mp->mnt_kern_flag |= MNTK_SUSPENDED; } @@ -865,7 +865,7 @@ vn_kqfilter(struct file *fp, struct knote *kn) */ int vn_extattr_get(struct vnode *vp, int ioflg, int attrnamespace, - const char *attrname, int *buflen, char *buf, struct proc *p) + const char *attrname, int *buflen, char *buf, struct thread *td) { struct uio auio; struct iovec iov; @@ -878,18 +878,18 @@ vn_extattr_get(struct vnode *vp, int ioflg, int attrnamespace, auio.uio_iovcnt = 1; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; auio.uio_resid = *buflen; if ((ioflg & IO_NODELOCKED) == 0) - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); /* authorize attribute retrieval as kernel */ - error = VOP_GETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, p); + error = VOP_GETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, td); if ((ioflg & IO_NODELOCKED) == 0) - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (error == 0) { *buflen = *buflen - auio.uio_resid; @@ -903,7 +903,7 @@ vn_extattr_get(struct vnode *vp, int ioflg, int attrnamespace, */ int vn_extattr_set(struct vnode *vp, int ioflg, int attrnamespace, - const char *attrname, int buflen, char *buf, struct proc *p) + const char *attrname, int buflen, char *buf, struct thread *td) { struct uio auio; struct iovec iov; @@ -917,22 +917,22 @@ vn_extattr_set(struct vnode *vp, int ioflg, int attrnamespace, auio.uio_iovcnt = 1; auio.uio_rw = UIO_WRITE; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; auio.uio_resid = buflen; if ((ioflg & IO_NODELOCKED) == 0) { if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0) return (error); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); } /* authorize attribute setting as kernel */ - error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, p); + error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, td); if ((ioflg & IO_NODELOCKED) == 0) { vn_finished_write(mp); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); } return (error); @@ -940,7 +940,7 @@ vn_extattr_set(struct vnode *vp, int ioflg, int attrnamespace, int vn_extattr_rm(struct vnode *vp, int ioflg, int attrnamespace, - const char *attrname, struct proc *p) + const char *attrname, struct thread *td) { struct mount *mp; int error; @@ -948,15 +948,15 @@ vn_extattr_rm(struct vnode *vp, int ioflg, int attrnamespace, if ((ioflg & IO_NODELOCKED) == 0) { if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0) return (error); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); } /* authorize attribute removal as kernel */ - error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL, NULL, p); + error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL, NULL, td); if ((ioflg & IO_NODELOCKED) == 0) { vn_finished_write(mp); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); } return (error); diff --git a/sys/kern/vnode_if.pl b/sys/kern/vnode_if.pl index 53236e5..32eabfe 100644 --- a/sys/kern/vnode_if.pl +++ b/sys/kern/vnode_if.pl @@ -322,8 +322,8 @@ line: while (<SRC>) { printf CFILE "\t%s,\n", &find_arg_with_type('struct vnode **'); # cred (if any) printf CFILE "\t%s,\n", &find_arg_with_type('struct ucred *'); - # proc (if any) - printf CFILE "\t%s,\n", &find_arg_with_type('struct proc *'); + # thread (if any) + printf CFILE "\t%s,\n", &find_arg_with_type('struct thread *'); # componentname printf CFILE "\t%s,\n", &find_arg_with_type('struct componentname *'); # transport layer information diff --git a/sys/kern/vnode_if.src b/sys/kern/vnode_if.src index e275617..43ff6b5 100644 --- a/sys/kern/vnode_if.src +++ b/sys/kern/vnode_if.src @@ -59,7 +59,7 @@ # vop_islocked { IN struct vnode *vp; - IN struct proc *p; + IN struct thread *td; }; # @@ -126,7 +126,7 @@ vop_open { IN struct vnode *vp; IN int mode; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -136,7 +136,7 @@ vop_close { IN struct vnode *vp; IN int fflag; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -146,7 +146,7 @@ vop_access { IN struct vnode *vp; IN int mode; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -156,7 +156,7 @@ vop_getattr { IN struct vnode *vp; OUT struct vattr *vap; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -166,7 +166,7 @@ vop_setattr { IN struct vnode *vp; IN struct vattr *vap; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -194,7 +194,7 @@ vop_write { # vop_lease { IN struct vnode *vp; - IN struct proc *p; + IN struct thread *td; IN struct ucred *cred; IN int flag; }; @@ -208,7 +208,7 @@ vop_ioctl { IN caddr_t data; IN int fflag; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -218,7 +218,7 @@ vop_poll { IN struct vnode *vp; IN int events; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -244,7 +244,7 @@ vop_fsync { IN struct vnode *vp; IN struct ucred *cred; IN int waitfor; - IN struct proc *p; + IN struct thread *td; }; # @@ -341,7 +341,7 @@ vop_readlink { # vop_inactive { IN struct vnode *vp; - IN struct proc *p; + IN struct thread *td; }; # @@ -349,7 +349,7 @@ vop_inactive { # vop_reclaim { IN struct vnode *vp; - IN struct proc *p; + IN struct thread *td; }; # @@ -358,7 +358,7 @@ vop_reclaim { vop_lock { IN struct vnode *vp; IN int flags; - IN struct proc *p; + IN struct thread *td; }; # @@ -367,7 +367,7 @@ vop_lock { vop_unlock { IN struct vnode *vp; IN int flags; - IN struct proc *p; + IN struct thread *td; }; # @@ -479,7 +479,7 @@ vop_getacl { IN acl_type_t type; OUT struct acl *aclp; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -490,7 +490,7 @@ vop_setacl { IN acl_type_t type; IN struct acl *aclp; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -501,7 +501,7 @@ vop_aclcheck { IN acl_type_t type; IN struct acl *aclp; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -513,7 +513,7 @@ vop_getextattr { IN const char *name; INOUT struct uio *uio; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -525,7 +525,7 @@ vop_setextattr { IN const char *name; INOUT struct uio *uio; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # @@ -534,7 +534,7 @@ vop_setextattr { vop_createvobject { IN struct vnode *vp; IN struct ucred *cred; - IN struct proc *p; + IN struct thread *td; }; # diff --git a/sys/modules/Makefile b/sys/modules/Makefile index e16cc7f..c6d0f4b 100644 --- a/sys/modules/Makefile +++ b/sys/modules/Makefile @@ -49,13 +49,11 @@ SUBDIR= 3dfx \ mii \ mlx \ msdosfs \ - ncp \ nfs \ nge \ nmdm \ ntfs \ nullfs \ - nwfs \ pcn \ portalfs \ procfs \ @@ -99,6 +97,9 @@ SUBDIR= 3dfx \ wx \ xl +#removed while KSE settles in: +# ncp \ +# nwfs \ # XXX some of these can move to the general case when de-i386'ed .if ${MACHINE_ARCH} == "i386" SUBDIR+=aac \ @@ -120,13 +121,14 @@ SUBDIR+=aac \ pecoff \ ray \ s3 \ - smbfs \ splash \ sr \ streams \ vesa \ wi .endif +#removed while KSE settles in: +# smbfs \ .if ${MACHINE} == "pc98" SUBDIR+=snc diff --git a/sys/modules/netgraph/Makefile b/sys/modules/netgraph/Makefile index 7f65322..466a4d4 100644 --- a/sys/modules/netgraph/Makefile +++ b/sys/modules/netgraph/Makefile @@ -6,6 +6,7 @@ SUBDIR= async \ bridge \ cisco \ echo \ + eiface \ ether \ frame_relay \ hole \ diff --git a/sys/net/bpf.c b/sys/net/bpf.c index cd12323..874fcb6 100644 --- a/sys/net/bpf.c +++ b/sys/net/bpf.c @@ -313,11 +313,11 @@ bpf_detachd(d) */ /* ARGSUSED */ static int -bpfopen(dev, flags, fmt, p) +bpfopen(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { struct bpf_d *d; @@ -353,11 +353,11 @@ bpfopen(dev, flags, fmt, p) */ /* ARGSUSED */ static int -bpfclose(dev, flags, fmt, p) +bpfclose(dev, flags, fmt, td) dev_t dev; int flags; int fmt; - struct proc *p; + struct thread *td; { struct bpf_d *d = dev->si_drv1; @@ -585,12 +585,12 @@ reset_d(d) */ /* ARGSUSED */ static int -bpfioctl(dev, cmd, addr, flags, p) +bpfioctl(dev, cmd, addr, flags, td) dev_t dev; u_long cmd; caddr_t addr; int flags; - struct proc *p; + struct thread *td; { struct bpf_d *d = dev->si_drv1; int error = 0; @@ -966,10 +966,10 @@ bpf_setif(d, ifr) * Otherwise, return false but make a note that a selwakeup() must be done. */ int -bpfpoll(dev, events, p) +bpfpoll(dev, events, td) register dev_t dev; int events; - struct proc *p; + struct thread *td; { struct bpf_d *d; int revents; @@ -990,7 +990,7 @@ bpfpoll(dev, events, p) if (d->bd_hlen != 0 || (d->bd_immediate && d->bd_slen != 0)) revents |= events & (POLLIN | POLLRDNORM); else - selrecord(p, &d->bd_sel); + selrecord(curthread, &d->bd_sel); } BPFD_UNLOCK(d); return (revents); diff --git a/sys/net/bpfdesc.h b/sys/net/bpfdesc.h index 9172c7f..7f61d70 100644 --- a/sys/net/bpfdesc.h +++ b/sys/net/bpfdesc.h @@ -84,7 +84,7 @@ struct bpf_d { #if BSD < 199103 u_char bd_selcoll; /* true if selects collide */ int bd_timedout; - struct proc * bd_selproc; /* process that last selected us */ + struct thread * bd_selthread; /* process that last selected us */ #else u_char bd_pad; /* explicit alignment */ struct selinfo bd_sel; /* bsd select info */ diff --git a/sys/net/if.c b/sys/net/if.c index 7ff94c7..c08d494 100644 --- a/sys/net/if.c +++ b/sys/net/if.c @@ -952,11 +952,11 @@ if_withname(sa) * Interface ioctls. */ int -ifioctl(so, cmd, data, p) +ifioctl(so, cmd, data, td) struct socket *so; u_long cmd; caddr_t data; - struct proc *p; + struct thread *td; { register struct ifnet *ifp; register struct ifreq *ifr; @@ -975,7 +975,7 @@ ifioctl(so, cmd, data, p) switch (cmd) { case SIOCIFCREATE: case SIOCIFDESTROY: - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) return (error); return ((cmd == SIOCIFCREATE) ? if_clone_create(ifr->ifr_name, sizeof(ifr->ifr_name)) : @@ -1007,7 +1007,7 @@ ifioctl(so, cmd, data, p) break; case SIOCSIFFLAGS: - error = suser(p); + error = suser_td(td); if (error) return (error); ifr->ifr_prevflags = ifp->if_flags; @@ -1032,7 +1032,7 @@ ifioctl(so, cmd, data, p) break; case SIOCSIFMETRIC: - error = suser(p); + error = suser_td(td); if (error) return (error); ifp->if_metric = ifr->ifr_metric; @@ -1040,7 +1040,7 @@ ifioctl(so, cmd, data, p) break; case SIOCSIFPHYS: - error = suser(p); + error = suser_td(td); if (error) return error; if (!ifp->if_ioctl) @@ -1054,7 +1054,7 @@ ifioctl(so, cmd, data, p) { u_long oldmtu = ifp->if_mtu; - error = suser(p); + error = suser_td(td); if (error) return (error); if (ifp->if_ioctl == NULL) @@ -1079,7 +1079,7 @@ ifioctl(so, cmd, data, p) case SIOCADDMULTI: case SIOCDELMULTI: - error = suser(p); + error = suser_td(td); if (error) return (error); @@ -1109,7 +1109,7 @@ ifioctl(so, cmd, data, p) case SIOCSLIFPHYADDR: case SIOCSIFMEDIA: case SIOCSIFGENERIC: - error = suser(p); + error = suser_td(td); if (error) return (error); if (ifp->if_ioctl == 0) @@ -1133,7 +1133,7 @@ ifioctl(so, cmd, data, p) return ((*ifp->if_ioctl)(ifp, cmd, data)); case SIOCSIFLLADDR: - error = suser(p); + error = suser_td(td); if (error) return (error); return if_setlladdr(ifp, @@ -1146,7 +1146,7 @@ ifioctl(so, cmd, data, p) #ifndef COMPAT_43 error = ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, data, - ifp, p)); + ifp, td)); #else { int ocmd = cmd; @@ -1187,7 +1187,7 @@ ifioctl(so, cmd, data, p) error = ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, data, - ifp, p)); + ifp, td)); switch (ocmd) { case OSIOCGIFADDR: diff --git a/sys/net/if.h b/sys/net/if.h index 088c7ef..70428bf 100644 --- a/sys/net/if.h +++ b/sys/net/if.h @@ -297,7 +297,7 @@ __END_DECLS #endif #ifdef _KERNEL -struct proc; +struct thread; /* XXX - this should go away soon. */ #include <net/if_var.h> diff --git a/sys/net/if_ppp.c b/sys/net/if_ppp.c index 86c541b..95b9684 100644 --- a/sys/net/if_ppp.c +++ b/sys/net/if_ppp.c @@ -338,13 +338,14 @@ pppdealloc(sc) * Ioctl routine for generic ppp devices. */ int -pppioctl(sc, cmd, data, flag, p) +pppioctl(sc, cmd, data, flag, td) struct ppp_softc *sc; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { + struct proc *p = td->td_proc; int s, flags, mru, npx; u_int nb; int error = 0; diff --git a/sys/net/if_pppvar.h b/sys/net/if_pppvar.h index 77456f7..cc71846 100644 --- a/sys/net/if_pppvar.h +++ b/sys/net/if_pppvar.h @@ -103,7 +103,7 @@ extern struct ppp_softc ppp_softc[]; struct ppp_softc *pppalloc __P((pid_t pid)); void pppdealloc __P((struct ppp_softc *sc)); int pppioctl __P((struct ppp_softc *sc, u_long cmd, caddr_t data, - int flag, struct proc *p)); + int flag, struct thread *td)); int pppoutput __P((struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst, struct rtentry *rtp)); void ppp_restart __P((struct ppp_softc *sc)); diff --git a/sys/net/if_sl.c b/sys/net/if_sl.c index b681a0b..35d67e2 100644 --- a/sys/net/if_sl.c +++ b/sys/net/if_sl.c @@ -72,6 +72,7 @@ #include <sys/systm.h> #include <sys/malloc.h> #include <sys/mbuf.h> +#include <sys/proc.h> #include <sys/dkstat.h> #include <sys/socket.h> #include <sys/sockio.h> @@ -178,10 +179,10 @@ static void sldestroy __P((struct sl_softc *sc)); static struct mbuf *sl_btom __P((struct sl_softc *, int)); static timeout_t sl_keepalive; static timeout_t sl_outfill; -static int slclose __P((struct tty *,int)); -static int slinput __P((int, struct tty *)); +static l_close_t slclose; +static l_rint_t slinput; +static l_ioctl_t sltioctl; static int slioctl __P((struct ifnet *, u_long, caddr_t)); -static int sltioctl __P((struct tty *, u_long, caddr_t, int, struct proc *)); static int slopen __P((dev_t, struct tty *)); static int sloutput __P((struct ifnet *, struct mbuf *, struct sockaddr *, struct rtentry *)); @@ -336,11 +337,10 @@ slopen(dev, tp) dev_t dev; register struct tty *tp; { - struct proc *p = curproc; /* XXX */ register struct sl_softc *sc; int s, error; - error = suser(p); + error = suser_td(curthread); if (error) return (error); @@ -437,12 +437,12 @@ slclose(tp,flag) */ /* ARGSUSED */ static int -sltioctl(tp, cmd, data, flag, p) +sltioctl(tp, cmd, data, flag, td) struct tty *tp; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct sl_softc *sc = (struct sl_softc *)tp->t_sc, *nc; int s, unit, wasup; diff --git a/sys/net/if_tap.c b/sys/net/if_tap.c index 6e60b5b..f41fbd3 100644 --- a/sys/net/if_tap.c +++ b/sys/net/if_tap.c @@ -389,17 +389,17 @@ tapcreate(dev) * to open tunnel. must be superuser */ static int -tapopen(dev, flag, mode, p) +tapopen(dev, flag, mode, td) dev_t dev; int flag; int mode; - struct proc *p; + struct thread *td; { struct tap_softc *tp = NULL; int unit, error; struct resource *r = NULL; - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) return (error); unit = dev2unit(dev) & TAPMAXUNIT; @@ -428,7 +428,7 @@ tapopen(dev, flag, mode, p) bcopy(tp->arpcom.ac_enaddr, tp->ether_addr, sizeof(tp->ether_addr)); tp->tap_unit = r; - tp->tap_pid = p->p_pid; + tp->tap_pid = td->td_proc->p_pid; tp->tap_flags |= TAP_OPEN; TAPDEBUG("%s%d is open. minor = %#x\n", @@ -444,11 +444,11 @@ tapopen(dev, flag, mode, p) * close the device - mark i/f down & delete routing info */ static int -tapclose(dev, foo, bar, p) +tapclose(dev, foo, bar, td) dev_t dev; int foo; int bar; - struct proc *p; + struct thread *td; { int s, error; struct tap_softc *tp = dev->si_drv1; @@ -643,12 +643,12 @@ tapifstart(ifp) * the cdevsw interface is now pretty minimal */ static int -tapioctl(dev, cmd, data, flag, p) +tapioctl(dev, cmd, data, flag, td) dev_t dev; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct tap_softc *tp = dev->si_drv1; struct ifnet *ifp = &tp->tap_if; @@ -911,10 +911,10 @@ tapwrite(dev, uio, flag) * anyway, it either accepts the packet or drops it */ static int -tappoll(dev, events, p) +tappoll(dev, events, td) dev_t dev; int events; - struct proc *p; + struct thread *td; { struct tap_softc *tp = dev->si_drv1; struct ifnet *ifp = &tp->tap_if; @@ -935,7 +935,7 @@ tappoll(dev, events, p) TAPDEBUG("%s%d waiting for data, minor = %#x\n", ifp->if_name, ifp->if_unit, minor(dev)); - selrecord(p, &tp->tap_rsel); + selrecord(curthread, &tp->tap_rsel); } } diff --git a/sys/net/if_tun.c b/sys/net/if_tun.c index 1e6f19b..92bf7f6 100644 --- a/sys/net/if_tun.c +++ b/sys/net/if_tun.c @@ -259,7 +259,7 @@ tuncreate(dev_t dev) } static int -tunopen(dev_t dev, int flag, int mode, struct proc *p) +tunopen(dev_t dev, int flag, int mode, struct thread *td) { struct resource *r; struct ifnet *ifp; @@ -284,7 +284,7 @@ tunopen(dev_t dev, int flag, int mode, struct proc *p) } KASSERT(!(tp->tun_flags & TUN_OPEN), ("Resource & flags out-of-sync")); tp->r_unit = r; - tp->tun_pid = p->p_pid; + tp->tun_pid = td->td_proc->p_pid; ifp = &tp->tun_if; tp->tun_flags |= TUN_OPEN; TUNDEBUG("%s%d: open\n", ifp->if_name, ifp->if_unit); @@ -297,7 +297,7 @@ tunopen(dev_t dev, int flag, int mode, struct proc *p) * routing info */ static int -tunclose(dev_t dev, int foo, int bar, struct proc *p) +tunclose(dev_t dev, int foo, int bar, struct thread *td) { struct tun_softc *tp; struct ifnet *ifp; @@ -520,7 +520,7 @@ tunoutput( * the cdevsw interface is now pretty minimal. */ static int -tunioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) +tunioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td) { int s; int error; @@ -532,7 +532,8 @@ tunioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) tunp = (struct tuninfo *)data; if (tunp->mtu < IF_MINMTU) return (EINVAL); - if (tp->tun_if.if_mtu != tunp->mtu && (error = suser(p)) != 0) + if (tp->tun_if.if_mtu != tunp->mtu + && (error = suser_td(td)) != 0) return (error); tp->tun_if.if_mtu = tunp->mtu; tp->tun_if.if_type = tunp->type; @@ -584,7 +585,7 @@ tunioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) } break; case TUNSIFPID: - tp->tun_pid = curproc->p_pid; + tp->tun_pid = curthread->td_proc->p_pid; break; case FIONBIO: break; @@ -790,7 +791,7 @@ tunwrite(dev_t dev, struct uio *uio, int flag) * anyway, it either accepts the packet or drops it. */ static int -tunpoll(dev_t dev, int events, struct proc *p) +tunpoll(dev_t dev, int events, struct thread *td) { int s; struct tun_softc *tp = dev->si_drv1; @@ -808,7 +809,7 @@ tunpoll(dev_t dev, int events, struct proc *p) } else { TUNDEBUG("%s%d: tunpoll waiting\n", ifp->if_name, ifp->if_unit); - selrecord(p, &tp->tun_rsel); + selrecord(curthread, &tp->tun_rsel); } } if (events & (POLLOUT | POLLWRNORM)) diff --git a/sys/net/if_var.h b/sys/net/if_var.h index 5a4d92f..597eb64 100644 --- a/sys/net/if_var.h +++ b/sys/net/if_var.h @@ -67,7 +67,7 @@ * Forward structure declarations for function prototypes [sic]. */ struct mbuf; -struct proc; +struct thread; struct rtentry; struct socket; struct ether_header; @@ -410,7 +410,7 @@ int if_setlladdr __P((struct ifnet *, const u_char *, int)); void if_unroute __P((struct ifnet *, int flag, int fam)); void if_up __P((struct ifnet *)); /*void ifinit __P((void));*/ /* declared in systm.h for main() */ -int ifioctl __P((struct socket *, u_long, caddr_t, struct proc *)); +int ifioctl __P((struct socket *, u_long, caddr_t, struct thread *)); int ifpromisc __P((struct ifnet *, int)); struct ifnet *ifunit __P((const char *)); struct ifnet *if_withname __P((struct sockaddr *)); diff --git a/sys/net/ppp_tty.c b/sys/net/ppp_tty.c index 3a95fdb..635e7ad 100644 --- a/sys/net/ppp_tty.c +++ b/sys/net/ppp_tty.c @@ -98,8 +98,8 @@ static int pppopen __P((dev_t dev, struct tty *tp)); static int pppclose __P((struct tty *tp, int flag)); static int pppread __P((struct tty *tp, struct uio *uio, int flag)); static int pppwrite __P((struct tty *tp, struct uio *uio, int flag)); -static int ppptioctl __P((struct tty *tp, u_long cmd, caddr_t data, int flag, - struct proc *)); +static int ppptioctl __P((struct tty *tp, u_long cmd, caddr_t data, + int flag, struct thread *td)); static int pppinput __P((int c, struct tty *tp)); static int pppstart __P((struct tty *tp)); @@ -171,11 +171,11 @@ pppopen(dev, tp) dev_t dev; register struct tty *tp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ register struct ppp_softc *sc; int error, s; - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) return (error); s = spltty(); @@ -188,7 +188,7 @@ pppopen(dev, tp) } } - if ((sc = pppalloc(p->p_pid)) == NULL) { + if ((sc = pppalloc(td->td_proc->p_pid)) == NULL) { splx(s); return ENXIO; } @@ -428,12 +428,12 @@ pppwrite(tp, uio, flag) */ /* ARGSUSED */ static int -ppptioctl(tp, cmd, data, flag, p) +ppptioctl(tp, cmd, data, flag, td) struct tty *tp; u_long cmd; caddr_t data; int flag; - struct proc *p; + struct thread *td; { struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc; int error, s; @@ -444,7 +444,7 @@ ppptioctl(tp, cmd, data, flag, p) error = 0; switch (cmd) { case PPPIOCSASYNCMAP: - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) break; sc->sc_asyncmap[0] = *(u_int *)data; break; @@ -454,7 +454,7 @@ ppptioctl(tp, cmd, data, flag, p) break; case PPPIOCSRASYNCMAP: - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) break; sc->sc_rasyncmap = *(u_int *)data; break; @@ -464,7 +464,7 @@ ppptioctl(tp, cmd, data, flag, p) break; case PPPIOCSXASYNCMAP: - if ((error = suser(p)) != 0) + if ((error = suser_td(td)) != 0) break; s = spltty(); bcopy(data, sc->sc_asyncmap, sizeof(sc->sc_asyncmap)); @@ -479,7 +479,7 @@ ppptioctl(tp, cmd, data, flag, p) break; default: - error = pppioctl(sc, cmd, data, flag, p); + error = pppioctl(sc, cmd, data, flag, td); if (error == 0 && cmd == PPPIOCSMRU) pppgetm(sc); } diff --git a/sys/net/raw_cb.h b/sys/net/raw_cb.h index 6c079a9..59905085 100644 --- a/sys/net/raw_cb.h +++ b/sys/net/raw_cb.h @@ -62,13 +62,21 @@ struct rawcb { #ifdef _KERNEL extern LIST_HEAD(rawcb_list_head, rawcb) rawcb_list; +/* protosw entries */ +pr_ctlinput_t raw_ctlinput; +pr_init_t raw_init; + +/* usrreq entries */ int raw_attach __P((struct socket *, int)); -void raw_ctlinput __P((int, struct sockaddr *, void *)); void raw_detach __P((struct rawcb *)); void raw_disconnect __P((struct rawcb *)); -void raw_init __P((void)); + +#if 0 /* what the ??? */ +pr_input_t raw_input; +#else void raw_input __P((struct mbuf *, struct sockproto *, struct sockaddr *, struct sockaddr *)); +#endif extern struct pr_usrreqs raw_usrreqs; #endif diff --git a/sys/net/raw_usrreq.c b/sys/net/raw_usrreq.c index 102ae69..555bd3f 100644 --- a/sys/net/raw_usrreq.c +++ b/sys/net/raw_usrreq.c @@ -150,26 +150,26 @@ raw_uabort(struct socket *so) /* pru_accept is EOPNOTSUPP */ static int -raw_uattach(struct socket *so, int proto, struct proc *p) +raw_uattach(struct socket *so, int proto, struct thread *td) { struct rawcb *rp = sotorawcb(so); int error; if (rp == 0) return EINVAL; - if (p && (error = suser(p)) != 0) + if (td && (error = suser_td(td)) != 0) return error; return raw_attach(so, proto); } static int -raw_ubind(struct socket *so, struct sockaddr *nam, struct proc *p) +raw_ubind(struct socket *so, struct sockaddr *nam, struct thread *td) { return EINVAL; } static int -raw_uconnect(struct socket *so, struct sockaddr *nam, struct proc *p) +raw_uconnect(struct socket *so, struct sockaddr *nam, struct thread *td) { return EINVAL; } @@ -225,7 +225,7 @@ raw_upeeraddr(struct socket *so, struct sockaddr **nam) static int raw_usend(struct socket *so, int flags, struct mbuf *m, - struct sockaddr *nam, struct mbuf *control, struct proc *p) + struct sockaddr *nam, struct mbuf *control, struct thread *td) { int error; struct rawcb *rp = sotorawcb(so); diff --git a/sys/net/route.h b/sys/net/route.h index bfe72d8..16c59e4 100644 --- a/sys/net/route.h +++ b/sys/net/route.h @@ -271,7 +271,6 @@ extern struct route_cb route_cb; extern struct radix_node_head *rt_tables[AF_MAX+1]; struct ifmultiaddr; -struct proc; void route_init __P((void)); void rt_ifmsg __P((struct ifnet *)); diff --git a/sys/net/rtsock.c b/sys/net/rtsock.c index ede7ad6..e7f3a2c 100644 --- a/sys/net/rtsock.c +++ b/sys/net/rtsock.c @@ -102,7 +102,7 @@ rts_abort(struct socket *so) /* pru_accept is EOPNOTSUPP */ static int -rts_attach(struct socket *so, int proto, struct proc *p) +rts_attach(struct socket *so, int proto, struct thread *td) { struct rawcb *rp; int s, error; @@ -154,21 +154,21 @@ rts_attach(struct socket *so, int proto, struct proc *p) } static int -rts_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +rts_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { int s, error; s = splnet(); - error = raw_usrreqs.pru_bind(so, nam, p); /* xxx just EINVAL */ + error = raw_usrreqs.pru_bind(so, nam, td); /* xxx just EINVAL */ splx(s); return error; } static int -rts_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +rts_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { int s, error; s = splnet(); - error = raw_usrreqs.pru_connect(so, nam, p); /* XXX just EINVAL */ + error = raw_usrreqs.pru_connect(so, nam, td); /* XXX just EINVAL */ splx(s); return error; } @@ -232,11 +232,11 @@ rts_peeraddr(struct socket *so, struct sockaddr **nam) static int rts_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { int s, error; s = splnet(); - error = raw_usrreqs.pru_send(so, flags, m, nam, control, p); + error = raw_usrreqs.pru_send(so, flags, m, nam, control, td); splx(s); return error; } diff --git a/sys/netatalk/at_control.c b/sys/netatalk/at_control.c index 3107225..5144115 100644 --- a/sys/netatalk/at_control.c +++ b/sys/netatalk/at_control.c @@ -43,7 +43,7 @@ static int aa_claim_addr(struct ifaddr *ifa, struct sockaddr *gw); int at_control(struct socket *so, u_long cmd, caddr_t data, - struct ifnet *ifp, struct proc *p ) + struct ifnet *ifp, struct thread *td ) { struct ifreq *ifr = (struct ifreq *)data; struct sockaddr_at *sat; @@ -99,7 +99,7 @@ at_control(struct socket *so, u_long cmd, caddr_t data, /* * If we are not superuser, then we don't get to do these ops. */ - if ( suser(p) ) { + if ( suser_td(td) ) { return( EPERM ); } diff --git a/sys/netatalk/at_extern.h b/sys/netatalk/at_extern.h index 8191d4f..583bbec 100644 --- a/sys/netatalk/at_extern.h +++ b/sys/netatalk/at_extern.h @@ -1,3 +1,6 @@ +/* + * $FreeBSD$ + */ struct mbuf; struct sockaddr_at; @@ -16,7 +19,7 @@ extern void aarptfree __P((struct aarptab *)); #endif struct ifnet; -struct proc; +struct thread; struct socket; extern void aarp_clean __P((void)); @@ -24,7 +27,7 @@ extern int at_control __P(( struct socket *so, u_long cmd, caddr_t data, struct ifnet *ifp, - struct proc *p )); + struct thread *td )); extern u_short at_cksum __P(( struct mbuf *m, int skip)); extern void ddp_init __P((void )); extern struct at_ifaddr *at_ifawithnet __P((struct sockaddr_at *)); diff --git a/sys/netatalk/ddp_pcb.c b/sys/netatalk/ddp_pcb.c index 7390d8d..2dbf0f9 100644 --- a/sys/netatalk/ddp_pcb.c +++ b/sys/netatalk/ddp_pcb.c @@ -23,9 +23,9 @@ static void at_pcbdisconnect( struct ddpcb *ddp ); static void at_sockaddr(struct ddpcb *ddp, struct sockaddr **addr); static int at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, - struct proc *p); + struct thread *td); static int at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, - struct proc *p); + struct thread *td); static void at_pcbdetach(struct socket *so, struct ddpcb *ddp); static int at_pcballoc(struct socket *so); @@ -36,7 +36,7 @@ static u_long ddp_recvspace = 10 * ( 587 + sizeof( struct sockaddr_at )); static int -ddp_attach(struct socket *so, int proto, struct proc *p) +ddp_attach(struct socket *so, int proto, struct thread *td) { struct ddpcb *ddp; int error = 0; @@ -74,7 +74,7 @@ ddp_detach(struct socket *so) } static int -ddp_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +ddp_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { struct ddpcb *ddp; int error = 0; @@ -85,13 +85,13 @@ ddp_bind(struct socket *so, struct sockaddr *nam, struct proc *p) return( EINVAL); } s = splnet(); - error = at_pcbsetaddr(ddp, nam, p); + error = at_pcbsetaddr(ddp, nam, td); splx(s); return (error); } static int -ddp_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +ddp_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { struct ddpcb *ddp; int error = 0; @@ -107,7 +107,7 @@ ddp_connect(struct socket *so, struct sockaddr *nam, struct proc *p) } s = splnet(); - error = at_pcbconnect( ddp, nam, p ); + error = at_pcbconnect( ddp, nam, td ); splx(s); if ( error == 0 ) soisconnected( so ); @@ -152,7 +152,7 @@ ddp_shutdown(struct socket *so) static int ddp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { struct ddpcb *ddp; int error = 0; @@ -173,7 +173,7 @@ ddp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, } s = splnet(); - error = at_pcbconnect(ddp, addr, p); + error = at_pcbconnect(ddp, addr, td); splx( s ); if ( error ) { return(error); @@ -218,7 +218,7 @@ at_sockaddr(struct ddpcb *ddp, struct sockaddr **addr) } static int -at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct proc *p) +at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td) { struct sockaddr_at lsat, *sat; struct at_ifaddr *aa; @@ -253,7 +253,7 @@ at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct proc *p) return( EINVAL ); } if ( sat->sat_port < ATPORT_RESERVED && - suser(p) ) { + suser_td(td) ) { return( EACCES ); } } @@ -312,7 +312,7 @@ at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct proc *p) } static int -at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct proc *p) +at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td) { struct sockaddr_at *sat = (struct sockaddr_at *)addr; struct route *ro; @@ -401,7 +401,7 @@ at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct proc *p) ddp->ddp_fsat = *sat; if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) { - return(at_pcbsetaddr(ddp, (struct sockaddr *)0, p)); + return(at_pcbsetaddr(ddp, (struct sockaddr *)0, td)); } return( 0 ); } diff --git a/sys/netatalk/ddp_usrreq.c b/sys/netatalk/ddp_usrreq.c index 7390d8d..2dbf0f9 100644 --- a/sys/netatalk/ddp_usrreq.c +++ b/sys/netatalk/ddp_usrreq.c @@ -23,9 +23,9 @@ static void at_pcbdisconnect( struct ddpcb *ddp ); static void at_sockaddr(struct ddpcb *ddp, struct sockaddr **addr); static int at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, - struct proc *p); + struct thread *td); static int at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, - struct proc *p); + struct thread *td); static void at_pcbdetach(struct socket *so, struct ddpcb *ddp); static int at_pcballoc(struct socket *so); @@ -36,7 +36,7 @@ static u_long ddp_recvspace = 10 * ( 587 + sizeof( struct sockaddr_at )); static int -ddp_attach(struct socket *so, int proto, struct proc *p) +ddp_attach(struct socket *so, int proto, struct thread *td) { struct ddpcb *ddp; int error = 0; @@ -74,7 +74,7 @@ ddp_detach(struct socket *so) } static int -ddp_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +ddp_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { struct ddpcb *ddp; int error = 0; @@ -85,13 +85,13 @@ ddp_bind(struct socket *so, struct sockaddr *nam, struct proc *p) return( EINVAL); } s = splnet(); - error = at_pcbsetaddr(ddp, nam, p); + error = at_pcbsetaddr(ddp, nam, td); splx(s); return (error); } static int -ddp_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +ddp_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { struct ddpcb *ddp; int error = 0; @@ -107,7 +107,7 @@ ddp_connect(struct socket *so, struct sockaddr *nam, struct proc *p) } s = splnet(); - error = at_pcbconnect( ddp, nam, p ); + error = at_pcbconnect( ddp, nam, td ); splx(s); if ( error == 0 ) soisconnected( so ); @@ -152,7 +152,7 @@ ddp_shutdown(struct socket *so) static int ddp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { struct ddpcb *ddp; int error = 0; @@ -173,7 +173,7 @@ ddp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, } s = splnet(); - error = at_pcbconnect(ddp, addr, p); + error = at_pcbconnect(ddp, addr, td); splx( s ); if ( error ) { return(error); @@ -218,7 +218,7 @@ at_sockaddr(struct ddpcb *ddp, struct sockaddr **addr) } static int -at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct proc *p) +at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td) { struct sockaddr_at lsat, *sat; struct at_ifaddr *aa; @@ -253,7 +253,7 @@ at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct proc *p) return( EINVAL ); } if ( sat->sat_port < ATPORT_RESERVED && - suser(p) ) { + suser_td(td) ) { return( EACCES ); } } @@ -312,7 +312,7 @@ at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct proc *p) } static int -at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct proc *p) +at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td) { struct sockaddr_at *sat = (struct sockaddr_at *)addr; struct route *ro; @@ -401,7 +401,7 @@ at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct proc *p) ddp->ddp_fsat = *sat; if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) { - return(at_pcbsetaddr(ddp, (struct sockaddr *)0, p)); + return(at_pcbsetaddr(ddp, (struct sockaddr *)0, td)); } return( 0 ); } diff --git a/sys/netatm/atm_aal5.c b/sys/netatm/atm_aal5.c index ba79a5b..f0beaca 100644 --- a/sys/netatm/atm_aal5.c +++ b/sys/netatm/atm_aal5.c @@ -68,21 +68,21 @@ u_long atm_aal5_recvspace = 64 * 1024; /* XXX */ /* * Local functions */ -static int atm_aal5_attach __P((struct socket *, int, struct proc *)); +static int atm_aal5_attach __P((struct socket *, int, struct thread *td)); static int atm_aal5_detach __P((struct socket *)); static int atm_aal5_bind __P((struct socket *, struct sockaddr *, - struct proc *)); -static int atm_aal5_listen __P((struct socket *, struct proc *)); + struct thread *td)); +static int atm_aal5_listen __P((struct socket *, struct thread *td)); static int atm_aal5_connect __P((struct socket *, struct sockaddr *, - struct proc *)); + struct thread *td)); static int atm_aal5_accept __P((struct socket *, struct sockaddr **)); static int atm_aal5_disconnect __P((struct socket *)); static int atm_aal5_shutdown __P((struct socket *)); static int atm_aal5_send __P((struct socket *, int, KBuffer *, - struct sockaddr *, KBuffer *, struct proc *)); + struct sockaddr *, KBuffer *, struct thread *td)); static int atm_aal5_abort __P((struct socket *)); static int atm_aal5_control __P((struct socket *, u_long, caddr_t, - struct ifnet *, struct proc *)); + struct ifnet *, struct thread *td)); static int atm_aal5_sense __P((struct socket *, struct stat *)); static int atm_aal5_sockaddr __P((struct socket *, struct sockaddr **)); static int atm_aal5_peeraddr __P((struct socket *, struct sockaddr **)); @@ -244,10 +244,10 @@ static Atm_attributes atm_aal5_defattr = { * */ static int -atm_aal5_attach(so, proto, p) +atm_aal5_attach(so, proto, td) struct socket *so; int proto; - struct proc *p; + struct thread *td; { Atm_pcb *atp; @@ -314,10 +314,10 @@ atm_aal5_detach(so) * */ static int -atm_aal5_bind(so, addr, p) +atm_aal5_bind(so, addr, td) struct socket *so; struct sockaddr *addr; - struct proc *p; + struct thread *td; { ATM_INTRO("bind"); @@ -340,9 +340,9 @@ atm_aal5_bind(so, addr, p) * */ static int -atm_aal5_listen(so, p) +atm_aal5_listen(so, td) struct socket *so; - struct proc *p; + struct thread *td; { ATM_INTRO("listen"); @@ -366,10 +366,10 @@ atm_aal5_listen(so, p) * */ static int -atm_aal5_connect(so, addr, p) +atm_aal5_connect(so, addr, td) struct socket *so; struct sockaddr *addr; - struct proc *p; + struct thread *td; { Atm_pcb *atp; @@ -385,7 +385,7 @@ atm_aal5_connect(so, addr, p) size = atp->atp_attr.aal.v.aal5.forward_max_SDU_size; if (size != T_ATM_ABSENT) - if (!sbreserve(&so->so_snd, size, so, p)) { + if (!sbreserve(&so->so_snd, size, so, td)) { err = ENOBUFS; ATM_OUTRO(); } @@ -493,13 +493,13 @@ atm_aal5_shutdown(so) * */ static int -atm_aal5_send(so, flags, m, addr, control, p) +atm_aal5_send(so, flags, m, addr, control, td) struct socket *so; int flags; KBuffer *m; struct sockaddr *addr; KBuffer *control; - struct proc *p; + struct thread *td; { Atm_pcb *atp; @@ -585,12 +585,12 @@ atm_aal5_abort(so) * */ static int -atm_aal5_control(so, cmd, data, ifp, p) +atm_aal5_control(so, cmd, data, ifp, td) struct socket *so; u_long cmd; caddr_t data; struct ifnet *ifp; - struct proc *p; + struct thread *td; { ATM_INTRO("control"); diff --git a/sys/netatm/atm_proto.c b/sys/netatm/atm_proto.c index c28f919..6de7a83 100644 --- a/sys/netatm/atm_proto.c +++ b/sys/netatm/atm_proto.c @@ -158,10 +158,10 @@ atm_proto_notsupp1(so) * */ int -atm_proto_notsupp2(so, addr, p) +atm_proto_notsupp2(so, addr, td) struct socket *so; struct sockaddr *addr; - struct proc *p; + struct thread *td; { return (EOPNOTSUPP); } @@ -203,13 +203,13 @@ atm_proto_notsupp3(so, addr) * */ int -atm_proto_notsupp4(so, i, m, addr, m2, p) +atm_proto_notsupp4(so, i, m, addr, m2, td) struct socket *so; int i; KBuffer *m; struct sockaddr *addr; KBuffer *m2; - struct proc *p; + struct thread *td; { return (EOPNOTSUPP); } diff --git a/sys/netatm/atm_usrreq.c b/sys/netatm/atm_usrreq.c index 6965d9c..361665b 100644 --- a/sys/netatm/atm_usrreq.c +++ b/sys/netatm/atm_usrreq.c @@ -62,9 +62,9 @@ __RCSID("@(#) $FreeBSD$"); /* * Local functions */ -static int atm_dgram_attach __P((struct socket *, int, struct proc *)); +static int atm_dgram_attach __P((struct socket *, int, struct thread *)); static int atm_dgram_control __P((struct socket *, u_long, caddr_t, - struct ifnet *, struct proc *)); + struct ifnet *, struct thread *)); static int atm_dgram_info __P((caddr_t)); @@ -143,10 +143,10 @@ struct pr_usrreqs atm_dgram_usrreqs = { * */ static int -atm_dgram_attach(so, proto, p) +atm_dgram_attach(so, proto, td) struct socket *so; int proto; - struct proc *p; + struct thread *td; { ATM_INTRO(); @@ -173,12 +173,12 @@ atm_dgram_attach(so, proto, p) * */ static int -atm_dgram_control(so, cmd, data, ifp, p) +atm_dgram_control(so, cmd, data, ifp, td) struct socket *so; u_long cmd; caddr_t data; struct ifnet *ifp; - struct proc *p; + struct thread *td; { ATM_INTRO(); @@ -192,7 +192,7 @@ atm_dgram_control(so, cmd, data, ifp, p) struct atmcfgreq *acp = (struct atmcfgreq *)data; struct atm_pif *pip; - if (p && (suser(p) != 0)) + if (td && (suser_td(td) != 0)) ATM_RETERR(EPERM); switch (acp->acr_opcode) { @@ -225,7 +225,7 @@ atm_dgram_control(so, cmd, data, ifp, p) struct atmaddreq *aap = (struct atmaddreq *)data; Atm_endpoint *epp; - if (p && (suser(p) != 0)) + if (td && (suser_td(td) != 0)) ATM_RETERR(EPERM); switch (aap->aar_opcode) { @@ -275,7 +275,7 @@ atm_dgram_control(so, cmd, data, ifp, p) struct sigmgr *smp; Atm_endpoint *epp; - if (p && (suser(p) != 0)) + if (td && (suser_td(td) != 0)) ATM_RETERR(EPERM); switch (adp->adr_opcode) { @@ -328,7 +328,7 @@ atm_dgram_control(so, cmd, data, ifp, p) struct sigmgr *smp; struct ifnet *ifp2; - if (p && (suser(p) != 0)) + if (td && (suser_td(td) != 0)) ATM_RETERR(EPERM); switch (asp->asr_opcode) { diff --git a/sys/netatm/atm_var.h b/sys/netatm/atm_var.h index 66edeb5..4c76bab 100644 --- a/sys/netatm/atm_var.h +++ b/sys/netatm/atm_var.h @@ -150,10 +150,10 @@ struct atm_nif * #if (defined(__FreeBSD__) && (BSD >= 199506)) int atm_proto_notsupp1 __P((struct socket *)); int atm_proto_notsupp2 __P((struct socket *, struct sockaddr *, - struct proc *)); + struct thread *)); int atm_proto_notsupp3 __P((struct socket *, struct sockaddr **)); int atm_proto_notsupp4 __P((struct socket *, int, KBuffer *, - struct sockaddr *, KBuffer *, struct proc *)); + struct sockaddr *, KBuffer *, struct thread *)); #endif /* atm_signal.c */ diff --git a/sys/netgraph/ng_ether.c b/sys/netgraph/ng_ether.c index 18faa65..69e1b35 100644 --- a/sys/netgraph/ng_ether.c +++ b/sys/netgraph/ng_ether.c @@ -609,6 +609,9 @@ ng_ether_rcvdata(hook_p hook, item_p item) if (hook == priv->upper) return ng_ether_rcv_upper(node, m, meta); panic("%s: weird hook", __FUNCTION__); +#ifdef RESTARTABLE_PANICS /* so we don;t get an error msg in LINT */ + return NULL; +#endif } /* diff --git a/sys/netgraph/ng_ksocket.c b/sys/netgraph/ng_ksocket.c index c29aa7d..b47fe2c 100644 --- a/sys/netgraph/ng_ksocket.c +++ b/sys/netgraph/ng_ksocket.c @@ -548,7 +548,7 @@ ng_ksocket_constructor(node_p node) static int ng_ksocket_newhook(node_p node, hook_p hook, const char *name0) { - struct proc *p = curproc ? curproc : &proc0; /* XXX broken */ + struct thread *td = curthread ? curthread : thread0; /* XXX broken */ const priv_p priv = NG_NODE_PRIVATE(node); char *s1, *s2, name[NG_HOOKLEN+1]; int family, type, protocol, error; @@ -586,7 +586,7 @@ ng_ksocket_newhook(node_p node, hook_p hook, const char *name0) return (EINVAL); /* Create the socket */ - error = socreate(family, &priv->so, type, protocol, p); + error = socreate(family, &priv->so, type, protocol, td); if (error != 0) return (error); @@ -656,7 +656,7 @@ ng_ksocket_connect(hook_p hook) static int ng_ksocket_rcvmsg(node_p node, item_p item, hook_p lasthook) { - struct proc *p = curproc ? curproc : &proc0; /* XXX broken */ + struct thread *td = curthread ? curthread : thread0; /* XXX broken */ const priv_p priv = NG_NODE_PRIVATE(node); struct socket *const so = priv->so; struct ng_mesg *resp = NULL; @@ -681,7 +681,7 @@ ng_ksocket_rcvmsg(node_p node, item_p item, hook_p lasthook) ERROUT(ENXIO); /* Bind */ - error = sobind(so, sa, p); + error = sobind(so, sa, td); break; } case NGM_KSOCKET_LISTEN: @@ -693,7 +693,7 @@ ng_ksocket_rcvmsg(node_p node, item_p item, hook_p lasthook) ERROUT(ENXIO); /* Listen */ - error = solisten(so, *((int32_t *)msg->data), p); + error = solisten(so, *((int32_t *)msg->data), td); break; } @@ -744,7 +744,7 @@ ng_ksocket_rcvmsg(node_p node, item_p item, hook_p lasthook) /* Do connect */ if ((so->so_state & SS_ISCONNECTING) != 0) ERROUT(EALREADY); - if ((error = soconnect(so, sa, p)) != 0) { + if ((error = soconnect(so, sa, td)) != 0) { so->so_state &= ~SS_ISCONNECTING; ERROUT(error); } @@ -821,7 +821,7 @@ ng_ksocket_rcvmsg(node_p node, item_p item, hook_p lasthook) sopt.sopt_dir = SOPT_GET; sopt.sopt_level = ksopt->level; sopt.sopt_name = ksopt->name; - sopt.sopt_p = NULL; + sopt.sopt_td = NULL; sopt.sopt_valsize = NG_KSOCKET_MAX_OPTLEN; ksopt = (struct ng_ksocket_sockopt *)resp->data; sopt.sopt_val = ksopt->value; @@ -855,7 +855,7 @@ ng_ksocket_rcvmsg(node_p node, item_p item, hook_p lasthook) sopt.sopt_name = ksopt->name; sopt.sopt_val = ksopt->value; sopt.sopt_valsize = valsize; - sopt.sopt_p = NULL; + sopt.sopt_td = NULL; error = sosetopt(so, &sopt); break; } @@ -881,7 +881,7 @@ done: static int ng_ksocket_rcvdata(hook_p hook, item_p item) { - struct proc *p = curproc ? curproc : &proc0; /* XXX broken */ + struct thread *td = curthread ? curthread : thread0; /* XXX broken */ const node_p node = NG_HOOK_NODE(hook); const priv_p priv = NG_NODE_PRIVATE(node); struct socket *const so = priv->so; @@ -890,7 +890,7 @@ ng_ksocket_rcvdata(hook_p hook, item_p item) NGI_GET_M(item, m); NG_FREE_ITEM(item); - error = (*so->so_proto->pr_usrreqs->pru_sosend)(so, 0, 0, m, 0, 0, p); + error = (*so->so_proto->pr_usrreqs->pru_sosend)(so, 0, 0, m, 0, 0, td); return (error); } @@ -1053,7 +1053,7 @@ ng_ksocket_incoming2(node_p node, hook_p hook, void *arg1, int waitflag) } /* Read and forward available mbuf's */ - auio.uio_procp = NULL; + auio.uio_td = NULL; auio.uio_resid = 1000000000; flags = MSG_DONTWAIT; do { diff --git a/sys/netgraph/ng_mppc.c b/sys/netgraph/ng_mppc.c index e0bd485..a1d6ce8 100644 --- a/sys/netgraph/ng_mppc.c +++ b/sys/netgraph/ng_mppc.c @@ -388,6 +388,9 @@ ng_mppc_rcvdata(hook_p hook, item_p item) /* Oops */ panic("%s: unknown hook", __FUNCTION__); +#ifdef RESTARTABLE_PANICS + return (EINVAL); +#endif } /* diff --git a/sys/netgraph/ng_parse.c b/sys/netgraph/ng_parse.c index 5daf600..fa29c6b 100644 --- a/sys/netgraph/ng_parse.c +++ b/sys/netgraph/ng_parse.c @@ -378,6 +378,9 @@ ng_int8_unparse(const struct ng_parse_type *type, break; default: panic("%s: unknown type", __FUNCTION__); +#ifdef RESTARTABLE_PANICS + return(0); +#endif } NG_PARSE_APPEND(fmt, fval); *off += sizeof(int8_t); @@ -472,6 +475,9 @@ ng_int16_unparse(const struct ng_parse_type *type, break; default: panic("%s: unknown type", __FUNCTION__); +#ifdef RESTARTABLE_PANICS + return(0); +#endif } NG_PARSE_APPEND(fmt, fval); *off += sizeof(int16_t); @@ -566,6 +572,9 @@ ng_int32_unparse(const struct ng_parse_type *type, break; default: panic("%s: unknown type", __FUNCTION__); +#ifdef RESTARTABLE_PANICS + return(0); +#endif } NG_PARSE_APPEND(fmt, fval); *off += sizeof(int32_t); @@ -659,6 +668,9 @@ ng_int64_unparse(const struct ng_parse_type *type, break; default: panic("%s: unknown type", __FUNCTION__); +#ifdef RESTARTABLE_PANICS + return(0); +#endif } NG_PARSE_APPEND(fmt, fval); *off += sizeof(int64_t); diff --git a/sys/netgraph/ng_socket.c b/sys/netgraph/ng_socket.c index 09b8ab7..a7e7e20 100644 --- a/sys/netgraph/ng_socket.c +++ b/sys/netgraph/ng_socket.c @@ -117,7 +117,7 @@ static int ng_attach_data(struct socket *so); static int ng_attach_cntl(struct socket *so); static int ng_attach_common(struct socket *so, int type); static void ng_detach_common(struct ngpcb *pcbp, int type); -/*static int ng_internalize(struct mbuf *m, struct proc *p); */ +/*static int ng_internalize(struct mbuf *m, struct thread *p); */ static int ng_connect_data(struct sockaddr *nam, struct ngpcb *pcbp); static int ng_bind(struct sockaddr *nam, struct ngpcb *pcbp); @@ -162,11 +162,11 @@ LIST_HEAD(, ngpcb) ngsocklist; ***************************************************************/ static int -ngc_attach(struct socket *so, int proto, struct proc *p) +ngc_attach(struct socket *so, int proto, struct thread *td) { struct ngpcb *const pcbp = sotongpcb(so); - if (suser(p)) + if (suser_td(td)) return (EPERM); if (pcbp != NULL) return (EISCONN); @@ -186,7 +186,7 @@ ngc_detach(struct socket *so) static int ngc_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { struct ngpcb *const pcbp = sotongpcb(so); struct sockaddr_ng *const sap = (struct sockaddr_ng *) addr; @@ -200,7 +200,7 @@ ngc_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, goto release; } #ifdef NOTYET - if (control && (error = ng_internalize(control, p))) { + if (control && (error = ng_internalize(control, td))) { if (pcbp->sockdata == NULL) { error = ENOTCONN; goto release; @@ -287,7 +287,7 @@ release: } static int -ngc_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +ngc_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { struct ngpcb *const pcbp = sotongpcb(so); @@ -297,7 +297,7 @@ ngc_bind(struct socket *so, struct sockaddr *nam, struct proc *p) } static int -ngc_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +ngc_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { printf(" program tried to connect control socket to remote node\n "); /* @@ -312,7 +312,7 @@ printf(" program tried to connect control socket to remote node\n "); ***************************************************************/ static int -ngd_attach(struct socket *so, int proto, struct proc *p) +ngd_attach(struct socket *so, int proto, struct thread *td) { struct ngpcb *const pcbp = sotongpcb(so); @@ -334,7 +334,7 @@ ngd_detach(struct socket *so) static int ngd_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { struct ngpcb *const pcbp = sotongpcb(so); struct sockaddr_ng *const sap = (struct sockaddr_ng *) addr; @@ -402,7 +402,7 @@ release: } static int -ngd_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +ngd_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { struct ngpcb *const pcbp = sotongpcb(so); @@ -567,9 +567,9 @@ ng_detach_common(struct ngpcb *pcbp, int which) * which after all is the purpose of this whole system. */ static int -ng_internalize(struct mbuf *control, struct proc *p) +ng_internalize(struct mbuf *control, struct thread *td) { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct cmsghdr *cm = mtod(control, struct cmsghdr *); struct file *fp; struct vnode *vn; diff --git a/sys/netgraph/ng_tee.c b/sys/netgraph/ng_tee.c index e95c41f..7b47617 100644 --- a/sys/netgraph/ng_tee.c +++ b/sys/netgraph/ng_tee.c @@ -309,8 +309,12 @@ ngt_rcvdata(hook_p hook, item_p item) } else if (hinfo == &sc->left2right) { dup = NULL; dest = &sc->left; - } else + } else { panic("%s: no hook!", __FUNCTION__); +#ifdef RESTARTABLE_PANICS + return(EINVAL); +#endif + } /* Update stats on incoming hook */ hinfo->stats.inOctets += m->m_pkthdr.len; diff --git a/sys/netgraph/ng_tty.c b/sys/netgraph/ng_tty.c index 690892f..cb3c770 100644 --- a/sys/netgraph/ng_tty.c +++ b/sys/netgraph/ng_tty.c @@ -120,7 +120,7 @@ static int ngt_close(struct tty *tp, int flag); static int ngt_read(struct tty *tp, struct uio *uio, int flag); static int ngt_write(struct tty *tp, struct uio *uio, int flag); static int ngt_tioctl(struct tty *tp, - u_long cmd, caddr_t data, int flag, struct proc *); + u_long cmd, caddr_t data, int flag, struct thread *); static int ngt_input(int c, struct tty *tp); static int ngt_start(struct tty *tp); @@ -184,13 +184,13 @@ static int ngt_ldisc; static int ngt_open(dev_t dev, struct tty *tp) { - struct proc *const p = curproc; /* XXX */ + struct thread *const td = curthread; /* XXX */ char name[sizeof(NG_TTY_NODE_TYPE) + 8]; sc_p sc; int s, error; /* Super-user only */ - if ((error = suser(p))) + if ((error = suser_td(td))) return (error); s = splnet(); (void) spltty(); /* XXX is this necessary? */ @@ -304,7 +304,7 @@ ngt_write(struct tty *tp, struct uio *uio, int flag) * We implement the NGIOCGINFO ioctl() defined in ng_message.h. */ static int -ngt_tioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, struct proc *p) +ngt_tioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, struct thread *td) { const sc_p sc = (sc_p) tp->t_sc; int s, error = 0; diff --git a/sys/netinet/in.c b/sys/netinet/in.c index c0b45c3..d56d28e 100644 --- a/sys/netinet/in.c +++ b/sys/netinet/in.c @@ -57,7 +57,7 @@ static MALLOC_DEFINE(M_IPMADDR, "in_multi", "internet multicast address"); static int in_mask2len __P((struct in_addr *)); static void in_len2mask __P((struct in_addr *, int)); static int in_lifaddr_ioctl __P((struct socket *, u_long, caddr_t, - struct ifnet *, struct proc *)); + struct ifnet *, struct thread *)); static void in_socktrim __P((struct sockaddr_in *)); static int in_ifinit __P((struct ifnet *, @@ -183,12 +183,12 @@ static int in_interfaces; /* number of external internet interfaces */ */ /* ARGSUSED */ int -in_control(so, cmd, data, ifp, p) +in_control(so, cmd, data, ifp, td) struct socket *so; u_long cmd; caddr_t data; register struct ifnet *ifp; - struct proc *p; + struct thread *td; { register struct ifreq *ifr = (struct ifreq *)data; register struct in_ifaddr *ia = 0, *iap; @@ -202,13 +202,13 @@ in_control(so, cmd, data, ifp, p) switch (cmd) { case SIOCALIFADDR: case SIOCDLIFADDR: - if (p && (error = suser(p)) != 0) + if (td && (error = suser_td(td)) != 0) return error; /*fall through*/ case SIOCGLIFADDR: if (!ifp) return EINVAL; - return in_lifaddr_ioctl(so, cmd, data, ifp, p); + return in_lifaddr_ioctl(so, cmd, data, ifp, td); } /* @@ -257,7 +257,7 @@ in_control(so, cmd, data, ifp, p) case SIOCSIFADDR: case SIOCSIFNETMASK: case SIOCSIFDSTADDR: - if (p && (error = suser(p)) != 0) + if (td && (error = suser_td(td)) != 0) return error; if (ifp == 0) @@ -293,7 +293,7 @@ in_control(so, cmd, data, ifp, p) break; case SIOCSIFBRDADDR: - if (p && (error = suser(p)) != 0) + if (td && (error = suser_td(td)) != 0) return error; /* FALLTHROUGH */ @@ -454,12 +454,12 @@ in_control(so, cmd, data, ifp, p) * other values may be returned from in_ioctl() */ static int -in_lifaddr_ioctl(so, cmd, data, ifp, p) +in_lifaddr_ioctl(so, cmd, data, ifp, td) struct socket *so; u_long cmd; caddr_t data; struct ifnet *ifp; - struct proc *p; + struct thread *td; { struct if_laddrreq *iflr = (struct if_laddrreq *)data; struct ifaddr *ifa; @@ -521,7 +521,7 @@ in_lifaddr_ioctl(so, cmd, data, ifp, p) ifra.ifra_mask.sin_len = sizeof(struct sockaddr_in); in_len2mask(&ifra.ifra_mask.sin_addr, iflr->prefixlen); - return in_control(so, SIOCAIFADDR, (caddr_t)&ifra, ifp, p); + return in_control(so, SIOCAIFADDR, (caddr_t)&ifra, ifp, td); } case SIOCGLIFADDR: case SIOCDLIFADDR: @@ -607,7 +607,7 @@ in_lifaddr_ioctl(so, cmd, data, ifp, p) ia->ia_sockmask.sin_len); return in_control(so, SIOCDIFADDR, (caddr_t)&ifra, - ifp, p); + ifp, td); } } } diff --git a/sys/netinet/in_gif.c b/sys/netinet/in_gif.c index 46c10e0..8e41fa2 100644 --- a/sys/netinet/in_gif.c +++ b/sys/netinet/in_gif.c @@ -299,7 +299,7 @@ gif_encapcheck4(m, off, proto, arg) dst = (struct sockaddr_in *)sc->gif_pdst; /* LINTED const cast */ - m_copydata((struct mbuf *)m, 0, sizeof(ip), (caddr_t)&ip); + m_copydata(m, 0, sizeof(ip), (caddr_t)&ip); /* check for address match */ addrmatch = 0; diff --git a/sys/netinet/in_pcb.c b/sys/netinet/in_pcb.c index c967851..0b54024 100644 --- a/sys/netinet/in_pcb.c +++ b/sys/netinet/in_pcb.c @@ -136,10 +136,10 @@ SYSCTL_PROC(_net_inet_ip_portrange, OID_AUTO, hilast, CTLTYPE_INT|CTLFLAG_RW, * Allocate a PCB and associate it with the socket. */ int -in_pcballoc(so, pcbinfo, p) +in_pcballoc(so, pcbinfo, td) struct socket *so; struct inpcbinfo *pcbinfo; - struct proc *p; + struct thread *td; { register struct inpcb *inp; #ifdef IPSEC @@ -175,11 +175,12 @@ in_pcballoc(so, pcbinfo, p) } int -in_pcbbind(inp, nam, p) +in_pcbbind(inp, nam, td) register struct inpcb *inp; struct sockaddr *nam; - struct proc *p; + struct thread *td; { + struct proc *p = td->td_proc; register struct socket *so = inp->inp_socket; unsigned short *lastport; struct sockaddr_in *sin; @@ -494,10 +495,10 @@ in_pcbladdr(inp, nam, plocal_sin) * then pick one. */ int -in_pcbconnect(inp, nam, p) +in_pcbconnect(inp, nam, td) register struct inpcb *inp; struct sockaddr *nam; - struct proc *p; + struct thread *td; { struct sockaddr_in *ifaddr; struct sockaddr_in *sin = (struct sockaddr_in *)nam; @@ -511,7 +512,7 @@ in_pcbconnect(inp, nam, p) sa.sin_addr.s_addr = htonl(cred->cr_prison->pr_ip); sa.sin_len=sizeof (sa); sa.sin_family = AF_INET; - error = in_pcbbind(inp, (struct sockaddr *)&sa, p); + error = in_pcbbind(inp, (struct sockaddr *)&sa, td); if (error) return (error); } @@ -528,7 +529,7 @@ in_pcbconnect(inp, nam, p) } if (inp->inp_laddr.s_addr == INADDR_ANY) { if (inp->inp_lport == 0) { - error = in_pcbbind(inp, (struct sockaddr *)0, p); + error = in_pcbbind(inp, (struct sockaddr *)0, td); if (error) return (error); } diff --git a/sys/netinet/in_pcb.h b/sys/netinet/in_pcb.h index 2b01db4..8423462 100644 --- a/sys/netinet/in_pcb.h +++ b/sys/netinet/in_pcb.h @@ -278,9 +278,9 @@ extern int ipport_hilastauto; void in_pcbpurgeif0 __P((struct inpcb *, struct ifnet *)); void in_losing __P((struct inpcb *)); void in_rtchange __P((struct inpcb *, int)); -int in_pcballoc __P((struct socket *, struct inpcbinfo *, struct proc *)); -int in_pcbbind __P((struct inpcb *, struct sockaddr *, struct proc *)); -int in_pcbconnect __P((struct inpcb *, struct sockaddr *, struct proc *)); +int in_pcballoc __P((struct socket *, struct inpcbinfo *, struct thread *)); +int in_pcbbind __P((struct inpcb *, struct sockaddr *, struct thread *)); +int in_pcbconnect __P((struct inpcb *, struct sockaddr *, struct thread *)); void in_pcbdetach __P((struct inpcb *)); void in_pcbdisconnect __P((struct inpcb *)); int in_pcbinshash __P((struct inpcb *)); diff --git a/sys/netinet/in_var.h b/sys/netinet/in_var.h index e603cee..7cef6ea 100644 --- a/sys/netinet/in_var.h +++ b/sys/netinet/in_var.h @@ -211,7 +211,7 @@ struct route; struct in_multi *in_addmulti __P((struct in_addr *, struct ifnet *)); void in_delmulti __P((struct in_multi *)); int in_control __P((struct socket *, u_long, caddr_t, struct ifnet *, - struct proc *)); + struct thread *)); void in_rtqdrain __P((void)); void ip_input __P((struct mbuf *)); int in_ifadown __P((struct ifaddr *ifa, int)); diff --git a/sys/netinet/ip_divert.c b/sys/netinet/ip_divert.c index a571271..d63df09 100644 --- a/sys/netinet/ip_divert.c +++ b/sys/netinet/ip_divert.c @@ -335,7 +335,7 @@ cantsend: } static int -div_attach(struct socket *so, int proto, struct proc *p) +div_attach(struct socket *so, int proto, struct thread *td) { struct inpcb *inp; int error, s; @@ -343,14 +343,14 @@ div_attach(struct socket *so, int proto, struct proc *p) inp = sotoinpcb(so); if (inp) panic("div_attach"); - if (p && (error = suser(p)) != 0) + if (td && (error = suser_td(td)) != 0) return error; error = soreserve(so, div_sendspace, div_recvspace); if (error) return error; s = splnet(); - error = in_pcballoc(so, &divcbinfo, p); + error = in_pcballoc(so, &divcbinfo, td); splx(s); if (error) return error; @@ -392,7 +392,7 @@ div_disconnect(struct socket *so) } static int -div_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +div_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { struct inpcb *inp; int s; @@ -411,7 +411,7 @@ div_bind(struct socket *so, struct sockaddr *nam, struct proc *p) error = EAFNOSUPPORT; } else { ((struct sockaddr_in *)nam)->sin_addr.s_addr = INADDR_ANY; - error = in_pcbbind(inp, nam, p); + error = in_pcbbind(inp, nam, td); } splx(s); return error; @@ -426,7 +426,7 @@ div_shutdown(struct socket *so) static int div_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { /* Packet must have a header (but that's about it) */ if (m->m_len < sizeof (struct ip) && diff --git a/sys/netinet/ip_output.c b/sys/netinet/ip_output.c index 2201e06..86b321e 100644 --- a/sys/netinet/ip_output.c +++ b/sys/netinet/ip_output.c @@ -1147,7 +1147,7 @@ ip_ctloutput(so, sopt) error = EMSGSIZE; break; } - MGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT, MT_HEADER); + MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_HEADER); if (m == 0) { error = ENOBUFS; break; @@ -1263,8 +1263,8 @@ ip_ctloutput(so, sopt) break; if ((error = soopt_mcopyin(sopt, m)) != 0) /* XXX */ break; - priv = (sopt->sopt_p != NULL && - suser(sopt->sopt_p) != 0) ? 0 : 1; + priv = (sopt->sopt_td != NULL && + suser_td(sopt->sopt_td) != 0) ? 0 : 1; req = mtod(m, caddr_t); len = m->m_len; optname = sopt->sopt_name; diff --git a/sys/netinet/ipprotosw.h b/sys/netinet/ipprotosw.h index 97c1c85..bdc4c73 100644 --- a/sys/netinet/ipprotosw.h +++ b/sys/netinet/ipprotosw.h @@ -73,7 +73,6 @@ /* Forward declare these structures referenced from prototypes below. */ struct mbuf; -struct proc; struct sockaddr; struct socket; struct sockopt; diff --git a/sys/netinet/raw_ip.c b/sys/netinet/raw_ip.c index 7a1c9a1..178b483 100644 --- a/sys/netinet/raw_ip.c +++ b/sys/netinet/raw_ip.c @@ -461,7 +461,7 @@ SYSCTL_INT(_net_inet_raw, OID_AUTO, recvspace, CTLFLAG_RW, &rip_recvspace, 0, "Maximum incoming raw IP datagram size"); static int -rip_attach(struct socket *so, int proto, struct proc *p) +rip_attach(struct socket *so, int proto, struct thread *td) { struct inpcb *inp; int error, s; @@ -469,14 +469,14 @@ rip_attach(struct socket *so, int proto, struct proc *p) inp = sotoinpcb(so); if (inp) panic("rip_attach"); - if (p && (error = suser(p)) != 0) + if (td && (error = suser_td(td)) != 0) return error; error = soreserve(so, rip_sendspace, rip_recvspace); if (error) return error; s = splnet(); - error = in_pcballoc(so, &ripcbinfo, p); + error = in_pcballoc(so, &ripcbinfo, td); splx(s); if (error) return error; @@ -520,7 +520,7 @@ rip_disconnect(struct socket *so) } static int -rip_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +rip_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { struct inpcb *inp = sotoinpcb(so); struct sockaddr_in *addr = (struct sockaddr_in *)nam; @@ -538,7 +538,7 @@ rip_bind(struct socket *so, struct sockaddr *nam, struct proc *p) } static int -rip_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +rip_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { struct inpcb *inp = sotoinpcb(so); struct sockaddr_in *addr = (struct sockaddr_in *)nam; @@ -564,7 +564,7 @@ rip_shutdown(struct socket *so) static int rip_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { struct inpcb *inp = sotoinpcb(so); register u_long dst; diff --git a/sys/netinet/tcp_input.c b/sys/netinet/tcp_input.c index e093896..baa972d 100644 --- a/sys/netinet/tcp_input.c +++ b/sys/netinet/tcp_input.c @@ -1098,7 +1098,7 @@ findpcb: if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) inp->in6p_laddr = ip6->ip6_dst; if (in6_pcbconnect(inp, (struct sockaddr *)sin6, - &proc0)) { + thread0)) { inp->in6p_laddr = laddr6; FREE(sin6, M_SONAME); goto drop; @@ -1119,7 +1119,7 @@ findpcb: laddr = inp->inp_laddr; if (inp->inp_laddr.s_addr == INADDR_ANY) inp->inp_laddr = ip->ip_dst; - if (in_pcbconnect(inp, (struct sockaddr *)sin, &proc0)) { + if (in_pcbconnect(inp, (struct sockaddr *)sin, thread0)) { inp->inp_laddr = laddr; FREE(sin, M_SONAME); goto drop; diff --git a/sys/netinet/tcp_reass.c b/sys/netinet/tcp_reass.c index e093896..baa972d 100644 --- a/sys/netinet/tcp_reass.c +++ b/sys/netinet/tcp_reass.c @@ -1098,7 +1098,7 @@ findpcb: if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) inp->in6p_laddr = ip6->ip6_dst; if (in6_pcbconnect(inp, (struct sockaddr *)sin6, - &proc0)) { + thread0)) { inp->in6p_laddr = laddr6; FREE(sin6, M_SONAME); goto drop; @@ -1119,7 +1119,7 @@ findpcb: laddr = inp->inp_laddr; if (inp->inp_laddr.s_addr == INADDR_ANY) inp->inp_laddr = ip->ip_dst; - if (in_pcbconnect(inp, (struct sockaddr *)sin, &proc0)) { + if (in_pcbconnect(inp, (struct sockaddr *)sin, thread0)) { inp->inp_laddr = laddr; FREE(sin, M_SONAME); goto drop; diff --git a/sys/netinet/tcp_usrreq.c b/sys/netinet/tcp_usrreq.c index 6f761a0..2485a91 100644 --- a/sys/netinet/tcp_usrreq.c +++ b/sys/netinet/tcp_usrreq.c @@ -88,12 +88,12 @@ */ extern char *tcpstates[]; /* XXX ??? */ -static int tcp_attach __P((struct socket *, struct proc *)); +static int tcp_attach __P((struct socket *, struct thread *td)); static int tcp_connect __P((struct tcpcb *, struct sockaddr *, - struct proc *)); + struct thread *td)); #ifdef INET6 static int tcp6_connect __P((struct tcpcb *, struct sockaddr *, - struct proc *)); + struct thread *td)); #endif /* INET6 */ static struct tcpcb * tcp_disconnect __P((struct tcpcb *)); @@ -116,7 +116,7 @@ static struct tcpcb * * and an internet control block. */ static int -tcp_usr_attach(struct socket *so, int proto, struct proc *p) +tcp_usr_attach(struct socket *so, int proto, struct thread *td) { int s = splnet(); int error; @@ -130,7 +130,7 @@ tcp_usr_attach(struct socket *so, int proto, struct proc *p) goto out; } - error = tcp_attach(so, p); + error = tcp_attach(so, td); if (error) goto out; @@ -189,7 +189,7 @@ tcp_usr_detach(struct socket *so) * Give the socket an address. */ static int -tcp_usr_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +tcp_usr_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { int s = splnet(); int error = 0; @@ -209,7 +209,7 @@ tcp_usr_bind(struct socket *so, struct sockaddr *nam, struct proc *p) error = EAFNOSUPPORT; goto out; } - error = in_pcbbind(inp, nam, p); + error = in_pcbbind(inp, nam, td); if (error) goto out; COMMON_END(PRU_BIND); @@ -218,7 +218,7 @@ tcp_usr_bind(struct socket *so, struct sockaddr *nam, struct proc *p) #ifdef INET6 static int -tcp6_usr_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +tcp6_usr_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { int s = splnet(); int error = 0; @@ -249,11 +249,11 @@ tcp6_usr_bind(struct socket *so, struct sockaddr *nam, struct proc *p) in6_sin6_2_sin(&sin, sin6p); inp->inp_vflag |= INP_IPV4; inp->inp_vflag &= ~INP_IPV6; - error = in_pcbbind(inp, (struct sockaddr *)&sin, p); + error = in_pcbbind(inp, (struct sockaddr *)&sin, td); goto out; } } - error = in6_pcbbind(inp, nam, p); + error = in6_pcbbind(inp, nam, td); if (error) goto out; COMMON_END(PRU_BIND); @@ -264,7 +264,7 @@ tcp6_usr_bind(struct socket *so, struct sockaddr *nam, struct proc *p) * Prepare to accept connections. */ static int -tcp_usr_listen(struct socket *so, struct proc *p) +tcp_usr_listen(struct socket *so, struct thread *td) { int s = splnet(); int error = 0; @@ -273,7 +273,7 @@ tcp_usr_listen(struct socket *so, struct proc *p) COMMON_START(); if (inp->inp_lport == 0) - error = in_pcbbind(inp, (struct sockaddr *)0, p); + error = in_pcbbind(inp, (struct sockaddr *)0, td); if (error == 0) tp->t_state = TCPS_LISTEN; COMMON_END(PRU_LISTEN); @@ -281,7 +281,7 @@ tcp_usr_listen(struct socket *so, struct proc *p) #ifdef INET6 static int -tcp6_usr_listen(struct socket *so, struct proc *p) +tcp6_usr_listen(struct socket *so, struct thread *td) { int s = splnet(); int error = 0; @@ -294,7 +294,7 @@ tcp6_usr_listen(struct socket *so, struct proc *p) if (ip6_mapped_addr_on && (inp->inp_flags & IN6P_IPV6_V6ONLY) == 0) inp->inp_vflag |= INP_IPV4; - error = in6_pcbbind(inp, (struct sockaddr *)0, p); + error = in6_pcbbind(inp, (struct sockaddr *)0, td); } if (error == 0) tp->t_state = TCPS_LISTEN; @@ -310,7 +310,7 @@ tcp6_usr_listen(struct socket *so, struct proc *p) * Send initial segment on connection. */ static int -tcp_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +tcp_usr_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { int s = splnet(); int error = 0; @@ -330,10 +330,10 @@ tcp_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p) goto out; } - if (p && jailed(p->p_ucred)) - prison_remote_ip(p->p_ucred, 0, &sinp->sin_addr.s_addr); + if (td && jailed(td->td_proc->p_ucred)) + prison_remote_ip(td->td_proc->p_ucred, 0, &sinp->sin_addr.s_addr); - if ((error = tcp_connect(tp, nam, p)) != 0) + if ((error = tcp_connect(tp, nam, td)) != 0) goto out; error = tcp_output(tp); COMMON_END(PRU_CONNECT); @@ -341,7 +341,7 @@ tcp_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p) #ifdef INET6 static int -tcp6_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +tcp6_usr_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { int s = splnet(); int error = 0; @@ -371,14 +371,14 @@ tcp6_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p) in6_sin6_2_sin(&sin, sin6p); inp->inp_vflag |= INP_IPV4; inp->inp_vflag &= ~INP_IPV6; - if ((error = tcp_connect(tp, (struct sockaddr *)&sin, p)) != 0) + if ((error = tcp_connect(tp, (struct sockaddr *)&sin, td)) != 0) goto out; error = tcp_output(tp); goto out; } inp->inp_vflag &= ~INP_IPV4; inp->inp_vflag |= INP_IPV6; - if ((error = tcp6_connect(tp, nam, p)) != 0) + if ((error = tcp6_connect(tp, nam, td)) != 0) goto out; error = tcp_output(tp); COMMON_END(PRU_CONNECT); @@ -505,7 +505,7 @@ tcp_usr_rcvd(struct socket *so, int flags) */ static int tcp_usr_send(struct socket *so, int flags, struct mbuf *m, - struct sockaddr *nam, struct mbuf *control, struct proc *p) + struct sockaddr *nam, struct mbuf *control, struct thread *td) { int s = splnet(); int error = 0; @@ -558,10 +558,10 @@ tcp_usr_send(struct socket *so, int flags, struct mbuf *m, */ #ifdef INET6 if (isipv6) - error = tcp6_connect(tp, nam, p); + error = tcp6_connect(tp, nam, td); else #endif /* INET6 */ - error = tcp_connect(tp, nam, p); + error = tcp_connect(tp, nam, td); if (error) goto out; tp->snd_wnd = TTCP_CLIENT_SND_WND; @@ -607,10 +607,10 @@ tcp_usr_send(struct socket *so, int flags, struct mbuf *m, */ #ifdef INET6 if (isipv6) - error = tcp6_connect(tp, nam, p); + error = tcp6_connect(tp, nam, td); else #endif /* INET6 */ - error = tcp_connect(tp, nam, p); + error = tcp_connect(tp, nam, td); if (error) goto out; tp->snd_wnd = TTCP_CLIENT_SND_WND; @@ -701,10 +701,10 @@ struct pr_usrreqs tcp6_usrreqs = { * Initialize connection parameters and enter SYN-SENT state. */ static int -tcp_connect(tp, nam, p) +tcp_connect(tp, nam, td) register struct tcpcb *tp; struct sockaddr *nam; - struct proc *p; + struct thread *td; { struct inpcb *inp = tp->t_inpcb, *oinp; struct socket *so = inp->inp_socket; @@ -716,7 +716,7 @@ tcp_connect(tp, nam, p) int error; if (inp->inp_lport == 0) { - error = in_pcbbind(inp, (struct sockaddr *)0, p); + error = in_pcbbind(inp, (struct sockaddr *)0, td); if (error) return error; } @@ -784,10 +784,10 @@ tcp_connect(tp, nam, p) #ifdef INET6 static int -tcp6_connect(tp, nam, p) +tcp6_connect(tp, nam, td) register struct tcpcb *tp; struct sockaddr *nam; - struct proc *p; + struct thread *td; { struct inpcb *inp = tp->t_inpcb, *oinp; struct socket *so = inp->inp_socket; @@ -799,7 +799,7 @@ tcp6_connect(tp, nam, p) int error; if (inp->inp_lport == 0) { - error = in6_pcbbind(inp, (struct sockaddr *)0, p); + error = in6_pcbbind(inp, (struct sockaddr *)0, td); if (error) return error; } @@ -1008,9 +1008,9 @@ SYSCTL_INT(_net_inet_tcp, TCPCTL_RECVSPACE, recvspace, CTLFLAG_RW, * bufer space, and entering LISTEN state if to accept connections. */ static int -tcp_attach(so, p) +tcp_attach(so, td) struct socket *so; - struct proc *p; + struct thread *td; { register struct tcpcb *tp; struct inpcb *inp; @@ -1024,7 +1024,7 @@ tcp_attach(so, p) if (error) return (error); } - error = in_pcballoc(so, &tcbinfo, p); + error = in_pcballoc(so, &tcbinfo, td); if (error) return (error); inp = sotoinpcb(so); diff --git a/sys/netinet/udp_usrreq.c b/sys/netinet/udp_usrreq.c index ab18872..4af1870 100644 --- a/sys/netinet/udp_usrreq.c +++ b/sys/netinet/udp_usrreq.c @@ -134,7 +134,7 @@ static void ip_2_ip6_hdr __P((struct ip6_hdr *ip6, struct ip *ip)); static int udp_detach __P((struct socket *so)); static int udp_output __P((struct inpcb *, struct mbuf *, struct sockaddr *, - struct mbuf *, struct proc *)); + struct mbuf *, struct thread *)); void udp_init() @@ -660,12 +660,12 @@ SYSCTL_PROC(_net_inet_udp, OID_AUTO, getcred, udp_getcred, "S,xucred", "Get the xucred of a UDP connection"); static int -udp_output(inp, m, addr, control, p) +udp_output(inp, m, addr, control, td) register struct inpcb *inp; struct mbuf *m; struct sockaddr *addr; struct mbuf *control; - struct proc *p; + struct thread *td; { register struct udpiphdr *ui; register int len = m->m_pkthdr.len; @@ -683,8 +683,8 @@ udp_output(inp, m, addr, control, p) if (addr) { sin = (struct sockaddr_in *)addr; - if (p && jailed(p->p_ucred)) - prison_remote_ip(p->p_ucred, 0, &sin->sin_addr.s_addr); + if (td && jailed(td->td_proc->p_ucred)) + prison_remote_ip(td->td_proc->p_ucred, 0, &sin->sin_addr.s_addr); laddr = inp->inp_laddr; if (inp->inp_faddr.s_addr != INADDR_ANY) { error = EISCONN; @@ -694,7 +694,7 @@ udp_output(inp, m, addr, control, p) * Must block input while temporarily connected. */ s = splnet(); - error = in_pcbconnect(inp, addr, p); + error = in_pcbconnect(inp, addr, td); if (error) { splx(s); goto release; @@ -800,7 +800,7 @@ udp_abort(struct socket *so) } static int -udp_attach(struct socket *so, int proto, struct proc *p) +udp_attach(struct socket *so, int proto, struct thread *td) { struct inpcb *inp; int s, error; @@ -813,7 +813,7 @@ udp_attach(struct socket *so, int proto, struct proc *p) if (error) return error; s = splnet(); - error = in_pcballoc(so, &udbinfo, p); + error = in_pcballoc(so, &udbinfo, td); splx(s); if (error) return error; @@ -825,7 +825,7 @@ udp_attach(struct socket *so, int proto, struct proc *p) } static int -udp_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +udp_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { struct inpcb *inp; int s, error; @@ -834,13 +834,13 @@ udp_bind(struct socket *so, struct sockaddr *nam, struct proc *p) if (inp == 0) return EINVAL; s = splnet(); - error = in_pcbbind(inp, nam, p); + error = in_pcbbind(inp, nam, td); splx(s); return error; } static int -udp_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +udp_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { struct inpcb *inp; int s, error; @@ -853,9 +853,9 @@ udp_connect(struct socket *so, struct sockaddr *nam, struct proc *p) return EISCONN; s = splnet(); sin = (struct sockaddr_in *)nam; - if (p && jailed(p->p_ucred)) - prison_remote_ip(p->p_ucred, 0, &sin->sin_addr.s_addr); - error = in_pcbconnect(inp, nam, p); + if (td && jailed(td->td_proc->p_ucred)) + prison_remote_ip(td->td_proc->p_ucred, 0, &sin->sin_addr.s_addr); + error = in_pcbconnect(inp, nam, td); splx(s); if (error == 0) soisconnected(so); @@ -899,7 +899,7 @@ udp_disconnect(struct socket *so) static int udp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { struct inpcb *inp; @@ -908,7 +908,7 @@ udp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, m_freem(m); return EINVAL; } - return udp_output(inp, m, addr, control, p); + return udp_output(inp, m, addr, control, td); } int diff --git a/sys/netinet6/in6.c b/sys/netinet6/in6.c index c6d0d60..c17bf55 100644 --- a/sys/netinet6/in6.c +++ b/sys/netinet6/in6.c @@ -131,7 +131,7 @@ const struct sockaddr_in6 sa6_any = {sizeof(sa6_any), AF_INET6, 0, 0, IN6ADDR_ANY_INIT, 0}; static int in6_lifaddr_ioctl __P((struct socket *, u_long, caddr_t, - struct ifnet *, struct proc *)); + struct ifnet *, struct thread *)); static int in6_ifinit __P((struct ifnet *, struct in6_ifaddr *, struct sockaddr_in6 *, int)); static void in6_unlink_ifa __P((struct in6_ifaddr *, struct ifnet *)); @@ -361,12 +361,12 @@ in6_len2mask(mask, len) #define ia62ifa(ia6) (&((ia6)->ia_ifa)) int -in6_control(so, cmd, data, ifp, p) +in6_control(so, cmd, data, ifp, td) struct socket *so; u_long cmd; caddr_t data; struct ifnet *ifp; - struct proc *p; + struct thread *td; { struct in6_ifreq *ifr = (struct in6_ifreq *)data; struct in6_ifaddr *ia = NULL; @@ -374,7 +374,7 @@ in6_control(so, cmd, data, ifp, p) int privileged; privileged = 0; - if (p == NULL || !suser(p)) + if (td == NULL || !suser_td(td)) privileged++; switch (cmd) { @@ -438,7 +438,7 @@ in6_control(so, cmd, data, ifp, p) return(EPERM); /*fall through*/ case SIOCGLIFADDR: - return in6_lifaddr_ioctl(so, cmd, data, ifp, p); + return in6_lifaddr_ioctl(so, cmd, data, ifp, td); } /* @@ -1317,12 +1317,12 @@ in6_purgeif(ifp) * address encoding scheme. (see figure on page 8) */ static int -in6_lifaddr_ioctl(so, cmd, data, ifp, p) +in6_lifaddr_ioctl(so, cmd, data, ifp, td) struct socket *so; u_long cmd; caddr_t data; struct ifnet *ifp; - struct proc *p; + struct thread *td; { struct if_laddrreq *iflr = (struct if_laddrreq *)data; struct ifaddr *ifa; @@ -1430,7 +1430,7 @@ in6_lifaddr_ioctl(so, cmd, data, ifp, p) in6_len2mask(&ifra.ifra_prefixmask.sin6_addr, prefixlen); ifra.ifra_flags = iflr->flags & ~IFLR_PREFIX; - return in6_control(so, SIOCAIFADDR_IN6, (caddr_t)&ifra, ifp, p); + return in6_control(so, SIOCAIFADDR_IN6, (caddr_t)&ifra, ifp, td); } case SIOCGLIFADDR: case SIOCDLIFADDR: @@ -1558,7 +1558,7 @@ in6_lifaddr_ioctl(so, cmd, data, ifp, p) ifra.ifra_flags = ia->ia6_flags; return in6_control(so, SIOCDIFADDR_IN6, (caddr_t)&ifra, - ifp, p); + ifp, td); } } } diff --git a/sys/netinet6/in6_pcb.c b/sys/netinet6/in6_pcb.c index 5e8b3dd..fa67043 100644 --- a/sys/netinet6/in6_pcb.c +++ b/sys/netinet6/in6_pcb.c @@ -120,10 +120,10 @@ struct in6_addr zeroin6_addr; int -in6_pcbbind(inp, nam, p) +in6_pcbbind(inp, nam, td) register struct inpcb *inp; struct sockaddr *nam; - struct proc *p; + struct thread *td; { struct socket *so = inp->inp_socket; struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)NULL; @@ -187,8 +187,8 @@ in6_pcbbind(inp, nam, p) struct inpcb *t; /* GROSS */ - if (ntohs(lport) < IPV6PORT_RESERVED && p && - suser_xxx(0, p, PRISON_ROOT)) + if (ntohs(lport) < IPV6PORT_RESERVED && td && + suser_xxx(0, td->td_proc, PRISON_ROOT)) return(EACCES); if (so->so_cred->cr_uid != 0 && !IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) { @@ -246,7 +246,7 @@ in6_pcbbind(inp, nam, p) } if (lport == 0) { int e; - if ((e = in6_pcbsetport(&inp->in6p_laddr, inp, p)) != 0) + if ((e = in6_pcbsetport(&inp->in6p_laddr, inp, td)) != 0) return(e); } else { @@ -337,10 +337,10 @@ in6_pcbladdr(inp, nam, plocal_addr6) * then pick one. */ int -in6_pcbconnect(inp, nam, p) +in6_pcbconnect(inp, nam, td) register struct inpcb *inp; struct sockaddr *nam; - struct proc *p; + struct thread *td; { struct in6_addr *addr6; register struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)nam; @@ -361,7 +361,7 @@ in6_pcbconnect(inp, nam, p) } if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) { if (inp->inp_lport == 0) { - error = in6_pcbbind(inp, (struct sockaddr *)0, p); + error = in6_pcbbind(inp, (struct sockaddr *)0, td); if (error) return (error); } diff --git a/sys/netinet6/in6_pcb.h b/sys/netinet6/in6_pcb.h index df8e2c8..c1d038d 100644 --- a/sys/netinet6/in6_pcb.h +++ b/sys/netinet6/in6_pcb.h @@ -76,9 +76,9 @@ void in6_pcbpurgeif0 __P((struct in6pcb *, struct ifnet *)); void in6_losing __P((struct inpcb *)); -int in6_pcballoc __P((struct socket *, struct inpcbinfo *, struct proc *)); -int in6_pcbbind __P((struct inpcb *, struct sockaddr *, struct proc *)); -int in6_pcbconnect __P((struct inpcb *, struct sockaddr *, struct proc *)); +int in6_pcballoc __P((struct socket *, struct inpcbinfo *, struct thread *)); +int in6_pcbbind __P((struct inpcb *, struct sockaddr *, struct thread *)); +int in6_pcbconnect __P((struct inpcb *, struct sockaddr *, struct thread *)); void in6_pcbdetach __P((struct inpcb *)); void in6_pcbdisconnect __P((struct inpcb *)); int in6_pcbladdr __P((struct inpcb *, struct sockaddr *, @@ -104,7 +104,7 @@ struct in6_addr *in6_selectsrc __P((struct sockaddr_in6 *, struct route_in6 *, struct in6_addr *, int *)); int in6_selecthlim __P((struct in6pcb *, struct ifnet *)); -int in6_pcbsetport __P((struct in6_addr *, struct inpcb *, struct proc *)); +int in6_pcbsetport __P((struct in6_addr *, struct inpcb *, struct thread *)); void init_sin6 __P((struct sockaddr_in6 *sin6, struct mbuf *m)); #endif /* _KERNEL */ diff --git a/sys/netinet6/in6_src.c b/sys/netinet6/in6_src.c index 708c4f5..3cee6cb 100644 --- a/sys/netinet6/in6_src.c +++ b/sys/netinet6/in6_src.c @@ -325,10 +325,10 @@ in6_selecthlim(in6p, ifp) * share this function by all *bsd*... */ int -in6_pcbsetport(laddr, inp, p) +in6_pcbsetport(laddr, inp, td) struct in6_addr *laddr; struct inpcb *inp; - struct proc *p; + struct thread *td; { struct socket *so = inp->inp_socket; u_int16_t lport = 0, first, last, *lastport; @@ -346,7 +346,7 @@ in6_pcbsetport(laddr, inp, p) last = ipport_hilastauto; lastport = &pcbinfo->lasthi; } else if (inp->inp_flags & INP_LOWPORT) { - if (p && (error = suser(p))) + if (td && (error = suser_td(td))) return error; first = ipport_lowfirstauto; /* 1023 */ last = ipport_lowlastauto; /* 600 */ diff --git a/sys/netinet6/in6_var.h b/sys/netinet6/in6_var.h index bb5abc9..c109bfc 100644 --- a/sys/netinet6/in6_var.h +++ b/sys/netinet6/in6_var.h @@ -571,7 +571,7 @@ extern int in6_ifindex2scopeid __P((int)); extern int in6_mask2len __P((struct in6_addr *, u_char *)); extern void in6_len2mask __P((struct in6_addr *, int)); int in6_control __P((struct socket *, - u_long, caddr_t, struct ifnet *, struct proc *)); + u_long, caddr_t, struct ifnet *, struct thread *)); int in6_update_ifa __P((struct ifnet *, struct in6_aliasreq *, struct in6_ifaddr *)); void in6_purgeaddr __P((struct ifaddr *)); diff --git a/sys/netinet6/ip6_input.c b/sys/netinet6/ip6_input.c index f4a0307..c426e13 100644 --- a/sys/netinet6/ip6_input.c +++ b/sys/netinet6/ip6_input.c @@ -75,6 +75,7 @@ #include <sys/systm.h> #include <sys/malloc.h> #include <sys/mbuf.h> +#include <sys/proc.h> #include <sys/domain.h> #include <sys/protosw.h> #include <sys/socket.h> diff --git a/sys/netinet6/ip6_output.c b/sys/netinet6/ip6_output.c index 41b25b6c..99e8ddd 100644 --- a/sys/netinet6/ip6_output.c +++ b/sys/netinet6/ip6_output.c @@ -74,6 +74,7 @@ #include <sys/param.h> #include <sys/malloc.h> #include <sys/mbuf.h> +#include <sys/proc.h> #include <sys/errno.h> #include <sys/protosw.h> #include <sys/socket.h> @@ -1271,20 +1272,20 @@ ip6_ctloutput(so, sopt) int error, optval; int level, op, optname; int optlen; - struct proc *p; + struct thread *td; if (sopt) { level = sopt->sopt_level; op = sopt->sopt_dir; optname = sopt->sopt_name; optlen = sopt->sopt_valsize; - p = sopt->sopt_p; + td = sopt->sopt_td; } else { panic("ip6_ctloutput: arg soopt is NULL"); } error = optval = 0; - privileged = (p == 0 || suser(p)) ? 0 : 1; + privileged = (td == 0 || suser_td(td)) ? 0 : 1; if (level == IPPROTO_IPV6) { switch (op) { @@ -1440,7 +1441,7 @@ do { \ break; } /* XXX */ - MGET(m, sopt->sopt_p ? M_TRYWAIT : M_DONTWAIT, MT_HEADER); + MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_HEADER); if (m == 0) { error = ENOBUFS; break; @@ -1708,7 +1709,7 @@ ip6_pcbopts(pktopt, m, so, sopt) { struct ip6_pktopts *opt = *pktopt; int error = 0; - struct proc *p = sopt->sopt_p; + struct thread *td = sopt->sopt_td; int priv = 0; /* turn off any old options. */ @@ -1734,7 +1735,7 @@ ip6_pcbopts(pktopt, m, so, sopt) } /* set options specified by user. */ - if (p && !suser(p)) + if (td && !suser_td(td)) priv = 1; if ((error = ip6_setpktoptions(m, opt, priv, 1)) != 0) { ip6_clearpktopts(opt, 1, -1); /* XXX: discard all options */ @@ -1895,7 +1896,7 @@ ip6_setmoptions(optname, im6op, m) struct route_in6 ro; struct sockaddr_in6 *dst; struct in6_multi_mship *imm; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ if (im6o == NULL) { /* @@ -1990,7 +1991,7 @@ ip6_setmoptions(optname, im6op, m) * all multicast addresses. Only super user is allowed * to do this. */ - if (suser(p)) + if (suser_td(td)) { error = EACCES; break; @@ -2097,7 +2098,7 @@ ip6_setmoptions(optname, im6op, m) } mreq = mtod(m, struct ipv6_mreq *); if (IN6_IS_ADDR_UNSPECIFIED(&mreq->ipv6mr_multiaddr)) { - if (suser(p)) { + if (suser_td(td)) { error = EACCES; break; } diff --git a/sys/netinet6/ip6_var.h b/sys/netinet6/ip6_var.h index dea9c07..f226cc6 100644 --- a/sys/netinet6/ip6_var.h +++ b/sys/netinet6/ip6_var.h @@ -345,7 +345,7 @@ void rip6_ctlinput __P((int, struct sockaddr *, void *)); int rip6_ctloutput __P((struct socket *so, struct sockopt *sopt)); int rip6_output __P((struct mbuf *, ...)); int rip6_usrreq __P((struct socket *, - int, struct mbuf *, struct mbuf *, struct mbuf *, struct proc *)); + int, struct mbuf *, struct mbuf *, struct mbuf *, struct thread *)); int dest6_input __P((struct mbuf **, int *, int)); int none_input __P((struct mbuf **, int *, int)); diff --git a/sys/netinet6/ip6protosw.h b/sys/netinet6/ip6protosw.h index c2f38fc..541402b 100644 --- a/sys/netinet6/ip6protosw.h +++ b/sys/netinet6/ip6protosw.h @@ -85,7 +85,7 @@ struct mbuf; struct sockaddr; struct socket; struct domain; -struct proc; +struct thread; struct ip6_hdr; struct icmp6_hdr; struct in6_addr; @@ -140,7 +140,7 @@ struct ip6protosw { /* user-protocol hook */ int (*pr_usrreq) /* user request: see list below */ __P((struct socket *, int, struct mbuf *, - struct mbuf *, struct mbuf *, struct proc *)); + struct mbuf *, struct mbuf *, struct thread *)); /* utility hooks */ void (*pr_init) /* initialization hook */ diff --git a/sys/netinet6/raw_ip6.c b/sys/netinet6/raw_ip6.c index 43aa54e..5f89668 100644 --- a/sys/netinet6/raw_ip6.c +++ b/sys/netinet6/raw_ip6.c @@ -543,7 +543,7 @@ rip6_ctloutput(so, sopt) } static int -rip6_attach(struct socket *so, int proto, struct proc *p) +rip6_attach(struct socket *so, int proto, struct thread *td) { struct inpcb *inp; int error, s; @@ -551,14 +551,14 @@ rip6_attach(struct socket *so, int proto, struct proc *p) inp = sotoinpcb(so); if (inp) panic("rip6_attach"); - if (p && (error = suser(p)) != 0) + if (td && (error = suser_td(td)) != 0) return error; error = soreserve(so, rip_sendspace, rip_recvspace); if (error) return error; s = splnet(); - error = in_pcballoc(so, &ripcbinfo, p); + error = in_pcballoc(so, &ripcbinfo, td); splx(s); if (error) return error; @@ -611,7 +611,7 @@ rip6_disconnect(struct socket *so) } static int -rip6_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +rip6_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { struct inpcb *inp = sotoinpcb(so); struct sockaddr_in6 *addr = (struct sockaddr_in6 *)nam; @@ -641,7 +641,7 @@ rip6_bind(struct socket *so, struct sockaddr *nam, struct proc *p) } static int -rip6_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +rip6_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { struct inpcb *inp = sotoinpcb(so); struct sockaddr_in6 *addr = (struct sockaddr_in6 *)nam; @@ -686,7 +686,7 @@ rip6_shutdown(struct socket *so) static int rip6_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { struct inpcb *inp = sotoinpcb(so); struct sockaddr_in6 tmp; diff --git a/sys/netinet6/udp6_output.c b/sys/netinet6/udp6_output.c index 0092f50..37a820d 100644 --- a/sys/netinet6/udp6_output.c +++ b/sys/netinet6/udp6_output.c @@ -121,12 +121,12 @@ #define udp6s_opackets udps_opackets int -udp6_output(in6p, m, addr6, control, p) +udp6_output(in6p, m, addr6, control, td) struct in6pcb *in6p; struct mbuf *m; struct mbuf *control; struct sockaddr *addr6; - struct proc *p; + struct thread *td; { u_int32_t ulen = m->m_pkthdr.len; u_int32_t plen = sizeof(struct udphdr) + ulen; @@ -142,7 +142,7 @@ udp6_output(in6p, m, addr6, control, p) struct sockaddr_in6 tmp; priv = 0; - if (p && !suser(p)) + if (td && !suser_td(td)) priv = 1; if (control) { if ((error = ip6_setpktoptions(control, &opt, priv, 0)) != 0) @@ -215,7 +215,7 @@ udp6_output(in6p, m, addr6, control, p) goto release; } if (in6p->in6p_lport == 0 && - (error = in6_pcbsetport(laddr, in6p, p)) != 0) + (error = in6_pcbsetport(laddr, in6p, td)) != 0) goto release; } else { if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) { diff --git a/sys/netinet6/udp6_usrreq.c b/sys/netinet6/udp6_usrreq.c index 631e57c..6440dbe 100644 --- a/sys/netinet6/udp6_usrreq.c +++ b/sys/netinet6/udp6_usrreq.c @@ -523,7 +523,7 @@ udp6_abort(struct socket *so) } static int -udp6_attach(struct socket *so, int proto, struct proc *p) +udp6_attach(struct socket *so, int proto, struct thread *td) { struct inpcb *inp; int s, error; @@ -538,7 +538,7 @@ udp6_attach(struct socket *so, int proto, struct proc *p) return error; } s = splnet(); - error = in_pcballoc(so, &udbinfo, p); + error = in_pcballoc(so, &udbinfo, td); splx(s); if (error) return error; @@ -557,7 +557,7 @@ udp6_attach(struct socket *so, int proto, struct proc *p) } static int -udp6_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +udp6_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { struct inpcb *inp; int s, error; @@ -582,20 +582,20 @@ udp6_bind(struct socket *so, struct sockaddr *nam, struct proc *p) inp->inp_vflag |= INP_IPV4; inp->inp_vflag &= ~INP_IPV6; s = splnet(); - error = in_pcbbind(inp, (struct sockaddr *)&sin, p); + error = in_pcbbind(inp, (struct sockaddr *)&sin, td); splx(s); return error; } } s = splnet(); - error = in6_pcbbind(inp, nam, p); + error = in6_pcbbind(inp, nam, td); splx(s); return error; } static int -udp6_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +udp6_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { struct inpcb *inp; int s, error; @@ -615,7 +615,7 @@ udp6_connect(struct socket *so, struct sockaddr *nam, struct proc *p) return EISCONN; in6_sin6_2_sin(&sin, sin6_p); s = splnet(); - error = in_pcbconnect(inp, (struct sockaddr *)&sin, p); + error = in_pcbconnect(inp, (struct sockaddr *)&sin, td); splx(s); if (error == 0) { inp->inp_vflag |= INP_IPV4; @@ -629,7 +629,7 @@ udp6_connect(struct socket *so, struct sockaddr *nam, struct proc *p) if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) return EISCONN; s = splnet(); - error = in6_pcbconnect(inp, nam, p); + error = in6_pcbconnect(inp, nam, td); splx(s); if (error == 0) { if (ip6_mapped_addr_on) { /* should be non mapped addr */ @@ -686,7 +686,7 @@ udp6_disconnect(struct socket *so) static int udp6_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { struct inpcb *inp; int error = 0; @@ -726,13 +726,13 @@ udp6_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, in6_sin6_2_sin_in_sock(addr); pru = inetsw[ip_protox[IPPROTO_UDP]].pr_usrreqs; error = ((*pru->pru_send)(so, flags, m, addr, control, - p)); + td)); /* addr will just be freed in sendit(). */ return error; } } - return udp6_output(inp, m, addr, control, p); + return udp6_output(inp, m, addr, control, td); bad: m_freem(m); diff --git a/sys/netinet6/udp6_var.h b/sys/netinet6/udp6_var.h index 5c3efbc..2da5057 100644 --- a/sys/netinet6/udp6_var.h +++ b/sys/netinet6/udp6_var.h @@ -76,7 +76,7 @@ void udp6_ctlinput __P((int, struct sockaddr *, void *)); int udp6_input __P((struct mbuf **, int *, int)); int udp6_output __P((struct inpcb *inp, struct mbuf *m, struct sockaddr *addr, struct mbuf *control, - struct proc *p)); + struct thread *td)); #endif #endif /*_NETINET6_UDP6_VAR_H_*/ diff --git a/sys/netipx/ipx.c b/sys/netipx/ipx.c index 6dfc32f..2727875 100644 --- a/sys/netipx/ipx.c +++ b/sys/netipx/ipx.c @@ -59,12 +59,12 @@ static int ipx_ifinit(struct ifnet *ifp, struct ipx_ifaddr *ia, * Generic internet control operations (ioctl's). */ int -ipx_control(so, cmd, data, ifp, p) +ipx_control(so, cmd, data, ifp, td) struct socket *so; u_long cmd; caddr_t data; register struct ifnet *ifp; - struct proc *p; + struct thread *td; { register struct ifreq *ifr = (struct ifreq *)data; register struct ipx_aliasreq *ifra = (struct ipx_aliasreq *)data; @@ -108,7 +108,7 @@ ipx_control(so, cmd, data, ifp, p) return (0); } - if (p && (error = suser(p)) != 0) + if (td && (error = suser_td(td)) != 0) return (error); switch (cmd) { diff --git a/sys/netipx/ipx_ip.c b/sys/netipx/ipx_ip.c index d4c9693..4dea458 100644 --- a/sys/netipx/ipx_ip.c +++ b/sys/netipx/ipx_ip.c @@ -384,14 +384,14 @@ ipxip_route(so, sopt) ifr_ipxip.ifr_name[4] = '0' + ipxipif.if_unit - 1; ifr_ipxip.ifr_dstaddr = *(struct sockaddr *)ipx_dst; ipx_control(so, (int)SIOCSIFDSTADDR, (caddr_t)&ifr_ipxip, - (struct ifnet *)ifn, sopt->sopt_p); + (struct ifnet *)ifn, sopt->sopt_td); /* use any of our addresses */ satoipx_addr(ifr_ipxip.ifr_addr).x_host = ipx_ifaddr->ia_addr.sipx_addr.x_host; return (ipx_control(so, (int)SIOCSIFADDR, (caddr_t)&ifr_ipxip, - (struct ifnet *)ifn, sopt->sopt_p)); + (struct ifnet *)ifn, sopt->sopt_td)); } static int diff --git a/sys/netipx/ipx_pcb.c b/sys/netipx/ipx_pcb.c index 0ae2462..fc0c6dd 100644 --- a/sys/netipx/ipx_pcb.c +++ b/sys/netipx/ipx_pcb.c @@ -53,10 +53,10 @@ static struct ipx_addr zeroipx_addr; int -ipx_pcballoc(so, head, p) +ipx_pcballoc(so, head, td) struct socket *so; struct ipxpcb *head; - struct proc *p; + struct thread *td; { register struct ipxpcb *ipxp; @@ -72,10 +72,10 @@ ipx_pcballoc(so, head, p) } int -ipx_pcbbind(ipxp, nam, p) +ipx_pcbbind(ipxp, nam, td) register struct ipxpcb *ipxp; struct sockaddr *nam; - struct proc *p; + struct thread *td; { register struct sockaddr_ipx *sipx; u_short lport = 0; @@ -99,7 +99,7 @@ ipx_pcbbind(ipxp, nam, p) int error; if (aport < IPXPORT_RESERVED && - p != NULL && (error = suser(p)) != 0) + td != NULL && (error = suser_td(td)) != 0) return (error); if (ipx_pcblookup(&zeroipx_addr, lport, 0)) return (EADDRINUSE); @@ -125,10 +125,10 @@ noname: * then pick one. */ int -ipx_pcbconnect(ipxp, nam, p) +ipx_pcbconnect(ipxp, nam, td) struct ipxpcb *ipxp; struct sockaddr *nam; - struct proc *p; + struct thread *td; { struct ipx_ifaddr *ia; register struct sockaddr_ipx *sipx = (struct sockaddr_ipx *)nam; @@ -242,7 +242,7 @@ ipx_pcbconnect(ipxp, nam, p) if (ipx_pcblookup(&sipx->sipx_addr, ipxp->ipxp_lport, 0)) return (EADDRINUSE); if (ipxp->ipxp_lport == 0) - ipx_pcbbind(ipxp, (struct sockaddr *)NULL, p); + ipx_pcbbind(ipxp, (struct sockaddr *)NULL, td); /* XXX just leave it zero if we can't find a route */ diff --git a/sys/netipx/ipx_pcb.h b/sys/netipx/ipx_pcb.h index 13bd9f9..482f812 100644 --- a/sys/netipx/ipx_pcb.h +++ b/sys/netipx/ipx_pcb.h @@ -83,11 +83,11 @@ struct ipxpcb { extern struct ipxpcb ipxpcb; /* head of list */ int ipx_pcballoc __P((struct socket *so, struct ipxpcb *head, - struct proc *p)); + struct thread *p)); int ipx_pcbbind __P((struct ipxpcb *ipxp, struct sockaddr *nam, - struct proc *p)); + struct thread *p)); int ipx_pcbconnect __P((struct ipxpcb *ipxp, struct sockaddr *nam, - struct proc *p)); + struct thread *p)); void ipx_pcbdetach __P((struct ipxpcb *ipxp)); void ipx_pcbdisconnect __P((struct ipxpcb *ipxp)); struct ipxpcb * diff --git a/sys/netipx/ipx_usrreq.c b/sys/netipx/ipx_usrreq.c index 4939568..fdd6917 100644 --- a/sys/netipx/ipx_usrreq.c +++ b/sys/netipx/ipx_usrreq.c @@ -70,17 +70,17 @@ SYSCTL_INT(_net_ipx_ipx, OID_AUTO, ipxrecvspace, CTLFLAG_RW, &ipxrecvspace, 0, ""); static int ipx_usr_abort(struct socket *so); -static int ipx_attach(struct socket *so, int proto, struct proc *p); -static int ipx_bind(struct socket *so, struct sockaddr *nam, struct proc *p); +static int ipx_attach(struct socket *so, int proto, struct thread *td); +static int ipx_bind(struct socket *so, struct sockaddr *nam, struct thread *td); static int ipx_connect(struct socket *so, struct sockaddr *nam, - struct proc *p); + struct thread *td); static int ipx_detach(struct socket *so); static int ipx_disconnect(struct socket *so); static int ipx_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, struct mbuf *control, - struct proc *p); + struct thread *td); static int ipx_shutdown(struct socket *so); -static int ripx_attach(struct socket *so, int proto, struct proc *p); +static int ripx_attach(struct socket *so, int proto, struct thread *td); static int ipx_output(struct ipxpcb *ipxp, struct mbuf *m0); struct pr_usrreqs ipx_usrreqs = { @@ -432,10 +432,10 @@ ipx_usr_abort(so) } static int -ipx_attach(so, proto, p) +ipx_attach(so, proto, td) struct socket *so; int proto; - struct proc *p; + struct thread *td; { int error; int s; @@ -444,7 +444,7 @@ ipx_attach(so, proto, p) if (ipxp != NULL) return (EINVAL); s = splnet(); - error = ipx_pcballoc(so, &ipxpcb, p); + error = ipx_pcballoc(so, &ipxpcb, td); splx(s); if (error == 0) error = soreserve(so, ipxsendspace, ipxrecvspace); @@ -452,21 +452,21 @@ ipx_attach(so, proto, p) } static int -ipx_bind(so, nam, p) +ipx_bind(so, nam, td) struct socket *so; struct sockaddr *nam; - struct proc *p; + struct thread *td; { struct ipxpcb *ipxp = sotoipxpcb(so); - return (ipx_pcbbind(ipxp, nam, p)); + return (ipx_pcbbind(ipxp, nam, td)); } static int -ipx_connect(so, nam, p) +ipx_connect(so, nam, td) struct socket *so; struct sockaddr *nam; - struct proc *p; + struct thread *td; { int error; int s; @@ -475,7 +475,7 @@ ipx_connect(so, nam, p) if (!ipx_nullhost(ipxp->ipxp_faddr)) return (EISCONN); s = splnet(); - error = ipx_pcbconnect(ipxp, nam, p); + error = ipx_pcbconnect(ipxp, nam, td); splx(s); if (error == 0) soisconnected(so); @@ -525,13 +525,13 @@ ipx_peeraddr(so, nam) } static int -ipx_send(so, flags, m, nam, control, p) +ipx_send(so, flags, m, nam, control, td) struct socket *so; int flags; struct mbuf *m; struct sockaddr *nam; struct mbuf *control; - struct proc *p; + struct thread *td; { int error; struct ipxpcb *ipxp = sotoipxpcb(so); @@ -548,7 +548,7 @@ ipx_send(so, flags, m, nam, control, p) * Must block input while temporarily connected. */ s = splnet(); - error = ipx_pcbconnect(ipxp, nam, p); + error = ipx_pcbconnect(ipxp, nam, td); if (error) { splx(s); goto send_release; @@ -593,19 +593,19 @@ ipx_sockaddr(so, nam) } static int -ripx_attach(so, proto, p) +ripx_attach(so, proto, td) struct socket *so; int proto; - struct proc *p; + struct thread *td; { int error = 0; int s; struct ipxpcb *ipxp = sotoipxpcb(so); - if (p != NULL && (error = suser(p)) != 0) + if (td != NULL && (error = suser_td(td)) != 0) return (error); s = splnet(); - error = ipx_pcballoc(so, &ipxrawpcb, p); + error = ipx_pcballoc(so, &ipxrawpcb, td); splx(s); if (error) return (error); diff --git a/sys/netipx/ipx_var.h b/sys/netipx/ipx_var.h index c387738..7e7b5ef 100644 --- a/sys/netipx/ipx_var.h +++ b/sys/netipx/ipx_var.h @@ -80,7 +80,7 @@ extern union ipx_host ipx_broadhost; struct ifnet; struct ipx_addr; struct mbuf; -struct proc; +struct thread; struct route; struct sockaddr; struct socket; @@ -89,7 +89,7 @@ struct sockopt; void ipx_abort __P((struct ipxpcb *ipxp)); u_short ipx_cksum __P((struct mbuf *m, int len)); int ipx_control __P((struct socket *so, u_long cmd, caddr_t data, - struct ifnet *ifp, struct proc *p)); + struct ifnet *ifp, struct thread *td)); void ipx_ctlinput __P((int cmd, struct sockaddr *arg_as_sa, void *dummy)); int ipx_ctloutput __P((struct socket *so, struct sockopt *sopt)); void ipx_drop __P((struct ipxpcb *ipxp, int errno)); diff --git a/sys/netipx/spx_usrreq.c b/sys/netipx/spx_usrreq.c index 19ebab9..7f1a1ae 100644 --- a/sys/netipx/spx_usrreq.c +++ b/sys/netipx/spx_usrreq.c @@ -89,20 +89,20 @@ static struct spxpcb *spx_usrclosed(struct spxpcb *cb); static int spx_usr_abort(struct socket *so); static int spx_accept(struct socket *so, struct sockaddr **nam); -static int spx_attach(struct socket *so, int proto, struct proc *p); -static int spx_bind(struct socket *so, struct sockaddr *nam, struct proc *p); +static int spx_attach(struct socket *so, int proto, struct thread *td); +static int spx_bind(struct socket *so, struct sockaddr *nam, struct thread *td); static int spx_connect(struct socket *so, struct sockaddr *nam, - struct proc *p); + struct thread *td); static int spx_detach(struct socket *so); static int spx_usr_disconnect(struct socket *so); -static int spx_listen(struct socket *so, struct proc *p); +static int spx_listen(struct socket *so, struct thread *td); static int spx_rcvd(struct socket *so, int flags); static int spx_rcvoob(struct socket *so, struct mbuf *m, int flags); static int spx_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, struct mbuf *control, - struct proc *p); + struct thread *td); static int spx_shutdown(struct socket *so); -static int spx_sp_attach(struct socket *so, int proto, struct proc *p); +static int spx_sp_attach(struct socket *so, int proto, struct thread *td); struct pr_usrreqs spx_usrreqs = { spx_usr_abort, spx_accept, spx_attach, spx_bind, @@ -223,7 +223,7 @@ spx_input(m, ipxp) laddr = ipxp->ipxp_laddr; if (ipx_nullhost(laddr)) ipxp->ipxp_laddr = si->si_dna; - if (ipx_pcbconnect(ipxp, (struct sockaddr *)sipx, &proc0)) { + if (ipx_pcbconnect(ipxp, (struct sockaddr *)sipx, thread0)) { ipxp->ipxp_laddr = laddr; spx_istat.noconn++; goto drop; @@ -1304,10 +1304,10 @@ spx_accept(so, nam) } static int -spx_attach(so, proto, p) +spx_attach(so, proto, td) struct socket *so; int proto; - struct proc *p; + struct thread *td; { int error; int s; @@ -1322,7 +1322,7 @@ spx_attach(so, proto, p) if (ipxp != NULL) return (EISCONN); s = splnet(); - error = ipx_pcballoc(so, &ipxpcb, p); + error = ipx_pcballoc(so, &ipxpcb, td); if (error) goto spx_attach_end; if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) { @@ -1370,16 +1370,16 @@ spx_attach_end: } static int -spx_bind(so, nam, p) +spx_bind(so, nam, td) struct socket *so; struct sockaddr *nam; - struct proc *p; + struct thread *td; { struct ipxpcb *ipxp; ipxp = sotoipxpcb(so); - return (ipx_pcbbind(ipxp, nam, p)); + return (ipx_pcbbind(ipxp, nam, td)); } /* @@ -1389,10 +1389,10 @@ spx_bind(so, nam, p) * Send initial system packet requesting connection. */ static int -spx_connect(so, nam, p) +spx_connect(so, nam, td) struct socket *so; struct sockaddr *nam; - struct proc *p; + struct thread *td; { int error; int s; @@ -1404,11 +1404,11 @@ spx_connect(so, nam, p) s = splnet(); if (ipxp->ipxp_lport == 0) { - error = ipx_pcbbind(ipxp, (struct sockaddr *)NULL, p); + error = ipx_pcbbind(ipxp, (struct sockaddr *)NULL, td); if (error) goto spx_connect_end; } - error = ipx_pcbconnect(ipxp, nam, p); + error = ipx_pcbconnect(ipxp, nam, td); if (error) goto spx_connect_end; soisconnecting(so); @@ -1478,9 +1478,9 @@ spx_usr_disconnect(so) } static int -spx_listen(so, p) +spx_listen(so, td) struct socket *so; - struct proc *p; + struct thread *td; { int error; struct ipxpcb *ipxp; @@ -1491,7 +1491,7 @@ spx_listen(so, p) cb = ipxtospxpcb(ipxp); if (ipxp->ipxp_lport == 0) - error = ipx_pcbbind(ipxp, (struct sockaddr *)NULL, p); + error = ipx_pcbbind(ipxp, (struct sockaddr *)NULL, td); if (error == 0) cb->s_state = TCPS_LISTEN; return (error); @@ -1543,13 +1543,13 @@ spx_rcvoob(so, m, flags) } static int -spx_send(so, flags, m, addr, controlp, p) +spx_send(so, flags, m, addr, controlp, td) struct socket *so; int flags; struct mbuf *m; struct sockaddr *addr; struct mbuf *controlp; - struct proc *p; + struct thread *td; { int error; int s; @@ -1612,15 +1612,15 @@ spx_shutdown(so) } static int -spx_sp_attach(so, proto, p) +spx_sp_attach(so, proto, td) struct socket *so; int proto; - struct proc *p; + struct thread *td; { int error; struct ipxpcb *ipxp; - error = spx_attach(so, proto, p); + error = spx_attach(so, proto, td); if (error == 0) { ipxp = sotoipxpcb(so); ((struct spxpcb *)ipxp->ipxp_pcb)->s_flags |= diff --git a/sys/netkey/keysock.c b/sys/netkey/keysock.c index 5eab147..76f6482 100644 --- a/sys/netkey/keysock.c +++ b/sys/netkey/keysock.c @@ -411,7 +411,7 @@ key_abort(struct socket *so) * derived from net/rtsock.c:rts_attach() */ static int -key_attach(struct socket *so, int proto, struct proc *p) +key_attach(struct socket *so, int proto, struct thread *td) { struct keycb *kp; int s, error; @@ -432,7 +432,7 @@ key_attach(struct socket *so, int proto, struct proc *p) */ s = splnet(); so->so_pcb = (caddr_t)kp; - error = raw_usrreqs.pru_attach(so, proto, p); + error = raw_usrreqs.pru_attach(so, proto, td); kp = (struct keycb *)sotorawcb(so); if (error) { free(kp, M_PCB); @@ -461,11 +461,11 @@ key_attach(struct socket *so, int proto, struct proc *p) * derived from net/rtsock.c:rts_bind() */ static int -key_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +key_bind(struct socket *so, struct sockaddr *nam, struct thread *td) { int s, error; s = splnet(); - error = raw_usrreqs.pru_bind(so, nam, p); /* xxx just EINVAL */ + error = raw_usrreqs.pru_bind(so, nam, td); /* xxx just EINVAL */ splx(s); return error; } @@ -475,11 +475,11 @@ key_bind(struct socket *so, struct sockaddr *nam, struct proc *p) * derived from net/rtsock.c:rts_connect() */ static int -key_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +key_connect(struct socket *so, struct sockaddr *nam, struct thread *td) { int s, error; s = splnet(); - error = raw_usrreqs.pru_connect(so, nam, p); /* XXX just EINVAL */ + error = raw_usrreqs.pru_connect(so, nam, td); /* XXX just EINVAL */ splx(s); return error; } @@ -542,11 +542,11 @@ key_peeraddr(struct socket *so, struct sockaddr **nam) */ static int key_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, - struct mbuf *control, struct proc *p) + struct mbuf *control, struct thread *td) { int s, error; s = splnet(); - error = raw_usrreqs.pru_send(so, flags, m, nam, control, p); + error = raw_usrreqs.pru_send(so, flags, m, nam, control, td); splx(s); return error; } diff --git a/sys/netncp/ncp_conn.h b/sys/netncp/ncp_conn.h index 707cac0..a163eed 100644 --- a/sys/netncp/ncp_conn.h +++ b/sys/netncp/ncp_conn.h @@ -195,33 +195,33 @@ struct ncp_conn { int ncp_conn_init(void); int ncp_conn_destroy(void); int ncp_conn_alloc(struct ncp_conn_args *cap, - struct proc *p, struct ucred *cred, struct ncp_conn **connid); + struct thread *td, struct ucred *cred, struct ncp_conn **connid); int ncp_conn_free(struct ncp_conn *conn); int ncp_conn_access(struct ncp_conn *conn,struct ucred *cred,mode_t mode); -int ncp_conn_lock(struct ncp_conn *conn,struct proc *p,struct ucred *cred,int mode); -void ncp_conn_unlock(struct ncp_conn *conn,struct proc *p); -int ncp_conn_assert_locked(struct ncp_conn *conn,char *checker,struct proc *p); +int ncp_conn_lock(struct ncp_conn *conn,struct thread *td, struct ucred *cred,int mode); +void ncp_conn_unlock(struct ncp_conn *conn,struct thread *td); +int ncp_conn_assert_locked(struct ncp_conn *conn,char *checker,struct thread *td); void ncp_conn_invalidate(struct ncp_conn *ncp); int ncp_conn_invalid(struct ncp_conn *ncp); /*int ncp_conn_ref(struct ncp_conn *conn, pid_t pid); int ncp_conn_rm_ref(struct ncp_conn *conn, pid_t pid, int force); void ncp_conn_list_rm_ref(pid_t pid);*/ -int ncp_conn_getbyref(int connRef,struct proc *p,struct ucred *cred, int mode, +int ncp_conn_getbyref(int connRef,struct thread *td, struct ucred *cred, int mode, struct ncp_conn **connpp); -int ncp_conn_getbyli(struct ncp_conn_loginfo *li,struct proc *p,struct ucred *cred, +int ncp_conn_getbyli(struct ncp_conn_loginfo *li,struct thread *td, struct ucred *cred, int mode, struct ncp_conn **connpp); int ncp_conn_setprimary(struct ncp_conn *conn, int on); -int ncp_conn_locklist(int flags, struct proc *p); -void ncp_conn_unlocklist(struct proc *p); -int ncp_conn_gethandle(struct ncp_conn *conn, struct proc *p, struct ncp_handle **handle); -int ncp_conn_puthandle(struct ncp_handle *handle, struct proc *p, int force); -int ncp_conn_findhandle(int connHandle, struct proc *p, struct ncp_handle **handle); -int ncp_conn_getattached(struct ncp_conn_args *li,struct proc *p,struct ucred *cred,int mode, struct ncp_conn **connpp); -int ncp_conn_putprochandles(struct proc *p); +int ncp_conn_locklist(int flags, struct thread *td); +void ncp_conn_unlocklist(struct thread *td); +int ncp_conn_gethandle(struct ncp_conn *conn, struct thread *td, struct ncp_handle **handle); +int ncp_conn_puthandle(struct ncp_handle *handle, struct thread *td, int force); +int ncp_conn_findhandle(int connHandle, struct thread *td, struct ncp_handle **handle); +int ncp_conn_getattached(struct ncp_conn_args *li,struct thread *td, struct ucred *cred,int mode, struct ncp_conn **connpp); +int ncp_conn_putprochandles(struct thread *td); int ncp_conn_getinfo(struct ncp_conn *ncp, struct ncp_conn_stat *ncs); int ncp_conn_reconnect(struct ncp_conn *ncp); -int ncp_conn_login(struct ncp_conn *conn, struct proc *p, struct ucred *cred); +int ncp_conn_login(struct ncp_conn *conn, struct thread *td, struct ucred *cred); extern struct ncp_conn_head conn_list; extern int ncp_burst_enabled; diff --git a/sys/netncp/ncp_rq.h b/sys/netncp/ncp_rq.h index bff912d..106537f 100644 --- a/sys/netncp/ncp_rq.h +++ b/sys/netncp/ncp_rq.h @@ -99,21 +99,21 @@ struct ncp_rq { int nr_rpsize; /* reply size minus ncp header */ int nr_cc; /* completion code */ int nr_cs; /* connection state */ - struct proc * nr_p; /* proc that did rq */ + struct thread * nr_td; /* thread that did rq */ struct ucred * nr_cred; /* user that did rq */ int rexmit; struct ncp_conn*nr_conn; /* back link */ }; -int ncp_rq_alloc(u_int8_t fn, struct ncp_conn *ncp, struct proc *p, +int ncp_rq_alloc(u_int8_t fn, struct ncp_conn *ncp, struct thread *td, struct ucred *cred, struct ncp_rq **rqpp); int ncp_rq_alloc_any(u_int32_t ptype, u_int8_t fn, struct ncp_conn *ncp, - struct proc *p, struct ucred *cred, struct ncp_rq **rqpp); + struct thread *td, struct ucred *cred, struct ncp_rq **rqpp); int ncp_rq_alloc_subfn(u_int8_t fn, u_int8_t subfn, struct ncp_conn *ncp, - struct proc *p, struct ucred *cred, struct ncp_rq **rqpp); + struct thread *td, struct ucred *cred, struct ncp_rq **rqpp); int ncp_rq_init_any(struct ncp_rq *rqp, u_int32_t ptype, u_int8_t fn, struct ncp_conn *ncp, - struct proc *p, struct ucred *cred); + struct thread *td, struct ucred *cred); void ncp_rq_done(struct ncp_rq *rqp); int ncp_request(struct ncp_rq *rqp); int ncp_request_int(struct ncp_rq *rqp); diff --git a/sys/nfs/bootp_subr.c b/sys/nfs/bootp_subr.c index 72fc393..063f77f 100644 --- a/sys/nfs/bootp_subr.c +++ b/sys/nfs/bootp_subr.c @@ -213,11 +213,11 @@ extern struct nfsv3_diskless nfsv3_diskless; /* mountd RPC */ static int md_mount(struct sockaddr_in *mdsin, char *path, u_char *fhp, int *fhsizep, - struct nfs_args *args,struct proc *procp); + struct nfs_args *args,struct thread *td); static int md_lookup_swap(struct sockaddr_in *mdsin,char *path, u_char *fhp, int *fhsizep, struct nfs_args *args, - struct proc *procp); + struct thread *td); static int setfs(struct sockaddr_in *addr, char *path, char *p); static int getdec(char **ptr); static char *substr(char *a,char *b); @@ -231,7 +231,7 @@ static struct bootpc_ifcontext *allocifctx(struct bootpc_globalcontext *gctx); static void bootpc_compose_query(struct bootpc_ifcontext *ifctx, struct bootpc_globalcontext *gctx, - struct proc *procp); + struct thread *td); static unsigned char *bootpc_tag(struct bootpc_tagcontext *tctx, struct bootp_packet *bp, int len, int tag); static void bootpc_tag_helper(struct bootpc_tagcontext *tctx, @@ -248,15 +248,15 @@ void bootpboot_p_iflist(void); #endif static int bootpc_call(struct bootpc_globalcontext *gctx, - struct proc *procp); + struct thread *td); static int bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, struct bootpc_globalcontext *gctx, - struct proc *procp); + struct thread *td); static int bootpc_adjust_interface(struct bootpc_ifcontext *ifctx, struct bootpc_globalcontext *gctx, - struct proc *procp); + struct thread *td); static void bootpc_decode_reply(struct nfsv3_diskless *nd, struct bootpc_ifcontext *ifctx, @@ -581,7 +581,7 @@ bootpc_received(struct bootpc_globalcontext *gctx, static int bootpc_call(struct bootpc_globalcontext *gctx, - struct proc *procp) + struct thread *td) { struct socket *so; struct sockaddr_in *sin, dst; @@ -601,7 +601,7 @@ bootpc_call(struct bootpc_globalcontext *gctx, /* * Create socket and set its recieve timeout. */ - error = socreate(AF_INET, &so, SOCK_DGRAM, 0, procp); + error = socreate(AF_INET, &so, SOCK_DGRAM, 0, td); if (error != 0) goto out; @@ -648,7 +648,7 @@ bootpc_call(struct bootpc_globalcontext *gctx, sin = &dst; clear_sinaddr(sin); sin->sin_port = htons(IPPORT_BOOTPC); - error = sobind(so, (struct sockaddr *)sin, procp); + error = sobind(so, (struct sockaddr *)sin, td); if (error != 0) { printf("bind failed\n"); goto out; @@ -706,7 +706,7 @@ bootpc_call(struct bootpc_globalcontext *gctx, (ifctx->state == IF_BOOTP_UNRESOLVED && ifctx->dhcpquerytype != DHCP_NOMSG)) { ifctx->sentmsg = 0; - bootpc_compose_query(ifctx, gctx, procp); + bootpc_compose_query(ifctx, gctx, td); } /* Send BOOTP request (or re-send). */ @@ -743,21 +743,21 @@ bootpc_call(struct bootpc_globalcontext *gctx, auio.uio_rw = UIO_WRITE; auio.uio_offset = 0; auio.uio_resid = sizeof(ifctx->call); - auio.uio_procp = procp; + auio.uio_td = td; /* Set netmask to 0.0.0.0 */ sin = (struct sockaddr_in *) &ifctx->ireq.ifr_addr; clear_sinaddr(sin); error = ifioctl(ifctx->so, SIOCSIFNETMASK, - (caddr_t) &ifctx->ireq, procp); + (caddr_t) &ifctx->ireq, td); if (error != 0) panic("bootpc_call:" "set if netmask, error=%d", error); error = sosend(so, (struct sockaddr *) &dst, - &auio, NULL, NULL, 0, procp); + &auio, NULL, NULL, 0, td); if (error != 0) { printf("bootpc_call: sosend: %d state %08x\n", error, (int) so->so_state); @@ -772,7 +772,7 @@ bootpc_call(struct bootpc_globalcontext *gctx, clear_sinaddr(sin); sin->sin_addr.s_addr = htonl(0xff000000u); error = ifioctl(ifctx->so, SIOCSIFNETMASK, - (caddr_t) &ifctx->ireq, procp); + (caddr_t) &ifctx->ireq, td); if (error != 0) panic("bootpc_call:" "set if netmask, error=%d", @@ -810,7 +810,7 @@ bootpc_call(struct bootpc_globalcontext *gctx, auio.uio_rw = UIO_READ; auio.uio_offset = 0; auio.uio_resid = sizeof(gctx->reply); - auio.uio_procp = procp; + auio.uio_td = td; rcvflg = 0; error = soreceive(so, NULL, &auio, @@ -979,7 +979,7 @@ out: static int bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, struct bootpc_globalcontext *gctx, - struct proc *procp) + struct thread *td) { struct sockaddr_in *sin; int error; @@ -989,7 +989,7 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, struct ifaddr *ifa; struct sockaddr_dl *sdl; - error = socreate(AF_INET, &ifctx->so, SOCK_DGRAM, 0, procp); + error = socreate(AF_INET, &ifctx->so, SOCK_DGRAM, 0, td); if (error != 0) panic("nfs_boot: socreate, error=%d", error); @@ -1002,11 +1002,11 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, * Get the old interface flags and or IFF_UP into them; if * IFF_UP set blindly, interface selection can be clobbered. */ - error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)ireq, td); if (error != 0) panic("bootpc_fakeup_interface: GIFFLAGS, error=%d", error); ireq->ifr_flags |= IFF_UP; - error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)ireq, td); if (error != 0) panic("bootpc_fakeup_interface: SIFFLAGS, error=%d", error); @@ -1019,7 +1019,7 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, sin = (struct sockaddr_in *) &ireq->ifr_addr; clear_sinaddr(sin); - error = ifioctl(so, SIOCSIFADDR, (caddr_t) ireq, procp); + error = ifioctl(so, SIOCSIFADDR, (caddr_t) ireq, td); if (error != 0 && (error != EEXIST || ifctx == gctx->interfaces)) panic("bootpc_fakeup_interface: " "set if addr, error=%d", error); @@ -1029,7 +1029,7 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, sin = (struct sockaddr_in *) &ireq->ifr_addr; clear_sinaddr(sin); sin->sin_addr.s_addr = htonl(0xff000000u); - error = ifioctl(so, SIOCSIFNETMASK, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCSIFNETMASK, (caddr_t)ireq, td); if (error != 0) panic("bootpc_fakeup_interface: set if netmask, error=%d", error); @@ -1042,7 +1042,7 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, sin->sin_addr.s_addr = htonl(INADDR_BROADCAST); ifctx->broadcast.sin_addr.s_addr = sin->sin_addr.s_addr; - error = ifioctl(so, SIOCSIFBRDADDR, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCSIFBRDADDR, (caddr_t)ireq, td); if (error != 0) panic("bootpc_fakeup_interface: " "set if broadcast addr, error=%d", @@ -1071,7 +1071,7 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, static int bootpc_adjust_interface(struct bootpc_ifcontext *ifctx, struct bootpc_globalcontext *gctx, - struct proc *procp) + struct thread *td) { int error; struct sockaddr_in defdst; @@ -1095,19 +1095,19 @@ bootpc_adjust_interface(struct bootpc_ifcontext *ifctx, /* Shutdown interfaces where BOOTP failed */ printf("Shutdown interface %s\n", ifctx->ireq.ifr_name); - error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)ireq, td); if (error != 0) panic("bootpc_adjust_interface: " "SIOCGIFFLAGS, error=%d", error); ireq->ifr_flags &= ~IFF_UP; - error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)ireq, td); if (error != 0) panic("bootpc_adjust_interface: " "SIOCSIFFLAGS, error=%d", error); sin = (struct sockaddr_in *) &ireq->ifr_addr; clear_sinaddr(sin); - error = ifioctl(so, SIOCDIFADDR, (caddr_t) ireq, procp); + error = ifioctl(so, SIOCDIFADDR, (caddr_t) ireq, td); if (error != 0 && (error != EEXIST || ifctx == gctx->interfaces)) panic("bootpc_adjust_interface: " @@ -1122,7 +1122,7 @@ bootpc_adjust_interface(struct bootpc_ifcontext *ifctx, * can talk to the servers. (just set the address) */ bcopy(netmask, &ireq->ifr_addr, sizeof(*netmask)); - error = ifioctl(so, SIOCSIFNETMASK, (caddr_t) ireq, procp); + error = ifioctl(so, SIOCSIFNETMASK, (caddr_t) ireq, td); if (error != 0) panic("bootpc_adjust_interface: " "set if netmask, error=%d", error); @@ -1133,13 +1133,13 @@ bootpc_adjust_interface(struct bootpc_ifcontext *ifctx, clear_sinaddr(sin); sin->sin_addr.s_addr = myaddr->sin_addr.s_addr | ~ netmask->sin_addr.s_addr; - error = ifioctl(so, SIOCSIFBRDADDR, (caddr_t) ireq, procp); + error = ifioctl(so, SIOCSIFBRDADDR, (caddr_t) ireq, td); if (error != 0) panic("bootpc_adjust_interface: " "set if broadcast addr, error=%d", error); bcopy(myaddr, &ireq->ifr_addr, sizeof(*myaddr)); - error = ifioctl(so, SIOCSIFADDR, (caddr_t) ireq, procp); + error = ifioctl(so, SIOCSIFADDR, (caddr_t) ireq, td); if (error != 0 && (error != EEXIST || ifctx == gctx->interfaces)) panic("bootpc_adjust_interface: " "set if addr, error=%d", error); @@ -1326,10 +1326,10 @@ print_in_addr(struct in_addr addr) } static void -bootpc_compose_query(ifctx, gctx, procp) +bootpc_compose_query(ifctx, gctx, td) struct bootpc_ifcontext *ifctx; struct bootpc_globalcontext *gctx; - struct proc *procp; + struct thread *td; { unsigned char *vendp; uint32_t leasetime; @@ -1670,10 +1670,10 @@ bootpc_init(void) struct ifnet *ifp; int error; struct nfsv3_diskless *nd; - struct proc *procp; + struct thread *td; nd = &nfsv3_diskless; - procp = curproc; + td = curthread; /* * If already filled in, don't touch it here @@ -1745,13 +1745,13 @@ bootpc_init(void) gctx->gotgw = 0; for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next) - bootpc_fakeup_interface(ifctx, gctx, procp); + bootpc_fakeup_interface(ifctx, gctx, td); for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next) - bootpc_compose_query(ifctx, gctx, procp); + bootpc_compose_query(ifctx, gctx, td); ifctx = gctx->interfaces; - error = bootpc_call(gctx, procp); + error = bootpc_call(gctx, td); if (error != 0) { #ifdef BOOTP_NFSROOT @@ -1777,7 +1777,7 @@ bootpc_init(void) #endif for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next) { - bootpc_adjust_interface(ifctx, gctx, procp); + bootpc_adjust_interface(ifctx, gctx, td); soclose(ifctx->so); } @@ -1799,7 +1799,7 @@ bootpc_init(void) error = md_mount(&nd->root_saddr, nd->root_hostnam, nd->root_fh, &nd->root_fhsize, - &nd->root_args, procp); + &nd->root_args, td); if (error != 0) panic("nfs_boot: mountd root, error=%d", error); @@ -1808,7 +1808,7 @@ bootpc_init(void) error = md_mount(&nd->swap_saddr, nd->swap_hostnam, nd->swap_fh, &nd->swap_fhsize, - &nd->swap_args, procp); + &nd->swap_args, td); if (error != 0) panic("nfs_boot: mountd swap, error=%d", error); @@ -1816,7 +1816,7 @@ bootpc_init(void) error = md_lookup_swap(&nd->swap_saddr, gctx->lookup_path, nd->swap_fh, &nd->swap_fhsize, - &nd->swap_args, procp); + &nd->swap_args, td); if (error != 0) panic("nfs_boot: lookup swap, error=%d", error); @@ -1852,7 +1852,7 @@ md_mount(struct sockaddr_in *mdsin, /* mountd server address */ u_char *fhp, int *fhsizep, struct nfs_args *args, - struct proc *procp) + struct thread *td) { struct mbuf *m; int error; @@ -1864,13 +1864,13 @@ md_mount(struct sockaddr_in *mdsin, /* mountd server address */ /* First try NFS v3 */ /* Get port number for MOUNTD. */ error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER3, - &mdsin->sin_port, procp); + &mdsin->sin_port, td); if (error == 0) { m = xdr_string_encode(path, strlen(path)); /* Do RPC to mountd. */ error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER3, - RPCMNT_MOUNT, &m, NULL, procp); + RPCMNT_MOUNT, &m, NULL, td); } if (error == 0) { args->flags |= NFSMNT_NFSV3; @@ -1880,7 +1880,7 @@ md_mount(struct sockaddr_in *mdsin, /* mountd server address */ /* Get port number for MOUNTD. */ error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER1, - &mdsin->sin_port, procp); + &mdsin->sin_port, td); if (error != 0) return error; @@ -1888,7 +1888,7 @@ md_mount(struct sockaddr_in *mdsin, /* mountd server address */ /* Do RPC to mountd. */ error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER1, - RPCMNT_MOUNT, &m, NULL, procp); + RPCMNT_MOUNT, &m, NULL, td); if (error != 0) return error; /* message already freed */ @@ -1931,7 +1931,7 @@ md_mount(struct sockaddr_in *mdsin, /* mountd server address */ error = krpc_portmap(mdsin, NFS_PROG, (args->flags & NFSMNT_NFSV3) ? NFS_VER3 : NFS_VER2, - &mdsin->sin_port, procp); + &mdsin->sin_port, td); goto out; @@ -1950,7 +1950,7 @@ md_lookup_swap(struct sockaddr_in *mdsin, /* mountd server address */ u_char *fhp, int *fhsizep, struct nfs_args *args, - struct proc *procp) + struct thread *td) { struct mbuf *m; int error; @@ -1984,10 +1984,10 @@ md_lookup_swap(struct sockaddr_in *mdsin, /* mountd server address */ /* Do RPC to nfsd. */ if ((args->flags & NFSMNT_NFSV3) != 0) error = krpc_call(mdsin, NFS_PROG, NFS_VER3, - NFSPROC_LOOKUP, &m, NULL, procp); + NFSPROC_LOOKUP, &m, NULL, td); else error = krpc_call(mdsin, NFS_PROG, NFS_VER2, - NFSV2PROC_LOOKUP, &m, NULL, procp); + NFSV2PROC_LOOKUP, &m, NULL, td); if (error != 0) return error; /* message already freed */ diff --git a/sys/nfs/krpc.h b/sys/nfs/krpc.h index 6c889b5..b6136e3 100644 --- a/sys/nfs/krpc.h +++ b/sys/nfs/krpc.h @@ -4,16 +4,16 @@ #include <sys/cdefs.h> struct mbuf; -struct proc; +struct thread; struct sockaddr; struct sockaddr_in; int krpc_call __P((struct sockaddr_in *_sin, u_int prog, u_int vers, u_int func, - struct mbuf **data, struct sockaddr **from, struct proc *procp)); + struct mbuf **data, struct sockaddr **from, struct thread *td)); int krpc_portmap __P((struct sockaddr_in *_sin, - u_int prog, u_int vers, u_int16_t *portp,struct proc *procp)); + u_int prog, u_int vers, u_int16_t *portp,struct thread *td)); struct mbuf *xdr_string_encode __P((char *str, int len)); diff --git a/sys/nfs/krpc_subr.c b/sys/nfs/krpc_subr.c index b7b1d2c..709af4a 100644 --- a/sys/nfs/krpc_subr.c +++ b/sys/nfs/krpc_subr.c @@ -124,11 +124,11 @@ struct rpc_reply { * Returns non-zero error on failure. */ int -krpc_portmap(sin, prog, vers, portp, procp) +krpc_portmap(sin, prog, vers, portp, td) struct sockaddr_in *sin; /* server address */ u_int prog, vers; /* host order */ u_int16_t *portp; /* network order */ - struct proc *procp; + struct thread *td; { struct sdata { u_int32_t prog; /* call program */ @@ -163,7 +163,7 @@ krpc_portmap(sin, prog, vers, portp, procp) sin->sin_port = htons(PMAPPORT); error = krpc_call(sin, PMAPPROG, PMAPVERS, - PMAPPROC_GETPORT, &m, NULL, procp); + PMAPPROC_GETPORT, &m, NULL, td); if (error) return error; @@ -185,12 +185,12 @@ krpc_portmap(sin, prog, vers, portp, procp) * the address from whence the response came is saved there. */ int -krpc_call(sa, prog, vers, func, data, from_p, procp) +krpc_call(sa, prog, vers, func, data, from_p, td) struct sockaddr_in *sa; u_int prog, vers, func; struct mbuf **data; /* input/output */ struct sockaddr **from_p; /* output */ - struct proc *procp; + struct thread *td; { struct socket *so; struct sockaddr_in *sin, ssin; @@ -220,7 +220,7 @@ krpc_call(sa, prog, vers, func, data, from_p, procp) /* * Create socket and set its recieve timeout. */ - if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0, procp))) + if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0, td))) goto out; tv.tv_sec = 1; @@ -260,7 +260,7 @@ krpc_call(sa, prog, vers, func, data, from_p, procp) do { tport--; sin->sin_port = htons(tport); - error = sobind(so, (struct sockaddr *)sin, procp); + error = sobind(so, (struct sockaddr *)sin, td); } while (error == EADDRINUSE && tport > IPPORT_RESERVED / 2); if (error) { @@ -321,7 +321,7 @@ krpc_call(sa, prog, vers, func, data, from_p, procp) goto out; } error = sosend(so, (struct sockaddr *)sa, NULL, m, - NULL, 0, procp); + NULL, 0, td); if (error) { printf("krpc_call: sosend: %d\n", error); goto out; diff --git a/sys/nfs/nfs.h b/sys/nfs/nfs.h index 44d04b9..d5d0796 100644 --- a/sys/nfs/nfs.h +++ b/sys/nfs/nfs.h @@ -348,7 +348,7 @@ struct nfsreq { int r_timer; /* tick counter on reply */ u_int32_t r_procnum; /* NFS procedure number */ int r_rtt; /* RTT for rpc */ - struct proc *r_procp; /* Proc that did I/O system call */ + struct thread *r_td; /* Proc that did I/O system call */ }; /* @@ -469,7 +469,7 @@ struct nfsd { u_char nfsd_authstr[RPCAUTH_MAXSIZ]; /* Authenticator data */ int nfsd_verflen; /* and the Verifier */ u_char nfsd_verfstr[RPCVERF_MAXSIZ]; - struct proc *nfsd_procp; /* Proc ptr */ + struct thread *nfsd_td; /* daemon thread ptr */ struct nfsrv_descript *nfsd_nd; /* Associated nfsrv_descript */ }; @@ -592,16 +592,16 @@ void nfs_sndunlock __P((struct nfsreq *)); int nfs_slplock __P((struct nfssvc_sock *, int)); void nfs_slpunlock __P((struct nfssvc_sock *)); int nfs_disct __P((struct mbuf **, caddr_t *, int, int, caddr_t *)); -int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct proc *, +int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct thread *, int)); int nfs_readrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_writerpc __P((struct vnode *, struct uio *, struct ucred *, int *, int *)); int nfs_commit __P((struct vnode *vp, u_quad_t offset, int cnt, - struct ucred *cred, struct proc *procp)); + struct ucred *cred, struct thread *)); int nfs_readdirrpc __P((struct vnode *, struct uio *, struct ucred *)); -int nfs_asyncio __P((struct buf *, struct ucred *, struct proc *)); -int nfs_doio __P((struct buf *, struct ucred *, struct proc *)); +int nfs_asyncio __P((struct buf *, struct ucred *, struct thread *)); +int nfs_doio __P((struct buf *, struct ucred *, struct thread *)); int nfs_readlinkrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_sigintr __P((struct nfsmount *, struct nfsreq *, struct proc *)); int nfs_readdirplusrpc __P((struct vnode *, struct uio *, struct ucred *)); @@ -613,14 +613,14 @@ void nfsm_srvwcc __P((struct nfsrv_descript *, int, struct vattr *, int, void nfsm_srvpostopattr __P((struct nfsrv_descript *, int, struct vattr *, struct mbuf **, char **)); int netaddr_match __P((int, union nethostaddr *, struct sockaddr *)); -int nfs_request __P((struct vnode *, struct mbuf *, int, struct proc *, +int nfs_request __P((struct vnode *, struct mbuf *, int, struct thread *, struct ucred *, struct mbuf **, struct mbuf **, caddr_t *)); int nfs_loadattrcache __P((struct vnode **, struct mbuf **, caddr_t *, struct vattr *, int)); int nfs_namei __P((struct nameidata *, fhandle_t *, int, struct nfssvc_sock *, struct sockaddr *, struct mbuf **, - caddr_t *, struct vnode **, struct proc *, int, int)); + caddr_t *, struct vnode **, struct thread *, int, int)); void nfsm_adj __P((struct mbuf *, int, int)); int nfsm_mbuftouio __P((struct mbuf **, struct uio *, int, caddr_t *)); void nfsrv_initcache __P((void)); @@ -652,21 +652,21 @@ void nfs_clearcommit __P((struct mount *)); int nfsrv_errmap __P((struct nfsrv_descript *, int)); void nfsrvw_sort __P((gid_t *, int)); void nfsrv_setcred __P((struct ucred *, struct ucred *)); -int nfs_writebp __P((struct buf *, int, struct proc *)); +int nfs_writebp __P((struct buf *, int, struct thread *)); int nfsrv_object_create __P((struct vnode *)); void nfsrv_wakenfsd __P((struct nfssvc_sock *slp)); int nfsrv_writegather __P((struct nfsrv_descript **, struct nfssvc_sock *, - struct proc *, struct mbuf **)); + struct thread *, struct mbuf **)); int nfs_fsinfo __P((struct nfsmount *, struct vnode *, struct ucred *, - struct proc *p)); + struct thread *p)); int nfsrv3_access __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_commit __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_create __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_fhtovp __P((fhandle_t *, int, struct vnode **, struct ucred *, struct nfssvc_sock *, struct sockaddr *, int *, int, int)); @@ -674,52 +674,52 @@ int nfsrv_setpublicfs __P((struct mount *, struct netexport *, struct export_args *)); int nfs_ispublicfh __P((fhandle_t *)); int nfsrv_fsinfo __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_getattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_link __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_lookup __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mkdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mknod __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_noop __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_null __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_pathconf __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_read __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdirplus __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_readlink __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_remove __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rename __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rmdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_setattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_statfs __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_symlink __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_write __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); void nfsrv_rcv __P((struct socket *so, void *arg, int waitflag)); void nfsrv_slpderef __P((struct nfssvc_sock *slp)); #endif /* _KERNEL */ diff --git a/sys/nfs/nfs_bio.c b/sys/nfs/nfs_bio.c index 3bcdb32..e48cd5c 100644 --- a/sys/nfs/nfs_bio.c +++ b/sys/nfs/nfs_bio.c @@ -72,7 +72,7 @@ static int nfs_bwrite(struct buf *bp) { - return (nfs_writebp(bp, 1, curproc)); + return (nfs_writebp(bp, 1, curthread)); } struct buf_ops buf_ops_nfs = { @@ -82,7 +82,7 @@ struct buf_ops buf_ops_nfs = { static struct buf *nfs_getcacheblk __P((struct vnode *vp, daddr_t bn, int size, - struct proc *p)); + struct thread *td)); extern int nfs_numasync; extern int nfs_pbuf_freecnt; @@ -107,7 +107,7 @@ nfs_getpages(ap) vm_offset_t kva; struct buf *bp; struct vnode *vp; - struct proc *p; + struct thread *td; struct ucred *cred; struct nfsmount *nmp; vm_page_t *pages; @@ -115,8 +115,8 @@ nfs_getpages(ap) GIANT_REQUIRED; vp = ap->a_vp; - p = curproc; /* XXX */ - cred = curproc->p_ucred; /* XXX */ + td = curthread; /* XXX */ + cred = curthread->td_proc->p_ucred; /* XXX */ nmp = VFSTONFS(vp->v_mount); pages = ap->a_m; count = ap->a_count; @@ -128,7 +128,7 @@ nfs_getpages(ap) if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) { - (void)nfs_fsinfo(nmp, vp, cred, p); + (void)nfs_fsinfo(nmp, vp, cred, td); } npages = btoc(count); @@ -172,7 +172,7 @@ nfs_getpages(ap) uio.uio_resid = count; uio.uio_segflg = UIO_SYSSPACE; uio.uio_rw = UIO_READ; - uio.uio_procp = p; + uio.uio_td = td; error = nfs_readrpc(vp, &uio, cred); pmap_qremove(kva, npages); @@ -268,7 +268,7 @@ nfs_putpages(ap) off_t offset; int *rtvals; struct vnode *vp; - struct proc *p; + struct thread *td; struct ucred *cred; struct nfsmount *nmp; struct nfsnode *np; @@ -278,8 +278,8 @@ nfs_putpages(ap) vp = ap->a_vp; np = VTONFS(vp); - p = curproc; /* XXX */ - cred = curproc->p_ucred; /* XXX */ + td = curthread; /* XXX */ + cred = curthread->td_proc->p_ucred; /* XXX */ nmp = VFSTONFS(vp->v_mount); pages = ap->a_m; count = ap->a_count; @@ -291,7 +291,7 @@ nfs_putpages(ap) if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) { - (void)nfs_fsinfo(nmp, vp, cred, p); + (void)nfs_fsinfo(nmp, vp, cred, td); } for (i = 0; i < npages; i++) { @@ -327,7 +327,7 @@ nfs_putpages(ap) uio.uio_resid = count; uio.uio_segflg = UIO_SYSSPACE; uio.uio_rw = UIO_WRITE; - uio.uio_procp = p; + uio.uio_td = td; if ((ap->a_sync & VM_PAGER_PUT_SYNC) == 0) iomode = NFSV3WRITE_UNSTABLE; @@ -366,7 +366,7 @@ nfs_bioread(vp, uio, ioflag, cred) register int biosize, i; struct buf *bp = 0, *rabp; struct vattr vattr; - struct proc *p; + struct thread *td; struct nfsmount *nmp = VFSTONFS(vp->v_mount); daddr_t lbn, rabn; int bcount; @@ -381,11 +381,11 @@ nfs_bioread(vp, uio, ioflag, cred) return (0); if (uio->uio_offset < 0) /* XXX VDIR cookies can be negative */ return (EINVAL); - p = uio->uio_procp; + td = uio->uio_td; if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) - (void)nfs_fsinfo(nmp, vp, cred, p); + (void)nfs_fsinfo(nmp, vp, cred, td); if (vp->v_type != VDIR && (uio->uio_offset + uio->uio_resid) > nmp->nm_maxfilesize) return (EFBIG); @@ -414,23 +414,23 @@ nfs_bioread(vp, uio, ioflag, cred) if (vp->v_type != VDIR) panic("nfs: bioread, not dir"); nfs_invaldir(vp); - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); } np->n_attrstamp = 0; - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); np->n_mtime = vattr.va_mtime.tv_sec; } else { - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); if (np->n_mtime != vattr.va_mtime.tv_sec) { if (vp->v_type == VDIR) nfs_invaldir(vp); - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); np->n_mtime = vattr.va_mtime.tv_sec; @@ -445,7 +445,7 @@ nfs_bioread(vp, uio, ioflag, cred) if (nmp->nm_flag & NFSMNT_NQNFS) { if (NQNFS_CKINVALID(vp, np, ND_READ)) { do { - error = nqnfs_getlease(vp, ND_READ, cred, p); + error = nqnfs_getlease(vp, ND_READ, cred, td); } while (error == NQNFS_EXPIRED); if (error) return (error); @@ -454,14 +454,14 @@ nfs_bioread(vp, uio, ioflag, cred) ((np->n_flag & NMODIFIED) && vp->v_type == VDIR)) { if (vp->v_type == VDIR) nfs_invaldir(vp); - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); np->n_brev = np->n_lrev; } } else if (vp->v_type == VDIR && (np->n_flag & NMODIFIED)) { nfs_invaldir(vp); - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); } @@ -493,14 +493,14 @@ nfs_bioread(vp, uio, ioflag, cred) (off_t)(lbn + 1 + nra) * biosize < np->n_size; nra++) { rabn = lbn + 1 + nra; if (!incore(vp, rabn)) { - rabp = nfs_getcacheblk(vp, rabn, biosize, p); + rabp = nfs_getcacheblk(vp, rabn, biosize, td); if (!rabp) return (EINTR); if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) { rabp->b_flags |= B_ASYNC; rabp->b_iocmd = BIO_READ; vfs_busy_pages(rabp, 0); - if (nfs_asyncio(rabp, cred, p)) { + if (nfs_asyncio(rabp, cred, td)) { rabp->b_flags |= B_INVAL; rabp->b_ioflags |= BIO_ERROR; vfs_unbusy_pages(rabp); @@ -534,7 +534,7 @@ again: bcount = np->n_size - (off_t)lbn * biosize; } if (bcount != biosize) { - switch(nfs_rslock(np, p)) { + switch(nfs_rslock(np, td)) { case ENOLCK: goto again; /* not reached */ @@ -547,10 +547,10 @@ again: } } - bp = nfs_getcacheblk(vp, lbn, bcount, p); + bp = nfs_getcacheblk(vp, lbn, bcount, td); if (bcount != biosize) - nfs_rsunlock(np, p); + nfs_rsunlock(np, td); if (!bp) return (EINTR); @@ -562,7 +562,7 @@ again: if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); - error = nfs_doio(bp, cred, p); + error = nfs_doio(bp, cred, td); if (error) { brelse(bp); return (error); @@ -583,13 +583,13 @@ again: break; case VLNK: nfsstats.biocache_readlinks++; - bp = nfs_getcacheblk(vp, (daddr_t)0, NFS_MAXPATHLEN, p); + bp = nfs_getcacheblk(vp, (daddr_t)0, NFS_MAXPATHLEN, td); if (!bp) return (EINTR); if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); - error = nfs_doio(bp, cred, p); + error = nfs_doio(bp, cred, td); if (error) { bp->b_ioflags |= BIO_ERROR; brelse(bp); @@ -607,20 +607,20 @@ again: } lbn = (uoff_t)uio->uio_offset / NFS_DIRBLKSIZ; on = uio->uio_offset & (NFS_DIRBLKSIZ - 1); - bp = nfs_getcacheblk(vp, lbn, NFS_DIRBLKSIZ, p); + bp = nfs_getcacheblk(vp, lbn, NFS_DIRBLKSIZ, td); if (!bp) return (EINTR); if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); - error = nfs_doio(bp, cred, p); + error = nfs_doio(bp, cred, td); if (error) { brelse(bp); } while (error == NFSERR_BAD_COOKIE) { printf("got bad cookie vp %p bp %p\n", vp, bp); nfs_invaldir(vp); - error = nfs_vinvalbuf(vp, 0, cred, p, 1); + error = nfs_vinvalbuf(vp, 0, cred, td, 1); /* * Yuck! The directory has been modified on the * server. The only way to get the block is by @@ -635,13 +635,13 @@ again: if (np->n_direofoffset && (i * NFS_DIRBLKSIZ) >= np->n_direofoffset) return (0); - bp = nfs_getcacheblk(vp, i, NFS_DIRBLKSIZ, p); + bp = nfs_getcacheblk(vp, i, NFS_DIRBLKSIZ, td); if (!bp) return (EINTR); if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); - error = nfs_doio(bp, cred, p); + error = nfs_doio(bp, cred, td); /* * no error + B_INVAL == directory EOF, * use the block. @@ -679,13 +679,13 @@ again: (lbn + 1) * NFS_DIRBLKSIZ < np->n_direofoffset) && !(np->n_flag & NQNFSNONCACHE) && !incore(vp, lbn + 1)) { - rabp = nfs_getcacheblk(vp, lbn + 1, NFS_DIRBLKSIZ, p); + rabp = nfs_getcacheblk(vp, lbn + 1, NFS_DIRBLKSIZ, td); if (rabp) { if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) { rabp->b_flags |= B_ASYNC; rabp->b_iocmd = BIO_READ; vfs_busy_pages(rabp, 0); - if (nfs_asyncio(rabp, cred, p)) { + if (nfs_asyncio(rabp, cred, td)) { rabp->b_flags |= B_INVAL; rabp->b_ioflags |= BIO_ERROR; vfs_unbusy_pages(rabp); @@ -756,7 +756,7 @@ nfs_write(ap) { int biosize; struct uio *uio = ap->a_uio; - struct proc *p = uio->uio_procp; + struct thread *td = uio->uio_td; struct vnode *vp = ap->a_vp; struct nfsnode *np = VTONFS(vp); struct ucred *cred = ap->a_cred; @@ -768,13 +768,14 @@ nfs_write(ap) int bcount; int n, on, error = 0, iomode, must_commit; int haverslock = 0; + struct proc *p = td?td->td_proc:NULL; GIANT_REQUIRED; #ifdef DIAGNOSTIC if (uio->uio_rw != UIO_WRITE) panic("nfs_write mode"); - if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc) + if (uio->uio_segflg == UIO_USERSPACE && uio->uio_td != curthread) panic("nfs_write proc"); #endif if (vp->v_type != VREG) @@ -785,7 +786,7 @@ nfs_write(ap) } if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) - (void)nfs_fsinfo(nmp, vp, cred, p); + (void)nfs_fsinfo(nmp, vp, cred, td); /* * Synchronously flush pending buffers if we are in synchronous @@ -794,7 +795,7 @@ nfs_write(ap) if (ioflag & (IO_APPEND | IO_SYNC)) { if (np->n_flag & NMODIFIED) { np->n_attrstamp = 0; - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); } @@ -807,7 +808,7 @@ nfs_write(ap) restart: if (ioflag & IO_APPEND) { np->n_attrstamp = 0; - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); uio->uio_offset = np->n_size; @@ -836,7 +837,7 @@ restart: */ if ((ioflag & IO_APPEND) || uio->uio_offset + uio->uio_resid > np->n_size) { - switch(nfs_rslock(np, p)) { + switch(nfs_rslock(np, td)) { case ENOLCK: goto restart; /* not reached */ @@ -860,7 +861,7 @@ restart: psignal(p, SIGXFSZ); PROC_UNLOCK(p); if (haverslock) - nfs_rsunlock(np, p); + nfs_rsunlock(np, td); return (EFBIG); } @@ -873,13 +874,13 @@ restart: if ((nmp->nm_flag & NFSMNT_NQNFS) && NQNFS_CKINVALID(vp, np, ND_WRITE)) { do { - error = nqnfs_getlease(vp, ND_WRITE, cred, p); + error = nqnfs_getlease(vp, ND_WRITE, cred, td); } while (error == NQNFS_EXPIRED); if (error) break; if (np->n_lrev != np->n_brev || (np->n_flag & NQNFSNONCACHE)) { - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) break; np->n_brev = np->n_lrev; @@ -910,7 +911,7 @@ again: * readers from reading garbage. */ bcount = on; - bp = nfs_getcacheblk(vp, lbn, bcount, p); + bp = nfs_getcacheblk(vp, lbn, bcount, td); if (bp != NULL) { long save; @@ -939,7 +940,7 @@ again: bcount = np->n_size - (off_t)lbn * biosize; } - bp = nfs_getcacheblk(vp, lbn, bcount, p); + bp = nfs_getcacheblk(vp, lbn, bcount, td); if (uio->uio_offset + n > np->n_size) { np->n_size = uio->uio_offset + n; @@ -981,7 +982,7 @@ again: if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); - error = nfs_doio(bp, cred, p); + error = nfs_doio(bp, cred, td); if (error) { brelse(bp); break; @@ -1047,7 +1048,7 @@ again: if ((nmp->nm_flag & NFSMNT_NQNFS) && NQNFS_CKINVALID(vp, np, ND_WRITE)) { do { - error = nqnfs_getlease(vp, ND_WRITE, cred, p); + error = nqnfs_getlease(vp, ND_WRITE, cred, td); } while (error == NQNFS_EXPIRED); if (error) { brelse(bp); @@ -1056,7 +1057,7 @@ again: if (np->n_lrev != np->n_brev || (np->n_flag & NQNFSNONCACHE)) { brelse(bp); - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) break; np->n_brev = np->n_lrev; @@ -1108,7 +1109,7 @@ again: if (error) break; if (np->n_flag & NQNFSNONCACHE) { - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) break; } @@ -1122,7 +1123,7 @@ again: } while (uio->uio_resid > 0 && n > 0); if (haverslock) - nfs_rsunlock(np, p); + nfs_rsunlock(np, td); return (error); } @@ -1143,11 +1144,11 @@ again: * its EOF. */ static struct buf * -nfs_getcacheblk(vp, bn, size, p) +nfs_getcacheblk(vp, bn, size, td) struct vnode *vp; daddr_t bn; int size; - struct proc *p; + struct thread *td; { register struct buf *bp; struct mount *mp; @@ -1159,7 +1160,7 @@ nfs_getcacheblk(vp, bn, size, p) if (nmp->nm_flag & NFSMNT_INT) { bp = getblk(vp, bn, size, PCATCH, 0); while (bp == (struct buf *)0) { - if (nfs_sigintr(nmp, (struct nfsreq *)0, p)) + if (nfs_sigintr(nmp, (struct nfsreq *)0, td->td_proc)) return ((struct buf *)0); bp = getblk(vp, bn, size, 0, 2 * hz); } @@ -1181,11 +1182,11 @@ nfs_getcacheblk(vp, bn, size, p) * doing the flush, just wait for completion. */ int -nfs_vinvalbuf(vp, flags, cred, p, intrflg) +nfs_vinvalbuf(vp, flags, cred, td, intrflg) struct vnode *vp; int flags; struct ucred *cred; - struct proc *p; + struct thread *td; int intrflg; { register struct nfsnode *np = VTONFS(vp); @@ -1212,7 +1213,7 @@ nfs_vinvalbuf(vp, flags, cred, p, intrflg) np->n_flag |= NFLUSHWANT; error = tsleep((caddr_t)&np->n_flag, PRIBIO + 2, "nfsvinval", slptimeo); - if (error && intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, p)) + if (error && intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, td->td_proc)) return (EINTR); } @@ -1220,9 +1221,9 @@ nfs_vinvalbuf(vp, flags, cred, p, intrflg) * Now, flush as required. */ np->n_flag |= NFLUSHINPROG; - error = vinvalbuf(vp, flags, cred, p, slpflag, 0); + error = vinvalbuf(vp, flags, cred, td, slpflag, 0); while (error) { - if (intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, p)) { + if (intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, td->td_proc)) { np->n_flag &= ~NFLUSHINPROG; if (np->n_flag & NFLUSHWANT) { np->n_flag &= ~NFLUSHWANT; @@ -1230,7 +1231,7 @@ nfs_vinvalbuf(vp, flags, cred, p, intrflg) } return (EINTR); } - error = vinvalbuf(vp, flags, cred, p, 0, slptimeo); + error = vinvalbuf(vp, flags, cred, td, 0, slptimeo); } np->n_flag &= ~(NMODIFIED | NFLUSHINPROG); if (np->n_flag & NFLUSHWANT) { @@ -1249,10 +1250,10 @@ nfs_vinvalbuf(vp, flags, cred, p, intrflg) * is eventually dequeued by the async daemon, nfs_doio() *will*. */ int -nfs_asyncio(bp, cred, procp) +nfs_asyncio(bp, cred, td) register struct buf *bp; struct ucred *cred; - struct proc *procp; + struct thread *td; { struct nfsmount *nmp; int i; @@ -1334,7 +1335,7 @@ again: error = tsleep(&nmp->nm_bufq, slpflag | PRIBIO, "nfsaio", slptimeo); if (error) { - if (nfs_sigintr(nmp, NULL, procp)) + if (nfs_sigintr(nmp, NULL, td->td_proc)) return (EINTR); if (slpflag == PCATCH) { slpflag = 0; @@ -1384,10 +1385,10 @@ again: * synchronously or from an nfsiod. */ int -nfs_doio(bp, cr, p) +nfs_doio(bp, cr, td) struct buf *bp; struct ucred *cr; - struct proc *p; + struct thread *td; { struct uio *uiop; struct vnode *vp; @@ -1396,6 +1397,7 @@ nfs_doio(bp, cr, p) int error = 0, iomode, must_commit = 0; struct uio uio; struct iovec io; + struct proc *p = td?td->td_proc:NULL; vp = bp->b_vp; np = VTONFS(vp); @@ -1404,7 +1406,7 @@ nfs_doio(bp, cr, p) uiop->uio_iov = &io; uiop->uio_iovcnt = 1; uiop->uio_segflg = UIO_SYSSPACE; - uiop->uio_procp = p; + uiop->uio_td = td; /* * clear BIO_ERROR and B_INVAL state prior to initiating the I/O. We @@ -1525,7 +1527,7 @@ nfs_doio(bp, cr, p) bp->b_flags |= B_WRITEINPROG; retv = nfs_commit( bp->b_vp, off, bp->b_dirtyend-bp->b_dirtyoff, - bp->b_wcred, p); + bp->b_wcred, td); bp->b_flags &= ~B_WRITEINPROG; if (retv == 0) { bp->b_dirtyoff = bp->b_dirtyend = 0; diff --git a/sys/nfs/nfs_common.c b/sys/nfs/nfs_common.c index ad8891c..4425129 100644 --- a/sys/nfs/nfs_common.c +++ b/sys/nfs/nfs_common.c @@ -554,11 +554,11 @@ extern struct nfsnodehashhead *nfsnodehashtbl; extern u_long nfsnodehash; struct nfssvc_args; -extern int nfssvc(struct proc *, struct nfssvc_args *, int *); +extern int nfssvc(struct thread *, struct nfssvc_args *, int *); LIST_HEAD(nfsnodehashhead, nfsnode); -int nfs_webnamei __P((struct nameidata *, struct vnode *, struct proc *)); +int nfs_webnamei __P((struct nameidata *, struct vnode *, struct thread *)); u_quad_t nfs_curusec() @@ -950,7 +950,7 @@ nfsm_disct(mdp, dposp, siz, left, cp2) { register struct mbuf *mp, *mp2; register int siz2, xfer; - register caddr_t p; + register caddr_t ptr; mp = *mdp; while (left == 0) { @@ -973,10 +973,10 @@ nfsm_disct(mdp, dposp, siz, left, cp2) mp->m_next = mp2; mp->m_len -= left; mp = mp2; - *cp2 = p = mtod(mp, caddr_t); - bcopy(*dposp, p, left); /* Copy what was left */ + *cp2 = ptr = mtod(mp, caddr_t); + bcopy(*dposp, ptr, left); /* Copy what was left */ siz2 = siz-left; - p += left; + ptr += left; mp2 = mp->m_next; /* Loop around copying up the siz2 bytes */ while (siz2 > 0) { @@ -984,10 +984,10 @@ nfsm_disct(mdp, dposp, siz, left, cp2) return (EBADRPC); xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2; if (xfer > 0) { - bcopy(mtod(mp2, caddr_t), p, xfer); + bcopy(mtod(mp2, caddr_t), ptr, xfer); NFSMADV(mp2, xfer); mp2->m_len -= xfer; - p += xfer; + ptr += xfer; siz2 -= xfer; } if (siz2 > 0) @@ -1464,7 +1464,7 @@ nfs_getattrcache(vp, vaper) * released by the caller. */ int -nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) +nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, td, kerbflag, pubflag) register struct nameidata *ndp; fhandle_t *fhp; int len; @@ -1473,7 +1473,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) struct mbuf **mdp; caddr_t *dposp; struct vnode **retdirp; - struct proc *p; + struct thread *td; int kerbflag, pubflag; { register int i, rem; @@ -1613,7 +1613,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) * becuase lookup() will dereference ni_startdir. */ - cnp->cn_proc = p; + cnp->cn_thread = td; VREF(dp); ndp->ni_startdir = dp; @@ -1649,7 +1649,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) * Validate symlink */ if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1) - VOP_UNLOCK(ndp->ni_dvp, 0, p); + VOP_UNLOCK(ndp->ni_dvp, 0, td); if (!pubflag) { error = EINVAL; goto badlink2; @@ -1670,7 +1670,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) auio.uio_offset = 0; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = (struct proc *)0; + auio.uio_td = (struct thread *)0; auio.uio_resid = MAXPATHLEN; error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred); if (error) { @@ -1924,7 +1924,7 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag, pubflag) int kerbflag; int pubflag; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ register struct mount *mp; register int i; struct ucred *credanon; @@ -1988,7 +1988,7 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag, pubflag) nfsrv_object_create(*vpp); if (!lockflag) - VOP_UNLOCK(*vpp, 0, p); + VOP_UNLOCK(*vpp, 0, td); return (0); } @@ -2196,8 +2196,8 @@ nfsrv_object_create(vp) if (vp == NULL || vp->v_type != VREG) return (1); - return (vfs_object_create(vp, curproc, - curproc ? curproc->p_ucred : NULL)); + return (vfs_object_create(vp, curthread, + curthread ? curthread->td_proc->p_ucred : NULL)); } /* diff --git a/sys/nfs/nfs_lock.c b/sys/nfs/nfs_lock.c index e2fa91c..b97b3b8 100644 --- a/sys/nfs/nfs_lock.c +++ b/sys/nfs/nfs_lock.c @@ -87,14 +87,17 @@ nfs_dolock(ap) { LOCKD_MSG msg; struct nameidata nd; - struct proc *p; + struct thread *td; uid_t saved_uid; struct vnode *vp, *wvp; int error, error1; struct flock *fl; int fmode, ioflg; + struct proc *p; + + td = curthread; + p = td->td_proc; - p = curproc; vp = ap->a_vp; fl = ap->a_fl; @@ -148,7 +151,7 @@ nfs_dolock(ap) * complain that the user's file is missing, which isn't the case. * Note that we use proc0's cred, so the fifo is opened as root. */ - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, _PATH_LCKFIFO, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, _PATH_LCKFIFO, td); /* * XXX Hack to temporarily allow this process (regardless of it's creds) @@ -166,15 +169,15 @@ nfs_dolock(ap) return (error == ENOENT ? EOPNOTSUPP : error); } wvp = nd.ni_vp; - VOP_UNLOCK(wvp, 0, p); /* vn_open leaves it locked */ + VOP_UNLOCK(wvp, 0, td); /* vn_open leaves it locked */ ioflg = IO_UNIT; for (;;) { - VOP_LEASE(wvp, p, proc0.p_ucred, LEASE_WRITE); + VOP_LEASE(wvp, td, proc0.p_ucred, LEASE_WRITE); error = vn_rdwr(UIO_WRITE, wvp, (caddr_t)&msg, sizeof(msg), 0, - UIO_SYSSPACE, ioflg, proc0.p_ucred, NULL, p); + UIO_SYSSPACE, ioflg, proc0.p_ucred, NULL, td); if (error && (((ioflg & IO_NDELAY) == 0) || error != EAGAIN)) { break; @@ -224,7 +227,7 @@ nfs_dolock(ap) break; } - if ((error1 = vn_close(wvp, FWRITE, proc0.p_ucred, p)) && error == 0) + if ((error1 = vn_close(wvp, FWRITE, proc0.p_ucred, td)) && error == 0) return (error1); return (error); diff --git a/sys/nfs/nfs_node.c b/sys/nfs/nfs_node.c index dc21bc3..5fe3abc 100644 --- a/sys/nfs/nfs_node.c +++ b/sys/nfs/nfs_node.c @@ -169,7 +169,7 @@ nfs_nget(mntp, fhp, fhsize, npp) int fhsize; struct nfsnode **npp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct nfsnode *np, *np2; struct nfsnodehashhead *nhpp; register struct vnode *vp; @@ -196,7 +196,7 @@ loop: bcmp((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize)) continue; vp = NFSTOV(np); - if (vget(vp, LK_EXCLUSIVE, p)) + if (vget(vp, LK_EXCLUSIVE, td)) goto loop; *npp = np; return(0); @@ -266,7 +266,7 @@ loop: /* * Lock the new nfsnode. */ - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); return (0); } @@ -275,12 +275,12 @@ int nfs_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct nfsnode *np; register struct sillyrename *sp; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ np = VTONFS(ap->a_vp); if (prtactive && ap->a_vp->v_usecount != 0) @@ -299,11 +299,11 @@ nfs_inactive(ap) * have our own reference. */ if (ap->a_vp->v_usecount > 0) - (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, p, 1); - else if (vget(ap->a_vp, 0, p)) + (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, td, 1); + else if (vget(ap->a_vp, 0, td)) panic("nfs_inactive: lost vnode"); else { - (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, p, 1); + (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, td, 1); vrele(ap->a_vp); } /* @@ -316,7 +316,7 @@ nfs_inactive(ap) } np->n_flag &= (NMODIFIED | NFLUSHINPROG | NFLUSHWANT | NQNFSEVICTED | NQNFSNONCACHE | NQNFSWRITE); - VOP_UNLOCK(ap->a_vp, 0, ap->a_p); + VOP_UNLOCK(ap->a_vp, 0, ap->a_td); return (0); } @@ -459,7 +459,7 @@ int nfs_islocked(ap) struct vop_islocked_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { return VTONFS(ap->a_vp)->n_flag & NLOCKED ? 1 : 0; diff --git a/sys/nfs/nfs_nqlease.c b/sys/nfs/nfs_nqlease.c index 55b44ba..86b5ef6 100644 --- a/sys/nfs/nfs_nqlease.c +++ b/sys/nfs/nfs_nqlease.c @@ -174,12 +174,12 @@ extern struct nfsstats nfsstats; * queue yet. (Ditto for the splsoftclock() and splx(s) calls) */ int -nqsrv_getlease(vp, duration, flags, slp, procp, nam, cachablep, frev, cred) +nqsrv_getlease(vp, duration, flags, slp, td, nam, cachablep, frev, cred) struct vnode *vp; u_int32_t *duration; int flags; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct sockaddr *nam; int *cachablep; u_quad_t *frev; @@ -198,7 +198,7 @@ nqsrv_getlease(vp, duration, flags, slp, procp, nam, cachablep, frev, cred) return (0); if (*duration > nqsrv_maxlease) *duration = nqsrv_maxlease; - error = VOP_GETATTR(vp, &vattr, cred, procp); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); *frev = vattr.va_filerev; @@ -340,9 +340,9 @@ doreply: * OS needs. */ void -nqnfs_lease_check(vp, p, cred, flag) +nqnfs_lease_check(vp, td, cred, flag) struct vnode *vp; - struct proc *p; + struct thread *td; struct ucred *cred; int flag; { @@ -351,14 +351,14 @@ nqnfs_lease_check(vp, p, cred, flag) u_quad_t frev; (void) nqsrv_getlease(vp, &duration, ND_CHECK | flag, NQLOCALSLP, - p, (struct sockaddr *)0, &cache, &frev, cred); + td, (struct sockaddr *)0, &cache, &frev, cred); } int nqnfs_vop_lease_check(ap) struct vop_lease_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; struct ucred *a_cred; int a_flag; } */ *ap; @@ -368,7 +368,7 @@ nqnfs_vop_lease_check(ap) u_quad_t frev; (void) nqsrv_getlease(ap->a_vp, &duration, ND_CHECK | ap->a_flag, - NQLOCALSLP, ap->a_p, (struct sockaddr *)0, + NQLOCALSLP, ap->a_td, (struct sockaddr *)0, &cache, &frev, ap->a_cred); return (0); } @@ -723,10 +723,10 @@ nqnfs_serverd() * do the real work. */ int -nqnfsrv_getlease(nfsd, slp, procp, mrq) +nqnfsrv_getlease(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -764,9 +764,9 @@ nqnfsrv_getlease(nfsd, slp, procp, mrq) vput(vp); nfsm_reply(0); } - (void) nqsrv_getlease(vp, &nfsd->nd_duration, flags, slp, procp, + (void) nqsrv_getlease(vp, &nfsd->nd_duration, flags, slp, td, nam, &cache, &frev, cred); - error = VOP_GETATTR(vp, vap, cred, procp); + error = VOP_GETATTR(vp, vap, cred, td); vput(vp); nfsm_reply(NFSX_V3FATTR + 4 * NFSX_UNSIGNED); nfsm_build(tl, u_int32_t *, 4 * NFSX_UNSIGNED); @@ -783,10 +783,10 @@ nqnfsrv_getlease(nfsd, slp, procp, mrq) * client. Find the entry and expire it. */ int -nqnfsrv_vacated(nfsd, slp, procp, mrq) +nqnfsrv_vacated(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -861,11 +861,11 @@ nfsmout: * Client get lease rpc function. */ int -nqnfs_getlease(vp, rwflag, cred, p) +nqnfs_getlease(vp, rwflag, cred, td) register struct vnode *vp; int rwflag; struct ucred *cred; - struct proc *p; + struct thread *td; { register u_int32_t *tl; register caddr_t cp; @@ -887,7 +887,7 @@ nqnfs_getlease(vp, rwflag, cred, p) *tl++ = txdr_unsigned(rwflag); *tl = txdr_unsigned(nmp->nm_leaseterm); reqtime = time_second; - nfsm_request(vp, NQNFSPROC_GETLEASE, p, cred); + nfsm_request(vp, NQNFSPROC_GETLEASE, td, cred); np = VTONFS(vp); nfsm_dissect(tl, u_int32_t *, 4 * NFSX_UNSIGNED); cachable = fxdr_unsigned(int, *tl++); @@ -1018,13 +1018,13 @@ nqnfs_callback(nmp, mrep, md, dpos) * the list asynchronously. */ int -nqnfs_clientd(nmp, cred, ncd, flag, argp, p) +nqnfs_clientd(nmp, cred, ncd, flag, argp, td) register struct nfsmount *nmp; struct ucred *cred; struct nfsd_cargs *ncd; int flag; caddr_t argp; - struct proc *p; + struct thread *td; { register struct nfsnode *np; struct vnode *vp; @@ -1078,7 +1078,7 @@ nqnfs_clientd(nmp, cred, ncd, flag, argp, p) myrep.r_flags = R_GETONEREP; myrep.r_nmp = nmp; myrep.r_mrep = (struct mbuf *)0; - myrep.r_procp = (struct proc *)0; + myrep.r_td = (struct thread *)0; (void) nfs_reply(&myrep); } @@ -1091,7 +1091,7 @@ nqnfs_clientd(nmp, cred, ncd, flag, argp, p) vp = NFSTOV(np); vpid = vp->v_id; if (np->n_expiry < time_second) { - if (vget(vp, LK_EXCLUSIVE, p) == 0) { + if (vget(vp, LK_EXCLUSIVE, td) == 0) { nmp->nm_inprog = vp; if (vpid == vp->v_id) { TAILQ_REMOVE(&nmp->nm_timerhead, np, n_timer); @@ -1102,12 +1102,12 @@ nqnfs_clientd(nmp, cred, ncd, flag, argp, p) nfs_invaldir(vp); cache_purge(vp); (void) nfs_vinvalbuf(vp, - V_SAVE, cred, p, 0); + V_SAVE, cred, td, 0); np->n_flag &= ~NQNFSEVICTED; (void) nqnfs_vacated(vp, cred); } else if (vp->v_type == VREG) { (void) VOP_FSYNC(vp, cred, - MNT_WAIT, p); + MNT_WAIT, td); np->n_flag &= ~NMODIFIED; } } @@ -1119,10 +1119,10 @@ nqnfs_clientd(nmp, cred, ncd, flag, argp, p) if ((np->n_flag & (NQNFSWRITE | NQNFSNONCACHE)) == NQNFSWRITE && !TAILQ_EMPTY(&vp->v_dirtyblkhd) && - vget(vp, LK_EXCLUSIVE, p) == 0) { + vget(vp, LK_EXCLUSIVE, td) == 0) { nmp->nm_inprog = vp; if (vpid == vp->v_id && - nqnfs_getlease(vp, ND_WRITE, cred, p)==0) + nqnfs_getlease(vp, ND_WRITE, cred, td)==0) np->n_brev = np->n_lrev; vput(vp); nmp->nm_inprog = NULLVP; @@ -1151,7 +1151,7 @@ nqnfs_clientd(nmp, cred, ncd, flag, argp, p) error = tsleep((caddr_t)&nmp->nm_authstr, PSOCK | PCATCH, "nqnfstimr", hz / 3); if (error == EINTR || error == ERESTART) - (void) dounmount(nmp->nm_mountp, 0, p); + (void) dounmount(nmp->nm_mountp, 0, td); } } @@ -1180,7 +1180,7 @@ void nqnfs_lease_updatetime(deltat) register int deltat; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct nqlease *lp; struct nfsnode *np; struct mount *mp, *nxtmp; @@ -1200,7 +1200,7 @@ nqnfs_lease_updatetime(deltat) */ mtx_lock(&mountlist_mtx); for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nxtmp) { - if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, p)) { + if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) { nxtmp = TAILQ_NEXT(mp, mnt_list); continue; } @@ -1214,7 +1214,7 @@ nqnfs_lease_updatetime(deltat) } mtx_lock(&mountlist_mtx); nxtmp = TAILQ_NEXT(mp, mnt_list); - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); } mtx_unlock(&mountlist_mtx); } diff --git a/sys/nfs/nfs_serv.c b/sys/nfs/nfs_serv.c index e015d17..0469388 100644 --- a/sys/nfs/nfs_serv.c +++ b/sys/nfs/nfs_serv.c @@ -145,7 +145,7 @@ SYSCTL_INT(_vfs_nfs, OID_AUTO, commit_blks, CTLFLAG_RW, &nfs_commit_blks, 0, "") SYSCTL_INT(_vfs_nfs, OID_AUTO, commit_miss, CTLFLAG_RW, &nfs_commit_miss, 0, ""); static int nfsrv_access __P((struct vnode *,int,struct ucred *,int, - struct proc *, int)); + struct thread *, int)); static void nfsrvw_coalesce __P((struct nfsrv_descript *, struct nfsrv_descript *)); @@ -168,10 +168,10 @@ ndclear(struct nameidata *nd) * nfs v3 access service */ int -nfsrv3_access(nfsd, slp, procp, mrq) +nfsrv3_access(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -208,7 +208,7 @@ nfsrv3_access(nfsd, slp, procp, mrq) } nfsmode = fxdr_unsigned(u_int32_t, *tl); if ((nfsmode & NFSV3ACCESS_READ) && - nfsrv_access(vp, VREAD, cred, rdonly, procp, 0)) + nfsrv_access(vp, VREAD, cred, rdonly, td, 0)) nfsmode &= ~NFSV3ACCESS_READ; if (vp->v_type == VDIR) testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND | @@ -216,16 +216,16 @@ nfsrv3_access(nfsd, slp, procp, mrq) else testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND); if ((nfsmode & testmode) && - nfsrv_access(vp, VWRITE, cred, rdonly, procp, 0)) + nfsrv_access(vp, VWRITE, cred, rdonly, td, 0)) nfsmode &= ~testmode; if (vp->v_type == VDIR) testmode = NFSV3ACCESS_LOOKUP; else testmode = NFSV3ACCESS_EXECUTE; if ((nfsmode & testmode) && - nfsrv_access(vp, VEXEC, cred, rdonly, procp, 0)) + nfsrv_access(vp, VEXEC, cred, rdonly, td, 0)) nfsmode &= ~testmode; - getret = VOP_GETATTR(vp, vap, cred, procp); + getret = VOP_GETATTR(vp, vap, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_POSTOPATTR(1) + NFSX_UNSIGNED); @@ -242,10 +242,10 @@ nfsmout: * nfs getattr service */ int -nfsrv_getattr(nfsd, slp, procp, mrq) +nfsrv_getattr(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -277,7 +277,7 @@ nfsrv_getattr(nfsd, slp, procp, mrq) goto nfsmout; } nqsrv_getl(vp, ND_READ); - error = VOP_GETATTR(vp, vap, cred, procp); + error = VOP_GETATTR(vp, vap, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_FATTR(nfsd->nd_flag & ND_NFSV3)); @@ -299,10 +299,10 @@ nfsmout: * nfs setattr service */ int -nfsrv_setattr(nfsd, slp, procp, mrq) +nfsrv_setattr(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -399,7 +399,7 @@ nfsrv_setattr(nfsd, slp, procp, mrq) nqsrv_getl(vp, ND_WRITE); if (v3) { - error = preat_ret = VOP_GETATTR(vp, &preat, cred, procp); + error = preat_ret = VOP_GETATTR(vp, &preat, cred, td); if (!error && gcheck && (preat.va_ctime.tv_sec != guard.tv_sec || preat.va_ctime.tv_nsec != guard.tv_nsec)) @@ -428,11 +428,11 @@ nfsrv_setattr(nfsd, slp, procp, mrq) error = EISDIR; goto out; } else if ((error = nfsrv_access(vp, VWRITE, cred, rdonly, - procp, 0)) != 0) + td, 0)) != 0) goto out; } - error = VOP_SETATTR(vp, vap, cred, procp); - postat_ret = VOP_GETATTR(vp, vap, cred, procp); + error = VOP_SETATTR(vp, vap, cred, td); + postat_ret = VOP_GETATTR(vp, vap, cred, td); if (!error) error = postat_ret; out: @@ -462,10 +462,10 @@ nfsmout: * nfs lookup rpc */ int -nfsrv_lookup(nfsd, slp, procp, mrq) +nfsrv_lookup(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -501,7 +501,7 @@ nfsrv_lookup(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = LOOKUP; nd.ni_cnd.cn_flags = LOCKLEAF | SAVESTART; error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), pubflag); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), pubflag); /* * namei failure, only dirp to cleanup. Clear out garbarge from @@ -512,7 +512,7 @@ nfsrv_lookup(nfsd, slp, procp, mrq) if (dirp) { if (v3) dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred, - procp); + td); vrele(dirp); dirp = NULL; } @@ -544,7 +544,7 @@ nfsrv_lookup(nfsd, slp, procp, mrq) * via the original nd. Confused? You aren't alone! */ ind = nd; - VOP_UNLOCK(nd.ni_vp, 0, procp); + VOP_UNLOCK(nd.ni_vp, 0, td); ind.ni_pathlen = strlen(nfs_pub.np_index); ind.ni_cnd.cn_nameptr = ind.ni_cnd.cn_pnbuf = nfs_pub.np_index; @@ -586,7 +586,7 @@ nfsrv_lookup(nfsd, slp, procp, mrq) if (dirp) { if (v3) dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred, - procp); + td); vrele(dirp); dirp = NULL; } @@ -624,7 +624,7 @@ nfsrv_lookup(nfsd, slp, procp, mrq) fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid; error = VFS_VPTOFH(vp, &fhp->fh_fid); if (!error) - error = VOP_GETATTR(vp, vap, cred, procp); + error = VOP_GETATTR(vp, vap, cred, td); vput(vp); ndp->ni_vp = NULL; @@ -658,10 +658,10 @@ nfsmout: * nfs readlink service */ int -nfsrv_readlink(nfsd, slp, procp, mrq) +nfsrv_readlink(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -720,7 +720,7 @@ nfsrv_readlink(nfsd, slp, procp, mrq) uiop->uio_resid = len; uiop->uio_rw = UIO_READ; uiop->uio_segflg = UIO_SYSSPACE; - uiop->uio_procp = (struct proc *)0; + uiop->uio_td = (struct thread *)0; error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE); if (error) { @@ -739,7 +739,7 @@ nfsrv_readlink(nfsd, slp, procp, mrq) nqsrv_getl(vp, ND_READ); error = VOP_READLINK(vp, uiop, cred); out: - getret = VOP_GETATTR(vp, &attr, cred, procp); + getret = VOP_GETATTR(vp, &attr, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_UNSIGNED); @@ -771,10 +771,10 @@ nfsmout: * nfs read service */ int -nfsrv_read(nfsd, slp, procp, mrq) +nfsrv_read(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -840,10 +840,10 @@ nfsrv_read(nfsd, slp, procp, mrq) } if (!error) { nqsrv_getl(vp, ND_READ); - if ((error = nfsrv_access(vp, VREAD, cred, rdonly, procp, 1)) != 0) - error = nfsrv_access(vp, VEXEC, cred, rdonly, procp, 1); + if ((error = nfsrv_access(vp, VREAD, cred, rdonly, td, 1)) != 0) + error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 1); } - getret = VOP_GETATTR(vp, vap, cred, procp); + getret = VOP_GETATTR(vp, vap, cred, td); if (!error) error = getret; if (error) { @@ -982,7 +982,7 @@ nfsrv_read(nfsd, slp, procp, mrq) off = uiop->uio_offset; nh->nh_nextr = off; FREE((caddr_t)iv2, M_TEMP); - if (error || (getret = VOP_GETATTR(vp, vap, cred, procp))) { + if (error || (getret = VOP_GETATTR(vp, vap, cred, td))) { if (!error) error = getret; m_freem(mreq); @@ -1022,10 +1022,10 @@ nfsmout: * nfs write service */ int -nfsrv_write(nfsd, slp, procp, mrq) +nfsrv_write(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -1137,7 +1137,7 @@ nfsrv_write(nfsd, slp, procp, mrq) goto nfsmout; } if (v3) - forat_ret = VOP_GETATTR(vp, &forat, cred, procp); + forat_ret = VOP_GETATTR(vp, &forat, cred, td); if (vp->v_type != VREG) { if (v3) error = EINVAL; @@ -1146,7 +1146,7 @@ nfsrv_write(nfsd, slp, procp, mrq) } if (!error) { nqsrv_getl(vp, ND_WRITE); - error = nfsrv_access(vp, VWRITE, cred, rdonly, procp, 1); + error = nfsrv_access(vp, VWRITE, cred, rdonly, td, 1); } if (error) { vput(vp); @@ -1188,13 +1188,13 @@ nfsrv_write(nfsd, slp, procp, mrq) uiop->uio_resid = len; uiop->uio_rw = UIO_WRITE; uiop->uio_segflg = UIO_SYSSPACE; - uiop->uio_procp = (struct proc *)0; + uiop->uio_td = (struct thread *)0; uiop->uio_offset = off; error = VOP_WRITE(vp, uiop, ioflags, cred); nfsstats.srvvop_writes++; FREE((caddr_t)iv, M_TEMP); } - aftat_ret = VOP_GETATTR(vp, vap, cred, procp); + aftat_ret = VOP_GETATTR(vp, vap, cred, td); vput(vp); vp = NULL; if (!error) @@ -1246,10 +1246,10 @@ nfsmout: * Jan. 1994. */ int -nfsrv_writegather(ndp, slp, procp, mrq) +nfsrv_writegather(ndp, slp, td, mrq) struct nfsrv_descript **ndp; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { register struct iovec *ivp; @@ -1427,7 +1427,7 @@ loop1: nfsd->nd_nam, &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE); if (!error) { if (v3) - forat_ret = VOP_GETATTR(vp, &forat, cred, procp); + forat_ret = VOP_GETATTR(vp, &forat, cred, td); if (vp->v_type != VREG) { if (v3) error = EINVAL; @@ -1439,7 +1439,7 @@ loop1: } if (!error) { nqsrv_getl(vp, ND_WRITE); - error = nfsrv_access(vp, VWRITE, cred, rdonly, procp, 1); + error = nfsrv_access(vp, VWRITE, cred, rdonly, td, 1); } if (nfsd->nd_stable == NFSV3WRITE_UNSTABLE) @@ -1450,7 +1450,7 @@ loop1: ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED); uiop->uio_rw = UIO_WRITE; uiop->uio_segflg = UIO_SYSSPACE; - uiop->uio_procp = (struct proc *)0; + uiop->uio_td = (struct thread *)0; uiop->uio_offset = nfsd->nd_off; uiop->uio_resid = nfsd->nd_eoff - nfsd->nd_off; if (uiop->uio_resid > 0) { @@ -1476,9 +1476,9 @@ loop1: } if (!error) { if (vn_start_write(vp, &mntp, V_NOWAIT) != 0) { - VOP_UNLOCK(vp, 0, procp); + VOP_UNLOCK(vp, 0, td); error = vn_start_write(NULL, &mntp, V_WAIT); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, procp); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); } } if (!error) { @@ -1490,7 +1490,7 @@ loop1: } m_freem(mrep); if (vp) { - aftat_ret = VOP_GETATTR(vp, &va, cred, procp); + aftat_ret = VOP_GETATTR(vp, &va, cred, td); vput(vp); vp = NULL; } @@ -1631,10 +1631,10 @@ nfsrvw_coalesce(owp, nfsd) * now does a truncate to 0 length via. setattr if it already exists */ int -nfsrv_create(nfsd, slp, procp, mrq) +nfsrv_create(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -1696,11 +1696,11 @@ nfsrv_create(nfsd, slp, procp, mrq) * prior to calling nfsm_reply ( which might goto nfsmout ). */ error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -1793,7 +1793,7 @@ nfsrv_create(nfsd, slp, procp, mrq) bcopy(cverf, (caddr_t)&vap->va_atime, NFSX_V3CREATEVERF); error = VOP_SETATTR(nd.ni_vp, vap, cred, - procp); + td); } } } else if ( @@ -1836,7 +1836,7 @@ nfsrv_create(nfsd, slp, procp, mrq) */ nd.ni_cnd.cn_nameiop = LOOKUP; nd.ni_cnd.cn_flags &= ~(LOCKPARENT); - nd.ni_cnd.cn_proc = procp; + nd.ni_cnd.cn_thread = td; nd.ni_cnd.cn_cred = cred; error = lookup(&nd); @@ -1857,14 +1857,14 @@ nfsrv_create(nfsd, slp, procp, mrq) } else { if (vap->va_size != -1) { error = nfsrv_access(nd.ni_vp, VWRITE, cred, - (nd.ni_cnd.cn_flags & RDONLY), procp, 0); + (nd.ni_cnd.cn_flags & RDONLY), td, 0); if (!error) { nqsrv_getl(nd.ni_vp, ND_WRITE); tempsize = vap->va_size; VATTR_NULL(vap); vap->va_size = tempsize; error = VOP_SETATTR(nd.ni_vp, vap, cred, - procp); + td); } } } @@ -1874,13 +1874,13 @@ nfsrv_create(nfsd, slp, procp, mrq) fhp->fh_fsid = nd.ni_vp->v_mount->mnt_stat.f_fsid; error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid); if (!error) - error = VOP_GETATTR(nd.ni_vp, vap, cred, procp); + error = VOP_GETATTR(nd.ni_vp, vap, cred, td); } if (v3) { if (exclusive_flag && !error && bcmp(cverf, (caddr_t)&vap->va_atime, NFSX_V3CREATEVERF)) error = EEXIST; - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); vrele(dirp); dirp = NULL; } @@ -1930,10 +1930,10 @@ nfsmout: * nfs v3 mknod service */ int -nfsrv_mknod(nfsd, slp, procp, mrq) +nfsrv_mknod(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -1986,9 +1986,9 @@ nfsrv_mknod(nfsd, slp, procp, mrq) */ error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) - dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, procp); + dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, td); if (error) { nfsm_reply(NFSX_WCCDATA(1)); nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft); @@ -2046,8 +2046,8 @@ nfsrv_mknod(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = LOOKUP; nd.ni_cnd.cn_flags &= ~(LOCKPARENT); - nd.ni_cnd.cn_proc = procp; - nd.ni_cnd.cn_cred = procp->p_ucred; + nd.ni_cnd.cn_thread = td; + nd.ni_cnd.cn_cred = td->td_proc->p_ucred; error = lookup(&nd); nd.ni_dvp = NULL; @@ -2080,12 +2080,12 @@ out: fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid; error = VFS_VPTOFH(vp, &fhp->fh_fid); if (!error) - error = VOP_GETATTR(vp, vap, cred, procp); + error = VOP_GETATTR(vp, vap, cred, td); vput(vp); vp = NULL; nd.ni_vp = NULL; } - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); if (dirp) { vrele(dirp); dirp = NULL; @@ -2121,10 +2121,10 @@ nfsmout: * nfs remove service */ int -nfsrv_remove(nfsd, slp, procp, mrq) +nfsrv_remove(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2169,11 +2169,11 @@ nfsrv_remove(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = DELETE; nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF; error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -2200,7 +2200,7 @@ out: } } if (dirp && v3) { - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); vrele(dirp); dirp = NULL; } @@ -2228,10 +2228,10 @@ nfsmout: * nfs rename service */ int -nfsrv_rename(nfsd, slp, procp, mrq) +nfsrv_rename(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2293,11 +2293,11 @@ nfsrv_rename(nfsd, slp, procp, mrq) fromnd.ni_cnd.cn_nameiop = DELETE; fromnd.ni_cnd.cn_flags = WANTPARENT | SAVESTART; error = nfs_namei(&fromnd, ffhp, len, slp, nam, &md, - &dpos, &fdirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dpos, &fdirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (fdirp) { if (v3) { fdirfor_ret = VOP_GETATTR(fdirp, &fdirfor, cred, - procp); + td); } else { vrele(fdirp); fdirp = NULL; @@ -2318,11 +2318,11 @@ nfsrv_rename(nfsd, slp, procp, mrq) tond.ni_cnd.cn_nameiop = RENAME; tond.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART; error = nfs_namei(&tond, tfhp, len2, slp, nam, &md, - &dpos, &tdirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dpos, &tdirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (tdirp) { if (v3) { tdirfor_ret = VOP_GETATTR(tdirp, &tdirfor, cred, - procp); + td); } else { vrele(tdirp); tdirp = NULL; @@ -2415,9 +2415,9 @@ out: out1: if (fdirp) - fdiraft_ret = VOP_GETATTR(fdirp, &fdiraft, cred, procp); + fdiraft_ret = VOP_GETATTR(fdirp, &fdiraft, cred, td); if (tdirp) - tdiraft_ret = VOP_GETATTR(tdirp, &tdiraft, cred, procp); + tdiraft_ret = VOP_GETATTR(tdirp, &tdiraft, cred, td); nfsm_reply(2 * NFSX_WCCDATA(v3)); if (v3) { nfsm_srvwcc_data(fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft); @@ -2465,10 +2465,10 @@ nfsmout: * nfs link service */ int -nfsrv_link(nfsd, slp, procp, mrq) +nfsrv_link(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2528,11 +2528,11 @@ nfsrv_link(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = CREATE; nd.ni_cnd.cn_flags = LOCKPARENT; error = nfs_namei(&nd, dfhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -2560,9 +2560,9 @@ out: out1: if (v3) - getret = VOP_GETATTR(vp, &at, cred, procp); + getret = VOP_GETATTR(vp, &at, cred, td); if (dirp) - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); ereply: nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3)); if (v3) { @@ -2594,10 +2594,10 @@ nfsmout: * nfs symbolic link service */ int -nfsrv_symlink(nfsd, slp, procp, mrq) +nfsrv_symlink(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2644,11 +2644,11 @@ nfsrv_symlink(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = CREATE; nd.ni_cnd.cn_flags = LOCKPARENT | SAVESTART; error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -2670,7 +2670,7 @@ nfsrv_symlink(nfsd, slp, procp, mrq) io.uio_iovcnt = 1; io.uio_segflg = UIO_SYSSPACE; io.uio_rw = UIO_READ; - io.uio_procp = (struct proc *)0; + io.uio_td = (struct thread *)0; nfsm_mtouio(&io, len2); if (!v3) { nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR); @@ -2712,7 +2712,7 @@ nfsrv_symlink(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = LOOKUP; nd.ni_cnd.cn_flags &= ~(LOCKPARENT | FOLLOW); nd.ni_cnd.cn_flags |= (NOFOLLOW | LOCKLEAF); - nd.ni_cnd.cn_proc = procp; + nd.ni_cnd.cn_thread = td; nd.ni_cnd.cn_cred = cred; error = lookup(&nd); @@ -2724,7 +2724,7 @@ nfsrv_symlink(nfsd, slp, procp, mrq) error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid); if (!error) error = VOP_GETATTR(nd.ni_vp, vap, cred, - procp); + td); vput(nd.ni_vp); nd.ni_vp = NULL; } @@ -2740,7 +2740,7 @@ out: pathcp = NULL; } if (dirp) { - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); vrele(dirp); dirp = NULL; } @@ -2784,10 +2784,10 @@ nfsmout: * nfs mkdir service */ int -nfsrv_mkdir(nfsd, slp, procp, mrq) +nfsrv_mkdir(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2836,11 +2836,11 @@ nfsrv_mkdir(nfsd, slp, procp, mrq) nd.ni_cnd.cn_flags = LOCKPARENT; error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -2890,11 +2890,11 @@ nfsrv_mkdir(nfsd, slp, procp, mrq) fhp->fh_fsid = nd.ni_vp->v_mount->mnt_stat.f_fsid; error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid); if (!error) - error = VOP_GETATTR(nd.ni_vp, vap, cred, procp); + error = VOP_GETATTR(nd.ni_vp, vap, cred, td); } out: if (dirp) - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); nfsm_reply(NFSX_SRVFH(v3) + NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3)); if (v3) { if (!error) { @@ -2935,10 +2935,10 @@ nfsmout: * nfs rmdir service */ int -nfsrv_rmdir(nfsd, slp, procp, mrq) +nfsrv_rmdir(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2981,11 +2981,11 @@ nfsrv_rmdir(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = DELETE; nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF; error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -3027,7 +3027,7 @@ out: NDFREE(&nd, NDF_ONLY_PNBUF); if (dirp) - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); nfsm_reply(NFSX_WCCDATA(v3)); if (v3) { nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft); @@ -3091,10 +3091,10 @@ struct flrep { }; int -nfsrv_readdir(nfsd, slp, procp, mrq) +nfsrv_readdir(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -3163,7 +3163,7 @@ nfsrv_readdir(nfsd, slp, procp, mrq) nqsrv_getl(vp, ND_READ); if (v3) { - error = getret = VOP_GETATTR(vp, &at, cred, procp); + error = getret = VOP_GETATTR(vp, &at, cred, td); #if 0 /* * XXX This check may be too strict for Solaris 2.5 clients. @@ -3173,7 +3173,7 @@ nfsrv_readdir(nfsd, slp, procp, mrq) #endif } if (!error) - error = nfsrv_access(vp, VEXEC, cred, rdonly, procp, 0); + error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 0); if (error) { vput(vp); vp = NULL; @@ -3182,7 +3182,7 @@ nfsrv_readdir(nfsd, slp, procp, mrq) error = 0; goto nfsmout; } - VOP_UNLOCK(vp, 0, procp); + VOP_UNLOCK(vp, 0, td); /* * end section. Allocate rbuf and continue @@ -3197,9 +3197,9 @@ again: io.uio_resid = fullsiz; io.uio_segflg = UIO_SYSSPACE; io.uio_rw = UIO_READ; - io.uio_procp = (struct proc *)0; + io.uio_td = (struct thread *)0; eofflag = 0; - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, procp); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (cookies) { free((caddr_t)cookies, M_TEMP); cookies = NULL; @@ -3209,11 +3209,11 @@ again: if (!cookies && !error) error = NFSERR_PERM; if (v3) { - getret = VOP_GETATTR(vp, &at, cred, procp); + getret = VOP_GETATTR(vp, &at, cred, td); if (!error) error = getret; } - VOP_UNLOCK(vp, 0, procp); + VOP_UNLOCK(vp, 0, td); if (error) { vrele(vp); vp = NULL; @@ -3384,10 +3384,10 @@ nfsmout: } int -nfsrv_readdirplus(nfsd, slp, procp, mrq) +nfsrv_readdirplus(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -3445,7 +3445,7 @@ nfsrv_readdirplus(nfsd, slp, procp, mrq) error = 0; goto nfsmout; } - error = getret = VOP_GETATTR(vp, &at, cred, procp); + error = getret = VOP_GETATTR(vp, &at, cred, td); #if 0 /* * XXX This check may be too strict for Solaris 2.5 clients. @@ -3455,7 +3455,7 @@ nfsrv_readdirplus(nfsd, slp, procp, mrq) #endif if (!error) { nqsrv_getl(vp, ND_READ); - error = nfsrv_access(vp, VEXEC, cred, rdonly, procp, 0); + error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 0); } if (error) { vput(vp); @@ -3465,7 +3465,7 @@ nfsrv_readdirplus(nfsd, slp, procp, mrq) error = 0; goto nfsmout; } - VOP_UNLOCK(vp, 0, procp); + VOP_UNLOCK(vp, 0, td); MALLOC(rbuf, caddr_t, siz, M_TEMP, M_WAITOK); again: iv.iov_base = rbuf; @@ -3476,17 +3476,17 @@ again: io.uio_resid = fullsiz; io.uio_segflg = UIO_SYSSPACE; io.uio_rw = UIO_READ; - io.uio_procp = (struct proc *)0; + io.uio_td = (struct thread *)0; eofflag = 0; - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, procp); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (cookies) { free((caddr_t)cookies, M_TEMP); cookies = NULL; } error = VOP_READDIR(vp, &io, cred, &eofflag, &ncookies, &cookies); off = (u_quad_t)io.uio_offset; - getret = VOP_GETATTR(vp, &at, cred, procp); - VOP_UNLOCK(vp, 0, procp); + getret = VOP_GETATTR(vp, &at, cred, td); + VOP_UNLOCK(vp, 0, td); if (!cookies && !error) error = NFSERR_PERM; if (!error) @@ -3603,7 +3603,7 @@ again: nvp = NULL; goto invalid; } - if (VOP_GETATTR(nvp, vap, cred, procp)) { + if (VOP_GETATTR(nvp, vap, cred, td)) { vput(nvp); nvp = NULL; goto invalid; @@ -3721,10 +3721,10 @@ nfsmout: * nfs commit service */ int -nfsrv_commit(nfsd, slp, procp, mrq) +nfsrv_commit(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -3778,7 +3778,7 @@ nfsrv_commit(nfsd, slp, procp, mrq) error = 0; goto nfsmout; } - for_ret = VOP_GETATTR(vp, &bfor, cred, procp); + for_ret = VOP_GETATTR(vp, &bfor, cred, td); if (cnt > MAX_COMMIT_COUNT) { /* @@ -3788,7 +3788,7 @@ nfsrv_commit(nfsd, slp, procp, mrq) (vp->v_object->flags & OBJ_MIGHTBEDIRTY)) { vm_object_page_clean(vp->v_object, 0, 0, OBJPC_SYNC); } - error = VOP_FSYNC(vp, cred, MNT_WAIT, procp); + error = VOP_FSYNC(vp, cred, MNT_WAIT, td); } else { /* * Locate and synchronously write any buffers that fall @@ -3846,7 +3846,7 @@ nfsrv_commit(nfsd, slp, procp, mrq) splx(s); } - aft_ret = VOP_GETATTR(vp, &aft, cred, procp); + aft_ret = VOP_GETATTR(vp, &aft, cred, td); vput(vp); vp = NULL; ereply: @@ -3872,10 +3872,10 @@ nfsmout: * nfs statfs service */ int -nfsrv_statfs(nfsd, slp, procp, mrq) +nfsrv_statfs(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -3913,8 +3913,8 @@ nfsrv_statfs(nfsd, slp, procp, mrq) goto nfsmout; } sf = &statfs; - error = VFS_STATFS(vp->v_mount, sf, procp); - getret = VOP_GETATTR(vp, &at, cred, procp); + error = VFS_STATFS(vp->v_mount, sf, td); + getret = VOP_GETATTR(vp, &at, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_STATFS(v3)); @@ -3959,10 +3959,10 @@ nfsmout: * nfs fsinfo service */ int -nfsrv_fsinfo(nfsd, slp, procp, mrq) +nfsrv_fsinfo(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -3999,10 +3999,10 @@ nfsrv_fsinfo(nfsd, slp, procp, mrq) } /* XXX Try to make a guess on the max file size. */ - VFS_STATFS(vp->v_mount, &sb, procp); + VFS_STATFS(vp->v_mount, &sb, td); maxfsize = (u_quad_t)0x80000000 * sb.f_bsize - 1; - getret = VOP_GETATTR(vp, &at, cred, procp); + getret = VOP_GETATTR(vp, &at, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3FSINFO); @@ -4041,10 +4041,10 @@ nfsmout: * nfs pathconf service */ int -nfsrv_pathconf(nfsd, slp, procp, mrq) +nfsrv_pathconf(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -4086,7 +4086,7 @@ nfsrv_pathconf(nfsd, slp, procp, mrq) error = VOP_PATHCONF(vp, _PC_CHOWN_RESTRICTED, &chownres); if (!error) error = VOP_PATHCONF(vp, _PC_NO_TRUNC, ¬runc); - getret = VOP_GETATTR(vp, &at, cred, procp); + getret = VOP_GETATTR(vp, &at, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3PATHCONF); @@ -4120,10 +4120,10 @@ nfsmout: */ /* ARGSUSED */ int -nfsrv_null(nfsd, slp, procp, mrq) +nfsrv_null(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep; @@ -4145,10 +4145,10 @@ nfsrv_null(nfsd, slp, procp, mrq) */ /* ARGSUSED */ int -nfsrv_noop(nfsd, slp, procp, mrq) +nfsrv_noop(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep; @@ -4184,12 +4184,12 @@ nfsrv_noop(nfsd, slp, procp, mrq) * will return EPERM instead of EACCESS. EPERM is always an error. */ static int -nfsrv_access(vp, flags, cred, rdonly, p, override) +nfsrv_access(vp, flags, cred, rdonly, td, override) register struct vnode *vp; int flags; register struct ucred *cred; int rdonly; - struct proc *p; + struct thread *td; int override; { struct vattr vattr; @@ -4220,10 +4220,10 @@ nfsrv_access(vp, flags, cred, rdonly, p, override) if (vp->v_flag & VTEXT) return (ETXTBSY); } - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); - error = VOP_ACCESS(vp, flags, cred, p); + error = VOP_ACCESS(vp, flags, cred, td); /* * Allow certain operations for the owner (reads and writes * on files that are already open). diff --git a/sys/nfs/nfs_socket.c b/sys/nfs/nfs_socket.c index 5772e4b..8991672 100644 --- a/sys/nfs/nfs_socket.c +++ b/sys/nfs/nfs_socket.c @@ -149,7 +149,7 @@ int nfsrtton = 0; struct nfsrtt nfsrtt; struct callout_handle nfs_timer_handle; -static int nfs_msg __P((struct proc *,char *,char *)); +static int nfs_msg __P((struct thread *,char *,char *)); static int nfs_rcvlock __P((struct nfsreq *)); static void nfs_rcvunlock __P((struct nfsreq *)); static void nfs_realign __P((struct mbuf **pm, int hsiz)); @@ -162,7 +162,7 @@ static int nfsrv_getstream __P((struct nfssvc_sock *,int)); int (*nfsrv3_procs[NFS_NPROCS]) __P((struct nfsrv_descript *nd, struct nfssvc_sock *slp, - struct proc *procp, + struct thread *td, struct mbuf **mreqp)) = { nfsrv_null, nfsrv_getattr, @@ -207,12 +207,12 @@ nfs_connect(nmp, rep) int pktscale; struct sockaddr *saddr; struct sockaddr_in *sin; - struct proc *p = &proc0; /* only used for socreate and sobind */ + struct thread *td = thread0; /* only used for socreate and sobind */ nmp->nm_so = (struct socket *)0; saddr = nmp->nm_nam; error = socreate(saddr->sa_family, &nmp->nm_so, nmp->nm_sotype, - nmp->nm_soproto, p); + nmp->nm_soproto, td); if (error) goto bad; so = nmp->nm_so; @@ -233,7 +233,7 @@ nfs_connect(nmp, rep) sopt.sopt_name = IP_PORTRANGE; sopt.sopt_val = (void *)&ip; sopt.sopt_valsize = sizeof(ip); - sopt.sopt_p = NULL; + sopt.sopt_td = NULL; error = sosetopt(so, &sopt); if (error) goto bad; @@ -243,7 +243,7 @@ nfs_connect(nmp, rep) sin->sin_family = AF_INET; sin->sin_addr.s_addr = INADDR_ANY; sin->sin_port = htons(0); - error = sobind(so, (struct sockaddr *)sin, p); + error = sobind(so, (struct sockaddr *)sin, td); if (error) goto bad; bzero(&sopt, sizeof sopt); @@ -253,7 +253,7 @@ nfs_connect(nmp, rep) sopt.sopt_name = IP_PORTRANGE; sopt.sopt_val = (void *)&ip; sopt.sopt_valsize = sizeof(ip); - sopt.sopt_p = NULL; + sopt.sopt_td = NULL; error = sosetopt(so, &sopt); if (error) goto bad; @@ -269,7 +269,7 @@ nfs_connect(nmp, rep) goto bad; } } else { - error = soconnect(so, nmp->nm_nam, p); + error = soconnect(so, nmp->nm_nam, td); if (error) goto bad; @@ -284,7 +284,8 @@ nfs_connect(nmp, rep) "nfscon", 2 * hz); if ((so->so_state & SS_ISCONNECTING) && so->so_error == 0 && rep && - (error = nfs_sigintr(nmp, rep, rep->r_procp)) != 0){ + (error = nfs_sigintr(nmp, rep, + (rep->r_td ? rep->r_td->td_proc : NULL))) != 0){ so->so_state &= ~SS_ISCONNECTING; splx(s); goto bad; @@ -489,7 +490,7 @@ nfs_send(so, nam, top, rep) flags = 0; error = so->so_proto->pr_usrreqs->pru_sosend(so, sendnam, 0, top, 0, - flags, curproc /*XXX*/); + flags, curthread /*XXX*/); /* * ENOBUFS for dgram sockets is transient and non fatal. * No need to log, and no need to break a soft mount. @@ -547,7 +548,7 @@ nfs_receive(rep, aname, mp) u_int32_t len; struct sockaddr **getnam; int error, sotype, rcvflg; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ /* * Set up arguments for soreceive() @@ -614,7 +615,7 @@ tryagain: auio.uio_rw = UIO_READ; auio.uio_offset = 0; auio.uio_resid = sizeof(u_int32_t); - auio.uio_procp = p; + auio.uio_td = td; do { rcvflg = MSG_WAITALL; error = so->so_proto->pr_usrreqs->pru_soreceive @@ -682,7 +683,7 @@ tryagain: * on. */ auio.uio_resid = len = 100000000; /* Anything Big */ - auio.uio_procp = p; + auio.uio_td = td; do { rcvflg = 0; error = so->so_proto->pr_usrreqs->pru_soreceive @@ -727,7 +728,7 @@ errout: else getnam = aname; auio.uio_resid = len = 1000000; - auio.uio_procp = p; + auio.uio_td = td; do { rcvflg = 0; error = so->so_proto->pr_usrreqs->pru_soreceive @@ -937,11 +938,11 @@ nfsmout: * nb: always frees up mreq mbuf list */ int -nfs_request(vp, mrest, procnum, procp, cred, mrp, mdp, dposp) +nfs_request(vp, mrest, procnum, td, cred, mrp, mdp, dposp) struct vnode *vp; struct mbuf *mrest; int procnum; - struct proc *procp; + struct thread *td; struct ucred *cred; struct mbuf **mrp; struct mbuf **mdp; @@ -969,7 +970,7 @@ nfs_request(vp, mrest, procnum, procp, cred, mrp, mdp, dposp) MALLOC(rep, struct nfsreq *, sizeof(struct nfsreq), M_NFSREQ, M_WAITOK); rep->r_nmp = nmp; rep->r_vp = vp; - rep->r_procp = procp; + rep->r_td = td; rep->r_procnum = procnum; i = 0; m = mrest; @@ -1100,7 +1101,7 @@ tryagain: * tprintf a response. */ if (!error && (rep->r_flags & R_TPRINTFMSG)) - nfs_msg(rep->r_procp, nmp->nm_mountp->mnt_stat.f_mntfromname, + nfs_msg(rep->r_td, nmp->nm_mountp->mnt_stat.f_mntfromname, "is alive again"); mrep = rep->r_mrep; md = rep->r_md; @@ -1394,14 +1395,15 @@ nfs_timer(arg) register struct nfssvc_sock *slp; u_quad_t cur_usec; #endif /* NFS_NOSERVER */ - struct proc *p = &proc0; /* XXX for credentials, will break if sleep */ + struct thread *td = thread0; /* XXX for credentials, will break if sleep */ s = splnet(); for (rep = nfs_reqq.tqh_first; rep != 0; rep = rep->r_chain.tqe_next) { nmp = rep->r_nmp; if (rep->r_mrep || (rep->r_flags & R_SOFTTERM)) continue; - if (nfs_sigintr(nmp, rep, rep->r_procp)) { + if (nfs_sigintr(nmp, rep, + (rep->r_td ? rep->r_td->td_proc : NULL))) { nfs_softterm(rep); continue; } @@ -1423,7 +1425,7 @@ nfs_timer(arg) */ if ((rep->r_flags & R_TPRINTFMSG) == 0 && rep->r_rexmit > nmp->nm_deadthresh) { - nfs_msg(rep->r_procp, + nfs_msg(rep->r_td, nmp->nm_mountp->mnt_stat.f_mntfromname, "not responding"); rep->r_flags |= R_TPRINTFMSG; @@ -1455,11 +1457,11 @@ nfs_timer(arg) if ((nmp->nm_flag & NFSMNT_NOCONN) == 0) error = (*so->so_proto->pr_usrreqs->pru_send) (so, 0, m, (struct sockaddr *)0, - (struct mbuf *)0, p); + (struct mbuf *)0, td); else error = (*so->so_proto->pr_usrreqs->pru_send) (so, 0, m, nmp->nm_nam, (struct mbuf *)0, - p); + td); if (error) { if (NFSIGNORE_SOERROR(nmp->nm_soflags, error)) so->so_error = 0; @@ -1566,17 +1568,17 @@ nfs_sndlock(rep) struct nfsreq *rep; { register int *statep = &rep->r_nmp->nm_state; - struct proc *p; + struct thread *td; int slpflag = 0, slptimeo = 0; if (rep) { - p = rep->r_procp; + td = rep->r_td; if (rep->r_nmp->nm_flag & NFSMNT_INT) slpflag = PCATCH; } else - p = (struct proc *)0; + td = (struct thread *)0; while (*statep & NFSSTA_SNDLOCK) { - if (nfs_sigintr(rep->r_nmp, rep, p)) + if (nfs_sigintr(rep->r_nmp, rep, td ? td->td_proc : NULL)) return (EINTR); *statep |= NFSSTA_WANTSND; (void) tsleep((caddr_t)statep, slpflag | (PZERO - 1), @@ -1620,7 +1622,8 @@ nfs_rcvlock(rep) else slpflag = 0; while (*statep & NFSSTA_RCVLOCK) { - if (nfs_sigintr(rep->r_nmp, rep, rep->r_procp)) + if (nfs_sigintr(rep->r_nmp, rep, + (rep->r_td ? rep->r_td->td_proc : NULL))) return (EINTR); *statep |= NFSSTA_WANTRCV; (void) tsleep((caddr_t)statep, slpflag | (PZERO - 1), "nfsrcvlk", @@ -1966,12 +1969,12 @@ nfsmout: #endif static int -nfs_msg(p, server, msg) - struct proc *p; +nfs_msg(td, server, msg) + struct thread *td; char *server, *msg; { - tprintf(p, LOG_INFO, "nfs server %s: %s\n", server, msg); + tprintf(td->td_proc, LOG_INFO, "nfs server %s: %s\n", server, msg); return (0); } @@ -2005,7 +2008,7 @@ nfsrv_rcv(so, arg, waitflag) slp->ns_flag |= SLP_NEEDQ; goto dorecs; } #endif - auio.uio_procp = NULL; + auio.uio_td = NULL; if (so->so_type == SOCK_STREAM) { /* * If there are already records on the queue, defer soreceive() diff --git a/sys/nfs/nfs_subs.c b/sys/nfs/nfs_subs.c index ad8891c..4425129 100644 --- a/sys/nfs/nfs_subs.c +++ b/sys/nfs/nfs_subs.c @@ -554,11 +554,11 @@ extern struct nfsnodehashhead *nfsnodehashtbl; extern u_long nfsnodehash; struct nfssvc_args; -extern int nfssvc(struct proc *, struct nfssvc_args *, int *); +extern int nfssvc(struct thread *, struct nfssvc_args *, int *); LIST_HEAD(nfsnodehashhead, nfsnode); -int nfs_webnamei __P((struct nameidata *, struct vnode *, struct proc *)); +int nfs_webnamei __P((struct nameidata *, struct vnode *, struct thread *)); u_quad_t nfs_curusec() @@ -950,7 +950,7 @@ nfsm_disct(mdp, dposp, siz, left, cp2) { register struct mbuf *mp, *mp2; register int siz2, xfer; - register caddr_t p; + register caddr_t ptr; mp = *mdp; while (left == 0) { @@ -973,10 +973,10 @@ nfsm_disct(mdp, dposp, siz, left, cp2) mp->m_next = mp2; mp->m_len -= left; mp = mp2; - *cp2 = p = mtod(mp, caddr_t); - bcopy(*dposp, p, left); /* Copy what was left */ + *cp2 = ptr = mtod(mp, caddr_t); + bcopy(*dposp, ptr, left); /* Copy what was left */ siz2 = siz-left; - p += left; + ptr += left; mp2 = mp->m_next; /* Loop around copying up the siz2 bytes */ while (siz2 > 0) { @@ -984,10 +984,10 @@ nfsm_disct(mdp, dposp, siz, left, cp2) return (EBADRPC); xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2; if (xfer > 0) { - bcopy(mtod(mp2, caddr_t), p, xfer); + bcopy(mtod(mp2, caddr_t), ptr, xfer); NFSMADV(mp2, xfer); mp2->m_len -= xfer; - p += xfer; + ptr += xfer; siz2 -= xfer; } if (siz2 > 0) @@ -1464,7 +1464,7 @@ nfs_getattrcache(vp, vaper) * released by the caller. */ int -nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) +nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, td, kerbflag, pubflag) register struct nameidata *ndp; fhandle_t *fhp; int len; @@ -1473,7 +1473,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) struct mbuf **mdp; caddr_t *dposp; struct vnode **retdirp; - struct proc *p; + struct thread *td; int kerbflag, pubflag; { register int i, rem; @@ -1613,7 +1613,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) * becuase lookup() will dereference ni_startdir. */ - cnp->cn_proc = p; + cnp->cn_thread = td; VREF(dp); ndp->ni_startdir = dp; @@ -1649,7 +1649,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) * Validate symlink */ if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1) - VOP_UNLOCK(ndp->ni_dvp, 0, p); + VOP_UNLOCK(ndp->ni_dvp, 0, td); if (!pubflag) { error = EINVAL; goto badlink2; @@ -1670,7 +1670,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) auio.uio_offset = 0; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = (struct proc *)0; + auio.uio_td = (struct thread *)0; auio.uio_resid = MAXPATHLEN; error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred); if (error) { @@ -1924,7 +1924,7 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag, pubflag) int kerbflag; int pubflag; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ register struct mount *mp; register int i; struct ucred *credanon; @@ -1988,7 +1988,7 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag, pubflag) nfsrv_object_create(*vpp); if (!lockflag) - VOP_UNLOCK(*vpp, 0, p); + VOP_UNLOCK(*vpp, 0, td); return (0); } @@ -2196,8 +2196,8 @@ nfsrv_object_create(vp) if (vp == NULL || vp->v_type != VREG) return (1); - return (vfs_object_create(vp, curproc, - curproc ? curproc->p_ucred : NULL)); + return (vfs_object_create(vp, curthread, + curthread ? curthread->td_proc->p_ucred : NULL)); } /* diff --git a/sys/nfs/nfs_syscalls.c b/sys/nfs/nfs_syscalls.c index e378cc5..657f299 100644 --- a/sys/nfs/nfs_syscalls.c +++ b/sys/nfs/nfs_syscalls.c @@ -78,7 +78,7 @@ static MALLOC_DEFINE(M_NFSSVC, "NFS srvsock", "Nfs server structure"); /* Global defs. */ extern int32_t (*nfsrv3_procs[NFS_NPROCS]) __P((struct nfsrv_descript *nd, struct nfssvc_sock *slp, - struct proc *procp, + struct thread *td, struct mbuf **mreqp)); extern int nfs_numasync; extern time_t nqnfsstarttime; @@ -92,7 +92,7 @@ static int nuidhash_max = NFS_MAXUIDHASH; #ifndef NFS_NOSERVER static void nfsrv_zapsock __P((struct nfssvc_sock *slp)); #endif -static int nfssvc_iod __P((struct proc *)); +static int nfssvc_iod __P((struct thread *)); #define TRUE 1 #define FALSE 0 @@ -110,8 +110,9 @@ static int modify_flag = 0; static void nfsd_rt __P((int sotype, struct nfsrv_descript *nd, int cacherep)); static int nfssvc_addsock __P((struct file *, struct sockaddr *, - struct proc *)); -static int nfssvc_nfsd __P((struct nfsd_srvargs *,caddr_t,struct proc *)); + struct thread *)); +static int nfssvc_nfsd __P((struct nfsd_srvargs *,caddr_t, + struct thread *)); static int nfs_privport = 0; SYSCTL_INT(_vfs_nfs, NFS_NFSPRIVPORT, nfs_privport, CTLFLAG_RW, &nfs_privport, 0, ""); @@ -140,8 +141,8 @@ struct nfssvc_args { * MPSAFE */ int -nfssvc(p, uap) - struct proc *p; +nfssvc(td, uap) + struct thread *td; register struct nfssvc_args *uap; { #ifndef NFS_NOSERVER @@ -165,13 +166,13 @@ nfssvc(p, uap) error = copyin(uap->argp, &la, sizeof(la)); if (error == 0) - error = nfslockdans(p, &la); + error = nfslockdans(td->td_proc, &la); goto done2; } /* * Must be super user */ - error = suser(p); + error = suser_td(td); if (error) goto done2; while (nfssvc_sockhead_flag & SLP_INIT) { @@ -179,7 +180,7 @@ nfssvc(p, uap) (void) tsleep((caddr_t)&nfssvc_sockhead, PSOCK, "nfsd init", 0); } if (uap->flag & NFSSVC_BIOD) - error = nfssvc_iod(p); + error = nfssvc_iod(td); #ifdef NFS_NOSERVER else error = ENXIO; @@ -189,7 +190,7 @@ nfssvc(p, uap) if (error) goto done2; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - ncd.ncd_dirp, p); + ncd.ncd_dirp, td); error = namei(&nd); if (error) goto done2; @@ -206,13 +207,13 @@ nfssvc(p, uap) goto done2; } nmp->nm_state |= NFSSTA_MNTD; - error = nqnfs_clientd(nmp, p->p_ucred, &ncd, uap->flag, - uap->argp, p); + error = nqnfs_clientd(nmp, td->td_proc->p_ucred, &ncd, uap->flag, + uap->argp, td); } else if (uap->flag & NFSSVC_ADDSOCK) { error = copyin(uap->argp, (caddr_t)&nfsdarg, sizeof(nfsdarg)); if (error) goto done2; - error = holdsock(p->p_fd, nfsdarg.sock, &fp); + error = holdsock(td->td_proc->p_fd, nfsdarg.sock, &fp); if (error) goto done2; /* @@ -224,12 +225,12 @@ nfssvc(p, uap) error = getsockaddr(&nam, nfsdarg.name, nfsdarg.namelen); if (error) { - fdrop(fp, p); + fdrop(fp, td); goto done2; } } - error = nfssvc_addsock(fp, nam, p); - fdrop(fp, p); + error = nfssvc_addsock(fp, nam, td); + fdrop(fp, td); } else { error = copyin(uap->argp, (caddr_t)nsd, sizeof (*nsd)); if (error) @@ -327,7 +328,7 @@ nfssvc(p, uap) } if ((uap->flag & NFSSVC_AUTHINFAIL) && (nfsd = nsd->nsd_nfsd)) nfsd->nfsd_flag |= NFSD_AUTHFAIL; - error = nfssvc_nfsd(nsd, uap->argp, p); + error = nfssvc_nfsd(nsd, uap->argp, td); } #endif /* NFS_NOSERVER */ if (error == EINTR || error == ERESTART) @@ -342,10 +343,10 @@ done2: * Adds a socket to the list for servicing by nfsds. */ static int -nfssvc_addsock(fp, mynam, p) +nfssvc_addsock(fp, mynam, td) struct file *fp; struct sockaddr *mynam; - struct proc *p; + struct thread *td; { register int siz; register struct nfssvc_sock *slp; @@ -439,10 +440,10 @@ nfssvc_addsock(fp, mynam, p) * until it is killed by a signal. */ static int -nfssvc_nfsd(nsd, argp, p) +nfssvc_nfsd(nsd, argp, td) struct nfsd_srvargs *nsd; caddr_t argp; - struct proc *p; + struct thread *td; { register int siz; register struct nfssvc_sock *slp; @@ -461,7 +462,7 @@ nfssvc_nfsd(nsd, argp, p) nsd->nsd_nfsd = nfsd = (struct nfsd *) malloc(sizeof (struct nfsd), M_NFSD, M_WAITOK | M_ZERO); s = splnet(); - nfsd->nfsd_procp = p; + nfsd->nfsd_td = td; TAILQ_INSERT_TAIL(&nfsd_head, nfsd, nfsd_chain); nfs_numnfsd++; } else @@ -622,10 +623,10 @@ nfssvc_nfsd(nsd, argp, p) if (writes_todo || (nd->nd_procnum == NFSPROC_WRITE && procrastinate > 0 && !notstarted)) error = nfsrv_writegather(&nd, slp, - nfsd->nfsd_procp, &mreq); + nfsd->nfsd_td, &mreq); else error = (*(nfsrv3_procs[nd->nd_procnum]))(nd, - slp, nfsd->nfsd_procp, &mreq); + slp, nfsd->nfsd_td, &mreq); if (mreq == NULL) break; if (error != 0 && error != NFSERR_RETVOID) { @@ -757,7 +758,7 @@ nfsrv_zapsock(slp) so->so_upcall = NULL; so->so_upcallarg = NULL; soshutdown(so, 2); - closef(fp, (struct proc *)0); + closef(fp, (struct thread *)0); if (slp->ns_nam) FREE(slp->ns_nam, M_SONAME); m_freem(slp->ns_raw); @@ -935,8 +936,8 @@ SYSCTL_INT(_vfs_nfs, OID_AUTO, defect, CTLFLAG_RW, &nfs_defect, 0, ""); * Never returns unless it fails or gets killed. */ static int -nfssvc_iod(p) - struct proc *p; +nfssvc_iod(td) + struct thread *td; { register struct buf *bp; register int i, myiod; @@ -965,7 +966,7 @@ nfssvc_iod(p) && error == 0) { if (nmp) nmp->nm_bufqiods--; - nfs_iodwant[myiod] = p; + nfs_iodwant[myiod] = td->td_proc; nfs_iodmount[myiod] = NULL; error = tsleep((caddr_t)&nfs_iodwant[myiod], PWAIT | PCATCH, "nfsidl", 0); @@ -988,9 +989,9 @@ nfssvc_iod(p) wakeup(&nmp->nm_bufq); } if (bp->b_iocmd == BIO_READ) - (void) nfs_doio(bp, bp->b_rcred, (struct proc *)0); + (void) nfs_doio(bp, bp->b_rcred, (struct thread *)0); else - (void) nfs_doio(bp, bp->b_wcred, (struct proc *)0); + (void) nfs_doio(bp, bp->b_wcred, (struct thread *)0); /* * If there are more than one iod on this mount, then defect * so that the iods can be shared out fairly between the mounts @@ -1029,7 +1030,7 @@ nfs_getauth(nmp, rep, cred, auth_str, auth_len, verf_str, verf_len, key) nmp->nm_state |= NFSSTA_WANTAUTH; (void) tsleep((caddr_t)&nmp->nm_authtype, PSOCK, "nfsauth1", 2 * hz); - error = nfs_sigintr(nmp, rep, rep->r_procp); + error = nfs_sigintr(nmp, rep, rep->r_td->td_proc); if (error) { nmp->nm_state &= ~NFSSTA_WANTAUTH; return (error); @@ -1049,7 +1050,7 @@ nfs_getauth(nmp, rep, cred, auth_str, auth_len, verf_str, verf_len, key) while ((nmp->nm_state & NFSSTA_HASAUTH) == 0 && error == 0) { (void) tsleep((caddr_t)&nmp->nm_authlen, PSOCK, "nfsauth2", 2 * hz); - error = nfs_sigintr(nmp, rep, rep->r_procp); + error = nfs_sigintr(nmp, rep, rep->r_td->td_proc); } if (nmp->nm_state & NFSSTA_AUTHERR) { nmp->nm_state &= ~NFSSTA_AUTHERR; diff --git a/sys/nfs/nfs_vfsops.c b/sys/nfs/nfs_vfsops.c index bc6f3c0..c70600f 100644 --- a/sys/nfs/nfs_vfsops.c +++ b/sys/nfs/nfs_vfsops.c @@ -101,14 +101,14 @@ static void nfs_decode_args __P((struct nfsmount *nmp, static int mountnfs __P((struct nfs_args *,struct mount *, struct sockaddr *,char *,char *,struct vnode **)); static int nfs_mount __P(( struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p)); + struct nameidata *ndp, struct thread *p)); static int nfs_unmount __P(( struct mount *mp, int mntflags, - struct proc *p)); + struct thread *p)); static int nfs_root __P(( struct mount *mp, struct vnode **vpp)); static int nfs_statfs __P(( struct mount *mp, struct statfs *sbp, - struct proc *p)); + struct thread *p)); static int nfs_sync __P(( struct mount *mp, int waitfor, - struct ucred *cred, struct proc *p)); + struct ucred *cred, struct thread *p)); /* * nfs vfs operations. @@ -161,7 +161,7 @@ SYSCTL_OPAQUE(_vfs_nfs, OID_AUTO, diskless_swapaddr, CTLFLAG_RD, void nfsargs_ntoh __P((struct nfs_args *)); static int nfs_mountdiskless __P((char *, char *, int, struct sockaddr_in *, struct nfs_args *, - struct proc *, struct vnode **, + struct thread *, struct vnode **, struct mount **)); static void nfs_convert_diskless __P((void)); static void nfs_convert_oargs __P((struct nfs_args *args, @@ -241,10 +241,10 @@ nfs_convert_diskless() * nfs statfs call */ int -nfs_statfs(mp, sbp, p) +nfs_statfs(mp, sbp, td) struct mount *mp; register struct statfs *sbp; - struct proc *p; + struct thread *td; { register struct vnode *vp; register struct nfs_statfs *sfp; @@ -266,11 +266,11 @@ nfs_statfs(mp, sbp, p) return (error); vp = NFSTOV(np); if (v3 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) - (void)nfs_fsinfo(nmp, vp, p->p_ucred, p); + (void)nfs_fsinfo(nmp, vp, td->td_proc->p_ucred, td); nfsstats.rpccnt[NFSPROC_FSSTAT]++; nfsm_reqhead(vp, NFSPROC_FSSTAT, NFSX_FH(v3)); nfsm_fhtom(vp, v3); - nfsm_request(vp, NFSPROC_FSSTAT, p, p->p_ucred); + nfsm_request(vp, NFSPROC_FSSTAT, td, td->td_proc->p_ucred); if (v3) nfsm_postop_attr(vp, retattr); if (error) { @@ -315,11 +315,11 @@ nfs_statfs(mp, sbp, p) * nfs version 3 fsinfo rpc call */ int -nfs_fsinfo(nmp, vp, cred, p) +nfs_fsinfo(nmp, vp, cred, td) register struct nfsmount *nmp; register struct vnode *vp; struct ucred *cred; - struct proc *p; + struct thread *td; { register struct nfsv3_fsinfo *fsp; register caddr_t cp; @@ -333,7 +333,7 @@ nfs_fsinfo(nmp, vp, cred, p) nfsstats.rpccnt[NFSPROC_FSINFO]++; nfsm_reqhead(vp, NFSPROC_FSINFO, NFSX_FH(1)); nfsm_fhtom(vp, 1); - nfsm_request(vp, NFSPROC_FSINFO, p, cred); + nfsm_request(vp, NFSPROC_FSINFO, td, cred); nfsm_postop_attr(vp, retattr); if (!error) { nfsm_dissect(fsp, struct nfsv3_fsinfo *, NFSX_V3FSINFO); @@ -394,7 +394,7 @@ nfs_mountroot(mp) struct nfsv3_diskless *nd = &nfsv3_diskless; struct socket *so; struct vnode *vp; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ int error, i; u_long l; char buf[128]; @@ -433,7 +433,7 @@ nfs_mountroot(mp) * Do enough of ifconfig(8) so that the critical net interface can * talk to the server. */ - error = socreate(nd->myif.ifra_addr.sa_family, &so, SOCK_DGRAM, 0, p); + error = socreate(nd->myif.ifra_addr.sa_family, &so, SOCK_DGRAM, 0, td); if (error) panic("nfs_mountroot: socreate(%04x): %d", nd->myif.ifra_addr.sa_family, error); @@ -449,12 +449,12 @@ nfs_mountroot(mp) nd->myif.ifra_name[i] >= '0' && nd->myif.ifra_name[i] <= '9'; nd->myif.ifra_name[i] ++) { - error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, p); + error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td); if(!error) break; } #endif - error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, p); + error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td); if (error) panic("nfs_mountroot: SIOCAIFADDR: %d", error); soclose(so); @@ -488,7 +488,7 @@ nfs_mountroot(mp) (l >> 8) & 0xff, (l >> 0) & 0xff,nd->root_hostnam); printf("NFS ROOT: %s\n",buf); if ((error = nfs_mountdiskless(buf, "/", MNT_RDONLY, - &nd->root_saddr, &nd->root_args, p, &vp, &mp)) != 0) { + &nd->root_saddr, &nd->root_args, td, &vp, &mp)) != 0) { if (swap_mp) { mp->mnt_vfc->vfc_refcount--; free(swap_mp, M_MOUNT); @@ -514,9 +514,9 @@ nfs_mountroot(mp) (l >> 8) & 0xff, (l >> 0) & 0xff,nd->swap_hostnam); printf("NFS SWAP: %s\n",buf); if ((error = nfs_mountdiskless(buf, "/swap", 0, - &nd->swap_saddr, &nd->swap_args, p, &vp, &swap_mp)) != 0) + &nd->swap_saddr, &nd->swap_args, td, &vp, &swap_mp)) != 0) return (error); - vfs_unbusy(swap_mp, p); + vfs_unbusy(swap_mp, td); VTONFS(vp)->n_size = VTONFS(vp)->n_vattr.va_size = nd->swap_nblks * DEV_BSIZE ; @@ -528,13 +528,13 @@ nfs_mountroot(mp) vp->v_type = VREG; vp->v_flag = 0; VREF(vp); - swaponvp(p, vp, NODEV, nd->swap_nblks); + swaponvp(td, vp, NODEV, nd->swap_nblks); } mp->mnt_flag |= MNT_ROOTFS; mp->mnt_vnodecovered = NULLVP; rootvp = vp; - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); /* * This is not really an nfs issue, but it is much easier to @@ -554,13 +554,13 @@ nfs_mountroot(mp) * Internal version of mount system call for diskless setup. */ static int -nfs_mountdiskless(path, which, mountflag, sin, args, p, vpp, mpp) +nfs_mountdiskless(path, which, mountflag, sin, args, td, vpp, mpp) char *path; char *which; int mountflag; struct sockaddr_in *sin; struct nfs_args *args; - struct proc *p; + struct thread *td; struct vnode **vpp; struct mount **mpp; { @@ -581,7 +581,7 @@ nfs_mountdiskless(path, which, mountflag, sin, args, p, vpp, mpp) if ((error = mountnfs(args, mp, nam, which, path, vpp)) != 0) { printf("nfs_mountroot: mount %s on %s: %d", path, which, error); mp->mnt_vfc->vfc_refcount--; - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); free(mp, M_MOUNT); FREE(nam, M_SONAME); return (error); @@ -750,12 +750,12 @@ nfs_decode_args(nmp, argp) */ /* ARGSUSED */ static int -nfs_mount(mp, path, data, ndp, p) +nfs_mount(mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { int error; struct nfs_args args; @@ -930,12 +930,12 @@ mountnfs(argp, mp, nam, pth, hst, vpp) * Get file attributes for the mountpoint. This has the side * effect of filling in (*vpp)->v_type with the correct value. */ - VOP_GETATTR(*vpp, &attrs, curproc->p_ucred, curproc); + VOP_GETATTR(*vpp, &attrs, curthread->td_proc->p_ucred, curthread); /* * Lose the lock but keep the ref. */ - VOP_UNLOCK(*vpp, 0, curproc); + VOP_UNLOCK(*vpp, 0, curthread); return (0); bad: @@ -949,10 +949,10 @@ bad: * unmount system call */ static int -nfs_unmount(mp, mntflags, p) +nfs_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { register struct nfsmount *nmp; int error, flags = 0; @@ -1027,11 +1027,11 @@ extern int syncprt; */ /* ARGSUSED */ static int -nfs_sync(mp, waitfor, cred, p) +nfs_sync(mp, waitfor, cred, td) struct mount *mp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { struct vnode *vp, *vnp; int error, allerror = 0; @@ -1059,11 +1059,11 @@ loop: mtx_lock(&mntvnode_mtx); continue; } - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) { + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) { mtx_lock(&mntvnode_mtx); goto loop; } - error = VOP_FSYNC(vp, cred, waitfor, p); + error = VOP_FSYNC(vp, cred, waitfor, td); if (error) allerror = error; vput(vp); diff --git a/sys/nfs/nfs_vnops.c b/sys/nfs/nfs_vnops.c index 5b84741..8f9ff7d 100644 --- a/sys/nfs/nfs_vnops.c +++ b/sys/nfs/nfs_vnops.c @@ -102,8 +102,8 @@ static int nfsfifo_write __P((struct vop_write_args *)); static int nfsspec_close __P((struct vop_close_args *)); static int nfsfifo_close __P((struct vop_close_args *)); #define nfs_poll vop_nopoll -static int nfs_flush __P((struct vnode *,struct ucred *,int,struct proc *,int)); -static int nfs_setattrrpc __P((struct vnode *,struct vattr *,struct ucred *,struct proc *)); +static int nfs_flush __P((struct vnode *,struct ucred *,int,struct thread *,int)); +static int nfs_setattrrpc __P((struct vnode *,struct vattr *,struct ucred *,struct thread *)); static int nfs_lookup __P((struct vop_lookup_args *)); static int nfs_create __P((struct vop_create_args *)); static int nfs_mknod __P((struct vop_mknod_args *)); @@ -123,7 +123,7 @@ static int nfs_symlink __P((struct vop_symlink_args *)); static int nfs_readdir __P((struct vop_readdir_args *)); static int nfs_strategy __P((struct vop_strategy_args *)); static int nfs_lookitup __P((struct vnode *, const char *, int, - struct ucred *, struct proc *, struct nfsnode **)); + struct ucred *, struct thread *, struct nfsnode **)); static int nfs_sillyrename __P((struct vnode *,struct vnode *,struct componentname *)); static int nfsspec_access __P((struct vop_access_args *)); static int nfs_readlink __P((struct vop_readlink_args *)); @@ -224,11 +224,11 @@ static int nfs_mknodrpc __P((struct vnode *dvp, struct vnode **vpp, struct vattr *vap)); static int nfs_removerpc __P((struct vnode *dvp, const char *name, int namelen, - struct ucred *cred, struct proc *proc)); + struct ucred *cred, struct thread *td)); static int nfs_renamerpc __P((struct vnode *fdvp, const char *fnameptr, int fnamelen, struct vnode *tdvp, const char *tnameptr, int tnamelen, - struct ucred *cred, struct proc *proc)); + struct ucred *cred, struct thread *td)); static int nfs_renameit __P((struct vnode *sdvp, struct componentname *scnp, struct sillyrename *sp)); @@ -268,7 +268,7 @@ SYSCTL_INT(_vfs_nfs, OID_AUTO, access_cache_misses, CTLFLAG_RD, static int nfs3_access_otw(struct vnode *vp, int wmode, - struct proc *p, + struct thread *td, struct ucred *cred) { const int v3 = 1; @@ -287,7 +287,7 @@ nfs3_access_otw(struct vnode *vp, nfsm_fhtom(vp, v3); nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED); *tl = txdr_unsigned(wmode); - nfsm_request(vp, NFSPROC_ACCESS, p, cred); + nfsm_request(vp, NFSPROC_ACCESS, td, cred); nfsm_postop_attr(vp, attrflag); if (!error) { nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED); @@ -312,7 +312,7 @@ nfs_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -383,7 +383,7 @@ nfs_access(ap) * Either a no, or a don't know. Go to the wire. */ nfsstats.accesscache_misses++; - error = nfs3_access_otw(vp, wmode, ap->a_p,ap->a_cred); + error = nfs3_access_otw(vp, wmode, ap->a_td,ap->a_cred); if (!error) { if ((np->n_mode & mode) != mode) { error = EACCES; @@ -416,7 +416,7 @@ nfs_access(ap) auio.uio_resid = 1; auio.uio_segflg = UIO_SYSSPACE; auio.uio_rw = UIO_READ; - auio.uio_procp = ap->a_p; + auio.uio_td = ap->a_td; if (vp->v_type == VREG) error = nfs_readrpc(vp, &auio, ap->a_cred); @@ -450,7 +450,7 @@ nfs_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -472,14 +472,14 @@ nfs_open(ap) if (NQNFS_CKINVALID(vp, np, ND_READ)) { do { error = nqnfs_getlease(vp, ND_READ, ap->a_cred, - ap->a_p); + ap->a_td); } while (error == NQNFS_EXPIRED); if (error) return (error); if (np->n_lrev != np->n_brev || (np->n_flag & NQNFSNONCACHE)) { if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, - ap->a_p, 1)) == EINTR) + ap->a_td, 1)) == EINTR) return (error); np->n_brev = np->n_lrev; } @@ -487,24 +487,24 @@ nfs_open(ap) } else { if (np->n_flag & NMODIFIED) { if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, - ap->a_p, 1)) == EINTR) + ap->a_td, 1)) == EINTR) return (error); np->n_attrstamp = 0; if (vp->v_type == VDIR) np->n_direofoffset = 0; - error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p); + error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_td); if (error) return (error); np->n_mtime = vattr.va_mtime.tv_sec; } else { - error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p); + error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_td); if (error) return (error); if (np->n_mtime != vattr.va_mtime.tv_sec) { if (vp->v_type == VDIR) np->n_direofoffset = 0; if ((error = nfs_vinvalbuf(vp, V_SAVE, - ap->a_cred, ap->a_p, 1)) == EINTR) + ap->a_cred, ap->a_td, 1)) == EINTR) return (error); np->n_mtime = vattr.va_mtime.tv_sec; } @@ -553,7 +553,7 @@ nfs_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -578,10 +578,10 @@ nfs_close(ap) * cannot clear it if we don't commit. */ int cm = nfsv3_commit_on_close ? 1 : 0; - error = nfs_flush(vp, ap->a_cred, MNT_WAIT, ap->a_p, cm); + error = nfs_flush(vp, ap->a_cred, MNT_WAIT, ap->a_td, cm); /* np->n_flag &= ~NMODIFIED; */ } else { - error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_td, 1); } np->n_attrstamp = 0; } @@ -602,7 +602,7 @@ nfs_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -628,7 +628,7 @@ nfs_getattr(ap) if (v3 && nfsaccess_cache_timeout > 0) { nfsstats.accesscache_misses++; - nfs3_access_otw(vp, NFSV3ACCESS_ALL, ap->a_p, ap->a_cred); + nfs3_access_otw(vp, NFSV3ACCESS_ALL, ap->a_td, ap->a_cred); if (nfs_getattrcache(vp, ap->a_vap) == 0) return (0); } @@ -636,7 +636,7 @@ nfs_getattr(ap) nfsstats.rpccnt[NFSPROC_GETATTR]++; nfsm_reqhead(vp, NFSPROC_GETATTR, NFSX_FH(v3)); nfsm_fhtom(vp, v3); - nfsm_request(vp, NFSPROC_GETATTR, ap->a_p, ap->a_cred); + nfsm_request(vp, NFSPROC_GETATTR, ap->a_td, ap->a_cred); if (!error) { nfsm_loadattr(vp, ap->a_vap); } @@ -654,7 +654,7 @@ nfs_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -708,10 +708,10 @@ nfs_setattr(ap) if (np->n_flag & NMODIFIED) { if (vap->va_size == 0) error = nfs_vinvalbuf(vp, 0, - ap->a_cred, ap->a_p, 1); + ap->a_cred, ap->a_td, 1); else error = nfs_vinvalbuf(vp, V_SAVE, - ap->a_cred, ap->a_p, 1); + ap->a_cred, ap->a_td, 1); if (error) { vnode_pager_setsize(vp, np->n_size); return (error); @@ -724,9 +724,9 @@ nfs_setattr(ap) vap->va_atime.tv_sec != VNOVAL) && (np->n_flag & NMODIFIED) && vp->v_type == VREG && (error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, - ap->a_p, 1)) == EINTR) + ap->a_td, 1)) == EINTR) return (error); - error = nfs_setattrrpc(vp, vap, ap->a_cred, ap->a_p); + error = nfs_setattrrpc(vp, vap, ap->a_cred, ap->a_td); if (error && vap->va_size != VNOVAL) { np->n_size = np->n_vattr.va_size = tsize; vnode_pager_setsize(vp, np->n_size); @@ -738,11 +738,11 @@ nfs_setattr(ap) * Do an nfs setattr rpc. */ static int -nfs_setattrrpc(vp, vap, cred, procp) +nfs_setattrrpc(vp, vap, cred, td) register struct vnode *vp; register struct vattr *vap; struct ucred *cred; - struct proc *procp; + struct thread *td; { register struct nfsv2_sattr *sp; register caddr_t cp; @@ -778,7 +778,7 @@ nfs_setattrrpc(vp, vap, cred, procp) txdr_nfsv2time(&vap->va_atime, &sp->sa_atime); txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime); } - nfsm_request(vp, NFSPROC_SETATTR, procp, cred); + nfsm_request(vp, NFSPROC_SETATTR, td, cred); if (v3) { nfsm_wcc_data(vp, wccflag); } else @@ -817,7 +817,7 @@ nfs_lookup(ap) struct nfsnode *np; int lockparent, wantparent, error = 0, attrflag, fhsize; int v3 = NFS_ISV3(dvp); - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; *vpp = NULLVP; cnp->cn_flags &= ~PDIRUNLOCK; @@ -834,7 +834,7 @@ nfs_lookup(ap) struct vattr vattr; int vpid; - if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, p)) != 0) { + if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, td)) != 0) { *vpp = NULLVP; return (error); } @@ -849,24 +849,24 @@ nfs_lookup(ap) VREF(newvp); error = 0; } else if (flags & ISDOTDOT) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); cnp->cn_flags |= PDIRUNLOCK; - error = vget(newvp, LK_EXCLUSIVE, p); + error = vget(newvp, LK_EXCLUSIVE, td); if (!error && lockparent && (flags & ISLASTCN)) { - error = vn_lock(dvp, LK_EXCLUSIVE, p); + error = vn_lock(dvp, LK_EXCLUSIVE, td); if (error == 0) cnp->cn_flags &= ~PDIRUNLOCK; } } else { - error = vget(newvp, LK_EXCLUSIVE, p); + error = vget(newvp, LK_EXCLUSIVE, td); if (!lockparent || error || !(flags & ISLASTCN)) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } } if (!error) { if (vpid == newvp->v_id) { - if (!VOP_GETATTR(newvp, &vattr, cnp->cn_cred, p) + if (!VOP_GETATTR(newvp, &vattr, cnp->cn_cred, td) && vattr.va_ctime.tv_sec == VTONFS(newvp)->n_ctime) { nfsstats.lookupcache_hits++; if (cnp->cn_nameiop != LOOKUP && @@ -878,9 +878,9 @@ nfs_lookup(ap) } vput(newvp); if (lockparent && dvp != newvp && (flags & ISLASTCN)) - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); } - error = vn_lock(dvp, LK_EXCLUSIVE, p); + error = vn_lock(dvp, LK_EXCLUSIVE, td); *vpp = NULLVP; if (error) { cnp->cn_flags |= PDIRUNLOCK; @@ -897,7 +897,7 @@ nfs_lookup(ap) NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len)); nfsm_fhtom(dvp, v3); nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN); - nfsm_request(dvp, NFSPROC_LOOKUP, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_LOOKUP, cnp->cn_thread, cnp->cn_cred); if (error) { nfsm_postop_attr(dvp, attrflag); m_freem(mrep); @@ -928,22 +928,22 @@ nfs_lookup(ap) m_freem(mrep); cnp->cn_flags |= SAVENAME; if (!lockparent) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } return (0); } if (flags & ISDOTDOT) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); error = nfs_nget(dvp->v_mount, fhp, fhsize, &np); if (error) { - vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td); return (error); } newvp = NFSTOV(np); if (lockparent && (flags & ISLASTCN)) { - error = vn_lock(dvp, LK_EXCLUSIVE, p); + error = vn_lock(dvp, LK_EXCLUSIVE, td); if (error) { cnp->cn_flags |= PDIRUNLOCK; vput(newvp); @@ -962,7 +962,7 @@ nfs_lookup(ap) } if (!lockparent || !(flags & ISLASTCN)) { cnp->cn_flags |= PDIRUNLOCK; - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); } newvp = NFSTOV(np); } @@ -988,7 +988,7 @@ nfs_lookup(ap) if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) && (flags & ISLASTCN) && error == ENOENT) { if (!lockparent) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } if (dvp->v_mount->mnt_flag & MNT_RDONLY) @@ -1061,7 +1061,7 @@ nfs_readlinkrpc(vp, uiop, cred) nfsstats.rpccnt[NFSPROC_READLINK]++; nfsm_reqhead(vp, NFSPROC_READLINK, NFSX_FH(v3)); nfsm_fhtom(vp, v3); - nfsm_request(vp, NFSPROC_READLINK, uiop->uio_procp, cred); + nfsm_request(vp, NFSPROC_READLINK, uiop->uio_td, cred); if (v3) nfsm_postop_attr(vp, attrflag); if (!error) { @@ -1117,7 +1117,7 @@ nfs_readrpc(vp, uiop, cred) *tl++ = txdr_unsigned(len); *tl = 0; } - nfsm_request(vp, NFSPROC_READ, uiop->uio_procp, cred); + nfsm_request(vp, NFSPROC_READ, uiop->uio_td, cred); if (v3) { nfsm_postop_attr(vp, attrflag); if (error) { @@ -1195,7 +1195,7 @@ nfs_writerpc(vp, uiop, cred, iomode, must_commit) *tl = x; /* size of this write */ } nfsm_uiotom(uiop, len); - nfsm_request(vp, NFSPROC_WRITE, uiop->uio_procp, cred); + nfsm_request(vp, NFSPROC_WRITE, uiop->uio_td, cred); if (v3) { wccflag = NFSV3_WCCCHK; nfsm_wcc_data(vp, wccflag); @@ -1288,7 +1288,7 @@ nfs_mknodrpc(dvp, vpp, cnp, vap) else { return (EOPNOTSUPP); } - if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc)) != 0) { + if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_thread)) != 0) { return (error); } nfsstats.rpccnt[NFSPROC_MKNOD]++; @@ -1314,7 +1314,7 @@ nfs_mknodrpc(dvp, vpp, cnp, vap) txdr_nfsv2time(&vap->va_atime, &sp->sa_atime); txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime); } - nfsm_request(dvp, NFSPROC_MKNOD, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_MKNOD, cnp->cn_thread, cnp->cn_cred); if (!error) { nfsm_mtofh(dvp, newvp, v3, gotvp); if (!gotvp) { @@ -1323,7 +1323,7 @@ nfs_mknodrpc(dvp, vpp, cnp, vap) newvp = (struct vnode *)0; } error = nfs_lookitup(dvp, cnp->cn_nameptr, - cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc, &np); + cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np); if (!error) newvp = NFSTOV(np); } @@ -1396,7 +1396,7 @@ nfs_create(ap) if (vap->va_type == VSOCK) return (nfs_mknodrpc(dvp, ap->a_vpp, cnp, vap)); - if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc)) != 0) { + if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_thread)) != 0) { return (error); } if (vap->va_vaflags & VA_EXCLUSIVE) @@ -1432,7 +1432,7 @@ again: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime); txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime); } - nfsm_request(dvp, NFSPROC_CREATE, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_CREATE, cnp->cn_thread, cnp->cn_cred); if (!error) { nfsm_mtofh(dvp, newvp, v3, gotvp); if (!gotvp) { @@ -1441,7 +1441,7 @@ again: newvp = (struct vnode *)0; } error = nfs_lookitup(dvp, cnp->cn_nameptr, - cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc, &np); + cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np); if (!error) newvp = NFSTOV(np); } @@ -1469,7 +1469,7 @@ again: vfs_timestamp(&vap->va_mtime); if (vap->va_atime.tv_sec == VNOVAL) vap->va_atime = vap->va_mtime; - error = nfs_setattrrpc(newvp, vap, cnp->cn_cred, cnp->cn_proc); + error = nfs_setattrrpc(newvp, vap, cnp->cn_cred, cnp->cn_thread); } if (!error) { if (cnp->cn_flags & MAKEENTRY) @@ -1518,7 +1518,7 @@ nfs_remove(ap) if (vp->v_type == VDIR) error = EPERM; else if (vp->v_usecount == 1 || (np->n_sillyrename && - VOP_GETATTR(vp, &vattr, cnp->cn_cred, cnp->cn_proc) == 0 && + VOP_GETATTR(vp, &vattr, cnp->cn_cred, cnp->cn_thread) == 0 && vattr.va_nlink > 1)) { /* * Purge the name cache so that the chance of a lookup for @@ -1532,11 +1532,11 @@ nfs_remove(ap) * throw away biocache buffers, mainly to avoid * unnecessary delayed writes later. */ - error = nfs_vinvalbuf(vp, 0, cnp->cn_cred, cnp->cn_proc, 1); + error = nfs_vinvalbuf(vp, 0, cnp->cn_cred, cnp->cn_thread, 1); /* Do the rpc */ if (error != EINTR) error = nfs_removerpc(dvp, cnp->cn_nameptr, - cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc); + cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread); /* * Kludge City: If the first reply to the remove rpc is lost.. * the reply to the retransmitted request will be ENOENT @@ -1560,19 +1560,19 @@ nfs_removeit(sp) { return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred, - (struct proc *)0)); + (struct thread *)0)); } /* * Nfs remove rpc, called from nfs_remove() and nfs_removeit(). */ static int -nfs_removerpc(dvp, name, namelen, cred, proc) +nfs_removerpc(dvp, name, namelen, cred, td) register struct vnode *dvp; const char *name; int namelen; struct ucred *cred; - struct proc *proc; + struct thread *td; { register u_int32_t *tl; register caddr_t cp; @@ -1587,7 +1587,7 @@ nfs_removerpc(dvp, name, namelen, cred, proc) NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(namelen)); nfsm_fhtom(dvp, v3); nfsm_strtom(name, namelen, NFS_MAXNAMLEN); - nfsm_request(dvp, NFSPROC_REMOVE, proc, cred); + nfsm_request(dvp, NFSPROC_REMOVE, td, cred); if (v3) nfsm_wcc_data(dvp, wccflag); nfsm_reqdone; @@ -1640,9 +1640,9 @@ nfs_rename(ap) * often. */ - VOP_FSYNC(fvp, fcnp->cn_cred, MNT_WAIT, fcnp->cn_proc); + VOP_FSYNC(fvp, fcnp->cn_cred, MNT_WAIT, fcnp->cn_thread); if (tvp) - VOP_FSYNC(tvp, tcnp->cn_cred, MNT_WAIT, tcnp->cn_proc); + VOP_FSYNC(tvp, tcnp->cn_cred, MNT_WAIT, tcnp->cn_thread); /* * If the tvp exists and is in use, sillyrename it before doing the @@ -1657,7 +1657,7 @@ nfs_rename(ap) error = nfs_renamerpc(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen, tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, tcnp->cn_cred, - tcnp->cn_proc); + tcnp->cn_thread); if (fvp->v_type == VDIR) { if (tvp != NULL && tvp->v_type == VDIR) @@ -1692,14 +1692,14 @@ nfs_renameit(sdvp, scnp, sp) register struct sillyrename *sp; { return (nfs_renamerpc(sdvp, scnp->cn_nameptr, scnp->cn_namelen, - sdvp, sp->s_name, sp->s_namlen, scnp->cn_cred, scnp->cn_proc)); + sdvp, sp->s_name, sp->s_namlen, scnp->cn_cred, scnp->cn_thread)); } /* * Do an nfs rename rpc. Called from nfs_rename() and nfs_renameit(). */ static int -nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, proc) +nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, td) register struct vnode *fdvp; const char *fnameptr; int fnamelen; @@ -1707,7 +1707,7 @@ nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, proc) const char *tnameptr; int tnamelen; struct ucred *cred; - struct proc *proc; + struct thread *td; { register u_int32_t *tl; register caddr_t cp; @@ -1725,7 +1725,7 @@ nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, proc) nfsm_strtom(fnameptr, fnamelen, NFS_MAXNAMLEN); nfsm_fhtom(tdvp, v3); nfsm_strtom(tnameptr, tnamelen, NFS_MAXNAMLEN); - nfsm_request(fdvp, NFSPROC_RENAME, proc, cred); + nfsm_request(fdvp, NFSPROC_RENAME, td, cred); if (v3) { nfsm_wcc_data(fdvp, fwccflag); nfsm_wcc_data(tdvp, twccflag); @@ -1771,7 +1771,7 @@ nfs_link(ap) * doesn't get "out of sync" with the server. * XXX There should be a better way! */ - VOP_FSYNC(vp, cnp->cn_cred, MNT_WAIT, cnp->cn_proc); + VOP_FSYNC(vp, cnp->cn_cred, MNT_WAIT, cnp->cn_thread); v3 = NFS_ISV3(vp); nfsstats.rpccnt[NFSPROC_LINK]++; @@ -1780,7 +1780,7 @@ nfs_link(ap) nfsm_fhtom(vp, v3); nfsm_fhtom(tdvp, v3); nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN); - nfsm_request(vp, NFSPROC_LINK, cnp->cn_proc, cnp->cn_cred); + nfsm_request(vp, NFSPROC_LINK, cnp->cn_thread, cnp->cn_cred); if (v3) { nfsm_postop_attr(vp, attrflag); nfsm_wcc_data(tdvp, wccflag); @@ -1852,7 +1852,7 @@ nfs_symlink(ap) * a file handle that can be converted into newvp without having * to do an extra lookup rpc. */ - nfsm_request(dvp, NFSPROC_SYMLINK, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_SYMLINK, cnp->cn_thread, cnp->cn_cred); if (v3) { if (error == 0) nfsm_mtofh(dvp, newvp, v3, gotvp); @@ -1882,7 +1882,7 @@ nfs_symlink(ap) struct nfsnode *np = NULL; error = nfs_lookitup(dvp, cnp->cn_nameptr, cnp->cn_namelen, - cnp->cn_cred, cnp->cn_proc, &np); + cnp->cn_cred, cnp->cn_thread, &np); if (!error) newvp = NFSTOV(np); } @@ -1927,7 +1927,7 @@ nfs_mkdir(ap) struct vattr vattr; int v3 = NFS_ISV3(dvp); - if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc)) != 0) { + if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_thread)) != 0) { return (error); } len = cnp->cn_namelen; @@ -1947,7 +1947,7 @@ nfs_mkdir(ap) txdr_nfsv2time(&vap->va_atime, &sp->sa_atime); txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime); } - nfsm_request(dvp, NFSPROC_MKDIR, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_MKDIR, cnp->cn_thread, cnp->cn_cred); if (!error) nfsm_mtofh(dvp, newvp, v3, gotvp); if (v3) @@ -1966,7 +1966,7 @@ nfs_mkdir(ap) newvp = (struct vnode *)0; } error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred, - cnp->cn_proc, &np); + cnp->cn_thread, &np); if (!error) { newvp = NFSTOV(np); if (newvp->v_type != VDIR) @@ -2010,7 +2010,7 @@ nfs_rmdir(ap) NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen)); nfsm_fhtom(dvp, v3); nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN); - nfsm_request(dvp, NFSPROC_RMDIR, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_RMDIR, cnp->cn_thread, cnp->cn_cred); if (v3) nfsm_wcc_data(dvp, wccflag); nfsm_reqdone; @@ -2056,7 +2056,7 @@ nfs_readdir(ap) nfsstats.direofcache_hits++; return (0); } - } else if (VOP_GETATTR(vp, &vattr, ap->a_cred, uio->uio_procp) == 0 && + } else if (VOP_GETATTR(vp, &vattr, ap->a_cred, uio->uio_td) == 0 && np->n_mtime == vattr.va_mtime.tv_sec) { nfsstats.direofcache_hits++; return (0); @@ -2136,7 +2136,7 @@ nfs_readdirrpc(vp, uiop, cred) *tl++ = cookie.nfsuquad[0]; } *tl = txdr_unsigned(nmp->nm_readdirsize); - nfsm_request(vp, NFSPROC_READDIR, uiop->uio_procp, cred); + nfsm_request(vp, NFSPROC_READDIR, uiop->uio_td, cred); if (v3) { nfsm_postop_attr(vp, attrflag); if (!error) { @@ -2326,7 +2326,7 @@ nfs_readdirplusrpc(vp, uiop, cred) *tl++ = dnp->n_cookieverf.nfsuquad[1]; *tl++ = txdr_unsigned(nmp->nm_readdirsize); *tl = txdr_unsigned(nmp->nm_rsize); - nfsm_request(vp, NFSPROC_READDIRPLUS, uiop->uio_procp, cred); + nfsm_request(vp, NFSPROC_READDIRPLUS, uiop->uio_td, cred); nfsm_postop_attr(vp, attrflag); if (error) { m_freem(mrep); @@ -2525,12 +2525,12 @@ nfs_sillyrename(dvp, vp, cnp) VREF(dvp); /* Fudge together a funny name */ - pid = cnp->cn_proc->p_pid; + pid = cnp->cn_thread->td_proc->p_pid; sp->s_namlen = sprintf(sp->s_name, ".nfsA%04x4.4", pid); /* Try lookitups until we get one that isn't there */ while (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred, - cnp->cn_proc, (struct nfsnode **)0) == 0) { + cnp->cn_thread, (struct nfsnode **)0) == 0) { sp->s_name[4]++; if (sp->s_name[4] > 'z') { error = EINVAL; @@ -2541,7 +2541,7 @@ nfs_sillyrename(dvp, vp, cnp) if (error) goto bad; error = nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred, - cnp->cn_proc, &np); + cnp->cn_thread, &np); np->n_sillyrename = sp; return (0); bad: @@ -2560,12 +2560,12 @@ bad: * *npp != NULL --> update the file handle in the vnode */ static int -nfs_lookitup(dvp, name, len, cred, procp, npp) +nfs_lookitup(dvp, name, len, cred, td, npp) register struct vnode *dvp; const char *name; int len; struct ucred *cred; - struct proc *procp; + struct thread *td; struct nfsnode **npp; { register u_int32_t *tl; @@ -2584,7 +2584,7 @@ nfs_lookitup(dvp, name, len, cred, procp, npp) NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len)); nfsm_fhtom(dvp, v3); nfsm_strtom(name, len, NFS_MAXNAMLEN); - nfsm_request(dvp, NFSPROC_LOOKUP, procp, cred); + nfsm_request(dvp, NFSPROC_LOOKUP, td, cred); if (npp && !error) { nfsm_getfh(nfhp, fhlen, v3); if (*npp) { @@ -2640,12 +2640,12 @@ nfs_lookitup(dvp, name, len, cred, procp, npp) * Nfs Version 3 commit rpc */ int -nfs_commit(vp, offset, cnt, cred, procp) +nfs_commit(vp, offset, cnt, cred, td) struct vnode *vp; u_quad_t offset; int cnt; struct ucred *cred; - struct proc *procp; + struct thread *td; { register caddr_t cp; register u_int32_t *tl; @@ -2664,7 +2664,7 @@ nfs_commit(vp, offset, cnt, cred, procp) txdr_hyper(offset, tl); tl += 2; *tl = txdr_unsigned(cnt); - nfsm_request(vp, NFSPROC_COMMIT, procp, cred); + nfsm_request(vp, NFSPROC_COMMIT, td, cred); nfsm_wcc_data(vp, wccflag); if (!error) { nfsm_dissect(tl, u_int32_t *, NFSX_V3WRITEVERF); @@ -2691,7 +2691,7 @@ nfs_strategy(ap) { register struct buf *bp = ap->a_bp; struct ucred *cr; - struct proc *p; + struct thread *td; int error = 0; KASSERT(!(bp->b_flags & B_DONE), ("nfs_strategy: buffer %p unexpectedly marked B_DONE", bp)); @@ -2701,9 +2701,9 @@ nfs_strategy(ap) panic("nfs physio"); if (bp->b_flags & B_ASYNC) - p = (struct proc *)0; + td = (struct thread *)0; else - p = curproc; /* XXX */ + td = curthread; /* XXX */ if (bp->b_iocmd == BIO_READ) cr = bp->b_rcred; @@ -2716,8 +2716,8 @@ nfs_strategy(ap) * otherwise just do it ourselves. */ if ((bp->b_flags & B_ASYNC) == 0 || - nfs_asyncio(bp, NOCRED, p)) - error = nfs_doio(bp, cr, p); + nfs_asyncio(bp, NOCRED, td)) + error = nfs_doio(bp, cr, td); return (error); } @@ -2732,11 +2732,11 @@ nfs_fsync(ap) struct vnode * a_vp; struct ucred * a_cred; int a_waitfor; - struct proc * a_p; + struct thread * a_td; } */ *ap; { - return (nfs_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_p, 1)); + return (nfs_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_td, 1)); } /* @@ -2745,11 +2745,11 @@ nfs_fsync(ap) * associated with the vnode. */ static int -nfs_flush(vp, cred, waitfor, p, commit) +nfs_flush(vp, cred, waitfor, td, commit) register struct vnode *vp; struct ucred *cred; int waitfor; - struct proc *p; + struct thread *td; int commit; { register struct nfsnode *np = VTONFS(vp); @@ -2878,7 +2878,7 @@ again: */ if (wcred != NOCRED) retv = nfs_commit(vp, off, (int)(endoff - off), - wcred, p); + wcred, td); else { retv = 0; for (i = 0; i < bvecpos; i++) { @@ -2889,7 +2889,7 @@ again: size = (u_quad_t)(bp->b_dirtyend - bp->b_dirtyoff); retv = nfs_commit(vp, off, (int)size, - bp->b_wcred, p); + bp->b_wcred, td); if (retv) break; } } @@ -2949,7 +2949,7 @@ loop: panic("nfs_fsync: inconsistent lock"); if (error == ENOLCK) goto loop; - if (nfs_sigintr(nmp, (struct nfsreq *)0, p)) { + if (nfs_sigintr(nmp, (struct nfsreq *)0, td->td_proc)) { error = EINTR; goto done; } @@ -2985,7 +2985,7 @@ loop: error = tsleep((caddr_t)&vp->v_numoutput, slpflag | (PRIBIO + 1), "nfsfsync", slptimeo); if (error) { - if (nfs_sigintr(nmp, (struct nfsreq *)0, p)) { + if (nfs_sigintr(nmp, (struct nfsreq *)0, td->td_proc)) { error = EINTR; goto done; } @@ -3053,10 +3053,10 @@ nfs_print(ap) * We set B_CACHE if this is a VMIO buffer. */ int -nfs_writebp(bp, force, procp) +nfs_writebp(bp, force, td) register struct buf *bp; int force; - struct proc *procp; + struct thread *td; { int s; int oldflags = bp->b_flags; @@ -3086,7 +3086,7 @@ nfs_writebp(bp, force, procp) bp->b_iocmd = BIO_WRITE; bp->b_vp->v_numoutput++; - curproc->p_stats->p_ru.ru_oublock++; + curthread->td_proc->p_stats->p_ru.ru_oublock++; splx(s); /* @@ -3127,7 +3127,7 @@ nfsspec_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vattr *vap; @@ -3161,7 +3161,7 @@ nfsspec_access(ap) if (cred->cr_uid == 0) return (0); vap = &vattr; - error = VOP_GETATTR(vp, vap, cred, ap->a_p); + error = VOP_GETATTR(vp, vap, cred, ap->a_td); if (error) return (error); /* @@ -3238,7 +3238,7 @@ nfsspec_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -3254,7 +3254,7 @@ nfsspec_close(ap) vattr.va_atime = np->n_atim; if (np->n_flag & NUPD) vattr.va_mtime = np->n_mtim; - (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p); + (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_td); } } return (VOCALL(spec_vnodeop_p, VOFFSET(vop_close), ap)); @@ -3315,7 +3315,7 @@ nfsfifo_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -3337,7 +3337,7 @@ nfsfifo_close(ap) vattr.va_atime = np->n_atim; if (np->n_flag & NUPD) vattr.va_mtime = np->n_mtim; - (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p); + (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_td); } } return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_close), ap)); diff --git a/sys/nfs/nfsnode.h b/sys/nfs/nfsnode.h index 968f39c..ba99fea 100644 --- a/sys/nfs/nfsnode.h +++ b/sys/nfs/nfsnode.h @@ -171,16 +171,16 @@ extern struct nfsmount *nfs_iodmount[NFS_MAXASYNCDAEMON]; static __inline int -nfs_rslock(struct nfsnode *np, struct proc *p) +nfs_rslock(struct nfsnode *np, struct thread *td) { - return(lockmgr(&np->n_rslock, LK_EXCLUSIVE | LK_CANRECURSE | LK_SLEEPFAIL, NULL, p)); + return(lockmgr(&np->n_rslock, LK_EXCLUSIVE | LK_CANRECURSE | LK_SLEEPFAIL, NULL, td)); } static __inline void -nfs_rsunlock(struct nfsnode *np, struct proc *p) +nfs_rsunlock(struct nfsnode *np, struct thread *td) { - (void)lockmgr(&np->n_rslock, LK_RELEASE, NULL, p); + (void)lockmgr(&np->n_rslock, LK_RELEASE, NULL, td); } extern vop_t **fifo_nfsv2nodeop_p; diff --git a/sys/nfs/nqnfs.h b/sys/nfs/nqnfs.h index 94a8e27..ce8d692 100644 --- a/sys/nfs/nqnfs.h +++ b/sys/nfs/nqnfs.h @@ -146,7 +146,7 @@ struct nqm { (void) nqsrv_getlease((v), &nfsd->nd_duration, \ ((nfsd->nd_flag & ND_LEASE) ? (nfsd->nd_flag & ND_LEASE) : \ ((l) | ND_CHECK)), \ - slp, procp, nfsd->nd_nam, &cache, &frev, cred) + slp, td, nfsd->nd_nam, &cache, &frev, cred) /* * Client side macros that check for a valid lease. @@ -189,20 +189,20 @@ extern u_long nqfhhash; #define NQNFS_EXPIRED 500 #define NQNFS_TRYLATER 501 -void nqnfs_lease_check __P((struct vnode *, struct proc *, struct ucred *, int)); +void nqnfs_lease_check __P((struct vnode *, struct thread *, struct ucred *, int)); void nqnfs_lease_updatetime __P((int)); int nqsrv_getlease __P((struct vnode *, u_int32_t *, int, - struct nfssvc_sock *, struct proc *, + struct nfssvc_sock *, struct thread *, struct sockaddr *, int *, u_quad_t *, struct ucred *)); -int nqnfs_getlease __P((struct vnode *,int,struct ucred *,struct proc *)); +int nqnfs_getlease __P((struct vnode *,int,struct ucred *,struct thread *)); int nqnfs_callback __P((struct nfsmount *,struct mbuf *,struct mbuf *,caddr_t)); -int nqnfs_clientd __P((struct nfsmount *,struct ucred *,struct nfsd_cargs *,int,caddr_t,struct proc *)); +int nqnfs_clientd __P((struct nfsmount *,struct ucred *,struct nfsd_cargs *,int,caddr_t,struct thread *)); struct nfsnode; void nqnfs_clientlease __P((struct nfsmount *, struct nfsnode *, int, int, time_t, u_quad_t)); void nqnfs_serverd __P((void)); -int nqnfsrv_getlease __P((struct nfsrv_descript *, struct nfssvc_sock *, struct proc *, struct mbuf **)); -int nqnfsrv_vacated __P((struct nfsrv_descript *, struct nfssvc_sock *, struct proc *, struct mbuf **)); +int nqnfsrv_getlease __P((struct nfsrv_descript *, struct nfssvc_sock *, struct thread *, struct mbuf **)); +int nqnfsrv_vacated __P((struct nfsrv_descript *, struct nfssvc_sock *, struct thread *, struct mbuf **)); #endif #endif diff --git a/sys/nfsclient/bootp_subr.c b/sys/nfsclient/bootp_subr.c index 72fc393..063f77f 100644 --- a/sys/nfsclient/bootp_subr.c +++ b/sys/nfsclient/bootp_subr.c @@ -213,11 +213,11 @@ extern struct nfsv3_diskless nfsv3_diskless; /* mountd RPC */ static int md_mount(struct sockaddr_in *mdsin, char *path, u_char *fhp, int *fhsizep, - struct nfs_args *args,struct proc *procp); + struct nfs_args *args,struct thread *td); static int md_lookup_swap(struct sockaddr_in *mdsin,char *path, u_char *fhp, int *fhsizep, struct nfs_args *args, - struct proc *procp); + struct thread *td); static int setfs(struct sockaddr_in *addr, char *path, char *p); static int getdec(char **ptr); static char *substr(char *a,char *b); @@ -231,7 +231,7 @@ static struct bootpc_ifcontext *allocifctx(struct bootpc_globalcontext *gctx); static void bootpc_compose_query(struct bootpc_ifcontext *ifctx, struct bootpc_globalcontext *gctx, - struct proc *procp); + struct thread *td); static unsigned char *bootpc_tag(struct bootpc_tagcontext *tctx, struct bootp_packet *bp, int len, int tag); static void bootpc_tag_helper(struct bootpc_tagcontext *tctx, @@ -248,15 +248,15 @@ void bootpboot_p_iflist(void); #endif static int bootpc_call(struct bootpc_globalcontext *gctx, - struct proc *procp); + struct thread *td); static int bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, struct bootpc_globalcontext *gctx, - struct proc *procp); + struct thread *td); static int bootpc_adjust_interface(struct bootpc_ifcontext *ifctx, struct bootpc_globalcontext *gctx, - struct proc *procp); + struct thread *td); static void bootpc_decode_reply(struct nfsv3_diskless *nd, struct bootpc_ifcontext *ifctx, @@ -581,7 +581,7 @@ bootpc_received(struct bootpc_globalcontext *gctx, static int bootpc_call(struct bootpc_globalcontext *gctx, - struct proc *procp) + struct thread *td) { struct socket *so; struct sockaddr_in *sin, dst; @@ -601,7 +601,7 @@ bootpc_call(struct bootpc_globalcontext *gctx, /* * Create socket and set its recieve timeout. */ - error = socreate(AF_INET, &so, SOCK_DGRAM, 0, procp); + error = socreate(AF_INET, &so, SOCK_DGRAM, 0, td); if (error != 0) goto out; @@ -648,7 +648,7 @@ bootpc_call(struct bootpc_globalcontext *gctx, sin = &dst; clear_sinaddr(sin); sin->sin_port = htons(IPPORT_BOOTPC); - error = sobind(so, (struct sockaddr *)sin, procp); + error = sobind(so, (struct sockaddr *)sin, td); if (error != 0) { printf("bind failed\n"); goto out; @@ -706,7 +706,7 @@ bootpc_call(struct bootpc_globalcontext *gctx, (ifctx->state == IF_BOOTP_UNRESOLVED && ifctx->dhcpquerytype != DHCP_NOMSG)) { ifctx->sentmsg = 0; - bootpc_compose_query(ifctx, gctx, procp); + bootpc_compose_query(ifctx, gctx, td); } /* Send BOOTP request (or re-send). */ @@ -743,21 +743,21 @@ bootpc_call(struct bootpc_globalcontext *gctx, auio.uio_rw = UIO_WRITE; auio.uio_offset = 0; auio.uio_resid = sizeof(ifctx->call); - auio.uio_procp = procp; + auio.uio_td = td; /* Set netmask to 0.0.0.0 */ sin = (struct sockaddr_in *) &ifctx->ireq.ifr_addr; clear_sinaddr(sin); error = ifioctl(ifctx->so, SIOCSIFNETMASK, - (caddr_t) &ifctx->ireq, procp); + (caddr_t) &ifctx->ireq, td); if (error != 0) panic("bootpc_call:" "set if netmask, error=%d", error); error = sosend(so, (struct sockaddr *) &dst, - &auio, NULL, NULL, 0, procp); + &auio, NULL, NULL, 0, td); if (error != 0) { printf("bootpc_call: sosend: %d state %08x\n", error, (int) so->so_state); @@ -772,7 +772,7 @@ bootpc_call(struct bootpc_globalcontext *gctx, clear_sinaddr(sin); sin->sin_addr.s_addr = htonl(0xff000000u); error = ifioctl(ifctx->so, SIOCSIFNETMASK, - (caddr_t) &ifctx->ireq, procp); + (caddr_t) &ifctx->ireq, td); if (error != 0) panic("bootpc_call:" "set if netmask, error=%d", @@ -810,7 +810,7 @@ bootpc_call(struct bootpc_globalcontext *gctx, auio.uio_rw = UIO_READ; auio.uio_offset = 0; auio.uio_resid = sizeof(gctx->reply); - auio.uio_procp = procp; + auio.uio_td = td; rcvflg = 0; error = soreceive(so, NULL, &auio, @@ -979,7 +979,7 @@ out: static int bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, struct bootpc_globalcontext *gctx, - struct proc *procp) + struct thread *td) { struct sockaddr_in *sin; int error; @@ -989,7 +989,7 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, struct ifaddr *ifa; struct sockaddr_dl *sdl; - error = socreate(AF_INET, &ifctx->so, SOCK_DGRAM, 0, procp); + error = socreate(AF_INET, &ifctx->so, SOCK_DGRAM, 0, td); if (error != 0) panic("nfs_boot: socreate, error=%d", error); @@ -1002,11 +1002,11 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, * Get the old interface flags and or IFF_UP into them; if * IFF_UP set blindly, interface selection can be clobbered. */ - error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)ireq, td); if (error != 0) panic("bootpc_fakeup_interface: GIFFLAGS, error=%d", error); ireq->ifr_flags |= IFF_UP; - error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)ireq, td); if (error != 0) panic("bootpc_fakeup_interface: SIFFLAGS, error=%d", error); @@ -1019,7 +1019,7 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, sin = (struct sockaddr_in *) &ireq->ifr_addr; clear_sinaddr(sin); - error = ifioctl(so, SIOCSIFADDR, (caddr_t) ireq, procp); + error = ifioctl(so, SIOCSIFADDR, (caddr_t) ireq, td); if (error != 0 && (error != EEXIST || ifctx == gctx->interfaces)) panic("bootpc_fakeup_interface: " "set if addr, error=%d", error); @@ -1029,7 +1029,7 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, sin = (struct sockaddr_in *) &ireq->ifr_addr; clear_sinaddr(sin); sin->sin_addr.s_addr = htonl(0xff000000u); - error = ifioctl(so, SIOCSIFNETMASK, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCSIFNETMASK, (caddr_t)ireq, td); if (error != 0) panic("bootpc_fakeup_interface: set if netmask, error=%d", error); @@ -1042,7 +1042,7 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, sin->sin_addr.s_addr = htonl(INADDR_BROADCAST); ifctx->broadcast.sin_addr.s_addr = sin->sin_addr.s_addr; - error = ifioctl(so, SIOCSIFBRDADDR, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCSIFBRDADDR, (caddr_t)ireq, td); if (error != 0) panic("bootpc_fakeup_interface: " "set if broadcast addr, error=%d", @@ -1071,7 +1071,7 @@ bootpc_fakeup_interface(struct bootpc_ifcontext *ifctx, static int bootpc_adjust_interface(struct bootpc_ifcontext *ifctx, struct bootpc_globalcontext *gctx, - struct proc *procp) + struct thread *td) { int error; struct sockaddr_in defdst; @@ -1095,19 +1095,19 @@ bootpc_adjust_interface(struct bootpc_ifcontext *ifctx, /* Shutdown interfaces where BOOTP failed */ printf("Shutdown interface %s\n", ifctx->ireq.ifr_name); - error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCGIFFLAGS, (caddr_t)ireq, td); if (error != 0) panic("bootpc_adjust_interface: " "SIOCGIFFLAGS, error=%d", error); ireq->ifr_flags &= ~IFF_UP; - error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)ireq, procp); + error = ifioctl(so, SIOCSIFFLAGS, (caddr_t)ireq, td); if (error != 0) panic("bootpc_adjust_interface: " "SIOCSIFFLAGS, error=%d", error); sin = (struct sockaddr_in *) &ireq->ifr_addr; clear_sinaddr(sin); - error = ifioctl(so, SIOCDIFADDR, (caddr_t) ireq, procp); + error = ifioctl(so, SIOCDIFADDR, (caddr_t) ireq, td); if (error != 0 && (error != EEXIST || ifctx == gctx->interfaces)) panic("bootpc_adjust_interface: " @@ -1122,7 +1122,7 @@ bootpc_adjust_interface(struct bootpc_ifcontext *ifctx, * can talk to the servers. (just set the address) */ bcopy(netmask, &ireq->ifr_addr, sizeof(*netmask)); - error = ifioctl(so, SIOCSIFNETMASK, (caddr_t) ireq, procp); + error = ifioctl(so, SIOCSIFNETMASK, (caddr_t) ireq, td); if (error != 0) panic("bootpc_adjust_interface: " "set if netmask, error=%d", error); @@ -1133,13 +1133,13 @@ bootpc_adjust_interface(struct bootpc_ifcontext *ifctx, clear_sinaddr(sin); sin->sin_addr.s_addr = myaddr->sin_addr.s_addr | ~ netmask->sin_addr.s_addr; - error = ifioctl(so, SIOCSIFBRDADDR, (caddr_t) ireq, procp); + error = ifioctl(so, SIOCSIFBRDADDR, (caddr_t) ireq, td); if (error != 0) panic("bootpc_adjust_interface: " "set if broadcast addr, error=%d", error); bcopy(myaddr, &ireq->ifr_addr, sizeof(*myaddr)); - error = ifioctl(so, SIOCSIFADDR, (caddr_t) ireq, procp); + error = ifioctl(so, SIOCSIFADDR, (caddr_t) ireq, td); if (error != 0 && (error != EEXIST || ifctx == gctx->interfaces)) panic("bootpc_adjust_interface: " "set if addr, error=%d", error); @@ -1326,10 +1326,10 @@ print_in_addr(struct in_addr addr) } static void -bootpc_compose_query(ifctx, gctx, procp) +bootpc_compose_query(ifctx, gctx, td) struct bootpc_ifcontext *ifctx; struct bootpc_globalcontext *gctx; - struct proc *procp; + struct thread *td; { unsigned char *vendp; uint32_t leasetime; @@ -1670,10 +1670,10 @@ bootpc_init(void) struct ifnet *ifp; int error; struct nfsv3_diskless *nd; - struct proc *procp; + struct thread *td; nd = &nfsv3_diskless; - procp = curproc; + td = curthread; /* * If already filled in, don't touch it here @@ -1745,13 +1745,13 @@ bootpc_init(void) gctx->gotgw = 0; for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next) - bootpc_fakeup_interface(ifctx, gctx, procp); + bootpc_fakeup_interface(ifctx, gctx, td); for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next) - bootpc_compose_query(ifctx, gctx, procp); + bootpc_compose_query(ifctx, gctx, td); ifctx = gctx->interfaces; - error = bootpc_call(gctx, procp); + error = bootpc_call(gctx, td); if (error != 0) { #ifdef BOOTP_NFSROOT @@ -1777,7 +1777,7 @@ bootpc_init(void) #endif for (ifctx = gctx->interfaces; ifctx != NULL; ifctx = ifctx->next) { - bootpc_adjust_interface(ifctx, gctx, procp); + bootpc_adjust_interface(ifctx, gctx, td); soclose(ifctx->so); } @@ -1799,7 +1799,7 @@ bootpc_init(void) error = md_mount(&nd->root_saddr, nd->root_hostnam, nd->root_fh, &nd->root_fhsize, - &nd->root_args, procp); + &nd->root_args, td); if (error != 0) panic("nfs_boot: mountd root, error=%d", error); @@ -1808,7 +1808,7 @@ bootpc_init(void) error = md_mount(&nd->swap_saddr, nd->swap_hostnam, nd->swap_fh, &nd->swap_fhsize, - &nd->swap_args, procp); + &nd->swap_args, td); if (error != 0) panic("nfs_boot: mountd swap, error=%d", error); @@ -1816,7 +1816,7 @@ bootpc_init(void) error = md_lookup_swap(&nd->swap_saddr, gctx->lookup_path, nd->swap_fh, &nd->swap_fhsize, - &nd->swap_args, procp); + &nd->swap_args, td); if (error != 0) panic("nfs_boot: lookup swap, error=%d", error); @@ -1852,7 +1852,7 @@ md_mount(struct sockaddr_in *mdsin, /* mountd server address */ u_char *fhp, int *fhsizep, struct nfs_args *args, - struct proc *procp) + struct thread *td) { struct mbuf *m; int error; @@ -1864,13 +1864,13 @@ md_mount(struct sockaddr_in *mdsin, /* mountd server address */ /* First try NFS v3 */ /* Get port number for MOUNTD. */ error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER3, - &mdsin->sin_port, procp); + &mdsin->sin_port, td); if (error == 0) { m = xdr_string_encode(path, strlen(path)); /* Do RPC to mountd. */ error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER3, - RPCMNT_MOUNT, &m, NULL, procp); + RPCMNT_MOUNT, &m, NULL, td); } if (error == 0) { args->flags |= NFSMNT_NFSV3; @@ -1880,7 +1880,7 @@ md_mount(struct sockaddr_in *mdsin, /* mountd server address */ /* Get port number for MOUNTD. */ error = krpc_portmap(mdsin, RPCPROG_MNT, RPCMNT_VER1, - &mdsin->sin_port, procp); + &mdsin->sin_port, td); if (error != 0) return error; @@ -1888,7 +1888,7 @@ md_mount(struct sockaddr_in *mdsin, /* mountd server address */ /* Do RPC to mountd. */ error = krpc_call(mdsin, RPCPROG_MNT, RPCMNT_VER1, - RPCMNT_MOUNT, &m, NULL, procp); + RPCMNT_MOUNT, &m, NULL, td); if (error != 0) return error; /* message already freed */ @@ -1931,7 +1931,7 @@ md_mount(struct sockaddr_in *mdsin, /* mountd server address */ error = krpc_portmap(mdsin, NFS_PROG, (args->flags & NFSMNT_NFSV3) ? NFS_VER3 : NFS_VER2, - &mdsin->sin_port, procp); + &mdsin->sin_port, td); goto out; @@ -1950,7 +1950,7 @@ md_lookup_swap(struct sockaddr_in *mdsin, /* mountd server address */ u_char *fhp, int *fhsizep, struct nfs_args *args, - struct proc *procp) + struct thread *td) { struct mbuf *m; int error; @@ -1984,10 +1984,10 @@ md_lookup_swap(struct sockaddr_in *mdsin, /* mountd server address */ /* Do RPC to nfsd. */ if ((args->flags & NFSMNT_NFSV3) != 0) error = krpc_call(mdsin, NFS_PROG, NFS_VER3, - NFSPROC_LOOKUP, &m, NULL, procp); + NFSPROC_LOOKUP, &m, NULL, td); else error = krpc_call(mdsin, NFS_PROG, NFS_VER2, - NFSV2PROC_LOOKUP, &m, NULL, procp); + NFSV2PROC_LOOKUP, &m, NULL, td); if (error != 0) return error; /* message already freed */ diff --git a/sys/nfsclient/krpc.h b/sys/nfsclient/krpc.h index 6c889b5..b6136e3 100644 --- a/sys/nfsclient/krpc.h +++ b/sys/nfsclient/krpc.h @@ -4,16 +4,16 @@ #include <sys/cdefs.h> struct mbuf; -struct proc; +struct thread; struct sockaddr; struct sockaddr_in; int krpc_call __P((struct sockaddr_in *_sin, u_int prog, u_int vers, u_int func, - struct mbuf **data, struct sockaddr **from, struct proc *procp)); + struct mbuf **data, struct sockaddr **from, struct thread *td)); int krpc_portmap __P((struct sockaddr_in *_sin, - u_int prog, u_int vers, u_int16_t *portp,struct proc *procp)); + u_int prog, u_int vers, u_int16_t *portp,struct thread *td)); struct mbuf *xdr_string_encode __P((char *str, int len)); diff --git a/sys/nfsclient/krpc_subr.c b/sys/nfsclient/krpc_subr.c index b7b1d2c..709af4a 100644 --- a/sys/nfsclient/krpc_subr.c +++ b/sys/nfsclient/krpc_subr.c @@ -124,11 +124,11 @@ struct rpc_reply { * Returns non-zero error on failure. */ int -krpc_portmap(sin, prog, vers, portp, procp) +krpc_portmap(sin, prog, vers, portp, td) struct sockaddr_in *sin; /* server address */ u_int prog, vers; /* host order */ u_int16_t *portp; /* network order */ - struct proc *procp; + struct thread *td; { struct sdata { u_int32_t prog; /* call program */ @@ -163,7 +163,7 @@ krpc_portmap(sin, prog, vers, portp, procp) sin->sin_port = htons(PMAPPORT); error = krpc_call(sin, PMAPPROG, PMAPVERS, - PMAPPROC_GETPORT, &m, NULL, procp); + PMAPPROC_GETPORT, &m, NULL, td); if (error) return error; @@ -185,12 +185,12 @@ krpc_portmap(sin, prog, vers, portp, procp) * the address from whence the response came is saved there. */ int -krpc_call(sa, prog, vers, func, data, from_p, procp) +krpc_call(sa, prog, vers, func, data, from_p, td) struct sockaddr_in *sa; u_int prog, vers, func; struct mbuf **data; /* input/output */ struct sockaddr **from_p; /* output */ - struct proc *procp; + struct thread *td; { struct socket *so; struct sockaddr_in *sin, ssin; @@ -220,7 +220,7 @@ krpc_call(sa, prog, vers, func, data, from_p, procp) /* * Create socket and set its recieve timeout. */ - if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0, procp))) + if ((error = socreate(AF_INET, &so, SOCK_DGRAM, 0, td))) goto out; tv.tv_sec = 1; @@ -260,7 +260,7 @@ krpc_call(sa, prog, vers, func, data, from_p, procp) do { tport--; sin->sin_port = htons(tport); - error = sobind(so, (struct sockaddr *)sin, procp); + error = sobind(so, (struct sockaddr *)sin, td); } while (error == EADDRINUSE && tport > IPPORT_RESERVED / 2); if (error) { @@ -321,7 +321,7 @@ krpc_call(sa, prog, vers, func, data, from_p, procp) goto out; } error = sosend(so, (struct sockaddr *)sa, NULL, m, - NULL, 0, procp); + NULL, 0, td); if (error) { printf("krpc_call: sosend: %d\n", error); goto out; diff --git a/sys/nfsclient/nfs.h b/sys/nfsclient/nfs.h index 44d04b9..d5d0796 100644 --- a/sys/nfsclient/nfs.h +++ b/sys/nfsclient/nfs.h @@ -348,7 +348,7 @@ struct nfsreq { int r_timer; /* tick counter on reply */ u_int32_t r_procnum; /* NFS procedure number */ int r_rtt; /* RTT for rpc */ - struct proc *r_procp; /* Proc that did I/O system call */ + struct thread *r_td; /* Proc that did I/O system call */ }; /* @@ -469,7 +469,7 @@ struct nfsd { u_char nfsd_authstr[RPCAUTH_MAXSIZ]; /* Authenticator data */ int nfsd_verflen; /* and the Verifier */ u_char nfsd_verfstr[RPCVERF_MAXSIZ]; - struct proc *nfsd_procp; /* Proc ptr */ + struct thread *nfsd_td; /* daemon thread ptr */ struct nfsrv_descript *nfsd_nd; /* Associated nfsrv_descript */ }; @@ -592,16 +592,16 @@ void nfs_sndunlock __P((struct nfsreq *)); int nfs_slplock __P((struct nfssvc_sock *, int)); void nfs_slpunlock __P((struct nfssvc_sock *)); int nfs_disct __P((struct mbuf **, caddr_t *, int, int, caddr_t *)); -int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct proc *, +int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct thread *, int)); int nfs_readrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_writerpc __P((struct vnode *, struct uio *, struct ucred *, int *, int *)); int nfs_commit __P((struct vnode *vp, u_quad_t offset, int cnt, - struct ucred *cred, struct proc *procp)); + struct ucred *cred, struct thread *)); int nfs_readdirrpc __P((struct vnode *, struct uio *, struct ucred *)); -int nfs_asyncio __P((struct buf *, struct ucred *, struct proc *)); -int nfs_doio __P((struct buf *, struct ucred *, struct proc *)); +int nfs_asyncio __P((struct buf *, struct ucred *, struct thread *)); +int nfs_doio __P((struct buf *, struct ucred *, struct thread *)); int nfs_readlinkrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_sigintr __P((struct nfsmount *, struct nfsreq *, struct proc *)); int nfs_readdirplusrpc __P((struct vnode *, struct uio *, struct ucred *)); @@ -613,14 +613,14 @@ void nfsm_srvwcc __P((struct nfsrv_descript *, int, struct vattr *, int, void nfsm_srvpostopattr __P((struct nfsrv_descript *, int, struct vattr *, struct mbuf **, char **)); int netaddr_match __P((int, union nethostaddr *, struct sockaddr *)); -int nfs_request __P((struct vnode *, struct mbuf *, int, struct proc *, +int nfs_request __P((struct vnode *, struct mbuf *, int, struct thread *, struct ucred *, struct mbuf **, struct mbuf **, caddr_t *)); int nfs_loadattrcache __P((struct vnode **, struct mbuf **, caddr_t *, struct vattr *, int)); int nfs_namei __P((struct nameidata *, fhandle_t *, int, struct nfssvc_sock *, struct sockaddr *, struct mbuf **, - caddr_t *, struct vnode **, struct proc *, int, int)); + caddr_t *, struct vnode **, struct thread *, int, int)); void nfsm_adj __P((struct mbuf *, int, int)); int nfsm_mbuftouio __P((struct mbuf **, struct uio *, int, caddr_t *)); void nfsrv_initcache __P((void)); @@ -652,21 +652,21 @@ void nfs_clearcommit __P((struct mount *)); int nfsrv_errmap __P((struct nfsrv_descript *, int)); void nfsrvw_sort __P((gid_t *, int)); void nfsrv_setcred __P((struct ucred *, struct ucred *)); -int nfs_writebp __P((struct buf *, int, struct proc *)); +int nfs_writebp __P((struct buf *, int, struct thread *)); int nfsrv_object_create __P((struct vnode *)); void nfsrv_wakenfsd __P((struct nfssvc_sock *slp)); int nfsrv_writegather __P((struct nfsrv_descript **, struct nfssvc_sock *, - struct proc *, struct mbuf **)); + struct thread *, struct mbuf **)); int nfs_fsinfo __P((struct nfsmount *, struct vnode *, struct ucred *, - struct proc *p)); + struct thread *p)); int nfsrv3_access __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_commit __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_create __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_fhtovp __P((fhandle_t *, int, struct vnode **, struct ucred *, struct nfssvc_sock *, struct sockaddr *, int *, int, int)); @@ -674,52 +674,52 @@ int nfsrv_setpublicfs __P((struct mount *, struct netexport *, struct export_args *)); int nfs_ispublicfh __P((fhandle_t *)); int nfsrv_fsinfo __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_getattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_link __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_lookup __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mkdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mknod __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_noop __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_null __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_pathconf __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_read __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdirplus __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_readlink __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_remove __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rename __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rmdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_setattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_statfs __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_symlink __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_write __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); void nfsrv_rcv __P((struct socket *so, void *arg, int waitflag)); void nfsrv_slpderef __P((struct nfssvc_sock *slp)); #endif /* _KERNEL */ diff --git a/sys/nfsclient/nfs_bio.c b/sys/nfsclient/nfs_bio.c index 3bcdb32..e48cd5c 100644 --- a/sys/nfsclient/nfs_bio.c +++ b/sys/nfsclient/nfs_bio.c @@ -72,7 +72,7 @@ static int nfs_bwrite(struct buf *bp) { - return (nfs_writebp(bp, 1, curproc)); + return (nfs_writebp(bp, 1, curthread)); } struct buf_ops buf_ops_nfs = { @@ -82,7 +82,7 @@ struct buf_ops buf_ops_nfs = { static struct buf *nfs_getcacheblk __P((struct vnode *vp, daddr_t bn, int size, - struct proc *p)); + struct thread *td)); extern int nfs_numasync; extern int nfs_pbuf_freecnt; @@ -107,7 +107,7 @@ nfs_getpages(ap) vm_offset_t kva; struct buf *bp; struct vnode *vp; - struct proc *p; + struct thread *td; struct ucred *cred; struct nfsmount *nmp; vm_page_t *pages; @@ -115,8 +115,8 @@ nfs_getpages(ap) GIANT_REQUIRED; vp = ap->a_vp; - p = curproc; /* XXX */ - cred = curproc->p_ucred; /* XXX */ + td = curthread; /* XXX */ + cred = curthread->td_proc->p_ucred; /* XXX */ nmp = VFSTONFS(vp->v_mount); pages = ap->a_m; count = ap->a_count; @@ -128,7 +128,7 @@ nfs_getpages(ap) if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) { - (void)nfs_fsinfo(nmp, vp, cred, p); + (void)nfs_fsinfo(nmp, vp, cred, td); } npages = btoc(count); @@ -172,7 +172,7 @@ nfs_getpages(ap) uio.uio_resid = count; uio.uio_segflg = UIO_SYSSPACE; uio.uio_rw = UIO_READ; - uio.uio_procp = p; + uio.uio_td = td; error = nfs_readrpc(vp, &uio, cred); pmap_qremove(kva, npages); @@ -268,7 +268,7 @@ nfs_putpages(ap) off_t offset; int *rtvals; struct vnode *vp; - struct proc *p; + struct thread *td; struct ucred *cred; struct nfsmount *nmp; struct nfsnode *np; @@ -278,8 +278,8 @@ nfs_putpages(ap) vp = ap->a_vp; np = VTONFS(vp); - p = curproc; /* XXX */ - cred = curproc->p_ucred; /* XXX */ + td = curthread; /* XXX */ + cred = curthread->td_proc->p_ucred; /* XXX */ nmp = VFSTONFS(vp->v_mount); pages = ap->a_m; count = ap->a_count; @@ -291,7 +291,7 @@ nfs_putpages(ap) if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) { - (void)nfs_fsinfo(nmp, vp, cred, p); + (void)nfs_fsinfo(nmp, vp, cred, td); } for (i = 0; i < npages; i++) { @@ -327,7 +327,7 @@ nfs_putpages(ap) uio.uio_resid = count; uio.uio_segflg = UIO_SYSSPACE; uio.uio_rw = UIO_WRITE; - uio.uio_procp = p; + uio.uio_td = td; if ((ap->a_sync & VM_PAGER_PUT_SYNC) == 0) iomode = NFSV3WRITE_UNSTABLE; @@ -366,7 +366,7 @@ nfs_bioread(vp, uio, ioflag, cred) register int biosize, i; struct buf *bp = 0, *rabp; struct vattr vattr; - struct proc *p; + struct thread *td; struct nfsmount *nmp = VFSTONFS(vp->v_mount); daddr_t lbn, rabn; int bcount; @@ -381,11 +381,11 @@ nfs_bioread(vp, uio, ioflag, cred) return (0); if (uio->uio_offset < 0) /* XXX VDIR cookies can be negative */ return (EINVAL); - p = uio->uio_procp; + td = uio->uio_td; if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) - (void)nfs_fsinfo(nmp, vp, cred, p); + (void)nfs_fsinfo(nmp, vp, cred, td); if (vp->v_type != VDIR && (uio->uio_offset + uio->uio_resid) > nmp->nm_maxfilesize) return (EFBIG); @@ -414,23 +414,23 @@ nfs_bioread(vp, uio, ioflag, cred) if (vp->v_type != VDIR) panic("nfs: bioread, not dir"); nfs_invaldir(vp); - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); } np->n_attrstamp = 0; - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); np->n_mtime = vattr.va_mtime.tv_sec; } else { - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); if (np->n_mtime != vattr.va_mtime.tv_sec) { if (vp->v_type == VDIR) nfs_invaldir(vp); - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); np->n_mtime = vattr.va_mtime.tv_sec; @@ -445,7 +445,7 @@ nfs_bioread(vp, uio, ioflag, cred) if (nmp->nm_flag & NFSMNT_NQNFS) { if (NQNFS_CKINVALID(vp, np, ND_READ)) { do { - error = nqnfs_getlease(vp, ND_READ, cred, p); + error = nqnfs_getlease(vp, ND_READ, cred, td); } while (error == NQNFS_EXPIRED); if (error) return (error); @@ -454,14 +454,14 @@ nfs_bioread(vp, uio, ioflag, cred) ((np->n_flag & NMODIFIED) && vp->v_type == VDIR)) { if (vp->v_type == VDIR) nfs_invaldir(vp); - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); np->n_brev = np->n_lrev; } } else if (vp->v_type == VDIR && (np->n_flag & NMODIFIED)) { nfs_invaldir(vp); - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); } @@ -493,14 +493,14 @@ nfs_bioread(vp, uio, ioflag, cred) (off_t)(lbn + 1 + nra) * biosize < np->n_size; nra++) { rabn = lbn + 1 + nra; if (!incore(vp, rabn)) { - rabp = nfs_getcacheblk(vp, rabn, biosize, p); + rabp = nfs_getcacheblk(vp, rabn, biosize, td); if (!rabp) return (EINTR); if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) { rabp->b_flags |= B_ASYNC; rabp->b_iocmd = BIO_READ; vfs_busy_pages(rabp, 0); - if (nfs_asyncio(rabp, cred, p)) { + if (nfs_asyncio(rabp, cred, td)) { rabp->b_flags |= B_INVAL; rabp->b_ioflags |= BIO_ERROR; vfs_unbusy_pages(rabp); @@ -534,7 +534,7 @@ again: bcount = np->n_size - (off_t)lbn * biosize; } if (bcount != biosize) { - switch(nfs_rslock(np, p)) { + switch(nfs_rslock(np, td)) { case ENOLCK: goto again; /* not reached */ @@ -547,10 +547,10 @@ again: } } - bp = nfs_getcacheblk(vp, lbn, bcount, p); + bp = nfs_getcacheblk(vp, lbn, bcount, td); if (bcount != biosize) - nfs_rsunlock(np, p); + nfs_rsunlock(np, td); if (!bp) return (EINTR); @@ -562,7 +562,7 @@ again: if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); - error = nfs_doio(bp, cred, p); + error = nfs_doio(bp, cred, td); if (error) { brelse(bp); return (error); @@ -583,13 +583,13 @@ again: break; case VLNK: nfsstats.biocache_readlinks++; - bp = nfs_getcacheblk(vp, (daddr_t)0, NFS_MAXPATHLEN, p); + bp = nfs_getcacheblk(vp, (daddr_t)0, NFS_MAXPATHLEN, td); if (!bp) return (EINTR); if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); - error = nfs_doio(bp, cred, p); + error = nfs_doio(bp, cred, td); if (error) { bp->b_ioflags |= BIO_ERROR; brelse(bp); @@ -607,20 +607,20 @@ again: } lbn = (uoff_t)uio->uio_offset / NFS_DIRBLKSIZ; on = uio->uio_offset & (NFS_DIRBLKSIZ - 1); - bp = nfs_getcacheblk(vp, lbn, NFS_DIRBLKSIZ, p); + bp = nfs_getcacheblk(vp, lbn, NFS_DIRBLKSIZ, td); if (!bp) return (EINTR); if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); - error = nfs_doio(bp, cred, p); + error = nfs_doio(bp, cred, td); if (error) { brelse(bp); } while (error == NFSERR_BAD_COOKIE) { printf("got bad cookie vp %p bp %p\n", vp, bp); nfs_invaldir(vp); - error = nfs_vinvalbuf(vp, 0, cred, p, 1); + error = nfs_vinvalbuf(vp, 0, cred, td, 1); /* * Yuck! The directory has been modified on the * server. The only way to get the block is by @@ -635,13 +635,13 @@ again: if (np->n_direofoffset && (i * NFS_DIRBLKSIZ) >= np->n_direofoffset) return (0); - bp = nfs_getcacheblk(vp, i, NFS_DIRBLKSIZ, p); + bp = nfs_getcacheblk(vp, i, NFS_DIRBLKSIZ, td); if (!bp) return (EINTR); if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); - error = nfs_doio(bp, cred, p); + error = nfs_doio(bp, cred, td); /* * no error + B_INVAL == directory EOF, * use the block. @@ -679,13 +679,13 @@ again: (lbn + 1) * NFS_DIRBLKSIZ < np->n_direofoffset) && !(np->n_flag & NQNFSNONCACHE) && !incore(vp, lbn + 1)) { - rabp = nfs_getcacheblk(vp, lbn + 1, NFS_DIRBLKSIZ, p); + rabp = nfs_getcacheblk(vp, lbn + 1, NFS_DIRBLKSIZ, td); if (rabp) { if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) { rabp->b_flags |= B_ASYNC; rabp->b_iocmd = BIO_READ; vfs_busy_pages(rabp, 0); - if (nfs_asyncio(rabp, cred, p)) { + if (nfs_asyncio(rabp, cred, td)) { rabp->b_flags |= B_INVAL; rabp->b_ioflags |= BIO_ERROR; vfs_unbusy_pages(rabp); @@ -756,7 +756,7 @@ nfs_write(ap) { int biosize; struct uio *uio = ap->a_uio; - struct proc *p = uio->uio_procp; + struct thread *td = uio->uio_td; struct vnode *vp = ap->a_vp; struct nfsnode *np = VTONFS(vp); struct ucred *cred = ap->a_cred; @@ -768,13 +768,14 @@ nfs_write(ap) int bcount; int n, on, error = 0, iomode, must_commit; int haverslock = 0; + struct proc *p = td?td->td_proc:NULL; GIANT_REQUIRED; #ifdef DIAGNOSTIC if (uio->uio_rw != UIO_WRITE) panic("nfs_write mode"); - if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc) + if (uio->uio_segflg == UIO_USERSPACE && uio->uio_td != curthread) panic("nfs_write proc"); #endif if (vp->v_type != VREG) @@ -785,7 +786,7 @@ nfs_write(ap) } if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) - (void)nfs_fsinfo(nmp, vp, cred, p); + (void)nfs_fsinfo(nmp, vp, cred, td); /* * Synchronously flush pending buffers if we are in synchronous @@ -794,7 +795,7 @@ nfs_write(ap) if (ioflag & (IO_APPEND | IO_SYNC)) { if (np->n_flag & NMODIFIED) { np->n_attrstamp = 0; - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) return (error); } @@ -807,7 +808,7 @@ nfs_write(ap) restart: if (ioflag & IO_APPEND) { np->n_attrstamp = 0; - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); uio->uio_offset = np->n_size; @@ -836,7 +837,7 @@ restart: */ if ((ioflag & IO_APPEND) || uio->uio_offset + uio->uio_resid > np->n_size) { - switch(nfs_rslock(np, p)) { + switch(nfs_rslock(np, td)) { case ENOLCK: goto restart; /* not reached */ @@ -860,7 +861,7 @@ restart: psignal(p, SIGXFSZ); PROC_UNLOCK(p); if (haverslock) - nfs_rsunlock(np, p); + nfs_rsunlock(np, td); return (EFBIG); } @@ -873,13 +874,13 @@ restart: if ((nmp->nm_flag & NFSMNT_NQNFS) && NQNFS_CKINVALID(vp, np, ND_WRITE)) { do { - error = nqnfs_getlease(vp, ND_WRITE, cred, p); + error = nqnfs_getlease(vp, ND_WRITE, cred, td); } while (error == NQNFS_EXPIRED); if (error) break; if (np->n_lrev != np->n_brev || (np->n_flag & NQNFSNONCACHE)) { - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) break; np->n_brev = np->n_lrev; @@ -910,7 +911,7 @@ again: * readers from reading garbage. */ bcount = on; - bp = nfs_getcacheblk(vp, lbn, bcount, p); + bp = nfs_getcacheblk(vp, lbn, bcount, td); if (bp != NULL) { long save; @@ -939,7 +940,7 @@ again: bcount = np->n_size - (off_t)lbn * biosize; } - bp = nfs_getcacheblk(vp, lbn, bcount, p); + bp = nfs_getcacheblk(vp, lbn, bcount, td); if (uio->uio_offset + n > np->n_size) { np->n_size = uio->uio_offset + n; @@ -981,7 +982,7 @@ again: if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); - error = nfs_doio(bp, cred, p); + error = nfs_doio(bp, cred, td); if (error) { brelse(bp); break; @@ -1047,7 +1048,7 @@ again: if ((nmp->nm_flag & NFSMNT_NQNFS) && NQNFS_CKINVALID(vp, np, ND_WRITE)) { do { - error = nqnfs_getlease(vp, ND_WRITE, cred, p); + error = nqnfs_getlease(vp, ND_WRITE, cred, td); } while (error == NQNFS_EXPIRED); if (error) { brelse(bp); @@ -1056,7 +1057,7 @@ again: if (np->n_lrev != np->n_brev || (np->n_flag & NQNFSNONCACHE)) { brelse(bp); - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) break; np->n_brev = np->n_lrev; @@ -1108,7 +1109,7 @@ again: if (error) break; if (np->n_flag & NQNFSNONCACHE) { - error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, cred, td, 1); if (error) break; } @@ -1122,7 +1123,7 @@ again: } while (uio->uio_resid > 0 && n > 0); if (haverslock) - nfs_rsunlock(np, p); + nfs_rsunlock(np, td); return (error); } @@ -1143,11 +1144,11 @@ again: * its EOF. */ static struct buf * -nfs_getcacheblk(vp, bn, size, p) +nfs_getcacheblk(vp, bn, size, td) struct vnode *vp; daddr_t bn; int size; - struct proc *p; + struct thread *td; { register struct buf *bp; struct mount *mp; @@ -1159,7 +1160,7 @@ nfs_getcacheblk(vp, bn, size, p) if (nmp->nm_flag & NFSMNT_INT) { bp = getblk(vp, bn, size, PCATCH, 0); while (bp == (struct buf *)0) { - if (nfs_sigintr(nmp, (struct nfsreq *)0, p)) + if (nfs_sigintr(nmp, (struct nfsreq *)0, td->td_proc)) return ((struct buf *)0); bp = getblk(vp, bn, size, 0, 2 * hz); } @@ -1181,11 +1182,11 @@ nfs_getcacheblk(vp, bn, size, p) * doing the flush, just wait for completion. */ int -nfs_vinvalbuf(vp, flags, cred, p, intrflg) +nfs_vinvalbuf(vp, flags, cred, td, intrflg) struct vnode *vp; int flags; struct ucred *cred; - struct proc *p; + struct thread *td; int intrflg; { register struct nfsnode *np = VTONFS(vp); @@ -1212,7 +1213,7 @@ nfs_vinvalbuf(vp, flags, cred, p, intrflg) np->n_flag |= NFLUSHWANT; error = tsleep((caddr_t)&np->n_flag, PRIBIO + 2, "nfsvinval", slptimeo); - if (error && intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, p)) + if (error && intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, td->td_proc)) return (EINTR); } @@ -1220,9 +1221,9 @@ nfs_vinvalbuf(vp, flags, cred, p, intrflg) * Now, flush as required. */ np->n_flag |= NFLUSHINPROG; - error = vinvalbuf(vp, flags, cred, p, slpflag, 0); + error = vinvalbuf(vp, flags, cred, td, slpflag, 0); while (error) { - if (intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, p)) { + if (intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, td->td_proc)) { np->n_flag &= ~NFLUSHINPROG; if (np->n_flag & NFLUSHWANT) { np->n_flag &= ~NFLUSHWANT; @@ -1230,7 +1231,7 @@ nfs_vinvalbuf(vp, flags, cred, p, intrflg) } return (EINTR); } - error = vinvalbuf(vp, flags, cred, p, 0, slptimeo); + error = vinvalbuf(vp, flags, cred, td, 0, slptimeo); } np->n_flag &= ~(NMODIFIED | NFLUSHINPROG); if (np->n_flag & NFLUSHWANT) { @@ -1249,10 +1250,10 @@ nfs_vinvalbuf(vp, flags, cred, p, intrflg) * is eventually dequeued by the async daemon, nfs_doio() *will*. */ int -nfs_asyncio(bp, cred, procp) +nfs_asyncio(bp, cred, td) register struct buf *bp; struct ucred *cred; - struct proc *procp; + struct thread *td; { struct nfsmount *nmp; int i; @@ -1334,7 +1335,7 @@ again: error = tsleep(&nmp->nm_bufq, slpflag | PRIBIO, "nfsaio", slptimeo); if (error) { - if (nfs_sigintr(nmp, NULL, procp)) + if (nfs_sigintr(nmp, NULL, td->td_proc)) return (EINTR); if (slpflag == PCATCH) { slpflag = 0; @@ -1384,10 +1385,10 @@ again: * synchronously or from an nfsiod. */ int -nfs_doio(bp, cr, p) +nfs_doio(bp, cr, td) struct buf *bp; struct ucred *cr; - struct proc *p; + struct thread *td; { struct uio *uiop; struct vnode *vp; @@ -1396,6 +1397,7 @@ nfs_doio(bp, cr, p) int error = 0, iomode, must_commit = 0; struct uio uio; struct iovec io; + struct proc *p = td?td->td_proc:NULL; vp = bp->b_vp; np = VTONFS(vp); @@ -1404,7 +1406,7 @@ nfs_doio(bp, cr, p) uiop->uio_iov = &io; uiop->uio_iovcnt = 1; uiop->uio_segflg = UIO_SYSSPACE; - uiop->uio_procp = p; + uiop->uio_td = td; /* * clear BIO_ERROR and B_INVAL state prior to initiating the I/O. We @@ -1525,7 +1527,7 @@ nfs_doio(bp, cr, p) bp->b_flags |= B_WRITEINPROG; retv = nfs_commit( bp->b_vp, off, bp->b_dirtyend-bp->b_dirtyoff, - bp->b_wcred, p); + bp->b_wcred, td); bp->b_flags &= ~B_WRITEINPROG; if (retv == 0) { bp->b_dirtyoff = bp->b_dirtyend = 0; diff --git a/sys/nfsclient/nfs_lock.c b/sys/nfsclient/nfs_lock.c index e2fa91c..b97b3b8 100644 --- a/sys/nfsclient/nfs_lock.c +++ b/sys/nfsclient/nfs_lock.c @@ -87,14 +87,17 @@ nfs_dolock(ap) { LOCKD_MSG msg; struct nameidata nd; - struct proc *p; + struct thread *td; uid_t saved_uid; struct vnode *vp, *wvp; int error, error1; struct flock *fl; int fmode, ioflg; + struct proc *p; + + td = curthread; + p = td->td_proc; - p = curproc; vp = ap->a_vp; fl = ap->a_fl; @@ -148,7 +151,7 @@ nfs_dolock(ap) * complain that the user's file is missing, which isn't the case. * Note that we use proc0's cred, so the fifo is opened as root. */ - NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, _PATH_LCKFIFO, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, _PATH_LCKFIFO, td); /* * XXX Hack to temporarily allow this process (regardless of it's creds) @@ -166,15 +169,15 @@ nfs_dolock(ap) return (error == ENOENT ? EOPNOTSUPP : error); } wvp = nd.ni_vp; - VOP_UNLOCK(wvp, 0, p); /* vn_open leaves it locked */ + VOP_UNLOCK(wvp, 0, td); /* vn_open leaves it locked */ ioflg = IO_UNIT; for (;;) { - VOP_LEASE(wvp, p, proc0.p_ucred, LEASE_WRITE); + VOP_LEASE(wvp, td, proc0.p_ucred, LEASE_WRITE); error = vn_rdwr(UIO_WRITE, wvp, (caddr_t)&msg, sizeof(msg), 0, - UIO_SYSSPACE, ioflg, proc0.p_ucred, NULL, p); + UIO_SYSSPACE, ioflg, proc0.p_ucred, NULL, td); if (error && (((ioflg & IO_NDELAY) == 0) || error != EAGAIN)) { break; @@ -224,7 +227,7 @@ nfs_dolock(ap) break; } - if ((error1 = vn_close(wvp, FWRITE, proc0.p_ucred, p)) && error == 0) + if ((error1 = vn_close(wvp, FWRITE, proc0.p_ucred, td)) && error == 0) return (error1); return (error); diff --git a/sys/nfsclient/nfs_nfsiod.c b/sys/nfsclient/nfs_nfsiod.c index e378cc5..657f299 100644 --- a/sys/nfsclient/nfs_nfsiod.c +++ b/sys/nfsclient/nfs_nfsiod.c @@ -78,7 +78,7 @@ static MALLOC_DEFINE(M_NFSSVC, "NFS srvsock", "Nfs server structure"); /* Global defs. */ extern int32_t (*nfsrv3_procs[NFS_NPROCS]) __P((struct nfsrv_descript *nd, struct nfssvc_sock *slp, - struct proc *procp, + struct thread *td, struct mbuf **mreqp)); extern int nfs_numasync; extern time_t nqnfsstarttime; @@ -92,7 +92,7 @@ static int nuidhash_max = NFS_MAXUIDHASH; #ifndef NFS_NOSERVER static void nfsrv_zapsock __P((struct nfssvc_sock *slp)); #endif -static int nfssvc_iod __P((struct proc *)); +static int nfssvc_iod __P((struct thread *)); #define TRUE 1 #define FALSE 0 @@ -110,8 +110,9 @@ static int modify_flag = 0; static void nfsd_rt __P((int sotype, struct nfsrv_descript *nd, int cacherep)); static int nfssvc_addsock __P((struct file *, struct sockaddr *, - struct proc *)); -static int nfssvc_nfsd __P((struct nfsd_srvargs *,caddr_t,struct proc *)); + struct thread *)); +static int nfssvc_nfsd __P((struct nfsd_srvargs *,caddr_t, + struct thread *)); static int nfs_privport = 0; SYSCTL_INT(_vfs_nfs, NFS_NFSPRIVPORT, nfs_privport, CTLFLAG_RW, &nfs_privport, 0, ""); @@ -140,8 +141,8 @@ struct nfssvc_args { * MPSAFE */ int -nfssvc(p, uap) - struct proc *p; +nfssvc(td, uap) + struct thread *td; register struct nfssvc_args *uap; { #ifndef NFS_NOSERVER @@ -165,13 +166,13 @@ nfssvc(p, uap) error = copyin(uap->argp, &la, sizeof(la)); if (error == 0) - error = nfslockdans(p, &la); + error = nfslockdans(td->td_proc, &la); goto done2; } /* * Must be super user */ - error = suser(p); + error = suser_td(td); if (error) goto done2; while (nfssvc_sockhead_flag & SLP_INIT) { @@ -179,7 +180,7 @@ nfssvc(p, uap) (void) tsleep((caddr_t)&nfssvc_sockhead, PSOCK, "nfsd init", 0); } if (uap->flag & NFSSVC_BIOD) - error = nfssvc_iod(p); + error = nfssvc_iod(td); #ifdef NFS_NOSERVER else error = ENXIO; @@ -189,7 +190,7 @@ nfssvc(p, uap) if (error) goto done2; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - ncd.ncd_dirp, p); + ncd.ncd_dirp, td); error = namei(&nd); if (error) goto done2; @@ -206,13 +207,13 @@ nfssvc(p, uap) goto done2; } nmp->nm_state |= NFSSTA_MNTD; - error = nqnfs_clientd(nmp, p->p_ucred, &ncd, uap->flag, - uap->argp, p); + error = nqnfs_clientd(nmp, td->td_proc->p_ucred, &ncd, uap->flag, + uap->argp, td); } else if (uap->flag & NFSSVC_ADDSOCK) { error = copyin(uap->argp, (caddr_t)&nfsdarg, sizeof(nfsdarg)); if (error) goto done2; - error = holdsock(p->p_fd, nfsdarg.sock, &fp); + error = holdsock(td->td_proc->p_fd, nfsdarg.sock, &fp); if (error) goto done2; /* @@ -224,12 +225,12 @@ nfssvc(p, uap) error = getsockaddr(&nam, nfsdarg.name, nfsdarg.namelen); if (error) { - fdrop(fp, p); + fdrop(fp, td); goto done2; } } - error = nfssvc_addsock(fp, nam, p); - fdrop(fp, p); + error = nfssvc_addsock(fp, nam, td); + fdrop(fp, td); } else { error = copyin(uap->argp, (caddr_t)nsd, sizeof (*nsd)); if (error) @@ -327,7 +328,7 @@ nfssvc(p, uap) } if ((uap->flag & NFSSVC_AUTHINFAIL) && (nfsd = nsd->nsd_nfsd)) nfsd->nfsd_flag |= NFSD_AUTHFAIL; - error = nfssvc_nfsd(nsd, uap->argp, p); + error = nfssvc_nfsd(nsd, uap->argp, td); } #endif /* NFS_NOSERVER */ if (error == EINTR || error == ERESTART) @@ -342,10 +343,10 @@ done2: * Adds a socket to the list for servicing by nfsds. */ static int -nfssvc_addsock(fp, mynam, p) +nfssvc_addsock(fp, mynam, td) struct file *fp; struct sockaddr *mynam; - struct proc *p; + struct thread *td; { register int siz; register struct nfssvc_sock *slp; @@ -439,10 +440,10 @@ nfssvc_addsock(fp, mynam, p) * until it is killed by a signal. */ static int -nfssvc_nfsd(nsd, argp, p) +nfssvc_nfsd(nsd, argp, td) struct nfsd_srvargs *nsd; caddr_t argp; - struct proc *p; + struct thread *td; { register int siz; register struct nfssvc_sock *slp; @@ -461,7 +462,7 @@ nfssvc_nfsd(nsd, argp, p) nsd->nsd_nfsd = nfsd = (struct nfsd *) malloc(sizeof (struct nfsd), M_NFSD, M_WAITOK | M_ZERO); s = splnet(); - nfsd->nfsd_procp = p; + nfsd->nfsd_td = td; TAILQ_INSERT_TAIL(&nfsd_head, nfsd, nfsd_chain); nfs_numnfsd++; } else @@ -622,10 +623,10 @@ nfssvc_nfsd(nsd, argp, p) if (writes_todo || (nd->nd_procnum == NFSPROC_WRITE && procrastinate > 0 && !notstarted)) error = nfsrv_writegather(&nd, slp, - nfsd->nfsd_procp, &mreq); + nfsd->nfsd_td, &mreq); else error = (*(nfsrv3_procs[nd->nd_procnum]))(nd, - slp, nfsd->nfsd_procp, &mreq); + slp, nfsd->nfsd_td, &mreq); if (mreq == NULL) break; if (error != 0 && error != NFSERR_RETVOID) { @@ -757,7 +758,7 @@ nfsrv_zapsock(slp) so->so_upcall = NULL; so->so_upcallarg = NULL; soshutdown(so, 2); - closef(fp, (struct proc *)0); + closef(fp, (struct thread *)0); if (slp->ns_nam) FREE(slp->ns_nam, M_SONAME); m_freem(slp->ns_raw); @@ -935,8 +936,8 @@ SYSCTL_INT(_vfs_nfs, OID_AUTO, defect, CTLFLAG_RW, &nfs_defect, 0, ""); * Never returns unless it fails or gets killed. */ static int -nfssvc_iod(p) - struct proc *p; +nfssvc_iod(td) + struct thread *td; { register struct buf *bp; register int i, myiod; @@ -965,7 +966,7 @@ nfssvc_iod(p) && error == 0) { if (nmp) nmp->nm_bufqiods--; - nfs_iodwant[myiod] = p; + nfs_iodwant[myiod] = td->td_proc; nfs_iodmount[myiod] = NULL; error = tsleep((caddr_t)&nfs_iodwant[myiod], PWAIT | PCATCH, "nfsidl", 0); @@ -988,9 +989,9 @@ nfssvc_iod(p) wakeup(&nmp->nm_bufq); } if (bp->b_iocmd == BIO_READ) - (void) nfs_doio(bp, bp->b_rcred, (struct proc *)0); + (void) nfs_doio(bp, bp->b_rcred, (struct thread *)0); else - (void) nfs_doio(bp, bp->b_wcred, (struct proc *)0); + (void) nfs_doio(bp, bp->b_wcred, (struct thread *)0); /* * If there are more than one iod on this mount, then defect * so that the iods can be shared out fairly between the mounts @@ -1029,7 +1030,7 @@ nfs_getauth(nmp, rep, cred, auth_str, auth_len, verf_str, verf_len, key) nmp->nm_state |= NFSSTA_WANTAUTH; (void) tsleep((caddr_t)&nmp->nm_authtype, PSOCK, "nfsauth1", 2 * hz); - error = nfs_sigintr(nmp, rep, rep->r_procp); + error = nfs_sigintr(nmp, rep, rep->r_td->td_proc); if (error) { nmp->nm_state &= ~NFSSTA_WANTAUTH; return (error); @@ -1049,7 +1050,7 @@ nfs_getauth(nmp, rep, cred, auth_str, auth_len, verf_str, verf_len, key) while ((nmp->nm_state & NFSSTA_HASAUTH) == 0 && error == 0) { (void) tsleep((caddr_t)&nmp->nm_authlen, PSOCK, "nfsauth2", 2 * hz); - error = nfs_sigintr(nmp, rep, rep->r_procp); + error = nfs_sigintr(nmp, rep, rep->r_td->td_proc); } if (nmp->nm_state & NFSSTA_AUTHERR) { nmp->nm_state &= ~NFSSTA_AUTHERR; diff --git a/sys/nfsclient/nfs_node.c b/sys/nfsclient/nfs_node.c index dc21bc3..5fe3abc 100644 --- a/sys/nfsclient/nfs_node.c +++ b/sys/nfsclient/nfs_node.c @@ -169,7 +169,7 @@ nfs_nget(mntp, fhp, fhsize, npp) int fhsize; struct nfsnode **npp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct nfsnode *np, *np2; struct nfsnodehashhead *nhpp; register struct vnode *vp; @@ -196,7 +196,7 @@ loop: bcmp((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize)) continue; vp = NFSTOV(np); - if (vget(vp, LK_EXCLUSIVE, p)) + if (vget(vp, LK_EXCLUSIVE, td)) goto loop; *npp = np; return(0); @@ -266,7 +266,7 @@ loop: /* * Lock the new nfsnode. */ - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); return (0); } @@ -275,12 +275,12 @@ int nfs_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct nfsnode *np; register struct sillyrename *sp; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ np = VTONFS(ap->a_vp); if (prtactive && ap->a_vp->v_usecount != 0) @@ -299,11 +299,11 @@ nfs_inactive(ap) * have our own reference. */ if (ap->a_vp->v_usecount > 0) - (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, p, 1); - else if (vget(ap->a_vp, 0, p)) + (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, td, 1); + else if (vget(ap->a_vp, 0, td)) panic("nfs_inactive: lost vnode"); else { - (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, p, 1); + (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, td, 1); vrele(ap->a_vp); } /* @@ -316,7 +316,7 @@ nfs_inactive(ap) } np->n_flag &= (NMODIFIED | NFLUSHINPROG | NFLUSHWANT | NQNFSEVICTED | NQNFSNONCACHE | NQNFSWRITE); - VOP_UNLOCK(ap->a_vp, 0, ap->a_p); + VOP_UNLOCK(ap->a_vp, 0, ap->a_td); return (0); } @@ -459,7 +459,7 @@ int nfs_islocked(ap) struct vop_islocked_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { return VTONFS(ap->a_vp)->n_flag & NLOCKED ? 1 : 0; diff --git a/sys/nfsclient/nfs_socket.c b/sys/nfsclient/nfs_socket.c index 5772e4b..8991672 100644 --- a/sys/nfsclient/nfs_socket.c +++ b/sys/nfsclient/nfs_socket.c @@ -149,7 +149,7 @@ int nfsrtton = 0; struct nfsrtt nfsrtt; struct callout_handle nfs_timer_handle; -static int nfs_msg __P((struct proc *,char *,char *)); +static int nfs_msg __P((struct thread *,char *,char *)); static int nfs_rcvlock __P((struct nfsreq *)); static void nfs_rcvunlock __P((struct nfsreq *)); static void nfs_realign __P((struct mbuf **pm, int hsiz)); @@ -162,7 +162,7 @@ static int nfsrv_getstream __P((struct nfssvc_sock *,int)); int (*nfsrv3_procs[NFS_NPROCS]) __P((struct nfsrv_descript *nd, struct nfssvc_sock *slp, - struct proc *procp, + struct thread *td, struct mbuf **mreqp)) = { nfsrv_null, nfsrv_getattr, @@ -207,12 +207,12 @@ nfs_connect(nmp, rep) int pktscale; struct sockaddr *saddr; struct sockaddr_in *sin; - struct proc *p = &proc0; /* only used for socreate and sobind */ + struct thread *td = thread0; /* only used for socreate and sobind */ nmp->nm_so = (struct socket *)0; saddr = nmp->nm_nam; error = socreate(saddr->sa_family, &nmp->nm_so, nmp->nm_sotype, - nmp->nm_soproto, p); + nmp->nm_soproto, td); if (error) goto bad; so = nmp->nm_so; @@ -233,7 +233,7 @@ nfs_connect(nmp, rep) sopt.sopt_name = IP_PORTRANGE; sopt.sopt_val = (void *)&ip; sopt.sopt_valsize = sizeof(ip); - sopt.sopt_p = NULL; + sopt.sopt_td = NULL; error = sosetopt(so, &sopt); if (error) goto bad; @@ -243,7 +243,7 @@ nfs_connect(nmp, rep) sin->sin_family = AF_INET; sin->sin_addr.s_addr = INADDR_ANY; sin->sin_port = htons(0); - error = sobind(so, (struct sockaddr *)sin, p); + error = sobind(so, (struct sockaddr *)sin, td); if (error) goto bad; bzero(&sopt, sizeof sopt); @@ -253,7 +253,7 @@ nfs_connect(nmp, rep) sopt.sopt_name = IP_PORTRANGE; sopt.sopt_val = (void *)&ip; sopt.sopt_valsize = sizeof(ip); - sopt.sopt_p = NULL; + sopt.sopt_td = NULL; error = sosetopt(so, &sopt); if (error) goto bad; @@ -269,7 +269,7 @@ nfs_connect(nmp, rep) goto bad; } } else { - error = soconnect(so, nmp->nm_nam, p); + error = soconnect(so, nmp->nm_nam, td); if (error) goto bad; @@ -284,7 +284,8 @@ nfs_connect(nmp, rep) "nfscon", 2 * hz); if ((so->so_state & SS_ISCONNECTING) && so->so_error == 0 && rep && - (error = nfs_sigintr(nmp, rep, rep->r_procp)) != 0){ + (error = nfs_sigintr(nmp, rep, + (rep->r_td ? rep->r_td->td_proc : NULL))) != 0){ so->so_state &= ~SS_ISCONNECTING; splx(s); goto bad; @@ -489,7 +490,7 @@ nfs_send(so, nam, top, rep) flags = 0; error = so->so_proto->pr_usrreqs->pru_sosend(so, sendnam, 0, top, 0, - flags, curproc /*XXX*/); + flags, curthread /*XXX*/); /* * ENOBUFS for dgram sockets is transient and non fatal. * No need to log, and no need to break a soft mount. @@ -547,7 +548,7 @@ nfs_receive(rep, aname, mp) u_int32_t len; struct sockaddr **getnam; int error, sotype, rcvflg; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ /* * Set up arguments for soreceive() @@ -614,7 +615,7 @@ tryagain: auio.uio_rw = UIO_READ; auio.uio_offset = 0; auio.uio_resid = sizeof(u_int32_t); - auio.uio_procp = p; + auio.uio_td = td; do { rcvflg = MSG_WAITALL; error = so->so_proto->pr_usrreqs->pru_soreceive @@ -682,7 +683,7 @@ tryagain: * on. */ auio.uio_resid = len = 100000000; /* Anything Big */ - auio.uio_procp = p; + auio.uio_td = td; do { rcvflg = 0; error = so->so_proto->pr_usrreqs->pru_soreceive @@ -727,7 +728,7 @@ errout: else getnam = aname; auio.uio_resid = len = 1000000; - auio.uio_procp = p; + auio.uio_td = td; do { rcvflg = 0; error = so->so_proto->pr_usrreqs->pru_soreceive @@ -937,11 +938,11 @@ nfsmout: * nb: always frees up mreq mbuf list */ int -nfs_request(vp, mrest, procnum, procp, cred, mrp, mdp, dposp) +nfs_request(vp, mrest, procnum, td, cred, mrp, mdp, dposp) struct vnode *vp; struct mbuf *mrest; int procnum; - struct proc *procp; + struct thread *td; struct ucred *cred; struct mbuf **mrp; struct mbuf **mdp; @@ -969,7 +970,7 @@ nfs_request(vp, mrest, procnum, procp, cred, mrp, mdp, dposp) MALLOC(rep, struct nfsreq *, sizeof(struct nfsreq), M_NFSREQ, M_WAITOK); rep->r_nmp = nmp; rep->r_vp = vp; - rep->r_procp = procp; + rep->r_td = td; rep->r_procnum = procnum; i = 0; m = mrest; @@ -1100,7 +1101,7 @@ tryagain: * tprintf a response. */ if (!error && (rep->r_flags & R_TPRINTFMSG)) - nfs_msg(rep->r_procp, nmp->nm_mountp->mnt_stat.f_mntfromname, + nfs_msg(rep->r_td, nmp->nm_mountp->mnt_stat.f_mntfromname, "is alive again"); mrep = rep->r_mrep; md = rep->r_md; @@ -1394,14 +1395,15 @@ nfs_timer(arg) register struct nfssvc_sock *slp; u_quad_t cur_usec; #endif /* NFS_NOSERVER */ - struct proc *p = &proc0; /* XXX for credentials, will break if sleep */ + struct thread *td = thread0; /* XXX for credentials, will break if sleep */ s = splnet(); for (rep = nfs_reqq.tqh_first; rep != 0; rep = rep->r_chain.tqe_next) { nmp = rep->r_nmp; if (rep->r_mrep || (rep->r_flags & R_SOFTTERM)) continue; - if (nfs_sigintr(nmp, rep, rep->r_procp)) { + if (nfs_sigintr(nmp, rep, + (rep->r_td ? rep->r_td->td_proc : NULL))) { nfs_softterm(rep); continue; } @@ -1423,7 +1425,7 @@ nfs_timer(arg) */ if ((rep->r_flags & R_TPRINTFMSG) == 0 && rep->r_rexmit > nmp->nm_deadthresh) { - nfs_msg(rep->r_procp, + nfs_msg(rep->r_td, nmp->nm_mountp->mnt_stat.f_mntfromname, "not responding"); rep->r_flags |= R_TPRINTFMSG; @@ -1455,11 +1457,11 @@ nfs_timer(arg) if ((nmp->nm_flag & NFSMNT_NOCONN) == 0) error = (*so->so_proto->pr_usrreqs->pru_send) (so, 0, m, (struct sockaddr *)0, - (struct mbuf *)0, p); + (struct mbuf *)0, td); else error = (*so->so_proto->pr_usrreqs->pru_send) (so, 0, m, nmp->nm_nam, (struct mbuf *)0, - p); + td); if (error) { if (NFSIGNORE_SOERROR(nmp->nm_soflags, error)) so->so_error = 0; @@ -1566,17 +1568,17 @@ nfs_sndlock(rep) struct nfsreq *rep; { register int *statep = &rep->r_nmp->nm_state; - struct proc *p; + struct thread *td; int slpflag = 0, slptimeo = 0; if (rep) { - p = rep->r_procp; + td = rep->r_td; if (rep->r_nmp->nm_flag & NFSMNT_INT) slpflag = PCATCH; } else - p = (struct proc *)0; + td = (struct thread *)0; while (*statep & NFSSTA_SNDLOCK) { - if (nfs_sigintr(rep->r_nmp, rep, p)) + if (nfs_sigintr(rep->r_nmp, rep, td ? td->td_proc : NULL)) return (EINTR); *statep |= NFSSTA_WANTSND; (void) tsleep((caddr_t)statep, slpflag | (PZERO - 1), @@ -1620,7 +1622,8 @@ nfs_rcvlock(rep) else slpflag = 0; while (*statep & NFSSTA_RCVLOCK) { - if (nfs_sigintr(rep->r_nmp, rep, rep->r_procp)) + if (nfs_sigintr(rep->r_nmp, rep, + (rep->r_td ? rep->r_td->td_proc : NULL))) return (EINTR); *statep |= NFSSTA_WANTRCV; (void) tsleep((caddr_t)statep, slpflag | (PZERO - 1), "nfsrcvlk", @@ -1966,12 +1969,12 @@ nfsmout: #endif static int -nfs_msg(p, server, msg) - struct proc *p; +nfs_msg(td, server, msg) + struct thread *td; char *server, *msg; { - tprintf(p, LOG_INFO, "nfs server %s: %s\n", server, msg); + tprintf(td->td_proc, LOG_INFO, "nfs server %s: %s\n", server, msg); return (0); } @@ -2005,7 +2008,7 @@ nfsrv_rcv(so, arg, waitflag) slp->ns_flag |= SLP_NEEDQ; goto dorecs; } #endif - auio.uio_procp = NULL; + auio.uio_td = NULL; if (so->so_type == SOCK_STREAM) { /* * If there are already records on the queue, defer soreceive() diff --git a/sys/nfsclient/nfs_subs.c b/sys/nfsclient/nfs_subs.c index ad8891c..4425129 100644 --- a/sys/nfsclient/nfs_subs.c +++ b/sys/nfsclient/nfs_subs.c @@ -554,11 +554,11 @@ extern struct nfsnodehashhead *nfsnodehashtbl; extern u_long nfsnodehash; struct nfssvc_args; -extern int nfssvc(struct proc *, struct nfssvc_args *, int *); +extern int nfssvc(struct thread *, struct nfssvc_args *, int *); LIST_HEAD(nfsnodehashhead, nfsnode); -int nfs_webnamei __P((struct nameidata *, struct vnode *, struct proc *)); +int nfs_webnamei __P((struct nameidata *, struct vnode *, struct thread *)); u_quad_t nfs_curusec() @@ -950,7 +950,7 @@ nfsm_disct(mdp, dposp, siz, left, cp2) { register struct mbuf *mp, *mp2; register int siz2, xfer; - register caddr_t p; + register caddr_t ptr; mp = *mdp; while (left == 0) { @@ -973,10 +973,10 @@ nfsm_disct(mdp, dposp, siz, left, cp2) mp->m_next = mp2; mp->m_len -= left; mp = mp2; - *cp2 = p = mtod(mp, caddr_t); - bcopy(*dposp, p, left); /* Copy what was left */ + *cp2 = ptr = mtod(mp, caddr_t); + bcopy(*dposp, ptr, left); /* Copy what was left */ siz2 = siz-left; - p += left; + ptr += left; mp2 = mp->m_next; /* Loop around copying up the siz2 bytes */ while (siz2 > 0) { @@ -984,10 +984,10 @@ nfsm_disct(mdp, dposp, siz, left, cp2) return (EBADRPC); xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2; if (xfer > 0) { - bcopy(mtod(mp2, caddr_t), p, xfer); + bcopy(mtod(mp2, caddr_t), ptr, xfer); NFSMADV(mp2, xfer); mp2->m_len -= xfer; - p += xfer; + ptr += xfer; siz2 -= xfer; } if (siz2 > 0) @@ -1464,7 +1464,7 @@ nfs_getattrcache(vp, vaper) * released by the caller. */ int -nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) +nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, td, kerbflag, pubflag) register struct nameidata *ndp; fhandle_t *fhp; int len; @@ -1473,7 +1473,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) struct mbuf **mdp; caddr_t *dposp; struct vnode **retdirp; - struct proc *p; + struct thread *td; int kerbflag, pubflag; { register int i, rem; @@ -1613,7 +1613,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) * becuase lookup() will dereference ni_startdir. */ - cnp->cn_proc = p; + cnp->cn_thread = td; VREF(dp); ndp->ni_startdir = dp; @@ -1649,7 +1649,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) * Validate symlink */ if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1) - VOP_UNLOCK(ndp->ni_dvp, 0, p); + VOP_UNLOCK(ndp->ni_dvp, 0, td); if (!pubflag) { error = EINVAL; goto badlink2; @@ -1670,7 +1670,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) auio.uio_offset = 0; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = (struct proc *)0; + auio.uio_td = (struct thread *)0; auio.uio_resid = MAXPATHLEN; error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred); if (error) { @@ -1924,7 +1924,7 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag, pubflag) int kerbflag; int pubflag; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ register struct mount *mp; register int i; struct ucred *credanon; @@ -1988,7 +1988,7 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag, pubflag) nfsrv_object_create(*vpp); if (!lockflag) - VOP_UNLOCK(*vpp, 0, p); + VOP_UNLOCK(*vpp, 0, td); return (0); } @@ -2196,8 +2196,8 @@ nfsrv_object_create(vp) if (vp == NULL || vp->v_type != VREG) return (1); - return (vfs_object_create(vp, curproc, - curproc ? curproc->p_ucred : NULL)); + return (vfs_object_create(vp, curthread, + curthread ? curthread->td_proc->p_ucred : NULL)); } /* diff --git a/sys/nfsclient/nfs_vfsops.c b/sys/nfsclient/nfs_vfsops.c index bc6f3c0..c70600f 100644 --- a/sys/nfsclient/nfs_vfsops.c +++ b/sys/nfsclient/nfs_vfsops.c @@ -101,14 +101,14 @@ static void nfs_decode_args __P((struct nfsmount *nmp, static int mountnfs __P((struct nfs_args *,struct mount *, struct sockaddr *,char *,char *,struct vnode **)); static int nfs_mount __P(( struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p)); + struct nameidata *ndp, struct thread *p)); static int nfs_unmount __P(( struct mount *mp, int mntflags, - struct proc *p)); + struct thread *p)); static int nfs_root __P(( struct mount *mp, struct vnode **vpp)); static int nfs_statfs __P(( struct mount *mp, struct statfs *sbp, - struct proc *p)); + struct thread *p)); static int nfs_sync __P(( struct mount *mp, int waitfor, - struct ucred *cred, struct proc *p)); + struct ucred *cred, struct thread *p)); /* * nfs vfs operations. @@ -161,7 +161,7 @@ SYSCTL_OPAQUE(_vfs_nfs, OID_AUTO, diskless_swapaddr, CTLFLAG_RD, void nfsargs_ntoh __P((struct nfs_args *)); static int nfs_mountdiskless __P((char *, char *, int, struct sockaddr_in *, struct nfs_args *, - struct proc *, struct vnode **, + struct thread *, struct vnode **, struct mount **)); static void nfs_convert_diskless __P((void)); static void nfs_convert_oargs __P((struct nfs_args *args, @@ -241,10 +241,10 @@ nfs_convert_diskless() * nfs statfs call */ int -nfs_statfs(mp, sbp, p) +nfs_statfs(mp, sbp, td) struct mount *mp; register struct statfs *sbp; - struct proc *p; + struct thread *td; { register struct vnode *vp; register struct nfs_statfs *sfp; @@ -266,11 +266,11 @@ nfs_statfs(mp, sbp, p) return (error); vp = NFSTOV(np); if (v3 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) - (void)nfs_fsinfo(nmp, vp, p->p_ucred, p); + (void)nfs_fsinfo(nmp, vp, td->td_proc->p_ucred, td); nfsstats.rpccnt[NFSPROC_FSSTAT]++; nfsm_reqhead(vp, NFSPROC_FSSTAT, NFSX_FH(v3)); nfsm_fhtom(vp, v3); - nfsm_request(vp, NFSPROC_FSSTAT, p, p->p_ucred); + nfsm_request(vp, NFSPROC_FSSTAT, td, td->td_proc->p_ucred); if (v3) nfsm_postop_attr(vp, retattr); if (error) { @@ -315,11 +315,11 @@ nfs_statfs(mp, sbp, p) * nfs version 3 fsinfo rpc call */ int -nfs_fsinfo(nmp, vp, cred, p) +nfs_fsinfo(nmp, vp, cred, td) register struct nfsmount *nmp; register struct vnode *vp; struct ucred *cred; - struct proc *p; + struct thread *td; { register struct nfsv3_fsinfo *fsp; register caddr_t cp; @@ -333,7 +333,7 @@ nfs_fsinfo(nmp, vp, cred, p) nfsstats.rpccnt[NFSPROC_FSINFO]++; nfsm_reqhead(vp, NFSPROC_FSINFO, NFSX_FH(1)); nfsm_fhtom(vp, 1); - nfsm_request(vp, NFSPROC_FSINFO, p, cred); + nfsm_request(vp, NFSPROC_FSINFO, td, cred); nfsm_postop_attr(vp, retattr); if (!error) { nfsm_dissect(fsp, struct nfsv3_fsinfo *, NFSX_V3FSINFO); @@ -394,7 +394,7 @@ nfs_mountroot(mp) struct nfsv3_diskless *nd = &nfsv3_diskless; struct socket *so; struct vnode *vp; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ int error, i; u_long l; char buf[128]; @@ -433,7 +433,7 @@ nfs_mountroot(mp) * Do enough of ifconfig(8) so that the critical net interface can * talk to the server. */ - error = socreate(nd->myif.ifra_addr.sa_family, &so, SOCK_DGRAM, 0, p); + error = socreate(nd->myif.ifra_addr.sa_family, &so, SOCK_DGRAM, 0, td); if (error) panic("nfs_mountroot: socreate(%04x): %d", nd->myif.ifra_addr.sa_family, error); @@ -449,12 +449,12 @@ nfs_mountroot(mp) nd->myif.ifra_name[i] >= '0' && nd->myif.ifra_name[i] <= '9'; nd->myif.ifra_name[i] ++) { - error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, p); + error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td); if(!error) break; } #endif - error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, p); + error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td); if (error) panic("nfs_mountroot: SIOCAIFADDR: %d", error); soclose(so); @@ -488,7 +488,7 @@ nfs_mountroot(mp) (l >> 8) & 0xff, (l >> 0) & 0xff,nd->root_hostnam); printf("NFS ROOT: %s\n",buf); if ((error = nfs_mountdiskless(buf, "/", MNT_RDONLY, - &nd->root_saddr, &nd->root_args, p, &vp, &mp)) != 0) { + &nd->root_saddr, &nd->root_args, td, &vp, &mp)) != 0) { if (swap_mp) { mp->mnt_vfc->vfc_refcount--; free(swap_mp, M_MOUNT); @@ -514,9 +514,9 @@ nfs_mountroot(mp) (l >> 8) & 0xff, (l >> 0) & 0xff,nd->swap_hostnam); printf("NFS SWAP: %s\n",buf); if ((error = nfs_mountdiskless(buf, "/swap", 0, - &nd->swap_saddr, &nd->swap_args, p, &vp, &swap_mp)) != 0) + &nd->swap_saddr, &nd->swap_args, td, &vp, &swap_mp)) != 0) return (error); - vfs_unbusy(swap_mp, p); + vfs_unbusy(swap_mp, td); VTONFS(vp)->n_size = VTONFS(vp)->n_vattr.va_size = nd->swap_nblks * DEV_BSIZE ; @@ -528,13 +528,13 @@ nfs_mountroot(mp) vp->v_type = VREG; vp->v_flag = 0; VREF(vp); - swaponvp(p, vp, NODEV, nd->swap_nblks); + swaponvp(td, vp, NODEV, nd->swap_nblks); } mp->mnt_flag |= MNT_ROOTFS; mp->mnt_vnodecovered = NULLVP; rootvp = vp; - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); /* * This is not really an nfs issue, but it is much easier to @@ -554,13 +554,13 @@ nfs_mountroot(mp) * Internal version of mount system call for diskless setup. */ static int -nfs_mountdiskless(path, which, mountflag, sin, args, p, vpp, mpp) +nfs_mountdiskless(path, which, mountflag, sin, args, td, vpp, mpp) char *path; char *which; int mountflag; struct sockaddr_in *sin; struct nfs_args *args; - struct proc *p; + struct thread *td; struct vnode **vpp; struct mount **mpp; { @@ -581,7 +581,7 @@ nfs_mountdiskless(path, which, mountflag, sin, args, p, vpp, mpp) if ((error = mountnfs(args, mp, nam, which, path, vpp)) != 0) { printf("nfs_mountroot: mount %s on %s: %d", path, which, error); mp->mnt_vfc->vfc_refcount--; - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); free(mp, M_MOUNT); FREE(nam, M_SONAME); return (error); @@ -750,12 +750,12 @@ nfs_decode_args(nmp, argp) */ /* ARGSUSED */ static int -nfs_mount(mp, path, data, ndp, p) +nfs_mount(mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { int error; struct nfs_args args; @@ -930,12 +930,12 @@ mountnfs(argp, mp, nam, pth, hst, vpp) * Get file attributes for the mountpoint. This has the side * effect of filling in (*vpp)->v_type with the correct value. */ - VOP_GETATTR(*vpp, &attrs, curproc->p_ucred, curproc); + VOP_GETATTR(*vpp, &attrs, curthread->td_proc->p_ucred, curthread); /* * Lose the lock but keep the ref. */ - VOP_UNLOCK(*vpp, 0, curproc); + VOP_UNLOCK(*vpp, 0, curthread); return (0); bad: @@ -949,10 +949,10 @@ bad: * unmount system call */ static int -nfs_unmount(mp, mntflags, p) +nfs_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { register struct nfsmount *nmp; int error, flags = 0; @@ -1027,11 +1027,11 @@ extern int syncprt; */ /* ARGSUSED */ static int -nfs_sync(mp, waitfor, cred, p) +nfs_sync(mp, waitfor, cred, td) struct mount *mp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { struct vnode *vp, *vnp; int error, allerror = 0; @@ -1059,11 +1059,11 @@ loop: mtx_lock(&mntvnode_mtx); continue; } - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) { + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) { mtx_lock(&mntvnode_mtx); goto loop; } - error = VOP_FSYNC(vp, cred, waitfor, p); + error = VOP_FSYNC(vp, cred, waitfor, td); if (error) allerror = error; vput(vp); diff --git a/sys/nfsclient/nfs_vnops.c b/sys/nfsclient/nfs_vnops.c index 5b84741..8f9ff7d 100644 --- a/sys/nfsclient/nfs_vnops.c +++ b/sys/nfsclient/nfs_vnops.c @@ -102,8 +102,8 @@ static int nfsfifo_write __P((struct vop_write_args *)); static int nfsspec_close __P((struct vop_close_args *)); static int nfsfifo_close __P((struct vop_close_args *)); #define nfs_poll vop_nopoll -static int nfs_flush __P((struct vnode *,struct ucred *,int,struct proc *,int)); -static int nfs_setattrrpc __P((struct vnode *,struct vattr *,struct ucred *,struct proc *)); +static int nfs_flush __P((struct vnode *,struct ucred *,int,struct thread *,int)); +static int nfs_setattrrpc __P((struct vnode *,struct vattr *,struct ucred *,struct thread *)); static int nfs_lookup __P((struct vop_lookup_args *)); static int nfs_create __P((struct vop_create_args *)); static int nfs_mknod __P((struct vop_mknod_args *)); @@ -123,7 +123,7 @@ static int nfs_symlink __P((struct vop_symlink_args *)); static int nfs_readdir __P((struct vop_readdir_args *)); static int nfs_strategy __P((struct vop_strategy_args *)); static int nfs_lookitup __P((struct vnode *, const char *, int, - struct ucred *, struct proc *, struct nfsnode **)); + struct ucred *, struct thread *, struct nfsnode **)); static int nfs_sillyrename __P((struct vnode *,struct vnode *,struct componentname *)); static int nfsspec_access __P((struct vop_access_args *)); static int nfs_readlink __P((struct vop_readlink_args *)); @@ -224,11 +224,11 @@ static int nfs_mknodrpc __P((struct vnode *dvp, struct vnode **vpp, struct vattr *vap)); static int nfs_removerpc __P((struct vnode *dvp, const char *name, int namelen, - struct ucred *cred, struct proc *proc)); + struct ucred *cred, struct thread *td)); static int nfs_renamerpc __P((struct vnode *fdvp, const char *fnameptr, int fnamelen, struct vnode *tdvp, const char *tnameptr, int tnamelen, - struct ucred *cred, struct proc *proc)); + struct ucred *cred, struct thread *td)); static int nfs_renameit __P((struct vnode *sdvp, struct componentname *scnp, struct sillyrename *sp)); @@ -268,7 +268,7 @@ SYSCTL_INT(_vfs_nfs, OID_AUTO, access_cache_misses, CTLFLAG_RD, static int nfs3_access_otw(struct vnode *vp, int wmode, - struct proc *p, + struct thread *td, struct ucred *cred) { const int v3 = 1; @@ -287,7 +287,7 @@ nfs3_access_otw(struct vnode *vp, nfsm_fhtom(vp, v3); nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED); *tl = txdr_unsigned(wmode); - nfsm_request(vp, NFSPROC_ACCESS, p, cred); + nfsm_request(vp, NFSPROC_ACCESS, td, cred); nfsm_postop_attr(vp, attrflag); if (!error) { nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED); @@ -312,7 +312,7 @@ nfs_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -383,7 +383,7 @@ nfs_access(ap) * Either a no, or a don't know. Go to the wire. */ nfsstats.accesscache_misses++; - error = nfs3_access_otw(vp, wmode, ap->a_p,ap->a_cred); + error = nfs3_access_otw(vp, wmode, ap->a_td,ap->a_cred); if (!error) { if ((np->n_mode & mode) != mode) { error = EACCES; @@ -416,7 +416,7 @@ nfs_access(ap) auio.uio_resid = 1; auio.uio_segflg = UIO_SYSSPACE; auio.uio_rw = UIO_READ; - auio.uio_procp = ap->a_p; + auio.uio_td = ap->a_td; if (vp->v_type == VREG) error = nfs_readrpc(vp, &auio, ap->a_cred); @@ -450,7 +450,7 @@ nfs_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -472,14 +472,14 @@ nfs_open(ap) if (NQNFS_CKINVALID(vp, np, ND_READ)) { do { error = nqnfs_getlease(vp, ND_READ, ap->a_cred, - ap->a_p); + ap->a_td); } while (error == NQNFS_EXPIRED); if (error) return (error); if (np->n_lrev != np->n_brev || (np->n_flag & NQNFSNONCACHE)) { if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, - ap->a_p, 1)) == EINTR) + ap->a_td, 1)) == EINTR) return (error); np->n_brev = np->n_lrev; } @@ -487,24 +487,24 @@ nfs_open(ap) } else { if (np->n_flag & NMODIFIED) { if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, - ap->a_p, 1)) == EINTR) + ap->a_td, 1)) == EINTR) return (error); np->n_attrstamp = 0; if (vp->v_type == VDIR) np->n_direofoffset = 0; - error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p); + error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_td); if (error) return (error); np->n_mtime = vattr.va_mtime.tv_sec; } else { - error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p); + error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_td); if (error) return (error); if (np->n_mtime != vattr.va_mtime.tv_sec) { if (vp->v_type == VDIR) np->n_direofoffset = 0; if ((error = nfs_vinvalbuf(vp, V_SAVE, - ap->a_cred, ap->a_p, 1)) == EINTR) + ap->a_cred, ap->a_td, 1)) == EINTR) return (error); np->n_mtime = vattr.va_mtime.tv_sec; } @@ -553,7 +553,7 @@ nfs_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -578,10 +578,10 @@ nfs_close(ap) * cannot clear it if we don't commit. */ int cm = nfsv3_commit_on_close ? 1 : 0; - error = nfs_flush(vp, ap->a_cred, MNT_WAIT, ap->a_p, cm); + error = nfs_flush(vp, ap->a_cred, MNT_WAIT, ap->a_td, cm); /* np->n_flag &= ~NMODIFIED; */ } else { - error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 1); + error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_td, 1); } np->n_attrstamp = 0; } @@ -602,7 +602,7 @@ nfs_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -628,7 +628,7 @@ nfs_getattr(ap) if (v3 && nfsaccess_cache_timeout > 0) { nfsstats.accesscache_misses++; - nfs3_access_otw(vp, NFSV3ACCESS_ALL, ap->a_p, ap->a_cred); + nfs3_access_otw(vp, NFSV3ACCESS_ALL, ap->a_td, ap->a_cred); if (nfs_getattrcache(vp, ap->a_vap) == 0) return (0); } @@ -636,7 +636,7 @@ nfs_getattr(ap) nfsstats.rpccnt[NFSPROC_GETATTR]++; nfsm_reqhead(vp, NFSPROC_GETATTR, NFSX_FH(v3)); nfsm_fhtom(vp, v3); - nfsm_request(vp, NFSPROC_GETATTR, ap->a_p, ap->a_cred); + nfsm_request(vp, NFSPROC_GETATTR, ap->a_td, ap->a_cred); if (!error) { nfsm_loadattr(vp, ap->a_vap); } @@ -654,7 +654,7 @@ nfs_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -708,10 +708,10 @@ nfs_setattr(ap) if (np->n_flag & NMODIFIED) { if (vap->va_size == 0) error = nfs_vinvalbuf(vp, 0, - ap->a_cred, ap->a_p, 1); + ap->a_cred, ap->a_td, 1); else error = nfs_vinvalbuf(vp, V_SAVE, - ap->a_cred, ap->a_p, 1); + ap->a_cred, ap->a_td, 1); if (error) { vnode_pager_setsize(vp, np->n_size); return (error); @@ -724,9 +724,9 @@ nfs_setattr(ap) vap->va_atime.tv_sec != VNOVAL) && (np->n_flag & NMODIFIED) && vp->v_type == VREG && (error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, - ap->a_p, 1)) == EINTR) + ap->a_td, 1)) == EINTR) return (error); - error = nfs_setattrrpc(vp, vap, ap->a_cred, ap->a_p); + error = nfs_setattrrpc(vp, vap, ap->a_cred, ap->a_td); if (error && vap->va_size != VNOVAL) { np->n_size = np->n_vattr.va_size = tsize; vnode_pager_setsize(vp, np->n_size); @@ -738,11 +738,11 @@ nfs_setattr(ap) * Do an nfs setattr rpc. */ static int -nfs_setattrrpc(vp, vap, cred, procp) +nfs_setattrrpc(vp, vap, cred, td) register struct vnode *vp; register struct vattr *vap; struct ucred *cred; - struct proc *procp; + struct thread *td; { register struct nfsv2_sattr *sp; register caddr_t cp; @@ -778,7 +778,7 @@ nfs_setattrrpc(vp, vap, cred, procp) txdr_nfsv2time(&vap->va_atime, &sp->sa_atime); txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime); } - nfsm_request(vp, NFSPROC_SETATTR, procp, cred); + nfsm_request(vp, NFSPROC_SETATTR, td, cred); if (v3) { nfsm_wcc_data(vp, wccflag); } else @@ -817,7 +817,7 @@ nfs_lookup(ap) struct nfsnode *np; int lockparent, wantparent, error = 0, attrflag, fhsize; int v3 = NFS_ISV3(dvp); - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; *vpp = NULLVP; cnp->cn_flags &= ~PDIRUNLOCK; @@ -834,7 +834,7 @@ nfs_lookup(ap) struct vattr vattr; int vpid; - if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, p)) != 0) { + if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, td)) != 0) { *vpp = NULLVP; return (error); } @@ -849,24 +849,24 @@ nfs_lookup(ap) VREF(newvp); error = 0; } else if (flags & ISDOTDOT) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); cnp->cn_flags |= PDIRUNLOCK; - error = vget(newvp, LK_EXCLUSIVE, p); + error = vget(newvp, LK_EXCLUSIVE, td); if (!error && lockparent && (flags & ISLASTCN)) { - error = vn_lock(dvp, LK_EXCLUSIVE, p); + error = vn_lock(dvp, LK_EXCLUSIVE, td); if (error == 0) cnp->cn_flags &= ~PDIRUNLOCK; } } else { - error = vget(newvp, LK_EXCLUSIVE, p); + error = vget(newvp, LK_EXCLUSIVE, td); if (!lockparent || error || !(flags & ISLASTCN)) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } } if (!error) { if (vpid == newvp->v_id) { - if (!VOP_GETATTR(newvp, &vattr, cnp->cn_cred, p) + if (!VOP_GETATTR(newvp, &vattr, cnp->cn_cred, td) && vattr.va_ctime.tv_sec == VTONFS(newvp)->n_ctime) { nfsstats.lookupcache_hits++; if (cnp->cn_nameiop != LOOKUP && @@ -878,9 +878,9 @@ nfs_lookup(ap) } vput(newvp); if (lockparent && dvp != newvp && (flags & ISLASTCN)) - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); } - error = vn_lock(dvp, LK_EXCLUSIVE, p); + error = vn_lock(dvp, LK_EXCLUSIVE, td); *vpp = NULLVP; if (error) { cnp->cn_flags |= PDIRUNLOCK; @@ -897,7 +897,7 @@ nfs_lookup(ap) NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len)); nfsm_fhtom(dvp, v3); nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN); - nfsm_request(dvp, NFSPROC_LOOKUP, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_LOOKUP, cnp->cn_thread, cnp->cn_cred); if (error) { nfsm_postop_attr(dvp, attrflag); m_freem(mrep); @@ -928,22 +928,22 @@ nfs_lookup(ap) m_freem(mrep); cnp->cn_flags |= SAVENAME; if (!lockparent) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } return (0); } if (flags & ISDOTDOT) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); error = nfs_nget(dvp->v_mount, fhp, fhsize, &np); if (error) { - vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td); return (error); } newvp = NFSTOV(np); if (lockparent && (flags & ISLASTCN)) { - error = vn_lock(dvp, LK_EXCLUSIVE, p); + error = vn_lock(dvp, LK_EXCLUSIVE, td); if (error) { cnp->cn_flags |= PDIRUNLOCK; vput(newvp); @@ -962,7 +962,7 @@ nfs_lookup(ap) } if (!lockparent || !(flags & ISLASTCN)) { cnp->cn_flags |= PDIRUNLOCK; - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); } newvp = NFSTOV(np); } @@ -988,7 +988,7 @@ nfs_lookup(ap) if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) && (flags & ISLASTCN) && error == ENOENT) { if (!lockparent) { - VOP_UNLOCK(dvp, 0, p); + VOP_UNLOCK(dvp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } if (dvp->v_mount->mnt_flag & MNT_RDONLY) @@ -1061,7 +1061,7 @@ nfs_readlinkrpc(vp, uiop, cred) nfsstats.rpccnt[NFSPROC_READLINK]++; nfsm_reqhead(vp, NFSPROC_READLINK, NFSX_FH(v3)); nfsm_fhtom(vp, v3); - nfsm_request(vp, NFSPROC_READLINK, uiop->uio_procp, cred); + nfsm_request(vp, NFSPROC_READLINK, uiop->uio_td, cred); if (v3) nfsm_postop_attr(vp, attrflag); if (!error) { @@ -1117,7 +1117,7 @@ nfs_readrpc(vp, uiop, cred) *tl++ = txdr_unsigned(len); *tl = 0; } - nfsm_request(vp, NFSPROC_READ, uiop->uio_procp, cred); + nfsm_request(vp, NFSPROC_READ, uiop->uio_td, cred); if (v3) { nfsm_postop_attr(vp, attrflag); if (error) { @@ -1195,7 +1195,7 @@ nfs_writerpc(vp, uiop, cred, iomode, must_commit) *tl = x; /* size of this write */ } nfsm_uiotom(uiop, len); - nfsm_request(vp, NFSPROC_WRITE, uiop->uio_procp, cred); + nfsm_request(vp, NFSPROC_WRITE, uiop->uio_td, cred); if (v3) { wccflag = NFSV3_WCCCHK; nfsm_wcc_data(vp, wccflag); @@ -1288,7 +1288,7 @@ nfs_mknodrpc(dvp, vpp, cnp, vap) else { return (EOPNOTSUPP); } - if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc)) != 0) { + if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_thread)) != 0) { return (error); } nfsstats.rpccnt[NFSPROC_MKNOD]++; @@ -1314,7 +1314,7 @@ nfs_mknodrpc(dvp, vpp, cnp, vap) txdr_nfsv2time(&vap->va_atime, &sp->sa_atime); txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime); } - nfsm_request(dvp, NFSPROC_MKNOD, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_MKNOD, cnp->cn_thread, cnp->cn_cred); if (!error) { nfsm_mtofh(dvp, newvp, v3, gotvp); if (!gotvp) { @@ -1323,7 +1323,7 @@ nfs_mknodrpc(dvp, vpp, cnp, vap) newvp = (struct vnode *)0; } error = nfs_lookitup(dvp, cnp->cn_nameptr, - cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc, &np); + cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np); if (!error) newvp = NFSTOV(np); } @@ -1396,7 +1396,7 @@ nfs_create(ap) if (vap->va_type == VSOCK) return (nfs_mknodrpc(dvp, ap->a_vpp, cnp, vap)); - if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc)) != 0) { + if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_thread)) != 0) { return (error); } if (vap->va_vaflags & VA_EXCLUSIVE) @@ -1432,7 +1432,7 @@ again: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime); txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime); } - nfsm_request(dvp, NFSPROC_CREATE, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_CREATE, cnp->cn_thread, cnp->cn_cred); if (!error) { nfsm_mtofh(dvp, newvp, v3, gotvp); if (!gotvp) { @@ -1441,7 +1441,7 @@ again: newvp = (struct vnode *)0; } error = nfs_lookitup(dvp, cnp->cn_nameptr, - cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc, &np); + cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np); if (!error) newvp = NFSTOV(np); } @@ -1469,7 +1469,7 @@ again: vfs_timestamp(&vap->va_mtime); if (vap->va_atime.tv_sec == VNOVAL) vap->va_atime = vap->va_mtime; - error = nfs_setattrrpc(newvp, vap, cnp->cn_cred, cnp->cn_proc); + error = nfs_setattrrpc(newvp, vap, cnp->cn_cred, cnp->cn_thread); } if (!error) { if (cnp->cn_flags & MAKEENTRY) @@ -1518,7 +1518,7 @@ nfs_remove(ap) if (vp->v_type == VDIR) error = EPERM; else if (vp->v_usecount == 1 || (np->n_sillyrename && - VOP_GETATTR(vp, &vattr, cnp->cn_cred, cnp->cn_proc) == 0 && + VOP_GETATTR(vp, &vattr, cnp->cn_cred, cnp->cn_thread) == 0 && vattr.va_nlink > 1)) { /* * Purge the name cache so that the chance of a lookup for @@ -1532,11 +1532,11 @@ nfs_remove(ap) * throw away biocache buffers, mainly to avoid * unnecessary delayed writes later. */ - error = nfs_vinvalbuf(vp, 0, cnp->cn_cred, cnp->cn_proc, 1); + error = nfs_vinvalbuf(vp, 0, cnp->cn_cred, cnp->cn_thread, 1); /* Do the rpc */ if (error != EINTR) error = nfs_removerpc(dvp, cnp->cn_nameptr, - cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc); + cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread); /* * Kludge City: If the first reply to the remove rpc is lost.. * the reply to the retransmitted request will be ENOENT @@ -1560,19 +1560,19 @@ nfs_removeit(sp) { return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred, - (struct proc *)0)); + (struct thread *)0)); } /* * Nfs remove rpc, called from nfs_remove() and nfs_removeit(). */ static int -nfs_removerpc(dvp, name, namelen, cred, proc) +nfs_removerpc(dvp, name, namelen, cred, td) register struct vnode *dvp; const char *name; int namelen; struct ucred *cred; - struct proc *proc; + struct thread *td; { register u_int32_t *tl; register caddr_t cp; @@ -1587,7 +1587,7 @@ nfs_removerpc(dvp, name, namelen, cred, proc) NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(namelen)); nfsm_fhtom(dvp, v3); nfsm_strtom(name, namelen, NFS_MAXNAMLEN); - nfsm_request(dvp, NFSPROC_REMOVE, proc, cred); + nfsm_request(dvp, NFSPROC_REMOVE, td, cred); if (v3) nfsm_wcc_data(dvp, wccflag); nfsm_reqdone; @@ -1640,9 +1640,9 @@ nfs_rename(ap) * often. */ - VOP_FSYNC(fvp, fcnp->cn_cred, MNT_WAIT, fcnp->cn_proc); + VOP_FSYNC(fvp, fcnp->cn_cred, MNT_WAIT, fcnp->cn_thread); if (tvp) - VOP_FSYNC(tvp, tcnp->cn_cred, MNT_WAIT, tcnp->cn_proc); + VOP_FSYNC(tvp, tcnp->cn_cred, MNT_WAIT, tcnp->cn_thread); /* * If the tvp exists and is in use, sillyrename it before doing the @@ -1657,7 +1657,7 @@ nfs_rename(ap) error = nfs_renamerpc(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen, tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, tcnp->cn_cred, - tcnp->cn_proc); + tcnp->cn_thread); if (fvp->v_type == VDIR) { if (tvp != NULL && tvp->v_type == VDIR) @@ -1692,14 +1692,14 @@ nfs_renameit(sdvp, scnp, sp) register struct sillyrename *sp; { return (nfs_renamerpc(sdvp, scnp->cn_nameptr, scnp->cn_namelen, - sdvp, sp->s_name, sp->s_namlen, scnp->cn_cred, scnp->cn_proc)); + sdvp, sp->s_name, sp->s_namlen, scnp->cn_cred, scnp->cn_thread)); } /* * Do an nfs rename rpc. Called from nfs_rename() and nfs_renameit(). */ static int -nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, proc) +nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, td) register struct vnode *fdvp; const char *fnameptr; int fnamelen; @@ -1707,7 +1707,7 @@ nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, proc) const char *tnameptr; int tnamelen; struct ucred *cred; - struct proc *proc; + struct thread *td; { register u_int32_t *tl; register caddr_t cp; @@ -1725,7 +1725,7 @@ nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, proc) nfsm_strtom(fnameptr, fnamelen, NFS_MAXNAMLEN); nfsm_fhtom(tdvp, v3); nfsm_strtom(tnameptr, tnamelen, NFS_MAXNAMLEN); - nfsm_request(fdvp, NFSPROC_RENAME, proc, cred); + nfsm_request(fdvp, NFSPROC_RENAME, td, cred); if (v3) { nfsm_wcc_data(fdvp, fwccflag); nfsm_wcc_data(tdvp, twccflag); @@ -1771,7 +1771,7 @@ nfs_link(ap) * doesn't get "out of sync" with the server. * XXX There should be a better way! */ - VOP_FSYNC(vp, cnp->cn_cred, MNT_WAIT, cnp->cn_proc); + VOP_FSYNC(vp, cnp->cn_cred, MNT_WAIT, cnp->cn_thread); v3 = NFS_ISV3(vp); nfsstats.rpccnt[NFSPROC_LINK]++; @@ -1780,7 +1780,7 @@ nfs_link(ap) nfsm_fhtom(vp, v3); nfsm_fhtom(tdvp, v3); nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN); - nfsm_request(vp, NFSPROC_LINK, cnp->cn_proc, cnp->cn_cred); + nfsm_request(vp, NFSPROC_LINK, cnp->cn_thread, cnp->cn_cred); if (v3) { nfsm_postop_attr(vp, attrflag); nfsm_wcc_data(tdvp, wccflag); @@ -1852,7 +1852,7 @@ nfs_symlink(ap) * a file handle that can be converted into newvp without having * to do an extra lookup rpc. */ - nfsm_request(dvp, NFSPROC_SYMLINK, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_SYMLINK, cnp->cn_thread, cnp->cn_cred); if (v3) { if (error == 0) nfsm_mtofh(dvp, newvp, v3, gotvp); @@ -1882,7 +1882,7 @@ nfs_symlink(ap) struct nfsnode *np = NULL; error = nfs_lookitup(dvp, cnp->cn_nameptr, cnp->cn_namelen, - cnp->cn_cred, cnp->cn_proc, &np); + cnp->cn_cred, cnp->cn_thread, &np); if (!error) newvp = NFSTOV(np); } @@ -1927,7 +1927,7 @@ nfs_mkdir(ap) struct vattr vattr; int v3 = NFS_ISV3(dvp); - if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc)) != 0) { + if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_thread)) != 0) { return (error); } len = cnp->cn_namelen; @@ -1947,7 +1947,7 @@ nfs_mkdir(ap) txdr_nfsv2time(&vap->va_atime, &sp->sa_atime); txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime); } - nfsm_request(dvp, NFSPROC_MKDIR, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_MKDIR, cnp->cn_thread, cnp->cn_cred); if (!error) nfsm_mtofh(dvp, newvp, v3, gotvp); if (v3) @@ -1966,7 +1966,7 @@ nfs_mkdir(ap) newvp = (struct vnode *)0; } error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred, - cnp->cn_proc, &np); + cnp->cn_thread, &np); if (!error) { newvp = NFSTOV(np); if (newvp->v_type != VDIR) @@ -2010,7 +2010,7 @@ nfs_rmdir(ap) NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen)); nfsm_fhtom(dvp, v3); nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN); - nfsm_request(dvp, NFSPROC_RMDIR, cnp->cn_proc, cnp->cn_cred); + nfsm_request(dvp, NFSPROC_RMDIR, cnp->cn_thread, cnp->cn_cred); if (v3) nfsm_wcc_data(dvp, wccflag); nfsm_reqdone; @@ -2056,7 +2056,7 @@ nfs_readdir(ap) nfsstats.direofcache_hits++; return (0); } - } else if (VOP_GETATTR(vp, &vattr, ap->a_cred, uio->uio_procp) == 0 && + } else if (VOP_GETATTR(vp, &vattr, ap->a_cred, uio->uio_td) == 0 && np->n_mtime == vattr.va_mtime.tv_sec) { nfsstats.direofcache_hits++; return (0); @@ -2136,7 +2136,7 @@ nfs_readdirrpc(vp, uiop, cred) *tl++ = cookie.nfsuquad[0]; } *tl = txdr_unsigned(nmp->nm_readdirsize); - nfsm_request(vp, NFSPROC_READDIR, uiop->uio_procp, cred); + nfsm_request(vp, NFSPROC_READDIR, uiop->uio_td, cred); if (v3) { nfsm_postop_attr(vp, attrflag); if (!error) { @@ -2326,7 +2326,7 @@ nfs_readdirplusrpc(vp, uiop, cred) *tl++ = dnp->n_cookieverf.nfsuquad[1]; *tl++ = txdr_unsigned(nmp->nm_readdirsize); *tl = txdr_unsigned(nmp->nm_rsize); - nfsm_request(vp, NFSPROC_READDIRPLUS, uiop->uio_procp, cred); + nfsm_request(vp, NFSPROC_READDIRPLUS, uiop->uio_td, cred); nfsm_postop_attr(vp, attrflag); if (error) { m_freem(mrep); @@ -2525,12 +2525,12 @@ nfs_sillyrename(dvp, vp, cnp) VREF(dvp); /* Fudge together a funny name */ - pid = cnp->cn_proc->p_pid; + pid = cnp->cn_thread->td_proc->p_pid; sp->s_namlen = sprintf(sp->s_name, ".nfsA%04x4.4", pid); /* Try lookitups until we get one that isn't there */ while (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred, - cnp->cn_proc, (struct nfsnode **)0) == 0) { + cnp->cn_thread, (struct nfsnode **)0) == 0) { sp->s_name[4]++; if (sp->s_name[4] > 'z') { error = EINVAL; @@ -2541,7 +2541,7 @@ nfs_sillyrename(dvp, vp, cnp) if (error) goto bad; error = nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred, - cnp->cn_proc, &np); + cnp->cn_thread, &np); np->n_sillyrename = sp; return (0); bad: @@ -2560,12 +2560,12 @@ bad: * *npp != NULL --> update the file handle in the vnode */ static int -nfs_lookitup(dvp, name, len, cred, procp, npp) +nfs_lookitup(dvp, name, len, cred, td, npp) register struct vnode *dvp; const char *name; int len; struct ucred *cred; - struct proc *procp; + struct thread *td; struct nfsnode **npp; { register u_int32_t *tl; @@ -2584,7 +2584,7 @@ nfs_lookitup(dvp, name, len, cred, procp, npp) NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len)); nfsm_fhtom(dvp, v3); nfsm_strtom(name, len, NFS_MAXNAMLEN); - nfsm_request(dvp, NFSPROC_LOOKUP, procp, cred); + nfsm_request(dvp, NFSPROC_LOOKUP, td, cred); if (npp && !error) { nfsm_getfh(nfhp, fhlen, v3); if (*npp) { @@ -2640,12 +2640,12 @@ nfs_lookitup(dvp, name, len, cred, procp, npp) * Nfs Version 3 commit rpc */ int -nfs_commit(vp, offset, cnt, cred, procp) +nfs_commit(vp, offset, cnt, cred, td) struct vnode *vp; u_quad_t offset; int cnt; struct ucred *cred; - struct proc *procp; + struct thread *td; { register caddr_t cp; register u_int32_t *tl; @@ -2664,7 +2664,7 @@ nfs_commit(vp, offset, cnt, cred, procp) txdr_hyper(offset, tl); tl += 2; *tl = txdr_unsigned(cnt); - nfsm_request(vp, NFSPROC_COMMIT, procp, cred); + nfsm_request(vp, NFSPROC_COMMIT, td, cred); nfsm_wcc_data(vp, wccflag); if (!error) { nfsm_dissect(tl, u_int32_t *, NFSX_V3WRITEVERF); @@ -2691,7 +2691,7 @@ nfs_strategy(ap) { register struct buf *bp = ap->a_bp; struct ucred *cr; - struct proc *p; + struct thread *td; int error = 0; KASSERT(!(bp->b_flags & B_DONE), ("nfs_strategy: buffer %p unexpectedly marked B_DONE", bp)); @@ -2701,9 +2701,9 @@ nfs_strategy(ap) panic("nfs physio"); if (bp->b_flags & B_ASYNC) - p = (struct proc *)0; + td = (struct thread *)0; else - p = curproc; /* XXX */ + td = curthread; /* XXX */ if (bp->b_iocmd == BIO_READ) cr = bp->b_rcred; @@ -2716,8 +2716,8 @@ nfs_strategy(ap) * otherwise just do it ourselves. */ if ((bp->b_flags & B_ASYNC) == 0 || - nfs_asyncio(bp, NOCRED, p)) - error = nfs_doio(bp, cr, p); + nfs_asyncio(bp, NOCRED, td)) + error = nfs_doio(bp, cr, td); return (error); } @@ -2732,11 +2732,11 @@ nfs_fsync(ap) struct vnode * a_vp; struct ucred * a_cred; int a_waitfor; - struct proc * a_p; + struct thread * a_td; } */ *ap; { - return (nfs_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_p, 1)); + return (nfs_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_td, 1)); } /* @@ -2745,11 +2745,11 @@ nfs_fsync(ap) * associated with the vnode. */ static int -nfs_flush(vp, cred, waitfor, p, commit) +nfs_flush(vp, cred, waitfor, td, commit) register struct vnode *vp; struct ucred *cred; int waitfor; - struct proc *p; + struct thread *td; int commit; { register struct nfsnode *np = VTONFS(vp); @@ -2878,7 +2878,7 @@ again: */ if (wcred != NOCRED) retv = nfs_commit(vp, off, (int)(endoff - off), - wcred, p); + wcred, td); else { retv = 0; for (i = 0; i < bvecpos; i++) { @@ -2889,7 +2889,7 @@ again: size = (u_quad_t)(bp->b_dirtyend - bp->b_dirtyoff); retv = nfs_commit(vp, off, (int)size, - bp->b_wcred, p); + bp->b_wcred, td); if (retv) break; } } @@ -2949,7 +2949,7 @@ loop: panic("nfs_fsync: inconsistent lock"); if (error == ENOLCK) goto loop; - if (nfs_sigintr(nmp, (struct nfsreq *)0, p)) { + if (nfs_sigintr(nmp, (struct nfsreq *)0, td->td_proc)) { error = EINTR; goto done; } @@ -2985,7 +2985,7 @@ loop: error = tsleep((caddr_t)&vp->v_numoutput, slpflag | (PRIBIO + 1), "nfsfsync", slptimeo); if (error) { - if (nfs_sigintr(nmp, (struct nfsreq *)0, p)) { + if (nfs_sigintr(nmp, (struct nfsreq *)0, td->td_proc)) { error = EINTR; goto done; } @@ -3053,10 +3053,10 @@ nfs_print(ap) * We set B_CACHE if this is a VMIO buffer. */ int -nfs_writebp(bp, force, procp) +nfs_writebp(bp, force, td) register struct buf *bp; int force; - struct proc *procp; + struct thread *td; { int s; int oldflags = bp->b_flags; @@ -3086,7 +3086,7 @@ nfs_writebp(bp, force, procp) bp->b_iocmd = BIO_WRITE; bp->b_vp->v_numoutput++; - curproc->p_stats->p_ru.ru_oublock++; + curthread->td_proc->p_stats->p_ru.ru_oublock++; splx(s); /* @@ -3127,7 +3127,7 @@ nfsspec_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vattr *vap; @@ -3161,7 +3161,7 @@ nfsspec_access(ap) if (cred->cr_uid == 0) return (0); vap = &vattr; - error = VOP_GETATTR(vp, vap, cred, ap->a_p); + error = VOP_GETATTR(vp, vap, cred, ap->a_td); if (error) return (error); /* @@ -3238,7 +3238,7 @@ nfsspec_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -3254,7 +3254,7 @@ nfsspec_close(ap) vattr.va_atime = np->n_atim; if (np->n_flag & NUPD) vattr.va_mtime = np->n_mtim; - (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p); + (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_td); } } return (VOCALL(spec_vnodeop_p, VOFFSET(vop_close), ap)); @@ -3315,7 +3315,7 @@ nfsfifo_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -3337,7 +3337,7 @@ nfsfifo_close(ap) vattr.va_atime = np->n_atim; if (np->n_flag & NUPD) vattr.va_mtime = np->n_mtim; - (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p); + (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_td); } } return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_close), ap)); diff --git a/sys/nfsclient/nfsargs.h b/sys/nfsclient/nfsargs.h index 44d04b9..d5d0796 100644 --- a/sys/nfsclient/nfsargs.h +++ b/sys/nfsclient/nfsargs.h @@ -348,7 +348,7 @@ struct nfsreq { int r_timer; /* tick counter on reply */ u_int32_t r_procnum; /* NFS procedure number */ int r_rtt; /* RTT for rpc */ - struct proc *r_procp; /* Proc that did I/O system call */ + struct thread *r_td; /* Proc that did I/O system call */ }; /* @@ -469,7 +469,7 @@ struct nfsd { u_char nfsd_authstr[RPCAUTH_MAXSIZ]; /* Authenticator data */ int nfsd_verflen; /* and the Verifier */ u_char nfsd_verfstr[RPCVERF_MAXSIZ]; - struct proc *nfsd_procp; /* Proc ptr */ + struct thread *nfsd_td; /* daemon thread ptr */ struct nfsrv_descript *nfsd_nd; /* Associated nfsrv_descript */ }; @@ -592,16 +592,16 @@ void nfs_sndunlock __P((struct nfsreq *)); int nfs_slplock __P((struct nfssvc_sock *, int)); void nfs_slpunlock __P((struct nfssvc_sock *)); int nfs_disct __P((struct mbuf **, caddr_t *, int, int, caddr_t *)); -int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct proc *, +int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct thread *, int)); int nfs_readrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_writerpc __P((struct vnode *, struct uio *, struct ucred *, int *, int *)); int nfs_commit __P((struct vnode *vp, u_quad_t offset, int cnt, - struct ucred *cred, struct proc *procp)); + struct ucred *cred, struct thread *)); int nfs_readdirrpc __P((struct vnode *, struct uio *, struct ucred *)); -int nfs_asyncio __P((struct buf *, struct ucred *, struct proc *)); -int nfs_doio __P((struct buf *, struct ucred *, struct proc *)); +int nfs_asyncio __P((struct buf *, struct ucred *, struct thread *)); +int nfs_doio __P((struct buf *, struct ucred *, struct thread *)); int nfs_readlinkrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_sigintr __P((struct nfsmount *, struct nfsreq *, struct proc *)); int nfs_readdirplusrpc __P((struct vnode *, struct uio *, struct ucred *)); @@ -613,14 +613,14 @@ void nfsm_srvwcc __P((struct nfsrv_descript *, int, struct vattr *, int, void nfsm_srvpostopattr __P((struct nfsrv_descript *, int, struct vattr *, struct mbuf **, char **)); int netaddr_match __P((int, union nethostaddr *, struct sockaddr *)); -int nfs_request __P((struct vnode *, struct mbuf *, int, struct proc *, +int nfs_request __P((struct vnode *, struct mbuf *, int, struct thread *, struct ucred *, struct mbuf **, struct mbuf **, caddr_t *)); int nfs_loadattrcache __P((struct vnode **, struct mbuf **, caddr_t *, struct vattr *, int)); int nfs_namei __P((struct nameidata *, fhandle_t *, int, struct nfssvc_sock *, struct sockaddr *, struct mbuf **, - caddr_t *, struct vnode **, struct proc *, int, int)); + caddr_t *, struct vnode **, struct thread *, int, int)); void nfsm_adj __P((struct mbuf *, int, int)); int nfsm_mbuftouio __P((struct mbuf **, struct uio *, int, caddr_t *)); void nfsrv_initcache __P((void)); @@ -652,21 +652,21 @@ void nfs_clearcommit __P((struct mount *)); int nfsrv_errmap __P((struct nfsrv_descript *, int)); void nfsrvw_sort __P((gid_t *, int)); void nfsrv_setcred __P((struct ucred *, struct ucred *)); -int nfs_writebp __P((struct buf *, int, struct proc *)); +int nfs_writebp __P((struct buf *, int, struct thread *)); int nfsrv_object_create __P((struct vnode *)); void nfsrv_wakenfsd __P((struct nfssvc_sock *slp)); int nfsrv_writegather __P((struct nfsrv_descript **, struct nfssvc_sock *, - struct proc *, struct mbuf **)); + struct thread *, struct mbuf **)); int nfs_fsinfo __P((struct nfsmount *, struct vnode *, struct ucred *, - struct proc *p)); + struct thread *p)); int nfsrv3_access __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_commit __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_create __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_fhtovp __P((fhandle_t *, int, struct vnode **, struct ucred *, struct nfssvc_sock *, struct sockaddr *, int *, int, int)); @@ -674,52 +674,52 @@ int nfsrv_setpublicfs __P((struct mount *, struct netexport *, struct export_args *)); int nfs_ispublicfh __P((fhandle_t *)); int nfsrv_fsinfo __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_getattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_link __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_lookup __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mkdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mknod __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_noop __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_null __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_pathconf __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_read __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdirplus __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_readlink __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_remove __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rename __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rmdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_setattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_statfs __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_symlink __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_write __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); void nfsrv_rcv __P((struct socket *so, void *arg, int waitflag)); void nfsrv_slpderef __P((struct nfssvc_sock *slp)); #endif /* _KERNEL */ diff --git a/sys/nfsclient/nfsnode.h b/sys/nfsclient/nfsnode.h index 968f39c..ba99fea 100644 --- a/sys/nfsclient/nfsnode.h +++ b/sys/nfsclient/nfsnode.h @@ -171,16 +171,16 @@ extern struct nfsmount *nfs_iodmount[NFS_MAXASYNCDAEMON]; static __inline int -nfs_rslock(struct nfsnode *np, struct proc *p) +nfs_rslock(struct nfsnode *np, struct thread *td) { - return(lockmgr(&np->n_rslock, LK_EXCLUSIVE | LK_CANRECURSE | LK_SLEEPFAIL, NULL, p)); + return(lockmgr(&np->n_rslock, LK_EXCLUSIVE | LK_CANRECURSE | LK_SLEEPFAIL, NULL, td)); } static __inline void -nfs_rsunlock(struct nfsnode *np, struct proc *p) +nfs_rsunlock(struct nfsnode *np, struct thread *td) { - (void)lockmgr(&np->n_rslock, LK_RELEASE, NULL, p); + (void)lockmgr(&np->n_rslock, LK_RELEASE, NULL, td); } extern vop_t **fifo_nfsv2nodeop_p; diff --git a/sys/nfsclient/nfsstats.h b/sys/nfsclient/nfsstats.h index 44d04b9..d5d0796 100644 --- a/sys/nfsclient/nfsstats.h +++ b/sys/nfsclient/nfsstats.h @@ -348,7 +348,7 @@ struct nfsreq { int r_timer; /* tick counter on reply */ u_int32_t r_procnum; /* NFS procedure number */ int r_rtt; /* RTT for rpc */ - struct proc *r_procp; /* Proc that did I/O system call */ + struct thread *r_td; /* Proc that did I/O system call */ }; /* @@ -469,7 +469,7 @@ struct nfsd { u_char nfsd_authstr[RPCAUTH_MAXSIZ]; /* Authenticator data */ int nfsd_verflen; /* and the Verifier */ u_char nfsd_verfstr[RPCVERF_MAXSIZ]; - struct proc *nfsd_procp; /* Proc ptr */ + struct thread *nfsd_td; /* daemon thread ptr */ struct nfsrv_descript *nfsd_nd; /* Associated nfsrv_descript */ }; @@ -592,16 +592,16 @@ void nfs_sndunlock __P((struct nfsreq *)); int nfs_slplock __P((struct nfssvc_sock *, int)); void nfs_slpunlock __P((struct nfssvc_sock *)); int nfs_disct __P((struct mbuf **, caddr_t *, int, int, caddr_t *)); -int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct proc *, +int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct thread *, int)); int nfs_readrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_writerpc __P((struct vnode *, struct uio *, struct ucred *, int *, int *)); int nfs_commit __P((struct vnode *vp, u_quad_t offset, int cnt, - struct ucred *cred, struct proc *procp)); + struct ucred *cred, struct thread *)); int nfs_readdirrpc __P((struct vnode *, struct uio *, struct ucred *)); -int nfs_asyncio __P((struct buf *, struct ucred *, struct proc *)); -int nfs_doio __P((struct buf *, struct ucred *, struct proc *)); +int nfs_asyncio __P((struct buf *, struct ucred *, struct thread *)); +int nfs_doio __P((struct buf *, struct ucred *, struct thread *)); int nfs_readlinkrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_sigintr __P((struct nfsmount *, struct nfsreq *, struct proc *)); int nfs_readdirplusrpc __P((struct vnode *, struct uio *, struct ucred *)); @@ -613,14 +613,14 @@ void nfsm_srvwcc __P((struct nfsrv_descript *, int, struct vattr *, int, void nfsm_srvpostopattr __P((struct nfsrv_descript *, int, struct vattr *, struct mbuf **, char **)); int netaddr_match __P((int, union nethostaddr *, struct sockaddr *)); -int nfs_request __P((struct vnode *, struct mbuf *, int, struct proc *, +int nfs_request __P((struct vnode *, struct mbuf *, int, struct thread *, struct ucred *, struct mbuf **, struct mbuf **, caddr_t *)); int nfs_loadattrcache __P((struct vnode **, struct mbuf **, caddr_t *, struct vattr *, int)); int nfs_namei __P((struct nameidata *, fhandle_t *, int, struct nfssvc_sock *, struct sockaddr *, struct mbuf **, - caddr_t *, struct vnode **, struct proc *, int, int)); + caddr_t *, struct vnode **, struct thread *, int, int)); void nfsm_adj __P((struct mbuf *, int, int)); int nfsm_mbuftouio __P((struct mbuf **, struct uio *, int, caddr_t *)); void nfsrv_initcache __P((void)); @@ -652,21 +652,21 @@ void nfs_clearcommit __P((struct mount *)); int nfsrv_errmap __P((struct nfsrv_descript *, int)); void nfsrvw_sort __P((gid_t *, int)); void nfsrv_setcred __P((struct ucred *, struct ucred *)); -int nfs_writebp __P((struct buf *, int, struct proc *)); +int nfs_writebp __P((struct buf *, int, struct thread *)); int nfsrv_object_create __P((struct vnode *)); void nfsrv_wakenfsd __P((struct nfssvc_sock *slp)); int nfsrv_writegather __P((struct nfsrv_descript **, struct nfssvc_sock *, - struct proc *, struct mbuf **)); + struct thread *, struct mbuf **)); int nfs_fsinfo __P((struct nfsmount *, struct vnode *, struct ucred *, - struct proc *p)); + struct thread *p)); int nfsrv3_access __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_commit __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_create __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_fhtovp __P((fhandle_t *, int, struct vnode **, struct ucred *, struct nfssvc_sock *, struct sockaddr *, int *, int, int)); @@ -674,52 +674,52 @@ int nfsrv_setpublicfs __P((struct mount *, struct netexport *, struct export_args *)); int nfs_ispublicfh __P((fhandle_t *)); int nfsrv_fsinfo __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_getattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_link __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_lookup __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mkdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mknod __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_noop __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_null __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_pathconf __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_read __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdirplus __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_readlink __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_remove __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rename __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rmdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_setattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_statfs __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_symlink __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_write __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); void nfsrv_rcv __P((struct socket *so, void *arg, int waitflag)); void nfsrv_slpderef __P((struct nfssvc_sock *slp)); #endif /* _KERNEL */ diff --git a/sys/nfsserver/nfs.h b/sys/nfsserver/nfs.h index 44d04b9..d5d0796 100644 --- a/sys/nfsserver/nfs.h +++ b/sys/nfsserver/nfs.h @@ -348,7 +348,7 @@ struct nfsreq { int r_timer; /* tick counter on reply */ u_int32_t r_procnum; /* NFS procedure number */ int r_rtt; /* RTT for rpc */ - struct proc *r_procp; /* Proc that did I/O system call */ + struct thread *r_td; /* Proc that did I/O system call */ }; /* @@ -469,7 +469,7 @@ struct nfsd { u_char nfsd_authstr[RPCAUTH_MAXSIZ]; /* Authenticator data */ int nfsd_verflen; /* and the Verifier */ u_char nfsd_verfstr[RPCVERF_MAXSIZ]; - struct proc *nfsd_procp; /* Proc ptr */ + struct thread *nfsd_td; /* daemon thread ptr */ struct nfsrv_descript *nfsd_nd; /* Associated nfsrv_descript */ }; @@ -592,16 +592,16 @@ void nfs_sndunlock __P((struct nfsreq *)); int nfs_slplock __P((struct nfssvc_sock *, int)); void nfs_slpunlock __P((struct nfssvc_sock *)); int nfs_disct __P((struct mbuf **, caddr_t *, int, int, caddr_t *)); -int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct proc *, +int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct thread *, int)); int nfs_readrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_writerpc __P((struct vnode *, struct uio *, struct ucred *, int *, int *)); int nfs_commit __P((struct vnode *vp, u_quad_t offset, int cnt, - struct ucred *cred, struct proc *procp)); + struct ucred *cred, struct thread *)); int nfs_readdirrpc __P((struct vnode *, struct uio *, struct ucred *)); -int nfs_asyncio __P((struct buf *, struct ucred *, struct proc *)); -int nfs_doio __P((struct buf *, struct ucred *, struct proc *)); +int nfs_asyncio __P((struct buf *, struct ucred *, struct thread *)); +int nfs_doio __P((struct buf *, struct ucred *, struct thread *)); int nfs_readlinkrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_sigintr __P((struct nfsmount *, struct nfsreq *, struct proc *)); int nfs_readdirplusrpc __P((struct vnode *, struct uio *, struct ucred *)); @@ -613,14 +613,14 @@ void nfsm_srvwcc __P((struct nfsrv_descript *, int, struct vattr *, int, void nfsm_srvpostopattr __P((struct nfsrv_descript *, int, struct vattr *, struct mbuf **, char **)); int netaddr_match __P((int, union nethostaddr *, struct sockaddr *)); -int nfs_request __P((struct vnode *, struct mbuf *, int, struct proc *, +int nfs_request __P((struct vnode *, struct mbuf *, int, struct thread *, struct ucred *, struct mbuf **, struct mbuf **, caddr_t *)); int nfs_loadattrcache __P((struct vnode **, struct mbuf **, caddr_t *, struct vattr *, int)); int nfs_namei __P((struct nameidata *, fhandle_t *, int, struct nfssvc_sock *, struct sockaddr *, struct mbuf **, - caddr_t *, struct vnode **, struct proc *, int, int)); + caddr_t *, struct vnode **, struct thread *, int, int)); void nfsm_adj __P((struct mbuf *, int, int)); int nfsm_mbuftouio __P((struct mbuf **, struct uio *, int, caddr_t *)); void nfsrv_initcache __P((void)); @@ -652,21 +652,21 @@ void nfs_clearcommit __P((struct mount *)); int nfsrv_errmap __P((struct nfsrv_descript *, int)); void nfsrvw_sort __P((gid_t *, int)); void nfsrv_setcred __P((struct ucred *, struct ucred *)); -int nfs_writebp __P((struct buf *, int, struct proc *)); +int nfs_writebp __P((struct buf *, int, struct thread *)); int nfsrv_object_create __P((struct vnode *)); void nfsrv_wakenfsd __P((struct nfssvc_sock *slp)); int nfsrv_writegather __P((struct nfsrv_descript **, struct nfssvc_sock *, - struct proc *, struct mbuf **)); + struct thread *, struct mbuf **)); int nfs_fsinfo __P((struct nfsmount *, struct vnode *, struct ucred *, - struct proc *p)); + struct thread *p)); int nfsrv3_access __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_commit __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_create __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_fhtovp __P((fhandle_t *, int, struct vnode **, struct ucred *, struct nfssvc_sock *, struct sockaddr *, int *, int, int)); @@ -674,52 +674,52 @@ int nfsrv_setpublicfs __P((struct mount *, struct netexport *, struct export_args *)); int nfs_ispublicfh __P((fhandle_t *)); int nfsrv_fsinfo __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_getattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_link __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_lookup __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mkdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mknod __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_noop __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_null __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_pathconf __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_read __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdirplus __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_readlink __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_remove __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rename __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rmdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_setattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_statfs __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_symlink __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_write __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); void nfsrv_rcv __P((struct socket *so, void *arg, int waitflag)); void nfsrv_slpderef __P((struct nfssvc_sock *slp)); #endif /* _KERNEL */ diff --git a/sys/nfsserver/nfs_serv.c b/sys/nfsserver/nfs_serv.c index e015d17..0469388 100644 --- a/sys/nfsserver/nfs_serv.c +++ b/sys/nfsserver/nfs_serv.c @@ -145,7 +145,7 @@ SYSCTL_INT(_vfs_nfs, OID_AUTO, commit_blks, CTLFLAG_RW, &nfs_commit_blks, 0, "") SYSCTL_INT(_vfs_nfs, OID_AUTO, commit_miss, CTLFLAG_RW, &nfs_commit_miss, 0, ""); static int nfsrv_access __P((struct vnode *,int,struct ucred *,int, - struct proc *, int)); + struct thread *, int)); static void nfsrvw_coalesce __P((struct nfsrv_descript *, struct nfsrv_descript *)); @@ -168,10 +168,10 @@ ndclear(struct nameidata *nd) * nfs v3 access service */ int -nfsrv3_access(nfsd, slp, procp, mrq) +nfsrv3_access(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -208,7 +208,7 @@ nfsrv3_access(nfsd, slp, procp, mrq) } nfsmode = fxdr_unsigned(u_int32_t, *tl); if ((nfsmode & NFSV3ACCESS_READ) && - nfsrv_access(vp, VREAD, cred, rdonly, procp, 0)) + nfsrv_access(vp, VREAD, cred, rdonly, td, 0)) nfsmode &= ~NFSV3ACCESS_READ; if (vp->v_type == VDIR) testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND | @@ -216,16 +216,16 @@ nfsrv3_access(nfsd, slp, procp, mrq) else testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND); if ((nfsmode & testmode) && - nfsrv_access(vp, VWRITE, cred, rdonly, procp, 0)) + nfsrv_access(vp, VWRITE, cred, rdonly, td, 0)) nfsmode &= ~testmode; if (vp->v_type == VDIR) testmode = NFSV3ACCESS_LOOKUP; else testmode = NFSV3ACCESS_EXECUTE; if ((nfsmode & testmode) && - nfsrv_access(vp, VEXEC, cred, rdonly, procp, 0)) + nfsrv_access(vp, VEXEC, cred, rdonly, td, 0)) nfsmode &= ~testmode; - getret = VOP_GETATTR(vp, vap, cred, procp); + getret = VOP_GETATTR(vp, vap, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_POSTOPATTR(1) + NFSX_UNSIGNED); @@ -242,10 +242,10 @@ nfsmout: * nfs getattr service */ int -nfsrv_getattr(nfsd, slp, procp, mrq) +nfsrv_getattr(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -277,7 +277,7 @@ nfsrv_getattr(nfsd, slp, procp, mrq) goto nfsmout; } nqsrv_getl(vp, ND_READ); - error = VOP_GETATTR(vp, vap, cred, procp); + error = VOP_GETATTR(vp, vap, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_FATTR(nfsd->nd_flag & ND_NFSV3)); @@ -299,10 +299,10 @@ nfsmout: * nfs setattr service */ int -nfsrv_setattr(nfsd, slp, procp, mrq) +nfsrv_setattr(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -399,7 +399,7 @@ nfsrv_setattr(nfsd, slp, procp, mrq) nqsrv_getl(vp, ND_WRITE); if (v3) { - error = preat_ret = VOP_GETATTR(vp, &preat, cred, procp); + error = preat_ret = VOP_GETATTR(vp, &preat, cred, td); if (!error && gcheck && (preat.va_ctime.tv_sec != guard.tv_sec || preat.va_ctime.tv_nsec != guard.tv_nsec)) @@ -428,11 +428,11 @@ nfsrv_setattr(nfsd, slp, procp, mrq) error = EISDIR; goto out; } else if ((error = nfsrv_access(vp, VWRITE, cred, rdonly, - procp, 0)) != 0) + td, 0)) != 0) goto out; } - error = VOP_SETATTR(vp, vap, cred, procp); - postat_ret = VOP_GETATTR(vp, vap, cred, procp); + error = VOP_SETATTR(vp, vap, cred, td); + postat_ret = VOP_GETATTR(vp, vap, cred, td); if (!error) error = postat_ret; out: @@ -462,10 +462,10 @@ nfsmout: * nfs lookup rpc */ int -nfsrv_lookup(nfsd, slp, procp, mrq) +nfsrv_lookup(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -501,7 +501,7 @@ nfsrv_lookup(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = LOOKUP; nd.ni_cnd.cn_flags = LOCKLEAF | SAVESTART; error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), pubflag); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), pubflag); /* * namei failure, only dirp to cleanup. Clear out garbarge from @@ -512,7 +512,7 @@ nfsrv_lookup(nfsd, slp, procp, mrq) if (dirp) { if (v3) dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred, - procp); + td); vrele(dirp); dirp = NULL; } @@ -544,7 +544,7 @@ nfsrv_lookup(nfsd, slp, procp, mrq) * via the original nd. Confused? You aren't alone! */ ind = nd; - VOP_UNLOCK(nd.ni_vp, 0, procp); + VOP_UNLOCK(nd.ni_vp, 0, td); ind.ni_pathlen = strlen(nfs_pub.np_index); ind.ni_cnd.cn_nameptr = ind.ni_cnd.cn_pnbuf = nfs_pub.np_index; @@ -586,7 +586,7 @@ nfsrv_lookup(nfsd, slp, procp, mrq) if (dirp) { if (v3) dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred, - procp); + td); vrele(dirp); dirp = NULL; } @@ -624,7 +624,7 @@ nfsrv_lookup(nfsd, slp, procp, mrq) fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid; error = VFS_VPTOFH(vp, &fhp->fh_fid); if (!error) - error = VOP_GETATTR(vp, vap, cred, procp); + error = VOP_GETATTR(vp, vap, cred, td); vput(vp); ndp->ni_vp = NULL; @@ -658,10 +658,10 @@ nfsmout: * nfs readlink service */ int -nfsrv_readlink(nfsd, slp, procp, mrq) +nfsrv_readlink(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -720,7 +720,7 @@ nfsrv_readlink(nfsd, slp, procp, mrq) uiop->uio_resid = len; uiop->uio_rw = UIO_READ; uiop->uio_segflg = UIO_SYSSPACE; - uiop->uio_procp = (struct proc *)0; + uiop->uio_td = (struct thread *)0; error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE); if (error) { @@ -739,7 +739,7 @@ nfsrv_readlink(nfsd, slp, procp, mrq) nqsrv_getl(vp, ND_READ); error = VOP_READLINK(vp, uiop, cred); out: - getret = VOP_GETATTR(vp, &attr, cred, procp); + getret = VOP_GETATTR(vp, &attr, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_UNSIGNED); @@ -771,10 +771,10 @@ nfsmout: * nfs read service */ int -nfsrv_read(nfsd, slp, procp, mrq) +nfsrv_read(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -840,10 +840,10 @@ nfsrv_read(nfsd, slp, procp, mrq) } if (!error) { nqsrv_getl(vp, ND_READ); - if ((error = nfsrv_access(vp, VREAD, cred, rdonly, procp, 1)) != 0) - error = nfsrv_access(vp, VEXEC, cred, rdonly, procp, 1); + if ((error = nfsrv_access(vp, VREAD, cred, rdonly, td, 1)) != 0) + error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 1); } - getret = VOP_GETATTR(vp, vap, cred, procp); + getret = VOP_GETATTR(vp, vap, cred, td); if (!error) error = getret; if (error) { @@ -982,7 +982,7 @@ nfsrv_read(nfsd, slp, procp, mrq) off = uiop->uio_offset; nh->nh_nextr = off; FREE((caddr_t)iv2, M_TEMP); - if (error || (getret = VOP_GETATTR(vp, vap, cred, procp))) { + if (error || (getret = VOP_GETATTR(vp, vap, cred, td))) { if (!error) error = getret; m_freem(mreq); @@ -1022,10 +1022,10 @@ nfsmout: * nfs write service */ int -nfsrv_write(nfsd, slp, procp, mrq) +nfsrv_write(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -1137,7 +1137,7 @@ nfsrv_write(nfsd, slp, procp, mrq) goto nfsmout; } if (v3) - forat_ret = VOP_GETATTR(vp, &forat, cred, procp); + forat_ret = VOP_GETATTR(vp, &forat, cred, td); if (vp->v_type != VREG) { if (v3) error = EINVAL; @@ -1146,7 +1146,7 @@ nfsrv_write(nfsd, slp, procp, mrq) } if (!error) { nqsrv_getl(vp, ND_WRITE); - error = nfsrv_access(vp, VWRITE, cred, rdonly, procp, 1); + error = nfsrv_access(vp, VWRITE, cred, rdonly, td, 1); } if (error) { vput(vp); @@ -1188,13 +1188,13 @@ nfsrv_write(nfsd, slp, procp, mrq) uiop->uio_resid = len; uiop->uio_rw = UIO_WRITE; uiop->uio_segflg = UIO_SYSSPACE; - uiop->uio_procp = (struct proc *)0; + uiop->uio_td = (struct thread *)0; uiop->uio_offset = off; error = VOP_WRITE(vp, uiop, ioflags, cred); nfsstats.srvvop_writes++; FREE((caddr_t)iv, M_TEMP); } - aftat_ret = VOP_GETATTR(vp, vap, cred, procp); + aftat_ret = VOP_GETATTR(vp, vap, cred, td); vput(vp); vp = NULL; if (!error) @@ -1246,10 +1246,10 @@ nfsmout: * Jan. 1994. */ int -nfsrv_writegather(ndp, slp, procp, mrq) +nfsrv_writegather(ndp, slp, td, mrq) struct nfsrv_descript **ndp; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { register struct iovec *ivp; @@ -1427,7 +1427,7 @@ loop1: nfsd->nd_nam, &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE); if (!error) { if (v3) - forat_ret = VOP_GETATTR(vp, &forat, cred, procp); + forat_ret = VOP_GETATTR(vp, &forat, cred, td); if (vp->v_type != VREG) { if (v3) error = EINVAL; @@ -1439,7 +1439,7 @@ loop1: } if (!error) { nqsrv_getl(vp, ND_WRITE); - error = nfsrv_access(vp, VWRITE, cred, rdonly, procp, 1); + error = nfsrv_access(vp, VWRITE, cred, rdonly, td, 1); } if (nfsd->nd_stable == NFSV3WRITE_UNSTABLE) @@ -1450,7 +1450,7 @@ loop1: ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED); uiop->uio_rw = UIO_WRITE; uiop->uio_segflg = UIO_SYSSPACE; - uiop->uio_procp = (struct proc *)0; + uiop->uio_td = (struct thread *)0; uiop->uio_offset = nfsd->nd_off; uiop->uio_resid = nfsd->nd_eoff - nfsd->nd_off; if (uiop->uio_resid > 0) { @@ -1476,9 +1476,9 @@ loop1: } if (!error) { if (vn_start_write(vp, &mntp, V_NOWAIT) != 0) { - VOP_UNLOCK(vp, 0, procp); + VOP_UNLOCK(vp, 0, td); error = vn_start_write(NULL, &mntp, V_WAIT); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, procp); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); } } if (!error) { @@ -1490,7 +1490,7 @@ loop1: } m_freem(mrep); if (vp) { - aftat_ret = VOP_GETATTR(vp, &va, cred, procp); + aftat_ret = VOP_GETATTR(vp, &va, cred, td); vput(vp); vp = NULL; } @@ -1631,10 +1631,10 @@ nfsrvw_coalesce(owp, nfsd) * now does a truncate to 0 length via. setattr if it already exists */ int -nfsrv_create(nfsd, slp, procp, mrq) +nfsrv_create(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -1696,11 +1696,11 @@ nfsrv_create(nfsd, slp, procp, mrq) * prior to calling nfsm_reply ( which might goto nfsmout ). */ error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -1793,7 +1793,7 @@ nfsrv_create(nfsd, slp, procp, mrq) bcopy(cverf, (caddr_t)&vap->va_atime, NFSX_V3CREATEVERF); error = VOP_SETATTR(nd.ni_vp, vap, cred, - procp); + td); } } } else if ( @@ -1836,7 +1836,7 @@ nfsrv_create(nfsd, slp, procp, mrq) */ nd.ni_cnd.cn_nameiop = LOOKUP; nd.ni_cnd.cn_flags &= ~(LOCKPARENT); - nd.ni_cnd.cn_proc = procp; + nd.ni_cnd.cn_thread = td; nd.ni_cnd.cn_cred = cred; error = lookup(&nd); @@ -1857,14 +1857,14 @@ nfsrv_create(nfsd, slp, procp, mrq) } else { if (vap->va_size != -1) { error = nfsrv_access(nd.ni_vp, VWRITE, cred, - (nd.ni_cnd.cn_flags & RDONLY), procp, 0); + (nd.ni_cnd.cn_flags & RDONLY), td, 0); if (!error) { nqsrv_getl(nd.ni_vp, ND_WRITE); tempsize = vap->va_size; VATTR_NULL(vap); vap->va_size = tempsize; error = VOP_SETATTR(nd.ni_vp, vap, cred, - procp); + td); } } } @@ -1874,13 +1874,13 @@ nfsrv_create(nfsd, slp, procp, mrq) fhp->fh_fsid = nd.ni_vp->v_mount->mnt_stat.f_fsid; error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid); if (!error) - error = VOP_GETATTR(nd.ni_vp, vap, cred, procp); + error = VOP_GETATTR(nd.ni_vp, vap, cred, td); } if (v3) { if (exclusive_flag && !error && bcmp(cverf, (caddr_t)&vap->va_atime, NFSX_V3CREATEVERF)) error = EEXIST; - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); vrele(dirp); dirp = NULL; } @@ -1930,10 +1930,10 @@ nfsmout: * nfs v3 mknod service */ int -nfsrv_mknod(nfsd, slp, procp, mrq) +nfsrv_mknod(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -1986,9 +1986,9 @@ nfsrv_mknod(nfsd, slp, procp, mrq) */ error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) - dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, procp); + dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, td); if (error) { nfsm_reply(NFSX_WCCDATA(1)); nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft); @@ -2046,8 +2046,8 @@ nfsrv_mknod(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = LOOKUP; nd.ni_cnd.cn_flags &= ~(LOCKPARENT); - nd.ni_cnd.cn_proc = procp; - nd.ni_cnd.cn_cred = procp->p_ucred; + nd.ni_cnd.cn_thread = td; + nd.ni_cnd.cn_cred = td->td_proc->p_ucred; error = lookup(&nd); nd.ni_dvp = NULL; @@ -2080,12 +2080,12 @@ out: fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid; error = VFS_VPTOFH(vp, &fhp->fh_fid); if (!error) - error = VOP_GETATTR(vp, vap, cred, procp); + error = VOP_GETATTR(vp, vap, cred, td); vput(vp); vp = NULL; nd.ni_vp = NULL; } - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); if (dirp) { vrele(dirp); dirp = NULL; @@ -2121,10 +2121,10 @@ nfsmout: * nfs remove service */ int -nfsrv_remove(nfsd, slp, procp, mrq) +nfsrv_remove(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2169,11 +2169,11 @@ nfsrv_remove(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = DELETE; nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF; error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -2200,7 +2200,7 @@ out: } } if (dirp && v3) { - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); vrele(dirp); dirp = NULL; } @@ -2228,10 +2228,10 @@ nfsmout: * nfs rename service */ int -nfsrv_rename(nfsd, slp, procp, mrq) +nfsrv_rename(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2293,11 +2293,11 @@ nfsrv_rename(nfsd, slp, procp, mrq) fromnd.ni_cnd.cn_nameiop = DELETE; fromnd.ni_cnd.cn_flags = WANTPARENT | SAVESTART; error = nfs_namei(&fromnd, ffhp, len, slp, nam, &md, - &dpos, &fdirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dpos, &fdirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (fdirp) { if (v3) { fdirfor_ret = VOP_GETATTR(fdirp, &fdirfor, cred, - procp); + td); } else { vrele(fdirp); fdirp = NULL; @@ -2318,11 +2318,11 @@ nfsrv_rename(nfsd, slp, procp, mrq) tond.ni_cnd.cn_nameiop = RENAME; tond.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART; error = nfs_namei(&tond, tfhp, len2, slp, nam, &md, - &dpos, &tdirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dpos, &tdirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (tdirp) { if (v3) { tdirfor_ret = VOP_GETATTR(tdirp, &tdirfor, cred, - procp); + td); } else { vrele(tdirp); tdirp = NULL; @@ -2415,9 +2415,9 @@ out: out1: if (fdirp) - fdiraft_ret = VOP_GETATTR(fdirp, &fdiraft, cred, procp); + fdiraft_ret = VOP_GETATTR(fdirp, &fdiraft, cred, td); if (tdirp) - tdiraft_ret = VOP_GETATTR(tdirp, &tdiraft, cred, procp); + tdiraft_ret = VOP_GETATTR(tdirp, &tdiraft, cred, td); nfsm_reply(2 * NFSX_WCCDATA(v3)); if (v3) { nfsm_srvwcc_data(fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft); @@ -2465,10 +2465,10 @@ nfsmout: * nfs link service */ int -nfsrv_link(nfsd, slp, procp, mrq) +nfsrv_link(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2528,11 +2528,11 @@ nfsrv_link(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = CREATE; nd.ni_cnd.cn_flags = LOCKPARENT; error = nfs_namei(&nd, dfhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -2560,9 +2560,9 @@ out: out1: if (v3) - getret = VOP_GETATTR(vp, &at, cred, procp); + getret = VOP_GETATTR(vp, &at, cred, td); if (dirp) - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); ereply: nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3)); if (v3) { @@ -2594,10 +2594,10 @@ nfsmout: * nfs symbolic link service */ int -nfsrv_symlink(nfsd, slp, procp, mrq) +nfsrv_symlink(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2644,11 +2644,11 @@ nfsrv_symlink(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = CREATE; nd.ni_cnd.cn_flags = LOCKPARENT | SAVESTART; error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -2670,7 +2670,7 @@ nfsrv_symlink(nfsd, slp, procp, mrq) io.uio_iovcnt = 1; io.uio_segflg = UIO_SYSSPACE; io.uio_rw = UIO_READ; - io.uio_procp = (struct proc *)0; + io.uio_td = (struct thread *)0; nfsm_mtouio(&io, len2); if (!v3) { nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR); @@ -2712,7 +2712,7 @@ nfsrv_symlink(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = LOOKUP; nd.ni_cnd.cn_flags &= ~(LOCKPARENT | FOLLOW); nd.ni_cnd.cn_flags |= (NOFOLLOW | LOCKLEAF); - nd.ni_cnd.cn_proc = procp; + nd.ni_cnd.cn_thread = td; nd.ni_cnd.cn_cred = cred; error = lookup(&nd); @@ -2724,7 +2724,7 @@ nfsrv_symlink(nfsd, slp, procp, mrq) error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid); if (!error) error = VOP_GETATTR(nd.ni_vp, vap, cred, - procp); + td); vput(nd.ni_vp); nd.ni_vp = NULL; } @@ -2740,7 +2740,7 @@ out: pathcp = NULL; } if (dirp) { - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); vrele(dirp); dirp = NULL; } @@ -2784,10 +2784,10 @@ nfsmout: * nfs mkdir service */ int -nfsrv_mkdir(nfsd, slp, procp, mrq) +nfsrv_mkdir(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2836,11 +2836,11 @@ nfsrv_mkdir(nfsd, slp, procp, mrq) nd.ni_cnd.cn_flags = LOCKPARENT; error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -2890,11 +2890,11 @@ nfsrv_mkdir(nfsd, slp, procp, mrq) fhp->fh_fsid = nd.ni_vp->v_mount->mnt_stat.f_fsid; error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid); if (!error) - error = VOP_GETATTR(nd.ni_vp, vap, cred, procp); + error = VOP_GETATTR(nd.ni_vp, vap, cred, td); } out: if (dirp) - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); nfsm_reply(NFSX_SRVFH(v3) + NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3)); if (v3) { if (!error) { @@ -2935,10 +2935,10 @@ nfsmout: * nfs rmdir service */ int -nfsrv_rmdir(nfsd, slp, procp, mrq) +nfsrv_rmdir(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -2981,11 +2981,11 @@ nfsrv_rmdir(nfsd, slp, procp, mrq) nd.ni_cnd.cn_nameiop = DELETE; nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF; error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos, - &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE); + &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE); if (dirp) { if (v3) { dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, - procp); + td); } else { vrele(dirp); dirp = NULL; @@ -3027,7 +3027,7 @@ out: NDFREE(&nd, NDF_ONLY_PNBUF); if (dirp) - diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp); + diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td); nfsm_reply(NFSX_WCCDATA(v3)); if (v3) { nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft); @@ -3091,10 +3091,10 @@ struct flrep { }; int -nfsrv_readdir(nfsd, slp, procp, mrq) +nfsrv_readdir(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -3163,7 +3163,7 @@ nfsrv_readdir(nfsd, slp, procp, mrq) nqsrv_getl(vp, ND_READ); if (v3) { - error = getret = VOP_GETATTR(vp, &at, cred, procp); + error = getret = VOP_GETATTR(vp, &at, cred, td); #if 0 /* * XXX This check may be too strict for Solaris 2.5 clients. @@ -3173,7 +3173,7 @@ nfsrv_readdir(nfsd, slp, procp, mrq) #endif } if (!error) - error = nfsrv_access(vp, VEXEC, cred, rdonly, procp, 0); + error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 0); if (error) { vput(vp); vp = NULL; @@ -3182,7 +3182,7 @@ nfsrv_readdir(nfsd, slp, procp, mrq) error = 0; goto nfsmout; } - VOP_UNLOCK(vp, 0, procp); + VOP_UNLOCK(vp, 0, td); /* * end section. Allocate rbuf and continue @@ -3197,9 +3197,9 @@ again: io.uio_resid = fullsiz; io.uio_segflg = UIO_SYSSPACE; io.uio_rw = UIO_READ; - io.uio_procp = (struct proc *)0; + io.uio_td = (struct thread *)0; eofflag = 0; - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, procp); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (cookies) { free((caddr_t)cookies, M_TEMP); cookies = NULL; @@ -3209,11 +3209,11 @@ again: if (!cookies && !error) error = NFSERR_PERM; if (v3) { - getret = VOP_GETATTR(vp, &at, cred, procp); + getret = VOP_GETATTR(vp, &at, cred, td); if (!error) error = getret; } - VOP_UNLOCK(vp, 0, procp); + VOP_UNLOCK(vp, 0, td); if (error) { vrele(vp); vp = NULL; @@ -3384,10 +3384,10 @@ nfsmout: } int -nfsrv_readdirplus(nfsd, slp, procp, mrq) +nfsrv_readdirplus(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -3445,7 +3445,7 @@ nfsrv_readdirplus(nfsd, slp, procp, mrq) error = 0; goto nfsmout; } - error = getret = VOP_GETATTR(vp, &at, cred, procp); + error = getret = VOP_GETATTR(vp, &at, cred, td); #if 0 /* * XXX This check may be too strict for Solaris 2.5 clients. @@ -3455,7 +3455,7 @@ nfsrv_readdirplus(nfsd, slp, procp, mrq) #endif if (!error) { nqsrv_getl(vp, ND_READ); - error = nfsrv_access(vp, VEXEC, cred, rdonly, procp, 0); + error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 0); } if (error) { vput(vp); @@ -3465,7 +3465,7 @@ nfsrv_readdirplus(nfsd, slp, procp, mrq) error = 0; goto nfsmout; } - VOP_UNLOCK(vp, 0, procp); + VOP_UNLOCK(vp, 0, td); MALLOC(rbuf, caddr_t, siz, M_TEMP, M_WAITOK); again: iv.iov_base = rbuf; @@ -3476,17 +3476,17 @@ again: io.uio_resid = fullsiz; io.uio_segflg = UIO_SYSSPACE; io.uio_rw = UIO_READ; - io.uio_procp = (struct proc *)0; + io.uio_td = (struct thread *)0; eofflag = 0; - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, procp); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (cookies) { free((caddr_t)cookies, M_TEMP); cookies = NULL; } error = VOP_READDIR(vp, &io, cred, &eofflag, &ncookies, &cookies); off = (u_quad_t)io.uio_offset; - getret = VOP_GETATTR(vp, &at, cred, procp); - VOP_UNLOCK(vp, 0, procp); + getret = VOP_GETATTR(vp, &at, cred, td); + VOP_UNLOCK(vp, 0, td); if (!cookies && !error) error = NFSERR_PERM; if (!error) @@ -3603,7 +3603,7 @@ again: nvp = NULL; goto invalid; } - if (VOP_GETATTR(nvp, vap, cred, procp)) { + if (VOP_GETATTR(nvp, vap, cred, td)) { vput(nvp); nvp = NULL; goto invalid; @@ -3721,10 +3721,10 @@ nfsmout: * nfs commit service */ int -nfsrv_commit(nfsd, slp, procp, mrq) +nfsrv_commit(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -3778,7 +3778,7 @@ nfsrv_commit(nfsd, slp, procp, mrq) error = 0; goto nfsmout; } - for_ret = VOP_GETATTR(vp, &bfor, cred, procp); + for_ret = VOP_GETATTR(vp, &bfor, cred, td); if (cnt > MAX_COMMIT_COUNT) { /* @@ -3788,7 +3788,7 @@ nfsrv_commit(nfsd, slp, procp, mrq) (vp->v_object->flags & OBJ_MIGHTBEDIRTY)) { vm_object_page_clean(vp->v_object, 0, 0, OBJPC_SYNC); } - error = VOP_FSYNC(vp, cred, MNT_WAIT, procp); + error = VOP_FSYNC(vp, cred, MNT_WAIT, td); } else { /* * Locate and synchronously write any buffers that fall @@ -3846,7 +3846,7 @@ nfsrv_commit(nfsd, slp, procp, mrq) splx(s); } - aft_ret = VOP_GETATTR(vp, &aft, cred, procp); + aft_ret = VOP_GETATTR(vp, &aft, cred, td); vput(vp); vp = NULL; ereply: @@ -3872,10 +3872,10 @@ nfsmout: * nfs statfs service */ int -nfsrv_statfs(nfsd, slp, procp, mrq) +nfsrv_statfs(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -3913,8 +3913,8 @@ nfsrv_statfs(nfsd, slp, procp, mrq) goto nfsmout; } sf = &statfs; - error = VFS_STATFS(vp->v_mount, sf, procp); - getret = VOP_GETATTR(vp, &at, cred, procp); + error = VFS_STATFS(vp->v_mount, sf, td); + getret = VOP_GETATTR(vp, &at, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_STATFS(v3)); @@ -3959,10 +3959,10 @@ nfsmout: * nfs fsinfo service */ int -nfsrv_fsinfo(nfsd, slp, procp, mrq) +nfsrv_fsinfo(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -3999,10 +3999,10 @@ nfsrv_fsinfo(nfsd, slp, procp, mrq) } /* XXX Try to make a guess on the max file size. */ - VFS_STATFS(vp->v_mount, &sb, procp); + VFS_STATFS(vp->v_mount, &sb, td); maxfsize = (u_quad_t)0x80000000 * sb.f_bsize - 1; - getret = VOP_GETATTR(vp, &at, cred, procp); + getret = VOP_GETATTR(vp, &at, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3FSINFO); @@ -4041,10 +4041,10 @@ nfsmout: * nfs pathconf service */ int -nfsrv_pathconf(nfsd, slp, procp, mrq) +nfsrv_pathconf(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md; @@ -4086,7 +4086,7 @@ nfsrv_pathconf(nfsd, slp, procp, mrq) error = VOP_PATHCONF(vp, _PC_CHOWN_RESTRICTED, &chownres); if (!error) error = VOP_PATHCONF(vp, _PC_NO_TRUNC, ¬runc); - getret = VOP_GETATTR(vp, &at, cred, procp); + getret = VOP_GETATTR(vp, &at, cred, td); vput(vp); vp = NULL; nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3PATHCONF); @@ -4120,10 +4120,10 @@ nfsmout: */ /* ARGSUSED */ int -nfsrv_null(nfsd, slp, procp, mrq) +nfsrv_null(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep; @@ -4145,10 +4145,10 @@ nfsrv_null(nfsd, slp, procp, mrq) */ /* ARGSUSED */ int -nfsrv_noop(nfsd, slp, procp, mrq) +nfsrv_noop(nfsd, slp, td, mrq) struct nfsrv_descript *nfsd; struct nfssvc_sock *slp; - struct proc *procp; + struct thread *td; struct mbuf **mrq; { struct mbuf *mrep = nfsd->nd_mrep; @@ -4184,12 +4184,12 @@ nfsrv_noop(nfsd, slp, procp, mrq) * will return EPERM instead of EACCESS. EPERM is always an error. */ static int -nfsrv_access(vp, flags, cred, rdonly, p, override) +nfsrv_access(vp, flags, cred, rdonly, td, override) register struct vnode *vp; int flags; register struct ucred *cred; int rdonly; - struct proc *p; + struct thread *td; int override; { struct vattr vattr; @@ -4220,10 +4220,10 @@ nfsrv_access(vp, flags, cred, rdonly, p, override) if (vp->v_flag & VTEXT) return (ETXTBSY); } - error = VOP_GETATTR(vp, &vattr, cred, p); + error = VOP_GETATTR(vp, &vattr, cred, td); if (error) return (error); - error = VOP_ACCESS(vp, flags, cred, p); + error = VOP_ACCESS(vp, flags, cred, td); /* * Allow certain operations for the owner (reads and writes * on files that are already open). diff --git a/sys/nfsserver/nfs_srvsock.c b/sys/nfsserver/nfs_srvsock.c index 5772e4b..8991672 100644 --- a/sys/nfsserver/nfs_srvsock.c +++ b/sys/nfsserver/nfs_srvsock.c @@ -149,7 +149,7 @@ int nfsrtton = 0; struct nfsrtt nfsrtt; struct callout_handle nfs_timer_handle; -static int nfs_msg __P((struct proc *,char *,char *)); +static int nfs_msg __P((struct thread *,char *,char *)); static int nfs_rcvlock __P((struct nfsreq *)); static void nfs_rcvunlock __P((struct nfsreq *)); static void nfs_realign __P((struct mbuf **pm, int hsiz)); @@ -162,7 +162,7 @@ static int nfsrv_getstream __P((struct nfssvc_sock *,int)); int (*nfsrv3_procs[NFS_NPROCS]) __P((struct nfsrv_descript *nd, struct nfssvc_sock *slp, - struct proc *procp, + struct thread *td, struct mbuf **mreqp)) = { nfsrv_null, nfsrv_getattr, @@ -207,12 +207,12 @@ nfs_connect(nmp, rep) int pktscale; struct sockaddr *saddr; struct sockaddr_in *sin; - struct proc *p = &proc0; /* only used for socreate and sobind */ + struct thread *td = thread0; /* only used for socreate and sobind */ nmp->nm_so = (struct socket *)0; saddr = nmp->nm_nam; error = socreate(saddr->sa_family, &nmp->nm_so, nmp->nm_sotype, - nmp->nm_soproto, p); + nmp->nm_soproto, td); if (error) goto bad; so = nmp->nm_so; @@ -233,7 +233,7 @@ nfs_connect(nmp, rep) sopt.sopt_name = IP_PORTRANGE; sopt.sopt_val = (void *)&ip; sopt.sopt_valsize = sizeof(ip); - sopt.sopt_p = NULL; + sopt.sopt_td = NULL; error = sosetopt(so, &sopt); if (error) goto bad; @@ -243,7 +243,7 @@ nfs_connect(nmp, rep) sin->sin_family = AF_INET; sin->sin_addr.s_addr = INADDR_ANY; sin->sin_port = htons(0); - error = sobind(so, (struct sockaddr *)sin, p); + error = sobind(so, (struct sockaddr *)sin, td); if (error) goto bad; bzero(&sopt, sizeof sopt); @@ -253,7 +253,7 @@ nfs_connect(nmp, rep) sopt.sopt_name = IP_PORTRANGE; sopt.sopt_val = (void *)&ip; sopt.sopt_valsize = sizeof(ip); - sopt.sopt_p = NULL; + sopt.sopt_td = NULL; error = sosetopt(so, &sopt); if (error) goto bad; @@ -269,7 +269,7 @@ nfs_connect(nmp, rep) goto bad; } } else { - error = soconnect(so, nmp->nm_nam, p); + error = soconnect(so, nmp->nm_nam, td); if (error) goto bad; @@ -284,7 +284,8 @@ nfs_connect(nmp, rep) "nfscon", 2 * hz); if ((so->so_state & SS_ISCONNECTING) && so->so_error == 0 && rep && - (error = nfs_sigintr(nmp, rep, rep->r_procp)) != 0){ + (error = nfs_sigintr(nmp, rep, + (rep->r_td ? rep->r_td->td_proc : NULL))) != 0){ so->so_state &= ~SS_ISCONNECTING; splx(s); goto bad; @@ -489,7 +490,7 @@ nfs_send(so, nam, top, rep) flags = 0; error = so->so_proto->pr_usrreqs->pru_sosend(so, sendnam, 0, top, 0, - flags, curproc /*XXX*/); + flags, curthread /*XXX*/); /* * ENOBUFS for dgram sockets is transient and non fatal. * No need to log, and no need to break a soft mount. @@ -547,7 +548,7 @@ nfs_receive(rep, aname, mp) u_int32_t len; struct sockaddr **getnam; int error, sotype, rcvflg; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ /* * Set up arguments for soreceive() @@ -614,7 +615,7 @@ tryagain: auio.uio_rw = UIO_READ; auio.uio_offset = 0; auio.uio_resid = sizeof(u_int32_t); - auio.uio_procp = p; + auio.uio_td = td; do { rcvflg = MSG_WAITALL; error = so->so_proto->pr_usrreqs->pru_soreceive @@ -682,7 +683,7 @@ tryagain: * on. */ auio.uio_resid = len = 100000000; /* Anything Big */ - auio.uio_procp = p; + auio.uio_td = td; do { rcvflg = 0; error = so->so_proto->pr_usrreqs->pru_soreceive @@ -727,7 +728,7 @@ errout: else getnam = aname; auio.uio_resid = len = 1000000; - auio.uio_procp = p; + auio.uio_td = td; do { rcvflg = 0; error = so->so_proto->pr_usrreqs->pru_soreceive @@ -937,11 +938,11 @@ nfsmout: * nb: always frees up mreq mbuf list */ int -nfs_request(vp, mrest, procnum, procp, cred, mrp, mdp, dposp) +nfs_request(vp, mrest, procnum, td, cred, mrp, mdp, dposp) struct vnode *vp; struct mbuf *mrest; int procnum; - struct proc *procp; + struct thread *td; struct ucred *cred; struct mbuf **mrp; struct mbuf **mdp; @@ -969,7 +970,7 @@ nfs_request(vp, mrest, procnum, procp, cred, mrp, mdp, dposp) MALLOC(rep, struct nfsreq *, sizeof(struct nfsreq), M_NFSREQ, M_WAITOK); rep->r_nmp = nmp; rep->r_vp = vp; - rep->r_procp = procp; + rep->r_td = td; rep->r_procnum = procnum; i = 0; m = mrest; @@ -1100,7 +1101,7 @@ tryagain: * tprintf a response. */ if (!error && (rep->r_flags & R_TPRINTFMSG)) - nfs_msg(rep->r_procp, nmp->nm_mountp->mnt_stat.f_mntfromname, + nfs_msg(rep->r_td, nmp->nm_mountp->mnt_stat.f_mntfromname, "is alive again"); mrep = rep->r_mrep; md = rep->r_md; @@ -1394,14 +1395,15 @@ nfs_timer(arg) register struct nfssvc_sock *slp; u_quad_t cur_usec; #endif /* NFS_NOSERVER */ - struct proc *p = &proc0; /* XXX for credentials, will break if sleep */ + struct thread *td = thread0; /* XXX for credentials, will break if sleep */ s = splnet(); for (rep = nfs_reqq.tqh_first; rep != 0; rep = rep->r_chain.tqe_next) { nmp = rep->r_nmp; if (rep->r_mrep || (rep->r_flags & R_SOFTTERM)) continue; - if (nfs_sigintr(nmp, rep, rep->r_procp)) { + if (nfs_sigintr(nmp, rep, + (rep->r_td ? rep->r_td->td_proc : NULL))) { nfs_softterm(rep); continue; } @@ -1423,7 +1425,7 @@ nfs_timer(arg) */ if ((rep->r_flags & R_TPRINTFMSG) == 0 && rep->r_rexmit > nmp->nm_deadthresh) { - nfs_msg(rep->r_procp, + nfs_msg(rep->r_td, nmp->nm_mountp->mnt_stat.f_mntfromname, "not responding"); rep->r_flags |= R_TPRINTFMSG; @@ -1455,11 +1457,11 @@ nfs_timer(arg) if ((nmp->nm_flag & NFSMNT_NOCONN) == 0) error = (*so->so_proto->pr_usrreqs->pru_send) (so, 0, m, (struct sockaddr *)0, - (struct mbuf *)0, p); + (struct mbuf *)0, td); else error = (*so->so_proto->pr_usrreqs->pru_send) (so, 0, m, nmp->nm_nam, (struct mbuf *)0, - p); + td); if (error) { if (NFSIGNORE_SOERROR(nmp->nm_soflags, error)) so->so_error = 0; @@ -1566,17 +1568,17 @@ nfs_sndlock(rep) struct nfsreq *rep; { register int *statep = &rep->r_nmp->nm_state; - struct proc *p; + struct thread *td; int slpflag = 0, slptimeo = 0; if (rep) { - p = rep->r_procp; + td = rep->r_td; if (rep->r_nmp->nm_flag & NFSMNT_INT) slpflag = PCATCH; } else - p = (struct proc *)0; + td = (struct thread *)0; while (*statep & NFSSTA_SNDLOCK) { - if (nfs_sigintr(rep->r_nmp, rep, p)) + if (nfs_sigintr(rep->r_nmp, rep, td ? td->td_proc : NULL)) return (EINTR); *statep |= NFSSTA_WANTSND; (void) tsleep((caddr_t)statep, slpflag | (PZERO - 1), @@ -1620,7 +1622,8 @@ nfs_rcvlock(rep) else slpflag = 0; while (*statep & NFSSTA_RCVLOCK) { - if (nfs_sigintr(rep->r_nmp, rep, rep->r_procp)) + if (nfs_sigintr(rep->r_nmp, rep, + (rep->r_td ? rep->r_td->td_proc : NULL))) return (EINTR); *statep |= NFSSTA_WANTRCV; (void) tsleep((caddr_t)statep, slpflag | (PZERO - 1), "nfsrcvlk", @@ -1966,12 +1969,12 @@ nfsmout: #endif static int -nfs_msg(p, server, msg) - struct proc *p; +nfs_msg(td, server, msg) + struct thread *td; char *server, *msg; { - tprintf(p, LOG_INFO, "nfs server %s: %s\n", server, msg); + tprintf(td->td_proc, LOG_INFO, "nfs server %s: %s\n", server, msg); return (0); } @@ -2005,7 +2008,7 @@ nfsrv_rcv(so, arg, waitflag) slp->ns_flag |= SLP_NEEDQ; goto dorecs; } #endif - auio.uio_procp = NULL; + auio.uio_td = NULL; if (so->so_type == SOCK_STREAM) { /* * If there are already records on the queue, defer soreceive() diff --git a/sys/nfsserver/nfs_srvsubs.c b/sys/nfsserver/nfs_srvsubs.c index ad8891c..4425129 100644 --- a/sys/nfsserver/nfs_srvsubs.c +++ b/sys/nfsserver/nfs_srvsubs.c @@ -554,11 +554,11 @@ extern struct nfsnodehashhead *nfsnodehashtbl; extern u_long nfsnodehash; struct nfssvc_args; -extern int nfssvc(struct proc *, struct nfssvc_args *, int *); +extern int nfssvc(struct thread *, struct nfssvc_args *, int *); LIST_HEAD(nfsnodehashhead, nfsnode); -int nfs_webnamei __P((struct nameidata *, struct vnode *, struct proc *)); +int nfs_webnamei __P((struct nameidata *, struct vnode *, struct thread *)); u_quad_t nfs_curusec() @@ -950,7 +950,7 @@ nfsm_disct(mdp, dposp, siz, left, cp2) { register struct mbuf *mp, *mp2; register int siz2, xfer; - register caddr_t p; + register caddr_t ptr; mp = *mdp; while (left == 0) { @@ -973,10 +973,10 @@ nfsm_disct(mdp, dposp, siz, left, cp2) mp->m_next = mp2; mp->m_len -= left; mp = mp2; - *cp2 = p = mtod(mp, caddr_t); - bcopy(*dposp, p, left); /* Copy what was left */ + *cp2 = ptr = mtod(mp, caddr_t); + bcopy(*dposp, ptr, left); /* Copy what was left */ siz2 = siz-left; - p += left; + ptr += left; mp2 = mp->m_next; /* Loop around copying up the siz2 bytes */ while (siz2 > 0) { @@ -984,10 +984,10 @@ nfsm_disct(mdp, dposp, siz, left, cp2) return (EBADRPC); xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2; if (xfer > 0) { - bcopy(mtod(mp2, caddr_t), p, xfer); + bcopy(mtod(mp2, caddr_t), ptr, xfer); NFSMADV(mp2, xfer); mp2->m_len -= xfer; - p += xfer; + ptr += xfer; siz2 -= xfer; } if (siz2 > 0) @@ -1464,7 +1464,7 @@ nfs_getattrcache(vp, vaper) * released by the caller. */ int -nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) +nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, td, kerbflag, pubflag) register struct nameidata *ndp; fhandle_t *fhp; int len; @@ -1473,7 +1473,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) struct mbuf **mdp; caddr_t *dposp; struct vnode **retdirp; - struct proc *p; + struct thread *td; int kerbflag, pubflag; { register int i, rem; @@ -1613,7 +1613,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) * becuase lookup() will dereference ni_startdir. */ - cnp->cn_proc = p; + cnp->cn_thread = td; VREF(dp); ndp->ni_startdir = dp; @@ -1649,7 +1649,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) * Validate symlink */ if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1) - VOP_UNLOCK(ndp->ni_dvp, 0, p); + VOP_UNLOCK(ndp->ni_dvp, 0, td); if (!pubflag) { error = EINVAL; goto badlink2; @@ -1670,7 +1670,7 @@ nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag) auio.uio_offset = 0; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = (struct proc *)0; + auio.uio_td = (struct thread *)0; auio.uio_resid = MAXPATHLEN; error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred); if (error) { @@ -1924,7 +1924,7 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag, pubflag) int kerbflag; int pubflag; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ register struct mount *mp; register int i; struct ucred *credanon; @@ -1988,7 +1988,7 @@ nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag, pubflag) nfsrv_object_create(*vpp); if (!lockflag) - VOP_UNLOCK(*vpp, 0, p); + VOP_UNLOCK(*vpp, 0, td); return (0); } @@ -2196,8 +2196,8 @@ nfsrv_object_create(vp) if (vp == NULL || vp->v_type != VREG) return (1); - return (vfs_object_create(vp, curproc, - curproc ? curproc->p_ucred : NULL)); + return (vfs_object_create(vp, curthread, + curthread ? curthread->td_proc->p_ucred : NULL)); } /* diff --git a/sys/nfsserver/nfs_syscalls.c b/sys/nfsserver/nfs_syscalls.c index e378cc5..657f299 100644 --- a/sys/nfsserver/nfs_syscalls.c +++ b/sys/nfsserver/nfs_syscalls.c @@ -78,7 +78,7 @@ static MALLOC_DEFINE(M_NFSSVC, "NFS srvsock", "Nfs server structure"); /* Global defs. */ extern int32_t (*nfsrv3_procs[NFS_NPROCS]) __P((struct nfsrv_descript *nd, struct nfssvc_sock *slp, - struct proc *procp, + struct thread *td, struct mbuf **mreqp)); extern int nfs_numasync; extern time_t nqnfsstarttime; @@ -92,7 +92,7 @@ static int nuidhash_max = NFS_MAXUIDHASH; #ifndef NFS_NOSERVER static void nfsrv_zapsock __P((struct nfssvc_sock *slp)); #endif -static int nfssvc_iod __P((struct proc *)); +static int nfssvc_iod __P((struct thread *)); #define TRUE 1 #define FALSE 0 @@ -110,8 +110,9 @@ static int modify_flag = 0; static void nfsd_rt __P((int sotype, struct nfsrv_descript *nd, int cacherep)); static int nfssvc_addsock __P((struct file *, struct sockaddr *, - struct proc *)); -static int nfssvc_nfsd __P((struct nfsd_srvargs *,caddr_t,struct proc *)); + struct thread *)); +static int nfssvc_nfsd __P((struct nfsd_srvargs *,caddr_t, + struct thread *)); static int nfs_privport = 0; SYSCTL_INT(_vfs_nfs, NFS_NFSPRIVPORT, nfs_privport, CTLFLAG_RW, &nfs_privport, 0, ""); @@ -140,8 +141,8 @@ struct nfssvc_args { * MPSAFE */ int -nfssvc(p, uap) - struct proc *p; +nfssvc(td, uap) + struct thread *td; register struct nfssvc_args *uap; { #ifndef NFS_NOSERVER @@ -165,13 +166,13 @@ nfssvc(p, uap) error = copyin(uap->argp, &la, sizeof(la)); if (error == 0) - error = nfslockdans(p, &la); + error = nfslockdans(td->td_proc, &la); goto done2; } /* * Must be super user */ - error = suser(p); + error = suser_td(td); if (error) goto done2; while (nfssvc_sockhead_flag & SLP_INIT) { @@ -179,7 +180,7 @@ nfssvc(p, uap) (void) tsleep((caddr_t)&nfssvc_sockhead, PSOCK, "nfsd init", 0); } if (uap->flag & NFSSVC_BIOD) - error = nfssvc_iod(p); + error = nfssvc_iod(td); #ifdef NFS_NOSERVER else error = ENXIO; @@ -189,7 +190,7 @@ nfssvc(p, uap) if (error) goto done2; NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, - ncd.ncd_dirp, p); + ncd.ncd_dirp, td); error = namei(&nd); if (error) goto done2; @@ -206,13 +207,13 @@ nfssvc(p, uap) goto done2; } nmp->nm_state |= NFSSTA_MNTD; - error = nqnfs_clientd(nmp, p->p_ucred, &ncd, uap->flag, - uap->argp, p); + error = nqnfs_clientd(nmp, td->td_proc->p_ucred, &ncd, uap->flag, + uap->argp, td); } else if (uap->flag & NFSSVC_ADDSOCK) { error = copyin(uap->argp, (caddr_t)&nfsdarg, sizeof(nfsdarg)); if (error) goto done2; - error = holdsock(p->p_fd, nfsdarg.sock, &fp); + error = holdsock(td->td_proc->p_fd, nfsdarg.sock, &fp); if (error) goto done2; /* @@ -224,12 +225,12 @@ nfssvc(p, uap) error = getsockaddr(&nam, nfsdarg.name, nfsdarg.namelen); if (error) { - fdrop(fp, p); + fdrop(fp, td); goto done2; } } - error = nfssvc_addsock(fp, nam, p); - fdrop(fp, p); + error = nfssvc_addsock(fp, nam, td); + fdrop(fp, td); } else { error = copyin(uap->argp, (caddr_t)nsd, sizeof (*nsd)); if (error) @@ -327,7 +328,7 @@ nfssvc(p, uap) } if ((uap->flag & NFSSVC_AUTHINFAIL) && (nfsd = nsd->nsd_nfsd)) nfsd->nfsd_flag |= NFSD_AUTHFAIL; - error = nfssvc_nfsd(nsd, uap->argp, p); + error = nfssvc_nfsd(nsd, uap->argp, td); } #endif /* NFS_NOSERVER */ if (error == EINTR || error == ERESTART) @@ -342,10 +343,10 @@ done2: * Adds a socket to the list for servicing by nfsds. */ static int -nfssvc_addsock(fp, mynam, p) +nfssvc_addsock(fp, mynam, td) struct file *fp; struct sockaddr *mynam; - struct proc *p; + struct thread *td; { register int siz; register struct nfssvc_sock *slp; @@ -439,10 +440,10 @@ nfssvc_addsock(fp, mynam, p) * until it is killed by a signal. */ static int -nfssvc_nfsd(nsd, argp, p) +nfssvc_nfsd(nsd, argp, td) struct nfsd_srvargs *nsd; caddr_t argp; - struct proc *p; + struct thread *td; { register int siz; register struct nfssvc_sock *slp; @@ -461,7 +462,7 @@ nfssvc_nfsd(nsd, argp, p) nsd->nsd_nfsd = nfsd = (struct nfsd *) malloc(sizeof (struct nfsd), M_NFSD, M_WAITOK | M_ZERO); s = splnet(); - nfsd->nfsd_procp = p; + nfsd->nfsd_td = td; TAILQ_INSERT_TAIL(&nfsd_head, nfsd, nfsd_chain); nfs_numnfsd++; } else @@ -622,10 +623,10 @@ nfssvc_nfsd(nsd, argp, p) if (writes_todo || (nd->nd_procnum == NFSPROC_WRITE && procrastinate > 0 && !notstarted)) error = nfsrv_writegather(&nd, slp, - nfsd->nfsd_procp, &mreq); + nfsd->nfsd_td, &mreq); else error = (*(nfsrv3_procs[nd->nd_procnum]))(nd, - slp, nfsd->nfsd_procp, &mreq); + slp, nfsd->nfsd_td, &mreq); if (mreq == NULL) break; if (error != 0 && error != NFSERR_RETVOID) { @@ -757,7 +758,7 @@ nfsrv_zapsock(slp) so->so_upcall = NULL; so->so_upcallarg = NULL; soshutdown(so, 2); - closef(fp, (struct proc *)0); + closef(fp, (struct thread *)0); if (slp->ns_nam) FREE(slp->ns_nam, M_SONAME); m_freem(slp->ns_raw); @@ -935,8 +936,8 @@ SYSCTL_INT(_vfs_nfs, OID_AUTO, defect, CTLFLAG_RW, &nfs_defect, 0, ""); * Never returns unless it fails or gets killed. */ static int -nfssvc_iod(p) - struct proc *p; +nfssvc_iod(td) + struct thread *td; { register struct buf *bp; register int i, myiod; @@ -965,7 +966,7 @@ nfssvc_iod(p) && error == 0) { if (nmp) nmp->nm_bufqiods--; - nfs_iodwant[myiod] = p; + nfs_iodwant[myiod] = td->td_proc; nfs_iodmount[myiod] = NULL; error = tsleep((caddr_t)&nfs_iodwant[myiod], PWAIT | PCATCH, "nfsidl", 0); @@ -988,9 +989,9 @@ nfssvc_iod(p) wakeup(&nmp->nm_bufq); } if (bp->b_iocmd == BIO_READ) - (void) nfs_doio(bp, bp->b_rcred, (struct proc *)0); + (void) nfs_doio(bp, bp->b_rcred, (struct thread *)0); else - (void) nfs_doio(bp, bp->b_wcred, (struct proc *)0); + (void) nfs_doio(bp, bp->b_wcred, (struct thread *)0); /* * If there are more than one iod on this mount, then defect * so that the iods can be shared out fairly between the mounts @@ -1029,7 +1030,7 @@ nfs_getauth(nmp, rep, cred, auth_str, auth_len, verf_str, verf_len, key) nmp->nm_state |= NFSSTA_WANTAUTH; (void) tsleep((caddr_t)&nmp->nm_authtype, PSOCK, "nfsauth1", 2 * hz); - error = nfs_sigintr(nmp, rep, rep->r_procp); + error = nfs_sigintr(nmp, rep, rep->r_td->td_proc); if (error) { nmp->nm_state &= ~NFSSTA_WANTAUTH; return (error); @@ -1049,7 +1050,7 @@ nfs_getauth(nmp, rep, cred, auth_str, auth_len, verf_str, verf_len, key) while ((nmp->nm_state & NFSSTA_HASAUTH) == 0 && error == 0) { (void) tsleep((caddr_t)&nmp->nm_authlen, PSOCK, "nfsauth2", 2 * hz); - error = nfs_sigintr(nmp, rep, rep->r_procp); + error = nfs_sigintr(nmp, rep, rep->r_td->td_proc); } if (nmp->nm_state & NFSSTA_AUTHERR) { nmp->nm_state &= ~NFSSTA_AUTHERR; diff --git a/sys/nfsserver/nfsrvstats.h b/sys/nfsserver/nfsrvstats.h index 44d04b9..d5d0796 100644 --- a/sys/nfsserver/nfsrvstats.h +++ b/sys/nfsserver/nfsrvstats.h @@ -348,7 +348,7 @@ struct nfsreq { int r_timer; /* tick counter on reply */ u_int32_t r_procnum; /* NFS procedure number */ int r_rtt; /* RTT for rpc */ - struct proc *r_procp; /* Proc that did I/O system call */ + struct thread *r_td; /* Proc that did I/O system call */ }; /* @@ -469,7 +469,7 @@ struct nfsd { u_char nfsd_authstr[RPCAUTH_MAXSIZ]; /* Authenticator data */ int nfsd_verflen; /* and the Verifier */ u_char nfsd_verfstr[RPCVERF_MAXSIZ]; - struct proc *nfsd_procp; /* Proc ptr */ + struct thread *nfsd_td; /* daemon thread ptr */ struct nfsrv_descript *nfsd_nd; /* Associated nfsrv_descript */ }; @@ -592,16 +592,16 @@ void nfs_sndunlock __P((struct nfsreq *)); int nfs_slplock __P((struct nfssvc_sock *, int)); void nfs_slpunlock __P((struct nfssvc_sock *)); int nfs_disct __P((struct mbuf **, caddr_t *, int, int, caddr_t *)); -int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct proc *, +int nfs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct thread *, int)); int nfs_readrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_writerpc __P((struct vnode *, struct uio *, struct ucred *, int *, int *)); int nfs_commit __P((struct vnode *vp, u_quad_t offset, int cnt, - struct ucred *cred, struct proc *procp)); + struct ucred *cred, struct thread *)); int nfs_readdirrpc __P((struct vnode *, struct uio *, struct ucred *)); -int nfs_asyncio __P((struct buf *, struct ucred *, struct proc *)); -int nfs_doio __P((struct buf *, struct ucred *, struct proc *)); +int nfs_asyncio __P((struct buf *, struct ucred *, struct thread *)); +int nfs_doio __P((struct buf *, struct ucred *, struct thread *)); int nfs_readlinkrpc __P((struct vnode *, struct uio *, struct ucred *)); int nfs_sigintr __P((struct nfsmount *, struct nfsreq *, struct proc *)); int nfs_readdirplusrpc __P((struct vnode *, struct uio *, struct ucred *)); @@ -613,14 +613,14 @@ void nfsm_srvwcc __P((struct nfsrv_descript *, int, struct vattr *, int, void nfsm_srvpostopattr __P((struct nfsrv_descript *, int, struct vattr *, struct mbuf **, char **)); int netaddr_match __P((int, union nethostaddr *, struct sockaddr *)); -int nfs_request __P((struct vnode *, struct mbuf *, int, struct proc *, +int nfs_request __P((struct vnode *, struct mbuf *, int, struct thread *, struct ucred *, struct mbuf **, struct mbuf **, caddr_t *)); int nfs_loadattrcache __P((struct vnode **, struct mbuf **, caddr_t *, struct vattr *, int)); int nfs_namei __P((struct nameidata *, fhandle_t *, int, struct nfssvc_sock *, struct sockaddr *, struct mbuf **, - caddr_t *, struct vnode **, struct proc *, int, int)); + caddr_t *, struct vnode **, struct thread *, int, int)); void nfsm_adj __P((struct mbuf *, int, int)); int nfsm_mbuftouio __P((struct mbuf **, struct uio *, int, caddr_t *)); void nfsrv_initcache __P((void)); @@ -652,21 +652,21 @@ void nfs_clearcommit __P((struct mount *)); int nfsrv_errmap __P((struct nfsrv_descript *, int)); void nfsrvw_sort __P((gid_t *, int)); void nfsrv_setcred __P((struct ucred *, struct ucred *)); -int nfs_writebp __P((struct buf *, int, struct proc *)); +int nfs_writebp __P((struct buf *, int, struct thread *)); int nfsrv_object_create __P((struct vnode *)); void nfsrv_wakenfsd __P((struct nfssvc_sock *slp)); int nfsrv_writegather __P((struct nfsrv_descript **, struct nfssvc_sock *, - struct proc *, struct mbuf **)); + struct thread *, struct mbuf **)); int nfs_fsinfo __P((struct nfsmount *, struct vnode *, struct ucred *, - struct proc *p)); + struct thread *p)); int nfsrv3_access __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_commit __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_create __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_fhtovp __P((fhandle_t *, int, struct vnode **, struct ucred *, struct nfssvc_sock *, struct sockaddr *, int *, int, int)); @@ -674,52 +674,52 @@ int nfsrv_setpublicfs __P((struct mount *, struct netexport *, struct export_args *)); int nfs_ispublicfh __P((fhandle_t *)); int nfsrv_fsinfo __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_getattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_link __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_lookup __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mkdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_mknod __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_noop __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_null __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_pathconf __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_read __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_readdirplus __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_readlink __P((struct nfsrv_descript *nfsd, - struct nfssvc_sock *slp, struct proc *procp, + struct nfssvc_sock *slp, struct thread *td, struct mbuf **mrq)); int nfsrv_remove __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rename __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_rmdir __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_setattr __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_statfs __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_symlink __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); int nfsrv_write __P((struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, - struct proc *procp, struct mbuf **mrq)); + struct thread *td, struct mbuf **mrq)); void nfsrv_rcv __P((struct socket *so, void *arg, int waitflag)); void nfsrv_slpderef __P((struct nfssvc_sock *slp)); #endif /* _KERNEL */ diff --git a/sys/pc98/i386/machdep.c b/sys/pc98/i386/machdep.c index c78aa589..ed9657f 100644 --- a/sys/pc98/i386/machdep.c +++ b/sys/pc98/i386/machdep.c @@ -49,7 +49,7 @@ #include "opt_msgbuf.h" #include "opt_npx.h" #include "opt_perfmon.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" /* #include "opt_userconfig.h" */ #include <sys/param.h> diff --git a/sys/pc98/pc98/machdep.c b/sys/pc98/pc98/machdep.c index c78aa589..ed9657f 100644 --- a/sys/pc98/pc98/machdep.c +++ b/sys/pc98/pc98/machdep.c @@ -49,7 +49,7 @@ #include "opt_msgbuf.h" #include "opt_npx.h" #include "opt_perfmon.h" -#include "opt_upages.h" +#include "opt_kstack_pages.h" /* #include "opt_userconfig.h" */ #include <sys/param.h> diff --git a/sys/pccard/pccard.c b/sys/pccard/pccard.c index 0a02e02..f98bf0a 100644 --- a/sys/pccard/pccard.c +++ b/sys/pccard/pccard.c @@ -330,7 +330,7 @@ pccard_event(struct slot *slt, enum card_event event) * Device driver interface. */ static int -crdopen(dev_t dev, int oflags, int devtype, struct proc *p) +crdopen(dev_t dev, int oflags, int devtype, struct thread *td) { struct slot *slt = PCCARD_DEV2SOFTC(dev); @@ -346,7 +346,7 @@ crdopen(dev_t dev, int oflags, int devtype, struct proc *p) * slots may be assigned to drivers already. */ static int -crdclose(dev_t dev, int fflag, int devtype, struct proc *p) +crdclose(dev_t dev, int fflag, int devtype, struct thread *td) { return (0); } @@ -447,7 +447,7 @@ crdwrite(dev_t dev, struct uio *uio, int ioflag) * descriptors, and assignment of drivers. */ static int -crdioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) +crdioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct thread *td) { u_int32_t addr; int err; @@ -497,7 +497,7 @@ crdioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) * At the very least, we only allow root to set the context. */ case PIOCSMEM: - if (suser(p)) + if (suser_td(td)) return (EPERM); if (slt->state != filled) return (ENXIO); @@ -522,7 +522,7 @@ crdioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) * Set I/O port context. */ case PIOCSIO: - if (suser(p)) + if (suser_td(td)) return (EPERM); if (slt->state != filled) return (ENXIO); @@ -548,7 +548,7 @@ crdioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) *(unsigned long *)data = pccard_mem; break; } - if (suser(p)) + if (suser_td(td)) return (EPERM); /* * Validate the memory by checking it against the I/O @@ -580,7 +580,7 @@ crdioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) * Allocate a driver to this slot. */ case PIOCSDRV: - if (suser(p)) + if (suser_td(td)) return (EPERM); err = allocate_driver(slt, (struct dev_desc *)data); if (!err) @@ -617,7 +617,7 @@ crdioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) * when a change in card status occurs. */ static int -crdpoll(dev_t dev, int events, struct proc *p) +crdpoll(dev_t dev, int events, struct thread *td) { int revents = 0; int s; @@ -638,7 +638,7 @@ crdpoll(dev_t dev, int events, struct proc *p) revents |= POLLRDBAND; if (revents == 0) - selrecord(p, &slt->selp); + selrecord(td, &slt->selp); splx(s); return (revents); diff --git a/sys/pci/agp.c b/sys/pci/agp.c index 333c4c8..138fe45 100644 --- a/sys/pci/agp.c +++ b/sys/pci/agp.c @@ -270,7 +270,7 @@ agp_generic_detach(device_t dev) { struct agp_softc *sc = device_get_softc(dev); bus_release_resource(dev, SYS_RES_MEMORY, AGP_APBASE, sc->as_aperture); - lockmgr(&sc->as_lock, LK_DRAIN, 0, curproc); + lockmgr(&sc->as_lock, LK_DRAIN, 0, curthread); lockdestroy(&sc->as_lock); destroy_dev(sc->as_devnode); agp_flush_cache(); @@ -389,7 +389,7 @@ agp_generic_bind_memory(device_t dev, struct agp_memory *mem, vm_page_t m; int error; - lockmgr(&sc->as_lock, LK_EXCLUSIVE, 0, curproc); + lockmgr(&sc->as_lock, LK_EXCLUSIVE, 0, curthread); if (mem->am_is_bound) { device_printf(dev, "memory already bound\n"); @@ -450,7 +450,7 @@ agp_generic_bind_memory(device_t dev, struct agp_memory *mem, OFF_TO_IDX(k)); vm_page_unwire(m, 0); } - lockmgr(&sc->as_lock, LK_RELEASE, 0, curproc); + lockmgr(&sc->as_lock, LK_RELEASE, 0, curthread); return error; } } @@ -471,7 +471,7 @@ agp_generic_bind_memory(device_t dev, struct agp_memory *mem, mem->am_offset = offset; mem->am_is_bound = 1; - lockmgr(&sc->as_lock, LK_RELEASE, 0, curproc); + lockmgr(&sc->as_lock, LK_RELEASE, 0, curthread); return 0; } @@ -483,7 +483,7 @@ agp_generic_unbind_memory(device_t dev, struct agp_memory *mem) vm_page_t m; int i; - lockmgr(&sc->as_lock, LK_EXCLUSIVE, 0, curproc); + lockmgr(&sc->as_lock, LK_EXCLUSIVE, 0, curthread); if (!mem->am_is_bound) { device_printf(dev, "memory is not bound\n"); @@ -508,7 +508,7 @@ agp_generic_unbind_memory(device_t dev, struct agp_memory *mem) mem->am_offset = 0; mem->am_is_bound = 0; - lockmgr(&sc->as_lock, LK_RELEASE, 0, curproc); + lockmgr(&sc->as_lock, LK_RELEASE, 0, curthread); return 0; } @@ -645,7 +645,7 @@ agp_unbind_user(device_t dev, agp_unbind *unbind) } static int -agp_open(dev_t kdev, int oflags, int devtype, struct proc *p) +agp_open(dev_t kdev, int oflags, int devtype, struct thread *td) { device_t dev = KDEV2DEV(kdev); struct agp_softc *sc = device_get_softc(dev); @@ -659,7 +659,7 @@ agp_open(dev_t kdev, int oflags, int devtype, struct proc *p) } static int -agp_close(dev_t kdev, int fflag, int devtype, struct proc *p) +agp_close(dev_t kdev, int fflag, int devtype, struct thread *td) { device_t dev = KDEV2DEV(kdev); struct agp_softc *sc = device_get_softc(dev); @@ -676,7 +676,7 @@ agp_close(dev_t kdev, int fflag, int devtype, struct proc *p) } static int -agp_ioctl(dev_t kdev, u_long cmd, caddr_t data, int fflag, struct proc *p) +agp_ioctl(dev_t kdev, u_long cmd, caddr_t data, int fflag, struct thread *td) { device_t dev = KDEV2DEV(kdev); diff --git a/sys/pci/meteor.c b/sys/pci/meteor.c index 72c6988..4c701c4 100644 --- a/sys/pci/meteor.c +++ b/sys/pci/meteor.c @@ -1171,7 +1171,7 @@ struct saa7116_regs *m; int -meteor_open(dev_t dev, int flags, int fmt, struct proc *p) +meteor_open(dev_t dev, int flags, int fmt, struct thread *td) { meteor_reg_t *mtr; int unit; @@ -1215,7 +1215,7 @@ meteor_open(dev_t dev, int flags, int fmt, struct proc *p) } int -meteor_close(dev_t dev, int flags, int fmt, struct proc *p) +meteor_close(dev_t dev, int flags, int fmt, struct thread *td) { meteor_reg_t *mtr; int unit; @@ -1338,7 +1338,7 @@ meteor_write(dev_t dev, struct uio *uio, int ioflag) } int -meteor_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *pr) +meteor_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct thread *td) { int error; int unit; @@ -1402,7 +1402,7 @@ meteor_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *pr) case METEORSSIGNAL: mtr->signal = *(int *) arg; if (mtr->signal) { - mtr->proc = pr; + mtr->proc = td->td_proc; } else { mtr->proc = (struct proc *)0; } diff --git a/sys/pci/xrpu.c b/sys/pci/xrpu.c index a1a8d6c..1cae322 100644 --- a/sys/pci/xrpu.c +++ b/sys/pci/xrpu.c @@ -115,7 +115,7 @@ xrpu_poll_pps(struct timecounter *tc) } static int -xrpu_open(dev_t dev, int flag, int mode, struct proc *p) +xrpu_open(dev_t dev, int flag, int mode, struct thread *td) { struct softc *sc = devclass_get_softc(xrpu_devclass, dev2unit(dev)); @@ -126,7 +126,7 @@ xrpu_open(dev_t dev, int flag, int mode, struct proc *p) } static int -xrpu_close(dev_t dev, int flag, int mode, struct proc *p) +xrpu_close(dev_t dev, int flag, int mode, struct thread *td) { return (0); } @@ -141,7 +141,7 @@ xrpu_mmap(dev_t dev, vm_offset_t offset, int nprot) } static int -xrpu_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *pr) +xrpu_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct thread *tdr) { struct softc *sc = dev->si_drv1; int i, error; diff --git a/sys/posix4/ksched.c b/sys/posix4/ksched.c index d118b93..6ad2a07 100644 --- a/sys/posix4/ksched.c +++ b/sys/posix4/ksched.c @@ -62,9 +62,9 @@ int ksched_attach(struct ksched **p) return 0; } -int ksched_detach(struct ksched *p) +int ksched_detach(struct ksched *ks) { - p31b_free(p); + p31b_free(ks); return 0; } @@ -94,13 +94,13 @@ int ksched_detach(struct ksched *p) #define P1B_PRIO_MAX rtpprio_to_p4prio(RTP_PRIO_MIN) static __inline int -getscheduler(register_t *ret, struct ksched *ksched, struct proc *p) +getscheduler(register_t *ret, struct ksched *ksched, struct thread *td) { struct rtprio rtp; int e = 0; mtx_lock_spin(&sched_lock); - pri_to_rtp(&p->p_pri, &rtp); + pri_to_rtp(&td->td_ksegrp->kg_pri, &rtp); mtx_unlock_spin(&sched_lock); switch (rtp.type) { @@ -121,31 +121,31 @@ getscheduler(register_t *ret, struct ksched *ksched, struct proc *p) } int ksched_setparam(register_t *ret, struct ksched *ksched, - struct proc *p, const struct sched_param *param) + struct thread *td, const struct sched_param *param) { register_t policy; int e; - e = getscheduler(&policy, ksched, p); + e = getscheduler(&policy, ksched, td); if (e == 0) { if (policy == SCHED_OTHER) e = EINVAL; else - e = ksched_setscheduler(ret, ksched, p, policy, param); + e = ksched_setscheduler(ret, ksched, td, policy, param); } return e; } int ksched_getparam(register_t *ret, struct ksched *ksched, - struct proc *p, struct sched_param *param) + struct thread *td, struct sched_param *param) { struct rtprio rtp; mtx_lock_spin(&sched_lock); - pri_to_rtp(&p->p_pri, &rtp); + pri_to_rtp(&td->td_ksegrp->kg_pri, &rtp); mtx_unlock_spin(&sched_lock); if (RTP_PRIO_IS_REALTIME(rtp.type)) param->sched_priority = rtpprio_to_p4prio(rtp.prio); @@ -161,7 +161,7 @@ int ksched_getparam(register_t *ret, struct ksched *ksched, * */ int ksched_setscheduler(register_t *ret, struct ksched *ksched, - struct proc *p, int policy, const struct sched_param *param) + struct thread *td, int policy, const struct sched_param *param) { int e = 0; struct rtprio rtp; @@ -179,8 +179,8 @@ int ksched_setscheduler(register_t *ret, struct ksched *ksched, ? RTP_PRIO_FIFO : RTP_PRIO_REALTIME; mtx_lock_spin(&sched_lock); - rtp_to_pri(&rtp, &p->p_pri); - p->p_sflag |= PS_NEEDRESCHED; + rtp_to_pri(&rtp, &td->td_ksegrp->kg_pri); + td->td_last_kse->ke_flags |= KEF_NEEDRESCHED; /* XXXKSE */ mtx_unlock_spin(&sched_lock); } else @@ -194,7 +194,7 @@ int ksched_setscheduler(register_t *ret, struct ksched *ksched, rtp.type = RTP_PRIO_NORMAL; rtp.prio = p4prio_to_rtpprio(param->sched_priority); mtx_lock_spin(&sched_lock); - rtp_to_pri(&rtp, &p->p_pri); + rtp_to_pri(&rtp, &td->td_ksegrp->kg_pri); /* XXX Simply revert to whatever we had for last * normal scheduler priorities. @@ -202,7 +202,7 @@ int ksched_setscheduler(register_t *ret, struct ksched *ksched, * on the scheduling code: You must leave the * scheduling info alone. */ - p->p_sflag |= PS_NEEDRESCHED; + td->td_last_kse->ke_flags |= KEF_NEEDRESCHED; /* XXXKSE */ mtx_unlock_spin(&sched_lock); } break; @@ -211,9 +211,9 @@ int ksched_setscheduler(register_t *ret, struct ksched *ksched, return e; } -int ksched_getscheduler(register_t *ret, struct ksched *ksched, struct proc *p) +int ksched_getscheduler(register_t *ret, struct ksched *ksched, struct thread *td) { - return getscheduler(ret, ksched, p); + return getscheduler(ret, ksched, td); } /* ksched_yield: Yield the CPU. @@ -221,7 +221,7 @@ int ksched_getscheduler(register_t *ret, struct ksched *ksched, struct proc *p) int ksched_yield(register_t *ret, struct ksched *ksched) { mtx_lock_spin(&sched_lock); - curproc->p_sflag |= PS_NEEDRESCHED; + curthread->td_kse->ke_flags |= KEF_NEEDRESCHED; mtx_unlock_spin(&sched_lock); return 0; } @@ -271,7 +271,7 @@ int ksched_get_priority_min(register_t *ret, struct ksched *ksched, int policy) } int ksched_rr_get_interval(register_t *ret, struct ksched *ksched, - struct proc *p, struct timespec *timespec) + struct thread *td, struct timespec *timespec) { *timespec = ksched->rr_interval; diff --git a/sys/posix4/p1003_1b.c b/sys/posix4/p1003_1b.c index 4e43b22..0409d63 100644 --- a/sys/posix4/p1003_1b.c +++ b/sys/posix4/p1003_1b.c @@ -56,10 +56,10 @@ MALLOC_DEFINE(M_P31B, "p1003.1b", "Posix 1003.1B"); * start to use this when they shouldn't. That will be removed if annoying. */ int -syscall_not_present(struct proc *p, const char *s, struct nosys_args *uap) +syscall_not_present(struct thread *td, const char *s, struct nosys_args *uap) { log(LOG_ERR, "cmd %s pid %d tried to use non-present %s\n", - p->p_comm, p->p_pid, s); + td->td_proc->p_comm, td->td_proc->p_pid, s); /* a " return nosys(p, uap); " here causes a core dump. */ @@ -105,9 +105,10 @@ static int sched_attach(void) /* * MPSAFE */ -int sched_setparam(struct proc *p, +int sched_setparam(struct thread *td, struct sched_setparam_args *uap) { + struct thread *targettd; struct proc *targetp; int e; struct sched_param sched_param; @@ -118,7 +119,8 @@ int sched_setparam(struct proc *p, mtx_lock(&Giant); if (uap->pid == 0) { - targetp = p; + targetp = td->td_proc; + targettd = td; PROC_LOCK(targetp); } else { targetp = pfind(uap->pid); @@ -126,12 +128,13 @@ int sched_setparam(struct proc *p, e = ESRCH; goto done2; } + targettd = &targetp->p_thread; /* XXXKSE */ } - e = p_cansched(p, targetp); + e = p_cansched(td->td_proc, targetp); PROC_UNLOCK(targetp); if (e == 0) { - e = ksched_setparam(&p->p_retval[0], ksched, targetp, + e = ksched_setparam(&td->td_retval[0], ksched, targettd, (const struct sched_param *)&sched_param); } done2: @@ -142,16 +145,18 @@ done2: /* * MPSAFE */ -int sched_getparam(struct proc *p, +int sched_getparam(struct thread *td, struct sched_getparam_args *uap) { int e; struct sched_param sched_param; + struct thread *targettd; struct proc *targetp; mtx_lock(&Giant); if (uap->pid == 0) { - targetp = p; + targetp = td->td_proc; + targettd = td; PROC_LOCK(targetp); } else { targetp = pfind(uap->pid); @@ -159,28 +164,31 @@ int sched_getparam(struct proc *p, e = ESRCH; goto done2; } + targettd = &targetp->p_thread; /* XXXKSE */ } - e = p_cansee(p, targetp); + e = p_cansee(td->td_proc, targetp); PROC_UNLOCK(targetp); if (e) goto done2; - e = ksched_getparam(&p->p_retval[0], ksched, targetp, &sched_param); + e = ksched_getparam(&td->td_retval[0], ksched, targettd, &sched_param); if (e == 0) e = copyout(&sched_param, uap->param, sizeof(sched_param)); done2: mtx_unlock(&Giant); return (e); } + /* * MPSAFE */ -int sched_setscheduler(struct proc *p, +int sched_setscheduler(struct thread *td, struct sched_setscheduler_args *uap) { int e; struct sched_param sched_param; + struct thread *targettd; struct proc *targetp; e = copyin(uap->param, &sched_param, sizeof(sched_param)); @@ -189,7 +197,8 @@ int sched_setscheduler(struct proc *p, mtx_lock(&Giant); if (uap->pid == 0) { - targetp = p; + targetp = td->td_proc; + targettd = td; PROC_LOCK(targetp); } else { targetp = pfind(uap->pid); @@ -197,31 +206,34 @@ int sched_setscheduler(struct proc *p, e = ESRCH; goto done2; } + targettd = &targetp->p_thread; /* XXXKSE */ } - e = p_cansched(p, targetp); + e = p_cansched(td->td_proc, targetp); PROC_UNLOCK(targetp); if (e == 0) { - e = ksched_setscheduler(&p->p_retval[0], ksched, - targetp, uap->policy, - (const struct sched_param *)&sched_param); + e = ksched_setscheduler(&td->td_retval[0], ksched, targettd, + uap->policy, (const struct sched_param *)&sched_param); } done2: mtx_unlock(&Giant); return (e); } + /* * MPSAFE */ -int sched_getscheduler(struct proc *p, +int sched_getscheduler(struct thread *td, struct sched_getscheduler_args *uap) { int e; + struct thread *targettd; struct proc *targetp; mtx_lock(&Giant); if (uap->pid == 0) { - targetp = p; + targetp = td->td_proc; + targettd = td; PROC_LOCK(targetp); } else { targetp = pfind(uap->pid); @@ -229,67 +241,75 @@ int sched_getscheduler(struct proc *p, e = ESRCH; goto done2; } + targettd = &targetp->p_thread; /* XXXKSE */ } - e = p_cansee(p, targetp); + e = p_cansee(td->td_proc, targetp); PROC_UNLOCK(targetp); if (e == 0) - e = ksched_getscheduler(&p->p_retval[0], ksched, targetp); + e = ksched_getscheduler(&td->td_retval[0], ksched, targettd); done2: mtx_unlock(&Giant); return (e); } + /* * MPSAFE */ -int sched_yield(struct proc *p, +int sched_yield(struct thread *td, struct sched_yield_args *uap) { int error; mtx_lock(&Giant); - error = ksched_yield(&p->p_retval[0], ksched); + error = ksched_yield(&td->td_retval[0], ksched); mtx_unlock(&Giant); return (error); } + /* * MPSAFE */ -int sched_get_priority_max(struct proc *p, +int sched_get_priority_max(struct thread *td, struct sched_get_priority_max_args *uap) { int error; mtx_lock(&Giant); - error = ksched_get_priority_max(&p->p_retval[0], ksched, uap->policy); + error = ksched_get_priority_max(&td->td_retval[0], ksched, uap->policy); mtx_unlock(&Giant); return (error); } + /* * MPSAFE */ -int sched_get_priority_min(struct proc *p, +int sched_get_priority_min(struct thread *td, struct sched_get_priority_min_args *uap) { int error; + mtx_lock(&Giant); - error = ksched_get_priority_min(&p->p_retval[0], ksched, uap->policy); + error = ksched_get_priority_min(&td->td_retval[0], ksched, uap->policy); mtx_unlock(&Giant); return (error); } + /* * MPSAFE */ -int sched_rr_get_interval(struct proc *p, +int sched_rr_get_interval(struct thread *td, struct sched_rr_get_interval_args *uap) { int e; + struct thread *targettd; struct proc *targetp; mtx_lock(&Giant); if (uap->pid == 0) { - targetp = p; + targettd = td; + targetp = td->td_proc; PROC_LOCK(targetp); } else { targetp = pfind(uap->pid); @@ -297,12 +317,13 @@ int sched_rr_get_interval(struct proc *p, e = ESRCH; goto done2; } + targettd = &targetp->p_thread; /* XXXKSE */ } - e = p_cansee(p, targetp); + e = p_cansee(td->td_proc, targetp); PROC_UNLOCK(targetp); if (e == 0) { - e = ksched_rr_get_interval(&p->p_retval[0], ksched, targetp, + e = ksched_rr_get_interval(&td->td_retval[0], ksched, targettd, uap->interval); } done2: diff --git a/sys/posix4/posix4.h b/sys/posix4/posix4.h index 232435a..626d6d8 100644 --- a/sys/posix4/posix4.h +++ b/sys/posix4/posix4.h @@ -47,12 +47,12 @@ */ struct proc; struct nosys_args; -extern int syscall_not_present(struct proc *, const char *, struct nosys_args *); +extern int syscall_not_present(struct thread *, const char *, struct nosys_args *); #define SYSCALL_NOT_PRESENT_GEN(SC) \ -int SC (struct proc *p, struct SC##_args *uap) \ +int SC (struct thread *td, struct SC##_args *uap) \ { \ - return syscall_not_present(p, #SC , (struct nosys_args *)uap); \ + return syscall_not_present(td, #SC , (struct nosys_args *)uap); \ } @@ -95,13 +95,13 @@ int ksched_attach(struct ksched **); int ksched_detach(struct ksched *); int ksched_setparam(register_t *, struct ksched *, - struct proc *, const struct sched_param *); + struct thread *, const struct sched_param *); int ksched_getparam(register_t *, struct ksched *, - struct proc *, struct sched_param *); + struct thread *, struct sched_param *); int ksched_setscheduler(register_t *, struct ksched *, - struct proc *, int, const struct sched_param *); -int ksched_getscheduler(register_t *, struct ksched *, struct proc *); + struct thread *, int, const struct sched_param *); +int ksched_getscheduler(register_t *, struct ksched *, struct thread *); int ksched_yield(register_t *, struct ksched *); @@ -109,7 +109,7 @@ int ksched_get_priority_max(register_t *, struct ksched *, int); int ksched_get_priority_min(register_t *, struct ksched *, int); int ksched_rr_get_interval(register_t *, struct ksched *, - struct proc *, struct timespec *); + struct thread *, struct timespec *); #endif /* _KPOSIX_PRIORITY_SCHEDULING */ diff --git a/sys/powerpc/aim/mmu_oea.c b/sys/powerpc/aim/mmu_oea.c index e5b6198..ad79c602 100644 --- a/sys/powerpc/aim/mmu_oea.c +++ b/sys/powerpc/aim/mmu_oea.c @@ -1441,15 +1441,15 @@ next: * is the current process, load the new MMU context. */ void -pmap_activate(struct proc *p) +pmap_activate(struct thread *td) { struct pcb *pcb; pmap_t pmap; pmap_t rpm; int psl, i, ksr, seg; - pcb = &p->p_addr->u_pcb; - pmap = p->p_vmspace->vm_map.pmap; + pcb = td->td_pcb; + pmap = td->td_pric->p_vmspace->vm_map.pmap; /* * XXX Normally performed in cpu_fork(). @@ -1460,7 +1460,7 @@ pmap_activate(struct proc *p) (vm_offset_t)pcb->pcb_pm); } - if (p == curproc) { + if (td == curthread) { /* Disable interrupts while switching. */ psl = mfmsr(); mtmsr(psl & ~PSL_EE); diff --git a/sys/powerpc/aim/swtch.S b/sys/powerpc/aim/swtch.S index 35a5ed5..af18976 100644 --- a/sys/powerpc/aim/swtch.S +++ b/sys/powerpc/aim/swtch.S @@ -143,7 +143,7 @@ ENTRY(cpu_switch) mr 30,3 mfsprg 3,0 xor 31,31,31 - stw 31,GD_CURPROC(3) /* Zero to not accumulate cpu time */ + stw 31,GD_CURTHREAD(3) /* Zero to not accumulate cpu time */ mfsprg 3,0 lwz 31,GD_CURPCB(3) @@ -159,7 +159,7 @@ ENTRY(cpu_switch) 1: /* record new process */ mfsprg 4,0 - stw 3,GD_CURPROC(4) + stw 3,GD_CURTHREAD(4) cmpl 0,31,30 /* is it the same process? */ beq switch_return @@ -172,7 +172,7 @@ ENTRY(cpu_switch) mr 12,2 /* save r2 */ stwu 1,-SFRAMELEN(1) /* still running on old stack */ stmw 10,8(1) - lwz 3,P_ADDR(30) + lwz 3,TD_ADDR(30) stw 1,PCB_SP(3) /* save SP */ switch_exited: @@ -182,7 +182,7 @@ switch_exited: mtmsr 3 /* indicate new pcb */ - lwz 4,P_ADDR(31) + lwz 4,TD_ADDR(31) mfsprg 5,0 stw 4,GD_CURPCB(5) @@ -227,7 +227,7 @@ switch_return: bl lcsplx #endif - mr 3,30 /* get curproc for special fork + mr 3,30 /* get curthread for special fork returns */ lwz 31,12(1) diff --git a/sys/powerpc/include/globaldata.h b/sys/powerpc/include/globaldata.h index b51592a..c95a725 100644 --- a/sys/powerpc/include/globaldata.h +++ b/sys/powerpc/include/globaldata.h @@ -44,15 +44,16 @@ * point at the globaldata structure. */ struct globaldata { - 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 */ - int gd_inside_intr; + struct thread *gd_curthread; /* current thread */ + struct proc *gd_idleproc; /* idle process */ + struct thread *gd_fpcurthread; /* fp state owner */ + 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 */ + int gd_inside_intr; u_int32_t gd_next_asn; /* next ASN to allocate */ u_int32_t gd_current_asngen; /* ASN rollover check */ u_int32_t gd_intr_nesting_level; /* interrupt recursion */ diff --git a/sys/powerpc/include/globals.h b/sys/powerpc/include/globals.h index 26c21e8..6aa1a7a 100644 --- a/sys/powerpc/include/globals.h +++ b/sys/powerpc/include/globals.h @@ -45,12 +45,16 @@ * other hand, kernel modules should always use these macros to maintain * portability between UP and SMP kernels. */ -#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) + #define idleproc PCPU_GET(idleproc) #define curpcb PCPU_GET(curpcb) #define fpcurproc PCPU_GET(fpcurproc) +#define fpcurthread PCPU_GET(fpcurthread) #define switchtime PCPU_GET(switchtime) #define switchticks PCPU_GET(switchticks) #define witness_spin_check PCPU_GET(witness_spin_check) diff --git a/sys/powerpc/include/pcpu.h b/sys/powerpc/include/pcpu.h index b51592a..c95a725 100644 --- a/sys/powerpc/include/pcpu.h +++ b/sys/powerpc/include/pcpu.h @@ -44,15 +44,16 @@ * point at the globaldata structure. */ struct globaldata { - 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 */ - int gd_inside_intr; + struct thread *gd_curthread; /* current thread */ + struct proc *gd_idleproc; /* idle process */ + struct thread *gd_fpcurthread; /* fp state owner */ + 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 */ + int gd_inside_intr; u_int32_t gd_next_asn; /* next ASN to allocate */ u_int32_t gd_current_asngen; /* ASN rollover check */ u_int32_t gd_intr_nesting_level; /* interrupt recursion */ diff --git a/sys/powerpc/include/proc.h b/sys/powerpc/include/proc.h index 21b9b32..33eb778 100644 --- a/sys/powerpc/include/proc.h +++ b/sys/powerpc/include/proc.h @@ -37,5 +37,8 @@ /* * Machine-dependent part of the proc structure */ +struct mdthread { +}; + struct mdproc { }; diff --git a/sys/powerpc/powerpc/genassym.c b/sys/powerpc/powerpc/genassym.c index c140bcb..07c972b 100644 --- a/sys/powerpc/powerpc/genassym.c +++ b/sys/powerpc/powerpc/genassym.c @@ -64,7 +64,7 @@ #include <machine/pcb.h> #include <machine/pmap.h> -ASSYM(GD_CURPROC, offsetof(struct globaldata, gd_curproc)); +ASSYM(GD_CURTHREAD, offsetof(struct globaldata, gd_curthread)); ASSYM(GD_CURPCB, offsetof(struct globaldata, gd_curpcb)); ASSYM(GD_SWITCHTIME, offsetof(struct globaldata, gd_switchtime)); @@ -95,6 +95,6 @@ ASSYM(SFRAMELEN, roundup(sizeof(struct switchframe), 16)); ASSYM(PCB_PMR, offsetof(struct pcb, pcb_pmreal)); ASSYM(PCB_SP, offsetof(struct pcb, pcb_sp)); ASSYM(PCB_SPL, offsetof(struct pcb, pcb_spl)); -ASSYM(PCB_FAULT, offsetof(struct pcb, pcb_onfault)); -ASSYM(P_ADDR, offsetof(struct proc, p_addr)); +ASSYM(TD_PROC, offsetof(struct thread, td_proc)); +ASSYM(TD_ADDR, offsetof(struct thread, td_addr)); diff --git a/sys/powerpc/powerpc/mmu_oea.c b/sys/powerpc/powerpc/mmu_oea.c index e5b6198..ad79c602 100644 --- a/sys/powerpc/powerpc/mmu_oea.c +++ b/sys/powerpc/powerpc/mmu_oea.c @@ -1441,15 +1441,15 @@ next: * is the current process, load the new MMU context. */ void -pmap_activate(struct proc *p) +pmap_activate(struct thread *td) { struct pcb *pcb; pmap_t pmap; pmap_t rpm; int psl, i, ksr, seg; - pcb = &p->p_addr->u_pcb; - pmap = p->p_vmspace->vm_map.pmap; + pcb = td->td_pcb; + pmap = td->td_pric->p_vmspace->vm_map.pmap; /* * XXX Normally performed in cpu_fork(). @@ -1460,7 +1460,7 @@ pmap_activate(struct proc *p) (vm_offset_t)pcb->pcb_pm); } - if (p == curproc) { + if (td == curthread) { /* Disable interrupts while switching. */ psl = mfmsr(); mtmsr(psl & ~PSL_EE); diff --git a/sys/powerpc/powerpc/pmap.c b/sys/powerpc/powerpc/pmap.c index e5b6198..ad79c602 100644 --- a/sys/powerpc/powerpc/pmap.c +++ b/sys/powerpc/powerpc/pmap.c @@ -1441,15 +1441,15 @@ next: * is the current process, load the new MMU context. */ void -pmap_activate(struct proc *p) +pmap_activate(struct thread *td) { struct pcb *pcb; pmap_t pmap; pmap_t rpm; int psl, i, ksr, seg; - pcb = &p->p_addr->u_pcb; - pmap = p->p_vmspace->vm_map.pmap; + pcb = td->td_pcb; + pmap = td->td_pric->p_vmspace->vm_map.pmap; /* * XXX Normally performed in cpu_fork(). @@ -1460,7 +1460,7 @@ pmap_activate(struct proc *p) (vm_offset_t)pcb->pcb_pm); } - if (p == curproc) { + if (td == curthread) { /* Disable interrupts while switching. */ psl = mfmsr(); mtmsr(psl & ~PSL_EE); diff --git a/sys/powerpc/powerpc/swtch.S b/sys/powerpc/powerpc/swtch.S index 35a5ed5..af18976 100644 --- a/sys/powerpc/powerpc/swtch.S +++ b/sys/powerpc/powerpc/swtch.S @@ -143,7 +143,7 @@ ENTRY(cpu_switch) mr 30,3 mfsprg 3,0 xor 31,31,31 - stw 31,GD_CURPROC(3) /* Zero to not accumulate cpu time */ + stw 31,GD_CURTHREAD(3) /* Zero to not accumulate cpu time */ mfsprg 3,0 lwz 31,GD_CURPCB(3) @@ -159,7 +159,7 @@ ENTRY(cpu_switch) 1: /* record new process */ mfsprg 4,0 - stw 3,GD_CURPROC(4) + stw 3,GD_CURTHREAD(4) cmpl 0,31,30 /* is it the same process? */ beq switch_return @@ -172,7 +172,7 @@ ENTRY(cpu_switch) mr 12,2 /* save r2 */ stwu 1,-SFRAMELEN(1) /* still running on old stack */ stmw 10,8(1) - lwz 3,P_ADDR(30) + lwz 3,TD_ADDR(30) stw 1,PCB_SP(3) /* save SP */ switch_exited: @@ -182,7 +182,7 @@ switch_exited: mtmsr 3 /* indicate new pcb */ - lwz 4,P_ADDR(31) + lwz 4,TD_ADDR(31) mfsprg 5,0 stw 4,GD_CURPCB(5) @@ -227,7 +227,7 @@ switch_return: bl lcsplx #endif - mr 3,30 /* get curproc for special fork + mr 3,30 /* get curthread for special fork returns */ lwz 31,12(1) diff --git a/sys/powerpc/powerpc/swtch.s b/sys/powerpc/powerpc/swtch.s index 35a5ed5..af18976 100644 --- a/sys/powerpc/powerpc/swtch.s +++ b/sys/powerpc/powerpc/swtch.s @@ -143,7 +143,7 @@ ENTRY(cpu_switch) mr 30,3 mfsprg 3,0 xor 31,31,31 - stw 31,GD_CURPROC(3) /* Zero to not accumulate cpu time */ + stw 31,GD_CURTHREAD(3) /* Zero to not accumulate cpu time */ mfsprg 3,0 lwz 31,GD_CURPCB(3) @@ -159,7 +159,7 @@ ENTRY(cpu_switch) 1: /* record new process */ mfsprg 4,0 - stw 3,GD_CURPROC(4) + stw 3,GD_CURTHREAD(4) cmpl 0,31,30 /* is it the same process? */ beq switch_return @@ -172,7 +172,7 @@ ENTRY(cpu_switch) mr 12,2 /* save r2 */ stwu 1,-SFRAMELEN(1) /* still running on old stack */ stmw 10,8(1) - lwz 3,P_ADDR(30) + lwz 3,TD_ADDR(30) stw 1,PCB_SP(3) /* save SP */ switch_exited: @@ -182,7 +182,7 @@ switch_exited: mtmsr 3 /* indicate new pcb */ - lwz 4,P_ADDR(31) + lwz 4,TD_ADDR(31) mfsprg 5,0 stw 4,GD_CURPCB(5) @@ -227,7 +227,7 @@ switch_return: bl lcsplx #endif - mr 3,30 /* get curproc for special fork + mr 3,30 /* get curthread for special fork returns */ lwz 31,12(1) diff --git a/sys/sparc64/include/cpu.h b/sys/sparc64/include/cpu.h index 3a84287..91e04fa 100644 --- a/sys/sparc64/include/cpu.h +++ b/sys/sparc64/include/cpu.h @@ -50,8 +50,8 @@ #define TRAPF_PC(tfp) ((tfp)->tf_tpc) #define TRAPF_USERMODE(tfp) (((tfp)->tf_tstate & TSTATE_PRIV) == 0) -#define cpu_getstack(p) ((p)->p_frame->tf_sp) -#define cpu_setstack(p, sp) ((p)->p_frame->tf_sp = (sp)) +#define cpu_getstack(td) ((td)->td_frame->tf_sp) +#define cpu_setstack(td, sp) ((td)->td_frame->tf_sp = (sp)) /* * CTL_MACHDEP definitions. diff --git a/sys/sparc64/include/fp.h b/sys/sparc64/include/fp.h index 6305c2b..699dba8 100644 --- a/sys/sparc64/include/fp.h +++ b/sys/sparc64/include/fp.h @@ -75,8 +75,8 @@ struct fpstate { u_long fp_fprs; }; -void fp_init_proc(struct pcb *); -int fp_enable_proc(struct proc *); +void fp_init_thread(struct pcb *); +int fp_enable_thread(struct thread *); /* * Note: The pointers passed to the next two functions must be aligned on * 64 byte boundaries. diff --git a/sys/sparc64/include/frame.h b/sys/sparc64/include/frame.h index 9d1c0c6..5151ef2 100644 --- a/sys/sparc64/include/frame.h +++ b/sys/sparc64/include/frame.h @@ -80,10 +80,10 @@ struct rwindow { u_long rw_in[8]; }; -struct proc; +struct thread; -int rwindow_save(struct proc *p); -int rwindow_load(struct proc *p, struct trapframe *tf, int n); +int rwindow_save(struct thread *td); +int rwindow_load(struct thread *td, struct trapframe *tf, int n); int kdb_trap(struct trapframe *tf); diff --git a/sys/sparc64/include/globaldata.h b/sys/sparc64/include/globaldata.h index 69a7ab2..325bd08 100644 --- a/sys/sparc64/include/globaldata.h +++ b/sys/sparc64/include/globaldata.h @@ -46,8 +46,8 @@ * point at the globaldata structure. */ struct globaldata { - struct proc *gd_curproc; /* current process */ - struct proc *gd_idleproc; /* idle process */ + struct thread *gd_curthread; /* current thread */ + struct thread *gd_idlethread; /* idle thread */ struct pcb *gd_curpcb; /* current pcb */ struct timeval gd_switchtime; int gd_switchticks; diff --git a/sys/sparc64/include/globals.h b/sys/sparc64/include/globals.h index 01d48a8..951d1e2 100644 --- a/sys/sparc64/include/globals.h +++ b/sys/sparc64/include/globals.h @@ -40,9 +40,11 @@ register struct globaldata *globalp __asm__("%g7"); #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/sparc64/include/md_var.h b/sys/sparc64/include/md_var.h index d411cf4..7a0733b 100644 --- a/sys/sparc64/include/md_var.h +++ b/sys/sparc64/include/md_var.h @@ -39,14 +39,14 @@ extern int Maxmem; struct dbreg; struct fpreg; -struct proc; +struct thread; struct reg; void cpu_halt(void); void cpu_reset(void); -int fill_dbregs(struct proc *p, struct dbreg *dbregs); -int fill_fpregs(struct proc *p, struct fpreg *fpregs); -int fill_regs(struct proc *p, struct reg *regs); +int fill_dbregs(struct thread *td, struct dbreg *dbregs); +int fill_fpregs(struct thread *td, struct fpreg *fpregs); +int fill_regs(struct thread *td, struct reg *regs); void swi_vm(void *v); #endif /* !_MACHINE_MD_VAR_H_ */ diff --git a/sys/sparc64/include/param.h b/sys/sparc64/include/param.h index e669f45..2f8d6a6 100644 --- a/sys/sparc64/include/param.h +++ b/sys/sparc64/include/param.h @@ -116,7 +116,11 @@ #define MAXDUMPPGS (DFLTPHYS/PAGE_SIZE) #define IOPAGES 2 /* pages of i/o permission bitmap */ -#define UPAGES 4 /* pages of u-area */ + +#define KSTACK_PAGES 4 /* pages of kernel stack (with pcb) */ +#define UAREA_PAGES 1 /* pages of user area */ + +/* #define KSTACK_GUARD */ /* compile in kstack guard page */ /* * Constants related to network buffer management. diff --git a/sys/sparc64/include/pcpu.h b/sys/sparc64/include/pcpu.h index 69a7ab2..325bd08 100644 --- a/sys/sparc64/include/pcpu.h +++ b/sys/sparc64/include/pcpu.h @@ -46,8 +46,8 @@ * point at the globaldata structure. */ struct globaldata { - struct proc *gd_curproc; /* current process */ - struct proc *gd_idleproc; /* idle process */ + struct thread *gd_curthread; /* current thread */ + struct thread *gd_idlethread; /* idle thread */ struct pcb *gd_curpcb; /* current pcb */ struct timeval gd_switchtime; int gd_switchticks; diff --git a/sys/sparc64/include/proc.h b/sys/sparc64/include/proc.h index c6df75d..84ada25 100644 --- a/sys/sparc64/include/proc.h +++ b/sys/sparc64/include/proc.h @@ -41,6 +41,9 @@ #include <machine/globals.h> #include <machine/tte.h> +struct mdthread { +}; + struct mdproc { }; diff --git a/sys/sparc64/include/reg.h b/sys/sparc64/include/reg.h index b0b7a61..bd3414c 100644 --- a/sys/sparc64/include/reg.h +++ b/sys/sparc64/include/reg.h @@ -39,10 +39,10 @@ struct dbreg { }; #ifdef _KERNEL -int set_fpregs(struct proc *p, struct fpreg *fpregs); -int set_regs(struct proc *p, struct reg *regs); -void setregs(struct proc *p, u_long e, u_long s, u_long ps); -int set_dbregs(struct proc *p, struct dbreg *dbregs); +int set_fpregs(struct thread *td, struct fpreg *fpregs); +int set_regs(struct thread *td, struct reg *regs); +void setregs(struct thread *td, u_long e, u_long s, u_long ps); +int set_dbregs(struct thread *td, struct dbreg *dbregs); #endif #endif /* !_MACHINE_REG_H_ */ diff --git a/sys/sparc64/sparc64/exception.S b/sys/sparc64/sparc64/exception.S index 8a10c17..b9090b3 100644 --- a/sys/sparc64/sparc64/exception.S +++ b/sys/sparc64/sparc64/exception.S @@ -313,8 +313,9 @@ ENTRY(tl0_kstack_fixup) wrpr %o1, 0, %wstate wrpr %o0, 0, %otherwin wrpr %g0, 0, %canrestore - ldx [PCPU(CURPCB)], %o0 - set UPAGES * PAGE_SIZE - SPOFF - CCFSZ, %o1 + ldx [PCPU(CURTHREAD)], %o0 + ldx [%o0 + TD_KSTACK], %o0 + set KSTACK_PAGES * PAGE_SIZE - SPOFF - CCFSZ, %o1 retl add %o0, %o1, %sp END(tl0_kstack_fixup) @@ -1021,9 +1022,9 @@ END(tl1_align_trap) ENTRY(intr_enqueue) #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "intr_enqueue: p=%p (%s) tl=%#lx pc=%#lx sp=%#lx" + CATR(KTR_CT1, "intr_enqueue: td=%p (%s) tl=%#lx pc=%#lx sp=%#lx" , %g1, %g2, %g3, 7, 8, 9) - ldx [PCPU(CURPROC)], %g2 + ldx [PCPU(CURTHREAD)], %g2 stx %g2, [%g1 + KTR_PARM1] add %g2, P_COMM, %g2 stx %g2, [%g1 + KTR_PARM2] @@ -1818,9 +1819,9 @@ ENTRY(tl0_trap) stx %g7, [%sp + SPOFF + CCFSZ + TF_G7] #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "tl0_trap: p=%p type=%#x arg=%#lx pil=%#lx ws=%#lx" + CATR(KTR_CT1, "tl0_trap: td=%p type=%#x arg=%#lx pil=%#lx ws=%#lx" , %g1, %g2, %g3, 7, 8, 9) - ldx [PCPU(CURPROC)], %g2 + ldx [PCPU(CURTHREAD)], %g2 stx %g2, [%g1 + KTR_PARM1] stx %o0, [%g1 + KTR_PARM2] stx %o1, [%g1 + KTR_PARM3] @@ -1848,9 +1849,9 @@ END(tl0_trap) /* Return to tl0 (user process). */ ENTRY(tl0_ret) #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "tl0_ret: p=%p (%s) pil=%#lx sflag=%#x" + CATR(KTR_CT1, "tl0_ret: td=%p (%s) pil=%#lx sflag=%#x" , %g1, %g2, %g3, 7, 8, 9) - ldx [PCPU(CURPROC)], %g2 + ldx [PCPU(CURTHREAD)], %g2 stx %g2, [%g1 + KTR_PARM1] add %g2, P_COMM, %g3 stx %g3, [%g1 + KTR_PARM2] @@ -1862,9 +1863,10 @@ ENTRY(tl0_ret) #endif wrpr %g0, PIL_TICK, %pil - ldx [PCPU(CURPROC)], %o0 - lduw [%o0 + P_SFLAG], %o1 - and %o1, PS_ASTPENDING | PS_NEEDRESCHED, %o1 + ldx [PCPU(CURTHREAD)], %o0 + ldx [%o0 + TD_KSE], %o0 + lduw [%o0 + KE_FLAGS], %o1 + and %o1, KEF_ASTPENDING | KEF_NEEDRESCHED, %o1 brz,pt %o1, 1f nop call ast @@ -1927,9 +1929,9 @@ ENTRY(tl0_ret) tl0_ret_fill: #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "tl0_ret: return p=%#lx pil=%#lx ts=%#lx pc=%#lx sp=%#lx" + CATR(KTR_CT1, "tl0_ret: return td=%#lx pil=%#lx ts=%#lx pc=%#lx sp=%#lx" , %g2, %g3, %g4, 7, 8, 9) - ldx [PCPU(CURPROC)], %g3 + ldx [PCPU(CURTHREAD)], %g3 stx %g3, [%g2 + KTR_PARM1] rdpr %tstate, %g3 stx %g3, [%g2 + KTR_PARM2] @@ -1993,9 +1995,9 @@ ENTRY(tl1_trap) and %l4, %l5, %l4 brz %l4, 9f nop - CATR(KTR_CT1, "tl1_trap: p=%p pil=%#lx type=%#lx arg=%#lx pc=%#lx" + CATR(KTR_CT1, "tl1_trap: td=%p pil=%#lx type=%#lx arg=%#lx pc=%#lx" , %l3, %l4, %l5, 7, 8, 9) - ldx [PCPU(CURPROC)], %l4 + ldx [PCPU(CURTHREAD)], %l4 stx %l4, [%l3 + KTR_PARM1] #if 0 add %l4, P_COMM, %l4 @@ -2062,9 +2064,9 @@ ENTRY(tl1_trap) and %l4, %l5, %l4 brz %l4, 9f nop - CATR(KTR_CT1, "tl1_trap: return p=%p pil=%#lx sp=%#lx pc=%#lx" + CATR(KTR_CT1, "tl1_trap: return td=%p pil=%#lx sp=%#lx pc=%#lx" , %l3, %l4, %l5, 7, 8, 9) - ldx [PCPU(CURPROC)], %l4 + ldx [PCPU(CURTHREAD)], %l4 stx %l4, [%l3 + KTR_PARM1] stx %l0, [%l3 + KTR_PARM2] stx %sp, [%l3 + KTR_PARM3] @@ -2083,9 +2085,9 @@ END(tl1_trap) */ ENTRY(fork_trampoline) #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "fork_trampoline: p=%p (%s) cwp=%#lx" + CATR(KTR_CT1, "fork_trampoline: td=%p (%s) cwp=%#lx" , %g1, %g2, %g3, 7, 8, 9) - ldx [PCPU(CURPROC)], %g2 + ldx [PCPU(CURTHREAD)], %g2 stx %g2, [%g1 + KTR_PARM1] add %g2, P_COMM, %g2 stx %g2, [%g1 + KTR_PARM2] diff --git a/sys/sparc64/sparc64/exception.s b/sys/sparc64/sparc64/exception.s index 8a10c17..b9090b3 100644 --- a/sys/sparc64/sparc64/exception.s +++ b/sys/sparc64/sparc64/exception.s @@ -313,8 +313,9 @@ ENTRY(tl0_kstack_fixup) wrpr %o1, 0, %wstate wrpr %o0, 0, %otherwin wrpr %g0, 0, %canrestore - ldx [PCPU(CURPCB)], %o0 - set UPAGES * PAGE_SIZE - SPOFF - CCFSZ, %o1 + ldx [PCPU(CURTHREAD)], %o0 + ldx [%o0 + TD_KSTACK], %o0 + set KSTACK_PAGES * PAGE_SIZE - SPOFF - CCFSZ, %o1 retl add %o0, %o1, %sp END(tl0_kstack_fixup) @@ -1021,9 +1022,9 @@ END(tl1_align_trap) ENTRY(intr_enqueue) #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "intr_enqueue: p=%p (%s) tl=%#lx pc=%#lx sp=%#lx" + CATR(KTR_CT1, "intr_enqueue: td=%p (%s) tl=%#lx pc=%#lx sp=%#lx" , %g1, %g2, %g3, 7, 8, 9) - ldx [PCPU(CURPROC)], %g2 + ldx [PCPU(CURTHREAD)], %g2 stx %g2, [%g1 + KTR_PARM1] add %g2, P_COMM, %g2 stx %g2, [%g1 + KTR_PARM2] @@ -1818,9 +1819,9 @@ ENTRY(tl0_trap) stx %g7, [%sp + SPOFF + CCFSZ + TF_G7] #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "tl0_trap: p=%p type=%#x arg=%#lx pil=%#lx ws=%#lx" + CATR(KTR_CT1, "tl0_trap: td=%p type=%#x arg=%#lx pil=%#lx ws=%#lx" , %g1, %g2, %g3, 7, 8, 9) - ldx [PCPU(CURPROC)], %g2 + ldx [PCPU(CURTHREAD)], %g2 stx %g2, [%g1 + KTR_PARM1] stx %o0, [%g1 + KTR_PARM2] stx %o1, [%g1 + KTR_PARM3] @@ -1848,9 +1849,9 @@ END(tl0_trap) /* Return to tl0 (user process). */ ENTRY(tl0_ret) #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "tl0_ret: p=%p (%s) pil=%#lx sflag=%#x" + CATR(KTR_CT1, "tl0_ret: td=%p (%s) pil=%#lx sflag=%#x" , %g1, %g2, %g3, 7, 8, 9) - ldx [PCPU(CURPROC)], %g2 + ldx [PCPU(CURTHREAD)], %g2 stx %g2, [%g1 + KTR_PARM1] add %g2, P_COMM, %g3 stx %g3, [%g1 + KTR_PARM2] @@ -1862,9 +1863,10 @@ ENTRY(tl0_ret) #endif wrpr %g0, PIL_TICK, %pil - ldx [PCPU(CURPROC)], %o0 - lduw [%o0 + P_SFLAG], %o1 - and %o1, PS_ASTPENDING | PS_NEEDRESCHED, %o1 + ldx [PCPU(CURTHREAD)], %o0 + ldx [%o0 + TD_KSE], %o0 + lduw [%o0 + KE_FLAGS], %o1 + and %o1, KEF_ASTPENDING | KEF_NEEDRESCHED, %o1 brz,pt %o1, 1f nop call ast @@ -1927,9 +1929,9 @@ ENTRY(tl0_ret) tl0_ret_fill: #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "tl0_ret: return p=%#lx pil=%#lx ts=%#lx pc=%#lx sp=%#lx" + CATR(KTR_CT1, "tl0_ret: return td=%#lx pil=%#lx ts=%#lx pc=%#lx sp=%#lx" , %g2, %g3, %g4, 7, 8, 9) - ldx [PCPU(CURPROC)], %g3 + ldx [PCPU(CURTHREAD)], %g3 stx %g3, [%g2 + KTR_PARM1] rdpr %tstate, %g3 stx %g3, [%g2 + KTR_PARM2] @@ -1993,9 +1995,9 @@ ENTRY(tl1_trap) and %l4, %l5, %l4 brz %l4, 9f nop - CATR(KTR_CT1, "tl1_trap: p=%p pil=%#lx type=%#lx arg=%#lx pc=%#lx" + CATR(KTR_CT1, "tl1_trap: td=%p pil=%#lx type=%#lx arg=%#lx pc=%#lx" , %l3, %l4, %l5, 7, 8, 9) - ldx [PCPU(CURPROC)], %l4 + ldx [PCPU(CURTHREAD)], %l4 stx %l4, [%l3 + KTR_PARM1] #if 0 add %l4, P_COMM, %l4 @@ -2062,9 +2064,9 @@ ENTRY(tl1_trap) and %l4, %l5, %l4 brz %l4, 9f nop - CATR(KTR_CT1, "tl1_trap: return p=%p pil=%#lx sp=%#lx pc=%#lx" + CATR(KTR_CT1, "tl1_trap: return td=%p pil=%#lx sp=%#lx pc=%#lx" , %l3, %l4, %l5, 7, 8, 9) - ldx [PCPU(CURPROC)], %l4 + ldx [PCPU(CURTHREAD)], %l4 stx %l4, [%l3 + KTR_PARM1] stx %l0, [%l3 + KTR_PARM2] stx %sp, [%l3 + KTR_PARM3] @@ -2083,9 +2085,9 @@ END(tl1_trap) */ ENTRY(fork_trampoline) #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "fork_trampoline: p=%p (%s) cwp=%#lx" + CATR(KTR_CT1, "fork_trampoline: td=%p (%s) cwp=%#lx" , %g1, %g2, %g3, 7, 8, 9) - ldx [PCPU(CURPROC)], %g2 + ldx [PCPU(CURTHREAD)], %g2 stx %g2, [%g1 + KTR_PARM1] add %g2, P_COMM, %g2 stx %g2, [%g1 + KTR_PARM2] diff --git a/sys/sparc64/sparc64/fp.c b/sys/sparc64/sparc64/fp.c index 756869a..e6762f2 100644 --- a/sys/sparc64/sparc64/fp.c +++ b/sys/sparc64/sparc64/fp.c @@ -36,7 +36,7 @@ #include <machine/tstate.h> void -fp_init_proc(struct pcb *pcb) +fp_init_thread(struct pcb *pcb) { bzero(&pcb->pcb_fpstate.fp_fb, sizeof(pcb->pcb_fpstate.fp_fb)); @@ -45,12 +45,12 @@ fp_init_proc(struct pcb *pcb) } int -fp_enable_proc(struct proc *p) +fp_enable_thread(struct thread *td) { struct pcb *pcb; - pcb = &p->p_addr->u_pcb; - if ((p->p_frame->tf_tstate & TSTATE_PEF) != 0 && + pcb = td->td_pcb; + if ((td->td_frame->tf_tstate & TSTATE_PEF) != 0 && (pcb->pcb_fpstate.fp_fprs & FPRS_FEF) == 0) { /* * Enable FEF for now. The SCD mandates that this should be @@ -61,10 +61,10 @@ fp_enable_proc(struct proc *p) return (1); } - if ((p->p_frame->tf_tstate & TSTATE_PEF) != 0) + if ((td->td_frame->tf_tstate & TSTATE_PEF) != 0) return (0); mtx_lock_spin(&sched_lock); - p->p_frame->tf_tstate |= TSTATE_PEF; + td->td_frame->tf_tstate |= TSTATE_PEF; /* Actually load the FP state into the registers. */ restorefpctx(&pcb->pcb_fpstate); mtx_unlock_spin(&sched_lock); diff --git a/sys/sparc64/sparc64/genassym.c b/sys/sparc64/sparc64/genassym.c index fa85ebc..6039621 100644 --- a/sys/sparc64/sparc64/genassym.c +++ b/sys/sparc64/sparc64/genassym.c @@ -68,7 +68,8 @@ ASSYM(ASI_BLK_S, ASI_BLK_S); ASSYM(EFAULT, EFAULT); ASSYM(ENAMETOOLONG, ENAMETOOLONG); -ASSYM(UPAGES, UPAGES); +ASSYM(KSTACK_PAGES, KSTACK_PAGES); +ASSYM(UAREA_PAGES, UAREA_PAGES); ASSYM(PAGE_SIZE, PAGE_SIZE); ASSYM(PIL_TICK, PIL_TICK); @@ -122,7 +123,7 @@ ASSYM(TT_VA_MASK, TT_VA_MASK); ASSYM(TT_VA_SHIFT, TT_VA_SHIFT); ASSYM(TT_CTX_SHIFT, TT_CTX_SHIFT); -ASSYM(GD_CURPROC, offsetof(struct globaldata, gd_curproc)); +ASSYM(GD_CURTHREAD, offsetof(struct globaldata, gd_curthread)); ASSYM(GD_CURPCB, offsetof(struct globaldata, gd_curpcb)); ASSYM(GD_CPUID, offsetof(struct globaldata, gd_cpuid)); @@ -149,15 +150,21 @@ ASSYM(JB_FP, offsetof(struct _jmp_buf, _jb[_JB_FP])); ASSYM(JB_PC, offsetof(struct _jmp_buf, _jb[_JB_PC])); ASSYM(JB_SP, offsetof(struct _jmp_buf, _jb[_JB_SP])); -ASSYM(PS_ASTPENDING, PS_ASTPENDING); -ASSYM(PS_NEEDRESCHED, PS_NEEDRESCHED); +ASSYM(KEF_ASTPENDING, KEF_ASTPENDING); +ASSYM(KEF_NEEDRESCHED, KEF_NEEDRESCHED); -ASSYM(P_ADDR, offsetof(struct proc, p_addr)); ASSYM(P_COMM, offsetof(struct proc, p_comm)); -ASSYM(P_FRAME, offsetof(struct proc, p_frame)); ASSYM(P_SFLAG, offsetof(struct proc, p_sflag)); ASSYM(P_VMSPACE, offsetof(struct proc, p_vmspace)); +ASSYM(KE_FLAGS, offsetof(struct kse, ke_flags)); + +ASSYM(TD_FRAME, offsetof(struct thread, td_frame)); +ASSYM(TD_KSE, offsetof(struct thread, td_kse)); +ASSYM(TD_KSTACK, offsetof(struct thread, td_kstack)); +ASSYM(TD_PCB, offsetof(struct thread, td_pcb)); +ASSYM(TD_PROC, offsetof(struct thread, td_proc)); + ASSYM(PCB_FPSTATE, offsetof(struct pcb, pcb_fpstate)); ASSYM(PCB_FP, offsetof(struct pcb, pcb_fp)); ASSYM(PCB_PC, offsetof(struct pcb, pcb_pc)); @@ -170,8 +177,6 @@ ASSYM(PCB_RW, offsetof(struct pcb, pcb_rw)); ASSYM(PCB_CWP_EMPTY, PCB_CWP_EMPTY); -ASSYM(U_PCB, offsetof(struct user, u_pcb)); - ASSYM(VM_PMAP, offsetof(struct vmspace, vm_pmap)); ASSYM(PM_CONTEXT, offsetof(struct pmap, pm_context)); ASSYM(PM_STTE, offsetof(struct pmap, pm_stte)); diff --git a/sys/sparc64/sparc64/locore.S b/sys/sparc64/sparc64/locore.S index 31ce6e0..34a9d6f 100644 --- a/sys/sparc64/sparc64/locore.S +++ b/sys/sparc64/sparc64/locore.S @@ -45,7 +45,7 @@ ENTRY(_start) wrpr %g0, 0, %cleanwin wrpr %g0, 0, %pil - setx user0 + UPAGES * PAGE_SIZE - SPOFF, %l0, %o5 + setx kstack0 + KSTACK_PAGES * PAGE_SIZE - SPOFF, %l0, %o5 save %o5, -CCFSZ, %sp mov %g1, %o0 diff --git a/sys/sparc64/sparc64/locore.s b/sys/sparc64/sparc64/locore.s index 31ce6e0..34a9d6f 100644 --- a/sys/sparc64/sparc64/locore.s +++ b/sys/sparc64/sparc64/locore.s @@ -45,7 +45,7 @@ ENTRY(_start) wrpr %g0, 0, %cleanwin wrpr %g0, 0, %pil - setx user0 + UPAGES * PAGE_SIZE - SPOFF, %l0, %o5 + setx kstack0 + KSTACK_PAGES * PAGE_SIZE - SPOFF, %l0, %o5 save %o5, -CCFSZ, %sp mov %g1, %o0 diff --git a/sys/sparc64/sparc64/machdep.c b/sys/sparc64/sparc64/machdep.c index b26a9a7..f17d935 100644 --- a/sys/sparc64/sparc64/machdep.c +++ b/sys/sparc64/sparc64/machdep.c @@ -77,6 +77,7 @@ #include <machine/bootinfo.h> #include <machine/clock.h> #include <machine/cpu.h> +#include <machine/fp.h> #include <machine/intr_machdep.h> #include <machine/md_var.h> #include <machine/pmap.h> @@ -109,8 +110,10 @@ struct globaldata __globaldata; * does not have an fp state (which it doesn't normally). * This constraint is only here for debugging. */ -char user0[UPAGES * PAGE_SIZE] __attribute__ ((aligned (64))); -struct user *proc0paddr; +char uarea0[UAREA_PAGES * PAGE_SIZE] __attribute__ ((aligned (64))); +char kstack0[KSTACK_PAGES * PAGE_SIZE] __attribute__ ((aligned (64))); +struct user *proc0uarea; +vm_offset_t proc0kstack; struct kva_md_info kmi; @@ -232,17 +235,21 @@ sparc64_init(struct bootinfo *bi, ofw_vec_t *vec) wrpr(tl, 0, 1); wrpr(tba, tl0_base, 0); + proc_linkup(&proc0); /* * Initialize proc0 stuff (p_contested needs to be done early). */ - LIST_INIT(&proc0.p_contested); - proc0paddr = (struct user *)user0; - proc0.p_addr = (struct user *)user0; - proc0.p_stats = &proc0.p_addr->u_stats; - tf = (struct trapframe *)(user0 + UPAGES * PAGE_SIZE - - sizeof(struct frame) - sizeof(*tf)); - proc0.p_frame = tf; - tf->tf_tstate = 0; + proc0uarea = (struct user *)uarea0; + proc0kstack = (vm_offset_t)kstack0; + proc0.p_uarea = proc0uarea; + proc0.p_stats = &proc0.p_uarea->u_stats; + thread0 = &proc0.p_thread; + thread0->td_kstack = proc0kstack; + tf = (struct trapframe *)(thread0->td_kstack + KSTACK_PAGES * + PAGE_SIZE) - 1; + tf->tf_tstate = TSTATE_IE; + thread0->td_frame = tf; + LIST_INIT(&thread0->td_contested); /* * Initialize the per-cpu pointer so we can set curproc. @@ -275,8 +282,8 @@ sparc64_init(struct bootinfo *bi, ofw_vec_t *vec) /* * Initialize curproc so that mutexes work. */ - PCPU_SET(curproc, &proc0); - PCPU_SET(curpcb, &((struct user *)user0)->u_pcb); + PCPU_SET(curthread, thread0); + PCPU_SET(curpcb, thread0->td_pcb); PCPU_SET(spinlocks, NULL); /* @@ -303,19 +310,21 @@ sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) struct sigframe *sfp; struct sigacts *psp; struct sigframe sf; + struct thread *td; struct proc *p; u_long sp; int oonstack; oonstack = 0; - p = curproc; + td = curthread; + p = td->td_proc; PROC_LOCK(p); psp = p->p_sigacts; - tf = p->p_frame; + tf = td->td_frame; sp = tf->tf_sp + SPOFF; oonstack = sigonstack(sp); - CTR4(KTR_SIG, "sendsig: p=%p (%s) catcher=%p sig=%d", p, p->p_comm, + CTR4(KTR_SIG, "sendsig: td=%p (%s) catcher=%p sig=%d", td, p->p_comm, catcher, sig); /* Save user context. */ @@ -356,7 +365,7 @@ sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) * Process has trashed its stack; give it an illegal * instruction to halt it in its tracks. */ - CTR2(KTR_SIG, "sendsig: trashed stack p=%p sfp=%p", p, sfp); + CTR2(KTR_SIG, "sendsig: trashed stack td=%p sfp=%p", td, sfp); PROC_LOCK(p); SIGACTION(p, SIGILL) = SIG_DFL; SIGDELSET(p->p_sigignore, SIGILL); @@ -392,14 +401,14 @@ sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) PROC_UNLOCK(p); /* Copy the sigframe out to the user's stack. */ - if (rwindow_save(p) != 0 || copyout(&sf, sfp, sizeof(*sfp)) != 0) { + if (rwindow_save(td) != 0 || copyout(&sf, sfp, sizeof(*sfp)) != 0) { /* * Something is wrong with the stack pointer. * ...Kill the process. */ - CTR2(KTR_SIG, "sendsig: sigexit p=%p sfp=%p", p, sfp); + CTR2(KTR_SIG, "sendsig: sigexit td=%p sfp=%p", td, sfp); PROC_LOCK(p); - sigexit(p, SIGILL); + sigexit(td, SIGILL); /* NOTREACHED */ } @@ -407,7 +416,7 @@ sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code) tf->tf_tnpc = tf->tf_tpc + 4; tf->tf_sp = (u_long)sfp - SPOFF; - CTR3(KTR_SIG, "sendsig: return p=%p pc=%#lx sp=%#lx", p, tf->tf_tpc, + CTR3(KTR_SIG, "sendsig: return td=%p pc=%#lx sp=%#lx", td, tf->tf_tpc, tf->tf_sp); } @@ -418,26 +427,28 @@ struct sigreturn_args { #endif int -sigreturn(struct proc *p, struct sigreturn_args *uap) +sigreturn(struct thread *td, struct sigreturn_args *uap) { struct trapframe *tf; + struct proc *p; ucontext_t uc; - if (rwindow_save(p)) { + p = td->td_proc; + if (rwindow_save(td)) { PROC_LOCK(p); - sigexit(p, SIGILL); + sigexit(td, SIGILL); } - CTR2(KTR_SIG, "sigreturn: p=%p ucp=%p", p, uap->sigcntxp); + CTR2(KTR_SIG, "sigreturn: td=%p ucp=%p", td, uap->sigcntxp); if (copyin(uap->sigcntxp, &uc, sizeof(uc)) != 0) { - CTR1(KTR_SIG, "sigreturn: efault p=%p", p); + CTR1(KTR_SIG, "sigreturn: efault td=%p", td); return (EFAULT); } if (((uc.uc_mcontext.mc_tpc | uc.uc_mcontext.mc_tnpc) & 3) != 0) return (EINVAL); - tf = p->p_frame; + tf = td->td_frame; bcopy(uc.uc_mcontext.mc_global, tf->tf_global, sizeof(tf->tf_global)); bcopy(uc.uc_mcontext.mc_out, tf->tf_out, sizeof(tf->tf_out)); @@ -456,8 +467,8 @@ sigreturn(struct proc *p, struct sigreturn_args *uap) p->p_sigmask = uc.uc_sigmask; SIG_CANTMASK(p->p_sigmask); PROC_UNLOCK(p); - CTR4(KTR_SIG, "sigreturn: return p=%p pc=%#lx sp=%#lx tstate=%#lx", - p, tf->tf_tpc, tf->tf_sp, tf->tf_tstate); + CTR4(KTR_SIG, "sigreturn: return td=%p pc=%#lx sp=%#lx tstate=%#lx", + td, tf->tf_tpc, tf->tf_sp, tf->tf_tstate); return (EJUSTRETURN); } @@ -468,43 +479,43 @@ cpu_halt(void) } int -ptrace_set_pc(struct proc *p, u_long addr) +ptrace_set_pc(struct thread *td, u_long addr) { - p->p_frame->tf_tpc = addr; - p->p_frame->tf_tnpc = addr + 4; + td->td_frame->tf_tpc = addr; + td->td_frame->tf_tnpc = addr + 4; return (0); } int -ptrace_single_step(struct proc *p) +ptrace_single_step(struct thread *td) { TODO; return (0); } 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 pcb *pcb; struct frame *fp; /* Round the stack down to a multiple of 16 bytes. */ stack = ((stack) / 16) * 16; - pcb = &p->p_addr->u_pcb; + pcb = td->td_pcb; /* XXX: honor the real number of windows... */ bzero(pcb->pcb_rw, sizeof(pcb->pcb_rw)); /* The inital window for the process (%cw = 0). */ - fp = (struct frame *)((caddr_t)p->p_addr + UPAGES * PAGE_SIZE) - 1; + fp = (struct frame *)(td->td_kstack + KSTACK_PAGES * PAGE_SIZE) - 1; /* Make sure the frames that are frobbed are actually flushed. */ __asm __volatile("flushw"); mtx_lock_spin(&sched_lock); - fp_init_proc(pcb); + fp_init_thread(pcb); /* Setup state in the trap frame. */ - p->p_frame->tf_tstate = TSTATE_IE; - p->p_frame->tf_tpc = entry; - p->p_frame->tf_tnpc = entry + 4; - p->p_frame->tf_pil = 0; + td->td_frame->tf_tstate = TSTATE_IE; + td->td_frame->tf_tpc = entry; + td->td_frame->tf_tnpc = entry + 4; + td->td_frame->tf_pil = 0; /* * Set up the registers for the user. * The SCD (2.4.1) mandates: @@ -514,11 +525,11 @@ setregs(struct proc *p, u_long entry, u_long stack, u_long ps_strings) * - %g1, if != 0, passes a function pointer which should be registered * with atexit(). */ - bzero(p->p_frame->tf_out, sizeof(p->p_frame->tf_out)); - bzero(p->p_frame->tf_global, sizeof(p->p_frame->tf_global)); + bzero(td->td_frame->tf_out, sizeof(td->td_frame->tf_out)); + bzero(td->td_frame->tf_global, sizeof(td->td_frame->tf_global)); /* Set up user stack. */ fp->f_fp = stack - SPOFF; - p->p_frame->tf_out[6] = stack - SPOFF - sizeof(struct frame); + td->td_frame->tf_out[6] = stack - SPOFF - sizeof(struct frame); wr(y, 0, 0); mtx_unlock_spin(&sched_lock); } @@ -532,42 +543,42 @@ Debugger(const char *msg) } int -fill_dbregs(struct proc *p, struct dbreg *dbregs) +fill_dbregs(struct thread *td, struct dbreg *dbregs) { TODO; return (0); } int -set_dbregs(struct proc *p, struct dbreg *dbregs) +set_dbregs(struct thread *td, struct dbreg *dbregs) { TODO; return (0); } int -fill_regs(struct proc *p, struct reg *regs) +fill_regs(struct thread *td, struct reg *regs) { TODO; return (0); } int -set_regs(struct proc *p, struct reg *regs) +set_regs(struct thread *td, struct reg *regs) { TODO; return (0); } int -fill_fpregs(struct proc *p, struct fpreg *fpregs) +fill_fpregs(struct thread *td, struct fpreg *fpregs) { TODO; return (0); } int -set_fpregs(struct proc *p, struct fpreg *fpregs) +set_fpregs(struct thread *td, struct fpreg *fpregs) { TODO; return (0); diff --git a/sys/sparc64/sparc64/pmap.c b/sys/sparc64/sparc64/pmap.c index 368f931..bc119d6 100644 --- a/sys/sparc64/sparc64/pmap.c +++ b/sys/sparc64/sparc64/pmap.c @@ -560,7 +560,7 @@ pmap_pageable(pmap_t pmap, vm_offset_t sva, vm_offset_t eva, } /* - * Create the kernel stack and user structure for a new process. This + * Create the user structure for a new process. This * routine directly affects the performance of fork(). */ void @@ -573,16 +573,16 @@ pmap_new_proc(struct proc *p) o = p->p_upages_obj; if (o == NULL) { - o = vm_object_allocate(OBJT_DEFAULT, UPAGES); + o = vm_object_allocate(OBJT_DEFAULT, UAREA_PAGES); p->p_upages_obj = o; } - u = (vm_offset_t)p->p_addr; + u = (vm_offset_t)p->p_uarea; if (u == 0) { - u = kmem_alloc_nofault(kernel_map, UPAGES * PAGE_SIZE); + u = kmem_alloc_nofault(kernel_map, UAREA_PAGES * PAGE_SIZE); KASSERT(u != NULL, ("pmap_new_proc: u area\n")); - p->p_addr = (struct user *)u; + p->p_uarea = (struct user *)u; } - for (i = 0; i < UPAGES; i++) { + for (i = 0; i < UAREA_PAGES; i++) { m = vm_page_grab(o, i, VM_ALLOC_NORMAL | VM_ALLOC_RETRY); m->wire_count++; cnt.v_wire_count++; @@ -603,8 +603,8 @@ pmap_dispose_proc(struct proc *p) int i; 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_dispose_proc: upage already missing?"); @@ -615,6 +615,62 @@ pmap_dispose_proc(struct proc *p) } } +/* + * Create the kernel stack for a new thread. This + * routine directly affects the performance of fork(). + */ +void +pmap_new_thread(struct thread *td) +{ + vm_object_t ksobj; + vm_offset_t ks; + vm_page_t m; + u_int i; + + ksobj = td->td_kstack_obj; + if (ksobj == NULL) { + ksobj = vm_object_allocate(OBJT_DEFAULT, KSTACK_PAGES); + td->td_kstack_obj = ksobj; + } + ks = td->td_kstack; + if (ks == 0) { + ks = kmem_alloc_nofault(kernel_map, KSTACK_PAGES * PAGE_SIZE); + KASSERT(ks != NULL, ("pmap_new_thread: kstack\n")); + td->td_kstack = ks; + } + for (i = 0; i < KSTACK_PAGES; i++) { + m = vm_page_grab(ksobj, i, VM_ALLOC_NORMAL | VM_ALLOC_RETRY); + m->wire_count++; + cnt.v_wire_count++; + pmap_kenter(ks + i * PAGE_SIZE, VM_PAGE_TO_PHYS(m)); + 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; + } +} + +void +pmap_dispose_thread(struct thread *td) +{ + vm_object_t ksobj; + vm_offset_t ks; + vm_page_t m; + int i; + + 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_dispose_proc: upage already missing?"); + vm_page_busy(m); + pmap_kremove(ks + i * PAGE_SIZE); + vm_page_unwire(m, 0); + vm_page_free(m); + } +} + void pmap_page_protect(vm_page_t m, vm_prot_t prot) { @@ -664,7 +720,7 @@ pmap_ts_referenced(vm_page_t m) } void -pmap_activate(struct proc *p) +pmap_activate(struct thread *td) { TODO; } @@ -839,3 +895,15 @@ pmap_swapout_proc(struct proc *p) { TODO; } + +void +pmap_swapin_thread(struct thread *td) +{ + TODO; +} + +void +pmap_swapout_thread(struct thread *td) +{ + TODO; +} diff --git a/sys/sparc64/sparc64/procfs_machdep.c b/sys/sparc64/sparc64/procfs_machdep.c index 4fb0471..f813f19 100644 --- a/sys/sparc64/sparc64/procfs_machdep.c +++ b/sys/sparc64/sparc64/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,31 +94,31 @@ } while(0) int -procfs_read_regs(struct proc *p, struct reg *regs) +procfs_read_regs(struct thread *td, struct reg *regs) { - PROCFS_ACTION(fill_regs(p, regs)); + PROCFS_ACTION(fill_regs(td, regs)); } int -procfs_write_regs(struct proc *p, struct reg *regs) +procfs_write_regs(struct thread *td, struct reg *regs) { - PROCFS_ACTION(set_regs(p, regs)); + PROCFS_ACTION(set_regs(td, regs)); } int -procfs_read_dbregs(struct proc *p, struct dbreg *dbregs) +procfs_read_dbregs(struct thread *td, struct dbreg *dbregs) { - PROCFS_ACTION(fill_dbregs(p, dbregs)); + PROCFS_ACTION(fill_dbregs(td, dbregs)); } int -procfs_write_dbregs(struct proc *p, struct dbreg *dbregs) +procfs_write_dbregs(struct thread *td, struct dbreg *dbregs) { - PROCFS_ACTION(set_dbregs(p, dbregs)); + PROCFS_ACTION(set_dbregs(td, dbregs)); } /* @@ -127,22 +127,22 @@ procfs_write_dbregs(struct proc *p, struct dbreg *dbregs) */ int -procfs_read_fpregs(struct proc *p, struct fpreg *fpregs) +procfs_read_fpregs(struct thread *td, struct fpreg *fpregs) { - PROCFS_ACTION(fill_fpregs(p, fpregs)); + PROCFS_ACTION(fill_fpregs(td, fpregs)); } int -procfs_write_fpregs(struct proc *p, struct fpreg *fpregs) +procfs_write_fpregs(struct thread *td, struct fpreg *fpregs) { - PROCFS_ACTION(set_fpregs(p, fpregs)); + PROCFS_ACTION(set_fpregs(td, fpregs)); } int -procfs_sstep(struct proc *p) +procfs_sstep(struct thread *td) { - PROCFS_ACTION(ptrace_single_step(p)); + PROCFS_ACTION(ptrace_single_step(td)); } diff --git a/sys/sparc64/sparc64/rwindow.c b/sys/sparc64/sparc64/rwindow.c index 474e6a9..5bcd9fb 100644 --- a/sys/sparc64/sparc64/rwindow.c +++ b/sys/sparc64/sparc64/rwindow.c @@ -38,7 +38,7 @@ #include <machine/frame.h> int -rwindow_load(struct proc *p, struct trapframe *tf, int n) +rwindow_load(struct thread *td, struct trapframe *tf, int n) { struct rwindow rw; u_long usp; @@ -49,11 +49,11 @@ rwindow_load(struct proc *p, struct trapframe *tf, int n) * In case current window is still only on-chip, push it out; * if it cannot get all the way out, we cannot continue either. */ - if ((error = rwindow_save(p)) != 0) + if ((error = rwindow_save(td)) != 0) return (error); usp = tf->tf_out[6]; - CTR3(KTR_TRAP, "rwindow_load: p=%p (%s) n=%d", - p, p->p_comm, n); + CTR3(KTR_TRAP, "rwindow_load: td=%p (%s) n=%d", + td, td->td_proc->p_comm, n); for (i = 0; i < n; i++) { CTR1(KTR_TRAP, "rwindow_load: usp=%#lx", usp); usp += SPOFF; @@ -65,7 +65,7 @@ rwindow_load(struct proc *p, struct trapframe *tf, int n) } int -rwindow_save(struct proc *p) +rwindow_save(struct thread *td) { struct rwindow *rw; struct pcb *pcb; @@ -75,9 +75,10 @@ rwindow_save(struct proc *p) int i; flushw(); - pcb = &p->p_addr->u_pcb; + pcb = td->td_pcb; i = pcb->pcb_nsaved; - CTR3(KTR_TRAP, "rwindow_save: p=%p (%s) nsaved=%d", p, p->p_comm, i); + CTR3(KTR_TRAP, "rwindow_save: td=%p (%s) nsaved=%d", td, + td->td_proc->p_comm, i); if (i == 0) return (0); ausp = pcb->pcb_rwsp; diff --git a/sys/sparc64/sparc64/swtch.S b/sys/sparc64/sparc64/swtch.S index e3d7466..a490811 100644 --- a/sys/sparc64/sparc64/swtch.S +++ b/sys/sparc64/sparc64/swtch.S @@ -70,8 +70,8 @@ ENTRY(cpu_throw) save %sp, -CCFSZ, %sp - call chooseproc - ldx [PCPU(CURPROC)], %l0 + call choosethread + ldx [PCPU(CURTHREAD)], %l0 flushw b,a .Lsw1 END(cpu_throw) @@ -82,8 +82,8 @@ ENTRY(cpu_switch) * nothing. */ save %sp, -CCFSZ, %sp - call chooseproc - ldx [PCPU(CURPROC)], %l0 + call choosethread + ldx [PCPU(CURTHREAD)], %l0 #if KTR_COMPILE & KTR_CT1 CATR(KTR_CT1, "cpu_switch: from=%p (%s) to=%p (%s)" , %g1, %g2, %g3, 7, 8, 9) @@ -104,7 +104,7 @@ ENTRY(cpu_switch) * and are therefore not saved in the trap frame. * If the process was using floating point, save its context. */ - ldx [%l0 + P_FRAME], %l1 + ldx [%l0 + TD_FRAME], %l1 ldx [PCPU(CURPCB)], %l2 rd %y, %l3 stx %l3, [%l2 + PCB_Y] @@ -131,41 +131,42 @@ ENTRY(cpu_switch) * Load the new process's frame pointer and program counter, and set * the current process and pcb. */ -.Lsw1: ldx [%o0 + P_ADDR], %o1 +.Lsw1: ldx [%o0 + TD_PCB], %o1 #if KTR_COMPILE & KTR_CT1 CATR(KTR_CT1, "cpu_switch: to=%p pc=%#lx fp=%#lx sp=%#lx cwp=%#lx" , %g1, %g2, %g3, 7, 8, 9) stx %o0, [%g1 + KTR_PARM1] - ldx [%o1 + U_PCB + PCB_PC], %g2 + ldx [%o1 + PCB_PC], %g2 stx %g2, [%g1 + KTR_PARM2] - ldx [%o1 + U_PCB + PCB_FP], %g2 + ldx [%o1 + PCB_FP], %g2 stx %g2, [%g1 + KTR_PARM3] sub %g2, CCFSZ, %g2 stx %g2, [%g1 + KTR_PARM4] - ldx [%o1 + U_PCB + PCB_CWP], %g2 + ldx [%o1 + PCB_CWP], %g2 stx %g2, [%g1 + KTR_PARM5] 9: #endif #if 1 mov %o0, %g4 mov %l0, %g5 - ldx [%o1 + U_PCB + PCB_CWP], %o2 + ldx [%o1 + PCB_CWP], %o2 wrpr %o2, %cwp mov %g4, %o0 mov %g5, %l0 #endif - ldx [%o0 + P_ADDR], %o1 - ldx [%o1 + U_PCB + PCB_FP], %fp - ldx [%o1 + U_PCB + PCB_PC], %i7 + ldx [%o0 + TD_PCB], %o1 + ldx [%o1 + PCB_FP], %fp + ldx [%o1 + PCB_PC], %i7 sub %fp, CCFSZ, %sp - stx %o0, [PCPU(CURPROC)] + stx %o0, [PCPU(CURTHREAD)] stx %o1, [PCPU(CURPCB)] /* * Point to the new process's vmspace and load its vm context number. * If its nucleus context we are done. */ - ldx [%o0 + P_VMSPACE], %o2 + ldx [%o0 + TD_PROC], %o2 + ldx [%o2 + P_VMSPACE], %o2 lduw [%o2 + VM_PMAP + PM_CONTEXT], %o3 #if KTR_COMPILE & KTR_CT1 CATR(KTR_CT1, "cpu_switch: to=%p vm=%p context=%#x" @@ -182,12 +183,12 @@ ENTRY(cpu_switch) * If the new process was using floating point, restore its context. * Always restore %fprs and %y. */ - ldx [%o0 + P_FRAME], %o4 + ldx [%o0 + TD_FRAME], %o4 ldx [%o4 + TF_TSTATE], %o4 andcc %o4, TSTATE_PEF, %o4 be,pt %xcc, 2f nop - restrfp %o1 + U_PCB + PCB_FPSTATE, %o4 + restrfp %o1 + PCB_FPSTATE, %o4 2: ldx [%o1 + PCB_FPSTATE + FP_FPRS], %o4 wr %o4, 0, %fprs @@ -199,7 +200,8 @@ ENTRY(cpu_switch) * context number. If its the same as the new process, we are * done. */ - ldx [%l0 + P_VMSPACE], %l1 + ldx [%l0 + TD_PROC], %l1 + ldx [%l1 + P_VMSPACE], %l1 lduw [%l1 + VM_PMAP + PM_CONTEXT], %l3 #if KTR_COMPILE & KTR_CT1 CATR(KTR_CT1, "cpu_switch: from=%p vm=%p context=%#x" @@ -247,9 +249,9 @@ ENTRY(cpu_switch) */ 3: #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "cpu_switch: return p=%p (%s)" + CATR(KTR_CT1, "cpu_switch: return td=%p (%s)" , %g1, %g2, %g3, 7, 8, 9) - ldx [PCPU(CURPROC)], %g2 + ldx [PCPU(CURTHREAD)], %g2 stx %g2, [%g1 + KTR_PARM1] add %g2, P_COMM, %g3 stx %g3, [%g1 + KTR_PARM2] @@ -266,8 +268,8 @@ ENTRY(savectx) stx %l0, [%i0 + PCB_Y] rd %fprs, %l0 stx %l0, [%i0 + PCB_FPSTATE + FP_FPRS] - ldx [PCPU(CURPROC)], %l0 - ldx [%l0 + P_FRAME], %l0 + ldx [PCPU(CURTHREAD)], %l0 + ldx [%l0 + TD_FRAME], %l0 ldx [%l0 + TF_TSTATE], %l0 andcc %l0, TSTATE_PEF, %l0 be,pt %xcc, 1f diff --git a/sys/sparc64/sparc64/swtch.s b/sys/sparc64/sparc64/swtch.s index e3d7466..a490811 100644 --- a/sys/sparc64/sparc64/swtch.s +++ b/sys/sparc64/sparc64/swtch.s @@ -70,8 +70,8 @@ ENTRY(cpu_throw) save %sp, -CCFSZ, %sp - call chooseproc - ldx [PCPU(CURPROC)], %l0 + call choosethread + ldx [PCPU(CURTHREAD)], %l0 flushw b,a .Lsw1 END(cpu_throw) @@ -82,8 +82,8 @@ ENTRY(cpu_switch) * nothing. */ save %sp, -CCFSZ, %sp - call chooseproc - ldx [PCPU(CURPROC)], %l0 + call choosethread + ldx [PCPU(CURTHREAD)], %l0 #if KTR_COMPILE & KTR_CT1 CATR(KTR_CT1, "cpu_switch: from=%p (%s) to=%p (%s)" , %g1, %g2, %g3, 7, 8, 9) @@ -104,7 +104,7 @@ ENTRY(cpu_switch) * and are therefore not saved in the trap frame. * If the process was using floating point, save its context. */ - ldx [%l0 + P_FRAME], %l1 + ldx [%l0 + TD_FRAME], %l1 ldx [PCPU(CURPCB)], %l2 rd %y, %l3 stx %l3, [%l2 + PCB_Y] @@ -131,41 +131,42 @@ ENTRY(cpu_switch) * Load the new process's frame pointer and program counter, and set * the current process and pcb. */ -.Lsw1: ldx [%o0 + P_ADDR], %o1 +.Lsw1: ldx [%o0 + TD_PCB], %o1 #if KTR_COMPILE & KTR_CT1 CATR(KTR_CT1, "cpu_switch: to=%p pc=%#lx fp=%#lx sp=%#lx cwp=%#lx" , %g1, %g2, %g3, 7, 8, 9) stx %o0, [%g1 + KTR_PARM1] - ldx [%o1 + U_PCB + PCB_PC], %g2 + ldx [%o1 + PCB_PC], %g2 stx %g2, [%g1 + KTR_PARM2] - ldx [%o1 + U_PCB + PCB_FP], %g2 + ldx [%o1 + PCB_FP], %g2 stx %g2, [%g1 + KTR_PARM3] sub %g2, CCFSZ, %g2 stx %g2, [%g1 + KTR_PARM4] - ldx [%o1 + U_PCB + PCB_CWP], %g2 + ldx [%o1 + PCB_CWP], %g2 stx %g2, [%g1 + KTR_PARM5] 9: #endif #if 1 mov %o0, %g4 mov %l0, %g5 - ldx [%o1 + U_PCB + PCB_CWP], %o2 + ldx [%o1 + PCB_CWP], %o2 wrpr %o2, %cwp mov %g4, %o0 mov %g5, %l0 #endif - ldx [%o0 + P_ADDR], %o1 - ldx [%o1 + U_PCB + PCB_FP], %fp - ldx [%o1 + U_PCB + PCB_PC], %i7 + ldx [%o0 + TD_PCB], %o1 + ldx [%o1 + PCB_FP], %fp + ldx [%o1 + PCB_PC], %i7 sub %fp, CCFSZ, %sp - stx %o0, [PCPU(CURPROC)] + stx %o0, [PCPU(CURTHREAD)] stx %o1, [PCPU(CURPCB)] /* * Point to the new process's vmspace and load its vm context number. * If its nucleus context we are done. */ - ldx [%o0 + P_VMSPACE], %o2 + ldx [%o0 + TD_PROC], %o2 + ldx [%o2 + P_VMSPACE], %o2 lduw [%o2 + VM_PMAP + PM_CONTEXT], %o3 #if KTR_COMPILE & KTR_CT1 CATR(KTR_CT1, "cpu_switch: to=%p vm=%p context=%#x" @@ -182,12 +183,12 @@ ENTRY(cpu_switch) * If the new process was using floating point, restore its context. * Always restore %fprs and %y. */ - ldx [%o0 + P_FRAME], %o4 + ldx [%o0 + TD_FRAME], %o4 ldx [%o4 + TF_TSTATE], %o4 andcc %o4, TSTATE_PEF, %o4 be,pt %xcc, 2f nop - restrfp %o1 + U_PCB + PCB_FPSTATE, %o4 + restrfp %o1 + PCB_FPSTATE, %o4 2: ldx [%o1 + PCB_FPSTATE + FP_FPRS], %o4 wr %o4, 0, %fprs @@ -199,7 +200,8 @@ ENTRY(cpu_switch) * context number. If its the same as the new process, we are * done. */ - ldx [%l0 + P_VMSPACE], %l1 + ldx [%l0 + TD_PROC], %l1 + ldx [%l1 + P_VMSPACE], %l1 lduw [%l1 + VM_PMAP + PM_CONTEXT], %l3 #if KTR_COMPILE & KTR_CT1 CATR(KTR_CT1, "cpu_switch: from=%p vm=%p context=%#x" @@ -247,9 +249,9 @@ ENTRY(cpu_switch) */ 3: #if KTR_COMPILE & KTR_CT1 - CATR(KTR_CT1, "cpu_switch: return p=%p (%s)" + CATR(KTR_CT1, "cpu_switch: return td=%p (%s)" , %g1, %g2, %g3, 7, 8, 9) - ldx [PCPU(CURPROC)], %g2 + ldx [PCPU(CURTHREAD)], %g2 stx %g2, [%g1 + KTR_PARM1] add %g2, P_COMM, %g3 stx %g3, [%g1 + KTR_PARM2] @@ -266,8 +268,8 @@ ENTRY(savectx) stx %l0, [%i0 + PCB_Y] rd %fprs, %l0 stx %l0, [%i0 + PCB_FPSTATE + FP_FPRS] - ldx [PCPU(CURPROC)], %l0 - ldx [%l0 + P_FRAME], %l0 + ldx [PCPU(CURTHREAD)], %l0 + ldx [%l0 + TD_FRAME], %l0 ldx [%l0 + TF_TSTATE], %l0 andcc %l0, TSTATE_PEF, %l0 be,pt %xcc, 1f diff --git a/sys/sparc64/sparc64/sys_machdep.c b/sys/sparc64/sparc64/sys_machdep.c index 0fd7a66..df0c16e 100644 --- a/sys/sparc64/sparc64/sys_machdep.c +++ b/sys/sparc64/sparc64/sys_machdep.c @@ -38,7 +38,7 @@ struct sysarch_args { #endif int -sysarch(struct proc *p, struct sysarch_args *uap) +sysarch(struct thread *td, struct sysarch_args *uap) { TODO; return (0); diff --git a/sys/sparc64/sparc64/trap.c b/sys/sparc64/sparc64/trap.c index e3f60a2..f1fa544 100644 --- a/sys/sparc64/sparc64/trap.c +++ b/sys/sparc64/sparc64/trap.c @@ -76,8 +76,8 @@ #include <machine/watch.h> void trap(struct trapframe *tf); -int trap_mmu_fault(struct proc *p, struct trapframe *tf); -void syscall(struct proc *p, struct trapframe *tf, u_int sticks); +int trap_mmu_fault(struct thread *td, struct trapframe *tf); +void syscall(struct thread *td, struct trapframe *tf, u_int sticks); u_long trap_mask = 0xffffffffffffffffL & ~(1 << T_INTR); @@ -124,6 +124,7 @@ void trap(struct trapframe *tf) { u_int sticks; + struct thread *td; struct proc *p; int error; int ucode; @@ -131,11 +132,12 @@ trap(struct trapframe *tf) int sig; int mask; - KASSERT(PCPU_GET(curproc) != NULL, ("trap: curproc NULL")); + KASSERT(PCPU_GET(curthread) != NULL, ("trap: curthread NULL")); KASSERT(PCPU_GET(curpcb) != NULL, ("trap: curpcb NULL")); error = 0; - p = PCPU_GET(curproc); + td = PCPU_GET(curthread); + p = td->td_proc; type = tf->tf_type; ucode = type; /* XXX */ sticks = 0; @@ -157,8 +159,8 @@ trap(struct trapframe *tf) cnt.v_trap++; if ((type & T_KERNEL) == 0) { - sticks = p->p_sticks; - p->p_frame = tf; + sticks = td->td_kse->ke_sticks; + td->td_frame = tf; } switch (type) { @@ -174,7 +176,7 @@ trap(struct trapframe *tf) sig = SIGFPE; goto trapsig; case T_FP_DISABLED: - if (fp_enable_proc(p)) + if (fp_enable_thread(td)) goto user; /* Fallthrough. */ case T_FP_IEEE: @@ -190,18 +192,18 @@ trap(struct trapframe *tf) case T_DMMU_MISS: case T_DMMU_PROT: case T_IMMU_MISS: - error = trap_mmu_fault(p, tf); + error = trap_mmu_fault(td, tf); if (error == 0) goto user; sig = error; goto trapsig; case T_FILL: - if (rwindow_load(p, tf, 2)) - sigexit(p, SIGILL); + if (rwindow_load(td, tf, 2)) + sigexit(td, SIGILL); goto out; case T_FILL_RET: - if (rwindow_load(p, tf, 1)) - sigexit(p, SIGILL); + if (rwindow_load(td, tf, 1)) + sigexit(td, SIGILL); goto out; case T_INSN_ILLEGAL: sig = SIGILL; @@ -217,12 +219,12 @@ trap(struct trapframe *tf) sig = SIGILL; goto trapsig; case T_SPILL: - if (rwindow_save(p)) - sigexit(p, SIGILL); + if (rwindow_save(td)) + sigexit(td, SIGILL); goto out; case T_SYSCALL: /* syscall() calls userret(), so we need goto out; */ - syscall(p, tf, sticks); + syscall(td, tf, sticks); goto out; case T_TAG_OVFLW: sig = SIGEMT; @@ -235,7 +237,7 @@ trap(struct trapframe *tf) #endif case T_DMMU_MISS | T_KERNEL: case T_DMMU_PROT | T_KERNEL: - error = trap_mmu_fault(p, tf); + error = trap_mmu_fault(td, tf); if (error == 0) goto out; break; @@ -292,7 +294,7 @@ trapsig: sig = (p->p_sysent->sv_transtrap)(sig, type); trapsignal(p, sig, ucode); user: - userret(p, tf, sticks); + userret(td, tf, sticks); out: #if KTR_COMPILE & KTR_TRAP if (trap_mask & (1 << (type & ~T_KERNEL))) { @@ -303,13 +305,14 @@ out: } int -trap_mmu_fault(struct proc *p, struct trapframe *tf) +trap_mmu_fault(struct thread *td, struct trapframe *tf) { struct mmuframe *mf; struct vmspace *vm; struct stte *stp; struct pcb *pcb; struct tte tte; + struct proc *p; vm_offset_t va; vm_prot_t prot; u_long ctx; @@ -318,6 +321,7 @@ trap_mmu_fault(struct proc *p, struct trapframe *tf) int type; int rv; + p = td->td_proc; KASSERT(p->p_vmspace != NULL, ("trap_dmmu_miss: vmspace NULL")); rv = KERN_SUCCESS; @@ -327,8 +331,8 @@ trap_mmu_fault(struct proc *p, struct trapframe *tf) type = tf->tf_type & ~T_KERNEL; va = TLB_TAR_VA(mf->mf_tar); - CTR4(KTR_TRAP, "trap_mmu_fault: p=%p pm_ctx=%#lx va=%#lx ctx=%#lx", - p, p->p_vmspace->vm_pmap.pm_context, va, ctx); + CTR4(KTR_TRAP, "trap_mmu_fault: td=%p pm_ctx=%#lx va=%#lx ctx=%#lx", + td, p->p_vmspace->vm_pmap.pm_context, va, ctx); if (type == T_DMMU_PROT) { prot = VM_PROT_WRITE; @@ -354,7 +358,7 @@ trap_mmu_fault(struct proc *p, struct trapframe *tf) tlb_store(TLB_DTLB, va, ctx, tte); } } else if (tf->tf_type & T_KERNEL && - (p->p_intr_nesting_level != 0 || pcb->pcb_onfault == NULL)) { + (td->td_intr_nesting_level != 0 || pcb->pcb_onfault == NULL)) { rv = KERN_FAILURE; } else { mtx_lock(&Giant); @@ -424,9 +428,10 @@ trap_mmu_fault(struct proc *p, struct trapframe *tf) * in %g1 (and also saved in the trap frame). */ void -syscall(struct proc *p, struct trapframe *tf, u_int sticks) +syscall(struct thread *td, struct trapframe *tf, u_int sticks) { struct sysent *callp; + struct proc *p; u_long code; u_long tpc; int reg; @@ -441,6 +446,7 @@ syscall(struct proc *p, struct trapframe *tf, u_int sticks) reg = 0; regcnt = REG_MAXARGS; code = tf->tf_global[1]; + p = td->td_proc; /* * For syscalls, we don't want to retry the faulting instruction * (usually), instead we need to advance one instruction. @@ -485,7 +491,7 @@ syscall(struct proc *p, struct trapframe *tf, u_int sticks) goto bad; } - CTR5(KTR_SYSC, "syscall: p=%p %s(%#lx, %#lx, %#lx)", p, + CTR5(KTR_SYSC, "syscall: td=%p %s(%#lx, %#lx, %#lx)", td, syscallnames[code], argp[0], argp[1], argp[2]); /* @@ -504,23 +510,23 @@ syscall(struct proc *p, struct trapframe *tf, u_int sticks) ktrsyscall(p->p_tracep, code, narg, args); } #endif - p->p_retval[0] = 0; - p->p_retval[1] = tf->tf_out[1]; + td->td_retval[0] = 0; + td->td_retval[1] = tf->tf_out[1]; STOPEVENT(p, S_SCE, narg); /* MP aware */ - error = (*callp->sy_call)(p, argp); + error = (*callp->sy_call)(td, argp); CTR5(KTR_SYSC, "syscall: p=%p error=%d %s return %#lx %#lx ", p, - error, syscallnames[code], p->p_retval[0], p->p_retval[1]); + error, syscallnames[code], td->td_retval[0], td->td_retval[1]); /* * MP SAFE (we may or may not have the MP lock at this point) */ switch (error) { case 0: - tf->tf_out[0] = p->p_retval[0]; - tf->tf_out[1] = p->p_retval[1]; + tf->tf_out[0] = td->td_retval[0]; + tf->tf_out[1] = td->td_retval[1]; tf->tf_tstate &= ~TSTATE_XCC_C; break; @@ -552,11 +558,11 @@ bad: /* * Handle reschedule and other end-of-syscall issues */ - userret(p, tf, sticks); + userret(td, tf, 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 @@ -575,7 +581,7 @@ bad: 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]); } diff --git a/sys/sparc64/sparc64/vm_machdep.c b/sys/sparc64/sparc64/vm_machdep.c index addec1b..1e94d40 100644 --- a/sys/sparc64/sparc64/vm_machdep.c +++ b/sys/sparc64/sparc64/vm_machdep.c @@ -64,7 +64,7 @@ #include <machine/tstate.h> void -cpu_exit(struct proc *p) +cpu_exit(struct thread *td) { } @@ -74,25 +74,29 @@ cpu_exit(struct proc *p) * ready to run and return to user mode. */ void -cpu_fork(struct proc *p1, struct proc *p2, int flags) +cpu_fork(struct thread *td1, struct proc *p2, int flags) { + struct thread *td2; struct trapframe *tf; struct frame *fp; struct pcb *pcb; - KASSERT(p1 == curproc || p1 == &proc0, + KASSERT(td1 == curthread || td1 == thread0, ("cpu_fork: p1 not curproc and not proc0")); if ((flags & RFPROC) == 0) return; + td2 = &p2->p_thread; + pcb = (struct pcb *)td2->td_kstack; + td2->td_pcb = pcb; + /* * Ensure that p1's pcb is up to date. */ - pcb = &p2->p_addr->u_pcb; - p1->p_addr->u_pcb.pcb_y = rd(y); - p1->p_addr->u_pcb.pcb_fpstate.fp_fprs = rd(fprs); - if ((p1->p_frame->tf_tstate & TSTATE_PEF) != 0) { + td1->td_pcb->pcb_y = rd(y); + td1->td_pcb->pcb_fpstate.fp_fprs = rd(fprs); + if ((td1->td_frame->tf_tstate & TSTATE_PEF) != 0) { mtx_lock_spin(&sched_lock); savefpctx(&pcb->pcb_fpstate); mtx_unlock_spin(&sched_lock); @@ -100,8 +104,7 @@ cpu_fork(struct proc *p1, struct proc *p2, int flags) /* Make sure the copied windows are spilled. */ __asm __volatile("flushw"); /* Copy the pcb (this will copy the windows saved in the pcb, too). */ - pcb = &p2->p_addr->u_pcb; - bcopy(&p1->p_addr->u_pcb, pcb, sizeof(*pcb)); + bcopy(td1->td_pcb, pcb, sizeof(*pcb)); pcb->pcb_cwp = 2; /* @@ -109,17 +112,18 @@ cpu_fork(struct proc *p1, struct proc *p2, int flags) * Copy the trap frame for the return to user mode as if from a * syscall. This copies most of the user mode register values. */ - tf = (struct trapframe *)((caddr_t)p2->p_addr + UPAGES * PAGE_SIZE) - 1; - bcopy(p1->p_frame, tf, sizeof(*tf)); + tf = (struct trapframe *) + (td2->td_kstack + KSTACK_PAGES * PAGE_SIZE) - 1; + bcopy(td1->td_frame, tf, sizeof(*tf)); tf->tf_out[0] = 0; /* Child returns zero */ tf->tf_out[1] = 1; /* XXX i386 returns 1 in %edx */ tf->tf_tstate &= ~(TSTATE_XCC_C | TSTATE_CWP_MASK); /* success */ - p2->p_frame = tf; + td2->td_frame = tf; fp = (struct frame *)tf - 1; fp->f_local[0] = (u_long)fork_return; - fp->f_local[1] = (u_long)p2; + fp->f_local[1] = (u_long)td2; fp->f_local[2] = (u_long)tf; pcb->pcb_cwp = 2; pcb->pcb_fp = (u_long)fp - SPOFF; @@ -143,12 +147,12 @@ cpu_reset(void) * This is needed to make kernel threads stay in kernel mode. */ void -cpu_set_fork_handler(struct proc *p, void (*func)(void *), void *arg) +cpu_set_fork_handler(struct thread *td, void (*func)(void *), void *arg) { struct frame *fp; struct pcb *pcb; - pcb = &p->p_addr->u_pcb; + pcb = td->td_pcb; fp = (struct frame *)(pcb->pcb_fp + SPOFF); fp->f_local[0] = (u_long)func; fp->f_local[1] = (u_long)arg; diff --git a/sys/sys/_mutex.h b/sys/sys/_mutex.h index 539e402..82f3648 100644 --- a/sys/sys/_mutex.h +++ b/sys/sys/_mutex.h @@ -40,7 +40,7 @@ struct mtx { volatile uintptr_t mtx_lock; /* owner (and state for sleep locks) */ volatile u_int mtx_recurse; /* number of recursive holds */ critical_t mtx_savecrit; /* saved flags (for spin locks) */ - TAILQ_HEAD(, proc) mtx_blocked; /* threads blocked on this lock */ + TAILQ_HEAD(, thread) mtx_blocked; /* threads blocked on this lock */ LIST_ENTRY(mtx) mtx_contested; /* list of all contested locks */ }; diff --git a/sys/sys/acct.h b/sys/sys/acct.h index 9896295..114b609 100644 --- a/sys/sys/acct.h +++ b/sys/sys/acct.h @@ -85,9 +85,9 @@ struct acct { #define AHZ 64 #ifdef _KERNEL -struct proc; +struct thread; -int acct_process __P((struct proc *p)); +int acct_process __P((struct thread *td)); #endif #endif /* !_SYS_ACCT_H_ */ diff --git a/sys/sys/aio.h b/sys/sys/aio.h index 5b54132..7dc5f05 100644 --- a/sys/sys/aio.h +++ b/sys/sys/aio.h @@ -140,9 +140,9 @@ struct aiocblist { int inputcharge, outputcharge; struct callout_handle timeouthandle; struct buf *bp; /* Buffer pointer */ - struct proc *userproc; /* User process */ + struct proc *userproc; /* User process */ /* Not td! */ struct file *fd_file; /* Pointer to file structure */ - struct aioproclist *jobaioproc;/* AIO process descriptor */ + struct aiothreadlist *jobaiothread; /* AIO process descriptor */ struct aio_liojob *lio; /* Optional lio job */ struct aiocb *uuaiocb; /* Pointer in userspace of aiocb */ struct klist klist; /* list of knotes */ diff --git a/sys/sys/buf.h b/sys/sys/buf.h index 21646ad..28c22ae 100644 --- a/sys/sys/buf.h +++ b/sys/sys/buf.h @@ -249,7 +249,7 @@ struct buf { extern struct mtx buftimelock; /* Interlock on setting prio and timo */ extern char *buf_wmesg; /* Default buffer lock message */ #define BUF_WMESG "bufwait" -#include <sys/proc.h> /* XXX for curproc */ +#include <sys/proc.h> /* XXX for curthread */ #include <sys/mutex.h> /* @@ -273,7 +273,7 @@ BUF_LOCK(struct buf *bp, int locktype) bp->b_lock.lk_wmesg = buf_wmesg; bp->b_lock.lk_prio = PRIBIO + 4; bp->b_lock.lk_timo = 0; - ret = lockmgr(&(bp)->b_lock, locktype, &buftimelock, curproc); + ret = lockmgr(&(bp)->b_lock, locktype, &buftimelock, curthread); splx(s); return ret; } @@ -292,7 +292,7 @@ BUF_TIMELOCK(struct buf *bp, int locktype, char *wmesg, int catch, int timo) bp->b_lock.lk_wmesg = wmesg; bp->b_lock.lk_prio = (PRIBIO + 4) | catch; bp->b_lock.lk_timo = timo; - ret = lockmgr(&(bp)->b_lock, (locktype), &buftimelock, curproc); + ret = lockmgr(&(bp)->b_lock, (locktype), &buftimelock, curthread); splx(s); return ret; } @@ -307,7 +307,7 @@ BUF_UNLOCK(struct buf *bp) int s; s = splbio(); - lockmgr(&(bp)->b_lock, LK_RELEASE, NULL, curproc); + lockmgr(&(bp)->b_lock, LK_RELEASE, NULL, curthread); splx(s); } @@ -332,10 +332,11 @@ static __inline void BUF_KERNPROC __P((struct buf *)); static __inline void BUF_KERNPROC(struct buf *bp) { - struct proc *p = curproc; + struct thread *td = curthread; - if (p != PCPU_GET(idleproc) && bp->b_lock.lk_lockholder == p->p_pid) - p->p_locks--; + if ((td != PCPU_GET(idlethread)) + && bp->b_lock.lk_lockholder == td->td_proc->p_pid) + td->td_locks--; bp->b_lock.lk_lockholder = LK_KERNPROC; } #endif diff --git a/sys/sys/capability.h b/sys/sys/capability.h index 5aff598..eb3d9e2 100644 --- a/sys/sys/capability.h +++ b/sys/sys/capability.h @@ -190,6 +190,7 @@ typedef struct cap *cap_t; #ifdef _KERNEL +struct thread; struct proc; struct ucred; struct vnode; diff --git a/sys/sys/condvar.h b/sys/sys/condvar.h index 5446a5e..72b1513 100644 --- a/sys/sys/condvar.h +++ b/sys/sys/condvar.h @@ -33,9 +33,9 @@ #include <sys/queue.h> struct mtx; -struct proc; +struct thread; -TAILQ_HEAD(cv_waitq, proc); +TAILQ_HEAD(cv_waitq, thread); /* * Condition variable. @@ -61,7 +61,7 @@ int cv_timedwait_sig(struct cv *cvp, struct mtx *mp, int timo); void cv_signal(struct cv *cvp); void cv_broadcast(struct cv *cvp); -void cv_waitq_remove(struct proc *p); +void cv_waitq_remove(struct thread *td); #define cv_waitq_empty(cvp) (TAILQ_EMPTY(&(cvp)->cv_waitq)) #define cv_wmesg(cvp) ((cvp)->cv_description) diff --git a/sys/sys/conf.h b/sys/sys/conf.h index 41556cc..1ecbcf8 100644 --- a/sys/sys/conf.h +++ b/sys/sys/conf.h @@ -110,21 +110,21 @@ struct specinfo { struct bio; struct buf; -struct proc; +struct thread; struct uio; struct knote; -typedef int d_open_t __P((dev_t dev, int oflags, int devtype, struct proc *p)); -typedef int d_close_t __P((dev_t dev, int fflag, int devtype, struct proc *p)); +typedef int d_open_t __P((dev_t dev, int oflags, int devtype, struct thread *td)); +typedef int d_close_t __P((dev_t dev, int fflag, int devtype, struct thread *td)); typedef void d_strategy_t __P((struct bio *bp)); typedef int d_ioctl_t __P((dev_t dev, u_long cmd, caddr_t data, - int fflag, struct proc *p)); + int fflag, struct thread *td)); typedef int d_dump_t __P((dev_t dev)); typedef int d_psize_t __P((dev_t dev)); typedef int d_read_t __P((dev_t dev, struct uio *uio, int ioflag)); typedef int d_write_t __P((dev_t dev, struct uio *uio, int ioflag)); -typedef int d_poll_t __P((dev_t dev, int events, struct proc *p)); +typedef int d_poll_t __P((dev_t dev, int events, struct thread *td)); typedef int d_kqfilter_t __P((dev_t dev, struct knote *kn)); typedef int d_mmap_t __P((dev_t dev, vm_offset_t offset, int nprot)); @@ -133,7 +133,7 @@ typedef int l_close_t __P((struct tty *tp, int flag)); typedef int l_read_t __P((struct tty *tp, struct uio *uio, int flag)); typedef int l_write_t __P((struct tty *tp, struct uio *uio, int flag)); typedef int l_ioctl_t __P((struct tty *tp, u_long cmd, caddr_t data, - int flag, struct proc *p)); + int flag, struct thread *td)); typedef int l_rint_t __P((int c, struct tty *tp)); typedef int l_start_t __P((struct tty *tp)); typedef int l_modem_t __P((struct tty *tp, int flag)); diff --git a/sys/sys/event.h b/sys/sys/event.h index fb16e54..19cb893 100644 --- a/sys/sys/event.h +++ b/sys/sys/event.h @@ -157,13 +157,14 @@ struct knote { #define kn_fp kn_ptr.p_fp }; +struct thread; struct proc; extern void knote(struct klist *list, long hint); -extern void knote_remove(struct proc *p, struct klist *list); -extern void knote_fdclose(struct proc *p, int fd); +extern void knote_remove(struct thread *p, struct klist *list); +extern void knote_fdclose(struct thread *p, int fd); extern int kqueue_register(struct kqueue *kq, - struct kevent *kev, struct proc *p); + struct kevent *kev, struct thread *p); #else /* !_KERNEL */ diff --git a/sys/sys/eventhandler.h b/sys/sys/eventhandler.h index 5effcda..8d91641 100644 --- a/sys/sys/eventhandler.h +++ b/sys/sys/eventhandler.h @@ -87,7 +87,7 @@ do { \ struct eventhandler_entry *_ep, *_en; \ \ if (_el->el_flags & EHE_INITTED) { \ - lockmgr(&_el->el_lock, LK_EXCLUSIVE, NULL, CURPROC); \ + lockmgr(&_el->el_lock, LK_EXCLUSIVE, NULL, curthread); \ _ep = TAILQ_FIRST(&(_el->el_entries)); \ while (_ep != NULL) { \ _en = TAILQ_NEXT(_ep, ee_link); \ @@ -95,7 +95,7 @@ do { \ ## args); \ _ep = _en; \ } \ - lockmgr(&_el->el_lock, LK_RELEASE, NULL, CURPROC); \ + lockmgr(&_el->el_lock, LK_RELEASE, NULL, curthread); \ } \ } while (0) @@ -127,7 +127,7 @@ do { \ \ if (((_el = eventhandler_find_list(#name)) != NULL) && \ (_el->el_flags & EHE_INITTED)) { \ - lockmgr(&_el->el_lock, LK_EXCLUSIVE, NULL, CURPROC); \ + lockmgr(&_el->el_lock, LK_EXCLUSIVE, NULL, curthread); \ _ep = TAILQ_FIRST(&(_el->el_entries)); \ while (_ep != NULL) { \ _en = TAILQ_NEXT(_ep, ee_link); \ @@ -135,7 +135,7 @@ do { \ ## args); \ _ep = _en; \ } \ - lockmgr(&_el->el_lock, LK_RELEASE, NULL, CURPROC); \ + lockmgr(&_el->el_lock, LK_RELEASE, NULL, curthread); \ } \ } while (0) diff --git a/sys/sys/file.h b/sys/sys/file.h index 6e04352..0416d3a 100644 --- a/sys/sys/file.h +++ b/sys/sys/file.h @@ -46,7 +46,7 @@ #include <sys/queue.h> struct stat; -struct proc; +struct thread; struct uio; struct knote; @@ -69,20 +69,20 @@ struct file { struct fileops { int (*fo_read) __P((struct file *fp, struct uio *uio, struct ucred *cred, int flags, - struct proc *p)); + struct thread *td)); int (*fo_write) __P((struct file *fp, struct uio *uio, struct ucred *cred, int flags, - struct proc *p)); + struct thread *td)); #define FOF_OFFSET 1 int (*fo_ioctl) __P((struct file *fp, u_long com, - caddr_t data, struct proc *p)); + caddr_t data, struct thread *td)); int (*fo_poll) __P((struct file *fp, int events, - struct ucred *cred, struct proc *p)); + struct ucred *cred, struct thread *td)); int (*fo_kqfilter) __P((struct file *fp, struct knote *kn)); int (*fo_stat) __P((struct file *fp, struct stat *sb, - struct proc *p)); - int (*fo_close) __P((struct file *fp, struct proc *p)); + struct thread *td)); + int (*fo_close) __P((struct file *fp, struct thread *td)); } *f_ops; int f_seqcount; /* * count of sequential accesses -- cleared @@ -109,7 +109,7 @@ extern int maxfilesperproc; /* per process limit on number of open files */ extern int nfiles; /* actual number of open files */ static __inline void fhold __P((struct file *fp)); -int fdrop __P((struct file *fp, struct proc *p)); +int fdrop __P((struct file *fp, struct thread *td)); static __inline void fhold(fp) @@ -120,101 +120,101 @@ fhold(fp) } static __inline int fo_read __P((struct file *fp, struct uio *uio, - struct ucred *cred, int flags, struct proc *p)); + struct ucred *cred, int flags, struct thread *td)); static __inline int fo_write __P((struct file *fp, struct uio *uio, - struct ucred *cred, int flags, struct proc *p)); + struct ucred *cred, int flags, struct thread *td)); static __inline int fo_ioctl __P((struct file *fp, u_long com, caddr_t data, - struct proc *p)); + struct thread *td)); static __inline int fo_poll __P((struct file *fp, int events, - struct ucred *cred, struct proc *p)); + struct ucred *cred, struct thread *td)); static __inline int fo_stat __P((struct file *fp, struct stat *sb, - struct proc *p)); -static __inline int fo_close __P((struct file *fp, struct proc *p)); + struct thread *td)); +static __inline int fo_close __P((struct file *fp, struct thread *td)); static __inline int fo_kqfilter __P((struct file *fp, struct knote *kn)); static __inline int -fo_read(fp, uio, cred, flags, p) +fo_read(fp, uio, cred, flags, td) struct file *fp; struct uio *uio; struct ucred *cred; - struct proc *p; + struct thread *td; int flags; { int error; fhold(fp); - error = (*fp->f_ops->fo_read)(fp, uio, cred, flags, p); - fdrop(fp, p); + error = (*fp->f_ops->fo_read)(fp, uio, cred, flags, td); + fdrop(fp, td); return (error); } static __inline int -fo_write(fp, uio, cred, flags, p) +fo_write(fp, uio, cred, flags, td) struct file *fp; struct uio *uio; struct ucred *cred; - struct proc *p; + struct thread *td; int flags; { int error; fhold(fp); - error = (*fp->f_ops->fo_write)(fp, uio, cred, flags, p); - fdrop(fp, p); + error = (*fp->f_ops->fo_write)(fp, uio, cred, flags, td); + fdrop(fp, td); return (error); } static __inline int -fo_ioctl(fp, com, data, p) +fo_ioctl(fp, com, data, td) struct file *fp; u_long com; caddr_t data; - struct proc *p; + struct thread *td; { int error; fhold(fp); - error = (*fp->f_ops->fo_ioctl)(fp, com, data, p); - fdrop(fp, p); + error = (*fp->f_ops->fo_ioctl)(fp, com, data, td); + fdrop(fp, td); return (error); } static __inline int -fo_poll(fp, events, cred, p) +fo_poll(fp, events, cred, td) struct file *fp; int events; struct ucred *cred; - struct proc *p; + struct thread *td; { int error; fhold(fp); - error = (*fp->f_ops->fo_poll)(fp, events, cred, p); - fdrop(fp, p); + error = (*fp->f_ops->fo_poll)(fp, events, cred, td); + fdrop(fp, td); return (error); } static __inline int -fo_stat(fp, sb, p) +fo_stat(fp, sb, td) struct file *fp; struct stat *sb; - struct proc *p; + struct thread *td; { int error; fhold(fp); - error = (*fp->f_ops->fo_stat)(fp, sb, p); - fdrop(fp, p); + error = (*fp->f_ops->fo_stat)(fp, sb, td); + fdrop(fp, td); return (error); } static __inline int -fo_close(fp, p) +fo_close(fp, td) struct file *fp; - struct proc *p; + struct thread *td; { - return ((*fp->f_ops->fo_close)(fp, p)); + return ((*fp->f_ops->fo_close)(fp, td)); } static __inline int diff --git a/sys/sys/filedesc.h b/sys/sys/filedesc.h index feebb62..3c1cb8d 100644 --- a/sys/sys/filedesc.h +++ b/sys/sys/filedesc.h @@ -125,16 +125,16 @@ struct sigio { SLIST_HEAD(sigiolst, sigio); #ifdef _KERNEL -int closef __P((struct file *fp, struct proc *p)); -int dupfdopen __P((struct proc *p, struct filedesc *fdp, int indx, int dfd, int mode, +int closef __P((struct file *fp, struct thread *p)); +int dupfdopen __P((struct thread *td, struct filedesc *fdp, int indx, int dfd, int mode, int error)); -int falloc __P((struct proc *p, struct file **resultfp, int *resultfd)); -int fdalloc __P((struct proc *p, int want, int *result)); -int fdavail __P((struct proc *p, int n)); -void fdcloseexec __P((struct proc *p)); -struct filedesc *fdcopy __P((struct proc *p)); -void fdfree __P((struct proc *p)); -struct filedesc *fdinit __P((struct proc *p)); +int falloc __P((struct thread *p, struct file **resultfp, int *resultfd)); +int fdalloc __P((struct thread *p, int want, int *result)); +int fdavail __P((struct thread *td, int n)); +void fdcloseexec __P((struct thread *td)); +struct filedesc *fdcopy __P((struct thread *td)); +void fdfree __P((struct thread *td)); +struct filedesc *fdinit __P((struct thread *td)); struct filedesc *fdshare __P((struct proc *p)); void ffree __P((struct file *fp)); pid_t fgetown __P((struct sigio *sigio)); @@ -143,7 +143,7 @@ void funsetown __P((struct sigio *sigio)); void funsetownlst __P((struct sigiolst *sigiolst)); struct file *holdfp __P((struct filedesc *fdp, int fd, int flag)); int getvnode __P((struct filedesc *fdp, int fd, struct file **fpp)); -void setugidsafety __P((struct proc *p)); +void setugidsafety __P((struct thread *td)); #endif /* _KERNEL */ diff --git a/sys/sys/imgact_aout.h b/sys/sys/imgact_aout.h index ed276c6..39d6baf 100644 --- a/sys/sys/imgact_aout.h +++ b/sys/sys/imgact_aout.h @@ -148,9 +148,9 @@ struct exec { #define EX_DPMASK 0x30 /* mask for the above */ #ifdef _KERNEL -struct proc; +struct thread; -int aout_coredump __P((struct proc *p, struct vnode *vp, off_t limit)); +int aout_coredump __P((struct thread *td, struct vnode *vp, off_t limit)); #endif #endif /* !_IMGACT_AOUT_H_ */ diff --git a/sys/sys/imgact_elf.h b/sys/sys/imgact_elf.h index 0753122..b50f6e8 100644 --- a/sys/sys/imgact_elf.h +++ b/sys/sys/imgact_elf.h @@ -103,9 +103,9 @@ int elf_remove_brand_entry __P((Elf64_Brandinfo *entry)); #endif /* ELF_TARG_CLASS == ELFCLASS32 */ -struct proc; +struct thread; -int elf_coredump __P((struct proc *, struct vnode *, off_t)); +int elf_coredump __P((struct thread *, struct vnode *, off_t)); #endif /* _KERNEL */ diff --git a/sys/sys/interrupt.h b/sys/sys/interrupt.h index 527a5e6..fda8495 100644 --- a/sys/sys/interrupt.h +++ b/sys/sys/interrupt.h @@ -63,7 +63,7 @@ struct intrhand { */ struct ithd { struct mtx it_lock; - struct proc *it_proc; /* Interrupt process. */ + struct thread *it_td; /* Interrupt process. */ LIST_ENTRY(ithd) it_list; /* All interrupt threads. */ TAILQ_HEAD(, intrhand) it_handlers; /* Interrupt handlers. */ struct ithd *it_interrupted; /* Who we interrupted. */ diff --git a/sys/sys/ipc.h b/sys/sys/ipc.h index 1a153c5..463a541 100644 --- a/sys/sys/ipc.h +++ b/sys/sys/ipc.h @@ -82,9 +82,10 @@ struct ipc_perm { #define IPCID_TO_SEQ(id) (((id) >> 16) & 0xffff) #define IXSEQ_TO_IPCID(ix,perm) (((perm.seq) << 16) | (ix & 0xffff)) +struct thread; struct proc; -int ipcperm __P((struct proc *, struct ipc_perm *, int)); +int ipcperm __P((struct thread *, struct ipc_perm *, int)); extern void (*semexit_hook)(struct proc *); extern void (*shmfork_hook)(struct proc *, struct proc *); extern void (*shmexit_hook)(struct proc *); diff --git a/sys/sys/kthread.h b/sys/sys/kthread.h index 91d59eb..279f597 100644 --- a/sys/sys/kthread.h +++ b/sys/sys/kthread.h @@ -47,8 +47,8 @@ void kproc_start __P((const void *)); int kthread_create __P((void (*)(void *), void *, struct proc **, int flags, const char *, ...)) __printflike(5, 6); void kthread_exit __P((int)) __dead2; -int kthread_resume __P((struct proc *)); -int kthread_suspend __P((struct proc *, int)); -void kthread_suspend_check __P((struct proc *)); +int kthread_resume __P((struct proc *)); /* XXXKSE */ +int kthread_suspend __P((struct proc *, int)); /* XXXKSE */ +void kthread_suspend_check __P((struct proc *)); /* XXXKSE */ #endif /* !_SYS_KTHREAD_H_ */ diff --git a/sys/sys/linedisc.h b/sys/sys/linedisc.h index 41556cc..1ecbcf8 100644 --- a/sys/sys/linedisc.h +++ b/sys/sys/linedisc.h @@ -110,21 +110,21 @@ struct specinfo { struct bio; struct buf; -struct proc; +struct thread; struct uio; struct knote; -typedef int d_open_t __P((dev_t dev, int oflags, int devtype, struct proc *p)); -typedef int d_close_t __P((dev_t dev, int fflag, int devtype, struct proc *p)); +typedef int d_open_t __P((dev_t dev, int oflags, int devtype, struct thread *td)); +typedef int d_close_t __P((dev_t dev, int fflag, int devtype, struct thread *td)); typedef void d_strategy_t __P((struct bio *bp)); typedef int d_ioctl_t __P((dev_t dev, u_long cmd, caddr_t data, - int fflag, struct proc *p)); + int fflag, struct thread *td)); typedef int d_dump_t __P((dev_t dev)); typedef int d_psize_t __P((dev_t dev)); typedef int d_read_t __P((dev_t dev, struct uio *uio, int ioflag)); typedef int d_write_t __P((dev_t dev, struct uio *uio, int ioflag)); -typedef int d_poll_t __P((dev_t dev, int events, struct proc *p)); +typedef int d_poll_t __P((dev_t dev, int events, struct thread *td)); typedef int d_kqfilter_t __P((dev_t dev, struct knote *kn)); typedef int d_mmap_t __P((dev_t dev, vm_offset_t offset, int nprot)); @@ -133,7 +133,7 @@ typedef int l_close_t __P((struct tty *tp, int flag)); typedef int l_read_t __P((struct tty *tp, struct uio *uio, int flag)); typedef int l_write_t __P((struct tty *tp, struct uio *uio, int flag)); typedef int l_ioctl_t __P((struct tty *tp, u_long cmd, caddr_t data, - int flag, struct proc *p)); + int flag, struct thread *td)); typedef int l_rint_t __P((int c, struct tty *tp)); typedef int l_start_t __P((struct tty *tp)); typedef int l_modem_t __P((struct tty *tp, int flag)); diff --git a/sys/sys/lock.h b/sys/sys/lock.h index 6e6f7e6..081c6ce 100644 --- a/sys/sys/lock.h +++ b/sys/sys/lock.h @@ -182,7 +182,7 @@ void witness_unlock(struct lock_object *, int, const char *, int); void witness_save(struct lock_object *, const char **, int *); void witness_restore(struct lock_object *, const char *, int); int witness_list_locks(struct lock_list_entry **); -int witness_list(struct proc *); +int witness_list(struct thread *); int witness_sleep(int, struct lock_object *, const char *, int); void witness_assert(struct lock_object *, int, const char *, int); diff --git a/sys/sys/lockmgr.h b/sys/sys/lockmgr.h index 477ef50..0b4ca9d 100644 --- a/sys/sys/lockmgr.h +++ b/sys/sys/lockmgr.h @@ -196,7 +196,7 @@ struct lock { #endif /* INVARIANTS */ void dumplockinfo(struct lock *lkp); -struct proc; +struct thread; void lockinit __P((struct lock *, int prio, char *wmesg, int timo, int flags)); @@ -204,7 +204,7 @@ void lockdestroy __P((struct lock *)); #ifdef DEBUG_LOCKS int debuglockmgr __P((struct lock *, u_int flags, - struct mtx *, struct proc *p, + struct mtx *, struct thread *p, const char *, const char *, int)); @@ -213,10 +213,10 @@ int debuglockmgr __P((struct lock *, u_int flags, "lockmgr", __FILE__, __LINE__) #else int lockmgr __P((struct lock *, u_int flags, - struct mtx *, struct proc *p)); + struct mtx *, struct thread *p)); #endif void lockmgr_printinfo __P((struct lock *)); -int lockstatus __P((struct lock *, struct proc *)); +int lockstatus __P((struct lock *, struct thread *)); int lockcount __P((struct lock *)); #endif /* !_SYS_LOCKMGR_H_ */ diff --git a/sys/sys/mount.h b/sys/sys/mount.h index e2d53ab..f3975ca 100644 --- a/sys/sys/mount.h +++ b/sys/sys/mount.h @@ -328,18 +328,18 @@ struct mount_args; struct vfsops { int (*vfs_mount) __P((struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p)); + struct nameidata *ndp, struct thread *td)); int (*vfs_start) __P((struct mount *mp, int flags, - struct proc *p)); + struct thread *td)); int (*vfs_unmount) __P((struct mount *mp, int mntflags, - struct proc *p)); + struct thread *td)); int (*vfs_root) __P((struct mount *mp, struct vnode **vpp)); int (*vfs_quotactl) __P((struct mount *mp, int cmds, uid_t uid, - caddr_t arg, struct proc *p)); + caddr_t arg, struct thread *td)); int (*vfs_statfs) __P((struct mount *mp, struct statfs *sbp, - struct proc *p)); + struct thread *td)); int (*vfs_sync) __P((struct mount *mp, int waitfor, - struct ucred *cred, struct proc *p)); + struct ucred *cred, struct thread *td)); int (*vfs_vget) __P((struct mount *mp, ino_t ino, struct vnode **vpp)); int (*vfs_fhtovp) __P((struct mount *mp, struct fid *fhp, @@ -352,7 +352,7 @@ struct vfsops { int (*vfs_extattrctl) __P((struct mount *mp, int cmd, struct vnode *filename_vp, int attrnamespace, const char *attrname, - struct proc *p)); + struct thread *td)); }; #define VFS_MOUNT(MP, PATH, DATA, NDP, P) \ @@ -394,15 +394,15 @@ extern char *mountrootfsname; /* * exported vnode operations */ -int dounmount __P((struct mount *, int, struct proc *)); -int vfs_mount __P((struct proc *p, const char *type, char *path, +int dounmount __P((struct mount *, int, struct thread *td)); +int vfs_mount __P((struct thread *td, const char *type, char *path, int flags, void *data)); int vfs_setpublicfs /* set publicly exported fs */ __P((struct mount *, struct netexport *, struct export_args *)); int vfs_lock __P((struct mount *)); /* lock a vfs */ void vfs_msync __P((struct mount *, int)); void vfs_unlock __P((struct mount *)); /* unlock a vfs */ -int vfs_busy __P((struct mount *, int, struct mtx *, struct proc *)); +int vfs_busy __P((struct mount *, int, struct mtx *, struct thread *td)); int vfs_export /* process mount export info */ __P((struct mount *, struct export_args *)); struct netcred *vfs_export_lookup /* lookup host in fs export list */ @@ -414,7 +414,7 @@ struct mount *vfs_getvfs __P((fsid_t *)); /* return vfs given fsid */ int vfs_modevent __P((module_t, int, void *)); int vfs_mountedon __P((struct vnode *)); /* is a vfs mounted on vp */ int vfs_rootmountalloc __P((char *, char *, struct mount **)); -void vfs_unbusy __P((struct mount *, struct proc *)); +void vfs_unbusy __P((struct mount *, struct thread *td)); void vfs_unmountall __P((void)); int vfs_register __P((struct vfsconf *)); int vfs_unregister __P((struct vfsconf *)); @@ -428,15 +428,15 @@ extern struct nfs_public nfs_pub; * functions or casting entries in the VFS op table to "enopnotsupp()". */ int vfs_stdmount __P((struct mount *mp, char *path, caddr_t data, - struct nameidata *ndp, struct proc *p)); -int vfs_stdstart __P((struct mount *mp, int flags, struct proc *p)); -int vfs_stdunmount __P((struct mount *mp, int mntflags, struct proc *p)); + struct nameidata *ndp, struct thread *td)); +int vfs_stdstart __P((struct mount *mp, int flags, struct thread *td)); +int vfs_stdunmount __P((struct mount *mp, int mntflags, struct thread *td)); int vfs_stdroot __P((struct mount *mp, struct vnode **vpp)); int vfs_stdquotactl __P((struct mount *mp, int cmds, uid_t uid, - caddr_t arg, struct proc *p)); -int vfs_stdstatfs __P((struct mount *mp, struct statfs *sbp, struct proc *p)); + caddr_t arg, struct thread *td)); +int vfs_stdstatfs __P((struct mount *mp, struct statfs *sbp, struct thread *td)); int vfs_stdsync __P((struct mount *mp, int waitfor, struct ucred *cred, - struct proc *p)); + struct thread *td)); int vfs_stdvget __P((struct mount *mp, ino_t ino, struct vnode **vpp)); int vfs_stdfhtovp __P((struct mount *mp, struct fid *fhp, struct vnode **vpp)); int vfs_stdcheckexp __P((struct mount *mp, struct sockaddr *nam, @@ -446,7 +446,7 @@ int vfs_stdinit __P((struct vfsconf *)); int vfs_stduninit __P((struct vfsconf *)); int vfs_stdextattrctl __P((struct mount *mp, int cmd, struct vnode *filename_vp, int attrnamespace, const char *attrname, - struct proc *p)); + struct thread *td)); /* XXX - these should be indirect functions!!! */ int softdep_process_worklist __P((struct mount *)); diff --git a/sys/sys/mutex.h b/sys/sys/mutex.h index 9137eac..b7c51b6 100644 --- a/sys/sys/mutex.h +++ b/sys/sys/mutex.h @@ -259,10 +259,10 @@ void _mtx_assert(struct mtx *m, int what, const char *file, int line); #endif #define __mtx_lock_flags(m, opts, file, line) do { \ - MPASS(curproc != NULL); \ + MPASS(curthread != NULL); \ KASSERT(((opts) & MTX_NOSWITCH) == 0, \ ("MTX_NOSWITCH used at %s:%d", (file), (line))); \ - _get_sleep_lock((m), curproc, (opts), (file), (line)); \ + _get_sleep_lock((m), curthread, (opts), (file), (line)); \ LOCK_LOG_LOCK("LOCK", &(m)->mtx_object, opts, m->mtx_recurse, \ (file), (line)); \ WITNESS_LOCK(&(m)->mtx_object, (opts) | LOP_EXCLUSIVE, (file), \ @@ -270,8 +270,8 @@ void _mtx_assert(struct mtx *m, int what, const char *file, int line); } while (0) #define __mtx_lock_spin_flags(m, opts, file, line) do { \ - MPASS(curproc != NULL); \ - _get_spin_lock((m), curproc, (opts), (file), (line)); \ + MPASS(curthread != NULL); \ + _get_spin_lock((m), curthread, (opts), (file), (line)); \ LOCK_LOG_LOCK("LOCK", &(m)->mtx_object, opts, m->mtx_recurse, \ (file), (line)); \ WITNESS_LOCK(&(m)->mtx_object, (opts) | LOP_EXCLUSIVE, (file), \ @@ -279,17 +279,17 @@ void _mtx_assert(struct mtx *m, int what, const char *file, int line); } while (0) #define __mtx_unlock_flags(m, opts, file, line) do { \ - MPASS(curproc != NULL); \ + MPASS(curthread != NULL); \ mtx_assert((m), MA_OWNED); \ WITNESS_UNLOCK(&(m)->mtx_object, (opts) | LOP_EXCLUSIVE, \ (file), (line)); \ LOCK_LOG_LOCK("UNLOCK", &(m)->mtx_object, (opts), \ (m)->mtx_recurse, (file), (line)); \ - _rel_sleep_lock((m), curproc, (opts), (file), (line)); \ + _rel_sleep_lock((m), curthread, (opts), (file), (line)); \ } while (0) #define __mtx_unlock_spin_flags(m, opts, file, line) do { \ - MPASS(curproc != NULL); \ + MPASS(curthread != NULL); \ mtx_assert((m), MA_OWNED); \ WITNESS_UNLOCK(&(m)->mtx_object, (opts) | LOP_EXCLUSIVE, \ (file), (line)); \ @@ -303,7 +303,7 @@ void _mtx_assert(struct mtx *m, int what, const char *file, int line); #define mtx_initialized(m) ((m)->mtx_object.lo_flags & LO_INITIALIZED) -#define mtx_owned(m) (((m)->mtx_lock & MTX_FLAGMASK) == (uintptr_t)curproc) +#define mtx_owned(m) (((m)->mtx_lock & MTX_FLAGMASK) == (uintptr_t)curthread) #define mtx_recursed(m) ((m)->mtx_recurse != 0) diff --git a/sys/sys/namei.h b/sys/sys/namei.h index 1d50937..69daed1 100644 --- a/sys/sys/namei.h +++ b/sys/sys/namei.h @@ -81,7 +81,7 @@ struct nameidata { */ u_long cn_nameiop; /* namei operation */ u_long cn_flags; /* flags to namei */ - struct proc *cn_proc; /* process requesting lookup */ + struct thread *cn_thread;/* thread requesting lookup */ struct ucred *cn_cred; /* credentials */ /* * Shared between lookup and commit routines. @@ -142,24 +142,25 @@ struct nameidata { #define ISUNICODE 0x100000 /* current component name is unicode*/ #define PDIRUNLOCK 0x200000 /* file system lookup() unlocked parent dir */ #define PARAMASK 0x1fff00 /* mask of parameter descriptors */ + /* * Initialization of an nameidata structure. */ static void NDINIT __P((struct nameidata *, u_long, u_long, enum uio_seg, - const char *, struct proc *)); + const char *, struct thread *)); static __inline void -NDINIT(ndp, op, flags, segflg, namep, p) +NDINIT(ndp, op, flags, segflg, namep, td) struct nameidata *ndp; u_long op, flags; enum uio_seg segflg; const char *namep; - struct proc *p; + struct thread *td; { ndp->ni_cnd.cn_nameiop = op; ndp->ni_cnd.cn_flags = flags; ndp->ni_segflg = segflg; ndp->ni_dirp = namep; - ndp->ni_cnd.cn_proc = p; + ndp->ni_cnd.cn_thread = td; } #define NDF_NO_DVP_RELE 0x00000001 diff --git a/sys/sys/posix4.h b/sys/sys/posix4.h index 232435a..626d6d8 100644 --- a/sys/sys/posix4.h +++ b/sys/sys/posix4.h @@ -47,12 +47,12 @@ */ struct proc; struct nosys_args; -extern int syscall_not_present(struct proc *, const char *, struct nosys_args *); +extern int syscall_not_present(struct thread *, const char *, struct nosys_args *); #define SYSCALL_NOT_PRESENT_GEN(SC) \ -int SC (struct proc *p, struct SC##_args *uap) \ +int SC (struct thread *td, struct SC##_args *uap) \ { \ - return syscall_not_present(p, #SC , (struct nosys_args *)uap); \ + return syscall_not_present(td, #SC , (struct nosys_args *)uap); \ } @@ -95,13 +95,13 @@ int ksched_attach(struct ksched **); int ksched_detach(struct ksched *); int ksched_setparam(register_t *, struct ksched *, - struct proc *, const struct sched_param *); + struct thread *, const struct sched_param *); int ksched_getparam(register_t *, struct ksched *, - struct proc *, struct sched_param *); + struct thread *, struct sched_param *); int ksched_setscheduler(register_t *, struct ksched *, - struct proc *, int, const struct sched_param *); -int ksched_getscheduler(register_t *, struct ksched *, struct proc *); + struct thread *, int, const struct sched_param *); +int ksched_getscheduler(register_t *, struct ksched *, struct thread *); int ksched_yield(register_t *, struct ksched *); @@ -109,7 +109,7 @@ int ksched_get_priority_max(register_t *, struct ksched *, int); int ksched_get_priority_min(register_t *, struct ksched *, int); int ksched_rr_get_interval(register_t *, struct ksched *, - struct proc *, struct timespec *); + struct thread *, struct timespec *); #endif /* _KPOSIX_PRIORITY_SCHEDULING */ diff --git a/sys/sys/proc.h b/sys/sys/proc.h index 0a321a5..dd53274 100644 --- a/sys/sys/proc.h +++ b/sys/sys/proc.h @@ -142,132 +142,301 @@ struct ithd; struct nlminfo; struct trapframe; -struct proc { - TAILQ_ENTRY(proc) p_procq; /* (j) Run/mutex queue. */ - TAILQ_ENTRY(proc) p_slpq; /* (j) Sleep queue. */ - LIST_ENTRY(proc) p_list; /* (d) List of all processes. */ +/* + * Here we define the four structures used for process information. + * + * The first is the thread. It might be though of as a "Kernel + * Schedulable Entity Context". + * This structure contains all the information as to where a thread of + * execution is now, or was when it was suspended, why it was suspended, + * and anything else that will be needed to restart it when it is + * rescheduled. Always associated with a KSE when running, but can be + * reassigned to an equivalent KSE when being restarted for + * load balancing. Each of these is associated with a kernel stack + * and a pcb. + * + * It is important to remember that a particular thread structure only + * exists as long as the system call or kernel entrance (e.g. by pagefault) + * which it is currently executing. It should threfore NEVER be referenced + * by pointers in long lived structures that live longer than a single + * request. If several threads complete their work at the same time, + * they will all rewind their stacks to the uer boundary, report their + * completion state, and all but one will be freed. That last one will + * be kept to provide a kernel stack and pcb for the NEXT syscall or kernel + * entrance. (basically to save freeing and then re-allocating it) A process + * might keep a cache of threads available to allow it to quickly + * get one when it needs a new one. There would probably also be a system + * cache of free threads. + */ +struct thread; + +/* + * The second structure is the Kernel Schedulable Entity. (KSE) + * As long as this is scheduled, it will continue to run any threads that + * are assigned to it or the KSEGRP (see later) until either it runs out + * of runnable threads or CPU. + * It runs on one CPU and is assigned a quantum of time. When a thread is + * blocked, The KSE continues to run and will search for another thread + * in a runnable state amongst those it has. It May decide to return to user + * mode with a new 'empty' thread if there are no runnable threads. + * threads are associated with a KSE for cache reasons, but a sheduled KSE with + * no runnable thread will try take a thread from a sibling KSE before + * surrendering its quantum. In some schemes it gets it's quantum from the KSEG + * and contributes to draining that quantum, along withthe other KSEs in + * the group. (undecided) + */ +struct kse; - /* substructures: */ - struct ucred *p_ucred; /* (c + k) Process owner's identity. */ - struct filedesc *p_fd; /* (b) Ptr to open files structure. */ - struct pstats *p_stats; /* (b) Accounting/statistics (CPU). */ - struct plimit *p_limit; /* (m) Process limits. */ - struct vm_object *p_upages_obj;/* (a) Upages object. */ - struct procsig *p_procsig; /* (c) Signal actions, state (CPU). */ -#define p_sigacts p_procsig->ps_sigacts -#define p_sigignore p_procsig->ps_sigignore -#define p_sigcatch p_procsig->ps_sigcatch +/* + * The KSEGRP is allocated resources across a number of CPUs. + * (Including a number of CPUxQUANTA. It parcels these QUANTA up among + * Its KSEs, each of which should be running in a different CPU. + * Priority and total available sheduled quanta are properties of a KSEGRP. + * Multiple KSEGRPs in a single process compete against each other + * for total quanta in the same way that a forked child competes against + * it's parent process. + */ +struct ksegrp; -#define p_rlimit p_limit->pl_rlimit +/* + * A process is the owner of all system resources allocated to a task + * except CPU quanta. + * All KSEGs under one process see, and have the same access to, these + * resources (e.g. files, memory, sockets, permissions kqueues). + * A process may compete for CPU cycles on the same basis as a + * forked process cluster by spawning several KSEGRPs. + */ +struct proc; + +/*************** + * In pictures: + With a single run queue used by all processors: + + RUNQ: --->KSE---KSE--... SLEEPQ:[]---THREAD---THREAD---THREAD + | / []---THREAD + KSEG---THREAD--THREAD--THREAD [] + []---THREAD---THREAD + + (processors run THREADs from the KSEG until they are exhausted or + the KSEG exhausts its quantum) + +With PER-CPU run queues: +KSEs on the separate run queues directly +They would be given priorities calculated from the KSEG. + + * + *****************/ + +/* + * Kernel runnable context (thread). + * This is what is put to sleep and reactivated. + * The first KSE available in the correct group will run this thread. + * If several are available, use the one on the same CPU as last time. + */ +struct thread { + struct proc *td_proc; /* Associated process. */ + struct ksegrp *td_ksegrp; /* Associated KSEG. */ + struct kse *td_last_kse; /* Where it wants to be if possible */ + struct kse *td_kse; /* and is now if running */ + + TAILQ_ENTRY(thread) td_plist; /* All threads in this proc */ + TAILQ_ENTRY(thread) td_kglist; /* All threads in this ksegrp */ + + /* The two queues below should someday be merged */ + TAILQ_ENTRY(thread) td_slpq; /* (j) Sleep queue. XXXKSE */ + TAILQ_ENTRY(thread) td_blkq; /* (j) mutex queue. XXXKSE */ + TAILQ_ENTRY(thread) td_runq; /* (j) run queue(s). XXXKSE */ + +#define td_startzero td_flags + int td_flags; /* (c) P_* flags. */ + int td_dupfd; /* (c) ret value from fdopen. XXX */ + void *td_wchan; /* (j) Sleep address. */ + const char *td_wmesg; /* (j) Reason for sleep. */ + u_char td_lastcpu; /* (j) Last cpu we were on. */ + short td_locks; /* (*) DEBUG: lockmgr count of locks */ + struct mtx *td_blocked; /* (j) Mutex process is blocked on. */ + struct ithd *td_ithd; /* (b) For interrupt threads only. */ + const char *td_mtxname; /* (j) Name of mutex blocked on. */ + LIST_HEAD(, mtx) td_contested; /* (j) Contested locks. */ + struct lock_list_entry *td_sleeplocks; /* (k) Held sleep locks. */ + int td_intr_nesting_level; /* (k) Interrupt recursion. */ +#define td_endzero td_md + +#define td_startcopy td_endzero + /* XXXKSE p_md is in the "on your own" section in old struct proc */ + struct mdthread td_md; /* (k) Any machine-dependent fields. */ + register_t td_retval[2]; /* (k) Syscall aux returns. */ +#define td_endcopy td_pcb + + struct pcb *td_pcb; /* (k) Kv addr of pcb and kstack. */ + struct callout td_slpcallout; /* (h) Callout for sleep. */ + struct trapframe *td_frame; /* (k) */ + struct vm_object *td_kstack_obj;/* (a) kstack object. */ + vm_offset_t td_kstack; /* kstack mapped address */ +}; +#define TDF_ONRUNQ 0x00000001 /* This KE is on a run queue */ + +/* + * The schedulable entity that can be given a context to run. + * A process may have several of these. Probably one per processor + * but posibly a few more. In this universe they are grouped + * with a KSEG that contains the priority and niceness + * for the group. + */ +struct kse { + struct proc *ke_proc; /* Associated process. */ + struct ksegrp *ke_ksegrp; /* Associated KSEG. */ + struct thread *ke_thread; /* Associated thread, if running. */ + TAILQ_ENTRY(kse) ke_kglist; /* Queue of all KSEs in ke_ksegrp. */ + TAILQ_ENTRY(kse) ke_kgrlist; /* Queue of all KSEs in this state. */ + TAILQ_ENTRY(kse) ke_procq; /* (j) Run queue. */ + TAILQ_HEAD(, thread) ke_runq; /* (td_runq) RUNNABLE bound to KSE. */ + +#define ke_startzero ke_flags + int ke_flags; /* (c) P_* flags. */ + /*u_int ke_estcpu; */ /* (j) Time averaged val of cpticks. */ + int ke_cpticks; /* (j) Ticks of cpu time. */ + fixpt_t ke_pctcpu; /* (j) %cpu during p_swtime. */ + u_int64_t ke_uu; /* (j) Previous user time in usec. */ + u_int64_t ke_su; /* (j) Previous system time in usec. */ + u_int64_t ke_iu; /* (j) Previous intr time in usec. */ + u_int64_t ke_uticks; /* (j) Statclock hits in user mode. */ + u_int64_t ke_sticks; /* (j) Statclock hits in system mode. */ + u_int64_t ke_iticks; /* (j) Statclock hits in intr. */ + u_char ke_oncpu; /* (j) Which cpu we are on. */ + u_int ke_slptime; /* (j) Time since last idle. */ + char ke_rqindex; /* (j) Run queue index. */ +#define ke_endzero ke_priority + +#define ke_startcopy ke_endzero + u_char ke_priority; /* (j) Process priority. */ + u_char ke_usrpri; /* (j) User pri from cpu & nice. */ +#define ke_endcopy ke_end + + int ke_end; /* dummy entry */ +}; + +/* + * Kernel-scheduled entity group (KSEG). The scheduler considers each KSEG to + * be an indivisible unit from a time-sharing perspective, though each KSEG may + * contain multiple KSEs. + */ +struct ksegrp { + struct proc *kg_proc; /* Process that contains this KSEG. */ + TAILQ_ENTRY(ksegrp) kg_ksegrp; /* Queue of KSEGs in kg_proc. */ + TAILQ_HEAD(, kse) kg_kseq; /* (ke_kglist) All KSEs */ + TAILQ_HEAD(, kse) kg_rq; /* (ke_kgrlist) Runnable KSEs */ + TAILQ_HEAD(, kse) kg_iq; /* (ke_kgrlist) Idle KSEs */ + TAILQ_HEAD(, thread) kg_threads;/* (td_kglist) All threads. */ + TAILQ_HEAD(, thread) kg_runq; /* (td_runq)unbound RUNNABLE threads */ + TAILQ_HEAD(, thread) kg_slpq; /* (td_runq)NONRUNNABLE threads. */ + +#define kg_startzero kg_estcpu + u_int kg_slptime; /* (j) how long completely blocked. */ + u_int kg_estcpu; /* sum of the same field in kses */ +#define kg_endzero kg_pri + +#define kg_startcopy kg_endzero + struct priority kg_pri; /* (j) Process priority. */ + char kg_nice; /* (j?/k?) Process "nice" value. */ + struct rtprio kg_rtprio; /* (j) Realtime priority. */ +#define kg_endcopy kg_runnable + + int kg_runnable; /* # runnable threads on queue */ + int kg_runq_kses; /* # kse's on runq. */ + int kg_kses; /* # kse's in group. */ +}; - int p_flag; /* (c) P_* flags. */ - int p_sflag; /* (j) PS_* flags. */ - int p_stat; /* (j) S* process status. */ +/* + * The old fashionned process. May have multiple threads, KSEGRPs + * and KSEs. Starts off with a single embedded KSEGRP, KSE and THREAD. + */ +struct proc { + LIST_ENTRY(proc) p_list; /* (d) List of all processes. */ + TAILQ_HEAD(, ksegrp) p_ksegrps; /* (kg_ksegrp) All KSEGs. */ + TAILQ_HEAD(, thread) p_threads; /* (td_plist) threads. (shortcut) */ + struct ucred *p_ucred; /* (c + k) Process owner's identity. */ + struct filedesc *p_fd; /* (b) Ptr to open files structure. */ + /* accumulated stats for all KSEs? */ + struct pstats *p_stats; /* (b) Accounting/statistics (CPU). */ + struct plimit *p_limit; /* (m) Process limits. */ + struct vm_object *p_upages_obj; /* (a) Upages object. */ + struct procsig *p_procsig; /* (c) Signal actions, state (CPU). */ + + struct ksegrp p_ksegrp; + struct kse p_kse; + struct thread p_thread; + + /* + * The following don't make too much sense.. + * See the td_ or ke_ versions of the same flags + */ + int p_flag; /* (c) P_* flags. */ + int p_sflag; /* (j) PS_* flags. */ + int p_stat; /* (j) S* process status. */ pid_t p_pid; /* (b) Process identifier. */ LIST_ENTRY(proc) p_hash; /* (d) Hash chain. */ LIST_ENTRY(proc) p_pglist; /* (c) List of processes in pgrp. */ - struct proc *p_pptr; /* (c + e) Pointer to parent process. */ + struct proc *p_pptr; /* (c + e) Pointer to parent process. */ LIST_ENTRY(proc) p_sibling; /* (e) List of sibling processes. */ LIST_HEAD(, proc) p_children; /* (e) Pointer to list of children. */ /* The following fields are all zeroed upon creation in fork. */ #define p_startzero p_oppid - - pid_t p_oppid; /* (c + e) Save parent pid during ptrace. XXX */ - int p_dupfd; /* (c) Sideways ret value from fdopen. XXX */ - struct vmspace *p_vmspace; /* (b) Address space. */ - - /* scheduling */ - u_int p_estcpu; /* (j) Time averaged value of p_cpticks. */ - int p_cpticks; /* (j) Ticks of cpu time. */ - fixpt_t p_pctcpu; /* (j) %cpu during p_swtime. */ - struct callout p_slpcallout; /* (h) Callout for sleep. */ - void *p_wchan; /* (j) Sleep address. */ - const char *p_wmesg; /* (j) Reason for sleep. */ - u_int p_swtime; /* (j) Time swapped in or out. */ - u_int p_slptime; /* (j) Time since last blocked. */ - - struct callout p_itcallout; /* (h) Interval timer callout. */ - struct itimerval p_realtimer; /* (h?/k?) Alarm timer. */ - u_int64_t p_runtime; /* (j) Real time in microsec. */ - u_int64_t p_uu; /* (j) Previous user time in microsec. */ - u_int64_t p_su; /* (j) Previous system time in microsec. */ - u_int64_t p_iu; /* (j) Previous interrupt time in microsec. */ - u_int64_t p_uticks; /* (j) Statclock hits in user mode. */ - u_int64_t p_sticks; /* (j) Statclock hits in system mode. */ - u_int64_t p_iticks; /* (j) Statclock hits processing intr. */ - - int p_traceflag; /* (j?) Kernel trace points. */ - struct vnode *p_tracep; /* (j?) Trace to vnode. */ - - sigset_t p_siglist; /* (c) Signals arrived but not delivered. */ - - struct vnode *p_textvp; /* (b) Vnode of executable. */ - - struct mtx p_mtx; /* (k) Lock for this struct. */ - char p_lock; /* (c) Process lock (prevent swap) count. */ - u_char p_oncpu; /* (j) Which cpu we are on. */ - u_char p_lastcpu; /* (j) Last cpu we were on. */ - char p_rqindex; /* (j) Run queue index. */ - - short p_locks; /* (*) DEBUG: lockmgr count of held locks */ - u_int p_stops; /* (c) Procfs event bitmask. */ - u_int p_stype; /* (c) Procfs stop event type. */ - char p_step; /* (c) Procfs stop *once* flag. */ - u_char p_pfsflags; /* (c) Procfs flags. */ - char p_pad3[2]; /* Alignment. */ - register_t p_retval[2]; /* (k) Syscall aux returns. */ - struct sigiolst p_sigiolst; /* (c) List of sigio sources. */ - int p_sigparent; /* (c) Signal to parent on exit. */ - sigset_t p_oldsigmask; /* (c) Saved mask from before sigpause. */ - int p_sig; /* (n) For core dump/debugger XXX. */ - u_long p_code; /* (n) For core dump/debugger XXX. */ - struct klist p_klist; /* (c) Knotes attached to this process. */ - struct lock_list_entry *p_sleeplocks; /* (k) Held sleep locks. */ - struct mtx *p_blocked; /* (j) Mutex process is blocked on. */ - const char *p_mtxname; /* (j) Name of mutex blocked on. */ - LIST_HEAD(, mtx) p_contested; /* (j) Contested locks. */ - + pid_t p_oppid; /* (c + e) Save ppid in ptrace. XXX */ + struct vmspace *p_vmspace; /* (b) Address space. */ + u_int p_swtime; /* (j) Time swapped in or out. */ + struct itimerval p_realtimer; /* (h?/k?) Alarm timer. */ + u_int64_t p_runtime; /* (j) Real time in microsec. */ + int p_traceflag; /* (j?) Kernel trace points. */ + struct vnode *p_tracep; /* (j?) Trace to vnode. */ + sigset_t p_siglist; /* (c) Sigs arrived, not delivered. */ + struct vnode *p_textvp; /* (b) Vnode of executable. */ + struct mtx p_mtx; /* (k) Lock for this struct. */ + char p_lock; /* (c) Proclock (prevent swap) count. */ + struct klist p_klist; /* (c) Knotes attached to this proc. */ + struct sigiolst p_sigiolst; /* (c) List of sigio sources. */ + int p_sigparent; /* (c) Signal to parent on exit. */ + sigset_t p_oldsigmask; /* (c) Saved mask from pre sigpause. */ + int p_sig; /* (n) For core dump/debugger XXX. */ + u_long p_code; /* (n) For core dump/debugger XXX. */ + u_int p_stops; /* (c) Procfs event bitmask. */ + u_int p_stype; /* (c) Procfs stop event type. */ + char p_step; /* (c) Procfs stop *once* flag. */ + u_char p_pfsflags; /* (c) Procfs flags. */ struct nlminfo *p_nlminfo; /* (?) only used by/for lockd */ - void *p_aioinfo; /* (c) ASYNC I/O info. */ - struct ithd *p_ithd; /* (b) For interrupt threads only. */ - int p_intr_nesting_level; /* (k) Interrupt recursion. */ - + void *p_aioinfo; /* (c) ASYNC I/O info. */ /* End area that is zeroed on creation. */ -#define p_endzero p_startcopy - -/* The following fields are all copied upon creation in fork. */ #define p_startcopy p_sigmask - sigset_t p_sigmask; /* (c) Current signal mask. */ - stack_t p_sigstk; /* (c) Stack pointer and on-stack flag. */ - - int p_magic; /* (b) Magic number. */ - struct priority p_pri; /* (j) Process priority. */ - char p_nice; /* (j?/k?) Process "nice" value. */ - char p_comm[MAXCOMLEN + 1]; /* (b) Process name. */ - - struct pgrp *p_pgrp; /* (e?/c?) Pointer to process group. */ - struct sysentvec *p_sysent; /* (b) System call dispatch information. */ - struct pargs *p_args; /* (c + k) Process arguments. */ - +/* The following fields are all copied upon creation in fork. */ +#define p_endzero p_startcopy + sigset_t p_sigmask; /* (c) Current signal mask. */ + stack_t p_sigstk; /* (c) Stack ptr and on-stack flag. */ + int p_magic; /* (b) Magic number. */ + char p_comm[MAXCOMLEN + 1]; /* (b) Process name. */ + struct pgrp *p_pgrp; /* (e?/c?) Pointer to process group. */ + struct sysentvec *p_sysent; /* (b) Syscall dispatch info. */ + struct pargs *p_args; /* (c + k) Process arguments. */ /* End area that is copied on creation. */ -#define p_endcopy p_addr - - struct user *p_addr; /* (k) Kernel virtual addr of u-area (CPU). */ - struct mdproc p_md; /* (k) Any machine-dependent fields. */ - - u_short p_xstat; /* (c) Exit status for wait; also stop sig. */ - u_short p_acflag; /* (c) Accounting flags. */ - struct rusage *p_ru; /* (a) Exit information. XXX */ - - struct proc *p_peers; /* (c) */ - struct proc *p_leader; /* (c) */ - void *p_emuldata; /* (c) Emulator state data. */ - struct trapframe *p_frame; /* (k) */ +#define p_endcopy p_xstat + + u_short p_xstat; /* (c) Exit status; also stop sig. */ + struct mdproc p_md; /* (k) Any machine-dependent fields. */ + struct callout p_itcallout; /* (h) Interval timer callout. */ + struct user *p_uarea; /* was p_addr. changed to break stuff */ + u_short p_acflag; /* (c) Accounting flags. */ + struct rusage *p_ru; /* (a) Exit information. XXX */ + struct proc *p_peers; /* (c) */ + struct proc *p_leader; /* (c) */ + void *p_emuldata; /* (c) Emulator state data. */ }; +#define p_rlimit p_limit->pl_rlimit +#define p_sigacts p_procsig->ps_sigacts +#define p_sigignore p_procsig->ps_sigignore +#define p_sigcatch p_procsig->ps_sigcatch #define p_session p_pgrp->pg_session #define p_pgid p_pgrp->pg_id @@ -283,25 +452,25 @@ struct proc { #define SMTX 7 /* Blocked on a mutex. */ /* These flags are kept in p_flag. */ +/* In a KSE world some go to a thread or a KSE (*)*/ #define P_ADVLOCK 0x00001 /* Process may hold a POSIX advisory lock. */ #define P_CONTROLT 0x00002 /* Has a controlling terminal. */ -#define P_KTHREAD 0x00004 /* Kernel thread. */ +#define P_KTHREAD 0x00004 /* Kernel thread. (*)*/ #define P_NOLOAD 0x00008 /* Ignore during load avg calculations. */ #define P_PPWAIT 0x00010 /* Parent is waiting for child to exec/exit. */ -#define P_SELECT 0x00040 /* Selecting; wakeup/waiting danger. */ #define P_SUGID 0x00100 /* Had set id privileges since last exec. */ #define P_SYSTEM 0x00200 /* System proc: no sigs, stats or swapping. */ #define P_TRACED 0x00800 /* Debugged process being traced. */ #define P_WAITED 0x01000 /* Debugging process has waited for child. */ #define P_WEXIT 0x02000 /* Working on exiting. */ #define P_EXEC 0x04000 /* Process called exec. */ +#define P_KSES 0x08000 /* Process is using KSEs. */ /* Should be moved to machine-dependent areas. */ #define P_BUFEXHAUST 0x100000 /* Dirty buffers flush is in progress. */ #define P_COWINPROGRESS 0x400000 /* Snapshot copy-on-write in progress. */ -#define P_DEADLKTREAT 0x800000 /* Lock aquisition - deadlock treatment. */ #define P_JAILED 0x1000000 /* Process is in jail. */ #define P_OLDMASK 0x2000000 /* Need to restore mask after suspend. */ @@ -309,18 +478,24 @@ struct proc { /* These flags are kept in p_sflag and are protected with sched_lock. */ #define PS_INMEM 0x00001 /* Loaded into memory. */ -#define PS_OWEUPC 0x00002 /* Owe process an addupc() call at next ast. */ #define PS_PROFIL 0x00004 /* Has started profiling. */ -#define PS_SINTR 0x00008 /* Sleep is interruptible. */ -#define PS_TIMEOUT 0x00010 /* Timing out during sleep. */ #define PS_ALRMPEND 0x00020 /* Pending SIGVTALRM needs to be posted. */ #define PS_PROFPEND 0x00040 /* Pending SIGPROF needs to be posted. */ -#define PS_CVWAITQ 0x00080 /* Proces is on a cv_waitq (not slpq). */ #define PS_SWAPINREQ 0x00100 /* Swapin request due to wakeup. */ #define PS_SWAPPING 0x00200 /* Process is being swapped. */ -#define PS_ASTPENDING 0x00400 /* Process has a pending ast. */ -#define PS_NEEDRESCHED 0x00800 /* Process needs to yield. */ -#define PS_TIMOFAIL 0x01000 /* Timeout from sleep after we were awake. */ + +#define TDF_SINTR 0x00008 /* Sleep is interruptible. */ +#define TDF_TIMEOUT 0x00010 /* Timing out during sleep. */ +#define TDF_SELECT 0x00040 /* Selecting; wakeup/waiting danger. */ +#define TDF_CVWAITQ 0x00080 /* Proces is on a cv_waitq (not slpq). */ +#define TDF_DEADLKTREAT 0x800000 /* Lock aquisition - deadlock treatment. */ + +#define KEF_OWEUPC 0x00002 /* Owe process an addupc() call at next ast. */ +#define KEF_ASTPENDING 0x00400 /* KSE has a pending ast. */ +#define KEF_NEEDRESCHED 0x00800 /* Process needs to yield. */ +#define TDF_TIMOFAIL 0x01000 /* Timeout from sleep after we were awake. */ + +#define KEF_ONRUNQ 0x00000001 /* This KE is on a run queue */ #define P_MAGIC 0xbeefface @@ -333,10 +508,22 @@ MALLOC_DECLARE(M_SUBPROC); MALLOC_DECLARE(M_ZOMBIE); #endif +#define FOREACH_PROC_IN_SYSTEM(p) \ + LIST_FOREACH((p), &allproc, p_list) +#define FOREACH_KSEGRP_IN_PROC(p, kg) \ + TAILQ_FOREACH((kg), &(p)->p_ksegrps, kg_ksegrp) +#define FOREACH_THREAD_IN_GROUP(kg, td) \ + TAILQ_FOREACH((td), &(kg)->kg_threads, td_kglist) +#define FOREACH_KSE_IN_GROUP(kg, ke) \ + TAILQ_FOREACH((ke), &(kg)->kg_kseq, ke_kglist) +#define FOREACH_THREAD_IN_PROC(p, td) \ + TAILQ_FOREACH((td), &(p)->p_threads, td_plist) + static __inline int sigonstack(size_t sp) { - register struct proc *p = curproc; + register struct thread *td = curthread; + struct proc *p = td->td_proc; return ((p->p_flag & P_ALTSTACK) ? #if defined(COMPAT_43) || defined(COMPAT_SUNOS) @@ -352,9 +539,9 @@ sigonstack(size_t sp) * Notify the current process (p) that it has a signal pending, * process as soon as possible. */ -#define signotify(p) do { \ +#define signotify(ke) do { \ mtx_assert(&sched_lock, MA_OWNED); \ - (p)->p_sflag |= PS_ASTPENDING; \ + (ke)->ke_flags |= KEF_ASTPENDING; \ } while (0) /* Handy macro to determine if p1 can mangle p2. */ @@ -429,6 +616,7 @@ extern u_long pgrphash; extern struct sx allproc_lock; extern struct sx proctree_lock; extern struct proc proc0; /* Process slot for swapper. */ +extern struct thread *thread0; /* Primary thread in proc0 */ extern int hogticks; /* Limit on kernel cpu hogs. */ extern int nprocs, maxproc; /* Current and max number of procs. */ extern int maxprocperuid; /* Max procs per uid. */ @@ -439,6 +627,7 @@ extern int sched_quantum; /* Scheduling quantum in ticks. */ LIST_HEAD(proclist, proc); TAILQ_HEAD(procqueue, proc); +TAILQ_HEAD(threadqueue, thread); extern struct proclist allproc; /* List of all processes. */ extern struct proclist zombproc; /* List of zombie processes. */ extern struct proc *initproc, *pageproc; /* Process slots for init, pager. */ @@ -465,14 +654,14 @@ struct pgrp *pgfind __P((pid_t)); /* Find process group by id. */ struct proc *zpfind __P((pid_t)); /* Find zombie process by id. */ void ast __P((struct trapframe *framep)); -struct proc *chooseproc __P((void)); +struct thread *choosethread __P((void)); int enterpgrp __P((struct proc *p, pid_t pgid, int mksess)); void faultin __P((struct proc *p)); void fixjobc __P((struct proc *p, struct pgrp *pgrp, int entering)); -int fork1 __P((struct proc *, int, struct proc **)); +int fork1 __P((struct thread *, int, struct proc **)); void fork_exit __P((void (*)(void *, struct trapframe *), void *, struct trapframe *)); -void fork_return __P((struct proc *, struct trapframe *)); +void fork_return __P((struct thread *, struct trapframe *)); int inferior __P((struct proc *p)); int leavepgrp __P((struct proc *p)); void mi_switch __P((void)); @@ -482,32 +671,33 @@ int p_cansched __P((struct proc *p1, struct proc *p2)); int p_cansignal __P((struct proc *p1, struct proc *p2, int signum)); int p_trespass __P((struct proc *p1, struct proc *p2)); void procinit __P((void)); +void proc_linkup __P((struct proc *p)); void proc_reparent __P((struct proc *child, struct proc *newparent)); int procrunnable __P((void)); -void remrunqueue __P((struct proc *)); -void resetpriority __P((struct proc *)); +void remrunqueue __P((struct thread *)); +void resetpriority __P((struct ksegrp *)); int roundrobin_interval __P((void)); -void schedclock __P((struct proc *)); -void setrunnable __P((struct proc *)); -void setrunqueue __P((struct proc *)); +void schedclock __P((struct thread *)); +void setrunnable __P((struct thread *)); +void setrunqueue __P((struct thread *)); void setsugid __P((struct proc *p)); void sleepinit __P((void)); void stopevent __P((struct proc *, u_int, u_int)); void cpu_idle __P((void)); void cpu_switch __P((void)); void cpu_throw __P((void)) __dead2; -void unsleep __P((struct proc *)); -void updatepri __P((struct proc *)); -void userret __P((struct proc *, struct trapframe *, u_int)); -void maybe_resched __P((struct proc *)); - -void cpu_exit __P((struct proc *)); -void exit1 __P((struct proc *, int)) __dead2; -void cpu_fork __P((struct proc *, struct proc *, int)); -void cpu_set_fork_handler __P((struct proc *, void (*)(void *), void *)); +void unsleep __P((struct thread *)); +void updatepri __P((struct thread *)); +void userret __P((struct thread *, struct trapframe *, u_int)); +void maybe_resched __P((struct ksegrp *)); + +void cpu_exit __P((struct thread *)); +void exit1 __P((struct thread *, int)) __dead2; +void cpu_fork __P((struct thread *, struct proc *, int)); +void cpu_set_fork_handler __P((struct thread *, void (*)(void *), void *)); int trace_req __P((struct proc *)); void cpu_wait __P((struct proc *)); -int cpu_coredump __P((struct proc *, struct vnode *, struct ucred *)); +int cpu_coredump __P((struct thread *, struct vnode *, struct ucred *)); #endif /* _KERNEL */ #endif /* !_SYS_PROC_H_ */ diff --git a/sys/sys/protosw.h b/sys/sys/protosw.h index 3bff666..81ff300 100644 --- a/sys/sys/protosw.h +++ b/sys/sys/protosw.h @@ -44,7 +44,7 @@ /* Forward declare these structures referenced from prototypes below. */ struct mbuf; -struct proc; +struct thread; struct sockaddr; struct socket; struct sockopt; @@ -86,7 +86,7 @@ typedef void pr_slowtimo_t (void); typedef void pr_drain_t (void); typedef int pr_usrreq_t(struct socket *, int, struct mbuf *, - struct mbuf *, struct mbuf *, struct proc *); + struct mbuf *, struct mbuf *, struct thread *); struct protosw { short pr_type; /* socket type used for */ @@ -199,17 +199,17 @@ struct pr_usrreqs { int (*pru_abort) __P((struct socket *so)); int (*pru_accept) __P((struct socket *so, struct sockaddr **nam)); int (*pru_attach) __P((struct socket *so, int proto, - struct proc *p)); + struct thread *td)); int (*pru_bind) __P((struct socket *so, struct sockaddr *nam, - struct proc *p)); + struct thread *td)); int (*pru_connect) __P((struct socket *so, struct sockaddr *nam, - struct proc *p)); + struct thread *td)); int (*pru_connect2) __P((struct socket *so1, struct socket *so2)); int (*pru_control) __P((struct socket *so, u_long cmd, caddr_t data, - struct ifnet *ifp, struct proc *p)); + struct ifnet *ifp, struct thread *td)); int (*pru_detach) __P((struct socket *so)); int (*pru_disconnect) __P((struct socket *so)); - int (*pru_listen) __P((struct socket *so, struct proc *p)); + int (*pru_listen) __P((struct socket *so, struct thread *td)); int (*pru_peeraddr) __P((struct socket *so, struct sockaddr **nam)); int (*pru_rcvd) __P((struct socket *so, int flags)); @@ -217,7 +217,7 @@ struct pr_usrreqs { int flags)); int (*pru_send) __P((struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, struct mbuf *control, - struct proc *p)); + struct thread *td)); #define PRUS_OOB 0x1 #define PRUS_EOF 0x2 #define PRUS_MORETOCOME 0x4 @@ -237,22 +237,22 @@ struct pr_usrreqs { int (*pru_sosend) __P((struct socket *so, struct sockaddr *addr, struct uio *uio, struct mbuf *top, struct mbuf *control, int flags, - struct proc *p)); + struct thread *td)); int (*pru_soreceive) __P((struct socket *so, struct sockaddr **paddr, struct uio *uio, struct mbuf **mp0, struct mbuf **controlp, int *flagsp)); int (*pru_sopoll) __P((struct socket *so, int events, - struct ucred *cred, struct proc *p)); + struct ucred *cred, struct thread *td)); }; int pru_accept_notsupp __P((struct socket *so, struct sockaddr **nam)); int pru_connect_notsupp __P((struct socket *so, struct sockaddr *nam, - struct proc *p)); + struct thread *td)); int pru_connect2_notsupp __P((struct socket *so1, struct socket *so2)); int pru_control_notsupp __P((struct socket *so, u_long cmd, caddr_t data, - struct ifnet *ifp, struct proc *p)); -int pru_listen_notsupp __P((struct socket *so, struct proc *p)); + struct ifnet *ifp, struct thread *td)); +int pru_listen_notsupp __P((struct socket *so, struct thread *td)); int pru_rcvd_notsupp __P((struct socket *so, int flags)); int pru_rcvoob_notsupp __P((struct socket *so, struct mbuf *m, int flags)); int pru_sense_null __P((struct socket *so, struct stat *sb)); diff --git a/sys/sys/ptrace.h b/sys/sys/ptrace.h index 77b797d..de4e5e9 100644 --- a/sys/sys/ptrace.h +++ b/sys/sys/ptrace.h @@ -55,8 +55,8 @@ #include <machine/ptrace.h> /* machine-specific requests, if any */ #ifdef _KERNEL -int ptrace_set_pc __P((struct proc *p, unsigned long addr)); -int ptrace_single_step __P((struct proc *p)); +int ptrace_set_pc __P((struct thread *td, unsigned long addr)); +int ptrace_single_step __P((struct thread *td)); #else /* !_KERNEL */ #include <sys/cdefs.h> diff --git a/sys/sys/resource.h b/sys/sys/resource.h index acc9cd1..2d868f3 100644 --- a/sys/sys/resource.h +++ b/sys/sys/resource.h @@ -135,7 +135,7 @@ struct loadavg { #ifdef _KERNEL extern struct loadavg averunnable; -int dosetrlimit __P((struct proc *, u_int, struct rlimit *)); +int dosetrlimit __P((struct thread *, u_int, struct rlimit *)); #else #include <sys/cdefs.h> diff --git a/sys/sys/resourcevar.h b/sys/sys/resourcevar.h index 53ceac6..e414de8 100644 --- a/sys/sys/resourcevar.h +++ b/sys/sys/resourcevar.h @@ -99,10 +99,12 @@ struct uidinfo { struct mtx ui_mtx; /* protect all counts/limits */ }; +struct thread; +struct kse; struct proc; -void addupc_intr __P((struct proc *p, uintptr_t pc, u_int ticks)); -void addupc_task __P((struct proc *p, uintptr_t pc, u_int ticks)); +void addupc_intr __P((struct kse *ke, uintptr_t pc, u_int ticks)); +void addupc_task __P((struct kse *ke, uintptr_t pc, u_int ticks)); void calcru __P((struct proc *p, struct timeval *up, struct timeval *sp, struct timeval *ip)); int chgproccnt __P((struct uidinfo *uip, int diff, int max)); diff --git a/sys/sys/runq.h b/sys/sys/runq.h index 20286c5..4636e7a 100644 --- a/sys/sys/runq.h +++ b/sys/sys/runq.h @@ -29,6 +29,8 @@ #ifndef _RUNQ_H_ #define _RUNQ_H_ +struct kse; + /* * Run queue parameters. */ @@ -52,7 +54,7 @@ typedef u_int32_t rqb_word_t; /* * Head of run queues. */ -TAILQ_HEAD(rqhead, proc); +TAILQ_HEAD(rqhead, kse); /* * Bit array which maintains the status of a run queue. When a queue is @@ -71,10 +73,10 @@ struct runq { struct rqhead rq_queues[RQ_NQS]; }; -void runq_add(struct runq *, struct proc *); +void runq_add(struct runq *, struct kse *); int runq_check(struct runq *); -struct proc *runq_choose(struct runq *); +struct kse *runq_choose(struct runq *); void runq_init(struct runq *); -void runq_remove(struct runq *, struct proc *); +void runq_remove(struct runq *, struct kse *); #endif diff --git a/sys/sys/selinfo.h b/sys/sys/selinfo.h index f0ca515..cbfa55d 100644 --- a/sys/sys/selinfo.h +++ b/sys/sys/selinfo.h @@ -39,21 +39,23 @@ #include <sys/event.h> /* for struct klist */ +struct thread; /* * Used to maintain information about processes that wish to be * notified when I/O becomes possible. */ struct selinfo { pid_t si_pid; /* process to be notified */ + struct thread *si_thread; /* thread in that process XXXKSE */ struct klist si_note; /* kernel note list */ short si_flags; /* see below */ }; #define SI_COLL 0x0001 /* collision occurred */ #ifdef _KERNEL -struct proc; +struct thread; -void selrecord __P((struct proc *selector, struct selinfo *)); +void selrecord __P((struct thread *selector, struct selinfo *)); void selwakeup __P((struct selinfo *)); #endif diff --git a/sys/sys/shm.h b/sys/sys/shm.h index 444539e..48aa303 100644 --- a/sys/sys/shm.h +++ b/sys/sys/shm.h @@ -79,6 +79,7 @@ struct shminfo { extern struct shminfo shminfo; extern struct shmid_ds *shmsegs; +struct thread; struct proc; void shmexit __P((struct proc *)); diff --git a/sys/sys/signalvar.h b/sys/sys/signalvar.h index 97f2513..2ad0960 100644 --- a/sys/sys/signalvar.h +++ b/sys/sys/signalvar.h @@ -188,6 +188,7 @@ __sigseteq(sigset_t *set1, sigset_t *set2) #ifdef _KERNEL struct pgrp; +struct thread; struct proc; struct sigio; @@ -205,7 +206,7 @@ void pgsigio __P((struct sigio *, int signum, int checkctty)); void pgsignal __P((struct pgrp *pgrp, int sig, int checkctty)); void postsig __P((int sig)); void psignal __P((struct proc *p, int sig)); -void sigexit __P((struct proc *p, int signum)) __dead2; +void sigexit __P((struct thread *td, int signum)) __dead2; void siginit __P((struct proc *p)); void trapsignal __P((struct proc *p, int sig, u_long code)); diff --git a/sys/sys/smp.h b/sys/sys/smp.h index 1245fd4..f887d08 100644 --- a/sys/sys/smp.h +++ b/sys/sys/smp.h @@ -52,7 +52,7 @@ void cpu_mp_announce(void); int cpu_mp_probe(void); void cpu_mp_start(void); -void forward_signal(struct proc *); +void forward_signal(struct thread *); void forward_roundrobin(void); int restart_cpus(u_int); int stop_cpus(u_int); diff --git a/sys/sys/socketvar.h b/sys/sys/socketvar.h index 3ce3c28..efd555f 100644 --- a/sys/sys/socketvar.h +++ b/sys/sys/socketvar.h @@ -267,7 +267,7 @@ struct sockopt { int sopt_name; /* third arg of [gs]etsockopt */ void *sopt_val; /* fourth arg of [gs]etsockopt */ size_t sopt_valsize; /* (almost) fifth arg of [gs]etsockopt */ - struct proc *sopt_p; /* calling process or null if kernel */ + struct thread *sopt_td; /* calling thread or null if kernel */ }; struct sf_buf { @@ -311,15 +311,15 @@ struct knote; * File operations on sockets. */ int soo_read __P((struct file *fp, struct uio *uio, struct ucred *cred, - int flags, struct proc *p)); + int flags, struct thread *td)); int soo_write __P((struct file *fp, struct uio *uio, struct ucred *cred, - int flags, struct proc *p)); -int soo_close __P((struct file *fp, struct proc *p)); + int flags, struct thread *td)); +int soo_close __P((struct file *fp, struct thread *td)); int soo_ioctl __P((struct file *fp, u_long cmd, caddr_t data, - struct proc *p)); + struct thread *td)); int soo_poll __P((struct file *fp, int events, struct ucred *cred, - struct proc *p)); -int soo_stat __P((struct file *fp, struct stat *ub, struct proc *p)); + struct thread *td)); +int soo_stat __P((struct file *fp, struct stat *ub, struct thread *td)); int sokqfilter __P((struct file *fp, struct knote *kn)); /* @@ -345,21 +345,21 @@ void sbflush __P((struct sockbuf *sb)); void sbinsertoob __P((struct sockbuf *sb, struct mbuf *m0)); void sbrelease __P((struct sockbuf *sb, struct socket *so)); int sbreserve __P((struct sockbuf *sb, u_long cc, struct socket *so, - struct proc *p)); + struct thread *td)); void sbtoxsockbuf __P((struct sockbuf *sb, struct xsockbuf *xsb)); int sbwait __P((struct sockbuf *sb)); int sb_lock __P((struct sockbuf *sb)); int soabort __P((struct socket *so)); int soaccept __P((struct socket *so, struct sockaddr **nam)); struct socket *soalloc __P((int waitok)); -int sobind __P((struct socket *so, struct sockaddr *nam, struct proc *p)); +int sobind __P((struct socket *so, struct sockaddr *nam, struct thread *td)); void socantrcvmore __P((struct socket *so)); void socantsendmore __P((struct socket *so)); int soclose __P((struct socket *so)); -int soconnect __P((struct socket *so, struct sockaddr *nam, struct proc *p)); +int soconnect __P((struct socket *so, struct sockaddr *nam, struct thread *td)); int soconnect2 __P((struct socket *so1, struct socket *so2)); int socreate __P((int dom, struct socket **aso, int type, int proto, - struct proc *p)); + struct thread *td)); void sodealloc __P((struct socket *so)); int sodisconnect __P((struct socket *so)); void sofree __P((struct socket *so)); @@ -369,13 +369,13 @@ void soisconnected __P((struct socket *so)); void soisconnecting __P((struct socket *so)); void soisdisconnected __P((struct socket *so)); void soisdisconnecting __P((struct socket *so)); -int solisten __P((struct socket *so, int backlog, struct proc *p)); +int solisten __P((struct socket *so, int backlog, struct thread *td)); struct socket * sodropablereq __P((struct socket *head)); struct socket * sonewconn __P((struct socket *head, int connstatus)); struct socket * - sonewconn3 __P((struct socket *head, int connstatus, struct proc *p)); + sonewconn3 __P((struct socket *head, int connstatus, struct thread *td)); int sooptcopyin __P((struct sockopt *sopt, void *buf, size_t len, size_t minlen)); int sooptcopyout __P((struct sockopt *sopt, void *buf, size_t len)); @@ -386,7 +386,7 @@ int soopt_mcopyin __P((struct sockopt *sopt, struct mbuf *m)); int soopt_mcopyout __P((struct sockopt *sopt, struct mbuf *m)); int sopoll __P((struct socket *so, int events, struct ucred *cred, - struct proc *p)); + struct thread *td)); int soreceive __P((struct socket *so, struct sockaddr **paddr, struct uio *uio, struct mbuf **mp0, struct mbuf **controlp, int *flagsp)); @@ -394,7 +394,7 @@ int soreserve __P((struct socket *so, u_long sndcc, u_long rcvcc)); void sorflush __P((struct socket *so)); int sosend __P((struct socket *so, struct sockaddr *addr, struct uio *uio, struct mbuf *top, struct mbuf *control, int flags, - struct proc *p)); + struct thread *td)); int sosetopt __P((struct socket *so, struct sockopt *sopt)); int soshutdown __P((struct socket *so, int how)); void sotoxsocket __P((struct socket *so, struct xsocket *xso)); diff --git a/sys/sys/sx.h b/sys/sys/sx.h index 42b269f..f6fef05 100644 --- a/sys/sys/sx.h +++ b/sys/sys/sx.h @@ -43,7 +43,7 @@ struct sx { int sx_shrd_wcnt; /* Number of slock waiters. */ struct cv sx_excl_cv; /* xlock waiters. */ int sx_excl_wcnt; /* Number of xlock waiters. */ - struct proc *sx_xholder; /* Thread presently holding xlock. */ + struct thread *sx_xholder; /* Thread presently holding xlock. */ }; #ifdef _KERNEL @@ -80,7 +80,7 @@ void _sx_downgrade(struct sx *sx, const char *file, int line); witness_assert(&(sx)->sx_object, LA_SLOCKED, file, line) #else #define _SX_ASSERT_LOCKED(sx, file, line) do { \ - KASSERT(((sx)->sx_cnt > 0 || (sx)->sx_xholder == curproc), \ + KASSERT(((sx)->sx_cnt > 0 || (sx)->sx_xholder == curthread), \ ("Lock %s not locked @ %s:%d", (sx)->sx_object.lo_name, \ file, line)); \ } while (0) @@ -96,7 +96,7 @@ void _sx_downgrade(struct sx *sx, const char *file, int line); * SX_ASSERT_XLOCKED() detects and guarantees that *we* own the xlock. */ #define _SX_ASSERT_XLOCKED(sx, file, line) do { \ - KASSERT(((sx)->sx_xholder == curproc), \ + KASSERT(((sx)->sx_xholder == curthread), \ ("Lock %s not exclusively locked @ %s:%d", \ (sx)->sx_object.lo_name, file, line)); \ } while (0) diff --git a/sys/sys/sysctl.h b/sys/sys/sysctl.h index e83d626..7f4923c 100644 --- a/sys/sys/sysctl.h +++ b/sys/sys/sysctl.h @@ -43,6 +43,7 @@ #include <sys/_posix.h> #include <sys/queue.h> +struct thread; /* * Definitions for sysctl call. The sysctl call uses a hierarchical name * for objects that can be examined or modified. The name is expressed as @@ -110,7 +111,7 @@ struct ctlname { * so that we can use the interface from the kernel or from user-space. */ struct sysctl_req { - struct proc *p; + struct proc *p; /* used for access checking */ int lock; void *oldptr; size_t oldlen; @@ -582,13 +583,13 @@ struct sysctl_ctx_entry *sysctl_ctx_entry_find(struct sysctl_ctx_list *clist, int sysctl_ctx_entry_del(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp); -int kernel_sysctl(struct proc *p, int *name, u_int namelen, void *old, +int kernel_sysctl(struct thread *td, int *name, u_int namelen, void *old, size_t *oldlenp, void *new, size_t newlen, size_t *retval); -int kernel_sysctlbyname(struct proc *p, char *name, +int kernel_sysctlbyname(struct thread *td, char *name, void *old, size_t *oldlenp, void *new, size_t newlen, size_t *retval); -int userland_sysctl(struct proc *p, int *name, u_int namelen, void *old, +int userland_sysctl(struct thread *td, int *name, u_int namelen, void *old, size_t *oldlenp, int inkernel, void *new, size_t newlen, size_t *retval); int sysctl_find_oid(int *name, u_int namelen, struct sysctl_oid **noid, diff --git a/sys/sys/sysent.h b/sys/sys/sysent.h index fca23e0..c74ee41 100644 --- a/sys/sys/sysent.h +++ b/sys/sys/sysent.h @@ -36,9 +36,9 @@ #ifndef _SYS_SYSENT_H_ #define _SYS_SYSENT_H_ -struct proc; +struct thread; -typedef int sy_call_t __P((struct proc *, void *)); +typedef int sy_call_t __P((struct thread *, void *)); struct sysent { /* system call table */ int sy_narg; /* number of arguments */ @@ -76,7 +76,7 @@ struct sysentvec { void (*sv_prepsyscall) __P((struct trapframe *, int *, u_int *, caddr_t *)); char *sv_name; /* name of binary type */ - int (*sv_coredump) __P((struct proc *, struct vnode *, + int (*sv_coredump) __P((struct thread *, struct vnode *, off_t)); /* function to dump core, or NULL */ int (*sv_imgact_try) __P((struct image_params *)); diff --git a/sys/sys/sysproto.h b/sys/sys/sysproto.h index c509d4c..e97f811 100644 --- a/sys/sys/sysproto.h +++ b/sys/sys/sysproto.h @@ -13,6 +13,7 @@ #include <sys/acl.h> +struct thread; struct proc; #define PAD_(t) (sizeof(register_t) <= sizeof(t) ? \ @@ -1071,246 +1072,246 @@ struct extattr_delete_fd_args { struct __setugid_args { char flag_l_[PADL_(int)]; int flag; char flag_r_[PADR_(int)]; }; -int nosys __P((struct proc *, struct nosys_args *)); -void sys_exit __P((struct proc *, struct sys_exit_args *)); -int fork __P((struct proc *, struct fork_args *)); -int read __P((struct proc *, struct read_args *)); -int write __P((struct proc *, struct write_args *)); -int open __P((struct proc *, struct open_args *)); -int close __P((struct proc *, struct close_args *)); -int wait4 __P((struct proc *, struct wait_args *)); -int link __P((struct proc *, struct link_args *)); -int unlink __P((struct proc *, struct unlink_args *)); -int chdir __P((struct proc *, struct chdir_args *)); -int fchdir __P((struct proc *, struct fchdir_args *)); -int mknod __P((struct proc *, struct mknod_args *)); -int chmod __P((struct proc *, struct chmod_args *)); -int chown __P((struct proc *, struct chown_args *)); -int obreak __P((struct proc *, struct obreak_args *)); -int getfsstat __P((struct proc *, struct getfsstat_args *)); -int getpid __P((struct proc *, struct getpid_args *)); -int mount __P((struct proc *, struct mount_args *)); -int unmount __P((struct proc *, struct unmount_args *)); -int setuid __P((struct proc *, struct setuid_args *)); -int getuid __P((struct proc *, struct getuid_args *)); -int geteuid __P((struct proc *, struct geteuid_args *)); -int ptrace __P((struct proc *, struct ptrace_args *)); -int recvmsg __P((struct proc *, struct recvmsg_args *)); -int sendmsg __P((struct proc *, struct sendmsg_args *)); -int recvfrom __P((struct proc *, struct recvfrom_args *)); -int accept __P((struct proc *, struct accept_args *)); -int getpeername __P((struct proc *, struct getpeername_args *)); -int getsockname __P((struct proc *, struct getsockname_args *)); -int access __P((struct proc *, struct access_args *)); -int chflags __P((struct proc *, struct chflags_args *)); -int fchflags __P((struct proc *, struct fchflags_args *)); -int sync __P((struct proc *, struct sync_args *)); -int kill __P((struct proc *, struct kill_args *)); -int getppid __P((struct proc *, struct getppid_args *)); -int dup __P((struct proc *, struct dup_args *)); -int pipe __P((struct proc *, struct pipe_args *)); -int getegid __P((struct proc *, struct getegid_args *)); -int profil __P((struct proc *, struct profil_args *)); -int ktrace __P((struct proc *, struct ktrace_args *)); -int getgid __P((struct proc *, struct getgid_args *)); -int getlogin __P((struct proc *, struct getlogin_args *)); -int setlogin __P((struct proc *, struct setlogin_args *)); -int acct __P((struct proc *, struct acct_args *)); -int sigaltstack __P((struct proc *, struct sigaltstack_args *)); -int ioctl __P((struct proc *, struct ioctl_args *)); -int reboot __P((struct proc *, struct reboot_args *)); -int revoke __P((struct proc *, struct revoke_args *)); -int symlink __P((struct proc *, struct symlink_args *)); -int readlink __P((struct proc *, struct readlink_args *)); -int execve __P((struct proc *, struct execve_args *)); -int umask __P((struct proc *, struct umask_args *)); -int chroot __P((struct proc *, struct chroot_args *)); -int msync __P((struct proc *, struct msync_args *)); -int vfork __P((struct proc *, struct vfork_args *)); -int sbrk __P((struct proc *, struct sbrk_args *)); -int sstk __P((struct proc *, struct sstk_args *)); -int ovadvise __P((struct proc *, struct ovadvise_args *)); -int munmap __P((struct proc *, struct munmap_args *)); -int mprotect __P((struct proc *, struct mprotect_args *)); -int madvise __P((struct proc *, struct madvise_args *)); -int mincore __P((struct proc *, struct mincore_args *)); -int getgroups __P((struct proc *, struct getgroups_args *)); -int setgroups __P((struct proc *, struct setgroups_args *)); -int getpgrp __P((struct proc *, struct getpgrp_args *)); -int setpgid __P((struct proc *, struct setpgid_args *)); -int setitimer __P((struct proc *, struct setitimer_args *)); -int swapon __P((struct proc *, struct swapon_args *)); -int getitimer __P((struct proc *, struct getitimer_args *)); -int getdtablesize __P((struct proc *, struct getdtablesize_args *)); -int dup2 __P((struct proc *, struct dup2_args *)); -int fcntl __P((struct proc *, struct fcntl_args *)); -int select __P((struct proc *, struct select_args *)); -int fsync __P((struct proc *, struct fsync_args *)); -int setpriority __P((struct proc *, struct setpriority_args *)); -int socket __P((struct proc *, struct socket_args *)); -int connect __P((struct proc *, struct connect_args *)); -int getpriority __P((struct proc *, struct getpriority_args *)); -int bind __P((struct proc *, struct bind_args *)); -int setsockopt __P((struct proc *, struct setsockopt_args *)); -int listen __P((struct proc *, struct listen_args *)); -int gettimeofday __P((struct proc *, struct gettimeofday_args *)); -int getrusage __P((struct proc *, struct getrusage_args *)); -int getsockopt __P((struct proc *, struct getsockopt_args *)); -int readv __P((struct proc *, struct readv_args *)); -int writev __P((struct proc *, struct writev_args *)); -int settimeofday __P((struct proc *, struct settimeofday_args *)); -int fchown __P((struct proc *, struct fchown_args *)); -int fchmod __P((struct proc *, struct fchmod_args *)); -int setreuid __P((struct proc *, struct setreuid_args *)); -int setregid __P((struct proc *, struct setregid_args *)); -int rename __P((struct proc *, struct rename_args *)); -int flock __P((struct proc *, struct flock_args *)); -int mkfifo __P((struct proc *, struct mkfifo_args *)); -int sendto __P((struct proc *, struct sendto_args *)); -int shutdown __P((struct proc *, struct shutdown_args *)); -int socketpair __P((struct proc *, struct socketpair_args *)); -int mkdir __P((struct proc *, struct mkdir_args *)); -int rmdir __P((struct proc *, struct rmdir_args *)); -int utimes __P((struct proc *, struct utimes_args *)); -int adjtime __P((struct proc *, struct adjtime_args *)); -int setsid __P((struct proc *, struct setsid_args *)); -int quotactl __P((struct proc *, struct quotactl_args *)); -int nfssvc __P((struct proc *, struct nfssvc_args *)); -int statfs __P((struct proc *, struct statfs_args *)); -int fstatfs __P((struct proc *, struct fstatfs_args *)); -int getfh __P((struct proc *, struct getfh_args *)); -int getdomainname __P((struct proc *, struct getdomainname_args *)); -int setdomainname __P((struct proc *, struct setdomainname_args *)); -int uname __P((struct proc *, struct uname_args *)); -int sysarch __P((struct proc *, struct sysarch_args *)); -int rtprio __P((struct proc *, struct rtprio_args *)); -int semsys __P((struct proc *, struct semsys_args *)); -int msgsys __P((struct proc *, struct msgsys_args *)); -int shmsys __P((struct proc *, struct shmsys_args *)); -int pread __P((struct proc *, struct pread_args *)); -int pwrite __P((struct proc *, struct pwrite_args *)); -int ntp_adjtime __P((struct proc *, struct ntp_adjtime_args *)); -int setgid __P((struct proc *, struct setgid_args *)); -int setegid __P((struct proc *, struct setegid_args *)); -int seteuid __P((struct proc *, struct seteuid_args *)); -int stat __P((struct proc *, struct stat_args *)); -int fstat __P((struct proc *, struct fstat_args *)); -int lstat __P((struct proc *, struct lstat_args *)); -int pathconf __P((struct proc *, struct pathconf_args *)); -int fpathconf __P((struct proc *, struct fpathconf_args *)); -int getrlimit __P((struct proc *, struct __getrlimit_args *)); -int setrlimit __P((struct proc *, struct __setrlimit_args *)); -int getdirentries __P((struct proc *, struct getdirentries_args *)); -int mmap __P((struct proc *, struct mmap_args *)); -int lseek __P((struct proc *, struct lseek_args *)); -int truncate __P((struct proc *, struct truncate_args *)); -int ftruncate __P((struct proc *, struct ftruncate_args *)); -int __sysctl __P((struct proc *, struct sysctl_args *)); -int mlock __P((struct proc *, struct mlock_args *)); -int munlock __P((struct proc *, struct munlock_args *)); -int undelete __P((struct proc *, struct undelete_args *)); -int futimes __P((struct proc *, struct futimes_args *)); -int getpgid __P((struct proc *, struct getpgid_args *)); -int poll __P((struct proc *, struct poll_args *)); -int lkmnosys __P((struct proc *, struct nosys_args *)); -int __semctl __P((struct proc *, struct __semctl_args *)); -int semget __P((struct proc *, struct semget_args *)); -int semop __P((struct proc *, struct semop_args *)); -int msgctl __P((struct proc *, struct msgctl_args *)); -int msgget __P((struct proc *, struct msgget_args *)); -int msgsnd __P((struct proc *, struct msgsnd_args *)); -int msgrcv __P((struct proc *, struct msgrcv_args *)); -int shmat __P((struct proc *, struct shmat_args *)); -int shmctl __P((struct proc *, struct shmctl_args *)); -int shmdt __P((struct proc *, struct shmdt_args *)); -int shmget __P((struct proc *, struct shmget_args *)); -int clock_gettime __P((struct proc *, struct clock_gettime_args *)); -int clock_settime __P((struct proc *, struct clock_settime_args *)); -int clock_getres __P((struct proc *, struct clock_getres_args *)); -int nanosleep __P((struct proc *, struct nanosleep_args *)); -int minherit __P((struct proc *, struct minherit_args *)); -int rfork __P((struct proc *, struct rfork_args *)); -int openbsd_poll __P((struct proc *, struct openbsd_poll_args *)); -int issetugid __P((struct proc *, struct issetugid_args *)); -int lchown __P((struct proc *, struct lchown_args *)); -int getdents __P((struct proc *, struct getdents_args *)); -int lchmod __P((struct proc *, struct lchmod_args *)); -int lutimes __P((struct proc *, struct lutimes_args *)); -int nstat __P((struct proc *, struct nstat_args *)); -int nfstat __P((struct proc *, struct nfstat_args *)); -int nlstat __P((struct proc *, struct nlstat_args *)); -int fhstatfs __P((struct proc *, struct fhstatfs_args *)); -int fhopen __P((struct proc *, struct fhopen_args *)); -int fhstat __P((struct proc *, struct fhstat_args *)); -int modnext __P((struct proc *, struct modnext_args *)); -int modstat __P((struct proc *, struct modstat_args *)); -int modfnext __P((struct proc *, struct modfnext_args *)); -int modfind __P((struct proc *, struct modfind_args *)); -int kldload __P((struct proc *, struct kldload_args *)); -int kldunload __P((struct proc *, struct kldunload_args *)); -int kldfind __P((struct proc *, struct kldfind_args *)); -int kldnext __P((struct proc *, struct kldnext_args *)); -int kldstat __P((struct proc *, struct kldstat_args *)); -int kldfirstmod __P((struct proc *, struct kldfirstmod_args *)); -int getsid __P((struct proc *, struct getsid_args *)); -int setresuid __P((struct proc *, struct setresuid_args *)); -int setresgid __P((struct proc *, struct setresgid_args *)); -int aio_return __P((struct proc *, struct aio_return_args *)); -int aio_suspend __P((struct proc *, struct aio_suspend_args *)); -int aio_cancel __P((struct proc *, struct aio_cancel_args *)); -int aio_error __P((struct proc *, struct aio_error_args *)); -int aio_read __P((struct proc *, struct aio_read_args *)); -int aio_write __P((struct proc *, struct aio_write_args *)); -int lio_listio __P((struct proc *, struct lio_listio_args *)); -int yield __P((struct proc *, struct yield_args *)); -int mlockall __P((struct proc *, struct mlockall_args *)); -int munlockall __P((struct proc *, struct munlockall_args *)); -int __getcwd __P((struct proc *, struct __getcwd_args *)); -int sched_setparam __P((struct proc *, struct sched_setparam_args *)); -int sched_getparam __P((struct proc *, struct sched_getparam_args *)); -int sched_setscheduler __P((struct proc *, struct sched_setscheduler_args *)); -int sched_getscheduler __P((struct proc *, struct sched_getscheduler_args *)); -int sched_yield __P((struct proc *, struct sched_yield_args *)); -int sched_get_priority_max __P((struct proc *, struct sched_get_priority_max_args *)); -int sched_get_priority_min __P((struct proc *, struct sched_get_priority_min_args *)); -int sched_rr_get_interval __P((struct proc *, struct sched_rr_get_interval_args *)); -int utrace __P((struct proc *, struct utrace_args *)); -int sendfile __P((struct proc *, struct sendfile_args *)); -int kldsym __P((struct proc *, struct kldsym_args *)); -int jail __P((struct proc *, struct jail_args *)); -int sigprocmask __P((struct proc *, struct sigprocmask_args *)); -int sigsuspend __P((struct proc *, struct sigsuspend_args *)); -int sigaction __P((struct proc *, struct sigaction_args *)); -int sigpending __P((struct proc *, struct sigpending_args *)); -int sigreturn __P((struct proc *, struct sigreturn_args *)); -int __acl_get_file __P((struct proc *, struct __acl_get_file_args *)); -int __acl_set_file __P((struct proc *, struct __acl_set_file_args *)); -int __acl_get_fd __P((struct proc *, struct __acl_get_fd_args *)); -int __acl_set_fd __P((struct proc *, struct __acl_set_fd_args *)); -int __acl_delete_file __P((struct proc *, struct __acl_delete_file_args *)); -int __acl_delete_fd __P((struct proc *, struct __acl_delete_fd_args *)); -int __acl_aclcheck_file __P((struct proc *, struct __acl_aclcheck_file_args *)); -int __acl_aclcheck_fd __P((struct proc *, struct __acl_aclcheck_fd_args *)); -int extattrctl __P((struct proc *, struct extattrctl_args *)); -int extattr_set_file __P((struct proc *, struct extattr_set_file_args *)); -int extattr_get_file __P((struct proc *, struct extattr_get_file_args *)); -int extattr_delete_file __P((struct proc *, struct extattr_delete_file_args *)); -int aio_waitcomplete __P((struct proc *, struct aio_waitcomplete_args *)); -int getresuid __P((struct proc *, struct getresuid_args *)); -int getresgid __P((struct proc *, struct getresgid_args *)); -int kqueue __P((struct proc *, struct kqueue_args *)); -int kevent __P((struct proc *, struct kevent_args *)); -int __cap_get_proc __P((struct proc *, struct __cap_get_proc_args *)); -int __cap_set_proc __P((struct proc *, struct __cap_set_proc_args *)); -int __cap_get_fd __P((struct proc *, struct __cap_get_fd_args *)); -int __cap_get_file __P((struct proc *, struct __cap_get_file_args *)); -int __cap_set_fd __P((struct proc *, struct __cap_set_fd_args *)); -int __cap_set_file __P((struct proc *, struct __cap_set_file_args *)); -int lkmressys __P((struct proc *, struct nosys_args *)); -int extattr_set_fd __P((struct proc *, struct extattr_set_fd_args *)); -int extattr_get_fd __P((struct proc *, struct extattr_get_fd_args *)); -int extattr_delete_fd __P((struct proc *, struct extattr_delete_fd_args *)); -int __setugid __P((struct proc *, struct __setugid_args *)); +int nosys __P((struct thread *, struct nosys_args *)); +void sys_exit __P((struct thread *, struct sys_exit_args *)); +int fork __P((struct thread *, struct fork_args *)); +int read __P((struct thread *, struct read_args *)); +int write __P((struct thread *, struct write_args *)); +int open __P((struct thread *, struct open_args *)); +int close __P((struct thread *, struct close_args *)); +int wait4 __P((struct thread *, struct wait_args *)); +int link __P((struct thread *, struct link_args *)); +int unlink __P((struct thread *, struct unlink_args *)); +int chdir __P((struct thread *, struct chdir_args *)); +int fchdir __P((struct thread *, struct fchdir_args *)); +int mknod __P((struct thread *, struct mknod_args *)); +int chmod __P((struct thread *, struct chmod_args *)); +int chown __P((struct thread *, struct chown_args *)); +int obreak __P((struct thread *, struct obreak_args *)); +int getfsstat __P((struct thread *, struct getfsstat_args *)); +int getpid __P((struct thread *, struct getpid_args *)); +int mount __P((struct thread *, struct mount_args *)); +int unmount __P((struct thread *, struct unmount_args *)); +int setuid __P((struct thread *, struct setuid_args *)); +int getuid __P((struct thread *, struct getuid_args *)); +int geteuid __P((struct thread *, struct geteuid_args *)); +int ptrace __P((struct thread *, struct ptrace_args *)); +int recvmsg __P((struct thread *, struct recvmsg_args *)); +int sendmsg __P((struct thread *, struct sendmsg_args *)); +int recvfrom __P((struct thread *, struct recvfrom_args *)); +int accept __P((struct thread *, struct accept_args *)); +int getpeername __P((struct thread *, struct getpeername_args *)); +int getsockname __P((struct thread *, struct getsockname_args *)); +int access __P((struct thread *, struct access_args *)); +int chflags __P((struct thread *, struct chflags_args *)); +int fchflags __P((struct thread *, struct fchflags_args *)); +int sync __P((struct thread *, struct sync_args *)); +int kill __P((struct thread *, struct kill_args *)); +int getppid __P((struct thread *, struct getppid_args *)); +int dup __P((struct thread *, struct dup_args *)); +int pipe __P((struct thread *, struct pipe_args *)); +int getegid __P((struct thread *, struct getegid_args *)); +int profil __P((struct thread *, struct profil_args *)); +int ktrace __P((struct thread *, struct ktrace_args *)); +int getgid __P((struct thread *, struct getgid_args *)); +int getlogin __P((struct thread *, struct getlogin_args *)); +int setlogin __P((struct thread *, struct setlogin_args *)); +int acct __P((struct thread *, struct acct_args *)); +int sigaltstack __P((struct thread *, struct sigaltstack_args *)); +int ioctl __P((struct thread *, struct ioctl_args *)); +int reboot __P((struct thread *, struct reboot_args *)); +int revoke __P((struct thread *, struct revoke_args *)); +int symlink __P((struct thread *, struct symlink_args *)); +int readlink __P((struct thread *, struct readlink_args *)); +int execve __P((struct thread *, struct execve_args *)); +int umask __P((struct thread *, struct umask_args *)); +int chroot __P((struct thread *, struct chroot_args *)); +int msync __P((struct thread *, struct msync_args *)); +int vfork __P((struct thread *, struct vfork_args *)); +int sbrk __P((struct thread *, struct sbrk_args *)); +int sstk __P((struct thread *, struct sstk_args *)); +int ovadvise __P((struct thread *, struct ovadvise_args *)); +int munmap __P((struct thread *, struct munmap_args *)); +int mprotect __P((struct thread *, struct mprotect_args *)); +int madvise __P((struct thread *, struct madvise_args *)); +int mincore __P((struct thread *, struct mincore_args *)); +int getgroups __P((struct thread *, struct getgroups_args *)); +int setgroups __P((struct thread *, struct setgroups_args *)); +int getpgrp __P((struct thread *, struct getpgrp_args *)); +int setpgid __P((struct thread *, struct setpgid_args *)); +int setitimer __P((struct thread *, struct setitimer_args *)); +int swapon __P((struct thread *, struct swapon_args *)); +int getitimer __P((struct thread *, struct getitimer_args *)); +int getdtablesize __P((struct thread *, struct getdtablesize_args *)); +int dup2 __P((struct thread *, struct dup2_args *)); +int fcntl __P((struct thread *, struct fcntl_args *)); +int select __P((struct thread *, struct select_args *)); +int fsync __P((struct thread *, struct fsync_args *)); +int setpriority __P((struct thread *, struct setpriority_args *)); +int socket __P((struct thread *, struct socket_args *)); +int connect __P((struct thread *, struct connect_args *)); +int getpriority __P((struct thread *, struct getpriority_args *)); +int bind __P((struct thread *, struct bind_args *)); +int setsockopt __P((struct thread *, struct setsockopt_args *)); +int listen __P((struct thread *, struct listen_args *)); +int gettimeofday __P((struct thread *, struct gettimeofday_args *)); +int getrusage __P((struct thread *, struct getrusage_args *)); +int getsockopt __P((struct thread *, struct getsockopt_args *)); +int readv __P((struct thread *, struct readv_args *)); +int writev __P((struct thread *, struct writev_args *)); +int settimeofday __P((struct thread *, struct settimeofday_args *)); +int fchown __P((struct thread *, struct fchown_args *)); +int fchmod __P((struct thread *, struct fchmod_args *)); +int setreuid __P((struct thread *, struct setreuid_args *)); +int setregid __P((struct thread *, struct setregid_args *)); +int rename __P((struct thread *, struct rename_args *)); +int flock __P((struct thread *, struct flock_args *)); +int mkfifo __P((struct thread *, struct mkfifo_args *)); +int sendto __P((struct thread *, struct sendto_args *)); +int shutdown __P((struct thread *, struct shutdown_args *)); +int socketpair __P((struct thread *, struct socketpair_args *)); +int mkdir __P((struct thread *, struct mkdir_args *)); +int rmdir __P((struct thread *, struct rmdir_args *)); +int utimes __P((struct thread *, struct utimes_args *)); +int adjtime __P((struct thread *, struct adjtime_args *)); +int setsid __P((struct thread *, struct setsid_args *)); +int quotactl __P((struct thread *, struct quotactl_args *)); +int nfssvc __P((struct thread *, struct nfssvc_args *)); +int statfs __P((struct thread *, struct statfs_args *)); +int fstatfs __P((struct thread *, struct fstatfs_args *)); +int getfh __P((struct thread *, struct getfh_args *)); +int getdomainname __P((struct thread *, struct getdomainname_args *)); +int setdomainname __P((struct thread *, struct setdomainname_args *)); +int uname __P((struct thread *, struct uname_args *)); +int sysarch __P((struct thread *, struct sysarch_args *)); +int rtprio __P((struct thread *, struct rtprio_args *)); +int semsys __P((struct thread *, struct semsys_args *)); +int msgsys __P((struct thread *, struct msgsys_args *)); +int shmsys __P((struct thread *, struct shmsys_args *)); +int pread __P((struct thread *, struct pread_args *)); +int pwrite __P((struct thread *, struct pwrite_args *)); +int ntp_adjtime __P((struct thread *, struct ntp_adjtime_args *)); +int setgid __P((struct thread *, struct setgid_args *)); +int setegid __P((struct thread *, struct setegid_args *)); +int seteuid __P((struct thread *, struct seteuid_args *)); +int stat __P((struct thread *, struct stat_args *)); +int fstat __P((struct thread *, struct fstat_args *)); +int lstat __P((struct thread *, struct lstat_args *)); +int pathconf __P((struct thread *, struct pathconf_args *)); +int fpathconf __P((struct thread *, struct fpathconf_args *)); +int getrlimit __P((struct thread *, struct __getrlimit_args *)); +int setrlimit __P((struct thread *, struct __setrlimit_args *)); +int getdirentries __P((struct thread *, struct getdirentries_args *)); +int mmap __P((struct thread *, struct mmap_args *)); +int lseek __P((struct thread *, struct lseek_args *)); +int truncate __P((struct thread *, struct truncate_args *)); +int ftruncate __P((struct thread *, struct ftruncate_args *)); +int __sysctl __P((struct thread *, struct sysctl_args *)); +int mlock __P((struct thread *, struct mlock_args *)); +int munlock __P((struct thread *, struct munlock_args *)); +int undelete __P((struct thread *, struct undelete_args *)); +int futimes __P((struct thread *, struct futimes_args *)); +int getpgid __P((struct thread *, struct getpgid_args *)); +int poll __P((struct thread *, struct poll_args *)); +int lkmnosys __P((struct thread *, struct nosys_args *)); +int __semctl __P((struct thread *, struct __semctl_args *)); +int semget __P((struct thread *, struct semget_args *)); +int semop __P((struct thread *, struct semop_args *)); +int msgctl __P((struct thread *, struct msgctl_args *)); +int msgget __P((struct thread *, struct msgget_args *)); +int msgsnd __P((struct thread *, struct msgsnd_args *)); +int msgrcv __P((struct thread *, struct msgrcv_args *)); +int shmat __P((struct thread *, struct shmat_args *)); +int shmctl __P((struct thread *, struct shmctl_args *)); +int shmdt __P((struct thread *, struct shmdt_args *)); +int shmget __P((struct thread *, struct shmget_args *)); +int clock_gettime __P((struct thread *, struct clock_gettime_args *)); +int clock_settime __P((struct thread *, struct clock_settime_args *)); +int clock_getres __P((struct thread *, struct clock_getres_args *)); +int nanosleep __P((struct thread *, struct nanosleep_args *)); +int minherit __P((struct thread *, struct minherit_args *)); +int rfork __P((struct thread *, struct rfork_args *)); +int openbsd_poll __P((struct thread *, struct openbsd_poll_args *)); +int issetugid __P((struct thread *, struct issetugid_args *)); +int lchown __P((struct thread *, struct lchown_args *)); +int getdents __P((struct thread *, struct getdents_args *)); +int lchmod __P((struct thread *, struct lchmod_args *)); +int lutimes __P((struct thread *, struct lutimes_args *)); +int nstat __P((struct thread *, struct nstat_args *)); +int nfstat __P((struct thread *, struct nfstat_args *)); +int nlstat __P((struct thread *, struct nlstat_args *)); +int fhstatfs __P((struct thread *, struct fhstatfs_args *)); +int fhopen __P((struct thread *, struct fhopen_args *)); +int fhstat __P((struct thread *, struct fhstat_args *)); +int modnext __P((struct thread *, struct modnext_args *)); +int modstat __P((struct thread *, struct modstat_args *)); +int modfnext __P((struct thread *, struct modfnext_args *)); +int modfind __P((struct thread *, struct modfind_args *)); +int kldload __P((struct thread *, struct kldload_args *)); +int kldunload __P((struct thread *, struct kldunload_args *)); +int kldfind __P((struct thread *, struct kldfind_args *)); +int kldnext __P((struct thread *, struct kldnext_args *)); +int kldstat __P((struct thread *, struct kldstat_args *)); +int kldfirstmod __P((struct thread *, struct kldfirstmod_args *)); +int getsid __P((struct thread *, struct getsid_args *)); +int setresuid __P((struct thread *, struct setresuid_args *)); +int setresgid __P((struct thread *, struct setresgid_args *)); +int aio_return __P((struct thread *, struct aio_return_args *)); +int aio_suspend __P((struct thread *, struct aio_suspend_args *)); +int aio_cancel __P((struct thread *, struct aio_cancel_args *)); +int aio_error __P((struct thread *, struct aio_error_args *)); +int aio_read __P((struct thread *, struct aio_read_args *)); +int aio_write __P((struct thread *, struct aio_write_args *)); +int lio_listio __P((struct thread *, struct lio_listio_args *)); +int yield __P((struct thread *, struct yield_args *)); +int mlockall __P((struct thread *, struct mlockall_args *)); +int munlockall __P((struct thread *, struct munlockall_args *)); +int __getcwd __P((struct thread *, struct __getcwd_args *)); +int sched_setparam __P((struct thread *, struct sched_setparam_args *)); +int sched_getparam __P((struct thread *, struct sched_getparam_args *)); +int sched_setscheduler __P((struct thread *, struct sched_setscheduler_args *)); +int sched_getscheduler __P((struct thread *, struct sched_getscheduler_args *)); +int sched_yield __P((struct thread *, struct sched_yield_args *)); +int sched_get_priority_max __P((struct thread *, struct sched_get_priority_max_args *)); +int sched_get_priority_min __P((struct thread *, struct sched_get_priority_min_args *)); +int sched_rr_get_interval __P((struct thread *, struct sched_rr_get_interval_args *)); +int utrace __P((struct thread *, struct utrace_args *)); +int sendfile __P((struct thread *, struct sendfile_args *)); +int kldsym __P((struct thread *, struct kldsym_args *)); +int jail __P((struct thread *, struct jail_args *)); +int sigprocmask __P((struct thread *, struct sigprocmask_args *)); +int sigsuspend __P((struct thread *, struct sigsuspend_args *)); +int sigaction __P((struct thread *, struct sigaction_args *)); +int sigpending __P((struct thread *, struct sigpending_args *)); +int sigreturn __P((struct thread *, struct sigreturn_args *)); +int __acl_get_file __P((struct thread *, struct __acl_get_file_args *)); +int __acl_set_file __P((struct thread *, struct __acl_set_file_args *)); +int __acl_get_fd __P((struct thread *, struct __acl_get_fd_args *)); +int __acl_set_fd __P((struct thread *, struct __acl_set_fd_args *)); +int __acl_delete_file __P((struct thread *, struct __acl_delete_file_args *)); +int __acl_delete_fd __P((struct thread *, struct __acl_delete_fd_args *)); +int __acl_aclcheck_file __P((struct thread *, struct __acl_aclcheck_file_args *)); +int __acl_aclcheck_fd __P((struct thread *, struct __acl_aclcheck_fd_args *)); +int extattrctl __P((struct thread *, struct extattrctl_args *)); +int extattr_set_file __P((struct thread *, struct extattr_set_file_args *)); +int extattr_get_file __P((struct thread *, struct extattr_get_file_args *)); +int extattr_delete_file __P((struct thread *, struct extattr_delete_file_args *)); +int aio_waitcomplete __P((struct thread *, struct aio_waitcomplete_args *)); +int getresuid __P((struct thread *, struct getresuid_args *)); +int getresgid __P((struct thread *, struct getresgid_args *)); +int kqueue __P((struct thread *, struct kqueue_args *)); +int kevent __P((struct thread *, struct kevent_args *)); +int __cap_get_proc __P((struct thread *, struct __cap_get_proc_args *)); +int __cap_set_proc __P((struct thread *, struct __cap_set_proc_args *)); +int __cap_get_fd __P((struct thread *, struct __cap_get_fd_args *)); +int __cap_get_file __P((struct thread *, struct __cap_get_file_args *)); +int __cap_set_fd __P((struct thread *, struct __cap_set_fd_args *)); +int __cap_set_file __P((struct thread *, struct __cap_set_file_args *)); +int lkmressys __P((struct thread *, struct nosys_args *)); +int extattr_set_fd __P((struct thread *, struct extattr_set_fd_args *)); +int extattr_get_fd __P((struct thread *, struct extattr_get_fd_args *)); +int extattr_delete_fd __P((struct thread *, struct extattr_delete_fd_args *)); +int __setugid __P((struct thread *, struct __setugid_args *)); #ifdef COMPAT_43 @@ -1443,43 +1444,43 @@ struct ogetdirentries_args { char count_l_[PADL_(u_int)]; u_int count; char count_r_[PADR_(u_int)]; char basep_l_[PADL_(long *)]; long * basep; char basep_r_[PADR_(long *)]; }; -int ocreat __P((struct proc *, struct ocreat_args *)); -int olseek __P((struct proc *, struct olseek_args *)); -int ostat __P((struct proc *, struct ostat_args *)); -int olstat __P((struct proc *, struct olstat_args *)); -int osigaction __P((struct proc *, struct osigaction_args *)); -int osigprocmask __P((struct proc *, struct osigprocmask_args *)); -int osigpending __P((struct proc *, struct osigpending_args *)); -int ofstat __P((struct proc *, struct ofstat_args *)); -int ogetkerninfo __P((struct proc *, struct getkerninfo_args *)); -int ogetpagesize __P((struct proc *, struct getpagesize_args *)); -int ommap __P((struct proc *, struct ommap_args *)); -int owait __P((struct proc *, struct owait_args *)); -int ogethostname __P((struct proc *, struct gethostname_args *)); -int osethostname __P((struct proc *, struct sethostname_args *)); -int oaccept __P((struct proc *, struct accept_args *)); -int osend __P((struct proc *, struct osend_args *)); -int orecv __P((struct proc *, struct orecv_args *)); -int osigreturn __P((struct proc *, struct osigreturn_args *)); -int osigvec __P((struct proc *, struct osigvec_args *)); -int osigblock __P((struct proc *, struct osigblock_args *)); -int osigsetmask __P((struct proc *, struct osigsetmask_args *)); -int osigsuspend __P((struct proc *, struct osigsuspend_args *)); -int osigstack __P((struct proc *, struct osigstack_args *)); -int orecvmsg __P((struct proc *, struct orecvmsg_args *)); -int osendmsg __P((struct proc *, struct osendmsg_args *)); -int orecvfrom __P((struct proc *, struct recvfrom_args *)); -int otruncate __P((struct proc *, struct otruncate_args *)); -int oftruncate __P((struct proc *, struct oftruncate_args *)); -int ogetpeername __P((struct proc *, struct ogetpeername_args *)); -int ogethostid __P((struct proc *, struct ogethostid_args *)); -int osethostid __P((struct proc *, struct osethostid_args *)); -int ogetrlimit __P((struct proc *, struct ogetrlimit_args *)); -int osetrlimit __P((struct proc *, struct osetrlimit_args *)); -int okillpg __P((struct proc *, struct okillpg_args *)); -int oquota __P((struct proc *, struct oquota_args *)); -int ogetsockname __P((struct proc *, struct getsockname_args *)); -int ogetdirentries __P((struct proc *, struct ogetdirentries_args *)); +int ocreat __P((struct thread *, struct ocreat_args *)); +int olseek __P((struct thread *, struct olseek_args *)); +int ostat __P((struct thread *, struct ostat_args *)); +int olstat __P((struct thread *, struct olstat_args *)); +int osigaction __P((struct thread *, struct osigaction_args *)); +int osigprocmask __P((struct thread *, struct osigprocmask_args *)); +int osigpending __P((struct thread *, struct osigpending_args *)); +int ofstat __P((struct thread *, struct ofstat_args *)); +int ogetkerninfo __P((struct thread *, struct getkerninfo_args *)); +int ogetpagesize __P((struct thread *, struct getpagesize_args *)); +int ommap __P((struct thread *, struct ommap_args *)); +int owait __P((struct thread *, struct owait_args *)); +int ogethostname __P((struct thread *, struct gethostname_args *)); +int osethostname __P((struct thread *, struct sethostname_args *)); +int oaccept __P((struct thread *, struct accept_args *)); +int osend __P((struct thread *, struct osend_args *)); +int orecv __P((struct thread *, struct orecv_args *)); +int osigreturn __P((struct thread *, struct osigreturn_args *)); +int osigvec __P((struct thread *, struct osigvec_args *)); +int osigblock __P((struct thread *, struct osigblock_args *)); +int osigsetmask __P((struct thread *, struct osigsetmask_args *)); +int osigsuspend __P((struct thread *, struct osigsuspend_args *)); +int osigstack __P((struct thread *, struct osigstack_args *)); +int orecvmsg __P((struct thread *, struct orecvmsg_args *)); +int osendmsg __P((struct thread *, struct osendmsg_args *)); +int orecvfrom __P((struct thread *, struct recvfrom_args *)); +int otruncate __P((struct thread *, struct otruncate_args *)); +int oftruncate __P((struct thread *, struct oftruncate_args *)); +int ogetpeername __P((struct thread *, struct ogetpeername_args *)); +int ogethostid __P((struct thread *, struct ogethostid_args *)); +int osethostid __P((struct thread *, struct osethostid_args *)); +int ogetrlimit __P((struct thread *, struct ogetrlimit_args *)); +int osetrlimit __P((struct thread *, struct osetrlimit_args *)); +int okillpg __P((struct thread *, struct okillpg_args *)); +int oquota __P((struct thread *, struct oquota_args *)); +int ogetsockname __P((struct thread *, struct getsockname_args *)); +int ogetdirentries __P((struct thread *, struct ogetdirentries_args *)); #endif /* COMPAT_43 */ diff --git a/sys/sys/systm.h b/sys/sys/systm.h index afc3e4b..e287a35 100644 --- a/sys/sys/systm.h +++ b/sys/sys/systm.h @@ -88,6 +88,8 @@ struct clockframe; struct malloc_type; struct mtx; struct proc; +struct kse; +struct thread; struct timeval; struct tty; struct ucred; @@ -101,7 +103,7 @@ int dumpstatus __P((vm_offset_t addr, long count)); int nullop __P((void)); int eopnotsupp __P((void)); int einval __P((void)); -int seltrue __P((dev_t dev, int which, struct proc *p)); +int seltrue __P((dev_t dev, int which, struct thread *td)); int ureadc __P((int, struct uio *)); void *hashinit __P((int count, struct malloc_type *type, u_long *hashmask)); void *phashinit __P((int count, struct malloc_type *type, u_long *nentries)); @@ -134,7 +136,7 @@ void bcopy __P((const void *from, void *to, size_t len)); void ovbcopy __P((const void *from, void *to, size_t len)); #ifdef __i386__ -extern void (*bzero) __P((void *buf, size_t len)); +extern void (*bzero) __P((volatile void *buf, size_t len)); #else void bzero __P((void *buf, size_t len)); #endif @@ -159,10 +161,10 @@ int susword __P((void *base, int word)); void realitexpire __P((void *)); void hardclock __P((struct clockframe *frame)); -void hardclock_process __P((struct proc *p, int user)); +void hardclock_process __P((struct thread *td, int user)); void softclock __P((void *)); void statclock __P((struct clockframe *frame)); -void statclock_process __P((struct proc *p, register_t pc, int user)); +void statclock_process __P((struct kse *ke, register_t pc, int user)); void startprofclock __P((struct proc *)); void stopprofclock __P((struct proc *)); @@ -172,7 +174,9 @@ void setstatclockrate __P((int hzrate)); #define PRISON_ROOT 1 int suser __P((struct proc *)); +int suser_td __P((struct thread *)); int suser_xxx __P((struct ucred *cred, struct proc *proc, int flag)); +int suser_xxx_td __P((struct ucred *cred, struct thread *thread, int flag)); int u_cansee __P((struct ucred *u1, struct ucred *u2)); char *getenv __P((const char *name)); diff --git a/sys/sys/tty.h b/sys/sys/tty.h index 82f79f3..70946bc 100644 --- a/sys/sys/tty.h +++ b/sys/sys/tty.h @@ -268,7 +268,7 @@ int ttylclose __P((struct tty *tp, int flag)); struct tty *ttymalloc __P((struct tty *tp)); int ttymodem __P((struct tty *tp, int flag)); int ttyopen __P((dev_t device, struct tty *tp)); -int ttypoll __P((dev_t dev, int events, struct proc *p)); +int ttypoll __P((dev_t dev, int events, struct thread *td)); int ttyread __P((dev_t dev, struct uio *uio, int flag)); void ttyregister __P((struct tty *tp)); int ttysleep __P((struct tty *tp, void *chan, int pri, char *wmesg, diff --git a/sys/sys/ucred.h b/sys/sys/ucred.h index 356cca2..1675bc0 100644 --- a/sys/sys/ucred.h +++ b/sys/sys/ucred.h @@ -80,7 +80,6 @@ struct xucred { #ifdef _KERNEL -struct proc; void change_egid __P((struct ucred *newcred, gid_t egid)); void change_euid __P((struct ucred *newcred, uid_t euid)); diff --git a/sys/sys/uio.h b/sys/sys/uio.h index fcf1570..48f6c97 100644 --- a/sys/sys/uio.h +++ b/sys/sys/uio.h @@ -65,7 +65,7 @@ struct uio { int uio_resid; enum uio_seg uio_segflg; enum uio_rw uio_rw; - struct proc *uio_procp; + struct thread *uio_td;; }; /* diff --git a/sys/sys/user.h b/sys/sys/user.h index 789b325..350707b 100644 --- a/sys/sys/user.h +++ b/sys/sys/user.h @@ -161,7 +161,10 @@ struct kinfo_proc { struct rusage ki_rusage; /* process rusage statistics */ long ki_sflag; /* PS_* flags */ struct priority ki_pri; /* process priority */ - long ki_spare[25]; /* spare constants */ + long ki_tdflags; /* XXXKSE kthread flag */ + struct pcb *ki_pcb; /* kernel virtual addr of pcb */ + void *ki_kstack; /* kernel virtual addr of stack */ + long ki_spare[22]; /* spare constants */ }; void fill_kinfo_proc __P((struct proc *, struct kinfo_proc *)); @@ -178,15 +181,15 @@ void fill_kinfo_proc __P((struct proc *, struct kinfo_proc *)); */ struct user { - struct pcb u_pcb; - struct sigacts u_sigacts; /* p_sigacts points here (use it!) */ - struct pstats u_stats; /* p_stats points here (use it!) */ + struct sigacts u_sigacts; /* *p_sigacts */ + struct pstats u_stats; /* *p_stats */ /* - * Remaining fields only for core dump and/or ptrace-- + * Remaining fields only for + * core dump and/or ptrace-- * not valid at other times! */ - struct kinfo_proc u_kproc; /* proc + eproc */ - struct md_coredump u_md; /* machine dependent glop */ + struct kinfo_proc u_kproc; /* eproc */ + struct md_coredump u_md; /* glop */ }; #endif diff --git a/sys/sys/vnode.h b/sys/sys/vnode.h index b4d7828..68029ac 100644 --- a/sys/sys/vnode.h +++ b/sys/sys/vnode.h @@ -135,7 +135,7 @@ struct vnode { short vpi_events; /* what they are looking for */ short vpi_revents; /* what has happened */ } v_pollinfo; - struct proc *v_vxproc; /* proc owning VXLOCK */ + struct thread *v_vxproc; /* thread owning VXLOCK */ #ifdef DEBUG_LOCKS const char *filename; /* Source file doing locking */ int line; /* Line number doing locking */ @@ -161,7 +161,7 @@ struct vnode { #define VSYSTEM 0x00004 /* vnode being used by kernel */ #define VISTTY 0x00008 /* vnode represents a tty */ #define VXLOCK 0x00100 /* vnode is locked to change underlying type */ -#define VXWANT 0x00200 /* process is waiting for vnode */ +#define VXWANT 0x00200 /* thread is waiting for vnode */ #define VBWAIT 0x00400 /* waiting for output to complete */ #define VNOSYNC 0x01000 /* unlinked, stop syncing */ /* open for business 0x01000 */ @@ -169,7 +169,7 @@ struct vnode { #define VCOPYONWRITE 0x04000 /* vnode is doing copy-on-write */ #define VAGE 0x08000 /* Insert vnode at head of free list */ #define VOLOCK 0x10000 /* vnode is locked waiting for an object */ -#define VOWANT 0x20000 /* a process is waiting for VOLOCK */ +#define VOWANT 0x20000 /* a thread is waiting for VOLOCK */ #define VDOOMED 0x40000 /* This vnode is being recycled */ #define VFREE 0x80000 /* This vnode is on the freelist */ /* open for business 0x100000 */ @@ -361,7 +361,7 @@ struct vnodeop_desc { int *vdesc_vp_offsets; /* list ended by VDESC_NO_OFFSET */ int vdesc_vpp_offset; /* return vpp location */ int vdesc_cred_offset; /* cred location, if any */ - int vdesc_proc_offset; /* proc location, if any */ + int vdesc_thread_offset; /* thread location, if any */ int vdesc_componentname_offset; /* if any */ /* * Finally, we've got a list of private data (about each operation) @@ -423,8 +423,8 @@ struct vop_generic_args { #ifdef DEBUG_VFS_LOCKS /* * Macros to aid in tracing VFS locking problems. Not totally - * reliable since if the process sleeps between changing the lock - * state and checking it with the assert, some other process could + * reliable since if the thread sleeps between changing the lock + * state and checking it with the assert, some other thread could * change the state. They are good enough for debugging a single * filesystem using a single-threaded test. I find that 'cvs co src' * is a pretty good test. @@ -454,7 +454,7 @@ do { \ int lockstate; \ \ if (_vp && IS_LOCKING_VFS(_vp)) { \ - lockstate = VOP_ISLOCKED(_vp, curproc); \ + lockstate = VOP_ISLOCKED(_vp, curthread); \ if (lockstate == LK_EXCLUSIVE) \ panic("%s: %p is locked but should not be", \ str, _vp); \ @@ -466,7 +466,7 @@ do { \ struct vnode *_vp = (vp); \ \ if (_vp && IS_LOCKING_VFS(_vp) && \ - VOP_ISLOCKED(_vp, curproc) != LK_EXCLUSIVE) \ + VOP_ISLOCKED(_vp, curthread) != LK_EXCLUSIVE) \ panic("%s: %p is not exclusive locked but should be", \ str, _vp); \ } while (0) @@ -476,8 +476,8 @@ do { \ struct vnode *_vp = (vp); \ \ if (_vp && IS_LOCKING_VFS(_vp) && \ - VOP_ISLOCKED(_vp, curproc) != LK_EXCLOTHER) \ - panic("%s: %p is not exclusive locked by another proc", \ + VOP_ISLOCKED(_vp, curthread) != LK_EXCLOTHER) \ + panic("%s: %p is not exclusive locked by another thread", \ str, _vp); \ } while (0) @@ -539,6 +539,7 @@ struct file; struct mount; struct nameidata; struct ostat; +struct thread; struct proc; struct stat; struct nstat; @@ -580,51 +581,52 @@ int vfinddev __P((dev_t dev, enum vtype type, struct vnode **vpp)); void vfs_add_vnodeops __P((const void *)); void vfs_rm_vnodeops __P((const void *)); int vflush __P((struct mount *mp, int rootrefs, int flags)); -int vget __P((struct vnode *vp, int lockflag, struct proc *p)); +int vget __P((struct vnode *vp, int lockflag, struct thread *td)); void vgone __P((struct vnode *vp)); -void vgonel __P((struct vnode *vp, struct proc *p)); +void vgonel __P((struct vnode *vp, struct thread *td)); void vhold __P((struct vnode *)); int vinvalbuf __P((struct vnode *vp, int save, struct ucred *cred, - struct proc *p, int slpflag, int slptimeo)); -int vtruncbuf __P((struct vnode *vp, struct ucred *cred, struct proc *p, + struct thread *td, int slpflag, int slptimeo)); +int vtruncbuf __P((struct vnode *vp, struct ucred *cred, struct thread *td, off_t length, int blksize)); void vprint __P((char *label, struct vnode *vp)); int vrecycle __P((struct vnode *vp, struct mtx *inter_lkp, - struct proc *p)); + struct thread *td)); int vn_close __P((struct vnode *vp, - int flags, struct ucred *cred, struct proc *p)); + int flags, struct ucred *cred, struct thread *td)); void vn_finished_write __P((struct mount *mp)); int vn_isdisk __P((struct vnode *vp, int *errp)); -int vn_lock __P((struct vnode *vp, int flags, struct proc *p)); +int vn_lock __P((struct vnode *vp, int flags, struct thread *td)); #ifdef DEBUG_LOCKS -int debug_vn_lock __P((struct vnode *vp, int flags, struct proc *p, +int debug_vn_lock __P((struct vnode *vp, int flags, struct thread *p, const char *filename, int line)); #define vn_lock(vp,flags,p) debug_vn_lock(vp,flags,p,__FILE__,__LINE__) #endif +int vn_mkdir __P((char *path, int mode, enum uio_seg segflg, struct thread *td)); int vn_open __P((struct nameidata *ndp, int *flagp, int cmode)); void vn_pollevent __P((struct vnode *vp, int events)); void vn_pollgone __P((struct vnode *vp)); -int vn_pollrecord __P((struct vnode *vp, struct proc *p, int events)); +int vn_pollrecord __P((struct vnode *vp, struct thread *p, int events)); int vn_rdwr __P((enum uio_rw rw, struct vnode *vp, caddr_t base, int len, off_t offset, enum uio_seg segflg, int ioflg, - struct ucred *cred, int *aresid, struct proc *p)); + struct ucred *cred, int *aresid, struct thread *td)); int vn_rdwr_inchunks __P((enum uio_rw rw, struct vnode *vp, caddr_t base, int len, off_t offset, enum uio_seg segflg, int ioflg, - struct ucred *cred, int *aresid, struct proc *p)); -int vn_stat __P((struct vnode *vp, struct stat *sb, struct proc *p)); + struct ucred *cred, int *aresid, struct thread *td)); +int vn_stat __P((struct vnode *vp, struct stat *sb, struct thread *td)); int vn_start_write __P((struct vnode *vp, struct mount **mpp, int flags)); dev_t vn_todev __P((struct vnode *vp)); int vn_write_suspend_wait __P((struct vnode *vp, struct mount *mp, int flags)); int vn_writechk __P((struct vnode *vp)); int vn_extattr_get __P((struct vnode *vp, int ioflg, int attrnamespace, - const char *attrname, int *buflen, char *buf, struct proc *p)); + const char *attrname, int *buflen, char *buf, struct thread *td)); int vn_extattr_set __P((struct vnode *vp, int ioflg, int attrnamespace, - const char *attrname, int buflen, char *buf, struct proc *p)); + const char *attrname, int buflen, char *buf, struct thread *td)); int vn_extattr_rm(struct vnode *vp, int ioflg, int attrnamespace, - const char *attrname, struct proc *p); + const char *attrname, struct thread *td); int vfs_cache_lookup __P((struct vop_lookup_args *ap)); -int vfs_object_create __P((struct vnode *vp, struct proc *p, +int vfs_object_create __P((struct vnode *vp, struct thread *td, struct ucred *cred)); void vfs_timestamp __P((struct timespec *)); void vfs_write_resume __P((struct mount *mp)); diff --git a/sys/tools/vnode_if.awk b/sys/tools/vnode_if.awk index 53236e5..32eabfe 100644 --- a/sys/tools/vnode_if.awk +++ b/sys/tools/vnode_if.awk @@ -322,8 +322,8 @@ line: while (<SRC>) { printf CFILE "\t%s,\n", &find_arg_with_type('struct vnode **'); # cred (if any) printf CFILE "\t%s,\n", &find_arg_with_type('struct ucred *'); - # proc (if any) - printf CFILE "\t%s,\n", &find_arg_with_type('struct proc *'); + # thread (if any) + printf CFILE "\t%s,\n", &find_arg_with_type('struct thread *'); # componentname printf CFILE "\t%s,\n", &find_arg_with_type('struct componentname *'); # transport layer information diff --git a/sys/ufs/ffs/ffs_balloc.c b/sys/ufs/ffs/ffs_balloc.c index cf57bc7..26747fc 100644 --- a/sys/ufs/ffs/ffs_balloc.c +++ b/sys/ufs/ffs/ffs_balloc.c @@ -72,7 +72,7 @@ ffs_balloc(struct vnode *a_vp, off_t a_startoffset, int a_size, int deallocated, osize, nsize, num, i, error; ufs_daddr_t *allocib, *blkp, *allocblk, allociblk[NIADDR + 1]; int unwindidx = -1; - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ vp = a_vp; ip = VTOI(vp); @@ -350,7 +350,7 @@ fail: * occurence. The error return from fsync is ignored as we already * have an error to return to the user. */ - (void) VOP_FSYNC(vp, cred, MNT_WAIT, p); + (void) VOP_FSYNC(vp, cred, MNT_WAIT, td); for (deallocated = 0, blkp = allociblk; blkp < allocblk; blkp++) { ffs_blkfree(ip, *blkp, fs->fs_bsize); deallocated += fs->fs_bsize; @@ -387,6 +387,6 @@ fail: ip->i_blocks -= btodb(deallocated); ip->i_flag |= IN_CHANGE | IN_UPDATE; } - (void) VOP_FSYNC(vp, cred, MNT_WAIT, p); + (void) VOP_FSYNC(vp, cred, MNT_WAIT, td); return (error); } diff --git a/sys/ufs/ffs/ffs_extern.h b/sys/ufs/ffs/ffs_extern.h index e7cdc17..49f0279 100644 --- a/sys/ufs/ffs/ffs_extern.h +++ b/sys/ufs/ffs/ffs_extern.h @@ -44,7 +44,7 @@ struct fs; struct inode; struct malloc_type; struct mount; -struct proc; +struct thread; struct sockaddr; struct statfs; struct ucred; @@ -64,16 +64,16 @@ ufs_daddr_t ffs_blkpref __P((struct inode *, ufs_daddr_t, int, ufs_daddr_t *)); void ffs_clrblock __P((struct fs *, u_char *, ufs_daddr_t)); void ffs_clusteracct __P((struct fs *, struct cg *, ufs_daddr_t, int)); int ffs_fhtovp __P((struct mount *, struct fid *, struct vnode **)); -int ffs_flushfiles __P((struct mount *, int, struct proc *)); +int ffs_flushfiles __P((struct mount *, int, struct thread *)); void ffs_fragacct __P((struct fs *, int, int32_t [], int)); int ffs_freefile __P((struct inode *, ino_t, int )); int ffs_isblock __P((struct fs *, u_char *, ufs_daddr_t)); int ffs_isfreeblock __P((struct fs *, unsigned char *, ufs_daddr_t)); -int ffs_mountfs __P((struct vnode *, struct mount *, struct proc *, +int ffs_mountfs __P((struct vnode *, struct mount *, struct thread *, struct malloc_type *)); int ffs_mountroot __P((void)); int ffs_mount __P((struct mount *, char *, caddr_t, struct nameidata *, - struct proc *)); + struct thread *)); int ffs_reallocblks __P((struct vop_reallocblks_args *)); int ffs_realloccg __P((struct inode *, ufs_daddr_t, ufs_daddr_t, int, int, struct ucred *, struct buf **)); @@ -83,10 +83,10 @@ void ffs_snapremove __P((struct vnode *vp)); int ffs_snapshot __P((struct mount *mp, char *snapfile)); void ffs_snapshot_mount __P((struct mount *mp)); void ffs_snapshot_unmount __P((struct mount *mp)); -int ffs_statfs __P((struct mount *, struct statfs *, struct proc *)); -int ffs_sync __P((struct mount *, int, struct ucred *, struct proc *)); -int ffs_truncate __P((struct vnode *, off_t, int, struct ucred *, struct proc *)); -int ffs_unmount __P((struct mount *, int, struct proc *)); +int ffs_statfs __P((struct mount *, struct statfs *, struct thread *)); +int ffs_sync __P((struct mount *, int, struct ucred *, struct thread *)); +int ffs_truncate __P((struct vnode *, off_t, int, struct ucred *, struct thread *)); +int ffs_unmount __P((struct mount *, int, struct thread *)); int ffs_update __P((struct vnode *, int)); int ffs_valloc __P((struct vnode *, int, struct ucred *, struct vnode **)); @@ -104,8 +104,8 @@ extern vop_t **ffs_fifoop_p; void softdep_initialize __P((void)); int softdep_mount __P((struct vnode *, struct mount *, struct fs *, struct ucred *)); -int softdep_flushworklist __P((struct mount *, int *, struct proc *)); -int softdep_flushfiles __P((struct mount *, int, struct proc *)); +int softdep_flushworklist __P((struct mount *, int *, struct thread *)); +int softdep_flushfiles __P((struct mount *, int, struct thread *)); void softdep_update_inodeblock __P((struct inode *, struct buf *, int)); void softdep_load_inodeblock __P((struct inode *)); void softdep_freefile __P((struct vnode *, ino_t, int)); diff --git a/sys/ufs/ffs/ffs_inode.c b/sys/ufs/ffs/ffs_inode.c index 3af19b5..d0cd063 100644 --- a/sys/ufs/ffs/ffs_inode.c +++ b/sys/ufs/ffs/ffs_inode.c @@ -130,12 +130,12 @@ ffs_update(vp, waitfor) * disk blocks. */ int -ffs_truncate(vp, length, flags, cred, p) +ffs_truncate(vp, length, flags, cred, td) struct vnode *vp; off_t length; int flags; struct ucred *cred; - struct proc *p; + struct thread *td; { register struct vnode *ovp = vp; ufs_daddr_t lastblock; @@ -191,7 +191,7 @@ ffs_truncate(vp, length, flags, cred, p) * so that it will have no data structures left. */ if ((error = VOP_FSYNC(ovp, cred, MNT_WAIT, - p)) != 0) + td)) != 0) return (error); if (oip->i_flag & IN_SPACECOUNTED) fs->fs_pendingblocks -= oip->i_blocks; @@ -200,7 +200,7 @@ ffs_truncate(vp, length, flags, cred, p) (void) chkdq(oip, -oip->i_blocks, NOCRED, 0); #endif softdep_setup_freeblocks(oip, length); - vinvalbuf(ovp, 0, cred, p, 0, 0); + vinvalbuf(ovp, 0, cred, td, 0, 0); oip->i_flag |= IN_CHANGE | IN_UPDATE; return (ffs_update(ovp, 0)); } @@ -302,7 +302,7 @@ ffs_truncate(vp, length, flags, cred, p) bcopy((caddr_t)oldblks, (caddr_t)&oip->i_db[0], sizeof oldblks); oip->i_size = osize; - error = vtruncbuf(ovp, cred, p, length, fs->fs_bsize); + error = vtruncbuf(ovp, cred, td, length, fs->fs_bsize); if (error && (allerror == 0)) allerror = error; diff --git a/sys/ufs/ffs/ffs_snapshot.c b/sys/ufs/ffs/ffs_snapshot.c index 1cbfe28..8085103 100644 --- a/sys/ufs/ffs/ffs_snapshot.c +++ b/sys/ufs/ffs/ffs_snapshot.c @@ -105,7 +105,7 @@ ffs_snapshot(mp, snapfile) void *space; struct fs *copy_fs = NULL, *fs = VFSTOUFS(mp)->um_fs; struct snaphead *snaphead; - struct proc *p = CURPROC; + struct thread *td = curthread; struct inode *ip, *xp; struct buf *bp, *nbp, *ibp, *sbp = NULL; struct nameidata nd; @@ -129,7 +129,7 @@ ffs_snapshot(mp, snapfile) * Create the snapshot file. */ restart: - NDINIT(&nd, CREATE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, snapfile, p); + NDINIT(&nd, CREATE, LOCKPARENT | LOCKLEAF, UIO_USERSPACE, snapfile, td); if ((error = namei(&nd)) != 0) return (error); if (nd.ni_vp != NULL) { @@ -162,7 +162,7 @@ restart: return (error); goto restart; } - VOP_LEASE(nd.ni_dvp, p, KERNCRED, LEASE_WRITE); + VOP_LEASE(nd.ni_dvp, td, KERNCRED, LEASE_WRITE); error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vat); vput(nd.ni_dvp); if (error) { @@ -199,7 +199,7 @@ restart: */ for (blkno = NDADDR; blkno < numblks; blkno += NINDIR(fs)) { error = UFS_BALLOC(vp, lblktosize(fs, (off_t)blkno), - fs->fs_bsize, p->p_ucred, B_METAONLY, &ibp); + fs->fs_bsize, td->td_proc->p_ucred, B_METAONLY, &ibp); if (error) goto out; bdwrite(ibp); @@ -260,7 +260,7 @@ restart: /* * Ensure that the snapshot is completely on disk. */ - if ((error = VOP_FSYNC(vp, KERNCRED, MNT_WAIT, p)) != 0) + if ((error = VOP_FSYNC(vp, KERNCRED, MNT_WAIT, td)) != 0) goto out; /* * All allocations are done, so we can now snapshot the system. @@ -464,12 +464,12 @@ out1: out: mp->mnt_flag = flag; if (error) - (void) UFS_TRUNCATE(vp, (off_t)0, 0, NOCRED, p); - (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, p); + (void) UFS_TRUNCATE(vp, (off_t)0, 0, NOCRED, td); + (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, td); if (error) vput(vp); else - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vn_finished_write(wrtmp); return (error); } @@ -840,7 +840,7 @@ ffs_snapblkfree(freeip, bno, size) { struct buf *ibp, *cbp, *savedcbp = 0; struct fs *fs = freeip->i_fs; - struct proc *p = CURPROC; + struct thread *td = curthread; struct inode *ip; struct vnode *vp; ufs_daddr_t lbn, blkno; @@ -857,12 +857,12 @@ ffs_snapblkfree(freeip, bno, size) if (lbn < NDADDR) { blkno = ip->i_db[lbn]; } else { - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - p->p_flag |= P_COWINPROGRESS; + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + td->td_proc->p_flag |= P_COWINPROGRESS; error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn), fs->fs_bsize, KERNCRED, B_METAONLY, &ibp); - p->p_flag &= ~P_COWINPROGRESS; - VOP_UNLOCK(vp, 0, p); + td->td_proc->p_flag &= ~P_COWINPROGRESS; + VOP_UNLOCK(vp, 0, td); if (error) break; indiroff = (lbn - NDADDR) % NINDIR(fs); @@ -888,7 +888,7 @@ ffs_snapblkfree(freeip, bno, size) case BLK_SNAP: if (claimedblk) panic("snapblkfree: inconsistent block type"); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (lbn < NDADDR) { ip->i_db[lbn] = BLK_NOCOPY; ip->i_flag |= IN_CHANGE | IN_UPDATE; @@ -897,7 +897,7 @@ ffs_snapblkfree(freeip, bno, size) BLK_NOCOPY; bdwrite(ibp); } - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); continue; /* * A block that we map is being freed. If it has not been @@ -921,7 +921,7 @@ ffs_snapblkfree(freeip, bno, size) "Grabonremove: snapino", ip->i_number, lbn, freeip->i_number); #endif - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (lbn < NDADDR) { ip->i_db[lbn] = bno; } else { @@ -930,7 +930,7 @@ ffs_snapblkfree(freeip, bno, size) } ip->i_blocks += btodb(size); ip->i_flag |= IN_CHANGE | IN_UPDATE; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); return (1); } if (lbn >= NDADDR) @@ -940,13 +940,13 @@ ffs_snapblkfree(freeip, bno, size) * allocation will never require any additional allocations for * the snapshot inode. */ - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - p->p_flag |= P_COWINPROGRESS; + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + td->td_proc->p_flag |= P_COWINPROGRESS; error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn), fs->fs_bsize, KERNCRED, 0, &cbp); - p->p_flag &= ~P_COWINPROGRESS; + td->td_proc->p_flag &= ~P_COWINPROGRESS; if (error) { - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); break; } #ifdef DEBUG @@ -966,8 +966,8 @@ ffs_snapblkfree(freeip, bno, size) bcopy(savedcbp->b_data, cbp->b_data, fs->fs_bsize); bawrite(cbp); if (dopersistence && ip->i_effnlink > 0) - (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, p); - VOP_UNLOCK(vp, 0, p); + (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, td); + VOP_UNLOCK(vp, 0, td); continue; } /* @@ -977,11 +977,11 @@ ffs_snapblkfree(freeip, bno, size) bzero(cbp->b_data, fs->fs_bsize); bawrite(cbp); if (dopersistence && ip->i_effnlink > 0) - (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, p); - VOP_UNLOCK(vp, 0, p); + (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, td); + VOP_UNLOCK(vp, 0, td); break; } - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); savedcbp = cbp; } /* @@ -993,9 +993,9 @@ ffs_snapblkfree(freeip, bno, size) vp = savedcbp->b_vp; bawrite(savedcbp); if (dopersistence && VTOI(vp)->i_effnlink > 0) { - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, p); - VOP_UNLOCK(vp, 0, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, td); + VOP_UNLOCK(vp, 0, td); } } /* @@ -1016,7 +1016,7 @@ ffs_snapshot_mount(mp) { struct ufsmount *ump = VFSTOUFS(mp); struct fs *fs = ump->um_fs; - struct proc *p = CURPROC; + struct thread *td = curthread; struct snaphead *snaphead; struct vnode *vp; struct inode *ip; @@ -1052,7 +1052,7 @@ ffs_snapshot_mount(mp) vp->v_flag |= VSYSTEM; ump->um_devvp->v_rdev->si_copyonwrite = ffs_copyonwrite; ump->um_devvp->v_flag |= VCOPYONWRITE; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); } } @@ -1087,7 +1087,7 @@ ffs_copyonwrite(devvp, bp) struct buf *bp; { struct buf *ibp, *cbp, *savedcbp = 0; - struct proc *p = CURPROC; + struct thread *td = curthread; struct fs *fs; struct inode *ip; struct vnode *vp; @@ -1096,7 +1096,7 @@ ffs_copyonwrite(devvp, bp) fs = TAILQ_FIRST(&devvp->v_rdev->si_snapshots)->i_fs; lbn = fragstoblks(fs, dbtofsb(fs, bp->b_blkno)); - if (p->p_flag & P_COWINPROGRESS) + if (td->td_proc->p_flag & P_COWINPROGRESS) panic("ffs_copyonwrite: recursive call"); TAILQ_FOREACH(ip, &devvp->v_rdev->si_snapshots, i_nextsnap) { vp = ITOV(ip); @@ -1117,19 +1117,19 @@ ffs_copyonwrite(devvp, bp) * sleep briefly, and try again. */ retry: - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (lbn < NDADDR) { blkno = ip->i_db[lbn]; } else { - p->p_flag |= P_COWINPROGRESS; + td->td_proc->p_flag |= P_COWINPROGRESS; error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn), fs->fs_bsize, KERNCRED, B_METAONLY | B_NOWAIT, &ibp); - p->p_flag &= ~P_COWINPROGRESS; + td->td_proc->p_flag &= ~P_COWINPROGRESS; if (error) { - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (error != EWOULDBLOCK) break; - tsleep(vp, p->p_pri.pri_user, "nap", 1); + tsleep(vp, td->td_ksegrp->kg_pri.pri_user, "nap", 1); goto retry; } indiroff = (lbn - NDADDR) % NINDIR(fs); @@ -1141,7 +1141,7 @@ retry: panic("ffs_copyonwrite: bad copy block"); #endif if (blkno != 0) { - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); continue; } /* @@ -1149,15 +1149,15 @@ retry: * allocation will never require any additional allocations for * the snapshot inode. */ - p->p_flag |= P_COWINPROGRESS; + td->td_proc->p_flag |= P_COWINPROGRESS; error = UFS_BALLOC(vp, lblktosize(fs, (off_t)lbn), fs->fs_bsize, KERNCRED, B_NOWAIT, &cbp); - p->p_flag &= ~P_COWINPROGRESS; + td->td_proc->p_flag &= ~P_COWINPROGRESS; if (error) { - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (error != EWOULDBLOCK) break; - tsleep(vp, p->p_pri.pri_user, "nap", 1); + tsleep(vp, td->td_ksegrp->kg_pri.pri_user, "nap", 1); goto retry; } #ifdef DEBUG @@ -1183,8 +1183,8 @@ retry: bcopy(savedcbp->b_data, cbp->b_data, fs->fs_bsize); bawrite(cbp); if (dopersistence && ip->i_effnlink > 0) - (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, p); - VOP_UNLOCK(vp, 0, p); + (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, td); + VOP_UNLOCK(vp, 0, td); continue; } /* @@ -1194,12 +1194,12 @@ retry: bzero(cbp->b_data, fs->fs_bsize); bawrite(cbp); if (dopersistence && ip->i_effnlink > 0) - (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, p); - VOP_UNLOCK(vp, 0, p); + (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, td); + VOP_UNLOCK(vp, 0, td); break; } savedcbp = cbp; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); } /* * Note that we need to synchronously write snapshots that @@ -1210,9 +1210,9 @@ retry: vp = savedcbp->b_vp; bawrite(savedcbp); if (dopersistence && VTOI(vp)->i_effnlink > 0) { - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, p); - VOP_UNLOCK(vp, 0, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + (void) VOP_FSYNC(vp, KERNCRED, MNT_WAIT, td); + VOP_UNLOCK(vp, 0, td); } } return (error); @@ -1229,7 +1229,7 @@ readblock(bp, lbn) { struct uio auio; struct iovec aiov; - struct proc *p = CURPROC; + struct thread *td = curthread; struct inode *ip = VTOI(bp->b_vp); aiov.iov_base = bp->b_data; @@ -1240,6 +1240,6 @@ readblock(bp, lbn) auio.uio_resid = bp->b_bcount; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = p; + auio.uio_td = td; return (physio(ip->i_devvp->v_rdev, &auio, 0)); } diff --git a/sys/ufs/ffs/ffs_softdep.c b/sys/ufs/ffs/ffs_softdep.c index 86f9111..a4a35bc 100644 --- a/sys/ufs/ffs/ffs_softdep.c +++ b/sys/ufs/ffs/ffs_softdep.c @@ -149,8 +149,8 @@ static struct malloc_type *memtype[] = { static void softdep_error __P((char *, int)); static void drain_output __P((struct vnode *, int)); static int getdirtybuf __P((struct buf **, int)); -static void clear_remove __P((struct proc *)); -static void clear_inodedeps __P((struct proc *)); +static void clear_remove __P((struct thread *)); +static void clear_inodedeps __P((struct thread *)); static int flush_pagedep_deps __P((struct vnode *, struct mount *, struct diraddhd *)); static int flush_inodedep_deps __P((struct fs *, ino_t)); @@ -239,10 +239,11 @@ static struct lockit { #define FREE_LOCK_INTERLOCKED(lk) #else /* DEBUG */ +#define NOHOLDER ((struct thread *)-1) static struct lockit { int lkt_spl; - pid_t lkt_held; -} lk = { 0, -1 }; + struct thread * lkt_held; +} lk = { 0, NOHOLDER }; static int lockcnt; static void acquire_lock __P((struct lockit *)); @@ -259,18 +260,18 @@ static void acquire_lock(lk) struct lockit *lk; { - pid_t holder; + struct thread *holder; - if (lk->lkt_held != -1) { + if (lk->lkt_held != NOHOLDER) { holder = lk->lkt_held; FREE_LOCK(lk); - if (holder == CURPROC->p_pid) + if (holder == curthread) panic("softdep_lock: locking against myself"); else - panic("softdep_lock: lock held by %d", holder); + panic("softdep_lock: lock held by %p", holder); } lk->lkt_spl = splbio(); - lk->lkt_held = CURPROC->p_pid; + lk->lkt_held = curthread; lockcnt++; } @@ -279,9 +280,9 @@ free_lock(lk) struct lockit *lk; { - if (lk->lkt_held == -1) + if (lk->lkt_held == NOHOLDER) panic("softdep_unlock: lock not held"); - lk->lkt_held = -1; + lk->lkt_held = NOHOLDER; splx(lk->lkt_spl); } @@ -289,18 +290,18 @@ static void acquire_lock_interlocked(lk) struct lockit *lk; { - pid_t holder; + struct thread *holder; - if (lk->lkt_held != -1) { + if (lk->lkt_held != NOHOLDER) { holder = lk->lkt_held; FREE_LOCK(lk); - if (holder == CURPROC->p_pid) + if (holder == curthread) panic("softdep_lock_interlocked: locking against self"); else - panic("softdep_lock_interlocked: lock held by %d", + panic("softdep_lock_interlocked: lock held by %p", holder); } - lk->lkt_held = CURPROC->p_pid; + lk->lkt_held = curthread; lockcnt++; } @@ -309,9 +310,9 @@ free_lock_interlocked(lk) struct lockit *lk; { - if (lk->lkt_held == -1) + if (lk->lkt_held == NOHOLDER) panic("softdep_unlock_interlocked: lock not held"); - lk->lkt_held = -1; + lk->lkt_held = NOHOLDER; } #endif /* DEBUG */ @@ -320,7 +321,7 @@ free_lock_interlocked(lk) */ struct sema { int value; - pid_t holder; + struct thread *holder; char *name; int prio; int timo; @@ -336,7 +337,7 @@ sema_init(semap, name, prio, timo) int prio, timo; { - semap->holder = -1; + semap->holder = NOHOLDER; semap->value = 0; semap->name = name; semap->prio = prio; @@ -359,7 +360,7 @@ sema_get(semap, interlock) } return (0); } - semap->holder = CURPROC->p_pid; + semap->holder = curthread; if (interlock != NULL) FREE_LOCK(interlock); return (1); @@ -370,8 +371,8 @@ sema_release(semap) struct sema *semap; { - if (semap->value <= 0 || semap->holder != CURPROC->p_pid) { - if (lk.lkt_held != -1) + if (semap->value <= 0 || semap->holder != curthread) { + if (lk.lkt_held != NOHOLDER) FREE_LOCK(&lk); panic("sema_release: not held"); } @@ -379,7 +380,7 @@ sema_release(semap) semap->value = 0; wakeup(semap); } - semap->holder = -1; + semap->holder = NOHOLDER; } /* @@ -412,7 +413,7 @@ worklist_insert(head, item) struct worklist *item; { - if (lk.lkt_held == -1) + if (lk.lkt_held == NOHOLDER) panic("worklist_insert: lock not held"); if (item->wk_state & ONWORKLIST) { FREE_LOCK(&lk); @@ -427,7 +428,7 @@ worklist_remove(item) struct worklist *item; { - if (lk.lkt_held == -1) + if (lk.lkt_held == NOHOLDER) panic("worklist_remove: lock not held"); if ((item->wk_state & ONWORKLIST) == 0) { FREE_LOCK(&lk); @@ -444,12 +445,12 @@ workitem_free(item, type) { if (item->wk_state & ONWORKLIST) { - if (lk.lkt_held != -1) + if (lk.lkt_held != NOHOLDER) FREE_LOCK(&lk); panic("workitem_free: still on list"); } if (item->wk_type != type) { - if (lk.lkt_held != -1) + if (lk.lkt_held != NOHOLDER) FREE_LOCK(&lk); panic("workitem_free: type mismatch"); } @@ -469,7 +470,7 @@ static int tickdelay = 2; /* number of ticks to pause during slowdown */ static int proc_waiting; /* tracks whether we have a timeout posted */ static int *stat_countp; /* statistic to count in proc_waiting timeout */ static struct callout_handle handle; /* handle on posted proc_waiting timeout */ -static struct proc *filesys_syncer; /* proc of filesystem syncer process */ +static struct thread *filesys_syncer; /* proc of filesystem syncer process */ static int req_clear_inodedeps; /* syncer process flush some inodedeps */ #define FLUSH_INODES 1 static int req_clear_remove; /* syncer process flush some freeblks */ @@ -518,7 +519,7 @@ add_to_worklist(wk) static struct worklist *worklist_tail; if (wk->wk_state & ONWORKLIST) { - if (lk.lkt_held != -1) + if (lk.lkt_held != NOHOLDER) FREE_LOCK(&lk); panic("add_to_worklist: already on list"); } @@ -544,7 +545,7 @@ int softdep_process_worklist(matchmnt) struct mount *matchmnt; { - struct proc *p = CURPROC; + struct thread *td = curthread; int matchcnt, loopcount; long starttime; @@ -552,7 +553,7 @@ softdep_process_worklist(matchmnt) * Record the process identifier of our caller so that we can give * this process preferential treatment in request_cleanup below. */ - filesys_syncer = p; + filesys_syncer = td; matchcnt = 0; /* @@ -571,12 +572,12 @@ softdep_process_worklist(matchmnt) * If requested, try removing inode or removal dependencies. */ if (req_clear_inodedeps) { - clear_inodedeps(p); + clear_inodedeps(td); req_clear_inodedeps -= 1; wakeup_one(&proc_waiting); } if (req_clear_remove) { - clear_remove(p); + clear_remove(td); req_clear_remove -= 1; wakeup_one(&proc_waiting); } @@ -598,12 +599,12 @@ softdep_process_worklist(matchmnt) * If requested, try removing inode or removal dependencies. */ if (req_clear_inodedeps) { - clear_inodedeps(p); + clear_inodedeps(td); req_clear_inodedeps -= 1; wakeup_one(&proc_waiting); } if (req_clear_remove) { - clear_remove(p); + clear_remove(td); req_clear_remove -= 1; wakeup_one(&proc_waiting); } @@ -658,7 +659,7 @@ process_worklist_item(matchmnt, flags) dirrem = WK_DIRREM(wk); vp = ufs_ihashlookup(VFSTOUFS(dirrem->dm_mnt)->um_dev, dirrem->dm_oldinum); - if (vp == NULL || !VOP_ISLOCKED(vp, CURPROC)) + if (vp == NULL || !VOP_ISLOCKED(vp, curthread)) break; } if (wk == 0) { @@ -751,10 +752,10 @@ softdep_move_dependencies(oldbp, newbp) * Purge the work list of all items associated with a particular mount point. */ int -softdep_flushworklist(oldmnt, countp, p) +softdep_flushworklist(oldmnt, countp, td) struct mount *oldmnt; int *countp; - struct proc *p; + struct thread *td; { struct vnode *devvp; int count, error = 0; @@ -778,9 +779,9 @@ softdep_flushworklist(oldmnt, countp, p) devvp = VFSTOUFS(oldmnt)->um_devvp; while ((count = softdep_process_worklist(oldmnt)) > 0) { *countp += count; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_FSYNC(devvp, p->p_ucred, MNT_WAIT, p); - VOP_UNLOCK(devvp, 0, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_FSYNC(devvp, td->td_proc->p_ucred, MNT_WAIT, td); + VOP_UNLOCK(devvp, 0, td); if (error) break; } @@ -794,10 +795,10 @@ softdep_flushworklist(oldmnt, countp, p) * Flush all vnodes and worklist items associated with a specified mount point. */ int -softdep_flushfiles(oldmnt, flags, p) +softdep_flushfiles(oldmnt, flags, td) struct mount *oldmnt; int flags; - struct proc *p; + struct thread *td; { int error, count, loopcnt; @@ -812,9 +813,9 @@ softdep_flushfiles(oldmnt, flags, p) * Do another flush in case any vnodes were brought in * as part of the cleanup operations. */ - if ((error = ffs_flushfiles(oldmnt, flags, p)) != 0) + if ((error = ffs_flushfiles(oldmnt, flags, td)) != 0) break; - if ((error = softdep_flushworklist(oldmnt, &count, p)) != 0 || + if ((error = softdep_flushworklist(oldmnt, &count, td)) != 0 || count == 0) break; } @@ -885,7 +886,7 @@ pagedep_lookup(ip, lbn, flags, pagedeppp) int i; #ifdef DEBUG - if (lk.lkt_held == -1) + if (lk.lkt_held == NOHOLDER) panic("pagedep_lookup: lock not held"); #endif mp = ITOV(ip)->v_mount; @@ -953,7 +954,7 @@ inodedep_lookup(fs, inum, flags, inodedeppp) int firsttry; #ifdef DEBUG - if (lk.lkt_held == -1) + if (lk.lkt_held == NOHOLDER) panic("inodedep_lookup: lock not held"); #endif firsttry = 1; @@ -1226,7 +1227,7 @@ bmsafemap_lookup(bp) struct worklist *wk; #ifdef DEBUG - if (lk.lkt_held == -1) + if (lk.lkt_held == NOHOLDER) panic("bmsafemap_lookup: lock not held"); #endif LIST_FOREACH(wk, &bp->b_dep, wk_list) @@ -1398,7 +1399,7 @@ allocdirect_merge(adphead, newadp, oldadp) struct newdirblk *newdirblk; #ifdef DEBUG - if (lk.lkt_held == -1) + if (lk.lkt_held == NOHOLDER) panic("allocdirect_merge: lock not held"); #endif if (newadp->ad_oldblkno != oldadp->ad_newblkno || @@ -1986,7 +1987,7 @@ free_allocdirect(adphead, adp, delay) struct worklist *wk; #ifdef DEBUG - if (lk.lkt_held == -1) + if (lk.lkt_held == NOHOLDER) panic("free_allocdirect: lock not held"); #endif if ((adp->ad_state & DEPCOMPLETE) == 0) @@ -2028,7 +2029,7 @@ free_newdirblk(newdirblk) int i; #ifdef DEBUG - if (lk.lkt_held == -1) + if (lk.lkt_held == NOHOLDER) panic("free_newdirblk: lock not held"); #endif /* @@ -2351,7 +2352,7 @@ free_allocindir(aip, inodedep) struct freefrag *freefrag; #ifdef DEBUG - if (lk.lkt_held == -1) + if (lk.lkt_held == NOHOLDER) panic("free_allocindir: lock not held"); #endif if ((aip->ai_state & DEPCOMPLETE) == 0) @@ -2609,7 +2610,7 @@ free_diradd(dap) struct mkdir *mkdir, *nextmd; #ifdef DEBUG - if (lk.lkt_held == -1) + if (lk.lkt_held == NOHOLDER) panic("free_diradd: lock not held"); #endif WORKLIST_REMOVE(&dap->da_list); @@ -2989,7 +2990,7 @@ static void handle_workitem_remove(dirrem) struct dirrem *dirrem; { - struct proc *p = CURPROC; /* XXX */ + struct thread *td = curthread; struct inodedep *inodedep; struct vnode *vp; struct inode *ip; @@ -3038,7 +3039,7 @@ handle_workitem_remove(dirrem) } inodedep->id_nlinkdelta = ip->i_nlink - ip->i_effnlink; FREE_LOCK(&lk); - if ((error = UFS_TRUNCATE(vp, (off_t)0, 0, p->p_ucred, p)) != 0) + if ((error = UFS_TRUNCATE(vp, (off_t)0, 0, td->td_proc->p_ucred, td)) != 0) softdep_error("handle_workitem_remove: truncate", error); /* * Rename a directory to a new parent. Since, we are both deleting @@ -3422,9 +3423,10 @@ softdep_disk_write_complete(bp) struct bmsafemap *bmsafemap; #ifdef DEBUG - if (lk.lkt_held != -1) +#define SPECIAL_FLAG NOHOLDER-1 + if (lk.lkt_held != NOHOLDER) panic("softdep_disk_write_complete: lock is held"); - lk.lkt_held = -2; + lk.lkt_held = SPECIAL_FLAG; #endif LIST_INIT(&reattach); while ((wk = LIST_FIRST(&bp->b_dep)) != NULL) { @@ -3490,7 +3492,7 @@ softdep_disk_write_complete(bp) case D_INDIRDEP: indirdep = WK_INDIRDEP(wk); if (indirdep->ir_state & GOINGAWAY) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("disk_write_complete: indirdep gone"); } bcopy(indirdep->ir_saveddata, bp->b_data, bp->b_bcount); @@ -3501,7 +3503,7 @@ softdep_disk_write_complete(bp) while ((aip = LIST_FIRST(&indirdep->ir_donehd)) != 0) { handle_allocindir_partdone(aip); if (aip == LIST_FIRST(&indirdep->ir_donehd)) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("disk_write_complete: not gone"); } } @@ -3512,7 +3514,7 @@ softdep_disk_write_complete(bp) continue; default: - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_disk_write_complete: Unknown type %s", TYPENAME(wk->wk_type)); /* NOTREACHED */ @@ -3526,9 +3528,9 @@ softdep_disk_write_complete(bp) WORKLIST_INSERT(&bp->b_dep, wk); } #ifdef DEBUG - if (lk.lkt_held != -2) + if (lk.lkt_held != SPECIAL_FLAG) panic("softdep_disk_write_complete: lock lost"); - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; #endif } @@ -3548,7 +3550,7 @@ handle_allocdirect_partdone(adp) if ((adp->ad_state & ALLCOMPLETE) != ALLCOMPLETE) return; if (adp->ad_buf != NULL) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_allocdirect_partdone: dangling dep"); } /* @@ -3586,7 +3588,7 @@ handle_allocdirect_partdone(adp) if (listadp == adp) break; if (listadp == NULL) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_allocdirect_partdone: lost dep"); } #endif /* DEBUG */ @@ -3622,7 +3624,7 @@ handle_allocindir_partdone(aip) if ((aip->ai_state & ALLCOMPLETE) != ALLCOMPLETE) return; if (aip->ai_buf != NULL) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_allocindir_partdone: dangling dependency"); } indirdep = aip->ai_indirdep; @@ -3656,7 +3658,7 @@ handle_written_inodeblock(inodedep, bp) int hadchanges; if ((inodedep->id_state & IOSTARTED) == 0) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_written_inodeblock: not started"); } inodedep->id_state &= ~IOSTARTED; @@ -3687,12 +3689,12 @@ handle_written_inodeblock(inodedep, bp) for (adp = TAILQ_FIRST(&inodedep->id_inoupdt); adp; adp = nextadp) { nextadp = TAILQ_NEXT(adp, ad_next); if (adp->ad_state & ATTACHED) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_written_inodeblock: new entry"); } if (adp->ad_lbn < NDADDR) { if (dp->di_db[adp->ad_lbn] != adp->ad_oldblkno) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("%s: %s #%ld mismatch %d != %d", "handle_written_inodeblock", "direct pointer", adp->ad_lbn, @@ -3701,7 +3703,7 @@ handle_written_inodeblock(inodedep, bp) dp->di_db[adp->ad_lbn] = adp->ad_newblkno; } else { if (dp->di_ib[adp->ad_lbn - NDADDR] != 0) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("%s: %s #%ld allocated as %d", "handle_written_inodeblock", "indirect pointer", adp->ad_lbn - NDADDR, @@ -3719,7 +3721,7 @@ handle_written_inodeblock(inodedep, bp) * Reset the file size to its most up-to-date value. */ if (inodedep->id_savedsize == -1) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_written_inodeblock: bad size"); } if (dp->di_size != inodedep->id_savedsize) { @@ -3759,7 +3761,7 @@ handle_written_inodeblock(inodedep, bp) * have been freed. */ if (filefree != NULL) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_written_inodeblock: filefree"); } filefree = wk; @@ -3784,7 +3786,7 @@ handle_written_inodeblock(inodedep, bp) continue; default: - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_written_inodeblock: Unknown type %s", TYPENAME(wk->wk_type)); /* NOTREACHED */ @@ -3792,7 +3794,7 @@ handle_written_inodeblock(inodedep, bp) } if (filefree != NULL) { if (free_inodedep(inodedep) == 0) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_written_inodeblock: live inodedep"); } add_to_worklist(filefree); @@ -3842,7 +3844,7 @@ handle_written_mkdir(mkdir, type) struct pagedep *pagedep; if (mkdir->md_state != type) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_written_mkdir: bad type"); } dap = mkdir->md_diradd; @@ -3879,7 +3881,7 @@ handle_written_filepage(pagedep, bp) int i, chgs; if ((pagedep->pd_state & IOSTARTED) == 0) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_written_filepage: not started"); } pagedep->pd_state &= ~IOSTARTED; @@ -3907,7 +3909,7 @@ handle_written_filepage(pagedep, bp) dap = nextdap) { nextdap = LIST_NEXT(dap, da_pdlist); if (dap->da_state & ATTACHED) { - lk.lkt_held = -1; + lk.lkt_held = NOHOLDER; panic("handle_written_filepage: attached"); } ep = (struct direct *) @@ -4124,7 +4126,7 @@ softdep_fsync(vp) struct inode *ip; struct buf *bp; struct fs *fs; - struct proc *p = CURPROC; /* XXX */ + struct thread *td = curthread; int error, flushparent; ino_t parentino; ufs_lbn_t lbn; @@ -4190,9 +4192,9 @@ softdep_fsync(vp) * ufs_lookup for details on possible races. */ FREE_LOCK(&lk); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); error = VFS_VGET(mnt, parentino, &pvp); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); if (error != 0) return (error); /* @@ -4209,7 +4211,7 @@ softdep_fsync(vp) return (error); } if ((pagedep->pd_state & NEWBLOCK) && - (error = VOP_FSYNC(pvp, p->p_ucred, MNT_WAIT, p))) { + (error = VOP_FSYNC(pvp, td->td_proc->p_ucred, MNT_WAIT, td))) { vput(pvp); return (error); } @@ -4217,7 +4219,7 @@ softdep_fsync(vp) /* * Flush directory page containing the inode's name. */ - error = bread(pvp, lbn, blksize(fs, VTOI(pvp), lbn), p->p_ucred, + error = bread(pvp, lbn, blksize(fs, VTOI(pvp), lbn), td->td_proc->p_ucred, &bp); if (error == 0) error = BUF_WRITE(bp); @@ -4294,7 +4296,7 @@ softdep_sync_metadata(ap) struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -4539,7 +4541,7 @@ loop: if (vn_isdisk(vp, NULL) && vp->v_rdev->si_mountpoint && !VOP_ISLOCKED(vp, NULL) && (error = VFS_SYNC(vp->v_rdev->si_mountpoint, MNT_WAIT, ap->a_cred, - ap->a_p)) != 0) + ap->a_td)) != 0) return (error); return (0); } @@ -4643,7 +4645,7 @@ flush_pagedep_deps(pvp, mp, diraddhdp) struct mount *mp; struct diraddhd *diraddhdp; { - struct proc *p = CURPROC; /* XXX */ + struct thread *td = curthread; struct inodedep *inodedep; struct ufsmount *ump; struct diradd *dap; @@ -4690,8 +4692,8 @@ flush_pagedep_deps(pvp, mp, diraddhdp) FREE_LOCK(&lk); if ((error = VFS_VGET(mp, inum, &vp)) != 0) break; - if ((error=VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p)) || - (error=VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p))) { + if ((error=VOP_FSYNC(vp, td->td_proc->p_ucred, MNT_NOWAIT, td)) || + (error=VOP_FSYNC(vp, td->td_proc->p_ucred, MNT_NOWAIT, td))) { vput(vp); break; } @@ -4792,12 +4794,12 @@ request_cleanup(resource, islocked) int resource; int islocked; { - struct proc *p = CURPROC; + struct thread *td = curthread; /* * We never hold up the filesystem syncer process. */ - if (p == filesys_syncer) + if (td == filesys_syncer) return (0); /* * First check to see if the work list has gotten backlogged. @@ -4891,8 +4893,8 @@ pause_timer(arg) * reduce the number of dirrem, freefile, and freeblks dependency structures. */ static void -clear_remove(p) - struct proc *p; +clear_remove(td) + struct thread *td; { struct pagedep_hashhead *pagedephd; struct pagedep *pagedep; @@ -4920,7 +4922,7 @@ clear_remove(p) vn_finished_write(mp); return; } - if ((error = VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p))) + if ((error = VOP_FSYNC(vp, td->td_proc->p_ucred, MNT_NOWAIT, td))) softdep_error("clear_remove: fsync", error); drain_output(vp, 0); vput(vp); @@ -4936,8 +4938,8 @@ clear_remove(p) * the number of inodedep dependency structures. */ static void -clear_inodedeps(p) - struct proc *p; +clear_inodedeps(td) + struct thread *td; { struct inodedep_hashhead *inodedephd; struct inodedep *inodedep; @@ -4994,10 +4996,10 @@ clear_inodedeps(p) return; } if (ino == lastino) { - if ((error = VOP_FSYNC(vp, p->p_ucred, MNT_WAIT, p))) + if ((error = VOP_FSYNC(vp, td->td_proc->p_ucred, MNT_WAIT, td))) softdep_error("clear_inodedeps: fsync1", error); } else { - if ((error = VOP_FSYNC(vp, p->p_ucred, MNT_NOWAIT, p))) + if ((error = VOP_FSYNC(vp, td->td_proc->p_ucred, MNT_NOWAIT, td))) softdep_error("clear_inodedeps: fsync2", error); drain_output(vp, 0); } diff --git a/sys/ufs/ffs/ffs_softdep_stub.c b/sys/ufs/ffs/ffs_softdep_stub.c index 7511533..c47fdb5 100644 --- a/sys/ufs/ffs/ffs_softdep_stub.c +++ b/sys/ufs/ffs/ffs_softdep_stub.c @@ -55,10 +55,10 @@ #include <ufs/ufs/ufs_extern.h> int -softdep_flushfiles(oldmnt, flags, p) +softdep_flushfiles(oldmnt, flags, td) struct mount *oldmnt; int flags; - struct proc *p; + struct thread *td; { panic("softdep_flushfiles called"); @@ -244,10 +244,10 @@ softdep_fsync_mountdev(vp) } int -softdep_flushworklist(oldmnt, countp, p) +softdep_flushworklist(oldmnt, countp, td) struct mount *oldmnt; int *countp; - struct proc *p; + struct thread *td; { *countp = 0; @@ -260,7 +260,7 @@ softdep_sync_metadata(ap) struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; - struct proc *a_p; + struct thread *a_td; } */ *ap; { diff --git a/sys/ufs/ffs/ffs_vfsops.c b/sys/ufs/ffs/ffs_vfsops.c index f741036..48a8ba97 100644 --- a/sys/ufs/ffs/ffs_vfsops.c +++ b/sys/ufs/ffs/ffs_vfsops.c @@ -67,7 +67,7 @@ static MALLOC_DEFINE(M_FFSNODE, "FFS node", "FFS vnode private part"); static int ffs_sbupdate __P((struct ufsmount *, int)); -int ffs_reload __P((struct mount *,struct ucred *,struct proc *)); +int ffs_reload __P((struct mount *,struct ucred *,struct thread *)); static int ffs_oldfscompat __P((struct fs *)); static int ffs_init __P((struct vfsconf *)); @@ -132,12 +132,12 @@ VFS_SET(ufs_vfsops, ufs, 0); * namei() if it is a genuine NULL from the user. */ int -ffs_mount(mp, path, data, ndp, p) +ffs_mount(mp, path, data, ndp, td) struct mount *mp; /* mount struct pointer*/ char *path; /* path to mount point*/ caddr_t data; /* arguments to FS specific mount*/ struct nameidata *ndp; /* mount point credentials*/ - struct proc *p; /* process requesting mount*/ + struct thread *td; /* process requesting mount*/ { size_t size; struct vnode *devvp; @@ -156,10 +156,10 @@ ffs_mount(mp, path, data, ndp, p) return (error); } - if ((error = ffs_mountfs(rootvp, mp, p, M_FFSNODE)) != 0) + if ((error = ffs_mountfs(rootvp, mp, td, M_FFSNODE)) != 0) return (error); - (void)VFS_STATFS(mp, &mp->mnt_stat, p); + (void)VFS_STATFS(mp, &mp->mnt_stat, td); return (0); } @@ -184,9 +184,9 @@ ffs_mount(mp, path, data, ndp, p) if (mp->mnt_flag & MNT_FORCE) flags |= FORCECLOSE; if (mp->mnt_flag & MNT_SOFTDEP) { - error = softdep_flushfiles(mp, flags, p); + error = softdep_flushfiles(mp, flags, td); } else { - error = ffs_flushfiles(mp, flags, p); + error = ffs_flushfiles(mp, flags, td); } if (error) { vn_finished_write(mp); @@ -212,21 +212,21 @@ ffs_mount(mp, path, data, ndp, p) vn_finished_write(mp); } if ((mp->mnt_flag & MNT_RELOAD) && - (error = ffs_reload(mp, ndp->ni_cnd.cn_cred, p)) != 0) + (error = ffs_reload(mp, ndp->ni_cnd.cn_cred, td)) != 0) return (error); if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) { /* * If upgrade to read-write by non-root, then verify * that user has necessary permissions on the device. */ - if (p->p_ucred->cr_uid != 0) { - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); + if (td->td_proc->p_ucred->cr_uid != 0) { + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); if ((error = VOP_ACCESS(devvp, VREAD | VWRITE, - p->p_ucred, p)) != 0) { - VOP_UNLOCK(devvp, 0, p); + td->td_proc->p_ucred, td)) != 0) { + VOP_UNLOCK(devvp, 0, td); return (error); } - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); } fs->fs_flags &= ~FS_UNCLEAN; if (fs->fs_clean == 0) { @@ -253,7 +253,7 @@ ffs_mount(mp, path, data, ndp, p) } /* check to see if we need to start softdep */ if ((fs->fs_flags & FS_DOSOFTDEP) && - (error = softdep_mount(devvp, mp, fs, p->p_ucred))){ + (error = softdep_mount(devvp, mp, fs, td->td_proc->p_ucred))){ vn_finished_write(mp); return (error); } @@ -286,7 +286,7 @@ ffs_mount(mp, path, data, ndp, p) * Not an update, or updating the name: look up the name * and verify that it refers to a sensible block device. */ - NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, td); if ((error = namei(ndp)) != 0) return (error); NDFREE(ndp, NDF_ONLY_PNBUF); @@ -300,16 +300,16 @@ ffs_mount(mp, path, data, ndp, p) * If mount by non-root, then verify that user has necessary * permissions on the device. */ - if (p->p_ucred->cr_uid != 0) { + if (td->td_proc->p_ucred->cr_uid != 0) { accessmode = VREAD; if ((mp->mnt_flag & MNT_RDONLY) == 0) accessmode |= VWRITE; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - if ((error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p))!= 0){ + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + if ((error = VOP_ACCESS(devvp, accessmode, td->td_proc->p_ucred, td))!= 0){ vput(devvp); return (error); } - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); } if (mp->mnt_flag & MNT_UPDATE) { @@ -335,7 +335,7 @@ ffs_mount(mp, path, data, ndp, p) * the mount point is discarded by the upper level code. * Note that vfs_mount() populates f_mntonname for us. */ - if ((error = ffs_mountfs(devvp, mp, p, M_FFSNODE)) != 0) { + if ((error = ffs_mountfs(devvp, mp, td, M_FFSNODE)) != 0) { vrele(devvp); return (error); } @@ -348,7 +348,7 @@ ffs_mount(mp, path, data, ndp, p) /* * Initialize filesystem stat information in mount struct. */ - (void)VFS_STATFS(mp, &mp->mnt_stat, p); + (void)VFS_STATFS(mp, &mp->mnt_stat, td); return (0); } @@ -366,10 +366,10 @@ ffs_mount(mp, path, data, ndp, p) * 6) re-read inode data for all active vnodes. */ int -ffs_reload(mp, cred, p) +ffs_reload(mp, cred, td) register struct mount *mp; struct ucred *cred; - struct proc *p; + struct thread *td; { register struct vnode *vp, *nvp, *devvp; struct inode *ip; @@ -387,9 +387,9 @@ ffs_reload(mp, cred, p) * Step 1: invalidate all cached meta-data. */ devvp = VFSTOUFS(mp)->um_devvp; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = vinvalbuf(devvp, 0, cred, p, 0, 0); - VOP_UNLOCK(devvp, 0, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = vinvalbuf(devvp, 0, cred, td, 0, 0); + VOP_UNLOCK(devvp, 0, td); if (error) panic("ffs_reload: dirty1"); @@ -400,16 +400,16 @@ ffs_reload(mp, cred, p) * block device. */ if (vn_isdisk(devvp, NULL)) { - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - vfs_object_create(devvp, p, p->p_ucred); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + vfs_object_create(devvp, td, td->td_proc->p_ucred); mtx_lock(&devvp->v_interlock); - VOP_UNLOCK(devvp, LK_INTERLOCK, p); + VOP_UNLOCK(devvp, LK_INTERLOCK, td); } /* * Step 2: re-read superblock from disk. */ - if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0) + if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, td) != 0) size = DEV_BSIZE; else size = dpart.disklab->d_secsize; @@ -486,16 +486,16 @@ loop: /* * Step 4: invalidate all inactive vnodes. */ - if (vrecycle(vp, NULL, p)) + if (vrecycle(vp, NULL, td)) goto loop; /* * Step 5: invalidate all cached file data. */ mtx_lock(&vp->v_interlock); - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) { + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) { goto loop; } - if (vinvalbuf(vp, 0, cred, p, 0, 0)) + if (vinvalbuf(vp, 0, cred, td, 0, 0)) panic("ffs_reload: dirty2"); /* * Step 6: re-read inode data for all active vnodes. @@ -527,10 +527,10 @@ SYSCTL_INT(_debug, OID_AUTO, bigcgs, CTLFLAG_RW, &bigcgs, 0, ""); * Common code for mount and mountroot */ int -ffs_mountfs(devvp, mp, p, malloctype) +ffs_mountfs(devvp, mp, td, malloctype) register struct vnode *devvp; struct mount *mp; - struct proc *p; + struct thread *td; struct malloc_type *malloctype; { register struct ufsmount *ump; @@ -547,7 +547,7 @@ ffs_mountfs(devvp, mp, p, malloctype) int ncount; dev = devvp->v_rdev; - cred = p ? p->p_ucred : NOCRED; + cred = td ? td->td_proc->p_ucred : NOCRED; /* * Disallow multiple mounts of the same device. * Disallow mounting of a device that is currently in use @@ -561,9 +561,9 @@ ffs_mountfs(devvp, mp, p, malloctype) if (ncount > 1 && devvp != rootvp) return (EBUSY); - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0); - VOP_UNLOCK(devvp, 0, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = vinvalbuf(devvp, V_SAVE, cred, td, 0, 0); + VOP_UNLOCK(devvp, 0, td); if (error) return (error); @@ -574,16 +574,16 @@ ffs_mountfs(devvp, mp, p, malloctype) * increases the opportunity for metadata caching. */ if (vn_isdisk(devvp, NULL)) { - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - vfs_object_create(devvp, p, cred); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + vfs_object_create(devvp, td, cred); mtx_lock(&devvp->v_interlock); - VOP_UNLOCK(devvp, LK_INTERLOCK, p); + VOP_UNLOCK(devvp, LK_INTERLOCK, td); } ronly = (mp->mnt_flag & MNT_RDONLY) != 0; - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p); - VOP_UNLOCK(devvp, 0, p); + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, td); + VOP_UNLOCK(devvp, 0, td); if (error) return (error); if (devvp->v_rdev->si_iosize_max > mp->mnt_iosize_max) @@ -591,7 +591,7 @@ ffs_mountfs(devvp, mp, p, malloctype) if (mp->mnt_iosize_max > MAXPHYS) mp->mnt_iosize_max = MAXPHYS; - if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, p) != 0) + if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, td) != 0) size = DEV_BSIZE; else size = dpart.disklab->d_secsize; @@ -767,7 +767,7 @@ ffs_mountfs(devvp, mp, p, malloctype) * This would all happen while the file system was busy/not * available, so would effectively be "atomic". */ - (void) ufs_extattr_autostart(mp, p); + (void) ufs_extattr_autostart(mp, td); #endif /* !UFS_EXTATTR_AUTOSTART */ #endif /* !UFS_EXTATTR */ return (0); @@ -775,7 +775,7 @@ out: devvp->v_rdev->si_mountpoint = NULL; if (bp) brelse(bp); - (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p); + (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, td); if (ump) { free(ump->um_fs, M_UFSMNT); free(ump, M_UFSMNT); @@ -820,10 +820,10 @@ ffs_oldfscompat(fs) * unmount system call */ int -ffs_unmount(mp, mntflags, p) +ffs_unmount(mp, mntflags, td) struct mount *mp; int mntflags; - struct proc *p; + struct thread *td; { register struct ufsmount *ump = VFSTOUFS(mp); register struct fs *fs; @@ -834,7 +834,7 @@ ffs_unmount(mp, mntflags, p) flags |= FORCECLOSE; } #ifdef UFS_EXTATTR - if ((error = ufs_extattr_stop(mp, p))) { + if ((error = ufs_extattr_stop(mp, td))) { if (error != EOPNOTSUPP) printf("ffs_unmount: ufs_extattr_stop returned %d\n", error); @@ -843,10 +843,10 @@ ffs_unmount(mp, mntflags, p) } #endif if (mp->mnt_flag & MNT_SOFTDEP) { - if ((error = softdep_flushfiles(mp, flags, p)) != 0) + if ((error = softdep_flushfiles(mp, flags, td)) != 0) return (error); } else { - if ((error = ffs_flushfiles(mp, flags, p)) != 0) + if ((error = ffs_flushfiles(mp, flags, td)) != 0) return (error); } fs = ump->um_fs; @@ -870,9 +870,9 @@ ffs_unmount(mp, mntflags, p) } ump->um_devvp->v_rdev->si_mountpoint = NULL; - vinvalbuf(ump->um_devvp, V_SAVE, NOCRED, p, 0, 0); + vinvalbuf(ump->um_devvp, V_SAVE, NOCRED, td, 0, 0); error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE, - NOCRED, p); + NOCRED, td); vrele(ump->um_devvp); @@ -888,10 +888,10 @@ ffs_unmount(mp, mntflags, p) * Flush out all the files in a filesystem. */ int -ffs_flushfiles(mp, flags, p) +ffs_flushfiles(mp, flags, td) register struct mount *mp; int flags; - struct proc *p; + struct thread *td; { register struct ufsmount *ump; int error; @@ -906,7 +906,7 @@ ffs_flushfiles(mp, flags, p) for (i = 0; i < MAXQUOTAS; i++) { if (ump->um_quotas[i] == NULLVP) continue; - quotaoff(p, mp, i); + quotaoff(td, mp, i); } /* * Here we fall through to vflush again to ensure @@ -931,9 +931,9 @@ ffs_flushfiles(mp, flags, p) /* * Flush filesystem metadata. */ - vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_FSYNC(ump->um_devvp, p->p_ucred, MNT_WAIT, p); - VOP_UNLOCK(ump->um_devvp, 0, p); + vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_FSYNC(ump->um_devvp, td->td_proc->p_ucred, MNT_WAIT, td); + VOP_UNLOCK(ump->um_devvp, 0, td); return (error); } @@ -941,10 +941,10 @@ ffs_flushfiles(mp, flags, p) * Get file system statistics. */ int -ffs_statfs(mp, sbp, p) +ffs_statfs(mp, sbp, td) struct mount *mp; register struct statfs *sbp; - struct proc *p; + struct thread *td; { register struct ufsmount *ump; register struct fs *fs; @@ -980,11 +980,11 @@ ffs_statfs(mp, sbp, p) * Note: we are always called with the filesystem marked `MPBUSY'. */ int -ffs_sync(mp, waitfor, cred, p) +ffs_sync(mp, waitfor, cred, td) struct mount *mp; int waitfor; struct ucred *cred; - struct proc *p; + struct thread *td; { struct vnode *nvp, *vp, *devvp; struct inode *ip; @@ -1028,15 +1028,15 @@ loop: continue; } if (vp->v_type != VCHR) { - if ((error = vget(vp, lockreq, p)) != 0) { + if ((error = vget(vp, lockreq, td)) != 0) { mtx_lock(&mntvnode_mtx); if (error == ENOENT) goto loop; continue; } - if ((error = VOP_FSYNC(vp, cred, waitfor, p)) != 0) + if ((error = VOP_FSYNC(vp, cred, waitfor, td)) != 0) allerror = error; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); vrele(vp); } else { mtx_unlock(&vp->v_interlock); @@ -1049,7 +1049,7 @@ loop: * Force stale file system control information to be flushed. */ if (waitfor == MNT_WAIT) { - if ((error = softdep_flushworklist(ump->um_mountp, &count, p))) + if ((error = softdep_flushworklist(ump->um_mountp, &count, td))) allerror = error; /* Flushed work items may create new vnodes to clean */ if (count) { @@ -1065,10 +1065,10 @@ loop: if (waitfor != MNT_LAZY && (devvp->v_numoutput > 0 || TAILQ_FIRST(&devvp->v_dirtyblkhd))) { mtx_unlock(&devvp->v_interlock); - vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p); - if ((error = VOP_FSYNC(devvp, cred, waitfor, p)) != 0) + vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); + if ((error = VOP_FSYNC(devvp, cred, waitfor, td)) != 0) allerror = error; - VOP_UNLOCK(devvp, 0, p); + VOP_UNLOCK(devvp, 0, td); if (waitfor == MNT_WAIT) { mtx_lock(&mntvnode_mtx); goto loop; diff --git a/sys/ufs/ffs/ffs_vnops.c b/sys/ufs/ffs/ffs_vnops.c index c50fe0f..78c32ea 100644 --- a/sys/ufs/ffs/ffs_vnops.c +++ b/sys/ufs/ffs/ffs_vnops.c @@ -130,7 +130,7 @@ ffs_fsync(ap) struct vnode *a_vp; struct ucred *a_cred; int a_waitfor; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -147,7 +147,7 @@ ffs_fsync(ap) * out from underneath us. */ if (ip->i_flags & SF_SNAPSHOT) - VOP_UNLOCK(vp, 0, ap->a_p); + VOP_UNLOCK(vp, 0, ap->a_td); wait = (ap->a_waitfor == MNT_WAIT); if (vn_isdisk(vp, NULL)) { lbn = INT_MAX; @@ -291,6 +291,6 @@ loop: splx(s); error = UFS_UPDATE(vp, wait); if (ip->i_flags & SF_SNAPSHOT) - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, ap->a_p); + vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, ap->a_td); return (error); } diff --git a/sys/ufs/ifs/ifs_extern.h b/sys/ufs/ifs/ifs_extern.h index 62d3581..df3af4a 100644 --- a/sys/ufs/ifs/ifs_extern.h +++ b/sys/ufs/ifs/ifs_extern.h @@ -64,7 +64,6 @@ struct fs; struct inode; struct malloc_type; struct mount; -struct proc; struct sockaddr; struct statfs; struct ucred; diff --git a/sys/ufs/ifs/ifs_lookup.c b/sys/ufs/ifs/ifs_lookup.c index 7f65967..c6e5873 100644 --- a/sys/ufs/ifs/ifs_lookup.c +++ b/sys/ufs/ifs/ifs_lookup.c @@ -119,7 +119,7 @@ ifs_lookup(ap) int flags = cnp->cn_flags; int nameiop = cnp->cn_nameiop; int error, lockparent, wantparent; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; ufs_daddr_t inodenum; char *endp; @@ -140,12 +140,12 @@ ifs_lookup(ap) return (EPERM); } /* Deal with the '.' directory */ - /* VOP_UNLOCK(vdp, 0, p); */ + /* VOP_UNLOCK(vdp, 0, td); */ if (cnp->cn_namelen == 1 && *(cnp->cn_nameptr) == '.') { /* We don't unlock the parent dir since the're the same */ *vpp = vdp; VREF(vdp); - /* vn_lock(vdp, LK_SHARED | LK_RETRY, p); */ + /* vn_lock(vdp, LK_SHARED | LK_RETRY, td); */ return (0); } /* @@ -155,12 +155,12 @@ ifs_lookup(ap) if ((cnp->cn_namelen) == 7 && (strncmp(cnp->cn_nameptr, "newfile", 7) == 0)) { if (nameiop == CREATE) { /* Check for write permissions in . */ - error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc); + error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread); if (error) return (error); *vpp = NULL; if (!lockparent || !(flags & ISLASTCN)) - VOP_UNLOCK(pdp, 0, p); + VOP_UNLOCK(pdp, 0, td); cnp->cn_flags |= SAVENAME; return (EJUSTRETURN); } else { @@ -246,7 +246,7 @@ ifs_lookup(ap) if (error) return (error); if (!lockparent || !(flags & ISLASTCN)) - VOP_UNLOCK(pdp, 0, p); + VOP_UNLOCK(pdp, 0, td); *vpp = tdp; return (0); } diff --git a/sys/ufs/ifs/ifs_vfsops.c b/sys/ufs/ifs/ifs_vfsops.c index 41b1d5f..0cbf5d0 100644 --- a/sys/ufs/ifs/ifs_vfsops.c +++ b/sys/ufs/ifs/ifs_vfsops.c @@ -70,7 +70,7 @@ static MALLOC_DEFINE(M_IFSNODE, "IFS node", "IFS vnode private part"); static int ifs_init (struct vfsconf *); static int ifs_mount (struct mount *, char *, caddr_t, - struct nameidata *, struct proc *); + struct nameidata *, struct thread *); extern int ifs_vget (struct mount *, ino_t, struct vnode **); @@ -101,16 +101,16 @@ VFS_SET(ifs_vfsops, ifs, 0); * deal with softupdates so we make sure the user isn't trying to use it. */ static int -ifs_mount(mp, path, data, ndp, p) +ifs_mount(mp, path, data, ndp, td) struct mount *mp; char *path; caddr_t data; struct nameidata *ndp; - struct proc *p; + struct thread *td; { /* Clear the softdep flag */ mp->mnt_flag &= ~MNT_SOFTDEP; - return (ffs_mount(mp, path, data, ndp, p)); + return (ffs_mount(mp, path, data, ndp, td)); } diff --git a/sys/ufs/ufs/extattr.h b/sys/ufs/ufs/extattr.h index b609ded..0eca43f 100644 --- a/sys/ufs/ufs/extattr.h +++ b/sys/ufs/ufs/extattr.h @@ -93,14 +93,14 @@ struct ufs_extattr_per_mount { void ufs_extattr_uepm_init(struct ufs_extattr_per_mount *uepm); void ufs_extattr_uepm_destroy(struct ufs_extattr_per_mount *uepm); -int ufs_extattr_start(struct mount *mp, struct proc *p); -int ufs_extattr_autostart(struct mount *mp, struct proc *p); -int ufs_extattr_stop(struct mount *mp, struct proc *p); +int ufs_extattr_start(struct mount *mp, struct thread *td); +int ufs_extattr_autostart(struct mount *mp, struct thread *td); +int ufs_extattr_stop(struct mount *mp, struct thread *td); int ufs_extattrctl(struct mount *mp, int cmd, struct vnode *filename, - int attrnamespace, const char *attrname, struct proc *p); + int attrnamespace, const char *attrname, struct thread *td); int ufs_vop_getextattr(struct vop_getextattr_args *ap); int ufs_vop_setextattr(struct vop_setextattr_args *ap); -void ufs_extattr_vnode_inactive(struct vnode *vp, struct proc *p); +void ufs_extattr_vnode_inactive(struct vnode *vp, struct thread *td); #endif /* !_KERNEL */ diff --git a/sys/ufs/ufs/quota.h b/sys/ufs/ufs/quota.h index efa714e..080569c 100644 --- a/sys/ufs/ufs/quota.h +++ b/sys/ufs/ufs/quota.h @@ -174,7 +174,7 @@ struct dquot { struct inode; struct mount; -struct proc; +struct thread; struct ucred; struct vnode; @@ -185,11 +185,11 @@ void dqrele __P((struct vnode *, struct dquot *)); int getinoquota __P((struct inode *)); int getquota __P((struct mount *, u_long, int, caddr_t)); int qsync __P((struct mount *mp)); -int quotaoff __P((struct proc *, struct mount *, int)); -int quotaon __P((struct proc *, struct mount *, int, caddr_t)); +int quotaoff __P((struct thread *td, struct mount *, int)); +int quotaon __P((struct thread *td, struct mount *, int, caddr_t)); int setquota __P((struct mount *, u_long, int, caddr_t)); int setuse __P((struct mount *, u_long, int, caddr_t)); -int ufs_quotactl __P((struct mount *, int, uid_t, caddr_t, struct proc *)); +int ufs_quotactl __P((struct mount *, int, uid_t, caddr_t, struct thread *td)); #else /* !_KERNEL */ diff --git a/sys/ufs/ufs/ufs_acl.c b/sys/ufs/ufs/ufs_acl.c index d5ab20b..56e4828 100644 --- a/sys/ufs/ufs/ufs_acl.c +++ b/sys/ufs/ufs/ufs_acl.c @@ -217,7 +217,7 @@ ufs_getacl(ap) struct acl_type_t type; struct acl *aclp; struct ucred *cred; - struct proc *p; + struct thread *td; } */ *ap; { struct inode *ip = VTOI(ap->a_vp); @@ -241,7 +241,7 @@ ufs_getacl(ap) error = vn_extattr_get(ap->a_vp, IO_NODELOCKED, POSIX1E_ACL_ACCESS_EXTATTR_NAMESPACE, POSIX1E_ACL_ACCESS_EXTATTR_NAME, &len, (char *) ap->a_aclp, - ap->a_p); + ap->a_td); switch (error) { /* XXX: Will be ENOATTR. */ /* XXX: If ufs_getacl() should work on file systems without @@ -294,7 +294,7 @@ ufs_getacl(ap) error = vn_extattr_get(ap->a_vp, IO_NODELOCKED, POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE, POSIX1E_ACL_DEFAULT_EXTATTR_NAME, &len, - (char *) ap->a_aclp, ap->a_p); + (char *) ap->a_aclp, ap->a_td); /* * Unlike ACL_TYPE_ACCESS, there is no relationship between * the inode contents and the ACL, and it is therefore @@ -370,7 +370,7 @@ ufs_setacl(ap) * Set operation. */ error = VOP_ACLCHECK(ap->a_vp, ap->a_type, ap->a_aclp, - ap->a_cred, ap->a_p); + ap->a_cred, ap->a_td); if (error != 0) return (error); } else { @@ -397,7 +397,7 @@ ufs_setacl(ap) /* * Must hold VADMIN (be file owner) or have appropriate privilege. */ - if ((error = VOP_ACCESS(ap->a_vp, VADMIN, ap->a_cred, ap->a_p))) + if ((error = VOP_ACCESS(ap->a_vp, VADMIN, ap->a_cred, ap->a_td))) return (error); switch(ap->a_type) { @@ -405,14 +405,14 @@ ufs_setacl(ap) error = vn_extattr_set(ap->a_vp, IO_NODELOCKED, POSIX1E_ACL_ACCESS_EXTATTR_NAMESPACE, POSIX1E_ACL_ACCESS_EXTATTR_NAME, sizeof(*ap->a_aclp), - (char *) ap->a_aclp, ap->a_p); + (char *) ap->a_aclp, ap->a_td); break; case ACL_TYPE_DEFAULT: if (ap->a_aclp == NULL) { error = vn_extattr_rm(ap->a_vp, IO_NODELOCKED, POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE, - POSIX1E_ACL_DEFAULT_EXTATTR_NAME, ap->a_p); + POSIX1E_ACL_DEFAULT_EXTATTR_NAME, ap->a_td); /* * Attempting to delete a non-present default ACL * will return success for portability purposes. @@ -425,7 +425,7 @@ ufs_setacl(ap) error = vn_extattr_set(ap->a_vp, IO_NODELOCKED, POSIX1E_ACL_DEFAULT_EXTATTR_NAMESPACE, POSIX1E_ACL_DEFAULT_EXTATTR_NAME, - sizeof(*ap->a_aclp), (char *) ap->a_aclp, ap->a_p); + sizeof(*ap->a_aclp), (char *) ap->a_aclp, ap->a_td); break; default: @@ -466,7 +466,7 @@ ufs_aclcheck(ap) acl_type_t type; struct acl *aclp; struct ucred *cred; - struct proc *p; + struct thread *td; } */ *ap; { diff --git a/sys/ufs/ufs/ufs_extattr.c b/sys/ufs/ufs/ufs_extattr.c index b713267..60dc574 100644 --- a/sys/ufs/ufs/ufs_extattr.c +++ b/sys/ufs/ufs/ufs_extattr.c @@ -66,20 +66,20 @@ SYSCTL_INT(_debug, OID_AUTO, ufs_extattr_sync, CTLFLAG_RW, &ufs_extattr_sync, static int ufs_extattr_valid_attrname(const char *attrname); static int ufs_extattr_credcheck(struct vnode *vp, - struct ufs_extattr_list_entry *uele, struct ucred *cred, struct proc *p, + struct ufs_extattr_list_entry *uele, struct ucred *cred, struct thread *td, int access); static int ufs_extattr_enable_with_open(struct ufsmount *ump, - struct vnode *vp, int attrnamespace, const char *attrname, struct proc *p); + struct vnode *vp, int attrnamespace, const char *attrname, struct thread *td); static int ufs_extattr_enable(struct ufsmount *ump, int attrnamespace, - const char *attrname, struct vnode *backing_vnode, struct proc *p); + const char *attrname, struct vnode *backing_vnode, struct thread *td); static int ufs_extattr_disable(struct ufsmount *ump, int attrnamespace, - const char *attrname, struct proc *p); + const char *attrname, struct thread *td); static int ufs_extattr_get(struct vnode *vp, int attrnamespace, - const char *name, struct uio *uio, struct ucred *cred, struct proc *p); + const char *name, struct uio *uio, struct ucred *cred, struct thread *td); static int ufs_extattr_set(struct vnode *vp, int attrnamespace, - const char *name, struct uio *uio, struct ucred *cred, struct proc *p); + const char *name, struct uio *uio, struct ucred *cred, struct thread *td); static int ufs_extattr_rm(struct vnode *vp, int attrnamespace, - const char *name, struct ucred *cred, struct proc *p); + const char *name, struct ucred *cred, struct thread *td); /* * Per-FS attribute lock protecting attribute operations. @@ -87,19 +87,19 @@ static int ufs_extattr_rm(struct vnode *vp, int attrnamespace, * lock per-FS; really, this should be far more fine-grained. */ static void -ufs_extattr_uepm_lock(struct ufsmount *ump, struct proc *p) +ufs_extattr_uepm_lock(struct ufsmount *ump, struct thread *td) { /* Ideally, LK_CANRECURSE would not be used, here. */ lockmgr(&ump->um_extattr.uepm_lock, LK_EXCLUSIVE | LK_RETRY | - LK_CANRECURSE, 0, p); + LK_CANRECURSE, 0, td); } static void -ufs_extattr_uepm_unlock(struct ufsmount *ump, struct proc *p) +ufs_extattr_uepm_unlock(struct ufsmount *ump, struct thread *td) { - lockmgr(&ump->um_extattr.uepm_lock, LK_RELEASE, 0, p); + lockmgr(&ump->um_extattr.uepm_lock, LK_RELEASE, 0, td); } /* @@ -190,14 +190,14 @@ ufs_extattr_uepm_destroy(struct ufs_extattr_per_mount *uepm) * Start extended attribute support on an FS. */ int -ufs_extattr_start(struct mount *mp, struct proc *p) +ufs_extattr_start(struct mount *mp, struct thread *td) { struct ufsmount *ump; int error = 0; ump = VFSTOUFS(mp); - ufs_extattr_uepm_lock(ump, p); + ufs_extattr_uepm_lock(ump, td); if (!(ump->um_extattr.uepm_flags & UFS_EXTATTR_UEPM_INITIALIZED)) { error = EOPNOTSUPP; @@ -210,11 +210,11 @@ ufs_extattr_start(struct mount *mp, struct proc *p) ump->um_extattr.uepm_flags |= UFS_EXTATTR_UEPM_STARTED; - crhold(p->p_ucred); - ump->um_extattr.uepm_ucred = p->p_ucred; + crhold(td->td_proc->p_ucred); + ump->um_extattr.uepm_ucred = td->td_proc->p_ucred; unlock: - ufs_extattr_uepm_unlock(ump, p); + ufs_extattr_uepm_unlock(ump, td); return (error); } @@ -232,7 +232,7 @@ unlock: #define UE_GETDIR_LOCKPARENT_DONT 2 static int ufs_extattr_lookup(struct vnode *start_dvp, int lockparent, char *dirname, - struct vnode **vp, struct proc *p) + struct vnode **vp, struct thread *td) { struct vop_cachedlookup_args vargs; struct componentname cnp; @@ -244,15 +244,15 @@ ufs_extattr_lookup(struct vnode *start_dvp, int lockparent, char *dirname, cnp.cn_flags = ISLASTCN; if (lockparent == UE_GETDIR_LOCKPARENT) cnp.cn_flags |= LOCKPARENT; - cnp.cn_proc = p; - cnp.cn_cred = p->p_ucred; + cnp.cn_thread = td; + cnp.cn_cred = td->td_proc->p_ucred; cnp.cn_pnbuf = zalloc(namei_zone); cnp.cn_nameptr = cnp.cn_pnbuf; error = copystr(dirname, cnp.cn_pnbuf, MAXPATHLEN, (size_t *) &cnp.cn_namelen); if (error) { if (lockparent == UE_GETDIR_LOCKPARENT_DONT) { - VOP_UNLOCK(start_dvp, 0, p); + VOP_UNLOCK(start_dvp, 0, td); } zfree(namei_zone, cnp.cn_pnbuf); printf("ufs_extattr_lookup: copystr failed\n"); @@ -272,7 +272,7 @@ ufs_extattr_lookup(struct vnode *start_dvp, int lockparent, char *dirname, */ if (!(cnp.cn_flags & PDIRUNLOCK) && (lockparent == UE_GETDIR_LOCKPARENT_DONT)) - VOP_UNLOCK(start_dvp, 0, p); + VOP_UNLOCK(start_dvp, 0, td); /* * Check that ufs_lookup() didn't release the lock when we @@ -313,15 +313,15 @@ ufs_extattr_lookup(struct vnode *start_dvp, int lockparent, char *dirname, */ static int ufs_extattr_enable_with_open(struct ufsmount *ump, struct vnode *vp, - int attrnamespace, const char *attrname, struct proc *p) + int attrnamespace, const char *attrname, struct thread *td) { int error; - error = VOP_OPEN(vp, FREAD|FWRITE, p->p_ucred, p); + error = VOP_OPEN(vp, FREAD|FWRITE, td->td_proc->p_ucred, td); if (error) { printf("ufs_extattr_enable_with_open.VOP_OPEN(): failed " "with %d\n", error); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); return (error); } @@ -330,12 +330,12 @@ ufs_extattr_enable_with_open(struct ufsmount *ump, struct vnode *vp, * to a similar piece of code in vn_open(), we don't. */ if (vn_canvmio(vp) == TRUE) - if ((error = vfs_object_create(vp, p, p->p_ucred)) != 0) { + if ((error = vfs_object_create(vp, td, td->td_proc->p_ucred)) != 0) { /* * XXX: bug replicated from vn_open(): should * VOP_CLOSE() here. */ - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); return (error); } @@ -343,11 +343,11 @@ ufs_extattr_enable_with_open(struct ufsmount *ump, struct vnode *vp, vref(vp); - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); - error = ufs_extattr_enable(ump, attrnamespace, attrname, vp, p); + error = ufs_extattr_enable(ump, attrnamespace, attrname, vp, td); if (error != 0) - vn_close(vp, FREAD|FWRITE, p->p_ucred, p); + vn_close(vp, FREAD|FWRITE, td->td_proc->p_ucred, td); return (error); } @@ -361,7 +361,7 @@ ufs_extattr_enable_with_open(struct ufsmount *ump, struct vnode *vp, */ static int ufs_extattr_iterate_directory(struct ufsmount *ump, struct vnode *dvp, - int attrnamespace, struct proc *p) + int attrnamespace, struct thread *td) { struct vop_readdir_args vargs; struct dirent *dp, *edp; @@ -380,13 +380,13 @@ ufs_extattr_iterate_directory(struct ufsmount *ump, struct vnode *dvp, auio.uio_iovcnt = 1; auio.uio_rw = UIO_READ; auio.uio_segflg = UIO_SYSSPACE; - auio.uio_procp = p; + auio.uio_td = td; auio.uio_offset = 0; vargs.a_desc = NULL; vargs.a_vp = dvp; vargs.a_uio = &auio; - vargs.a_cred = p->p_ucred; + vargs.a_cred = td->td_proc->p_ucred; vargs.a_eofflag = &eofflag; vargs.a_ncookies = NULL; vargs.a_cookies = NULL; @@ -413,7 +413,7 @@ ufs_extattr_iterate_directory(struct ufsmount *ump, struct vnode *dvp, if (dp->d_reclen == 0) break; error = ufs_extattr_lookup(dvp, UE_GETDIR_LOCKPARENT, - dp->d_name, &attr_vp, p); + dp->d_name, &attr_vp, td); if (error) { printf("ufs_extattr_iterate_directory: lookup " "%s %d\n", dp->d_name, error); @@ -429,7 +429,7 @@ ufs_extattr_iterate_directory(struct ufsmount *ump, struct vnode *dvp, vput(attr_vp); } else { error = ufs_extattr_enable_with_open(ump, - attr_vp, attrnamespace, dp->d_name, p); + attr_vp, attrnamespace, dp->d_name, td); vrele(attr_vp); if (error) { printf("ufs_extattr_iterate_directory: " @@ -458,7 +458,7 @@ ufs_extattr_iterate_directory(struct ufsmount *ump, struct vnode *dvp, * mount-time. */ int -ufs_extattr_autostart(struct mount *mp, struct proc *p) +ufs_extattr_autostart(struct mount *mp, struct thread *td) { struct vnode *rvp, *attr_dvp, *attr_system_dvp, *attr_user_dvp; int error; @@ -474,7 +474,7 @@ ufs_extattr_autostart(struct mount *mp, struct proc *p) } error = ufs_extattr_lookup(rvp, UE_GETDIR_LOCKPARENT_DONT, - UFS_EXTATTR_FSROOTSUBDIR, &attr_dvp, p); + UFS_EXTATTR_FSROOTSUBDIR, &attr_dvp, td); if (error) { /* rvp ref'd but now unlocked */ vrele(rvp); @@ -494,7 +494,7 @@ ufs_extattr_autostart(struct mount *mp, struct proc *p) goto return_vput_attr_dvp; } - error = ufs_extattr_start(mp, p); + error = ufs_extattr_start(mp, td); if (error) { printf("ufs_extattr_autostart: ufs_extattr_start failed (%d)\n", error); @@ -509,10 +509,10 @@ ufs_extattr_autostart(struct mount *mp, struct proc *p) * be cleaned up on exit. */ error = ufs_extattr_lookup(attr_dvp, UE_GETDIR_LOCKPARENT, - UFS_EXTATTR_SUBDIR_SYSTEM, &attr_system_dvp, p); + UFS_EXTATTR_SUBDIR_SYSTEM, &attr_system_dvp, td); if (!error) { error = ufs_extattr_iterate_directory(VFSTOUFS(mp), - attr_system_dvp, EXTATTR_NAMESPACE_SYSTEM, p); + attr_system_dvp, EXTATTR_NAMESPACE_SYSTEM, td); if (error) printf("ufs_extattr_iterate_directory returned %d\n", error); @@ -520,10 +520,10 @@ ufs_extattr_autostart(struct mount *mp, struct proc *p) } error = ufs_extattr_lookup(attr_dvp, UE_GETDIR_LOCKPARENT, - UFS_EXTATTR_SUBDIR_USER, &attr_user_dvp, p); + UFS_EXTATTR_SUBDIR_USER, &attr_user_dvp, td); if (!error) { error = ufs_extattr_iterate_directory(VFSTOUFS(mp), - attr_user_dvp, EXTATTR_NAMESPACE_USER, p); + attr_user_dvp, EXTATTR_NAMESPACE_USER, td); if (error) printf("ufs_extattr_iterate_directory returned %d\n", error); @@ -544,13 +544,13 @@ return_vput_attr_dvp: * Stop extended attribute support on an FS. */ int -ufs_extattr_stop(struct mount *mp, struct proc *p) +ufs_extattr_stop(struct mount *mp, struct thread *td) { struct ufs_extattr_list_entry *uele; struct ufsmount *ump = VFSTOUFS(mp); int error = 0; - ufs_extattr_uepm_lock(ump, p); + ufs_extattr_uepm_lock(ump, td); if (!(ump->um_extattr.uepm_flags & UFS_EXTATTR_UEPM_STARTED)) { error = EOPNOTSUPP; @@ -560,7 +560,7 @@ ufs_extattr_stop(struct mount *mp, struct proc *p) while (LIST_FIRST(&ump->um_extattr.uepm_list) != NULL) { uele = LIST_FIRST(&ump->um_extattr.uepm_list); ufs_extattr_disable(ump, uele->uele_attrnamespace, - uele->uele_attrname, p); + uele->uele_attrname, td); } ump->um_extattr.uepm_flags &= ~UFS_EXTATTR_UEPM_STARTED; @@ -569,7 +569,7 @@ ufs_extattr_stop(struct mount *mp, struct proc *p) ump->um_extattr.uepm_ucred = NULL; unlock: - ufs_extattr_uepm_unlock(ump, p); + ufs_extattr_uepm_unlock(ump, td); return (error); } @@ -580,7 +580,7 @@ unlock: */ static int ufs_extattr_enable(struct ufsmount *ump, int attrnamespace, - const char *attrname, struct vnode *backing_vnode, struct proc *p) + const char *attrname, struct vnode *backing_vnode, struct thread *td) { struct ufs_extattr_list_entry *attribute; struct iovec aiov; @@ -622,13 +622,13 @@ ufs_extattr_enable(struct ufsmount *ump, int attrnamespace, auio.uio_offset = (off_t) 0; auio.uio_segflg = UIO_SYSSPACE; auio.uio_rw = UIO_READ; - auio.uio_procp = (struct proc *) p; + auio.uio_td = td; - VOP_LEASE(backing_vnode, p, p->p_ucred, LEASE_WRITE); - vn_lock(backing_vnode, LK_SHARED | LK_NOPAUSE | LK_RETRY, p); + VOP_LEASE(backing_vnode, td, td->td_proc->p_ucred, LEASE_WRITE); + vn_lock(backing_vnode, LK_SHARED | LK_NOPAUSE | LK_RETRY, td); error = VOP_READ(backing_vnode, &auio, IO_NODELOCKED, ump->um_extattr.uepm_ucred); - VOP_UNLOCK(backing_vnode, 0, p); + VOP_UNLOCK(backing_vnode, 0, td); if (error) goto free_exit; @@ -667,7 +667,7 @@ free_exit: */ static int ufs_extattr_disable(struct ufsmount *ump, int attrnamespace, - const char *attrname, struct proc *p) + const char *attrname, struct thread *td) { struct ufs_extattr_list_entry *uele; int error = 0; @@ -682,7 +682,7 @@ ufs_extattr_disable(struct ufsmount *ump, int attrnamespace, LIST_REMOVE(uele, uele_entries); uele->uele_backing_vnode->v_flag &= ~VSYSTEM; - error = vn_close(uele->uele_backing_vnode, FREAD|FWRITE, p->p_ucred, p); + error = vn_close(uele->uele_backing_vnode, FREAD|FWRITE, td->td_proc->p_ucred, td); FREE(uele, M_UFS_EXTATTR); @@ -696,7 +696,7 @@ ufs_extattr_disable(struct ufsmount *ump, int attrnamespace, */ int ufs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp, - int attrnamespace, const char *attrname, struct proc *p) + int attrnamespace, const char *attrname, struct thread *td) { struct ufsmount *ump = VFSTOUFS(mp); int error; @@ -705,34 +705,34 @@ ufs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp, * Processes with privilege, but in jail, are not allowed to * configure extended attributes. */ - if ((error = suser_xxx(p->p_ucred, p, 0))) { + if ((error = suser_xxx(td->td_proc->p_ucred, td->td_proc, 0))) { if (filename_vp != NULL) - VOP_UNLOCK(filename_vp, 0, p); + VOP_UNLOCK(filename_vp, 0, td); return (error); } switch(cmd) { case UFS_EXTATTR_CMD_START: if (filename_vp != NULL) { - VOP_UNLOCK(filename_vp, 0, p); + VOP_UNLOCK(filename_vp, 0, td); return (EINVAL); } if (attrname != NULL) return (EINVAL); - error = ufs_extattr_start(mp, p); + error = ufs_extattr_start(mp, td); return (error); case UFS_EXTATTR_CMD_STOP: if (filename_vp != NULL) { - VOP_UNLOCK(filename_vp, 0, p); + VOP_UNLOCK(filename_vp, 0, td); return (EINVAL); } if (attrname != NULL) return (EINVAL); - error = ufs_extattr_stop(mp, p); + error = ufs_extattr_stop(mp, td); return (error); @@ -741,7 +741,7 @@ ufs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp, if (filename_vp == NULL) return (EINVAL); if (attrname == NULL) { - VOP_UNLOCK(filename_vp, 0, p); + VOP_UNLOCK(filename_vp, 0, td); return (EINVAL); } @@ -749,25 +749,25 @@ ufs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp, * ufs_extattr_enable_with_open() will always unlock the * vnode, regardless of failure. */ - ufs_extattr_uepm_lock(ump, p); + ufs_extattr_uepm_lock(ump, td); error = ufs_extattr_enable_with_open(ump, filename_vp, - attrnamespace, attrname, p); - ufs_extattr_uepm_unlock(ump, p); + attrnamespace, attrname, td); + ufs_extattr_uepm_unlock(ump, td); return (error); case UFS_EXTATTR_CMD_DISABLE: if (filename_vp != NULL) { - VOP_UNLOCK(filename_vp, 0, p); + VOP_UNLOCK(filename_vp, 0, td); return (EINVAL); } if (attrname == NULL) return (EINVAL); - ufs_extattr_uepm_lock(ump, p); - error = ufs_extattr_disable(ump, attrnamespace, attrname, p); - ufs_extattr_uepm_unlock(ump, p); + ufs_extattr_uepm_lock(ump, td); + error = ufs_extattr_disable(ump, attrnamespace, attrname, td); + ufs_extattr_uepm_unlock(ump, td); return (error); @@ -782,7 +782,7 @@ ufs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp, */ static int ufs_extattr_credcheck(struct vnode *vp, struct ufs_extattr_list_entry *uele, - struct ucred *cred, struct proc *p, int access) + struct ucred *cred, struct thread *td, int access) { /* @@ -800,9 +800,9 @@ ufs_extattr_credcheck(struct vnode *vp, struct ufs_extattr_list_entry *uele, */ switch (uele->uele_attrnamespace) { case EXTATTR_NAMESPACE_SYSTEM: - return (suser_xxx(cred, p, 0)); + return (suser_xxx(cred, td->td_proc, 0)); case EXTATTR_NAMESPACE_USER: - return (VOP_ACCESS(vp, access, cred, p)); + return (VOP_ACCESS(vp, access, cred, td)); default: return (EPERM); } @@ -820,7 +820,7 @@ vop_getextattr { IN const char *a_name; INOUT struct uio *a_uio; IN struct ucred *a_cred; - IN struct proc *a_p; + IN struct thread *a_td; }; */ { @@ -828,12 +828,12 @@ vop_getextattr { struct ufsmount *ump = VFSTOUFS(mp); int error; - ufs_extattr_uepm_lock(ump, ap->a_p); + ufs_extattr_uepm_lock(ump, ap->a_td); error = ufs_extattr_get(ap->a_vp, ap->a_attrnamespace, ap->a_name, - ap->a_uio, ap->a_cred, ap->a_p); + ap->a_uio, ap->a_cred, ap->a_td); - ufs_extattr_uepm_unlock(ump, ap->a_p); + ufs_extattr_uepm_unlock(ump, ap->a_td); return (error); } @@ -844,7 +844,7 @@ vop_getextattr { */ static int ufs_extattr_get(struct vnode *vp, int attrnamespace, const char *name, - struct uio *uio, struct ucred *cred, struct proc *p) + struct uio *uio, struct ucred *cred, struct thread *td) { struct ufs_extattr_list_entry *attribute; struct ufs_extattr_header ueh; @@ -870,7 +870,7 @@ ufs_extattr_get(struct vnode *vp, int attrnamespace, const char *name, if (!attribute) return (ENOENT); - if ((error = ufs_extattr_credcheck(vp, attribute, cred, p, IREAD))) + if ((error = ufs_extattr_credcheck(vp, attribute, cred, td, IREAD))) return (error); /* @@ -900,21 +900,21 @@ ufs_extattr_get(struct vnode *vp, int attrnamespace, const char *name, local_aio.uio_iovcnt = 1; local_aio.uio_rw = UIO_READ; local_aio.uio_segflg = UIO_SYSSPACE; - local_aio.uio_procp = p; + local_aio.uio_td = td; local_aio.uio_offset = base_offset; local_aio.uio_resid = sizeof(struct ufs_extattr_header); /* * Acquire locks. */ - VOP_LEASE(attribute->uele_backing_vnode, p, cred, LEASE_READ); + VOP_LEASE(attribute->uele_backing_vnode, td, cred, LEASE_READ); /* * Don't need to get a lock on the backing file if the getattr is * being applied to the backing file, as the lock is already held. */ if (attribute->uele_backing_vnode != vp) vn_lock(attribute->uele_backing_vnode, LK_SHARED | - LK_NOPAUSE | LK_RETRY, p); + LK_NOPAUSE | LK_RETRY, td); error = VOP_READ(attribute->uele_backing_vnode, &local_aio, IO_NODELOCKED, ump->um_extattr.uepm_ucred); @@ -970,7 +970,7 @@ vopunlock_exit: uio->uio_offset = 0; if (attribute->uele_backing_vnode != vp) - VOP_UNLOCK(attribute->uele_backing_vnode, 0, p); + VOP_UNLOCK(attribute->uele_backing_vnode, 0, td); return (error); } @@ -987,7 +987,7 @@ vop_setextattr { IN const char *a_name; INOUT struct uio *a_uio; IN struct ucred *a_cred; - IN struct proc *a_p; + IN struct thread *a_td; }; */ { @@ -996,16 +996,16 @@ vop_setextattr { int error; - ufs_extattr_uepm_lock(ump, ap->a_p); + ufs_extattr_uepm_lock(ump, ap->a_td); if (ap->a_uio != NULL) error = ufs_extattr_set(ap->a_vp, ap->a_attrnamespace, - ap->a_name, ap->a_uio, ap->a_cred, ap->a_p); + ap->a_name, ap->a_uio, ap->a_cred, ap->a_td); else error = ufs_extattr_rm(ap->a_vp, ap->a_attrnamespace, - ap->a_name, ap->a_cred, ap->a_p); + ap->a_name, ap->a_cred, ap->a_td); - ufs_extattr_uepm_unlock(ump, ap->a_p); + ufs_extattr_uepm_unlock(ump, ap->a_td); return (error); } @@ -1016,7 +1016,7 @@ vop_setextattr { */ static int ufs_extattr_set(struct vnode *vp, int attrnamespace, const char *name, - struct uio *uio, struct ucred *cred, struct proc *p) + struct uio *uio, struct ucred *cred, struct thread *td) { struct ufs_extattr_list_entry *attribute; struct ufs_extattr_header ueh; @@ -1039,7 +1039,7 @@ ufs_extattr_set(struct vnode *vp, int attrnamespace, const char *name, if (!attribute) return (ENOENT); - if ((error = ufs_extattr_credcheck(vp, attribute, cred, p, IWRITE))) + if ((error = ufs_extattr_credcheck(vp, attribute, cred, td, IWRITE))) return (error); /* @@ -1071,14 +1071,14 @@ ufs_extattr_set(struct vnode *vp, int attrnamespace, const char *name, local_aio.uio_iovcnt = 1; local_aio.uio_rw = UIO_WRITE; local_aio.uio_segflg = UIO_SYSSPACE; - local_aio.uio_procp = p; + local_aio.uio_td = td; local_aio.uio_offset = base_offset; local_aio.uio_resid = sizeof(struct ufs_extattr_header); /* * Acquire locks. */ - VOP_LEASE(attribute->uele_backing_vnode, p, cred, LEASE_WRITE); + VOP_LEASE(attribute->uele_backing_vnode, td, cred, LEASE_WRITE); /* * Don't need to get a lock on the backing file if the setattr is @@ -1086,7 +1086,7 @@ ufs_extattr_set(struct vnode *vp, int attrnamespace, const char *name, */ if (attribute->uele_backing_vnode != vp) vn_lock(attribute->uele_backing_vnode, - LK_EXCLUSIVE | LK_NOPAUSE | LK_RETRY, p); + LK_EXCLUSIVE | LK_NOPAUSE | LK_RETRY, td); ioflag = IO_NODELOCKED; if (ufs_extattr_sync) @@ -1116,7 +1116,7 @@ vopunlock_exit: uio->uio_offset = 0; if (attribute->uele_backing_vnode != vp) - VOP_UNLOCK(attribute->uele_backing_vnode, 0, p); + VOP_UNLOCK(attribute->uele_backing_vnode, 0, td); return (error); } @@ -1127,7 +1127,7 @@ vopunlock_exit: */ static int ufs_extattr_rm(struct vnode *vp, int attrnamespace, const char *name, - struct ucred *cred, struct proc *p) + struct ucred *cred, struct thread *td) { struct ufs_extattr_list_entry *attribute; struct ufs_extattr_header ueh; @@ -1150,7 +1150,7 @@ ufs_extattr_rm(struct vnode *vp, int attrnamespace, const char *name, if (!attribute) return (ENOENT); - if ((error = ufs_extattr_credcheck(vp, attribute, cred, p, IWRITE))) + if ((error = ufs_extattr_credcheck(vp, attribute, cred, td, IWRITE))) return (error); /* @@ -1172,11 +1172,11 @@ ufs_extattr_rm(struct vnode *vp, int attrnamespace, const char *name, local_aio.uio_iovcnt = 1; local_aio.uio_rw = UIO_READ; local_aio.uio_segflg = UIO_SYSSPACE; - local_aio.uio_procp = p; + local_aio.uio_td = td; local_aio.uio_offset = base_offset; local_aio.uio_resid = sizeof(struct ufs_extattr_header); - VOP_LEASE(attribute->uele_backing_vnode, p, cred, LEASE_WRITE); + VOP_LEASE(attribute->uele_backing_vnode, td, cred, LEASE_WRITE); /* * Don't need to get the lock on the backing vnode if the vnode we're @@ -1184,7 +1184,7 @@ ufs_extattr_rm(struct vnode *vp, int attrnamespace, const char *name, */ if (attribute->uele_backing_vnode != vp) vn_lock(attribute->uele_backing_vnode, - LK_EXCLUSIVE | LK_NOPAUSE | LK_RETRY, p); + LK_EXCLUSIVE | LK_NOPAUSE | LK_RETRY, td); error = VOP_READ(attribute->uele_backing_vnode, &local_aio, IO_NODELOCKED, ump->um_extattr.uepm_ucred); @@ -1221,7 +1221,7 @@ ufs_extattr_rm(struct vnode *vp, int attrnamespace, const char *name, local_aio.uio_iovcnt = 1; local_aio.uio_rw = UIO_WRITE; local_aio.uio_segflg = UIO_SYSSPACE; - local_aio.uio_procp = p; + local_aio.uio_td = td; local_aio.uio_offset = base_offset; local_aio.uio_resid = sizeof(struct ufs_extattr_header); @@ -1237,7 +1237,7 @@ ufs_extattr_rm(struct vnode *vp, int attrnamespace, const char *name, error = ENXIO; vopunlock_exit: - VOP_UNLOCK(attribute->uele_backing_vnode, 0, p); + VOP_UNLOCK(attribute->uele_backing_vnode, 0, td); return (error); } @@ -1247,7 +1247,7 @@ vopunlock_exit: * attributes stripped. */ void -ufs_extattr_vnode_inactive(struct vnode *vp, struct proc *p) +ufs_extattr_vnode_inactive(struct vnode *vp, struct thread *td) { struct ufs_extattr_list_entry *uele; struct mount *mp = vp->v_mount; @@ -1261,18 +1261,18 @@ ufs_extattr_vnode_inactive(struct vnode *vp, struct proc *p) if (!(ump->um_extattr.uepm_flags & UFS_EXTATTR_UEPM_INITIALIZED)) return; - ufs_extattr_uepm_lock(ump, p); + ufs_extattr_uepm_lock(ump, td); if (!(ump->um_extattr.uepm_flags & UFS_EXTATTR_UEPM_STARTED)) { - ufs_extattr_uepm_unlock(ump, p); + ufs_extattr_uepm_unlock(ump, td); return; } LIST_FOREACH(uele, &ump->um_extattr.uepm_list, uele_entries) ufs_extattr_rm(vp, uele->uele_attrnamespace, - uele->uele_attrname, NULL, p); + uele->uele_attrname, NULL, td); - ufs_extattr_uepm_unlock(ump, p); + ufs_extattr_uepm_unlock(ump, td); } #endif /* !UFS_EXTATTR */ diff --git a/sys/ufs/ufs/ufs_extern.h b/sys/ufs/ufs/ufs_extern.h index d95013b..c4e2795 100644 --- a/sys/ufs/ufs/ufs_extern.h +++ b/sys/ufs/ufs/ufs_extern.h @@ -43,7 +43,7 @@ struct indir; struct inode; struct mount; struct netcred; -struct proc; +struct thread; struct sockaddr; struct ucred; struct ufid; @@ -89,7 +89,7 @@ int ufs_readdir __P((struct vop_readdir_args *)); int ufs_reclaim __P((struct vop_reclaim_args *)); void ffs_snapgone __P((struct inode *)); int ufs_root __P((struct mount *, struct vnode **)); -int ufs_start __P((struct mount *, int, struct proc *)); +int ufs_start __P((struct mount *, int, struct thread *)); int ufs_vinit __P((struct mount *, vop_t **, vop_t **, struct vnode **)); /* diff --git a/sys/ufs/ufs/ufs_ihash.c b/sys/ufs/ufs/ufs_ihash.c index 1fd39e9..d1537af 100644 --- a/sys/ufs/ufs/ufs_ihash.c +++ b/sys/ufs/ufs/ufs_ihash.c @@ -40,6 +40,7 @@ #include <sys/lock.h> #include <sys/vnode.h> #include <sys/malloc.h> +#include <sys/proc.h> #include <sys/mutex.h> #include <ufs/ufs/quota.h> @@ -97,7 +98,7 @@ ufs_ihashget(dev, inum) dev_t dev; ino_t inum; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct inode *ip; struct vnode *vp; @@ -108,7 +109,7 @@ loop: vp = ITOV(ip); mtx_lock(&vp->v_interlock); mtx_unlock(&ufs_ihash_mtx); - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) goto loop; return (vp); } @@ -124,11 +125,11 @@ void ufs_ihashins(ip) struct inode *ip; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct ihashhead *ipp; /* lock the inode, then put it on the appropriate hash list */ - lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, p); + lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, td); mtx_lock(&ufs_ihash_mtx); ipp = INOHASH(ip->i_dev, ip->i_number); diff --git a/sys/ufs/ufs/ufs_inode.c b/sys/ufs/ufs/ufs_inode.c index 028e3b9..9858297 100644 --- a/sys/ufs/ufs/ufs_inode.c +++ b/sys/ufs/ufs/ufs_inode.c @@ -65,12 +65,12 @@ int ufs_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; struct inode *ip = VTOI(vp); - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; int mode, error = 0; if (prtactive && vp->v_usecount != 0) @@ -90,9 +90,9 @@ ufs_inactive(ap) (void)chkiq(ip, -1, NOCRED, 0); #endif #ifdef UFS_EXTATTR - ufs_extattr_vnode_inactive(ap->a_vp, ap->a_p); + ufs_extattr_vnode_inactive(ap->a_vp, ap->a_td); #endif - error = UFS_TRUNCATE(vp, (off_t)0, 0, NOCRED, p); + error = UFS_TRUNCATE(vp, (off_t)0, 0, NOCRED, td); /* * Setting the mode to zero needs to wait for the inode * to be written just as does a change to the link count. @@ -117,13 +117,13 @@ ufs_inactive(ap) } } out: - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); /* * If we are done with the inode, reclaim it * so that it can be reused immediately. */ if (ip->i_mode == 0) - vrecycle(vp, NULL, p); + vrecycle(vp, NULL, td); return (error); } @@ -134,7 +134,7 @@ int ufs_reclaim(ap) struct vop_reclaim_args /* { struct vnode *a_vp; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct inode *ip; diff --git a/sys/ufs/ufs/ufs_lookup.c b/sys/ufs/ufs/ufs_lookup.c index a062330..da1c0e9 100644 --- a/sys/ufs/ufs/ufs_lookup.c +++ b/sys/ufs/ufs/ufs_lookup.c @@ -156,7 +156,7 @@ ufs_lookup(ap) struct ucred *cred = cnp->cn_cred; int flags = cnp->cn_flags; int nameiop = cnp->cn_nameiop; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; bp = NULL; slotoffset = -1; @@ -400,7 +400,7 @@ notfound: * Access for write is interpreted as allowing * creation of files in the directory. */ - error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc); + error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread); if (error) return (error); /* @@ -445,7 +445,7 @@ notfound: */ cnp->cn_flags |= SAVENAME; if (!lockparent) { - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } return (EJUSTRETURN); @@ -490,7 +490,7 @@ found: /* * Write access to directory required to delete files. */ - error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc); + error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread); if (error) return (error); /* @@ -509,10 +509,10 @@ found: return (0); } if (flags & ISDOTDOT) - VOP_UNLOCK(vdp, 0, p); /* race to get the inode */ + VOP_UNLOCK(vdp, 0, td); /* race to get the inode */ error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp); if (flags & ISDOTDOT) { - if (vn_lock(vdp, LK_EXCLUSIVE | LK_RETRY, p) != 0) + if (vn_lock(vdp, LK_EXCLUSIVE | LK_RETRY, td) != 0) cnp->cn_flags |= PDIRUNLOCK; } if (error) @@ -524,14 +524,14 @@ found: * implements append-only directories. */ if ((dp->i_mode & ISVTX) && - VOP_ACCESS(vdp, VADMIN, cred, cnp->cn_proc) && - VOP_ACCESS(tdp, VADMIN, cred, cnp->cn_proc)) { + VOP_ACCESS(vdp, VADMIN, cred, cnp->cn_thread) && + VOP_ACCESS(tdp, VADMIN, cred, cnp->cn_thread)) { vput(tdp); return (EPERM); } *vpp = tdp; if (!lockparent) { - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } return (0); @@ -544,7 +544,7 @@ found: * regular file, or empty directory. */ if (nameiop == RENAME && wantparent && (flags & ISLASTCN)) { - if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_proc)) != 0) + if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread)) != 0) return (error); /* * Careful about locking second inode. @@ -553,10 +553,10 @@ found: if (dp->i_number == dp->i_ino) return (EISDIR); if (flags & ISDOTDOT) - VOP_UNLOCK(vdp, 0, p); /* race to get the inode */ + VOP_UNLOCK(vdp, 0, td); /* race to get the inode */ error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp); if (flags & ISDOTDOT) { - if (vn_lock(vdp, LK_EXCLUSIVE | LK_RETRY, p) != 0) + if (vn_lock(vdp, LK_EXCLUSIVE | LK_RETRY, td) != 0) cnp->cn_flags |= PDIRUNLOCK; } if (error) @@ -564,7 +564,7 @@ found: *vpp = tdp; cnp->cn_flags |= SAVENAME; if (!lockparent) { - VOP_UNLOCK(vdp, 0, p); + VOP_UNLOCK(vdp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } return (0); @@ -591,15 +591,15 @@ found: */ pdp = vdp; if (flags & ISDOTDOT) { - VOP_UNLOCK(pdp, 0, p); /* race to get the inode */ + VOP_UNLOCK(pdp, 0, td); /* race to get the inode */ cnp->cn_flags |= PDIRUNLOCK; if ((error = VFS_VGET(vdp->v_mount, dp->i_ino, &tdp)) != 0) { - if (vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, p) == 0) + if (vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY, td) == 0) cnp->cn_flags &= ~PDIRUNLOCK; return (error); } if (lockparent && (flags & ISLASTCN)) { - if ((error = vn_lock(pdp, LK_EXCLUSIVE, p)) != 0) { + if ((error = vn_lock(pdp, LK_EXCLUSIVE, td)) != 0) { vput(tdp); return (error); } @@ -614,7 +614,7 @@ found: if (error) return (error); if (!lockparent || !(flags & ISLASTCN)) { - VOP_UNLOCK(pdp, 0, p); + VOP_UNLOCK(pdp, 0, td); cnp->cn_flags |= PDIRUNLOCK; } *vpp = tdp; @@ -739,7 +739,7 @@ ufs_direnter(dvp, tvp, dirp, cnp, newdirbp) struct buf *newdirbp; { struct ucred *cr; - struct proc *p; + struct thread *td; int newentrysize; struct inode *dp; struct buf *bp; @@ -748,8 +748,8 @@ ufs_direnter(dvp, tvp, dirp, cnp, newdirbp) int error, ret, blkoff, loc, spacefree, flags; char *dirbuf; - p = curproc; /* XXX */ - cr = p->p_ucred; + td = curthread; /* XXX */ + cr = td->td_proc->p_ucred; dp = VTOI(dvp); newentrysize = DIRSIZ(OFSFMT(dvp), dirp); @@ -818,10 +818,10 @@ ufs_direnter(dvp, tvp, dirp, cnp, newdirbp) if ((error = BUF_WRITE(bp))) return (error); if (tvp != NULL) - VOP_UNLOCK(tvp, 0, p); - error = VOP_FSYNC(dvp, p->p_ucred, MNT_WAIT, p); + VOP_UNLOCK(tvp, 0, td); + error = VOP_FSYNC(dvp, td->td_proc->p_ucred, MNT_WAIT, td); if (tvp != NULL) - vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, td); return (error); } if (DOINGASYNC(dvp)) { @@ -966,14 +966,14 @@ ufs_direnter(dvp, tvp, dirp, cnp, newdirbp) */ if (error == 0 && dp->i_endoff && dp->i_endoff < dp->i_size) { if (tvp != NULL) - VOP_UNLOCK(tvp, 0, p); + VOP_UNLOCK(tvp, 0, td); #ifdef UFS_DIRHASH if (dp->i_dirhash != NULL) ufsdirhash_dirtrunc(dp, dp->i_endoff); #endif - (void) UFS_TRUNCATE(dvp, (off_t)dp->i_endoff, IO_SYNC, cr, p); + (void) UFS_TRUNCATE(dvp, (off_t)dp->i_endoff, IO_SYNC, cr, td); if (tvp != NULL) - vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, td); } return (error); } @@ -1159,7 +1159,7 @@ ufs_dirempty(ip, parentino, cred) for (off = 0; off < ip->i_size; off += dp->d_reclen) { error = vn_rdwr(UIO_READ, ITOV(ip), (caddr_t)dp, MINDIRSIZ, off, - UIO_SYSSPACE, IO_NODELOCKED, cred, &count, (struct proc *)0); + UIO_SYSSPACE, IO_NODELOCKED, cred, &count, (struct thread *)0); /* * Since we read MINDIRSIZ, residual must * be 0 unless we're at end of file. @@ -1230,7 +1230,7 @@ ufs_checkpath(source, target, cred) } error = vn_rdwr(UIO_READ, vp, (caddr_t)&dirbuf, sizeof (struct dirtemplate), (off_t)0, UIO_SYSSPACE, - IO_NODELOCKED, cred, (int *)0, (struct proc *)0); + IO_NODELOCKED, cred, (int *)0, (struct thread *)0); if (error != 0) break; # if (BYTE_ORDER == LITTLE_ENDIAN) diff --git a/sys/ufs/ufs/ufs_quota.c b/sys/ufs/ufs/ufs_quota.c index 6992160..4c10d88 100644 --- a/sys/ufs/ufs/ufs_quota.c +++ b/sys/ufs/ufs/ufs_quota.c @@ -386,8 +386,8 @@ chkdquot(ip) * Q_QUOTAON - set up a quota file for a particular file system. */ int -quotaon(p, mp, type, fname) - struct proc *p; +quotaon(td, mp, type, fname) + struct thread *td; struct mount *mp; register int type; caddr_t fname; @@ -400,20 +400,20 @@ quotaon(p, mp, type, fname) struct nameidata nd; vpp = &ump->um_quotas[type]; - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, fname, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, fname, td); flags = FREAD | FWRITE; error = vn_open(&nd, &flags, 0); if (error) return (error); NDFREE(&nd, NDF_ONLY_PNBUF); vp = nd.ni_vp; - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); if (vp->v_type != VREG) { - (void) vn_close(vp, FREAD|FWRITE, p->p_ucred, p); + (void) vn_close(vp, FREAD|FWRITE, td->td_proc->p_ucred, td); return (EACCES); } if (*vpp != vp) - quotaoff(p, mp, type); + quotaoff(td, mp, type); ump->um_qflags[type] |= QTF_OPENING; mp->mnt_flag |= MNT_QUOTA; vp->v_flag |= VSYSTEM; @@ -422,8 +422,8 @@ quotaon(p, mp, type, fname) * Save the credential of the process that turned on quotas. * Set up the time limits for this quota. */ - crhold(p->p_ucred); - ump->um_cred[type] = p->p_ucred; + crhold(td->td_proc->p_ucred); + ump->um_cred[type] = td->td_proc->p_ucred; ump->um_btime[type] = MAX_DQ_TIME; ump->um_itime[type] = MAX_IQ_TIME; if (dqget(NULLVP, 0, ump, type, &dq) == 0) { @@ -452,7 +452,7 @@ again: mtx_lock(&mntvnode_mtx); continue; } - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) { + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) { mtx_lock(&mntvnode_mtx); goto again; } @@ -467,7 +467,7 @@ again: mtx_unlock(&mntvnode_mtx); ump->um_qflags[type] &= ~QTF_OPENING; if (error) - quotaoff(p, mp, type); + quotaoff(td, mp, type); return (error); } @@ -475,8 +475,8 @@ again: * Q_QUOTAOFF - turn off disk quotas for a filesystem. */ int -quotaoff(p, mp, type) - struct proc *p; +quotaoff(td, mp, type) + struct thread *td; struct mount *mp; register int type; { @@ -508,7 +508,7 @@ again: mtx_lock(&mntvnode_mtx); continue; } - if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) { + if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) { mtx_lock(&mntvnode_mtx); goto again; } @@ -524,7 +524,7 @@ again: mtx_unlock(&mntvnode_mtx); dqflush(qvp); qvp->v_flag &= ~VSYSTEM; - error = vn_close(qvp, FREAD|FWRITE, p->p_ucred, p); + error = vn_close(qvp, FREAD|FWRITE, td->td_proc->p_ucred, td); ump->um_quotas[type] = NULLVP; crfree(ump->um_cred[type]); ump->um_cred[type] = NOCRED; @@ -675,7 +675,7 @@ qsync(mp) struct mount *mp; { struct ufsmount *ump = VFSTOUFS(mp); - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct vnode *vp, *nextvp; struct dquot *dq; int i, error; @@ -706,7 +706,7 @@ again: mtx_lock(&mntvnode_mtx); continue; } - error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, p); + error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, td); if (error) { mtx_lock(&mntvnode_mtx); if (error == ENOENT) @@ -765,7 +765,7 @@ dqget(vp, id, ump, type, dqp) register int type; struct dquot **dqp; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct dquot *dq; struct dqhash *dqh; struct vnode *dqvp; @@ -821,7 +821,7 @@ dqget(vp, id, ump, type, dqp) * Initialize the contents of the dquot structure. */ if (vp != dqvp) - vn_lock(dqvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dqvp, LK_EXCLUSIVE | LK_RETRY, td); LIST_INSERT_HEAD(dqh, dq, dq_hash); DQREF(dq); dq->dq_flags = DQ_LOCK; @@ -836,12 +836,12 @@ dqget(vp, id, ump, type, dqp) auio.uio_offset = (off_t)(id * sizeof (struct dqblk)); auio.uio_segflg = UIO_SYSSPACE; auio.uio_rw = UIO_READ; - auio.uio_procp = (struct proc *)0; + auio.uio_td = (struct thread *)0; error = VOP_READ(dqvp, &auio, 0, ump->um_cred[type]); if (auio.uio_resid == sizeof(struct dqblk) && error == 0) bzero((caddr_t)&dq->dq_dqb, sizeof(struct dqblk)); if (vp != dqvp) - VOP_UNLOCK(dqvp, 0, p); + VOP_UNLOCK(dqvp, 0, td); if (dq->dq_flags & DQ_WANT) wakeup((caddr_t)dq); dq->dq_flags = 0; @@ -915,7 +915,7 @@ dqsync(vp, dq) struct vnode *vp; struct dquot *dq; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ struct vnode *dqvp; struct iovec aiov; struct uio auio; @@ -929,13 +929,13 @@ dqsync(vp, dq) panic("dqsync: file"); (void) vn_write_suspend_wait(dqvp, NULL, V_WAIT); if (vp != dqvp) - vn_lock(dqvp, LK_EXCLUSIVE | LK_RETRY, p); + vn_lock(dqvp, LK_EXCLUSIVE | LK_RETRY, td); while (dq->dq_flags & DQ_LOCK) { dq->dq_flags |= DQ_WANT; (void) tsleep((caddr_t)dq, PINOD+2, "dqsync", 0); if ((dq->dq_flags & DQ_MOD) == 0) { if (vp != dqvp) - VOP_UNLOCK(dqvp, 0, p); + VOP_UNLOCK(dqvp, 0, td); return (0); } } @@ -948,7 +948,7 @@ dqsync(vp, dq) auio.uio_offset = (off_t)(dq->dq_id * sizeof (struct dqblk)); auio.uio_segflg = UIO_SYSSPACE; auio.uio_rw = UIO_WRITE; - auio.uio_procp = (struct proc *)0; + auio.uio_td = (struct thread *)0; error = VOP_WRITE(dqvp, &auio, 0, dq->dq_ump->um_cred[dq->dq_type]); if (auio.uio_resid && error == 0) error = EIO; @@ -956,7 +956,7 @@ dqsync(vp, dq) wakeup((caddr_t)dq); dq->dq_flags &= ~(DQ_MOD|DQ_LOCK|DQ_WANT); if (vp != dqvp) - VOP_UNLOCK(dqvp, 0, p); + VOP_UNLOCK(dqvp, 0, td); return (error); } diff --git a/sys/ufs/ufs/ufs_readwrite.c b/sys/ufs/ufs/ufs_readwrite.c index 0308895..83673eb 100644 --- a/sys/ufs/ufs/ufs_readwrite.c +++ b/sys/ufs/ufs/ufs_readwrite.c @@ -395,7 +395,7 @@ WRITE(ap) register struct inode *ip; register FS *fs; struct buf *bp; - struct proc *p; + struct thread *td; ufs_daddr_t lbn; off_t osize; int seqcount; @@ -456,13 +456,13 @@ WRITE(ap) * Maybe this should be above the vnode op call, but so long as * file servers have no limits, I don't think it matters. */ - p = uio->uio_procp; - if (vp->v_type == VREG && p && + td = uio->uio_td; + if (vp->v_type == VREG && td && uio->uio_offset + uio->uio_resid > - p->p_rlimit[RLIMIT_FSIZE].rlim_cur) { - PROC_LOCK(p); - psignal(p, SIGXFSZ); - PROC_UNLOCK(p); + td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) { + PROC_LOCK(td->td_proc); + psignal(td->td_proc, SIGXFSZ); + PROC_UNLOCK(td->td_proc); if (object) { vm_object_vndeallocate(object); } @@ -573,7 +573,7 @@ WRITE(ap) if (error) { if (ioflag & IO_UNIT) { (void)UFS_TRUNCATE(vp, osize, - ioflag & IO_SYNC, ap->a_cred, uio->uio_procp); + ioflag & IO_SYNC, ap->a_cred, uio->uio_td); uio->uio_offset -= resid - uio->uio_resid; uio->uio_resid = resid; } diff --git a/sys/ufs/ufs/ufs_vfsops.c b/sys/ufs/ufs/ufs_vfsops.c index 1fcd530..7b42452 100644 --- a/sys/ufs/ufs/ufs_vfsops.c +++ b/sys/ufs/ufs/ufs_vfsops.c @@ -64,10 +64,10 @@ MALLOC_DEFINE(M_UFSMNT, "UFS mount", "UFS mount structure"); */ /* ARGSUSED */ int -ufs_start(mp, flags, p) +ufs_start(mp, flags, td) struct mount *mp; int flags; - struct proc *p; + struct thread *td; { return (0); @@ -95,12 +95,12 @@ ufs_root(mp, vpp) * Do operations associated with quotas */ int -ufs_quotactl(mp, cmds, uid, arg, p) +ufs_quotactl(mp, cmds, uid, arg, td) struct mount *mp; int cmds; uid_t uid; caddr_t arg; - struct proc *p; + struct thread *td; { #ifndef QUOTA return (EOPNOTSUPP); @@ -108,35 +108,35 @@ ufs_quotactl(mp, cmds, uid, arg, p) int cmd, type, error; if (uid == -1) - uid = p->p_ucred->cr_ruid; + uid = td->td_proc->p_ucred->cr_ruid; cmd = cmds >> SUBCMDSHIFT; switch (cmd) { case Q_SYNC: break; case Q_GETQUOTA: - if (uid == p->p_ucred->cr_ruid) + if (uid == td->td_proc->p_ucred->cr_ruid) break; /* fall through */ default: - if ((error = suser_xxx(0, p, PRISON_ROOT)) != 0) + if ((error = suser_xxx(0, td->td_proc, PRISON_ROOT)) != 0) return (error); } type = cmds & SUBCMDMASK; if ((u_int)type >= MAXQUOTAS) return (EINVAL); - if (vfs_busy(mp, LK_NOWAIT, 0, p)) + if (vfs_busy(mp, LK_NOWAIT, 0, td)) return (0); switch (cmd) { case Q_QUOTAON: - error = quotaon(p, mp, type, arg); + error = quotaon(td, mp, type, arg); break; case Q_QUOTAOFF: - error = quotaoff(p, mp, type); + error = quotaoff(td, mp, type); break; case Q_SETQUOTA: @@ -159,7 +159,7 @@ ufs_quotactl(mp, cmds, uid, arg, p) error = EINVAL; break; } - vfs_unbusy(mp, p); + vfs_unbusy(mp, td); return (error); #endif } diff --git a/sys/ufs/ufs/ufs_vnops.c b/sys/ufs/ufs/ufs_vnops.c index e52bf93..c108c90 100644 --- a/sys/ufs/ufs/ufs_vnops.c +++ b/sys/ufs/ufs/ufs_vnops.c @@ -83,8 +83,8 @@ static int ufs_access __P((struct vop_access_args *)); static int ufs_advlock __P((struct vop_advlock_args *)); -static int ufs_chmod __P((struct vnode *, int, struct ucred *, struct proc *)); -static int ufs_chown __P((struct vnode *, uid_t, gid_t, struct ucred *, struct proc *)); +static int ufs_chmod __P((struct vnode *, int, struct ucred *, struct thread *)); +static int ufs_chown __P((struct vnode *, uid_t, gid_t, struct ucred *, struct thread *)); static int ufs_close __P((struct vop_close_args *)); static int ufs_create __P((struct vop_create_args *)); static int ufs_getattr __P((struct vop_getattr_args *)); @@ -267,7 +267,7 @@ ufs_open(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { @@ -292,7 +292,7 @@ ufs_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -332,7 +332,7 @@ ufs_access(ap) struct vnode *a_vp; int a_mode; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -373,7 +373,7 @@ ufs_access(ap) #ifdef UFS_ACL MALLOC(acl, struct acl *, sizeof(*acl), M_ACL, M_WAITOK); len = sizeof(*acl); - error = VOP_GETACL(vp, ACL_TYPE_ACCESS, acl, ap->a_cred, ap->a_p); + error = VOP_GETACL(vp, ACL_TYPE_ACCESS, acl, ap->a_cred, ap->a_td); switch (error) { case EOPNOTSUPP: error = vaccess(vp->v_type, ip->i_mode, ip->i_uid, ip->i_gid, @@ -408,7 +408,7 @@ ufs_getattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { register struct vnode *vp = ap->a_vp; @@ -452,14 +452,14 @@ ufs_setattr(ap) struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vattr *vap = ap->a_vap; struct vnode *vp = ap->a_vp; struct inode *ip = VTOI(vp); struct ucred *cred = ap->a_cred; - struct proc *p = ap->a_p; + struct thread *td = ap->a_td; int error; /* @@ -478,7 +478,7 @@ ufs_setattr(ap) * Callers may only modify the file flags on objects they * have VADMIN rights for. */ - if ((error = VOP_ACCESS(vp, VADMIN, cred, p))) + if ((error = VOP_ACCESS(vp, VADMIN, cred, td))) return (error); /* * Unprivileged processes and privileged processes in @@ -519,7 +519,7 @@ ufs_setattr(ap) if (vp->v_mount->mnt_flag & MNT_RDONLY) return (EROFS); if ((error = ufs_chown(vp, vap->va_uid, vap->va_gid, cred, - p)) != 0) + td)) != 0) return (error); } if (vap->va_size != VNOVAL) { @@ -541,7 +541,7 @@ ufs_setattr(ap) default: break; } - if ((error = UFS_TRUNCATE(vp, vap->va_size, 0, cred, p)) != 0) + if ((error = UFS_TRUNCATE(vp, vap->va_size, 0, cred, td)) != 0) return (error); } if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) { @@ -557,9 +557,9 @@ ufs_setattr(ap) * If times is non-NULL, ... The caller must be the owner of * the file or be the super-user. */ - if ((error = VOP_ACCESS(vp, VADMIN, cred, p)) && + if ((error = VOP_ACCESS(vp, VADMIN, cred, td)) && ((vap->va_vaflags & VA_UTIMES_NULL) == 0 || - (error = VOP_ACCESS(vp, VWRITE, cred, p)))) + (error = VOP_ACCESS(vp, VWRITE, cred, td)))) return (error); if (vap->va_atime.tv_sec != VNOVAL) ip->i_flag |= IN_ACCESS; @@ -585,7 +585,7 @@ ufs_setattr(ap) if ((ip->i_flags & SF_SNAPSHOT) != 0 && (vap->va_mode & (S_IXUSR | S_IWUSR | S_IXGRP | S_IWGRP | S_IXOTH | S_IWOTH))) return (EPERM); - error = ufs_chmod(vp, (int)vap->va_mode, cred, p); + error = ufs_chmod(vp, (int)vap->va_mode, cred, td); } VN_KNOTE(vp, NOTE_ATTRIB); return (error); @@ -596,11 +596,11 @@ ufs_setattr(ap) * Inode must be locked before calling. */ static int -ufs_chmod(vp, mode, cred, p) +ufs_chmod(vp, mode, cred, td) register struct vnode *vp; register int mode; register struct ucred *cred; - struct proc *p; + struct thread *td; { register struct inode *ip = VTOI(vp); int error; @@ -609,7 +609,7 @@ ufs_chmod(vp, mode, cred, p) * To modify the permissions on a file, must possess VADMIN * for that file. */ - if ((error = VOP_ACCESS(vp, VADMIN, cred, p))) + if ((error = VOP_ACCESS(vp, VADMIN, cred, td))) return (error); /* * Privileged processes may set the sticky bit on non-directories, @@ -633,12 +633,12 @@ ufs_chmod(vp, mode, cred, p) * inode must be locked prior to call. */ static int -ufs_chown(vp, uid, gid, cred, p) +ufs_chown(vp, uid, gid, cred, td) register struct vnode *vp; uid_t uid; gid_t gid; struct ucred *cred; - struct proc *p; + struct thread *td; { register struct inode *ip = VTOI(vp); uid_t ouid; @@ -657,7 +657,7 @@ ufs_chown(vp, uid, gid, cred, p) * To modify the ownership of a file, must possess VADMIN * for that file. */ - if ((error = VOP_ACCESS(vp, VADMIN, cred, p))) + if ((error = VOP_ACCESS(vp, VADMIN, cred, td))) return (error); /* * To change the owner of a file, or change the group of a file @@ -666,7 +666,7 @@ ufs_chown(vp, uid, gid, cred, p) */ if ((uid != ip->i_uid || (gid != ip->i_gid && !groupmember(gid, cred))) && - (error = suser_xxx(cred, p, PRISON_ROOT))) + (error = suser_xxx(cred, td->td_proc, PRISON_ROOT))) return (error); ogid = ip->i_gid; ouid = ip->i_uid; @@ -780,7 +780,7 @@ ufs_link(ap) struct vnode *vp = ap->a_vp; struct vnode *tdvp = ap->a_tdvp; struct componentname *cnp = ap->a_cnp; - struct proc *p = cnp->cn_proc; + struct thread *td = cnp->cn_thread; struct inode *ip; struct direct newdir; int error; @@ -793,7 +793,7 @@ ufs_link(ap) error = EXDEV; goto out2; } - if (tdvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE, p))) { + if (tdvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE, td))) { goto out2; } ip = VTOI(vp); @@ -825,7 +825,7 @@ ufs_link(ap) } out1: if (tdvp != vp) - VOP_UNLOCK(vp, 0, p); + VOP_UNLOCK(vp, 0, td); out2: VN_KNOTE(vp, NOTE_LINK); VN_KNOTE(tdvp, NOTE_WRITE); @@ -928,7 +928,7 @@ ufs_rename(ap) struct vnode *fdvp = ap->a_fdvp; struct componentname *tcnp = ap->a_tcnp; struct componentname *fcnp = ap->a_fcnp; - struct proc *p = fcnp->cn_proc; + struct thread *td = fcnp->cn_thread; struct inode *ip, *xp, *dp; struct direct newdir; int doingdirectory = 0, oldparent = 0, newparent = 0; @@ -1019,18 +1019,18 @@ abortit: vput(fvp); return (error); } - if ((error = vn_lock(fvp, LK_EXCLUSIVE, p)) != 0) + if ((error = vn_lock(fvp, LK_EXCLUSIVE, td)) != 0) goto abortit; dp = VTOI(fdvp); ip = VTOI(fvp); if (ip->i_nlink >= LINK_MAX) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); error = EMLINK; goto abortit; } if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) || (dp->i_flags & APPEND)) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); error = EPERM; goto abortit; } @@ -1041,7 +1041,7 @@ abortit: if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') || dp == ip || (fcnp->cn_flags | tcnp->cn_flags) & ISDOTDOT || (ip->i_flag & IN_RENAME)) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); error = EINVAL; goto abortit; } @@ -1074,7 +1074,7 @@ abortit: softdep_change_linkcnt(ip); if ((error = UFS_UPDATE(fvp, !(DOINGSOFTDEP(fvp) | DOINGASYNC(fvp)))) != 0) { - VOP_UNLOCK(fvp, 0, p); + VOP_UNLOCK(fvp, 0, td); goto bad; } @@ -1088,8 +1088,8 @@ abortit: * to namei, as the parent directory is unlocked by the * call to checkpath(). */ - error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc); - VOP_UNLOCK(fvp, 0, p); + error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_thread); + VOP_UNLOCK(fvp, 0, td); if (oldparent != dp->i_number) newparent = dp->i_number; if (doingdirectory && newparent) { @@ -1172,8 +1172,8 @@ abortit: * directories. */ if ((dp->i_mode & S_ISTXT) && - VOP_ACCESS(tdvp, VADMIN, tcnp->cn_cred, p) && - VOP_ACCESS(tvp, VADMIN, tcnp->cn_cred, p)) { + VOP_ACCESS(tdvp, VADMIN, tcnp->cn_cred, td) && + VOP_ACCESS(tvp, VADMIN, tcnp->cn_cred, td)) { error = EPERM; goto bad; } @@ -1232,7 +1232,7 @@ abortit: xp->i_flag |= IN_CHANGE; ioflag = DOINGASYNC(tvp) ? 0 : IO_SYNC; if ((error = UFS_TRUNCATE(tvp, (off_t)0, ioflag, - tcnp->cn_cred, tcnp->cn_proc)) != 0) + tcnp->cn_cred, tcnp->cn_thread)) != 0) goto bad; } VN_KNOTE(tdvp, NOTE_WRITE); @@ -1307,7 +1307,7 @@ bad: out: if (doingdirectory) ip->i_flag &= ~IN_RENAME; - if (vn_lock(fvp, LK_EXCLUSIVE, p) == 0) { + if (vn_lock(fvp, LK_EXCLUSIVE, td) == 0) { ip->i_effnlink--; ip->i_nlink--; ip->i_flag |= IN_CHANGE; @@ -1432,7 +1432,7 @@ ufs_mkdir(ap) * Retrieve default ACL from parent, if any. */ error = VOP_GETACL(dvp, ACL_TYPE_DEFAULT, acl, cnp->cn_cred, - cnp->cn_proc); + cnp->cn_thread); switch (error) { case 0: /* @@ -1500,10 +1500,10 @@ ufs_mkdir(ap) * code that the EAs for the file need to be released? */ error = VOP_SETACL(tvp, ACL_TYPE_ACCESS, acl, cnp->cn_cred, - cnp->cn_proc); + cnp->cn_thread); if (error == 0) error = VOP_SETACL(tvp, ACL_TYPE_DEFAULT, dacl, - cnp->cn_cred, cnp->cn_proc); + cnp->cn_cred, cnp->cn_thread); switch (error) { case 0: break; @@ -1693,7 +1693,7 @@ ufs_rmdir(ap) ip->i_flag |= IN_CHANGE; ioflag = DOINGASYNC(vp) ? 0 : IO_SYNC; error = UFS_TRUNCATE(vp, (off_t)0, ioflag, cnp->cn_cred, - cnp->cn_proc); + cnp->cn_thread); } cache_purge(vp); #ifdef UFS_DIRHASH @@ -1738,7 +1738,7 @@ ufs_symlink(ap) } else error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0, UIO_SYSSPACE, IO_NODELOCKED, ap->a_cnp->cn_cred, (int *)0, - (struct proc *)0); + (struct thread *)0); if (error) vput(vp); return (error); @@ -2014,7 +2014,7 @@ ufsspec_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -2088,7 +2088,7 @@ ufsfifo_close(ap) struct vnode *a_vp; int a_fflag; struct ucred *a_cred; - struct proc *a_p; + struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; @@ -2310,7 +2310,7 @@ ufs_makeinode(mode, dvp, vpp, cnp) * Retrieve default ACL for parent, if any. */ error = VOP_GETACL(dvp, ACL_TYPE_DEFAULT, acl, cnp->cn_cred, - cnp->cn_proc); + cnp->cn_thread); switch (error) { case 0: /* @@ -2372,7 +2372,7 @@ ufs_makeinode(mode, dvp, vpp, cnp) * code that the EAs for the file need to be released? */ error = VOP_SETACL(tvp, ACL_TYPE_ACCESS, acl, cnp->cn_cred, - cnp->cn_proc); + cnp->cn_thread); switch (error) { case 0: break; diff --git a/sys/ufs/ufs/ufsmount.h b/sys/ufs/ufs/ufsmount.h index 4c73aa3..85c9866 100644 --- a/sys/ufs/ufs/ufsmount.h +++ b/sys/ufs/ufs/ufsmount.h @@ -88,7 +88,7 @@ struct ufsmount { int um_i_effnlink_valid; /* i_effnlink valid? */ int (*um_balloc) __P((struct vnode *, off_t, int, struct ucred *, int, struct buf **)); int (*um_blkatoff) __P((struct vnode *, off_t, char **, struct buf **)); - int (*um_truncate) __P((struct vnode *, off_t, int, struct ucred *, struct proc *)); + int (*um_truncate) __P((struct vnode *, off_t, int, struct ucred *, struct thread *)); int (*um_update) __P((struct vnode *, int)); int (*um_valloc) __P((struct vnode *, int, struct ucred *, struct vnode **)); int (*um_vfree) __P((struct vnode *, ino_t, int)); diff --git a/sys/vm/pmap.h b/sys/vm/pmap.h index 4ff3321..89432aa 100644 --- a/sys/vm/pmap.h +++ b/sys/vm/pmap.h @@ -89,6 +89,7 @@ typedef struct pmap_statistics *pmap_statistics_t; #ifdef _KERNEL struct proc; +struct thread; #ifdef __alpha__ void pmap_page_is_free __P((vm_page_t m)); @@ -138,7 +139,11 @@ void pmap_new_proc __P((struct proc *p)); void pmap_dispose_proc __P((struct proc *p)); void pmap_swapout_proc __P((struct proc *p)); void pmap_swapin_proc __P((struct proc *p)); -void pmap_activate __P((struct proc *p)); +void pmap_new_thread __P((struct thread *td)); +void pmap_dispose_thread __P((struct thread *td)); +void pmap_swapout_thread __P((struct thread *td)); +void pmap_swapin_thread __P((struct thread *td)); +void pmap_activate __P((struct thread *td)); vm_offset_t pmap_addr_hint __P((vm_object_t obj, vm_offset_t addr, vm_size_t size)); void *pmap_kenter_temporary __P((vm_offset_t pa, int i)); void pmap_init2 __P((void)); diff --git a/sys/vm/vm_contig.c b/sys/vm/vm_contig.c index 50534db..b515e85 100644 --- a/sys/vm/vm_contig.c +++ b/sys/vm/vm_contig.c @@ -152,9 +152,9 @@ again1: vm_page_test_dirty(m); if (m->dirty) { if (m->object->type == OBJT_VNODE) { - vn_lock(m->object->handle, LK_EXCLUSIVE | LK_RETRY, curproc); + vn_lock(m->object->handle, LK_EXCLUSIVE | LK_RETRY, curthread); vm_object_page_clean(m->object, 0, 0, OBJPC_SYNC); - VOP_UNLOCK(m->object->handle, 0, curproc); + VOP_UNLOCK(m->object->handle, 0, curthread); goto again1; } else if (m->object->type == OBJT_SWAP || m->object->type == OBJT_DEFAULT) { @@ -179,9 +179,9 @@ again1: vm_page_test_dirty(m); if (m->dirty) { if (m->object->type == OBJT_VNODE) { - vn_lock(m->object->handle, LK_EXCLUSIVE | LK_RETRY, curproc); + vn_lock(m->object->handle, LK_EXCLUSIVE | LK_RETRY, curthread); vm_object_page_clean(m->object, 0, 0, OBJPC_SYNC); - VOP_UNLOCK(m->object->handle, 0, curproc); + VOP_UNLOCK(m->object->handle, 0, curthread); goto again1; } else if (m->object->type == OBJT_SWAP || m->object->type == OBJT_DEFAULT) { diff --git a/sys/vm/vm_extern.h b/sys/vm/vm_extern.h index 9ff0191..79bd5d8 100644 --- a/sys/vm/vm_extern.h +++ b/sys/vm/vm_extern.h @@ -47,16 +47,16 @@ struct vnode; #ifdef _KERNEL #ifdef TYPEDEF_FOR_UAP -int getpagesize __P((struct proc * p, void *, int *)); -int madvise __P((struct proc *, void *, int *)); -int mincore __P((struct proc *, void *, int *)); -int mprotect __P((struct proc *, void *, int *)); -int msync __P((struct proc *, void *, int *)); -int munmap __P((struct proc *, void *, int *)); -int obreak __P((struct proc *, void *, int *)); -int sbrk __P((struct proc *, void *, int *)); -int sstk __P((struct proc *, void *, int *)); -int swapon __P((struct proc *, void *, int *)); +int getpagesize __P((struct thread *, void *, int *)); +int madvise __P((struct thread *, void *, int *)); +int mincore __P((struct thread *, void *, int *)); +int mprotect __P((struct thread *, void *, int *)); +int msync __P((struct thread *, void *, int *)); +int munmap __P((struct thread *, void *, int *)); +int obreak __P((struct thread *, void *, int *)); +int sbrk __P((struct thread *, void *, int *)); +int sstk __P((struct thread *, void *, int *)); +int swapon __P((struct thread *, void *, int *)); #endif int grow __P((struct proc *, size_t)); @@ -71,8 +71,8 @@ void kmem_free_wakeup __P((vm_map_t, vm_offset_t, vm_size_t)); void kmem_init __P((vm_offset_t, vm_offset_t)); vm_offset_t kmem_malloc __P((vm_map_t, vm_size_t, boolean_t)); vm_map_t kmem_suballoc __P((vm_map_t, vm_offset_t *, vm_offset_t *, vm_size_t)); -void munmapfd __P((struct proc *, int)); -int swaponvp __P((struct proc *, struct vnode *, dev_t , u_long)); +void munmapfd __P((struct thread *, int)); +int swaponvp __P((struct thread *, struct vnode *, dev_t , u_long)); void swapout_procs __P((int)); int useracc __P((caddr_t, int, int)); int vm_fault __P((vm_map_t, vm_offset_t, vm_prot_t, int)); @@ -80,7 +80,7 @@ void vm_fault_copy_entry __P((vm_map_t, vm_map_t, vm_map_entry_t, vm_map_entry_t void vm_fault_unwire __P((vm_map_t, vm_offset_t, vm_offset_t)); int vm_fault_wire __P((vm_map_t, vm_offset_t, vm_offset_t)); int vm_fault_user_wire __P((vm_map_t, vm_offset_t, vm_offset_t)); -void vm_forkproc __P((struct proc *, struct proc *, int)); +void vm_forkproc __P((struct thread *, struct proc *, int)); void vm_waitproc __P((struct proc *)); int vm_mmap __P((vm_map_t, vm_offset_t *, vm_size_t, vm_prot_t, vm_prot_t, int, void *, vm_ooffset_t)); vm_offset_t vm_page_alloc_contig __P((vm_offset_t, vm_offset_t, vm_offset_t, vm_offset_t)); diff --git a/sys/vm/vm_fault.c b/sys/vm/vm_fault.c index c098088..3507353 100644 --- a/sys/vm/vm_fault.c +++ b/sys/vm/vm_fault.c @@ -666,7 +666,7 @@ readrest: * grab the lock if we need to */ (fs.lookup_still_valid || - lockmgr(&fs.map->lock, LK_EXCLUSIVE|LK_NOWAIT, (void *)0, curproc) == 0) + lockmgr(&fs.map->lock, LK_EXCLUSIVE|LK_NOWAIT, (void *)0, curthread) == 0) ) { fs.lookup_still_valid = 1; diff --git a/sys/vm/vm_glue.c b/sys/vm/vm_glue.c index 5638175..d239516 100644 --- a/sys/vm/vm_glue.c +++ b/sys/vm/vm_glue.c @@ -209,10 +209,12 @@ vsunlock(addr, len) * to user mode to avoid stack copying and relocation problems. */ void -vm_forkproc(p1, p2, flags) - struct proc *p1, *p2; +vm_forkproc(td, p2, flags) + struct thread *td; + struct proc *p2; int flags; { + struct proc *p1 = td->td_proc; struct user *up; GIANT_REQUIRED; @@ -228,7 +230,7 @@ vm_forkproc(p1, p2, flags) vmspace_unshare(p1); } } - cpu_fork(p1, p2, flags); + cpu_fork(td, p2, flags); return; } @@ -251,8 +253,10 @@ vm_forkproc(p1, p2, flags) } pmap_new_proc(p2); + pmap_new_thread(&p2->p_thread); /* Initial thread */ - up = p2->p_addr; + /* XXXKSE this is unsatisfactory but should be adequate */ + up = p2->p_uarea; /* * p_stats currently points at fields in the user struct @@ -282,7 +286,7 @@ vm_forkproc(p1, p2, flags) * cpu_fork will copy and update the pcb, set up the kernel stack, * and make the child ready to run. */ - cpu_fork(p1, p2, flags); + cpu_fork(td, p2, flags); } /* @@ -294,10 +298,13 @@ void vm_waitproc(p) struct proc *p; { + struct thread *td; GIANT_REQUIRED; cpu_wait(p); pmap_dispose_proc(p); /* drop per-process resources */ + FOREACH_THREAD_IN_PROC(p, td) + pmap_dispose_thread(td); vmspace_free(p->p_vmspace); /* and clean-out the vmspace */ } @@ -338,6 +345,7 @@ void faultin(p) struct proc *p; { + struct thread *td; GIANT_REQUIRED; PROC_LOCK_ASSERT(p, MA_OWNED); @@ -348,12 +356,14 @@ faultin(p) PROC_UNLOCK(p); pmap_swapin_proc(p); + FOREACH_THREAD_IN_PROC (p, td) + pmap_swapin_thread(td); PROC_LOCK(p); mtx_lock_spin(&sched_lock); - if (p->p_stat == SRUN) { - setrunqueue(p); - } + FOREACH_THREAD_IN_PROC (p, td) + if (td->td_proc->p_stat == SRUN) /* XXXKSE */ + setrunqueue(td); p->p_sflag |= PS_INMEM; @@ -368,6 +378,8 @@ faultin(p) * is enough space for them. Of course, if a process waits for a long * time, it will be swapped in anyway. * + * XXXKSE - KSEGRP with highest priority counts.. + * * Giant is still held at this point, to be released in tsleep. */ /* ARGSUSED*/ @@ -392,24 +404,29 @@ loop: pp = NULL; ppri = INT_MIN; sx_slock(&allproc_lock); - LIST_FOREACH(p, &allproc, p_list) { + FOREACH_PROC_IN_SYSTEM(p) { + struct ksegrp *kg; mtx_lock_spin(&sched_lock); - if (p->p_stat == SRUN && - (p->p_sflag & (PS_INMEM | PS_SWAPPING)) == 0) { - - pri = p->p_swtime + p->p_slptime; - if ((p->p_sflag & PS_SWAPINREQ) == 0) { - pri -= p->p_nice * 8; - } - - /* - * if this process is higher priority and there is - * enough space, then select this process instead of - * the previous selection. - */ - if (pri > ppri) { - pp = p; - ppri = pri; + if (p->p_stat == SRUN + && (p->p_sflag & (PS_INMEM | PS_SWAPPING)) == 0) { + /* Find the minimum sleeptime for the process */ + FOREACH_KSEGRP_IN_PROC(p, kg) { + pri = p->p_swtime + kg->kg_slptime; + if ((p->p_sflag & PS_SWAPINREQ) == 0) { + pri -= kg->kg_nice * 8; + } + + + /* + * if this ksegrp is higher priority + * and there is enough space, then select + * this process instead of the previous + * selection. + */ + if (pri > ppri) { + pp = p; + ppri = pri; + } } } mtx_unlock_spin(&sched_lock); @@ -469,6 +486,7 @@ swapout_procs(action) int action; { struct proc *p; + struct ksegrp *kg; struct proc *outp, *outp2; int outpri, outpri2; int didswap = 0; @@ -481,6 +499,7 @@ retry: sx_slock(&allproc_lock); LIST_FOREACH(p, &allproc, p_list) { struct vmspace *vm; + int minslptime = 100000; PROC_LOCK(p); if (p->p_lock != 0 || @@ -511,50 +530,59 @@ retry: case SSTOP: /* * do not swapout a realtime process + * Check all the thread groups.. */ - if (PRI_IS_REALTIME(p->p_pri.pri_class)) { - mtx_unlock_spin(&sched_lock); - PROC_UNLOCK(p); - continue; + FOREACH_KSEGRP_IN_PROC(p, kg) { + if (PRI_IS_REALTIME(kg->kg_pri.pri_class)) { + mtx_unlock_spin(&sched_lock); + PROC_UNLOCK(p); + goto nextproc; + } + + /* + * Do not swapout a process waiting + * on a critical event of some kind. + * Also guarantee swap_idle_threshold1 + * time in memory. + */ + if (((kg->kg_pri.pri_level) < PSOCK) || + (kg->kg_slptime < swap_idle_threshold1)) { + mtx_unlock_spin(&sched_lock); + PROC_UNLOCK(p); + goto nextproc; + } + + /* + * If the system is under memory stress, + * or if we are swapping + * idle processes >= swap_idle_threshold2, + * then swap the process out. + */ + if (((action & VM_SWAP_NORMAL) == 0) && + (((action & VM_SWAP_IDLE) == 0) || + (kg->kg_slptime < swap_idle_threshold2))) { + mtx_unlock_spin(&sched_lock); + PROC_UNLOCK(p); + goto nextproc; + } + if (minslptime > kg->kg_slptime) + minslptime = kg->kg_slptime; } - /* - * Do not swapout a process waiting on a critical - * event of some kind. Also guarantee swap_idle_threshold1 - * time in memory. - */ - if (((p->p_pri.pri_level) < PSOCK) || - (p->p_slptime < swap_idle_threshold1)) { - mtx_unlock_spin(&sched_lock); - PROC_UNLOCK(p); - continue; - } - - /* - * If the system is under memory stress, or if we are swapping - * idle processes >= swap_idle_threshold2, then swap the process - * out. - */ - if (((action & VM_SWAP_NORMAL) == 0) && - (((action & VM_SWAP_IDLE) == 0) || - (p->p_slptime < swap_idle_threshold2))) { - mtx_unlock_spin(&sched_lock); - PROC_UNLOCK(p); - continue; - } mtx_unlock_spin(&sched_lock); - ++vm->vm_refcnt; /* - * do not swapout a process that is waiting for VM - * data structures there is a possible deadlock. + * do not swapout a process that + * is waiting for VM + * data structures there is a + * possible deadlock. */ if (lockmgr(&vm->vm_map.lock, LK_EXCLUSIVE | LK_NOWAIT, - NULL, curproc)) { + NULL, curthread)) { vmspace_free(vm); PROC_UNLOCK(p); - continue; + goto nextproc; } vm_map_unlock(&vm->vm_map); /* @@ -563,7 +591,7 @@ retry: */ if ((action & VM_SWAP_NORMAL) || ((action & VM_SWAP_IDLE) && - (p->p_slptime > swap_idle_threshold2))) { + (minslptime > swap_idle_threshold2))) { sx_sunlock(&allproc_lock); swapout(p); vmspace_free(vm); @@ -573,6 +601,7 @@ retry: PROC_UNLOCK(p); vmspace_free(vm); } +nextproc: } sx_sunlock(&allproc_lock); /* @@ -587,6 +616,7 @@ static void swapout(p) struct proc *p; { + struct thread *td; PROC_LOCK_ASSERT(p, MA_OWNED); #if defined(SWAP_DEBUG) @@ -602,11 +632,14 @@ swapout(p) p->p_sflag &= ~PS_INMEM; p->p_sflag |= PS_SWAPPING; PROC_UNLOCK_NOSWITCH(p); - if (p->p_stat == SRUN) - remrunqueue(p); + FOREACH_THREAD_IN_PROC (p, td) + if (td->td_proc->p_stat == SRUN) /* XXXKSE */ + remrunqueue(td); /* XXXKSE */ mtx_unlock_spin(&sched_lock); pmap_swapout_proc(p); + FOREACH_THREAD_IN_PROC(p, td) + pmap_swapout_thread(td); mtx_lock_spin(&sched_lock); p->p_sflag &= ~PS_SWAPPING; diff --git a/sys/vm/vm_map.c b/sys/vm/vm_map.c index 72c0a06..e7a4898 100644 --- a/sys/vm/vm_map.c +++ b/sys/vm/vm_map.c @@ -266,7 +266,7 @@ void vm_map_lock(vm_map_t map) { vm_map_printf("locking map LK_EXCLUSIVE: %p\n", map); - if (lockmgr(&map->lock, LK_EXCLUSIVE, NULL, curproc) != 0) + if (lockmgr(&map->lock, LK_EXCLUSIVE, NULL, curthread) != 0) panic("vm_map_lock: failed to get lock"); map->timestamp++; } @@ -275,29 +275,29 @@ void vm_map_unlock(vm_map_t map) { vm_map_printf("locking map LK_RELEASE: %p\n", map); - lockmgr(&(map)->lock, LK_RELEASE, NULL, curproc); + lockmgr(&(map)->lock, LK_RELEASE, NULL, curthread); } void vm_map_lock_read(vm_map_t map) { vm_map_printf("locking map LK_SHARED: %p\n", map); - lockmgr(&(map)->lock, LK_SHARED, NULL, curproc); + lockmgr(&(map)->lock, LK_SHARED, NULL, curthread); } void vm_map_unlock_read(vm_map_t map) { vm_map_printf("locking map LK_RELEASE: %p\n", map); - lockmgr(&(map)->lock, LK_RELEASE, NULL, curproc); + lockmgr(&(map)->lock, LK_RELEASE, NULL, curthread); } static __inline__ int -_vm_map_lock_upgrade(vm_map_t map, struct proc *p) { +_vm_map_lock_upgrade(vm_map_t map, struct thread *td) { int error; vm_map_printf("locking map LK_EXCLUPGRADE: %p\n", map); - error = lockmgr(&map->lock, LK_EXCLUPGRADE, NULL, p); + error = lockmgr(&map->lock, LK_EXCLUPGRADE, NULL, td); if (error == 0) map->timestamp++; return error; @@ -306,14 +306,14 @@ _vm_map_lock_upgrade(vm_map_t map, struct proc *p) { int vm_map_lock_upgrade(vm_map_t map) { - return(_vm_map_lock_upgrade(map, curproc)); + return(_vm_map_lock_upgrade(map, curthread)); } void vm_map_lock_downgrade(vm_map_t map) { vm_map_printf("locking map LK_DOWNGRADE: %p\n", map); - lockmgr(&map->lock, LK_DOWNGRADE, NULL, curproc); + lockmgr(&map->lock, LK_DOWNGRADE, NULL, curthread); } void @@ -1863,7 +1863,7 @@ vm_map_clean( int flags; vm_object_reference(object); - vn_lock(object->handle, LK_EXCLUSIVE | LK_RETRY, curproc); + vn_lock(object->handle, LK_EXCLUSIVE | LK_RETRY, curthread); flags = (syncio || invalidate) ? OBJPC_SYNC : 0; flags |= invalidate ? OBJPC_INVAL : 0; vm_object_page_clean(object, @@ -1877,7 +1877,7 @@ vm_map_clean( OFF_TO_IDX(offset + size + PAGE_MASK), FALSE); } - VOP_UNLOCK(object->handle, 0, curproc); + VOP_UNLOCK(object->handle, 0, curthread); vm_object_deallocate(object); } start += size; @@ -2619,8 +2619,8 @@ vmspace_exec(struct proc *p) p->p_vmspace = newvmspace; pmap_pinit2(vmspace_pmap(newvmspace)); vmspace_free(oldvmspace); - if (p == curproc) - pmap_activate(p); + if (p == curthread->td_proc) /* XXXKSE ? */ + pmap_activate(curthread); } /* @@ -2641,8 +2641,8 @@ vmspace_unshare(struct proc *p) p->p_vmspace = newvmspace; pmap_pinit2(vmspace_pmap(newvmspace)); vmspace_free(oldvmspace); - if (p == curproc) - pmap_activate(p); + if (p == curthread->td_proc) /* XXXKSE ? */ + pmap_activate(curthread); } diff --git a/sys/vm/vm_map.h b/sys/vm/vm_map.h index 8839cd8..3776a6e 100644 --- a/sys/vm/vm_map.h +++ b/sys/vm/vm_map.h @@ -210,7 +210,7 @@ void vm_map_entry_set_behavior(struct vm_map_entry *entry, u_char behavior); #define vm_map_lock_drain_interlock(map) \ do { \ lockmgr(&(map)->lock, LK_DRAIN|LK_INTERLOCK, \ - &(map)->ref_lock, curproc); \ + &(map)->ref_lock, curthread); \ (map)->timestamp++; \ } while(0) #endif diff --git a/sys/vm/vm_meter.c b/sys/vm/vm_meter.c index 20346fa..c3697be 100644 --- a/sys/vm/vm_meter.c +++ b/sys/vm/vm_meter.c @@ -73,27 +73,34 @@ static fixpt_t cexp[3] = { /* * Compute a tenex style load average of a quantity on * 1, 5 and 15 minute intervals. + * XXXKSE Needs complete rewrite when correct info is available. + * Completely Bogus.. only works with 1:1 (but compiles ok now :-) */ static void loadav(struct loadavg *avg) { int i, nrun; struct proc *p; + struct ksegrp *kg; sx_slock(&allproc_lock); - for (nrun = 0, p = LIST_FIRST(&allproc); p != 0; p = LIST_NEXT(p, p_list)) { - switch (p->p_stat) { - case SSLEEP: - if (p->p_pri.pri_level > PZERO || - p->p_slptime != 0) - continue; - /* FALLTHROUGH */ - case SRUN: - if ((p->p_flag & P_NOLOAD) != 0) - continue; - /* FALLTHROUGH */ - case SIDL: - nrun++; + nrun = 0; + FOREACH_PROC_IN_SYSTEM(p) { + FOREACH_KSEGRP_IN_PROC(p, kg) { + switch (p->p_stat) { + case SSLEEP: + if (kg->kg_pri.pri_level > PZERO || + kg->kg_slptime != 0) /* ke? */ + goto nextproc; + /* FALLTHROUGH */ + case SRUN: + if ((p->p_flag & P_NOLOAD) != 0) + goto nextproc; + /* FALLTHROUGH */ + case SIDL: + nrun++; + } +nextproc: } } sx_sunlock(&allproc_lock); @@ -139,6 +146,7 @@ vmtotal(SYSCTL_HANDLER_ARGS) vm_object_t object; vm_map_t map; int paging; + struct ksegrp *kg; totalp = &total; bzero(totalp, sizeof *totalp); @@ -152,7 +160,7 @@ vmtotal(SYSCTL_HANDLER_ARGS) * Calculate process statistics. */ sx_slock(&allproc_lock); - LIST_FOREACH(p, &allproc, p_list) { + FOREACH_PROC_IN_SYSTEM(p) { if (p->p_flag & P_SYSTEM) continue; mtx_lock_spin(&sched_lock); @@ -164,14 +172,15 @@ vmtotal(SYSCTL_HANDLER_ARGS) case SMTX: case SSLEEP: case SSTOP: + kg = &p->p_ksegrp; /* XXXKSE */ if (p->p_sflag & PS_INMEM) { - if (p->p_pri.pri_level <= PZERO) + if (kg->kg_pri.pri_level <= PZERO) totalp->t_dw++; - else if (p->p_slptime < maxslp) + else if (kg->kg_slptime < maxslp) totalp->t_sl++; - } else if (p->p_slptime < maxslp) + } else if (kg->kg_slptime < maxslp) totalp->t_sw++; - if (p->p_slptime >= maxslp) { + if (kg->kg_slptime >= maxslp) { mtx_unlock_spin(&sched_lock); continue; } diff --git a/sys/vm/vm_mmap.c b/sys/vm/vm_mmap.c index 17fd7f2..0336529 100644 --- a/sys/vm/vm_mmap.c +++ b/sys/vm/vm_mmap.c @@ -112,8 +112,8 @@ vmmapentry_rsrc_init(dummy) */ /* ARGSUSED */ int -sbrk(p, uap) - struct proc *p; +sbrk(td, uap) + struct thread *td; struct sbrk_args *uap; { /* Not yet implemented */ @@ -133,8 +133,8 @@ struct sstk_args { */ /* ARGSUSED */ int -sstk(p, uap) - struct proc *p; +sstk(td, uap) + struct thread *td; struct sstk_args *uap; { /* Not yet implemented */ @@ -152,12 +152,12 @@ struct getpagesize_args { /* ARGSUSED */ int -ogetpagesize(p, uap) - struct proc *p; +ogetpagesize(td, uap) + struct thread *td; struct getpagesize_args *uap; { /* MP SAFE */ - p->p_retval[0] = PAGE_SIZE; + td->td_retval[0] = PAGE_SIZE; return (0); } #endif /* COMPAT_43 || COMPAT_SUNOS */ @@ -196,11 +196,11 @@ struct mmap_args { * MPSAFE */ int -mmap(p, uap) - struct proc *p; +mmap(td, uap) + struct thread *td; struct mmap_args *uap; { - struct filedesc *fdp = p->p_fd; + struct filedesc *fdp = td->td_proc->p_fd; struct file *fp = NULL; struct vnode *vp; vm_offset_t addr; @@ -210,7 +210,7 @@ mmap(p, uap) int flags, error; int disablexworkaround; off_t pos; - struct vmspace *vms = p->p_vmspace; + struct vmspace *vms = td->td_proc->p_vmspace; vm_object_t obj; addr = (vm_offset_t) uap->addr; @@ -358,7 +358,7 @@ mmap(p, uap) if (securelevel >= 1) disablexworkaround = 1; else - disablexworkaround = suser(p); + disablexworkaround = suser_td(td); if (vp->v_type == VCHR && disablexworkaround && (flags & (MAP_PRIVATE|MAP_COPY))) { error = EINVAL; @@ -396,7 +396,7 @@ mmap(p, uap) struct vattr va; if ((error = VOP_GETATTR(vp, &va, - p->p_ucred, p))) { + td->td_proc->p_ucred, td))) { goto done; } if ((va.va_flags & @@ -433,11 +433,11 @@ mmap(p, uap) error = vm_mmap(&vms->vm_map, &addr, size, prot, maxprot, flags, handle, pos); if (error == 0) - p->p_retval[0] = (register_t) (addr + pageoff); + td->td_retval[0] = (register_t) (addr + pageoff); mtx_lock(&Giant); done: if (fp) - fdrop(fp, p); + fdrop(fp, td); done2: mtx_unlock(&Giant); return (error); @@ -455,8 +455,8 @@ struct ommap_args { }; #endif int -ommap(p, uap) - struct proc *p; +ommap(td, uap) + struct thread *td; struct ommap_args *uap; { struct mmap_args nargs; @@ -492,7 +492,7 @@ ommap(p, uap) nargs.flags |= MAP_FIXED; nargs.fd = uap->fd; nargs.pos = uap->pos; - return (mmap(p, &nargs)); + return (mmap(td, &nargs)); } #endif /* COMPAT_43 */ @@ -508,8 +508,8 @@ struct msync_args { * MPSAFE */ int -msync(p, uap) - struct proc *p; +msync(td, uap) + struct thread *td; struct msync_args *uap; { vm_offset_t addr; @@ -534,7 +534,7 @@ msync(p, uap) mtx_lock(&Giant); - map = &p->p_vmspace->vm_map; + map = &td->td_proc->p_vmspace->vm_map; /* * XXX Gak! If size is zero we are supposed to sync "all modified @@ -588,8 +588,8 @@ struct munmap_args { * MPSAFE */ int -munmap(p, uap) - struct proc *p; +munmap(td, uap) + struct thread *td; struct munmap_args *uap; { vm_offset_t addr; @@ -620,7 +620,7 @@ munmap(p, uap) return (EINVAL); #endif mtx_lock(&Giant); - map = &p->p_vmspace->vm_map; + map = &td->td_proc->p_vmspace->vm_map; /* * Make sure entire range is allocated. */ @@ -636,14 +636,14 @@ munmap(p, uap) #if 0 void -munmapfd(p, fd) - struct proc *p; +munmapfd(td, fd) + struct thread *td; int fd; { /* * XXX should unmap any regions mapped to this file */ - p->p_fd->fd_ofileflags[fd] &= ~UF_MAPPED; + td->td_proc->p_fd->fd_ofileflags[fd] &= ~UF_MAPPED; } #endif @@ -658,8 +658,8 @@ struct mprotect_args { * MPSAFE */ int -mprotect(p, uap) - struct proc *p; +mprotect(td, uap) + struct thread *td; struct mprotect_args *uap; { vm_offset_t addr; @@ -683,7 +683,7 @@ mprotect(p, uap) return(EINVAL); mtx_lock(&Giant); - ret = vm_map_protect(&p->p_vmspace->vm_map, addr, + ret = vm_map_protect(&td->td_proc->p_vmspace->vm_map, addr, addr + size, prot, FALSE); mtx_unlock(&Giant); switch (ret) { @@ -706,8 +706,8 @@ struct minherit_args { * MPSAFE */ int -minherit(p, uap) - struct proc *p; +minherit(td, uap) + struct thread *td; struct minherit_args *uap; { vm_offset_t addr; @@ -727,7 +727,7 @@ minherit(p, uap) return(EINVAL); mtx_lock(&Giant); - ret = vm_map_inherit(&p->p_vmspace->vm_map, addr, addr+size, + ret = vm_map_inherit(&td->td_proc->p_vmspace->vm_map, addr, addr+size, inherit); mtx_unlock(&Giant); @@ -753,8 +753,8 @@ struct madvise_args { */ /* ARGSUSED */ int -madvise(p, uap) - struct proc *p; +madvise(td, uap) + struct thread *td; struct madvise_args *uap; { vm_offset_t start, end; @@ -787,7 +787,7 @@ madvise(p, uap) end = round_page((vm_offset_t) uap->addr + uap->len); mtx_lock(&Giant); - ret = vm_map_madvise(&p->p_vmspace->vm_map, start, end, uap->behav); + ret = vm_map_madvise(&td->td_proc->p_vmspace->vm_map, start, end, uap->behav); mtx_unlock(&Giant); return (ret ? EINVAL : 0); } @@ -805,8 +805,8 @@ struct mincore_args { */ /* ARGSUSED */ int -mincore(p, uap) - struct proc *p; +mincore(td, uap) + struct thread *td; struct mincore_args *uap; { vm_offset_t addr, first_addr; @@ -838,8 +838,8 @@ mincore(p, uap) vec = uap->vec; mtx_lock(&Giant); - map = &p->p_vmspace->vm_map; - pmap = vmspace_pmap(p->p_vmspace); + map = &td->td_proc->p_vmspace->vm_map; + pmap = vmspace_pmap(td->td_proc->p_vmspace); vm_map_lock_read(map); RestartScan: @@ -1001,8 +1001,8 @@ struct mlock_args { * MPSAFE */ int -mlock(p, uap) - struct proc *p; +mlock(td, uap) + struct thread *td; struct mlock_args *uap; { vm_offset_t addr; @@ -1025,17 +1025,17 @@ mlock(p, uap) return (EAGAIN); #ifdef pmap_wired_count - if (size + ptoa(pmap_wired_count(vm_map_pmap(&p->p_vmspace->vm_map))) > - p->p_rlimit[RLIMIT_MEMLOCK].rlim_cur) + if (size + ptoa(pmap_wired_count(vm_map_pmap(&td->td_proc->p_vmspace->vm_map))) > + td->td_proc->p_rlimit[RLIMIT_MEMLOCK].rlim_cur) return (ENOMEM); #else - error = suser(p); + error = suser_td(td); if (error) return (error); #endif mtx_lock(&Giant); - error = vm_map_user_pageable(&p->p_vmspace->vm_map, addr, + error = vm_map_user_pageable(&td->td_proc->p_vmspace->vm_map, addr, addr + size, FALSE); mtx_unlock(&Giant); return (error == KERN_SUCCESS ? 0 : ENOMEM); @@ -1051,8 +1051,8 @@ struct mlockall_args { * MPSAFE */ int -mlockall(p, uap) - struct proc *p; +mlockall(td, uap) + struct thread *td; struct mlockall_args *uap; { /* mtx_lock(&Giant); */ @@ -1070,8 +1070,8 @@ struct mlockall_args { * MPSAFE */ int -munlockall(p, uap) - struct proc *p; +munlockall(td, uap) + struct thread *td; struct munlockall_args *uap; { /* mtx_lock(&Giant); */ @@ -1089,8 +1089,8 @@ struct munlock_args { * MPSAFE */ int -munlock(p, uap) - struct proc *p; +munlock(td, uap) + struct thread *td; struct munlock_args *uap; { vm_offset_t addr; @@ -1110,13 +1110,13 @@ munlock(p, uap) return (EINVAL); #ifndef pmap_wired_count - error = suser(p); + error = suser_td(td); if (error) return (error); #endif mtx_lock(&Giant); - error = vm_map_user_pageable(&p->p_vmspace->vm_map, addr, + error = vm_map_user_pageable(&td->td_proc->p_vmspace->vm_map, addr, addr + size, TRUE); mtx_unlock(&Giant); return (error == KERN_SUCCESS ? 0 : ENOMEM); @@ -1143,7 +1143,7 @@ vm_mmap(vm_map_t map, vm_offset_t *addr, vm_size_t size, vm_prot_t prot, int rv = KERN_SUCCESS; vm_ooffset_t objsize; int docow; - struct proc *p = curproc; + struct thread *td = curthread; if (size == 0) return (0); @@ -1192,7 +1192,7 @@ vm_mmap(vm_map_t map, vm_offset_t *addr, vm_size_t size, vm_prot_t prot, struct vattr vat; int error; - error = VOP_GETATTR(vp, &vat, p->p_ucred, p); + error = VOP_GETATTR(vp, &vat, td->td_proc->p_ucred, td); if (error) { mtx_unlock(&Giant); return (error); diff --git a/sys/vm/vm_object.c b/sys/vm/vm_object.c index fe7e8c6..1d5a989 100644 --- a/sys/vm/vm_object.c +++ b/sys/vm/vm_object.c @@ -326,7 +326,7 @@ vm_object_reference(vm_object_t object) object->ref_count++; if (object->type == OBJT_VNODE) { - while (vget((struct vnode *) object->handle, LK_RETRY|LK_NOOBJ, curproc)) { + while (vget((struct vnode *) object->handle, LK_RETRY|LK_NOOBJ, curthread)) { printf("vm_object_reference: delay in getting object\n"); } } diff --git a/sys/vm/vm_pageout.c b/sys/vm/vm_pageout.c index 187d8ba7..be7df98 100644 --- a/sys/vm/vm_pageout.c +++ b/sys/vm/vm_pageout.c @@ -546,7 +546,7 @@ vm_pageout_map_deactivate_pages(map, desired) vm_object_t obj, bigobj; GIANT_REQUIRED; - if (lockmgr(&map->lock, LK_EXCLUSIVE | LK_NOWAIT, (void *)0, curproc)) { + if (lockmgr(&map->lock, LK_EXCLUSIVE | LK_NOWAIT, (void *)0, curthread)) { return; } @@ -863,7 +863,7 @@ rescan0: mp = NULL; if (vp->v_type == VREG) vn_start_write(vp, &mp, V_NOWAIT); - if (vget(vp, LK_EXCLUSIVE|LK_NOOBJ, curproc)) { + if (vget(vp, LK_EXCLUSIVE|LK_NOOBJ, curthread)) { vn_finished_write(mp); if (object->flags & OBJ_MIGHTBEDIRTY) vnodes_skipped++; @@ -1162,11 +1162,14 @@ rescan0: } sx_sunlock(&allproc_lock); if (bigproc != NULL) { + struct ksegrp *kg; killproc(bigproc, "out of swap space"); mtx_lock_spin(&sched_lock); - bigproc->p_estcpu = 0; - bigproc->p_nice = PRIO_MIN; - resetpriority(bigproc); + FOREACH_KSEGRP_IN_PROC(bigproc, kg) { + kg->kg_estcpu = 0; + kg->kg_nice = PRIO_MIN; /* XXXKSE ??? */ + resetpriority(kg); + } mtx_unlock_spin(&sched_lock); PROC_UNLOCK(bigproc); wakeup(&cnt.v_free_count); @@ -1358,9 +1361,9 @@ vm_pageout() if (vm_pageout_stats_free_max == 0) vm_pageout_stats_free_max = 5; - PROC_LOCK(curproc); - curproc->p_flag |= P_BUFEXHAUST; - PROC_UNLOCK(curproc); + PROC_LOCK(curthread->td_proc); + curthread->td_proc->p_flag |= P_BUFEXHAUST; + PROC_UNLOCK(curthread->td_proc); swap_pager_swap_init(); pass = 0; /* @@ -1421,7 +1424,7 @@ vm_pageout() void pagedaemon_wakeup() { - if (!vm_pages_needed && curproc != pageproc) { + if (!vm_pages_needed && curthread->td_proc != pageproc) { vm_pages_needed++; wakeup(&vm_pages_needed); } diff --git a/sys/vm/vm_swap.c b/sys/vm/vm_swap.c index 72f7b9c..1a26712 100644 --- a/sys/vm/vm_swap.c +++ b/sys/vm/vm_swap.c @@ -188,8 +188,8 @@ struct swapon_args { */ /* ARGSUSED */ int -swapon(p, uap) - struct proc *p; +swapon(td, uap) + struct thread *td; struct swapon_args *uap; { struct vattr attr; @@ -198,8 +198,7 @@ swapon(p, uap) int error; mtx_lock(&Giant); - - error = suser(p); + error = suser_td(td); if (error) goto done2; @@ -212,7 +211,7 @@ swapon(p, uap) goto done2; } - NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->name, p); + NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->name, td); error = namei(&nd); if (error) goto done2; @@ -221,14 +220,14 @@ swapon(p, uap) vp = nd.ni_vp; if (vn_isdisk(vp, &error)) - error = swaponvp(p, vp, vp->v_rdev, 0); + error = swaponvp(td, vp, vp->v_rdev, 0); else if (vp->v_type == VREG && vp->v_tag == VT_NFS && - (error = VOP_GETATTR(vp, &attr, p->p_ucred, p)) == 0) { + (error = VOP_GETATTR(vp, &attr, td->td_proc->p_ucred, td)) == 0) { /* * Allow direct swapping to NFS regular files in the same * way that nfs_mountroot() sets up diskless swapping. */ - error = swaponvp(p, vp, NODEV, attr.va_size / DEV_BSIZE); + error = swaponvp(td, vp, NODEV, attr.va_size / DEV_BSIZE); } if (error) @@ -250,8 +249,8 @@ done2: * XXX locking when multiple swapon's run in parallel */ int -swaponvp(p, vp, dev, nblks) - struct proc *p; +swaponvp(td, vp, dev, nblks) + struct thread *td; struct vnode *vp; dev_t dev; u_long nblks; @@ -263,6 +262,7 @@ swaponvp(p, vp, dev, nblks) swblk_t dvbase; int error; u_long aligned_nblks; + struct proc *p = td->td_proc; if (!swapdev_vp) { error = getnewvnode(VT_NON, NULL, swapdev_vnodeop_p, @@ -282,19 +282,19 @@ swaponvp(p, vp, dev, nblks) } return EINVAL; found: - (void) vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); - error = VOP_OPEN(vp, FREAD | FWRITE, p->p_ucred, p); - (void) VOP_UNLOCK(vp, 0, p); + (void) vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); + error = VOP_OPEN(vp, FREAD | FWRITE, p->p_ucred, td); + (void) VOP_UNLOCK(vp, 0, td); if (error) return (error); if (nblks == 0 && dev != NODEV && (devsw(dev)->d_psize == 0 || (nblks = (*devsw(dev)->d_psize) (dev)) == -1)) { - (void) VOP_CLOSE(vp, FREAD | FWRITE, p->p_ucred, p); + (void) VOP_CLOSE(vp, FREAD | FWRITE, p->p_ucred, td); return (ENXIO); } if (nblks == 0) { - (void) VOP_CLOSE(vp, FREAD | FWRITE, p->p_ucred, p); + (void) VOP_CLOSE(vp, FREAD | FWRITE, p->p_ucred, td); return (ENXIO); } @@ -305,7 +305,7 @@ swaponvp(p, vp, dev, nblks) if (nblks > 0x40000000 / BLIST_META_RADIX / nswdev) { printf("exceeded maximum of %d blocks per swap unit\n", 0x40000000 / BLIST_META_RADIX / nswdev); - (void) VOP_CLOSE(vp, FREAD | FWRITE, p->p_ucred, p); + (void) VOP_CLOSE(vp, FREAD | FWRITE, p->p_ucred, td); return (ENXIO); } /* diff --git a/sys/vm/vm_unix.c b/sys/vm/vm_unix.c index 10a5f65..47a768f 100644 --- a/sys/vm/vm_unix.c +++ b/sys/vm/vm_unix.c @@ -70,11 +70,11 @@ struct obreak_args { */ /* ARGSUSED */ int -obreak(p, uap) - struct proc *p; +obreak(td, uap) + struct thread *td; struct obreak_args *uap; { - struct vmspace *vm = p->p_vmspace; + struct vmspace *vm = td->td_proc->p_vmspace; vm_offset_t new, old, base; int rv; int error = 0; @@ -90,7 +90,7 @@ obreak(p, uap) * reduce their usage, even if they remain over the limit. */ if (new > old && - (new - base) > (unsigned) p->p_rlimit[RLIMIT_DATA].rlim_cur) { + (new - base) > (unsigned) td->td_proc->p_rlimit[RLIMIT_DATA].rlim_cur) { error = ENOMEM; goto done; } @@ -143,8 +143,8 @@ struct ovadvise_args { */ /* ARGSUSED */ int -ovadvise(p, uap) - struct proc *p; +ovadvise(td, uap) + struct thread *td; struct ovadvise_args *uap; { /* START_GIANT_OPTIONAL */ diff --git a/sys/vm/vm_zeroidle.c b/sys/vm/vm_zeroidle.c index 1fcab4d..a7e5685 100644 --- a/sys/vm/vm_zeroidle.c +++ b/sys/vm/vm_zeroidle.c @@ -112,14 +112,14 @@ vm_page_zero_idle_wakeup(void) static void vm_pagezero(void) { - struct proc *p = curproc; + struct thread *td = curthread; struct rtprio rtp; int pages = 0; rtp.prio = RTP_PRIO_MAX; rtp.type = RTP_PRIO_IDLE; mtx_lock_spin(&sched_lock); - rtp_to_pri(&rtp, &p->p_pri); + rtp_to_pri(&rtp, &td->td_ksegrp->kg_pri); mtx_unlock_spin(&sched_lock); for (;;) { @@ -127,8 +127,8 @@ vm_pagezero(void) pages += vm_page_zero_idle(); if (pages > idlezero_maxrun) { mtx_lock_spin(&sched_lock); - setrunqueue(p); - p->p_stats->p_ru.ru_nvcsw++; + setrunqueue(td); + td->td_proc->p_stats->p_ru.ru_nvcsw++; mi_switch(); mtx_unlock_spin(&sched_lock); pages = 0; diff --git a/sys/vm/vnode_pager.c b/sys/vm/vnode_pager.c index 7edaebc..bad9bcf 100644 --- a/sys/vm/vnode_pager.c +++ b/sys/vm/vnode_pager.c @@ -434,7 +434,7 @@ vnode_pager_input_smlfs(object, m) /* build a minimal buffer header */ bp->b_iocmd = BIO_READ; bp->b_iodone = vnode_pager_iodone; - bp->b_rcred = bp->b_wcred = curproc->p_ucred; + bp->b_rcred = bp->b_wcred = curthread->td_proc->p_ucred; if (bp->b_rcred != NOCRED) crhold(bp->b_rcred); if (bp->b_wcred != NOCRED) @@ -527,9 +527,9 @@ vnode_pager_input_old(object, m) auio.uio_segflg = UIO_SYSSPACE; auio.uio_rw = UIO_READ; auio.uio_resid = size; - auio.uio_procp = curproc; + auio.uio_td = curthread; - error = VOP_READ(vp, &auio, 0, curproc->p_ucred); + error = VOP_READ(vp, &auio, 0, curthread->td_proc->p_ucred); if (!error) { int count = size - auio.uio_resid; @@ -754,7 +754,7 @@ vnode_pager_generic_getpages(vp, m, bytecount, reqpage) bp->b_iocmd = BIO_READ; bp->b_iodone = vnode_pager_iodone; /* B_PHYS is not set, but it is nice to fill this in */ - bp->b_rcred = bp->b_wcred = curproc->p_ucred; + bp->b_rcred = bp->b_wcred = curthread->td_proc->p_ucred; if (bp->b_rcred != NOCRED) crhold(bp->b_rcred); if (bp->b_wcred != NOCRED) @@ -983,8 +983,8 @@ vnode_pager_generic_putpages(vp, m, bytecount, flags, rtvals) auio.uio_segflg = UIO_NOCOPY; auio.uio_rw = UIO_WRITE; auio.uio_resid = maxsize; - auio.uio_procp = (struct proc *) 0; - error = VOP_WRITE(vp, &auio, ioflags, curproc->p_ucred); + auio.uio_td = (struct thread *) 0; + error = VOP_WRITE(vp, &auio, ioflags, curthread->td_proc->p_ucred); cnt.v_vnodeout++; cnt.v_vnodepgsout += ncount; @@ -1005,7 +1005,7 @@ struct vnode * vnode_pager_lock(object) vm_object_t object; { - struct proc *p = curproc; /* XXX */ + struct thread *td = curthread; /* XXX */ GIANT_REQUIRED; @@ -1018,7 +1018,7 @@ vnode_pager_lock(object) /* XXX; If object->handle can change, we need to cache it. */ while (vget(object->handle, - LK_NOPAUSE | LK_SHARED | LK_RETRY | LK_CANRECURSE, p)) { + LK_NOPAUSE | LK_SHARED | LK_RETRY | LK_CANRECURSE, td)){ if ((object->flags & OBJ_DEAD) || (object->type != OBJT_VNODE)) return NULL; printf("vnode_pager_lock: retrying\n"); diff --git a/usr.bin/gcore/aoutcore.c b/usr.bin/gcore/aoutcore.c index c61bad8..5f17bf9 100644 --- a/usr.bin/gcore/aoutcore.c +++ b/usr.bin/gcore/aoutcore.c @@ -223,7 +223,10 @@ core(efd, fd, ki) { union { struct user user; - char ubytes[ctob(UPAGES)]; + struct { + char uabytes[ctob(UAREA_PAGES)]; + char ksbytes[ctob(KSTACK_PAGES)]; + } bytes; } uarea; int tsize = ki->ki_tsize; int dsize = ki->ki_dsize; @@ -231,9 +234,16 @@ core(efd, fd, ki) int cnt; /* Read in user struct */ - cnt = kvm_read(kd, (u_long)ki->ki_addr, &uarea, sizeof(uarea)); - if (cnt != sizeof(uarea)) - errx(1, "read user structure: %s", + cnt = kvm_read(kd, (u_long)ki->ki_addr, uarea.bytes.uabytes, + ctob(UAREA_PAGES)); + if (cnt != ctob(UAREA_PAGES)) + errx(1, "read upages structure: %s", + cnt > 0 ? strerror(EIO) : strerror(errno)); + + cnt = kvm_read(kd, (u_long)ki->ki_kstack, uarea.bytes.ksbytes, + ctob(KSTACK_PAGES)); + if (cnt != ctob(KSTACK_PAGES)) + errx(1, "read kstack structure: %s", cnt > 0 ? strerror(EIO) : strerror(errno)); /* diff --git a/usr.bin/gcore/gcore.c b/usr.bin/gcore/gcore.c index c61bad8..5f17bf9 100644 --- a/usr.bin/gcore/gcore.c +++ b/usr.bin/gcore/gcore.c @@ -223,7 +223,10 @@ core(efd, fd, ki) { union { struct user user; - char ubytes[ctob(UPAGES)]; + struct { + char uabytes[ctob(UAREA_PAGES)]; + char ksbytes[ctob(KSTACK_PAGES)]; + } bytes; } uarea; int tsize = ki->ki_tsize; int dsize = ki->ki_dsize; @@ -231,9 +234,16 @@ core(efd, fd, ki) int cnt; /* Read in user struct */ - cnt = kvm_read(kd, (u_long)ki->ki_addr, &uarea, sizeof(uarea)); - if (cnt != sizeof(uarea)) - errx(1, "read user structure: %s", + cnt = kvm_read(kd, (u_long)ki->ki_addr, uarea.bytes.uabytes, + ctob(UAREA_PAGES)); + if (cnt != ctob(UAREA_PAGES)) + errx(1, "read upages structure: %s", + cnt > 0 ? strerror(EIO) : strerror(errno)); + + cnt = kvm_read(kd, (u_long)ki->ki_kstack, uarea.bytes.ksbytes, + ctob(KSTACK_PAGES)); + if (cnt != ctob(KSTACK_PAGES)) + errx(1, "read kstack structure: %s", cnt > 0 ? strerror(EIO) : strerror(errno)); /* diff --git a/usr.bin/w/proc_compare.c b/usr.bin/w/proc_compare.c index a9403e7..7337b49 100644 --- a/usr.bin/w/proc_compare.c +++ b/usr.bin/w/proc_compare.c @@ -117,9 +117,9 @@ proc_compare(p1, p2) /* * favor one sleeping in a non-interruptible sleep */ - if (p1->ki_sflag & PS_SINTR && (p2->ki_sflag & PS_SINTR) == 0) + if (p1->ki_tdflags & TDF_SINTR && (p2->ki_tdflags & TDF_SINTR) == 0) return (1); - if (p2->ki_sflag & PS_SINTR && (p1->ki_sflag & PS_SINTR) == 0) + if (p2->ki_tdflags & TDF_SINTR && (p1->ki_tdflags & TDF_SINTR) == 0) return (0); return (p2->ki_pid > p1->ki_pid); /* tie - return highest pid */ } |
