kernel - adjust falloc and arguments to dupfdopen, fsetfd, fdcheckstd
authorMatthew Dillon <dillon@apollo.backplane.com>
Tue, 15 Dec 2009 20:31:02 +0000 (12:31 -0800)
committerMatthew Dillon <dillon@apollo.backplane.com>
Tue, 15 Dec 2009 20:31:02 +0000 (12:31 -0800)
* Make changes to the pointer type passed (proc, lwp, filedesc) to
  numerous routines.

* falloc() needs access to td_ucred (it was previously using p_ucred which
  is not MPSAFE).

* Adjust fsetfd() to make it conform to the other fsetfd*() procedures.

* Related changes to fdcheckstd() and dupfdopen().

12 files changed:
sys/kern/kern_checkpoint.c
sys/kern/kern_descrip.c
sys/kern/kern_event.c
sys/kern/kern_exec.c
sys/kern/kern_syslink.c
sys/kern/sys_mqueue.c
sys/kern/sys_pipe.c
sys/kern/uipc_syscalls.c
sys/kern/uipc_usrreq.c
sys/kern/vfs_syscalls.c
sys/opencrypto/cryptodev.c
sys/sys/filedesc.h

index e86d326..7738d04 100644 (file)
@@ -80,7 +80,7 @@ static int elf_demarshalnotes(void *src, prpsinfo_t *psinfo,
 static int elf_loadnotes(struct lwp *, prpsinfo_t *, prstatus_t *,
                 prfpregset_t *);
 static int elf_getsigs(struct lwp *lp, struct file *fp);
-static int elf_getfiles(struct proc *p, struct file *fp);
+static int elf_getfiles(struct lwp *lp, struct file *fp);
 static int elf_gettextvp(struct proc *p, struct file *fp);
 static char *ckpt_expand_name(const char *name, uid_t uid, pid_t pid);
 
@@ -253,7 +253,7 @@ ckpt_thaw_proc(struct lwp *lp, struct file *fp)
        }
 
        /* fetch open files */
-       if ((error = elf_getfiles(p, fp)) != 0)
+       if ((error = elf_getfiles(lp, fp)) != 0)
                goto done;
 
        /* handle mappings last in case we are reading from a socket */
@@ -582,7 +582,7 @@ elf_gettextvp(struct proc *p, struct file *fp)
 
 /* place holder */
 static int
-elf_getfiles(struct proc *p, struct file *fp)
+elf_getfiles(struct lwp *lp, struct file *fp)
 {
        int error;
        int i;
@@ -590,6 +590,7 @@ elf_getfiles(struct proc *p, struct file *fp)
        int fd;
        struct ckpt_filehdr filehdr;
        struct ckpt_fileinfo *cfi_base = NULL;
+       struct filedesc *fdp = lp->lwp_proc->p_fd;
        struct vnode *vp;
        struct file *tempfp;
        struct file *ofp;
@@ -610,7 +611,7 @@ elf_getfiles(struct proc *p, struct file *fp)
         * XXX we need a flag so a checkpoint restore can opt to supply the
         * descriptors, or the non-regular-file descripors.
         */
-       for (i = 3; i < p->p_fd->fd_nfiles; ++i)
+       for (i = 3; i < fdp->fd_nfiles; ++i)
                kern_close(i);
 
        /*
@@ -655,22 +656,22 @@ elf_getfiles(struct proc *p, struct file *fp)
                 * only occurs if the saved core saved descriptors that we 
                 * have not already closed.
                 */
-               if (cfi->cfi_index < p->p_fd->fd_nfiles &&
-                   (ofp = p->p_fd->fd_files[cfi->cfi_index].fp) != NULL) {
+               if (cfi->cfi_index < fdp->fd_nfiles &&
+                   (ofp = fdp->fd_files[cfi->cfi_index].fp) != NULL) {
                        kern_close(cfi->cfi_index);
                }
 
                /*
                 * Allocate the descriptor we want.
                 */
-               if (fdalloc(p, cfi->cfi_index, &fd) != 0) {
+               if (fdalloc(lp->lwp_proc, cfi->cfi_index, &fd) != 0) {
                        PRINTF(("can't currently restore fd: %d\n",
                               cfi->cfi_index));
                        fp_close(fp);
                        goto done;
                }
                KKASSERT(fd == cfi->cfi_index);
-               fsetfd(p, tempfp, fd);
+               fsetfd(fdp, tempfp, fd);
                fdrop(tempfp);
                cfi++;
                PRINTF(("restoring %d\n", cfi->cfi_index));
@@ -713,6 +714,7 @@ sys_sys_checkpoint(struct sys_checkpoint_args *uap)
         int error = 0;
        struct thread *td = curthread;
        struct proc *p = td->td_proc;
+       struct filedesc *fdp = p->p_fd;
        struct file *fp;
 
        /*
@@ -735,7 +737,7 @@ sys_sys_checkpoint(struct sys_checkpoint_args *uap)
                fp = NULL;
                if (uap->fd == -1 && uap->pid == (pid_t)-1)
                        error = checkpoint_signal_handler(td->td_lwp);
-               else if ((fp = holdfp(p->p_fd, uap->fd, FWRITE)) == NULL)
+               else if ((fp = holdfp(fdp, uap->fd, FWRITE)) == NULL)
                        error = EBADF;
                else
                        error = ckpt_freeze_proc(td->td_lwp, fp);
@@ -747,7 +749,7 @@ sys_sys_checkpoint(struct sys_checkpoint_args *uap)
                        error = EINVAL;
                        break;
                }
-               if ((fp = holdfp(p->p_fd, uap->fd, FREAD)) == NULL) {
+               if ((fp = holdfp(fdp, uap->fd, FREAD)) == NULL) {
                        error = EBADF;
                        break;
                }
index d490940..2502135 100644 (file)
@@ -1360,9 +1360,10 @@ fdrevoke_proc_callback(struct proc *p, void *vinfo)
  *     Create a new open file structure and reserve a file decriptor
  *     for the process that refers to it.
  *
- *     Root creds are checked using p, or assumed if p is NULL.  If
- *     resultfd is non-NULL then p must also be non-NULL.  No file
- *     descriptor is reserved if resultfd is NULL.
+ *     Root creds are checked using lp, or assumed if lp is NULL.  If
+ *     resultfd is non-NULL then lp must also be non-NULL.  No file
+ *     descriptor is reserved (and no process context is needed) if
+ *     resultfd is NULL.
  *
  *     A file pointer with a refcount of 1 is returned.  Note that the
  *     file pointer is NOT associated with the descriptor.  If falloc
@@ -1372,11 +1373,12 @@ fdrevoke_proc_callback(struct proc *p, void *vinfo)
  * MPSAFE
  */
 int
-falloc(struct proc *p, struct file **resultfp, int *resultfd)
+falloc(struct lwp *lp, struct file **resultfp, int *resultfd)
 {
        static struct timeval lastfail;
        static int curfail;
        struct file *fp;
+       struct ucred *cred = lp ? lp->lwp_thread->td_ucred : proc0.p_ucred;
        int error;
 
        fp = NULL;
@@ -1385,10 +1387,11 @@ falloc(struct proc *p, struct file **resultfp, int *resultfd)
         * Handle filetable full issues and root overfill.
         */
        if (nfiles >= maxfiles - maxfilesrootres &&
-           ((p && p->p_ucred->cr_ruid != 0) || nfiles >= maxfiles)) {
+           (cred->cr_ruid != 0 || nfiles >= maxfiles)) {
                if (ppsratecheck(&lastfail, &curfail, 1)) {
-                       kprintf("kern.maxfiles limit exceeded by uid %d, please see tuning(7).\n",
-                               (p ? p->p_ucred->cr_ruid : -1));
+                       kprintf("kern.maxfiles limit exceeded by uid %d, "
+                               "please see tuning(7).\n",
+                               cred->cr_ruid);
                }
                error = ENFILE;
                goto done;
@@ -1402,16 +1405,13 @@ falloc(struct proc *p, struct file **resultfp, int *resultfd)
        fp->f_count = 1;
        fp->f_ops = &badfileops;
        fp->f_seqcount = 1;
-       if (p)
-               fp->f_cred = crhold(p->p_ucred);
-       else
-               fp->f_cred = crhold(proc0.p_ucred);
+       fp->f_cred = crhold(cred);
        spin_lock_wr(&filehead_spin);
        nfiles++;
        LIST_INSERT_HEAD(&filehead, fp, f_list);
        spin_unlock_wr(&filehead_spin);
        if (resultfd) {
-               if ((error = fdalloc(p, 0, resultfd)) != 0) {
+               if ((error = fdalloc(lp->lwp_proc, 0, resultfd)) != 0) {
                        fdrop(fp);
                        fp = NULL;
                }
@@ -1475,10 +1475,8 @@ fsetfd_locked(struct filedesc *fdp, struct file *fp, int fd)
  * MPSAFE
  */
 void
-fsetfd(struct proc *p, struct file *fp, int fd)
+fsetfd(struct filedesc *fdp, struct file *fp, int fd)
 {
-       struct filedesc *fdp = p->p_fd;
-
        spin_lock_wr(&fdp->fd_spin);
        fsetfd_locked(fdp, fp, fd);
        spin_unlock_wr(&fdp->fd_spin);
@@ -2169,7 +2167,7 @@ fdcloseexec(struct proc *p)
  * NOT MPSAFE - calls falloc, vn_open, etc
  */
 int
-fdcheckstd(struct proc *p)
+fdcheckstd(struct lwp *lp)
 {
        struct nlookupdata nd;
        struct filedesc *fdp;
@@ -2177,7 +2175,7 @@ fdcheckstd(struct proc *p)
        int retval;
        int i, error, flags, devnull;
 
-       fdp = p->p_fd;
+       fdp = lp->lwp_proc->p_fd;
        if (fdp == NULL)
                return (0);
        devnull = -1;
@@ -2186,7 +2184,7 @@ fdcheckstd(struct proc *p)
                if (fdp->fd_files[i].fp != NULL)
                        continue;
                if (devnull < 0) {
-                       if ((error = falloc(p, &fp, &devnull)) != 0)
+                       if ((error = falloc(lp, &fp, &devnull)) != 0)
                                break;
 
                        error = nlookup_init(&nd, "/dev/null", UIO_SYSSPACE,
@@ -2195,9 +2193,9 @@ fdcheckstd(struct proc *p)
                        if (error == 0)
                                error = vn_open(&nd, fp, flags, 0);
                        if (error == 0)
-                               fsetfd(p, fp, devnull);
+                               fsetfd(fdp, fp, devnull);
                        else
-                               fsetfd(p, NULL, devnull);
+                               fsetfd(fdp, NULL, devnull);
                        fdrop(fp);
                        nlookup_done(&nd);
                        if (error)
@@ -2435,9 +2433,8 @@ fdopen(struct dev_open_args *ap)
  * NOT MPSAFE - isn't getting spinlocks, possibly other things
  */
 int
-dupfdopen(struct proc *p, int dfd, int sfd, int mode, int error)
+dupfdopen(struct filedesc *fdp, int dfd, int sfd, int mode, int error)
 {
-       struct filedesc *fdp = p->p_fd;
        struct file *wfp;
        struct file *xfp;
        int werror;
@@ -2479,7 +2476,7 @@ dupfdopen(struct proc *p, int dfd, int sfd, int mode, int error)
                        break;
                }
                fdp->fd_files[dfd].fileflags = fdp->fd_files[sfd].fileflags;
-               fsetfd(p, wfp, dfd);
+               fsetfd(fdp, wfp, dfd);
                error = 0;
                break;
        case ENXIO:
@@ -2487,7 +2484,7 @@ dupfdopen(struct proc *p, int dfd, int sfd, int mode, int error)
                 * Steal away the file pointer from dfd, and stuff it into indx.
                 */
                fdp->fd_files[dfd].fileflags = fdp->fd_files[sfd].fileflags;
-               fsetfd(p, wfp, dfd);
+               fsetfd(fdp, wfp, dfd);
                if ((xfp = funsetfd_locked(fdp, sfd)) != NULL)
                        fdrop(xfp);
                error = 0;
index 9367dca..766f8fe 100644 (file)
@@ -384,13 +384,12 @@ filt_timer(struct knote *kn, long hint)
 int
 sys_kqueue(struct kqueue_args *uap)
 {
-       struct proc *p = curproc;
-       struct filedesc *fdp = p->p_fd;
+       struct thread *td = curthread;
        struct kqueue *kq;
        struct file *fp;
        int fd, error;
 
-       error = falloc(p, &fp, &fd);
+       error = falloc(td->td_lwp, &fp, &fd);
        if (error)
                return (error);
        fp->f_flag = FREAD | FWRITE;
@@ -399,10 +398,10 @@ sys_kqueue(struct kqueue_args *uap)
 
        kq = kmalloc(sizeof(struct kqueue), M_KQUEUE, M_WAITOK | M_ZERO);
        TAILQ_INIT(&kq->kq_head);
-       kq->kq_fdp = fdp;
+       kq->kq_fdp = td->td_proc->p_fd;
        fp->f_data = kq;
 
-       fsetfd(p, fp, fd);
+       fsetfd(kq->kq_fdp, fp, fd);
        uap->sysmsg_result = fd;
        fdrop(fp);
        return (error);
index 94d11a5..571adf8 100644 (file)
@@ -409,7 +409,7 @@ interpret:
                /* Close any file descriptors 0..2 that reference procfs */
                setugidsafety(p);
                /* Make sure file descriptors 0..2 are in use. */
-               error = fdcheckstd(p);
+               error = fdcheckstd(lp);
                if (error != 0)
                        goto exec_fail_dealloc;
                /*
index 5da8941..869f8e0 100644 (file)
@@ -310,7 +310,8 @@ static
 int
 syslink_cmd_new(struct syslink_info_new *info, int *result)
 {
-       struct proc *p = curproc;
+       struct thread *td = curthread;
+       struct filedesc *fdp = td->td_proc->p_fd;
        struct file *fp1;
        struct file *fp2;
        struct sldesc *sl;
@@ -318,12 +319,12 @@ syslink_cmd_new(struct syslink_info_new *info, int *result)
        int error;
        int fd1, fd2;
 
-       error = falloc(p, &fp1, &fd1);
+       error = falloc(td->td_lwp, &fp1, &fd1);
        if (error)
                return(error);
-       error = falloc(p, &fp2, &fd2);
+       error = falloc(td->td_lwp, &fp2, &fd2);
        if (error) {
-               fsetfd(p, NULL, fd1);
+               fsetfd(fdp, NULL, fd1);
                fdrop(fp1);
                return(error);
        }
@@ -343,9 +344,9 @@ syslink_cmd_new(struct syslink_info_new *info, int *result)
        setsldescfp(sl, fp1);
        setsldescfp(slpeer, fp2);
 
-       fsetfd(p, fp1, fd1);
+       fsetfd(fdp, fp1, fd1);
        fdrop(fp1);
-       fsetfd(p, fp2, fd2);
+       fsetfd(fdp, fp2, fd2);
        fdrop(fp2);
 
        info->head.wbflag = 1;  /* write back */
@@ -1342,19 +1343,20 @@ backend_dispose_user(struct sldesc *sl, struct slmsg *slmsg)
  * error code is returned on failure.
  */
 int
-syslink_ukbackend(int *fdp, struct sldesc **kslp)
+syslink_ukbackend(int *pfd, struct sldesc **kslp)
 {
-       struct proc *p = curproc;
+       struct thread *td = curthread;
+       struct filedesc *fdp = td->td_proc->p_fd;
        struct file *fp;
        struct sldesc *usl;
        struct sldesc *ksl;
        int error;
        int fd;
 
-       *fdp = -1;
+       *pfd = -1;
        *kslp = NULL;
 
-       error = falloc(p, &fp, &fd);
+       error = falloc(td->td_lwp, &fp, &fd);
        if (error)
                return(error);
        usl = allocsldesc(NULL);
@@ -1373,10 +1375,10 @@ syslink_ukbackend(int *fdp, struct sldesc **kslp)
        usl->peer = ksl;
 
        setsldescfp(usl, fp);
-       fsetfd(p, fp, fd);
+       fsetfd(fdp, fp, fd);
        fdrop(fp);
 
-       *fdp = fd;
+       *pfd = fd;
        *kslp = ksl;
        return(0);
 }
index ae72251..74cdb6f 100644 (file)
@@ -391,6 +391,7 @@ sys_mq_open(struct mq_open_args *uap)
        } */
        struct thread *td = curthread;
        struct proc *p = td->td_proc;
+       struct filedesc *fdp = p->p_fd;
        struct mqueue *mq, *mq_new = NULL;
        file_t *fp;
        char *name;
@@ -473,7 +474,7 @@ sys_mq_open(struct mq_open_args *uap)
        }
 
        /* Allocate file structure and descriptor */
-       error = falloc(curproc, &fp, &mqd);
+       error = falloc(td->td_lwp, &fp, &mqd);
        if (error) {
                if (mq_new)
                        mqueue_destroy(mq_new);
@@ -525,7 +526,7 @@ sys_mq_open(struct mq_open_args *uap)
                if ((oflag & O_CREAT) == 0) {
                        lockmgr(&mqlist_mtx, LK_RELEASE);
                        KKASSERT(mq_new == NULL);
-                       fsetfd(curproc, NULL, mqd);
+                       fsetfd(fdp, NULL, mqd);
                        fp->f_ops = &badfileops;
                        fdrop(fp);
                        kfree(name, M_MQBUF);
@@ -558,10 +559,10 @@ exit:
        if (mq_new)
                mqueue_destroy(mq_new);
        if (error) {
-               fsetfd(curproc, NULL, mqd);
+               fsetfd(fdp, NULL, mqd);
                fp->f_ops = &badfileops;
        } else {
-               fsetfd(p, fp, mqd);
+               fsetfd(fdp, fp, mqd);
                uap->sysmsg_result = mqd;
        }
        fdrop(fp);
index 1ec3325..88619c9 100644 (file)
@@ -261,13 +261,11 @@ int
 sys_pipe(struct pipe_args *uap)
 {
        struct thread *td = curthread;
-       struct proc *p = td->td_proc;
+       struct filedesc *fdp = td->td_proc->p_fd;
        struct file *rf, *wf;
        struct pipe *rpipe, *wpipe;
        int fd1, fd2, error;
 
-       KKASSERT(p);
-
        rpipe = wpipe = NULL;
        if (pipe_create(&rpipe) || pipe_create(&wpipe)) {
                pipeclose(rpipe); 
@@ -275,7 +273,7 @@ sys_pipe(struct pipe_args *uap)
                return (ENFILE);
        }
        
-       error = falloc(p, &rf, &fd1);
+       error = falloc(td->td_lwp, &rf, &fd1);
        if (error) {
                pipeclose(rpipe);
                pipeclose(wpipe);
@@ -293,9 +291,9 @@ sys_pipe(struct pipe_args *uap)
        rf->f_flag = FREAD | FWRITE;
        rf->f_ops = &pipeops;
        rf->f_data = rpipe;
-       error = falloc(p, &wf, &fd2);
+       error = falloc(td->td_lwp, &wf, &fd2);
        if (error) {
-               fsetfd(p, NULL, fd1);
+               fsetfd(fdp, NULL, fd1);
                fdrop(rf);
                /* rpipe has been closed by fdrop(). */
                pipeclose(wpipe);
@@ -318,8 +316,8 @@ sys_pipe(struct pipe_args *uap)
         * Once activated the peer relationship remains valid until
         * both sides are closed.
         */
-       fsetfd(p, rf, fd1);
-       fsetfd(p, wf, fd2);
+       fsetfd(fdp, rf, fd1);
+       fsetfd(fdp, wf, fd2);
        fdrop(rf);
        fdrop(wf);
 
index af2f7b0..468d630 100644 (file)
@@ -105,26 +105,26 @@ int
 kern_socket(int domain, int type, int protocol, int *res)
 {
        struct thread *td = curthread;
-       struct proc *p = td->td_proc;
+       struct filedesc *fdp = td->td_proc->p_fd;
        struct socket *so;
        struct file *fp;
        int fd, error;
 
-       KKASSERT(p);
+       KKASSERT(td->td_lwp);
 
-       error = falloc(p, &fp, &fd);
+       error = falloc(td->td_lwp, &fp, &fd);
        if (error)
                return (error);
        error = socreate(domain, &so, type, protocol, td);
        if (error) {
-               fsetfd(p, NULL, fd);
+               fsetfd(fdp, NULL, fd);
        } else {
                fp->f_type = DTYPE_SOCKET;
                fp->f_flag = FREAD | FWRITE;
                fp->f_ops = &socketops;
                fp->f_data = so;
                *res = fd;
-               fsetfd(p, fp, fd);
+               fsetfd(fdp, fp, fd);
        }
        fdrop(fp);
        return (error);
@@ -262,7 +262,7 @@ int
 kern_accept(int s, int fflags, struct sockaddr **name, int *namelen, int *res)
 {
        struct thread *td = curthread;
-       struct proc *p = td->td_proc;
+       struct filedesc *fdp = td->td_proc->p_fd;
        struct file *lfp = NULL;
        struct file *nfp = NULL;
        struct sockaddr *sa;
@@ -276,11 +276,11 @@ kern_accept(int s, int fflags, struct sockaddr **name, int *namelen, int *res)
        if (name && namelen && *namelen < 0)
                return (EINVAL);
 
-       error = holdsock(p->p_fd, s, &lfp);
+       error = holdsock(td->td_proc->p_fd, s, &lfp);
        if (error)
                return (error);
 
-       error = falloc(p, &nfp, &fd);
+       error = falloc(td->td_lwp, &nfp, &fd);
        if (error) {            /* Probably ran out of file descriptors. */
                fdrop(lfp);
                return (error);
@@ -362,10 +362,10 @@ done:
         * a syscall message will still have access to the result code.
         */
        if (error) {
-               fsetfd(p, NULL, fd);
+               fsetfd(fdp, NULL, fd);
        } else {
                *res = fd;
-               fsetfd(p, nfp, fd);
+               fsetfd(fdp, nfp, fd);
        }
        fdrop(nfp);
        fdrop(lfp);
@@ -580,24 +580,24 @@ int
 kern_socketpair(int domain, int type, int protocol, int *sv)
 {
        struct thread *td = curthread;
-       struct proc *p = td->td_proc;
+       struct filedesc *fdp;
        struct file *fp1, *fp2;
        struct socket *so1, *so2;
        int fd1, fd2, error;
 
-       KKASSERT(p);
+       fdp = td->td_proc->p_fd;
        error = socreate(domain, &so1, type, protocol, td);
        if (error)
                return (error);
        error = socreate(domain, &so2, type, protocol, td);
        if (error)
                goto free1;
-       error = falloc(p, &fp1, &fd1);
+       error = falloc(td->td_lwp, &fp1, &fd1);
        if (error)
                goto free2;
        sv[0] = fd1;
        fp1->f_data = so1;
-       error = falloc(p, &fp2, &fd2);
+       error = falloc(td->td_lwp, &fp2, &fd2);
        if (error)
                goto free3;
        fp2->f_data = so2;
@@ -616,16 +616,16 @@ kern_socketpair(int domain, int type, int protocol, int *sv)
        fp1->f_type = fp2->f_type = DTYPE_SOCKET;
        fp1->f_flag = fp2->f_flag = FREAD|FWRITE;
        fp1->f_ops = fp2->f_ops = &socketops;
-       fsetfd(p, fp1, fd1);
-       fsetfd(p, fp2, fd2);
+       fsetfd(fdp, fp1, fd1);
+       fsetfd(fdp, fp2, fd2);
        fdrop(fp1);
        fdrop(fp2);
        return (error);
 free4:
-       fsetfd(p, NULL, fd2);
+       fsetfd(fdp, NULL, fd2);
        fdrop(fp2);
 free3:
-       fsetfd(p, NULL, fd1);
+       fsetfd(fdp, NULL, fd1);
        fdrop(fp1);
 free2:
        (void)soclose(so2, 0);
@@ -1851,7 +1851,7 @@ sys_sctp_peeloff(struct sctp_peeloff_args *uap)
 {
 #ifdef SCTP
        struct thread *td = curthread;
-       struct proc *p = td->td_proc;
+       struct filedesc *fdp = td->td_proc->p_fd;
        struct file *lfp = NULL;
        struct file *nfp = NULL;
        int error;
@@ -1880,7 +1880,7 @@ sys_sctp_peeloff(struct sctp_peeloff_args *uap)
         */
 
        fflag = lfp->f_flag;
-       error = falloc(p, &nfp, &fd);
+       error = falloc(td->td_lwp, &nfp, &fd);
        if (error) {
                /*
                 * Probably ran out of file descriptors. Put the
@@ -1918,9 +1918,9 @@ noconnection:
         * the reserved descriptor if an error occured.
         */
        if (error)
-               fsetfd(p, NULL, fd);
+               fsetfd(fdp, NULL, fd);
        else
-               fsetfd(p, nfp, fd);
+               fsetfd(fdp, nfp, fd);
        crit_exit();
        /*
         * Release explicitly held references before returning.
index 9170df4..ef89a21 100644 (file)
@@ -98,7 +98,7 @@ static void    unp_mark (struct file *, void *data);
 static void    unp_discard (struct file *, void *);
 static int     unp_internalize (struct mbuf *, struct thread *);
 static int     unp_listen (struct unpcb *, struct thread *);
-static void    unp_fp_externalize(struct proc *p, struct file *fp, int fd);
+static void    unp_fp_externalize(struct lwp *lp, struct file *fp, int fd);
 
 static int
 uipc_abort(struct socket *so)
@@ -939,10 +939,12 @@ unp_drain(void)
 int
 unp_externalize(struct mbuf *rights)
 {
-       struct proc *p = curproc;               /* XXX */
-       int i;
+       struct thread *td = curthread;
+       struct proc *p = td->td_proc;           /* XXX */
+       struct lwp *lp = td->td_lwp;
        struct cmsghdr *cm = mtod(rights, struct cmsghdr *);
        int *fdp;
+       int i;
        struct file **rp;
        struct file *fp;
        int newfds = (cm->cmsg_len - (CMSG_DATA(cm) - (u_char *)cm))
@@ -984,7 +986,7 @@ unp_externalize(struct mbuf *rights)
                        if (fdalloc(p, 0, &f))
                                panic("unp_externalize");
                        fp = *rp++;
-                       unp_fp_externalize(p, fp, f);
+                       unp_fp_externalize(lp, fp, f);
                        *fdp++ = f;
                }
        } else {
@@ -994,7 +996,7 @@ unp_externalize(struct mbuf *rights)
                        if (fdalloc(p, 0, &f))
                                panic("unp_externalize");
                        fp = *rp--;
-                       unp_fp_externalize(p, fp, f);
+                       unp_fp_externalize(lp, fp, f);
                        *fdp-- = f;
                }
        }
@@ -1009,24 +1011,24 @@ unp_externalize(struct mbuf *rights)
 }
 
 static void
-unp_fp_externalize(struct proc *p, struct file *fp, int fd)
+unp_fp_externalize(struct lwp *lp, struct file *fp, int fd)
 {
        struct file *fx;
        int error;
 
-       if (p) {
+       if (lp) {
                KKASSERT(fd >= 0);
                if (fp->f_flag & FREVOKED) {
                        kprintf("Warning: revoked fp exiting unix socket\n");
                        fx = NULL;
-                       error = falloc(p, &fx, NULL);
+                       error = falloc(lp, &fx, NULL);
                        if (error == 0)
-                               fsetfd(p, fx, fd);
+                               fsetfd(lp->lwp_proc->p_fd, fx, fd);
                        else
-                               fsetfd(p, NULL, fd);
+                               fsetfd(lp->lwp_proc->p_fd, NULL, fd);
                        fdrop(fx);
                } else {
-                       fsetfd(p, fp, fd);
+                       fsetfd(lp->lwp_proc->p_fd, fp, fd);
                }
        }
        spin_lock_wr(&unp_spin);
index b4ea94e..c4dfa2d 100644 (file)
@@ -1790,7 +1790,7 @@ kern_open(struct nlookupdata *nd, int oflags, int mode, int *res)
        if ((oflags & O_ACCMODE) == O_ACCMODE)
                return (EINVAL);
        flags = FFLAGS(oflags);
-       error = falloc(p, &nfp, NULL);
+       error = falloc(lp, &nfp, NULL);
        if (error)
                return (error);
        fp = nfp;
@@ -1824,13 +1824,13 @@ kern_open(struct nlookupdata *nd, int oflags, int mode, int *res)
                 */
                if ((error == ENODEV || error == ENXIO) && lp->lwp_dupfd >= 0) {
                        if (fdalloc(p, 0, &indx) == 0) {
-                               error = dupfdopen(p, indx, lp->lwp_dupfd, flags, error);
+                               error = dupfdopen(fdp, indx, lp->lwp_dupfd, flags, error);
                                if (error == 0) {
                                        *res = indx;
                                        fdrop(fp);      /* our ref */
                                        return (0);
                                }
-                               fsetfd(p, NULL, indx);
+                               fsetfd(fdp, NULL, indx);
                        }
                }
                fdrop(fp);      /* our ref */
@@ -1880,7 +1880,7 @@ kern_open(struct nlookupdata *nd, int oflags, int mode, int *res)
                         * descriptor.
                         */
                        vrele(vp);
-                       fsetfd(p, NULL, indx);
+                       fsetfd(fdp, NULL, indx);
                        fdrop(fp);
                        return (error);
                }
@@ -1900,7 +1900,7 @@ kern_open(struct nlookupdata *nd, int oflags, int mode, int *res)
         * release our private reference, leaving the one associated with the
         * descriptor table intact.
         */
-       fsetfd(p, fp, indx);
+       fsetfd(fdp, fp, indx);
        fdrop(fp);
        *res = indx;
        return (0);
@@ -4079,7 +4079,7 @@ int
 sys_fhopen(struct fhopen_args *uap)
 {
        struct thread *td = curthread;
-       struct proc *p = td->td_proc;
+       struct filedesc *fdp = td->td_proc->p_fd;
        struct mount *mp;
        struct vnode *vp;
        struct fhandle fhp;
@@ -4175,7 +4175,7 @@ sys_fhopen(struct fhopen_args *uap)
         * WARNING! no f_nchandle will be associated when fhopen()ing a
         * directory.  XXX
         */
-       if ((error = falloc(p, &nfp, &indx)) != 0)
+       if ((error = falloc(td->td_lwp, &nfp, &indx)) != 0)
                goto bad;
        fp = nfp;
 
@@ -4221,7 +4221,7 @@ sys_fhopen(struct fhopen_args *uap)
                        /*
                         * release our private reference.
                         */
-                       fsetfd(p, NULL, indx);
+                       fsetfd(fdp, NULL, indx);
                        fdrop(fp);
                        vrele(vp);
                        goto done;
@@ -4236,13 +4236,13 @@ sys_fhopen(struct fhopen_args *uap)
         */
        vput(vp);
        rel_mplock();
-       fsetfd(p, fp, indx);
+       fsetfd(fdp, fp, indx);
        fdrop(fp);
        uap->sysmsg_result = indx;
        return (0);
 
 bad_drop:
-       fsetfd(p, NULL, indx);
+       fsetfd(fdp, NULL, indx);
        fdrop(fp);
 bad:
        vput(vp);
index b3c7d24..401c910 100644 (file)
@@ -810,6 +810,7 @@ cryptowrite(struct dev_write_args *ap)
 static int
 cryptoioctl(struct dev_ioctl_args *ap)
 {
+       struct thread *td = curthread;
        struct file *f;
        struct fcrypt *fcr;
        int fd, error;
@@ -820,8 +821,8 @@ cryptoioctl(struct dev_ioctl_args *ap)
                TAILQ_INIT(&fcr->csessions);
                fcr->sesn = 0;
 
-               KKASSERT(curproc);
-               error = falloc(curproc, &f, &fd);
+               KKASSERT(td->td_lwp);
+               error = falloc(td->td_lwp, &f, &fd);
 
                if (error) {
                        kfree(fcr, M_XDATA);
@@ -832,7 +833,7 @@ cryptoioctl(struct dev_ioctl_args *ap)
                f->f_type = DTYPE_CRYPTO;
                f->f_ops = &cryptofops;
                f->f_data = fcr;
-               fsetfd(curproc, f, fd);
+               fsetfd(td->td_proc->p_fd, f, fd);
                *(u_int32_t *)ap->a_data = fd;
                fdrop(f);
 
index 764c273..6fa5b20 100644 (file)
@@ -153,15 +153,16 @@ SLIST_HEAD(sigiolst, sigio);
 
 struct thread;
 struct proc;
+struct lwp;
 
 /*
  * Kernel global variables and routines.
  */
-int    dupfdopen (struct proc *, int, int, int, int);
+int    dupfdopen (struct filedesc *, int, int, int, int);
 int    fdalloc (struct proc *p, int want, int *result);
 int    fdavail (struct proc *p, int n);
-int    falloc (struct proc *p, struct file **resultfp, int *resultfd);
-void   fsetfd (struct proc *p, struct file *fp, int fd);
+int    falloc (struct lwp *lp, struct file **resultfp, int *resultfd);
+void   fsetfd (struct filedesc *fdp, struct file *fp, int fd);
 int    fgetfdflags(struct filedesc *fdp, int fd, int *flagsp);
 int    fsetfdflags(struct filedesc *fdp, int fd, int add_flags);
 int    fclrfdflags(struct filedesc *fdp, int fd, int rem_flags);
@@ -174,7 +175,7 @@ void        fdfree (struct proc *p, struct filedesc *repl);
 int    fdrevoke(void *f_data, short f_type, struct ucred *cred);
 int    closef (struct file *fp, struct proc *p);
 void   fdcloseexec (struct proc *p);
-int    fdcheckstd (struct proc *p);
+int    fdcheckstd (struct lwp *lp);
 struct file *holdfp (struct filedesc *fdp, int fd, int flag);
 int    holdsock (struct filedesc *fdp, int fdes, struct file **fpp);
 int    holdvnode (struct filedesc *fdp, int fd, struct file **fpp);