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 /sys/kern | |
| 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
Diffstat (limited to 'sys/kern')
90 files changed, 4173 insertions, 3613 deletions
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; }; # |
