X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/6e7edb25cc39d3c7a292ffbce29991ab528249e3..fd88f5c5678c80ff5e338adc372d28a52ad20530:/usr/src/sys/kern/kern_descrip.c diff --git a/usr/src/sys/kern/kern_descrip.c b/usr/src/sys/kern/kern_descrip.c index e84ab721a1..3f2e4241b4 100644 --- a/usr/src/sys/kern/kern_descrip.c +++ b/usr/src/sys/kern/kern_descrip.c @@ -1,542 +1,930 @@ -/* kern_descrip.c 5.14 82/10/20 */ - -#include "../h/param.h" -#include "../h/systm.h" -#include "../h/dir.h" -#include "../h/user.h" -#include "../h/kernel.h" -#include "../h/inode.h" -#include "../h/proc.h" -#include "../h/conf.h" -#include "../h/file.h" -#include "../h/socket.h" -#include "../h/socketvar.h" -#include "../h/mount.h" - -#include "../h/descrip.h" - /* - * Descriptor management. + * Copyright (c) 1982, 1986, 1989, 1991, 1993 + * The Regents of the University of California. All rights reserved. + * (c) UNIX System Laboratories, Inc. + * All or some portions of this file are derived from material licensed + * to the University of California by American Telephone and Telegraph + * Co. or Unix System Laboratories, Inc. and are reproduced herein with + * the permission of UNIX System Laboratories, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)kern_descrip.c 8.8 (Berkeley) 2/14/95 */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + /* - * TODO: - * getf should be renamed - * ufalloc side effects are gross + * Descriptor management. */ +struct filelist filehead; /* head of list of open files */ +int nfiles; /* actual number of open files */ /* * System calls on descriptors. */ -getdtablesize() +/* ARGSUSED */ +int +getdtablesize(p, uap, retval) + struct proc *p; + void *uap; + register_t *retval; { - u.u_r.r_val1 = NOFILE; + *retval = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles); + return (0); } -getdprop() +/* + * Duplicate a file descriptor. + */ +/* ARGSUSED */ +int +dup(p, uap, retval) + struct proc *p; + struct dup_args /* { + syscallarg(u_int) fd; + } */ *uap; + register_t *retval; { - register struct a { - int d; - struct dtype *dtypeb; - } *uap = (struct a *)u.u_ap; - register struct file *fp; - struct dtype adtype; - - fp = getf(uap->d); - if (fp == 0) - return; - adtype.dt_type = 0; /* XXX */ - adtype.dt_protocol = 0; /* XXX */ - if (copyout((caddr_t)&adtype, (caddr_t)uap->dtypeb, - sizeof (struct dtype)) < 0) { - u.u_error = EFAULT; - return; + register struct filedesc *fdp; + u_int old; + int new, error; + + old = SCARG(uap, fd); + /* + * XXX Compatibility + */ + if (old &~ 077) { + SCARG(uap, fd) &= 077; + return (dup2(p, uap, retval)); } -} - -getdopt() -{ + fdp = p->p_fd; + if (old >= fdp->fd_nfiles || fdp->fd_ofiles[old] == NULL) + return (EBADF); + if (error = fdalloc(p, 0, &new)) + return (error); + return (finishdup(fdp, (int)old, new, retval)); } -setdopt() -{ - -} - -dup() +/* + * Duplicate a file descriptor to a particular value. + */ +/* ARGSUSED */ +int +dup2(p, uap, retval) + struct proc *p; + struct dup2_args /* { + syscallarg(u_int) from; + syscallarg(u_int) to; + } */ *uap; + register_t *retval; { - register struct a { - int i; - } *uap = (struct a *) u.u_ap; - struct file *fp; - int j; - - if (uap->i &~ 077) { uap->i &= 077; dup2(); return; } /* XXX */ - - fp = getf(uap->i); - if (fp == 0) - return; - j = ufalloc(); - if (j < 0) - return; - dupit(j, fp, u.u_pofile[uap->i] & (RDLOCK|WRLOCK)); + register struct filedesc *fdp = p->p_fd; + register int old = SCARG(uap, from), new = SCARG(uap, to); + int i, error; + + if (old >= fdp->fd_nfiles || + fdp->fd_ofiles[old] == NULL || + new >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur || + new >= maxfiles) + return (EBADF); + if (old == new) { + *retval = new; + return (0); + } + if (new >= fdp->fd_nfiles) { + if (error = fdalloc(p, new, &i)) + return (error); + if (new != i) + panic("dup2: fdalloc"); + } else if (fdp->fd_ofiles[new]) { + if (fdp->fd_ofileflags[new] & UF_MAPPED) + (void) munmapfd(p, new); + /* + * dup2() must succeed even if the close has an error. + */ + (void) closef(fdp->fd_ofiles[new], p); + } + return (finishdup(fdp, (int)old, (int)new, retval)); } -dup2() +/* + * The file control system call. + */ +/* ARGSUSED */ +int +fcntl(p, uap, retval) + struct proc *p; + register struct fcntl_args /* { + syscallarg(int) fd; + syscallarg(int) cmd; + syscallarg(void *) arg; + } */ *uap; + register_t *retval; { - register struct a { - int i, j; - } *uap = (struct a *) u.u_ap; + int fd = SCARG(uap, fd); + register struct filedesc *fdp = p->p_fd; register struct file *fp; + register char *pop; + struct vnode *vp; + int i, tmp, error, flg = F_POSIX; + struct flock fl; + u_int newmin; + + if ((u_int)fd >= fdp->fd_nfiles || + (fp = fdp->fd_ofiles[fd]) == NULL) + return (EBADF); + pop = &fdp->fd_ofileflags[fd]; + switch (SCARG(uap, cmd)) { + + case F_DUPFD: + newmin = (long)SCARG(uap, arg); + if (newmin >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur || + newmin >= maxfiles) + return (EINVAL); + if (error = fdalloc(p, newmin, &i)) + return (error); + return (finishdup(fdp, fd, i, retval)); + + case F_GETFD: + *retval = *pop & 1; + return (0); + + case F_SETFD: + *pop = (*pop &~ 1) | ((long)SCARG(uap, arg) & 1); + return (0); + + case F_GETFL: + *retval = OFLAGS(fp->f_flag); + return (0); + + case F_SETFL: + fp->f_flag &= ~FCNTLFLAGS; + fp->f_flag |= FFLAGS((long)SCARG(uap, arg)) & FCNTLFLAGS; + tmp = fp->f_flag & FNONBLOCK; + error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p); + if (error) + return (error); + tmp = fp->f_flag & FASYNC; + error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, (caddr_t)&tmp, p); + if (!error) + return (0); + fp->f_flag &= ~FNONBLOCK; + tmp = 0; + (void) (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p); + return (error); + + case F_GETOWN: + if (fp->f_type == DTYPE_SOCKET) { + *retval = ((struct socket *)fp->f_data)->so_pgid; + return (0); + } + error = (*fp->f_ops->fo_ioctl) + (fp, TIOCGPGRP, (caddr_t)retval, p); + *retval = -*retval; + return (error); + + case F_SETOWN: + if (fp->f_type == DTYPE_SOCKET) { + ((struct socket *)fp->f_data)->so_pgid = + (long)SCARG(uap, arg); + return (0); + } + if ((long)SCARG(uap, arg) <= 0) { + SCARG(uap, arg) = (void *)(-(long)SCARG(uap, arg)); + } else { + struct proc *p1 = pfind((long)SCARG(uap, arg)); + if (p1 == 0) + return (ESRCH); + SCARG(uap, arg) = (void *)(long)p1->p_pgrp->pg_id; + } + return ((*fp->f_ops->fo_ioctl) + (fp, TIOCSPGRP, (caddr_t)&SCARG(uap, arg), p)); + + case F_SETLKW: + flg |= F_WAIT; + /* Fall into F_SETLK */ + + case F_SETLK: + if (fp->f_type != DTYPE_VNODE) + return (EBADF); + vp = (struct vnode *)fp->f_data; + /* Copy in the lock structure */ + error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&fl, + sizeof (fl)); + if (error) + return (error); + if (fl.l_whence == SEEK_CUR) + fl.l_start += fp->f_offset; + switch (fl.l_type) { + + case F_RDLCK: + if ((fp->f_flag & FREAD) == 0) + return (EBADF); + p->p_flag |= P_ADVLOCK; + return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg)); + + case F_WRLCK: + if ((fp->f_flag & FWRITE) == 0) + return (EBADF); + p->p_flag |= P_ADVLOCK; + return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg)); + + case F_UNLCK: + return (VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &fl, + F_POSIX)); + + default: + return (EINVAL); + } - fp = getf(uap->i); - if (fp == 0) - return; - if (uap->j < 0 || uap->j >= NOFILE) { - u.u_error = EBADF; - return; - } - u.u_r.r_val1 = uap->j; - if (uap->i == uap->j) - return; - if (u.u_ofile[uap->j]) { - closef(u.u_ofile[uap->j], 0, u.u_pofile[uap->j]); - if (u.u_error) - return; - /* u.u_ofile[uap->j] = 0; */ - /* u.u_pofile[uap->j] = 0; */ + case F_GETLK: + if (fp->f_type != DTYPE_VNODE) + return (EBADF); + vp = (struct vnode *)fp->f_data; + /* Copy in the lock structure */ + error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&fl, + sizeof (fl)); + if (error) + return (error); + if (fl.l_whence == SEEK_CUR) + fl.l_start += fp->f_offset; + if (error = VOP_ADVLOCK(vp, (caddr_t)p, F_GETLK, &fl, F_POSIX)) + return (error); + return (copyout((caddr_t)&fl, (caddr_t)SCARG(uap, arg), + sizeof (fl))); + + default: + return (EINVAL); } - dupit(uap->j, fp, u.u_pofile[uap->i] & (RDLOCK|WRLOCK)); + /* NOTREACHED */ } -dupit(fd, fp, lockflags) - int fd; - register struct file *fp; - register int lockflags; +/* + * Common code for dup, dup2, and fcntl(F_DUPFD). + */ +int +finishdup(fdp, old, new, retval) + register struct filedesc *fdp; + register int old, new; + register_t *retval; { + register struct file *fp; - u.u_ofile[fd] = fp; - u.u_pofile[fd] = lockflags; + fp = fdp->fd_ofiles[old]; + fdp->fd_ofiles[new] = fp; + fdp->fd_ofileflags[new] = fdp->fd_ofileflags[old] &~ UF_EXCLOSE; fp->f_count++; - if (lockflags&RDLOCK) - fp->f_inode->i_rdlockc++; - if (lockflags&WRLOCK) - fp->f_inode->i_wrlockc++; + if (new > fdp->fd_lastfile) + fdp->fd_lastfile = new; + *retval = new; + return (0); } -close() +/* + * Close a file descriptor. + */ +/* ARGSUSED */ +int +close(p, uap, retval) + struct proc *p; + struct close_args /* { + syscallarg(int) fd; + } */ *uap; + register_t *retval; { - register struct a { - int i; - } *uap = (struct a *)u.u_ap; + int fd = SCARG(uap, fd); + register struct filedesc *fdp = p->p_fd; register struct file *fp; - - fp = getf(uap->i); - if (fp == 0) - return; - closef(fp, 0, u.u_pofile[uap->i]); - /* WHAT IF u.u_error ? */ - u.u_ofile[uap->i] = NULL; - u.u_pofile[uap->i] = 0; + register u_char *pf; + + if ((u_int)fd >= fdp->fd_nfiles || + (fp = fdp->fd_ofiles[fd]) == NULL) + return (EBADF); + pf = (u_char *)&fdp->fd_ofileflags[fd]; + if (*pf & UF_MAPPED) + (void) munmapfd(p, fd); + fdp->fd_ofiles[fd] = NULL; + while (fdp->fd_lastfile > 0 && fdp->fd_ofiles[fdp->fd_lastfile] == NULL) + fdp->fd_lastfile--; + if (fd < fdp->fd_freefile) + fdp->fd_freefile = fd; + *pf = 0; + return (closef(fp, p)); } -wrap() +#if defined(COMPAT_43) || defined(COMPAT_SUNOS) +/* + * Return status information about a file descriptor. + */ +/* ARGSUSED */ +int +compat_43_fstat(p, uap, retval) + struct proc *p; + register struct compat_43_fstat_args /* { + syscallarg(int) fd; + syscallarg(struct ostat *) sb; + } */ *uap; + register_t *retval; { - register struct a { - int d; - struct dtype *dtypeb; - } *uap = (struct a *)u.u_ap; + int fd = SCARG(uap, fd); + register struct filedesc *fdp = p->p_fd; register struct file *fp; - struct dtype adtype; + struct stat ub; + struct ostat oub; + int error; - fp = getf(uap->d); - if (fp == 0) - return; - if (copyin((caddr_t)uap->dtypeb, (caddr_t)&adtype, - sizeof (struct dtype)) < 0) { - u.u_error = EFAULT; - return; - } - /* DO WRAP */ -} + if ((u_int)fd >= fdp->fd_nfiles || + (fp = fdp->fd_ofiles[fd]) == NULL) + return (EBADF); + switch (fp->f_type) { -int unselect(); -int nselcoll; -/* - * Select system call. - */ -select() -{ - register struct uap { - int nd; - long *in; - long *ou; - long *ex; - struct timeval *tv; - } *uap = (struct uap *)u.u_ap; - int ibits[3], obits[3]; - struct timeval atv; - int s, ncoll; - label_t lqsave; - - if (uap->nd >= NOFILE) { - u.u_error = EINVAL; - return; - } + case DTYPE_VNODE: + error = vn_stat((struct vnode *)fp->f_data, &ub, p); + break; -#define getbits(name, x) \ - if (uap->name) { \ - if (copyin((caddr_t)uap->name, (caddr_t)&ibits[x], \ - sizeof (ibits[x]))) { \ - u.u_error = EFAULT; \ - return; \ - } \ - } else \ - ibits[x] = 0; - getbits(in, 0); - getbits(ou, 1); - getbits(ex, 2); -#undef getbits - - if (uap->tv) { - if (copyin((caddr_t)uap->tv, (caddr_t)&atv, sizeof (atv))) { - u.u_error = EFAULT; - return; - } - if (itimerfix(&atv)) { - u.u_error = EINVAL; - return; - } - s = spl7(); timevaladd(&atv, &time); splx(s); - } -retry: - ncoll = nselcoll; - u.u_procp->p_flag |= SSEL; - u.u_r.r_val1 = selscan(ibits, obits); - if (u.u_error) - return; - if (u.u_r.r_val1) - goto done; - s = spl6(); - if (uap->tv && timercmp(&time, &atv, >=)) { - splx(s); - goto done; - } - if ((u.u_procp->p_flag & SSEL) == 0 || nselcoll != ncoll) { - u.u_procp->p_flag &= ~SSEL; - splx(s); - goto retry; - } - u.u_procp->p_flag &= ~SSEL; - if (uap->tv) { - lqsave = u.u_qsave; - if (setjmp(&u.u_qsave)) { - untimeout(unselect, (caddr_t)u.u_procp); - u.u_error = EINTR; - splx(s); - return; - } - timeout(unselect, (caddr_t)u.u_procp, hzto(&atv)); - } - sleep((caddr_t)&selwait, PZERO+1); - if (uap->tv) { - u.u_qsave = lqsave; - untimeout(unselect, (caddr_t)u.u_procp); - } - splx(s); - goto retry; -done: -#define putbits(name, x) \ - if (uap->name) { \ - if (copyout((caddr_t)obits[x], (caddr_t)uap->name, \ - sizeof (obits[x]))) { \ - u.u_error = EFAULT; \ - return; \ - } \ + case DTYPE_SOCKET: + error = soo_stat((struct socket *)fp->f_data, &ub); + break; + + default: + panic("ofstat"); + /*NOTREACHED*/ } - putbits(in, 0); - putbits(ou, 1); - putbits(ex, 2); -#undef putbits + cvtstat(&ub, &oub); + if (error == 0) + error = copyout((caddr_t)&oub, (caddr_t)SCARG(uap, sb), + sizeof (oub)); + return (error); } +#endif /* COMPAT_43 || COMPAT_SUNOS */ -unselect(p) - register struct proc *p; +/* + * Return status information about a file descriptor. + */ +/* ARGSUSED */ +int +fstat(p, uap, retval) + struct proc *p; + register struct fstat_args /* { + syscallarg(int) fd; + syscallarg(struct stat *) sb; + } */ *uap; + register_t *retval; { - register int s = spl6(); + int fd = SCARG(uap, fd); + register struct filedesc *fdp = p->p_fd; + register struct file *fp; + struct stat ub; + int error; - switch (p->p_stat) { + if ((u_int)fd >= fdp->fd_nfiles || + (fp = fdp->fd_ofiles[fd]) == NULL) + return (EBADF); + switch (fp->f_type) { - case SSLEEP: - setrun(p); + case DTYPE_VNODE: + error = vn_stat((struct vnode *)fp->f_data, &ub, p); break; - case SSTOP: - unsleep(p); + case DTYPE_SOCKET: + error = soo_stat((struct socket *)fp->f_data, &ub); break; + + default: + panic("fstat"); + /*NOTREACHED*/ } - splx(s); + if (error == 0) + error = copyout((caddr_t)&ub, (caddr_t)SCARG(uap, sb), + sizeof (ub)); + return (error); } -selscan(ibits, obits) - int *ibits, *obits; +/* + * Return pathconf information about a file descriptor. + */ +/* ARGSUSED */ +int +fpathconf(p, uap, retval) + struct proc *p; + register struct fpathconf_args /* { + syscallarg(int) fd; + syscallarg(int) name; + } */ *uap; + register_t *retval; { - register int which, bits, i; - int flag; + int fd = SCARG(uap, fd); + struct filedesc *fdp = p->p_fd; struct file *fp; - int able; - struct inode *ip; - int n = 0; + struct vnode *vp; - for (which = 0; which < 3; which++) { - bits = ibits[which]; - obits[which] = 0; - switch (which) { + if ((u_int)fd >= fdp->fd_nfiles || + (fp = fdp->fd_ofiles[fd]) == NULL) + return (EBADF); + switch (fp->f_type) { - case 0: - flag = FREAD; break; + case DTYPE_SOCKET: + if (SCARG(uap, name) != _PC_PIPE_BUF) + return (EINVAL); + *retval = PIPE_BUF; + return (0); - case 1: - flag = FWRITE; break; + case DTYPE_VNODE: + vp = (struct vnode *)fp->f_data; + return (VOP_PATHCONF(vp, SCARG(uap, name), retval)); - case 2: - flag = 0; break; - } - while (i = ffs(bits)) { - bits &= ~(1<<(i-1)); - fp = u.u_ofile[i-1]; - if (fp == NULL) { - u.u_error = EBADF; - break; - } - if (fp->f_type == DTYPE_SOCKET) - able = soselect(fp->f_socket, flag); - else { - ip = fp->f_inode; - switch (ip->i_mode & IFMT) { - - case IFCHR: - able = - (*cdevsw[major(ip->i_rdev)].d_select) - (ip->i_rdev, flag); - break; - - case IFBLK: - case IFREG: - case IFDIR: - able = 1; - break; - } + default: + panic("fpathconf"); + } + /*NOTREACHED*/ +} - } - if (able) { - obits[which] |= (1<<(i-1)); - n++; +/* + * Allocate a file descriptor for the process. + */ +int fdexpand; + +int +fdalloc(p, want, result) + struct proc *p; + int want; + int *result; +{ + register struct filedesc *fdp = p->p_fd; + register int i; + int lim, last, nfiles; + struct file **newofile; + char *newofileflags; + + /* + * Search for a free descriptor starting at the higher + * of want or fd_freefile. If that fails, consider + * expanding the ofile array. + */ + lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles); + for (;;) { + last = min(fdp->fd_nfiles, lim); + if ((i = want) < fdp->fd_freefile) + i = fdp->fd_freefile; + for (; i < last; i++) { + if (fdp->fd_ofiles[i] == NULL) { + fdp->fd_ofileflags[i] = 0; + if (i > fdp->fd_lastfile) + fdp->fd_lastfile = i; + if (want <= fdp->fd_freefile) + fdp->fd_freefile = i; + *result = i; + return (0); } } + + /* + * No space in current array. Expand? + */ + if (fdp->fd_nfiles >= lim) + return (EMFILE); + if (fdp->fd_nfiles < NDEXTENT) + nfiles = NDEXTENT; + else + nfiles = 2 * fdp->fd_nfiles; + MALLOC(newofile, struct file **, nfiles * OFILESIZE, + M_FILEDESC, M_WAITOK); + newofileflags = (char *) &newofile[nfiles]; + /* + * Copy the existing ofile and ofileflags arrays + * and zero the new portion of each array. + */ + bcopy(fdp->fd_ofiles, newofile, + (i = sizeof(struct file *) * fdp->fd_nfiles)); + bzero((char *)newofile + i, nfiles * sizeof(struct file *) - i); + bcopy(fdp->fd_ofileflags, newofileflags, + (i = sizeof(char) * fdp->fd_nfiles)); + bzero(newofileflags + i, nfiles * sizeof(char) - i); + if (fdp->fd_nfiles > NDFILE) + FREE(fdp->fd_ofiles, M_FILEDESC); + fdp->fd_ofiles = newofile; + fdp->fd_ofileflags = newofileflags; + fdp->fd_nfiles = nfiles; + fdexpand++; } - return (n); } -/*ARGSUSED*/ -seltrue(dev, flag) - dev_t dev; - int flag; +/* + * Check to see whether n user file descriptors + * are available to the process p. + */ +int +fdavail(p, n) + struct proc *p; + register int n; { - - return (1); + register struct filedesc *fdp = p->p_fd; + register struct file **fpp; + register int i, lim; + + lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles); + if ((i = lim - fdp->fd_nfiles) > 0 && (n -= i) <= 0) + return (1); + fpp = &fdp->fd_ofiles[fdp->fd_freefile]; + for (i = fdp->fd_nfiles - fdp->fd_freefile; --i >= 0; fpp++) + if (*fpp == NULL && --n <= 0) + return (1); + return (0); } -selwakeup(p, coll) +/* + * Create a new open file structure and allocate + * a file decriptor for the process that refers to it. + */ +int +falloc(p, resultfp, resultfd) register struct proc *p; - int coll; + struct file **resultfp; + int *resultfd; { - int s; - - if (coll) { - nselcoll++; - wakeup((caddr_t)&selwait); + register struct file *fp, *fq; + int error, i; + + if (error = fdalloc(p, 0, &i)) + return (error); + if (nfiles >= maxfiles) { + tablefull("file"); + return (ENFILE); } - if (p) { - if (p->p_wchan == (caddr_t)&selwait) - setrun(p); - else { - s = spl6(); - if (p->p_flag & SSEL) - p->p_flag &= ~SSEL; - splx(s); - } + /* + * Allocate a new file descriptor. + * If the process has file descriptor zero open, add to the list + * of open files at that point, otherwise put it at the front of + * the list of open files. + */ + nfiles++; + MALLOC(fp, struct file *, sizeof(struct file), M_FILE, M_WAITOK); + bzero(fp, sizeof(struct file)); + if (fq = p->p_fd->fd_ofiles[0]) { + LIST_INSERT_AFTER(fq, fp, f_list); + } else { + LIST_INSERT_HEAD(&filehead, fp, f_list); } -} - -revoke() -{ - - /* XXX */ + p->p_fd->fd_ofiles[i] = fp; + fp->f_count = 1; + fp->f_cred = p->p_ucred; + crhold(fp->f_cred); + if (resultfp) + *resultfp = fp; + if (resultfd) + *resultfd = i; + return (0); } /* - * Allocate a user file descriptor. + * Free a file descriptor. */ -ufalloc() +void +ffree(fp) + register struct file *fp; { - register i; + register struct file *fq; - for (i=0; if_cred); +#ifdef DIAGNOSTIC + fp->f_count = 0; +#endif + nfiles--; + FREE(fp, M_FILE); } -struct file *lastf; /* - * Allocate a user file descriptor - * and a file structure. - * Initialize the descriptor - * to point at the file structure. + * Copy a filedesc structure. */ -struct file * -falloc() +struct filedesc * +fdcopy(p) + struct proc *p; { - register struct file *fp; - register i; - - i = ufalloc(); - if (i < 0) - return (NULL); - if (lastf == 0) - lastf = file; - for (fp = lastf; fp < fileNFILE; fp++) - if (fp->f_count == 0) - goto slot; - for (fp = file; fp < lastf; fp++) - if (fp->f_count == 0) - goto slot; - tablefull("file"); - u.u_error = ENFILE; - return (NULL); -slot: - u.u_ofile[i] = fp; - fp->f_count++; - fp->f_offset = 0; - fp->f_inode = 0; - lastf = fp + 1; - return (fp); + register struct filedesc *newfdp, *fdp = p->p_fd; + register struct file **fpp; + register int i; + + MALLOC(newfdp, struct filedesc *, sizeof(struct filedesc0), + M_FILEDESC, M_WAITOK); + bcopy(fdp, newfdp, sizeof(struct filedesc)); + VREF(newfdp->fd_cdir); + if (newfdp->fd_rdir) + VREF(newfdp->fd_rdir); + newfdp->fd_refcnt = 1; + + /* + * If the number of open files fits in the internal arrays + * of the open file structure, use them, otherwise allocate + * additional memory for the number of descriptors currently + * in use. + */ + if (newfdp->fd_lastfile < NDFILE) { + newfdp->fd_ofiles = ((struct filedesc0 *) newfdp)->fd_dfiles; + newfdp->fd_ofileflags = + ((struct filedesc0 *) newfdp)->fd_dfileflags; + i = NDFILE; + } else { + /* + * Compute the smallest multiple of NDEXTENT needed + * for the file descriptors currently in use, + * allowing the table to shrink. + */ + i = newfdp->fd_nfiles; + while (i > 2 * NDEXTENT && i > newfdp->fd_lastfile * 2) + i /= 2; + MALLOC(newfdp->fd_ofiles, struct file **, i * OFILESIZE, + M_FILEDESC, M_WAITOK); + newfdp->fd_ofileflags = (char *) &newfdp->fd_ofiles[i]; + } + newfdp->fd_nfiles = i; + bcopy(fdp->fd_ofiles, newfdp->fd_ofiles, i * sizeof(struct file **)); + bcopy(fdp->fd_ofileflags, newfdp->fd_ofileflags, i * sizeof(char)); + fpp = newfdp->fd_ofiles; + for (i = newfdp->fd_lastfile; i-- >= 0; fpp++) + if (*fpp != NULL) + (*fpp)->f_count++; + return (newfdp); } + /* - * Convert a user supplied file descriptor into a pointer - * to a file structure. Only task is to check range of the descriptor. - * Critical paths should use the GETF macro, defined in inline.h. + * Release a filedesc structure. */ -struct file * -getf(f) - register int f; +void +fdfree(p) + struct proc *p; { - register struct file *fp; + register struct filedesc *fdp = p->p_fd; + struct file **fpp; + register int i; - if ((unsigned)f >= NOFILE || (fp = u.u_ofile[f]) == NULL) { - u.u_error = EBADF; - return (NULL); - } - return (fp); + if (--fdp->fd_refcnt > 0) + return; + fpp = fdp->fd_ofiles; + for (i = fdp->fd_lastfile; i-- >= 0; fpp++) + if (*fpp) + (void) closef(*fpp, p); + if (fdp->fd_nfiles > NDFILE) + FREE(fdp->fd_ofiles, M_FILEDESC); + vrele(fdp->fd_cdir); + if (fdp->fd_rdir) + vrele(fdp->fd_rdir); + FREE(fdp, M_FILEDESC); } /* * Internal form of close. - * Decrement reference count on - * file structure. - * Also make sure the pipe protocol - * does not constipate. - * - * Decrement reference count on the inode following - * removal to the referencing file structure. - * Call device handler on last close. - * Nouser indicates that the user isn't available to present - * errors to. - * - * Handling locking at this level is RIDICULOUS. + * Decrement reference count on file structure. + * Note: p may be NULL when closing a file + * that was being passed in a message. */ -closef(fp, nouser, flags) +int +closef(fp, p) register struct file *fp; - int nouser, flags; + register struct proc *p; { - register struct inode *ip; - register struct mount *mp; - int flag, mode; - dev_t dev; - register int (*cfunc)(); + struct vnode *vp; + struct flock lf; + int error; if (fp == NULL) - return; - if (fp->f_count > 1) { - fp->f_count--; - return; + return (0); + /* + * POSIX record locking dictates that any close releases ALL + * locks owned by this process. This is handled by setting + * a flag in the unlock to free ONLY locks obeying POSIX + * semantics, and not to free BSD-style file locks. + * If the descriptor was in a message, POSIX-style locks + * aren't passed with the descriptor. + */ + if (p && (p->p_flag & P_ADVLOCK) && fp->f_type == DTYPE_VNODE) { + lf.l_whence = SEEK_SET; + lf.l_start = 0; + lf.l_len = 0; + lf.l_type = F_UNLCK; + vp = (struct vnode *)fp->f_data; + (void) VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_POSIX); } - if (fp->f_type == DTYPE_SOCKET) { - u.u_error = soclose(fp->f_socket, nouser); - if (nouser == 0 && u.u_error) - return; - fp->f_socket = 0; - fp->f_count = 0; - return; + if (--fp->f_count > 0) + return (0); + if (fp->f_count < 0) + panic("closef: count < 0"); + if ((fp->f_flag & FHASLOCK) && fp->f_type == DTYPE_VNODE) { + lf.l_whence = SEEK_SET; + lf.l_start = 0; + lf.l_len = 0; + lf.l_type = F_UNLCK; + vp = (struct vnode *)fp->f_data; + (void) VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK); } - flag = fp->f_flag; - ip = fp->f_inode; - dev = (dev_t)ip->i_rdev; - mode = ip->i_mode & IFMT; - flags &= RDLOCK|WRLOCK; /* conservative */ - if (flags) - funlocki(ip, flags); - ilock(ip); - iput(ip); - fp->f_count = 0; + if (fp->f_ops) + error = (*fp->f_ops->fo_close)(fp, p); + else + error = 0; + ffree(fp); + return (error); +} - switch (mode) { +/* + * Apply an advisory lock on a file descriptor. + * + * Just attempt to get a record lock of the requested type on + * the entire file (l_whence = SEEK_SET, l_start = 0, l_len = 0). + */ +/* ARGSUSED */ +int +flock(p, uap, retval) + struct proc *p; + register struct flock_args /* { + syscallarg(int) fd; + syscallarg(int) how; + } */ *uap; + register_t *retval; +{ + int fd = SCARG(uap, fd); + int how = SCARG(uap, how); + register struct filedesc *fdp = p->p_fd; + register struct file *fp; + struct vnode *vp; + struct flock lf; + + if ((u_int)fd >= fdp->fd_nfiles || + (fp = fdp->fd_ofiles[fd]) == NULL) + return (EBADF); + if (fp->f_type != DTYPE_VNODE) + return (EOPNOTSUPP); + vp = (struct vnode *)fp->f_data; + lf.l_whence = SEEK_SET; + lf.l_start = 0; + lf.l_len = 0; + if (how & LOCK_UN) { + lf.l_type = F_UNLCK; + fp->f_flag &= ~FHASLOCK; + return (VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK)); + } + if (how & LOCK_EX) + lf.l_type = F_WRLCK; + else if (how & LOCK_SH) + lf.l_type = F_RDLCK; + else + return (EBADF); + fp->f_flag |= FHASLOCK; + if (how & LOCK_NB) + return (VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, F_FLOCK)); + return (VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, F_FLOCK|F_WAIT)); +} - case IFCHR: - cfunc = cdevsw[major(dev)].d_close; - break; +/* + * File Descriptor pseudo-device driver (/dev/fd/). + * + * Opening minor device N dup()s the file (if any) connected to file + * descriptor N belonging to the calling process. Note that this driver + * consists of only the ``open()'' routine, because all subsequent + * references to this file will be direct to the other driver. + */ +/* ARGSUSED */ +int +fdopen(dev, mode, type, p) + dev_t dev; + int mode, type; + struct proc *p; +{ - case IFBLK: + /* + * XXX Kludge: set curproc->p_dupfd to contain the value of the + * the file descriptor being sought for duplication. The error + * return ensures that the vnode for this device will be released + * by vn_open. Open will detect this special error and take the + * actions in dupfdopen below. Other callers of vn_open or VOP_OPEN + * will simply report the error. + */ + p->p_dupfd = minor(dev); + return (ENODEV); +} + +/* + * Duplicate the specified descriptor to a free descriptor. + */ +int +dupfdopen(fdp, indx, dfd, mode, error) + register struct filedesc *fdp; + register int indx, dfd; + int mode; + int error; +{ + register struct file *wfp; + struct file *fp; + + /* + * If the to-be-dup'd fd number is greater than the allowed number + * of file descriptors, or the fd to be dup'd has already been + * closed, reject. Note, check for new == old is necessary as + * falloc could allocate an already closed to-be-dup'd descriptor + * as the new descriptor. + */ + fp = fdp->fd_ofiles[indx]; + if ((u_int)dfd >= fdp->fd_nfiles || + (wfp = fdp->fd_ofiles[dfd]) == NULL || fp == wfp) + return (EBADF); + + /* + * There are two cases of interest here. + * + * For ENODEV simply dup (dfd) to file descriptor + * (indx) and return. + * + * For ENXIO steal away the file structure from (dfd) and + * store it in (indx). (dfd) is effectively closed by + * this operation. + * + * Any other error code is just returned. + */ + switch (error) { + case ENODEV: /* - * We don't want to really close the device if it is mounted + * Check that the mode the file is being opened for is a + * subset of the mode of the existing descriptor. */ - for (mp = mount; mp < &mount[NMOUNT]; mp++) - if (mp->m_bufp != NULL && mp->m_dev == dev) - return; - cfunc = bdevsw[major(dev)].d_close; - break; - - default: - return; - } - for (fp = file; fp < fileNFILE; fp++) { - if (fp->f_type == DTYPE_SOCKET) /* XXX */ - continue; - if (fp->f_count && (ip = fp->f_inode) && - ip->i_rdev == dev && (ip->i_mode&IFMT) == mode) - return; - } - if (mode == IFBLK) { + if (((mode & (FREAD|FWRITE)) | wfp->f_flag) != wfp->f_flag) + return (EACCES); + fdp->fd_ofiles[indx] = wfp; + fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd]; + wfp->f_count++; + if (indx > fdp->fd_lastfile) + fdp->fd_lastfile = indx; + return (0); + + case ENXIO: /* - * On last close of a block device (that isn't mounted) - * we must invalidate any in core blocks + * Steal away the file pointer from dfd, and stuff it into indx. */ - bflush(dev); - binval(dev); - } - (*cfunc)(dev, flag, fp); -} - -opause() -{ + fdp->fd_ofiles[indx] = fdp->fd_ofiles[dfd]; + fdp->fd_ofiles[dfd] = NULL; + fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd]; + fdp->fd_ofileflags[dfd] = 0; + /* + * Complete the clean up of the filedesc structure by + * recomputing the various hints. + */ + if (indx > fdp->fd_lastfile) + fdp->fd_lastfile = indx; + else + while (fdp->fd_lastfile > 0 && + fdp->fd_ofiles[fdp->fd_lastfile] == NULL) + fdp->fd_lastfile--; + if (dfd < fdp->fd_freefile) + fdp->fd_freefile = dfd; + return (0); - for (;;) - sleep((caddr_t)&u, PSLEP); + default: + return (error); + } + /* NOTREACHED */ }