Home | History | Annotate | Line # | Download | only in kern
kern_descrip.c revision 1.130
      1  1.130  christos /*	$NetBSD: kern_descrip.c,v 1.130 2005/02/12 23:14:03 christos Exp $	*/
      2   1.22       cgd 
      3   1.16       cgd /*
      4   1.17       cgd  * Copyright (c) 1982, 1986, 1989, 1991, 1993
      5   1.17       cgd  *	The Regents of the University of California.  All rights reserved.
      6   1.16       cgd  * (c) UNIX System Laboratories, Inc.
      7   1.16       cgd  * All or some portions of this file are derived from material licensed
      8   1.16       cgd  * to the University of California by American Telephone and Telegraph
      9   1.16       cgd  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
     10   1.16       cgd  * the permission of UNIX System Laboratories, Inc.
     11   1.16       cgd  *
     12   1.16       cgd  * Redistribution and use in source and binary forms, with or without
     13   1.16       cgd  * modification, are permitted provided that the following conditions
     14   1.16       cgd  * are met:
     15   1.16       cgd  * 1. Redistributions of source code must retain the above copyright
     16   1.16       cgd  *    notice, this list of conditions and the following disclaimer.
     17   1.16       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     18   1.16       cgd  *    notice, this list of conditions and the following disclaimer in the
     19   1.16       cgd  *    documentation and/or other materials provided with the distribution.
     20  1.111       agc  * 3. Neither the name of the University nor the names of its contributors
     21   1.16       cgd  *    may be used to endorse or promote products derived from this software
     22   1.16       cgd  *    without specific prior written permission.
     23   1.16       cgd  *
     24   1.16       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     25   1.16       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     26   1.16       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     27   1.16       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     28   1.16       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     29   1.16       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     30   1.16       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     31   1.16       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     32   1.16       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     33   1.16       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     34   1.16       cgd  * SUCH DAMAGE.
     35   1.16       cgd  *
     36   1.51      fvdl  *	@(#)kern_descrip.c	8.8 (Berkeley) 2/14/95
     37   1.16       cgd  */
     38   1.81     lukem 
     39   1.81     lukem #include <sys/cdefs.h>
     40  1.130  christos __KERNEL_RCSID(0, "$NetBSD: kern_descrip.c,v 1.130 2005/02/12 23:14:03 christos Exp $");
     41   1.50       mrg 
     42   1.16       cgd #include <sys/param.h>
     43   1.16       cgd #include <sys/systm.h>
     44   1.16       cgd #include <sys/filedesc.h>
     45   1.16       cgd #include <sys/kernel.h>
     46   1.16       cgd #include <sys/vnode.h>
     47   1.16       cgd #include <sys/proc.h>
     48   1.16       cgd #include <sys/file.h>
     49   1.86  christos #include <sys/namei.h>
     50   1.16       cgd #include <sys/socket.h>
     51   1.16       cgd #include <sys/socketvar.h>
     52   1.16       cgd #include <sys/stat.h>
     53   1.16       cgd #include <sys/ioctl.h>
     54   1.16       cgd #include <sys/fcntl.h>
     55   1.16       cgd #include <sys/malloc.h>
     56   1.55   thorpej #include <sys/pool.h>
     57   1.16       cgd #include <sys/syslog.h>
     58   1.17       cgd #include <sys/unistd.h>
     59   1.16       cgd #include <sys/resourcevar.h>
     60   1.42  christos #include <sys/conf.h>
     61   1.96  jdolecek #include <sys/event.h>
     62   1.16       cgd 
     63   1.25       cgd #include <sys/mount.h>
     64   1.99   thorpej #include <sys/sa.h>
     65   1.25       cgd #include <sys/syscallargs.h>
     66   1.38  christos 
     67   1.16       cgd /*
     68   1.16       cgd  * Descriptor management.
     69   1.16       cgd  */
     70   1.72     lukem struct filelist	filehead;	/* head of list of open files */
     71   1.72     lukem int		nfiles;		/* actual number of open files */
     72  1.125    simonb POOL_INIT(file_pool, sizeof(struct file), 0, 0, 0, "filepl",
     73  1.125    simonb     &pool_allocator_nointr);
     74  1.125    simonb POOL_INIT(cwdi_pool, sizeof(struct cwdinfo), 0, 0, 0, "cwdipl",
     75  1.125    simonb     &pool_allocator_nointr);
     76  1.125    simonb POOL_INIT(filedesc0_pool, sizeof(struct filedesc0), 0, 0, 0, "fdescpl",
     77  1.125    simonb     &pool_allocator_nointr);
     78  1.101   thorpej 
     79  1.102        pk /* Global file list lock */
     80  1.102        pk static struct simplelock filelist_slock = SIMPLELOCK_INITIALIZER;
     81  1.102        pk 
     82  1.101   thorpej MALLOC_DEFINE(M_FILE, "file", "Open file structure");
     83  1.101   thorpej MALLOC_DEFINE(M_FILEDESC, "file desc", "Open file descriptor table");
     84  1.101   thorpej MALLOC_DEFINE(M_IOCTLOPS, "ioctlops", "ioctl data buffer");
     85   1.72     lukem 
     86   1.72     lukem static __inline void	fd_used(struct filedesc *, int);
     87   1.72     lukem static __inline void	fd_unused(struct filedesc *, int);
     88  1.115    provos static __inline int	find_next_zero(uint32_t *, int, u_int);
     89  1.110      fvdl int			finishdup(struct proc *, int, int, register_t *);
     90  1.115    provos int			find_last_set(struct filedesc *, int);
     91  1.110      fvdl int			fcntl_forfs(int, struct proc *, int, void *);
     92   1.94   gehenna 
     93   1.94   gehenna dev_type_open(filedescopen);
     94   1.94   gehenna 
     95   1.94   gehenna const struct cdevsw filedesc_cdevsw = {
     96   1.94   gehenna 	filedescopen, noclose, noread, nowrite, noioctl,
     97   1.96  jdolecek 	nostop, notty, nopoll, nommap, nokqfilter,
     98   1.94   gehenna };
     99   1.38  christos 
    100  1.115    provos static __inline int
    101  1.115    provos find_next_zero(uint32_t *bitmap, int want, u_int bits)
    102  1.115    provos {
    103  1.115    provos 	int i, off, maxoff;
    104  1.115    provos 	uint32_t sub;
    105  1.115    provos 
    106  1.115    provos 	if (want > bits)
    107  1.115    provos 		return -1;
    108  1.115    provos 
    109  1.115    provos 	off = want >> NDENTRYSHIFT;
    110  1.115    provos 	i = want & NDENTRYMASK;
    111  1.115    provos 	if (i) {
    112  1.115    provos 		sub = bitmap[off] | ((u_int)~0 >> (NDENTRIES - i));
    113  1.115    provos 		if (sub != ~0)
    114  1.115    provos 			goto found;
    115  1.115    provos 		off++;
    116  1.115    provos 	}
    117  1.115    provos 
    118  1.115    provos 	maxoff = NDLOSLOTS(bits);
    119  1.115    provos 	while (off < maxoff) {
    120  1.115    provos 		if ((sub = bitmap[off]) != ~0)
    121  1.115    provos 			goto found;
    122  1.115    provos 		off++;
    123  1.115    provos 	}
    124  1.115    provos 
    125  1.115    provos 	return (-1);
    126  1.115    provos 
    127  1.115    provos  found:
    128  1.115    provos 	return (off << NDENTRYSHIFT) + ffs(~sub) - 1;
    129  1.115    provos }
    130  1.115    provos 
    131  1.115    provos int
    132  1.115    provos find_last_set(struct filedesc *fd, int last)
    133  1.115    provos {
    134  1.115    provos 	int off, i;
    135  1.115    provos 	struct file **ofiles = fd->fd_ofiles;
    136  1.115    provos 	uint32_t *bitmap = fd->fd_lomap;
    137  1.115    provos 
    138  1.115    provos 	off = (last - 1) >> NDENTRYSHIFT;
    139  1.115    provos 
    140  1.121    provos 	while (off >= 0 && !bitmap[off])
    141  1.115    provos 		off--;
    142  1.115    provos 
    143  1.115    provos 	if (off < 0)
    144  1.128      cube 		return (-1);
    145  1.115    provos 
    146  1.115    provos 	i = ((off + 1) << NDENTRYSHIFT) - 1;
    147  1.115    provos 	if (i >= last)
    148  1.115    provos 		i = last - 1;
    149  1.115    provos 
    150  1.115    provos 	while (i > 0 && ofiles[i] == NULL)
    151  1.115    provos 		i--;
    152  1.115    provos 
    153  1.115    provos 	return (i);
    154  1.115    provos }
    155  1.115    provos 
    156   1.38  christos static __inline void
    157   1.72     lukem fd_used(struct filedesc *fdp, int fd)
    158   1.27   mycroft {
    159  1.115    provos 	u_int off = fd >> NDENTRYSHIFT;
    160  1.115    provos 
    161  1.126        pk 	LOCK_ASSERT(simple_lock_held(&fdp->fd_slock));
    162  1.124      yamt 	KDASSERT((fdp->fd_lomap[off] & (1 << (fd & NDENTRYMASK))) == 0);
    163  1.124      yamt 
    164  1.115    provos 	fdp->fd_lomap[off] |= 1 << (fd & NDENTRYMASK);
    165  1.124      yamt 	if (fdp->fd_lomap[off] == ~0) {
    166  1.124      yamt 		KDASSERT((fdp->fd_himap[off >> NDENTRYSHIFT] &
    167  1.124      yamt 		    (1 << (off & NDENTRYMASK))) == 0);
    168  1.115    provos 		fdp->fd_himap[off >> NDENTRYSHIFT] |= 1 << (off & NDENTRYMASK);
    169  1.124      yamt 	}
    170   1.27   mycroft 
    171   1.27   mycroft 	if (fd > fdp->fd_lastfile)
    172   1.27   mycroft 		fdp->fd_lastfile = fd;
    173   1.27   mycroft }
    174   1.27   mycroft 
    175   1.38  christos static __inline void
    176   1.72     lukem fd_unused(struct filedesc *fdp, int fd)
    177   1.27   mycroft {
    178  1.115    provos 	u_int off = fd >> NDENTRYSHIFT;
    179   1.27   mycroft 
    180  1.126        pk 	LOCK_ASSERT(simple_lock_held(&fdp->fd_slock));
    181   1.27   mycroft 	if (fd < fdp->fd_freefile)
    182   1.27   mycroft 		fdp->fd_freefile = fd;
    183  1.115    provos 
    184  1.124      yamt 	if (fdp->fd_lomap[off] == ~0) {
    185  1.124      yamt 		KDASSERT((fdp->fd_himap[off >> NDENTRYSHIFT] &
    186  1.124      yamt 		    (1 << (off & NDENTRYMASK))) != 0);
    187  1.124      yamt 		fdp->fd_himap[off >> NDENTRYSHIFT] &=
    188  1.124      yamt 		    ~(1 << (off & NDENTRYMASK));
    189  1.124      yamt 	}
    190  1.124      yamt 	KDASSERT((fdp->fd_lomap[off] & (1 << (fd & NDENTRYMASK))) != 0);
    191  1.115    provos 	fdp->fd_lomap[off] &= ~(1 << (fd & NDENTRYMASK));
    192  1.115    provos 
    193   1.27   mycroft #ifdef DIAGNOSTIC
    194   1.27   mycroft 	if (fd > fdp->fd_lastfile)
    195   1.27   mycroft 		panic("fd_unused: fd_lastfile inconsistent");
    196   1.27   mycroft #endif
    197  1.115    provos 	if (fd == fdp->fd_lastfile)
    198  1.115    provos 		fdp->fd_lastfile = find_last_set(fdp, fd);
    199   1.27   mycroft }
    200   1.27   mycroft 
    201  1.103        pk /*
    202  1.103        pk  * Lookup the file structure corresponding to a file descriptor
    203  1.103        pk  * and return it locked.
    204  1.103        pk  * Note: typical usage is: `fp = fd_getfile(..); FILE_USE(fp);'
    205  1.103        pk  * The locking strategy has been optimised for this case, i.e.
    206  1.103        pk  * fd_getfile() returns the file locked while FILE_USE() will increment
    207  1.103        pk  * the file's use count and unlock.
    208  1.103        pk  */
    209   1.77   thorpej struct file *
    210   1.77   thorpej fd_getfile(struct filedesc *fdp, int fd)
    211   1.77   thorpej {
    212   1.77   thorpej 	struct file *fp;
    213   1.77   thorpej 
    214   1.77   thorpej 	if ((u_int) fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL)
    215   1.77   thorpej 		return (NULL);
    216   1.77   thorpej 
    217  1.103        pk 	simple_lock(&fp->f_slock);
    218  1.103        pk 	if (FILE_IS_USABLE(fp) == 0) {
    219  1.103        pk 		simple_unlock(&fp->f_slock);
    220   1.77   thorpej 		return (NULL);
    221  1.103        pk 	}
    222   1.77   thorpej 
    223   1.77   thorpej 	return (fp);
    224   1.77   thorpej }
    225   1.77   thorpej 
    226   1.16       cgd /*
    227   1.16       cgd  * System calls on descriptors.
    228   1.16       cgd  */
    229   1.18       cgd 
    230   1.16       cgd /*
    231   1.16       cgd  * Duplicate a file descriptor.
    232   1.16       cgd  */
    233   1.16       cgd /* ARGSUSED */
    234   1.38  christos int
    235   1.99   thorpej sys_dup(struct lwp *l, void *v, register_t *retval)
    236   1.36   thorpej {
    237   1.37   mycroft 	struct sys_dup_args /* {
    238   1.72     lukem 		syscallarg(int)	fd;
    239   1.36   thorpej 	} */ *uap = v;
    240   1.72     lukem 	struct file	*fp;
    241   1.72     lukem 	struct filedesc	*fdp;
    242   1.99   thorpej 	struct proc	*p;
    243   1.72     lukem 	int		old, new, error;
    244   1.72     lukem 
    245   1.99   thorpej 	p = l->l_proc;
    246   1.72     lukem 	fdp = p->p_fd;
    247   1.72     lukem 	old = SCARG(uap, fd);
    248   1.16       cgd 
    249   1.75   thorpej  restart:
    250   1.77   thorpej 	if ((fp = fd_getfile(fdp, old)) == NULL)
    251   1.16       cgd 		return (EBADF);
    252   1.59   thorpej 
    253   1.59   thorpej 	FILE_USE(fp);
    254   1.59   thorpej 
    255   1.59   thorpej 	if ((error = fdalloc(p, 0, &new)) != 0) {
    256   1.76   thorpej 		if (error == ENOSPC) {
    257   1.76   thorpej 			fdexpand(p);
    258  1.110      fvdl 			FILE_UNUSE(fp, p);
    259   1.76   thorpej 			goto restart;
    260   1.76   thorpej 		}
    261  1.110      fvdl 		FILE_UNUSE(fp, p);
    262   1.16       cgd 		return (error);
    263   1.59   thorpej 	}
    264   1.59   thorpej 
    265   1.59   thorpej 	/* finishdup() will unuse the descriptors for us */
    266  1.110      fvdl 	return (finishdup(p, old, new, retval));
    267   1.16       cgd }
    268   1.16       cgd 
    269   1.16       cgd /*
    270   1.16       cgd  * Duplicate a file descriptor to a particular value.
    271   1.16       cgd  */
    272   1.16       cgd /* ARGSUSED */
    273   1.38  christos int
    274   1.99   thorpej sys_dup2(struct lwp *l, void *v, register_t *retval)
    275   1.36   thorpej {
    276   1.37   mycroft 	struct sys_dup2_args /* {
    277   1.72     lukem 		syscallarg(int)	from;
    278   1.72     lukem 		syscallarg(int)	to;
    279   1.36   thorpej 	} */ *uap = v;
    280   1.72     lukem 	struct file	*fp;
    281   1.72     lukem 	struct filedesc	*fdp;
    282   1.99   thorpej 	struct proc	*p;
    283   1.72     lukem 	int		old, new, i, error;
    284   1.72     lukem 
    285   1.99   thorpej 	p = l->l_proc;
    286   1.72     lukem 	fdp = p->p_fd;
    287   1.72     lukem 	old = SCARG(uap, from);
    288   1.72     lukem 	new = SCARG(uap, to);
    289   1.16       cgd 
    290   1.75   thorpej  restart:
    291   1.77   thorpej 	if ((fp = fd_getfile(fdp, old)) == NULL)
    292   1.77   thorpej 		return (EBADF);
    293   1.77   thorpej 
    294   1.77   thorpej 	if ((u_int)new >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
    295  1.103        pk 	    (u_int)new >= maxfiles) {
    296  1.103        pk 		simple_unlock(&fp->f_slock);
    297   1.16       cgd 		return (EBADF);
    298  1.103        pk 	}
    299   1.77   thorpej 
    300   1.17       cgd 	if (old == new) {
    301  1.103        pk 		simple_unlock(&fp->f_slock);
    302   1.17       cgd 		*retval = new;
    303   1.16       cgd 		return (0);
    304   1.17       cgd 	}
    305   1.59   thorpej 
    306   1.59   thorpej 	FILE_USE(fp);
    307   1.59   thorpej 
    308   1.16       cgd 	if (new >= fdp->fd_nfiles) {
    309   1.59   thorpej 		if ((error = fdalloc(p, new, &i)) != 0) {
    310   1.76   thorpej 			if (error == ENOSPC) {
    311   1.76   thorpej 				fdexpand(p);
    312  1.110      fvdl 				FILE_UNUSE(fp, p);
    313   1.76   thorpej 				goto restart;
    314   1.76   thorpej 			}
    315  1.110      fvdl 			FILE_UNUSE(fp, p);
    316   1.16       cgd 			return (error);
    317   1.59   thorpej 		}
    318   1.16       cgd 		if (new != i)
    319   1.16       cgd 			panic("dup2: fdalloc");
    320  1.126        pk 	} else {
    321  1.126        pk 		simple_lock(&fdp->fd_slock);
    322  1.117      yamt 		/*
    323  1.117      yamt 		 * Mark `new' slot "used" only if it was empty.
    324  1.117      yamt 		 */
    325  1.126        pk 		if (fdp->fd_ofiles[new] == NULL)
    326  1.126        pk 			fd_used(fdp, new);
    327  1.126        pk 		simple_unlock(&fdp->fd_slock);
    328   1.16       cgd 	}
    329   1.59   thorpej 
    330   1.75   thorpej 	/*
    331   1.75   thorpej 	 * finishdup() will close the file that's in the `new'
    332   1.75   thorpej 	 * slot, if there's one there.
    333   1.75   thorpej 	 */
    334   1.75   thorpej 
    335   1.59   thorpej 	/* finishdup() will unuse the descriptors for us */
    336  1.110      fvdl 	return (finishdup(p, old, new, retval));
    337   1.16       cgd }
    338   1.16       cgd 
    339   1.16       cgd /*
    340   1.16       cgd  * The file control system call.
    341   1.16       cgd  */
    342   1.16       cgd /* ARGSUSED */
    343   1.38  christos int
    344   1.99   thorpej sys_fcntl(struct lwp *l, void *v, register_t *retval)
    345   1.36   thorpej {
    346   1.66  augustss 	struct sys_fcntl_args /* {
    347   1.72     lukem 		syscallarg(int)		fd;
    348   1.72     lukem 		syscallarg(int)		cmd;
    349   1.72     lukem 		syscallarg(void *)	arg;
    350   1.36   thorpej 	} */ *uap = v;
    351   1.72     lukem 	struct filedesc *fdp;
    352   1.72     lukem 	struct file	*fp;
    353   1.99   thorpej 	struct proc	*p;
    354   1.72     lukem 	struct vnode	*vp;
    355   1.72     lukem 	int		fd, i, tmp, error, flg, cmd, newmin;
    356   1.72     lukem 	struct flock	fl;
    357   1.72     lukem 
    358   1.99   thorpej 	p = l->l_proc;
    359   1.72     lukem 	fd = SCARG(uap, fd);
    360  1.122  christos 	cmd = SCARG(uap, cmd);
    361   1.72     lukem 	fdp = p->p_fd;
    362   1.72     lukem 	error = 0;
    363   1.72     lukem 	flg = F_POSIX;
    364   1.16       cgd 
    365  1.122  christos 	switch (cmd) {
    366  1.122  christos 	case F_CLOSEM:
    367  1.122  christos 		if (fd < 0)
    368  1.122  christos 			return EBADF;
    369  1.122  christos 		while (fdp->fd_lastfile >= fd)
    370  1.122  christos 			fdrelease(p, fdp->fd_lastfile);
    371  1.122  christos 		return 0;
    372  1.122  christos 
    373  1.122  christos 	case F_MAXFD:
    374  1.123  jdolecek 		*retval = fdp->fd_lastfile;
    375  1.123  jdolecek 		return 0;
    376  1.122  christos 
    377  1.122  christos 	default:
    378  1.122  christos 		/* Handled below */
    379  1.122  christos 		break;
    380  1.122  christos 	}
    381  1.122  christos 
    382   1.75   thorpej  restart:
    383   1.77   thorpej 	if ((fp = fd_getfile(fdp, fd)) == NULL)
    384   1.16       cgd 		return (EBADF);
    385   1.59   thorpej 
    386   1.59   thorpej 	FILE_USE(fp);
    387   1.59   thorpej 
    388   1.61  wrstuden 	if ((cmd & F_FSCTL)) {
    389  1.110      fvdl 		error = fcntl_forfs(fd, p, cmd, SCARG(uap, arg));
    390   1.61  wrstuden 		goto out;
    391   1.61  wrstuden 	}
    392   1.61  wrstuden 
    393   1.61  wrstuden 	switch (cmd) {
    394   1.17       cgd 
    395   1.16       cgd 	case F_DUPFD:
    396   1.30       cgd 		newmin = (long)SCARG(uap, arg);
    397   1.27   mycroft 		if ((u_int)newmin >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
    398   1.59   thorpej 		    (u_int)newmin >= maxfiles) {
    399   1.59   thorpej 			error = EINVAL;
    400   1.59   thorpej 			goto out;
    401   1.59   thorpej 		}
    402   1.75   thorpej 		if ((error = fdalloc(p, newmin, &i)) != 0) {
    403   1.76   thorpej 			if (error == ENOSPC) {
    404   1.76   thorpej 				fdexpand(p);
    405  1.110      fvdl 				FILE_UNUSE(fp, p);
    406   1.75   thorpej 				goto restart;
    407   1.75   thorpej 			}
    408   1.59   thorpej 			goto out;
    409   1.75   thorpej 		}
    410   1.59   thorpej 
    411   1.59   thorpej 		/* finishdup() will unuse the descriptors for us */
    412  1.110      fvdl 		return (finishdup(p, fd, i, retval));
    413   1.16       cgd 
    414   1.16       cgd 	case F_GETFD:
    415   1.27   mycroft 		*retval = fdp->fd_ofileflags[fd] & UF_EXCLOSE ? 1 : 0;
    416   1.59   thorpej 		break;
    417   1.16       cgd 
    418   1.16       cgd 	case F_SETFD:
    419   1.27   mycroft 		if ((long)SCARG(uap, arg) & 1)
    420   1.27   mycroft 			fdp->fd_ofileflags[fd] |= UF_EXCLOSE;
    421   1.27   mycroft 		else
    422   1.27   mycroft 			fdp->fd_ofileflags[fd] &= ~UF_EXCLOSE;
    423   1.59   thorpej 		break;
    424   1.16       cgd 
    425   1.16       cgd 	case F_GETFL:
    426   1.16       cgd 		*retval = OFLAGS(fp->f_flag);
    427   1.59   thorpej 		break;
    428   1.16       cgd 
    429   1.16       cgd 	case F_SETFL:
    430   1.61  wrstuden 		tmp = FFLAGS((long)SCARG(uap, arg)) & FCNTLFLAGS;
    431  1.110      fvdl 		error = (*fp->f_ops->fo_fcntl)(fp, F_SETFL, &tmp, p);
    432   1.61  wrstuden 		if (error)
    433  1.107       dsl 			break;
    434  1.107       dsl 		i = tmp ^ fp->f_flag;
    435  1.107       dsl 		if (i & FNONBLOCK) {
    436  1.107       dsl 			int fl = tmp & FNONBLOCK;
    437  1.110      fvdl 			error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, &fl, p);
    438  1.107       dsl 			if (error)
    439  1.107       dsl 				goto reset_fcntl;
    440  1.107       dsl 		}
    441  1.107       dsl 		if (i & FASYNC) {
    442  1.107       dsl 			int fl = tmp & FASYNC;
    443  1.110      fvdl 			error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, &fl, p);
    444  1.107       dsl 			if (error) {
    445  1.107       dsl 				if (i & FNONBLOCK) {
    446  1.107       dsl 					tmp = fp->f_flag & FNONBLOCK;
    447  1.107       dsl 					(void)(*fp->f_ops->fo_ioctl)(fp,
    448  1.110      fvdl 						FIONBIO, &tmp, p);
    449  1.107       dsl 				}
    450  1.107       dsl 				goto reset_fcntl;
    451  1.107       dsl 			}
    452  1.107       dsl 		}
    453  1.107       dsl 		fp->f_flag = (fp->f_flag & ~FCNTLFLAGS) | tmp;
    454  1.107       dsl 		break;
    455  1.107       dsl 	    reset_fcntl:
    456  1.110      fvdl 		(void)(*fp->f_ops->fo_fcntl)(fp, F_SETFL, &fp->f_flag, p);
    457   1.59   thorpej 		break;
    458   1.16       cgd 
    459   1.16       cgd 	case F_GETOWN:
    460  1.113  jdolecek 		error = (*fp->f_ops->fo_ioctl)(fp, FIOGETOWN, retval, p);
    461   1.59   thorpej 		break;
    462   1.16       cgd 
    463   1.16       cgd 	case F_SETOWN:
    464  1.113  jdolecek 		tmp = (int)(intptr_t) SCARG(uap, arg);
    465  1.113  jdolecek 		error = (*fp->f_ops->fo_ioctl)(fp, FIOSETOWN, &tmp, p);
    466   1.59   thorpej 		break;
    467   1.16       cgd 
    468   1.16       cgd 	case F_SETLKW:
    469   1.16       cgd 		flg |= F_WAIT;
    470   1.16       cgd 		/* Fall into F_SETLK */
    471   1.16       cgd 
    472   1.16       cgd 	case F_SETLK:
    473   1.59   thorpej 		if (fp->f_type != DTYPE_VNODE) {
    474   1.59   thorpej 			error = EINVAL;
    475   1.59   thorpej 			goto out;
    476   1.59   thorpej 		}
    477   1.16       cgd 		vp = (struct vnode *)fp->f_data;
    478   1.16       cgd 		/* Copy in the lock structure */
    479  1.106       dsl 		error = copyin(SCARG(uap, arg), &fl, sizeof(fl));
    480   1.16       cgd 		if (error)
    481   1.59   thorpej 			goto out;
    482   1.16       cgd 		if (fl.l_whence == SEEK_CUR)
    483   1.16       cgd 			fl.l_start += fp->f_offset;
    484   1.16       cgd 		switch (fl.l_type) {
    485   1.16       cgd 		case F_RDLCK:
    486   1.59   thorpej 			if ((fp->f_flag & FREAD) == 0) {
    487   1.59   thorpej 				error = EBADF;
    488   1.59   thorpej 				goto out;
    489   1.59   thorpej 			}
    490   1.16       cgd 			p->p_flag |= P_ADVLOCK;
    491  1.106       dsl 			error = VOP_ADVLOCK(vp, p, F_SETLK, &fl, flg);
    492   1.59   thorpej 			goto out;
    493   1.16       cgd 
    494   1.16       cgd 		case F_WRLCK:
    495   1.59   thorpej 			if ((fp->f_flag & FWRITE) == 0) {
    496   1.59   thorpej 				error = EBADF;
    497   1.59   thorpej 				goto out;
    498   1.59   thorpej 			}
    499   1.16       cgd 			p->p_flag |= P_ADVLOCK;
    500  1.106       dsl 			error = VOP_ADVLOCK(vp, p, F_SETLK, &fl, flg);
    501   1.59   thorpej 			goto out;
    502   1.16       cgd 
    503   1.16       cgd 		case F_UNLCK:
    504  1.106       dsl 			error = VOP_ADVLOCK(vp, p, F_UNLCK, &fl, F_POSIX);
    505   1.59   thorpej 			goto out;
    506   1.16       cgd 
    507   1.16       cgd 		default:
    508   1.59   thorpej 			error = EINVAL;
    509   1.59   thorpej 			goto out;
    510   1.16       cgd 		}
    511   1.16       cgd 
    512   1.16       cgd 	case F_GETLK:
    513   1.59   thorpej 		if (fp->f_type != DTYPE_VNODE) {
    514   1.59   thorpej 			error = EINVAL;
    515   1.59   thorpej 			goto out;
    516   1.59   thorpej 		}
    517   1.16       cgd 		vp = (struct vnode *)fp->f_data;
    518   1.16       cgd 		/* Copy in the lock structure */
    519  1.106       dsl 		error = copyin(SCARG(uap, arg), &fl, sizeof(fl));
    520   1.16       cgd 		if (error)
    521   1.59   thorpej 			goto out;
    522   1.16       cgd 		if (fl.l_whence == SEEK_CUR)
    523   1.16       cgd 			fl.l_start += fp->f_offset;
    524   1.43    kleink 		if (fl.l_type != F_RDLCK &&
    525   1.43    kleink 		    fl.l_type != F_WRLCK &&
    526   1.59   thorpej 		    fl.l_type != F_UNLCK) {
    527   1.59   thorpej 			error = EINVAL;
    528   1.59   thorpej 			goto out;
    529   1.59   thorpej 		}
    530  1.106       dsl 		error = VOP_ADVLOCK(vp, p, F_GETLK, &fl, F_POSIX);
    531   1.38  christos 		if (error)
    532   1.59   thorpej 			goto out;
    533  1.106       dsl 		error = copyout(&fl, SCARG(uap, arg), sizeof(fl));
    534   1.59   thorpej 		break;
    535   1.16       cgd 
    536   1.16       cgd 	default:
    537   1.59   thorpej 		error = EINVAL;
    538   1.16       cgd 	}
    539   1.59   thorpej 
    540   1.59   thorpej  out:
    541  1.110      fvdl 	FILE_UNUSE(fp, p);
    542   1.59   thorpej 	return (error);
    543   1.16       cgd }
    544   1.16       cgd 
    545   1.16       cgd /*
    546   1.17       cgd  * Common code for dup, dup2, and fcntl(F_DUPFD).
    547   1.17       cgd  */
    548   1.17       cgd int
    549  1.110      fvdl finishdup(struct proc *p, int old, int new, register_t *retval)
    550   1.17       cgd {
    551   1.72     lukem 	struct filedesc	*fdp;
    552  1.110      fvdl 	struct file	*fp, *delfp;
    553   1.72     lukem 
    554   1.72     lukem 	fdp = p->p_fd;
    555   1.59   thorpej 
    556   1.59   thorpej 	/*
    557   1.75   thorpej 	 * If there is a file in the new slot, remember it so we
    558   1.75   thorpej 	 * can close it after we've finished the dup.  We need
    559   1.75   thorpej 	 * to do it after the dup is finished, since closing
    560   1.75   thorpej 	 * the file may block.
    561   1.75   thorpej 	 *
    562   1.59   thorpej 	 * Note: `old' is already used for us.
    563  1.117      yamt 	 * Note: Caller already marked `new' slot "used".
    564   1.59   thorpej 	 */
    565  1.126        pk 	simple_lock(&fdp->fd_slock);
    566   1.75   thorpej 	delfp = fdp->fd_ofiles[new];
    567   1.17       cgd 
    568   1.17       cgd 	fp = fdp->fd_ofiles[old];
    569  1.124      yamt 	KDASSERT(fp != NULL);
    570   1.17       cgd 	fdp->fd_ofiles[new] = fp;
    571   1.17       cgd 	fdp->fd_ofileflags[new] = fdp->fd_ofileflags[old] &~ UF_EXCLOSE;
    572  1.126        pk 	simple_unlock(&fdp->fd_slock);
    573  1.126        pk 
    574  1.126        pk 	*retval = new;
    575  1.126        pk 	simple_lock(&fp->f_slock);
    576   1.17       cgd 	fp->f_count++;
    577  1.126        pk 	FILE_UNUSE_HAVELOCK(fp, p);
    578   1.75   thorpej 
    579   1.75   thorpej 	if (delfp != NULL) {
    580  1.103        pk 		simple_lock(&delfp->f_slock);
    581   1.75   thorpej 		FILE_USE(delfp);
    582   1.96  jdolecek 		if (new < fdp->fd_knlistsize)
    583  1.110      fvdl 			knote_fdclose(p, new);
    584  1.110      fvdl 		(void) closef(delfp, p);
    585   1.75   thorpej 	}
    586   1.17       cgd 	return (0);
    587   1.65   thorpej }
    588   1.65   thorpej 
    589   1.65   thorpej void
    590   1.72     lukem fdremove(struct filedesc *fdp, int fd)
    591   1.65   thorpej {
    592   1.65   thorpej 
    593  1.126        pk 	simple_lock(&fdp->fd_slock);
    594   1.65   thorpej 	fdp->fd_ofiles[fd] = NULL;
    595   1.65   thorpej 	fd_unused(fdp, fd);
    596  1.126        pk 	simple_unlock(&fdp->fd_slock);
    597   1.17       cgd }
    598   1.17       cgd 
    599   1.27   mycroft int
    600  1.110      fvdl fdrelease(struct proc *p, int fd)
    601   1.72     lukem {
    602   1.72     lukem 	struct filedesc	*fdp;
    603  1.110      fvdl 	struct file	**fpp, *fp;
    604   1.27   mycroft 
    605   1.72     lukem 	fdp = p->p_fd;
    606  1.126        pk 	simple_lock(&fdp->fd_slock);
    607  1.129      cube 	if (fd < 0 || fd > fdp->fd_lastfile)
    608  1.126        pk 		goto badf;
    609   1.27   mycroft 	fpp = &fdp->fd_ofiles[fd];
    610   1.27   mycroft 	fp = *fpp;
    611   1.27   mycroft 	if (fp == NULL)
    612  1.126        pk 		goto badf;
    613   1.59   thorpej 
    614  1.103        pk 	simple_lock(&fp->f_slock);
    615  1.103        pk 	if (!FILE_IS_USABLE(fp)) {
    616  1.103        pk 		simple_unlock(&fp->f_slock);
    617  1.126        pk 		goto badf;
    618  1.103        pk 	}
    619  1.103        pk 
    620   1.59   thorpej 	FILE_USE(fp);
    621   1.59   thorpej 
    622   1.27   mycroft 	*fpp = NULL;
    623   1.75   thorpej 	fdp->fd_ofileflags[fd] = 0;
    624  1.126        pk 	fd_unused(fdp, fd);
    625  1.126        pk 	simple_unlock(&fdp->fd_slock);
    626   1.96  jdolecek 	if (fd < fdp->fd_knlistsize)
    627  1.110      fvdl 		knote_fdclose(p, fd);
    628  1.110      fvdl 	return (closef(fp, p));
    629  1.126        pk 
    630  1.126        pk badf:
    631  1.126        pk 	simple_unlock(&fdp->fd_slock);
    632  1.126        pk 	return (EBADF);
    633   1.27   mycroft }
    634   1.27   mycroft 
    635   1.17       cgd /*
    636   1.16       cgd  * Close a file descriptor.
    637   1.16       cgd  */
    638   1.16       cgd /* ARGSUSED */
    639   1.38  christos int
    640   1.99   thorpej sys_close(struct lwp *l, void *v, register_t *retval)
    641   1.36   thorpej {
    642   1.37   mycroft 	struct sys_close_args /* {
    643   1.72     lukem 		syscallarg(int)	fd;
    644   1.36   thorpej 	} */ *uap = v;
    645   1.72     lukem 	int		fd;
    646   1.72     lukem 	struct filedesc	*fdp;
    647   1.99   thorpej 	struct proc *p;
    648   1.16       cgd 
    649   1.99   thorpej 	p = l->l_proc;
    650   1.72     lukem 	fd = SCARG(uap, fd);
    651   1.72     lukem 	fdp = p->p_fd;
    652   1.79   thorpej 
    653  1.103        pk #if 0
    654  1.100    simonb 	if (fd_getfile(fdp, fd) == NULL)
    655   1.16       cgd 		return (EBADF);
    656  1.103        pk #endif
    657   1.79   thorpej 
    658  1.110      fvdl 	return (fdrelease(p, fd));
    659   1.16       cgd }
    660   1.16       cgd 
    661   1.17       cgd /*
    662   1.17       cgd  * Return status information about a file descriptor.
    663   1.17       cgd  */
    664   1.16       cgd /* ARGSUSED */
    665   1.38  christos int
    666   1.99   thorpej sys___fstat13(struct lwp *l, void *v, register_t *retval)
    667   1.36   thorpej {
    668   1.66  augustss 	struct sys___fstat13_args /* {
    669   1.72     lukem 		syscallarg(int)			fd;
    670   1.72     lukem 		syscallarg(struct stat *)	sb;
    671   1.36   thorpej 	} */ *uap = v;
    672   1.72     lukem 	int		fd;
    673   1.72     lukem 	struct filedesc	*fdp;
    674   1.72     lukem 	struct file	*fp;
    675   1.99   thorpej 	struct proc	*p;
    676   1.72     lukem 	struct stat	ub;
    677   1.72     lukem 	int		error;
    678   1.16       cgd 
    679   1.99   thorpej 	p = l->l_proc;
    680   1.72     lukem 	fd = SCARG(uap, fd);
    681   1.72     lukem 	fdp = p->p_fd;
    682   1.77   thorpej 
    683   1.77   thorpej 	if ((fp = fd_getfile(fdp, fd)) == NULL)
    684   1.16       cgd 		return (EBADF);
    685   1.59   thorpej 
    686   1.59   thorpej 	FILE_USE(fp);
    687  1.110      fvdl 	error = (*fp->f_ops->fo_stat)(fp, &ub, p);
    688  1.110      fvdl 	FILE_UNUSE(fp, p);
    689   1.59   thorpej 
    690   1.16       cgd 	if (error == 0)
    691   1.52     perry 		error = copyout(&ub, SCARG(uap, sb), sizeof(ub));
    692   1.73  jdolecek 
    693   1.16       cgd 	return (error);
    694   1.16       cgd }
    695   1.16       cgd 
    696   1.16       cgd /*
    697   1.16       cgd  * Return pathconf information about a file descriptor.
    698   1.16       cgd  */
    699   1.16       cgd /* ARGSUSED */
    700   1.38  christos int
    701   1.99   thorpej sys_fpathconf(struct lwp *l, void *v, register_t *retval)
    702   1.36   thorpej {
    703   1.66  augustss 	struct sys_fpathconf_args /* {
    704   1.72     lukem 		syscallarg(int)	fd;
    705   1.72     lukem 		syscallarg(int)	name;
    706   1.36   thorpej 	} */ *uap = v;
    707   1.72     lukem 	int		fd;
    708   1.72     lukem 	struct filedesc	*fdp;
    709   1.72     lukem 	struct file	*fp;
    710   1.99   thorpej 	struct proc 	*p;
    711   1.72     lukem 	struct vnode	*vp;
    712   1.72     lukem 	int		error;
    713   1.72     lukem 
    714   1.99   thorpej 	p = l->l_proc;
    715   1.72     lukem 	fd = SCARG(uap, fd);
    716   1.72     lukem 	fdp = p->p_fd;
    717   1.72     lukem 	error = 0;
    718   1.17       cgd 
    719   1.77   thorpej 	if ((fp = fd_getfile(fdp, fd)) == NULL)
    720   1.17       cgd 		return (EBADF);
    721   1.59   thorpej 
    722   1.59   thorpej 	FILE_USE(fp);
    723   1.59   thorpej 
    724   1.17       cgd 	switch (fp->f_type) {
    725   1.16       cgd 
    726   1.17       cgd 	case DTYPE_SOCKET:
    727   1.78  jdolecek 	case DTYPE_PIPE:
    728   1.25       cgd 		if (SCARG(uap, name) != _PC_PIPE_BUF)
    729   1.59   thorpej 			error = EINVAL;
    730   1.59   thorpej 		else
    731   1.59   thorpej 			*retval = PIPE_BUF;
    732   1.59   thorpej 		break;
    733   1.17       cgd 
    734   1.17       cgd 	case DTYPE_VNODE:
    735   1.17       cgd 		vp = (struct vnode *)fp->f_data;
    736   1.59   thorpej 		error = VOP_PATHCONF(vp, SCARG(uap, name), retval);
    737   1.59   thorpej 		break;
    738   1.17       cgd 
    739   1.96  jdolecek 	case DTYPE_KQUEUE:
    740   1.96  jdolecek 		error = EINVAL;
    741   1.96  jdolecek 		break;
    742   1.96  jdolecek 
    743   1.17       cgd 	default:
    744   1.93   thorpej 		error = EOPNOTSUPP;
    745   1.93   thorpej 		break;
    746   1.17       cgd 	}
    747   1.59   thorpej 
    748  1.110      fvdl 	FILE_UNUSE(fp, p);
    749   1.59   thorpej 	return (error);
    750   1.16       cgd }
    751   1.16       cgd 
    752   1.16       cgd /*
    753   1.16       cgd  * Allocate a file descriptor for the process.
    754   1.16       cgd  */
    755   1.76   thorpej int	fdexpanded;		/* XXX: what else uses this? */
    756   1.16       cgd 
    757   1.38  christos int
    758   1.72     lukem fdalloc(struct proc *p, int want, int *result)
    759   1.72     lukem {
    760   1.72     lukem 	struct filedesc	*fdp;
    761  1.126        pk 	int i, lim, last, error;
    762  1.115    provos 	u_int off, new;
    763   1.72     lukem 
    764   1.72     lukem 	fdp = p->p_fd;
    765  1.126        pk 	simple_lock(&fdp->fd_slock);
    766   1.16       cgd 
    767   1.16       cgd 	/*
    768   1.16       cgd 	 * Search for a free descriptor starting at the higher
    769   1.16       cgd 	 * of want or fd_freefile.  If that fails, consider
    770   1.16       cgd 	 * expanding the ofile array.
    771   1.16       cgd 	 */
    772   1.17       cgd 	lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles);
    773   1.90     enami 	last = min(fdp->fd_nfiles, lim);
    774  1.115    provos  again:
    775   1.90     enami 	if ((i = want) < fdp->fd_freefile)
    776   1.90     enami 		i = fdp->fd_freefile;
    777  1.115    provos 	off = i >> NDENTRYSHIFT;
    778  1.115    provos 	new = find_next_zero(fdp->fd_himap, off,
    779  1.115    provos 	    (last + NDENTRIES - 1) >> NDENTRYSHIFT);
    780  1.115    provos 	if (new != -1) {
    781  1.115    provos 		i = find_next_zero(&fdp->fd_lomap[new],
    782  1.115    provos 		    new > off ? 0 : i & NDENTRYMASK, NDENTRIES);
    783  1.115    provos 		if (i == -1) {
    784  1.115    provos 			/*
    785  1.115    provos 			 * free file descriptor in this block was
    786  1.115    provos 			 * below want, try again with higher want.
    787  1.115    provos 			 */
    788  1.115    provos 			want = (new + 1) << NDENTRYSHIFT;
    789  1.115    provos 			goto again;
    790  1.115    provos 		}
    791  1.115    provos 		i += (new << NDENTRYSHIFT);
    792  1.115    provos 		if (i < last) {
    793  1.115    provos 			if (fdp->fd_ofiles[i] == NULL) {
    794  1.115    provos 				fd_used(fdp, i);
    795  1.115    provos 				if (want <= fdp->fd_freefile)
    796  1.115    provos 					fdp->fd_freefile = i;
    797  1.115    provos 				*result = i;
    798  1.126        pk 				error = 0;
    799  1.126        pk 				goto out;
    800  1.115    provos 			}
    801   1.16       cgd 		}
    802   1.90     enami 	}
    803   1.16       cgd 
    804  1.126        pk 	/* No space in current array.  Expand or let the caller do it. */
    805  1.126        pk 	error = (fdp->fd_nfiles >= lim) ? EMFILE : ENOSPC;
    806   1.76   thorpej 
    807  1.126        pk out:
    808  1.126        pk 	simple_unlock(&fdp->fd_slock);
    809  1.126        pk 	return (error);
    810   1.16       cgd }
    811   1.16       cgd 
    812   1.76   thorpej void
    813   1.76   thorpej fdexpand(struct proc *p)
    814   1.76   thorpej {
    815   1.76   thorpej 	struct filedesc	*fdp;
    816  1.126        pk 	int		i, nfiles, oldnfiles;
    817   1.76   thorpej 	struct file	**newofile;
    818   1.76   thorpej 	char		*newofileflags;
    819  1.126        pk 	uint32_t	*newhimap = NULL, *newlomap = NULL;
    820   1.76   thorpej 
    821   1.76   thorpej 	fdp = p->p_fd;
    822   1.76   thorpej 
    823  1.126        pk restart:
    824  1.126        pk 	oldnfiles = fdp->fd_nfiles;
    825  1.126        pk 
    826  1.126        pk 	if (oldnfiles < NDEXTENT)
    827   1.76   thorpej 		nfiles = NDEXTENT;
    828   1.76   thorpej 	else
    829  1.126        pk 		nfiles = 2 * oldnfiles;
    830  1.126        pk 
    831   1.76   thorpej 	newofile = malloc(nfiles * OFILESIZE, M_FILEDESC, M_WAITOK);
    832  1.126        pk 	if (NDHISLOTS(nfiles) > NDHISLOTS(oldnfiles)) {
    833  1.126        pk 		newhimap = malloc(NDHISLOTS(nfiles) * sizeof(uint32_t),
    834  1.126        pk 		    M_FILEDESC, M_WAITOK);
    835  1.126        pk 		newlomap = malloc(NDLOSLOTS(nfiles) * sizeof(uint32_t),
    836  1.126        pk 		    M_FILEDESC, M_WAITOK);
    837  1.126        pk 	}
    838  1.126        pk 
    839  1.126        pk 	simple_lock(&fdp->fd_slock);
    840  1.126        pk 	/* lock fdp */
    841  1.126        pk 	if (fdp->fd_nfiles != oldnfiles) {
    842  1.126        pk 		/* fdp changed; retry */
    843  1.126        pk 		simple_unlock(&fdp->fd_slock);
    844  1.126        pk 		free(newofile, M_FILEDESC);
    845  1.126        pk 		if (newhimap != NULL) free(newhimap, M_FILEDESC);
    846  1.126        pk 		if (newlomap != NULL) free(newlomap, M_FILEDESC);
    847  1.126        pk 		goto restart;
    848  1.126        pk 	}
    849  1.126        pk 
    850   1.76   thorpej 	newofileflags = (char *) &newofile[nfiles];
    851   1.76   thorpej 	/*
    852   1.76   thorpej 	 * Copy the existing ofile and ofileflags arrays
    853   1.76   thorpej 	 * and zero the new portion of each array.
    854   1.76   thorpej 	 */
    855   1.76   thorpej 	memcpy(newofile, fdp->fd_ofiles,
    856   1.89     enami 	    (i = sizeof(struct file *) * fdp->fd_nfiles));
    857   1.76   thorpej 	memset((char *)newofile + i, 0,
    858   1.76   thorpej 	    nfiles * sizeof(struct file *) - i);
    859   1.76   thorpej 	memcpy(newofileflags, fdp->fd_ofileflags,
    860   1.76   thorpej 	    (i = sizeof(char) * fdp->fd_nfiles));
    861   1.76   thorpej 	memset(newofileflags + i, 0, nfiles * sizeof(char) - i);
    862  1.126        pk 	if (oldnfiles > NDFILE)
    863   1.76   thorpej 		free(fdp->fd_ofiles, M_FILEDESC);
    864  1.115    provos 
    865  1.126        pk 	if (NDHISLOTS(nfiles) > NDHISLOTS(oldnfiles)) {
    866  1.115    provos 		memcpy(newhimap, fdp->fd_himap,
    867  1.126        pk 		    (i = NDHISLOTS(oldnfiles) * sizeof(uint32_t)));
    868  1.115    provos 		memset((char *)newhimap + i, 0,
    869  1.115    provos 		    NDHISLOTS(nfiles) * sizeof(uint32_t) - i);
    870  1.115    provos 
    871  1.115    provos 		memcpy(newlomap, fdp->fd_lomap,
    872  1.126        pk 		    (i = NDLOSLOTS(oldnfiles) * sizeof(uint32_t)));
    873  1.115    provos 		memset((char *)newlomap + i, 0,
    874  1.115    provos 		    NDLOSLOTS(nfiles) * sizeof(uint32_t) - i);
    875  1.115    provos 
    876  1.126        pk 		if (NDHISLOTS(oldnfiles) > NDHISLOTS(NDFILE)) {
    877  1.115    provos 			free(fdp->fd_himap, M_FILEDESC);
    878  1.115    provos 			free(fdp->fd_lomap, M_FILEDESC);
    879  1.115    provos 		}
    880  1.115    provos 		fdp->fd_himap = newhimap;
    881  1.115    provos 		fdp->fd_lomap = newlomap;
    882  1.115    provos 	}
    883  1.115    provos 
    884   1.76   thorpej 	fdp->fd_ofiles = newofile;
    885   1.76   thorpej 	fdp->fd_ofileflags = newofileflags;
    886   1.76   thorpej 	fdp->fd_nfiles = nfiles;
    887  1.126        pk 
    888  1.126        pk 	simple_unlock(&fdp->fd_slock);
    889  1.126        pk 
    890   1.76   thorpej 	fdexpanded++;
    891   1.76   thorpej }
    892   1.76   thorpej 
    893   1.16       cgd /*
    894   1.16       cgd  * Check to see whether n user file descriptors
    895   1.16       cgd  * are available to the process p.
    896   1.16       cgd  */
    897   1.38  christos int
    898   1.72     lukem fdavail(struct proc *p, int n)
    899   1.72     lukem {
    900   1.72     lukem 	struct filedesc	*fdp;
    901   1.72     lukem 	struct file	**fpp;
    902   1.72     lukem 	int		i, lim;
    903   1.16       cgd 
    904   1.72     lukem 	fdp = p->p_fd;
    905   1.17       cgd 	lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles);
    906   1.17       cgd 	if ((i = lim - fdp->fd_nfiles) > 0 && (n -= i) <= 0)
    907   1.16       cgd 		return (1);
    908   1.16       cgd 	fpp = &fdp->fd_ofiles[fdp->fd_freefile];
    909   1.56  sommerfe 	for (i = min(lim,fdp->fd_nfiles) - fdp->fd_freefile; --i >= 0; fpp++)
    910   1.16       cgd 		if (*fpp == NULL && --n <= 0)
    911   1.16       cgd 			return (1);
    912   1.16       cgd 	return (0);
    913   1.16       cgd }
    914   1.16       cgd 
    915   1.16       cgd /*
    916   1.16       cgd  * Create a new open file structure and allocate
    917   1.98       wiz  * a file descriptor for the process that refers to it.
    918   1.16       cgd  */
    919   1.38  christos int
    920   1.72     lukem falloc(struct proc *p, struct file **resultfp, int *resultfd)
    921   1.16       cgd {
    922   1.72     lukem 	struct file	*fp, *fq;
    923   1.72     lukem 	int		error, i;
    924   1.16       cgd 
    925   1.75   thorpej  restart:
    926   1.75   thorpej 	if ((error = fdalloc(p, 0, &i)) != 0) {
    927   1.76   thorpej 		if (error == ENOSPC) {
    928   1.76   thorpej 			fdexpand(p);
    929   1.75   thorpej 			goto restart;
    930   1.76   thorpej 		}
    931   1.16       cgd 		return (error);
    932   1.75   thorpej 	}
    933  1.102        pk 
    934  1.102        pk 	fp = pool_get(&file_pool, PR_WAITOK);
    935  1.102        pk 	simple_lock(&filelist_slock);
    936   1.16       cgd 	if (nfiles >= maxfiles) {
    937   1.69  jdolecek 		tablefull("file", "increase kern.maxfiles or MAXFILES");
    938  1.102        pk 		simple_unlock(&filelist_slock);
    939  1.115    provos 		fd_unused(p->p_fd, i);
    940  1.102        pk 		pool_put(&file_pool, fp);
    941   1.16       cgd 		return (ENFILE);
    942   1.16       cgd 	}
    943   1.16       cgd 	/*
    944   1.16       cgd 	 * Allocate a new file descriptor.
    945   1.16       cgd 	 * If the process has file descriptor zero open, add to the list
    946   1.16       cgd 	 * of open files at that point, otherwise put it at the front of
    947   1.16       cgd 	 * the list of open files.
    948   1.16       cgd 	 */
    949   1.16       cgd 	nfiles++;
    950   1.53     perry 	memset(fp, 0, sizeof(struct file));
    951   1.83  jdolecek 	fp->f_iflags = FIF_LARVAL;
    952   1.38  christos 	if ((fq = p->p_fd->fd_ofiles[0]) != NULL) {
    953   1.24   mycroft 		LIST_INSERT_AFTER(fq, fp, f_list);
    954   1.24   mycroft 	} else {
    955   1.24   mycroft 		LIST_INSERT_HEAD(&filehead, fp, f_list);
    956   1.24   mycroft 	}
    957  1.102        pk 	simple_unlock(&filelist_slock);
    958  1.124      yamt 	KDASSERT(p->p_fd->fd_ofiles[i] == NULL);
    959   1.16       cgd 	p->p_fd->fd_ofiles[i] = fp;
    960  1.103        pk 	simple_lock_init(&fp->f_slock);
    961   1.16       cgd 	fp->f_count = 1;
    962   1.16       cgd 	fp->f_cred = p->p_ucred;
    963   1.16       cgd 	crhold(fp->f_cred);
    964   1.59   thorpej 	if (resultfp) {
    965  1.103        pk 		fp->f_usecount = 1;
    966   1.16       cgd 		*resultfp = fp;
    967   1.59   thorpej 	}
    968   1.16       cgd 	if (resultfd)
    969   1.16       cgd 		*resultfd = i;
    970   1.16       cgd 	return (0);
    971   1.16       cgd }
    972   1.16       cgd 
    973   1.16       cgd /*
    974   1.16       cgd  * Free a file descriptor.
    975   1.16       cgd  */
    976   1.38  christos void
    977   1.72     lukem ffree(struct file *fp)
    978   1.16       cgd {
    979   1.59   thorpej 
    980   1.59   thorpej #ifdef DIAGNOSTIC
    981   1.59   thorpej 	if (fp->f_usecount)
    982   1.59   thorpej 		panic("ffree");
    983   1.59   thorpej #endif
    984   1.59   thorpej 
    985  1.102        pk 	simple_lock(&filelist_slock);
    986   1.24   mycroft 	LIST_REMOVE(fp, f_list);
    987   1.16       cgd 	crfree(fp->f_cred);
    988   1.16       cgd #ifdef DIAGNOSTIC
    989  1.103        pk 	fp->f_count = 0; /* What's the point? */
    990   1.16       cgd #endif
    991   1.16       cgd 	nfiles--;
    992  1.102        pk 	simple_unlock(&filelist_slock);
    993   1.55   thorpej 	pool_put(&file_pool, fp);
    994   1.48   thorpej }
    995   1.48   thorpej 
    996   1.48   thorpej /*
    997   1.58   thorpej  * Create an initial cwdinfo structure, using the same current and root
    998   1.58   thorpej  * directories as p.
    999   1.58   thorpej  */
   1000   1.58   thorpej struct cwdinfo *
   1001   1.72     lukem cwdinit(struct proc *p)
   1002   1.58   thorpej {
   1003   1.58   thorpej 	struct cwdinfo *cwdi;
   1004   1.58   thorpej 
   1005   1.58   thorpej 	cwdi = pool_get(&cwdi_pool, PR_WAITOK);
   1006   1.58   thorpej 
   1007  1.126        pk 	simple_lock_init(&cwdi->cwdi_slock);
   1008   1.58   thorpej 	cwdi->cwdi_cdir = p->p_cwdi->cwdi_cdir;
   1009   1.63   thorpej 	if (cwdi->cwdi_cdir)
   1010   1.63   thorpej 		VREF(cwdi->cwdi_cdir);
   1011   1.58   thorpej 	cwdi->cwdi_rdir = p->p_cwdi->cwdi_rdir;
   1012   1.58   thorpej 	if (cwdi->cwdi_rdir)
   1013   1.58   thorpej 		VREF(cwdi->cwdi_rdir);
   1014   1.60  christos 	cwdi->cwdi_cmask =  p->p_cwdi->cwdi_cmask;
   1015   1.58   thorpej 	cwdi->cwdi_refcnt = 1;
   1016   1.58   thorpej 
   1017   1.58   thorpej 	return (cwdi);
   1018   1.58   thorpej }
   1019   1.58   thorpej 
   1020   1.58   thorpej /*
   1021   1.58   thorpej  * Make p2 share p1's cwdinfo.
   1022   1.58   thorpej  */
   1023   1.58   thorpej void
   1024   1.72     lukem cwdshare(struct proc *p1, struct proc *p2)
   1025   1.58   thorpej {
   1026  1.126        pk 	struct cwdinfo *cwdi = p1->p_cwdi;
   1027   1.58   thorpej 
   1028  1.126        pk 	simple_lock(&cwdi->cwdi_slock);
   1029  1.126        pk 	cwdi->cwdi_refcnt++;
   1030  1.126        pk 	simple_unlock(&cwdi->cwdi_slock);
   1031  1.126        pk 	p2->p_cwdi = cwdi;
   1032   1.58   thorpej }
   1033   1.58   thorpej 
   1034   1.58   thorpej /*
   1035   1.58   thorpej  * Make this process not share its cwdinfo structure, maintaining
   1036   1.58   thorpej  * all cwdinfo state.
   1037   1.58   thorpej  */
   1038   1.58   thorpej void
   1039   1.72     lukem cwdunshare(struct proc *p)
   1040   1.58   thorpej {
   1041  1.126        pk 	struct cwdinfo *oldcwdi, *newcwdi;
   1042   1.58   thorpej 
   1043   1.58   thorpej 	if (p->p_cwdi->cwdi_refcnt == 1)
   1044   1.58   thorpej 		return;
   1045   1.58   thorpej 
   1046   1.58   thorpej 	newcwdi = cwdinit(p);
   1047  1.126        pk 	oldcwdi = p->p_cwdi;
   1048   1.58   thorpej 	p->p_cwdi = newcwdi;
   1049  1.126        pk 	cwdfree(oldcwdi);
   1050   1.58   thorpej }
   1051   1.58   thorpej 
   1052   1.58   thorpej /*
   1053   1.58   thorpej  * Release a cwdinfo structure.
   1054   1.58   thorpej  */
   1055   1.58   thorpej void
   1056  1.126        pk cwdfree(struct cwdinfo *cwdi)
   1057   1.58   thorpej {
   1058  1.126        pk 	int n;
   1059   1.58   thorpej 
   1060  1.126        pk 	simple_lock(&cwdi->cwdi_slock);
   1061  1.126        pk 	n = --cwdi->cwdi_refcnt;
   1062  1.126        pk 	simple_unlock(&cwdi->cwdi_slock);
   1063  1.126        pk 	if (n > 0)
   1064   1.58   thorpej 		return;
   1065   1.58   thorpej 
   1066   1.58   thorpej 	vrele(cwdi->cwdi_cdir);
   1067   1.58   thorpej 	if (cwdi->cwdi_rdir)
   1068   1.58   thorpej 		vrele(cwdi->cwdi_rdir);
   1069   1.58   thorpej 	pool_put(&cwdi_pool, cwdi);
   1070   1.58   thorpej }
   1071   1.58   thorpej 
   1072   1.58   thorpej /*
   1073   1.48   thorpej  * Create an initial filedesc structure, using the same current and root
   1074   1.48   thorpej  * directories as p.
   1075   1.48   thorpej  */
   1076   1.48   thorpej struct filedesc *
   1077   1.72     lukem fdinit(struct proc *p)
   1078   1.48   thorpej {
   1079   1.48   thorpej 	struct filedesc0 *newfdp;
   1080   1.48   thorpej 
   1081   1.64   thorpej 	newfdp = pool_get(&filedesc0_pool, PR_WAITOK);
   1082   1.53     perry 	memset(newfdp, 0, sizeof(struct filedesc0));
   1083   1.48   thorpej 
   1084   1.48   thorpej 	fdinit1(newfdp);
   1085   1.48   thorpej 
   1086   1.48   thorpej 	return (&newfdp->fd_fd);
   1087   1.48   thorpej }
   1088   1.48   thorpej 
   1089   1.48   thorpej /*
   1090   1.48   thorpej  * Initialize a file descriptor table.
   1091   1.48   thorpej  */
   1092   1.48   thorpej void
   1093   1.72     lukem fdinit1(struct filedesc0 *newfdp)
   1094   1.48   thorpej {
   1095   1.48   thorpej 
   1096   1.48   thorpej 	newfdp->fd_fd.fd_refcnt = 1;
   1097   1.48   thorpej 	newfdp->fd_fd.fd_ofiles = newfdp->fd_dfiles;
   1098   1.48   thorpej 	newfdp->fd_fd.fd_ofileflags = newfdp->fd_dfileflags;
   1099   1.48   thorpej 	newfdp->fd_fd.fd_nfiles = NDFILE;
   1100   1.96  jdolecek 	newfdp->fd_fd.fd_knlistsize = -1;
   1101  1.115    provos 	newfdp->fd_fd.fd_himap = newfdp->fd_dhimap;
   1102  1.115    provos 	newfdp->fd_fd.fd_lomap = newfdp->fd_dlomap;
   1103  1.128      cube 	newfdp->fd_fd.fd_lastfile = -1;
   1104  1.126        pk 	simple_lock_init(&newfdp->fd_fd.fd_slock);
   1105   1.48   thorpej }
   1106   1.48   thorpej 
   1107   1.48   thorpej /*
   1108   1.48   thorpej  * Make p2 share p1's filedesc structure.
   1109   1.48   thorpej  */
   1110   1.48   thorpej void
   1111   1.72     lukem fdshare(struct proc *p1, struct proc *p2)
   1112   1.48   thorpej {
   1113  1.126        pk 	struct filedesc *fdp = p1->p_fd;
   1114   1.48   thorpej 
   1115  1.126        pk 	simple_lock(&fdp->fd_slock);
   1116  1.126        pk 	p2->p_fd = fdp;
   1117  1.126        pk 	fdp->fd_refcnt++;
   1118  1.126        pk 	simple_unlock(&fdp->fd_slock);
   1119   1.48   thorpej }
   1120   1.48   thorpej 
   1121   1.48   thorpej /*
   1122   1.48   thorpej  * Make this process not share its filedesc structure, maintaining
   1123   1.48   thorpej  * all file descriptor state.
   1124   1.48   thorpej  */
   1125   1.48   thorpej void
   1126  1.110      fvdl fdunshare(struct proc *p)
   1127   1.48   thorpej {
   1128   1.48   thorpej 	struct filedesc *newfd;
   1129   1.48   thorpej 
   1130   1.48   thorpej 	if (p->p_fd->fd_refcnt == 1)
   1131   1.48   thorpej 		return;
   1132   1.48   thorpej 
   1133   1.48   thorpej 	newfd = fdcopy(p);
   1134  1.110      fvdl 	fdfree(p);
   1135   1.48   thorpej 	p->p_fd = newfd;
   1136   1.48   thorpej }
   1137   1.48   thorpej 
   1138   1.48   thorpej /*
   1139   1.48   thorpej  * Clear a process's fd table.
   1140   1.48   thorpej  */
   1141   1.48   thorpej void
   1142  1.110      fvdl fdclear(struct proc *p)
   1143   1.48   thorpej {
   1144   1.48   thorpej 	struct filedesc *newfd;
   1145   1.48   thorpej 
   1146   1.48   thorpej 	newfd = fdinit(p);
   1147  1.110      fvdl 	fdfree(p);
   1148   1.48   thorpej 	p->p_fd = newfd;
   1149   1.16       cgd }
   1150   1.16       cgd 
   1151   1.16       cgd /*
   1152   1.16       cgd  * Copy a filedesc structure.
   1153   1.16       cgd  */
   1154   1.16       cgd struct filedesc *
   1155   1.72     lukem fdcopy(struct proc *p)
   1156   1.16       cgd {
   1157   1.72     lukem 	struct filedesc	*newfdp, *fdp;
   1158  1.126        pk 	struct file	**fpp, **nfpp;
   1159  1.126        pk 	int		i, nfiles, lastfile;
   1160   1.16       cgd 
   1161   1.72     lukem 	fdp = p->p_fd;
   1162   1.64   thorpej 	newfdp = pool_get(&filedesc0_pool, PR_WAITOK);
   1163   1.16       cgd 	newfdp->fd_refcnt = 1;
   1164  1.126        pk 	simple_lock_init(&newfdp->fd_slock);
   1165  1.126        pk 
   1166  1.126        pk restart:
   1167  1.126        pk 	nfiles = fdp->fd_nfiles;
   1168  1.126        pk 	lastfile = fdp->fd_lastfile;
   1169   1.16       cgd 
   1170   1.16       cgd 	/*
   1171   1.16       cgd 	 * If the number of open files fits in the internal arrays
   1172   1.16       cgd 	 * of the open file structure, use them, otherwise allocate
   1173   1.16       cgd 	 * additional memory for the number of descriptors currently
   1174   1.16       cgd 	 * in use.
   1175   1.16       cgd 	 */
   1176  1.126        pk 	if (lastfile < NDFILE) {
   1177   1.16       cgd 		i = NDFILE;
   1178   1.16       cgd 	} else {
   1179   1.16       cgd 		/*
   1180   1.16       cgd 		 * Compute the smallest multiple of NDEXTENT needed
   1181   1.16       cgd 		 * for the file descriptors currently in use,
   1182   1.16       cgd 		 * allowing the table to shrink.
   1183   1.16       cgd 		 */
   1184  1.126        pk 		i = nfiles;
   1185  1.126        pk 		while (i >= 2 * NDEXTENT && i > lastfile * 2)
   1186   1.16       cgd 			i /= 2;
   1187   1.64   thorpej 		newfdp->fd_ofiles = malloc(i * OFILESIZE, M_FILEDESC, M_WAITOK);
   1188  1.126        pk 	}
   1189  1.126        pk 	if (NDHISLOTS(i) > NDHISLOTS(NDFILE)) {
   1190  1.126        pk 		newfdp->fd_himap = malloc(NDHISLOTS(i) * sizeof(uint32_t),
   1191  1.126        pk 		    M_FILEDESC, M_WAITOK);
   1192  1.126        pk 		newfdp->fd_lomap = malloc(NDLOSLOTS(i) * sizeof(uint32_t),
   1193  1.126        pk 		    M_FILEDESC, M_WAITOK);
   1194  1.126        pk 	}
   1195  1.126        pk 
   1196  1.126        pk 	simple_lock(&fdp->fd_slock);
   1197  1.126        pk 	if (nfiles != fdp->fd_nfiles || lastfile != fdp->fd_lastfile) {
   1198  1.126        pk 		simple_unlock(&fdp->fd_slock);
   1199  1.126        pk 		if (i > NDFILE)
   1200  1.126        pk 			free(newfdp->fd_ofiles, M_FILEDESC);
   1201  1.126        pk 		if (NDHISLOTS(i) > NDHISLOTS(NDFILE)) {
   1202  1.126        pk 			free(newfdp->fd_himap, M_FILEDESC);
   1203  1.126        pk 			free(newfdp->fd_lomap, M_FILEDESC);
   1204  1.126        pk 		}
   1205  1.126        pk 		goto restart;
   1206  1.126        pk 	}
   1207  1.126        pk 
   1208  1.126        pk 	if (lastfile < NDFILE) {
   1209  1.126        pk 		newfdp->fd_ofiles = ((struct filedesc0 *) newfdp)->fd_dfiles;
   1210  1.126        pk 		newfdp->fd_ofileflags =
   1211  1.126        pk 		    ((struct filedesc0 *) newfdp)->fd_dfileflags;
   1212  1.126        pk 	} else {
   1213   1.16       cgd 		newfdp->fd_ofileflags = (char *) &newfdp->fd_ofiles[i];
   1214   1.16       cgd 	}
   1215  1.115    provos 	if (NDHISLOTS(i) <= NDHISLOTS(NDFILE)) {
   1216  1.115    provos 		newfdp->fd_himap =
   1217  1.115    provos 		    ((struct filedesc0 *) newfdp)->fd_dhimap;
   1218  1.115    provos 		newfdp->fd_lomap =
   1219  1.115    provos 		    ((struct filedesc0 *) newfdp)->fd_dlomap;
   1220  1.115    provos 	}
   1221  1.115    provos 
   1222   1.16       cgd 	newfdp->fd_nfiles = i;
   1223  1.126        pk 	newfdp->fd_lastfile = lastfile;
   1224  1.126        pk 	newfdp->fd_freefile = fdp->fd_freefile;
   1225  1.126        pk 
   1226  1.128      cube 	/* Clear the entries that will not be copied over.
   1227  1.128      cube 	 * Avoid calling memset with 0 size (i.e. when
   1228  1.128      cube 	 * lastfile == i-1 */
   1229  1.128      cube 	if (lastfile < (i-1))
   1230  1.128      cube 		memset(newfdp->fd_ofiles + lastfile + 1, 0,
   1231  1.128      cube 		    (i - lastfile - 1) * sizeof(struct file **));
   1232   1.53     perry 	memcpy(newfdp->fd_ofileflags, fdp->fd_ofileflags, i * sizeof(char));
   1233  1.120      yamt 	if (i < NDENTRIES * NDENTRIES)
   1234  1.120      yamt 		i = NDENTRIES * NDENTRIES; /* size of inlined bitmaps */
   1235  1.115    provos 	memcpy(newfdp->fd_himap, fdp->fd_himap, NDHISLOTS(i)*sizeof(uint32_t));
   1236  1.115    provos 	memcpy(newfdp->fd_lomap, fdp->fd_lomap, NDLOSLOTS(i)*sizeof(uint32_t));
   1237  1.126        pk 
   1238  1.126        pk 	fpp = fdp->fd_ofiles;
   1239  1.126        pk 	nfpp = newfdp->fd_ofiles;
   1240  1.126        pk 	for (i = 0; i <= lastfile; i++, fpp++, nfpp++) {
   1241  1.126        pk 		if ((*nfpp = *fpp) == NULL)
   1242  1.126        pk 			continue;
   1243  1.126        pk 
   1244  1.126        pk 		if ((*fpp)->f_type == DTYPE_KQUEUE)
   1245  1.126        pk 			/* kq descriptors cannot be copied. */
   1246  1.126        pk 			fdremove(newfdp, i);
   1247  1.126        pk 		else {
   1248  1.126        pk 			simple_lock(&(*fpp)->f_slock);
   1249  1.126        pk 			(*fpp)->f_count++;
   1250  1.126        pk 			simple_unlock(&(*fpp)->f_slock);
   1251   1.96  jdolecek 		}
   1252  1.126        pk 	}
   1253  1.126        pk 
   1254  1.126        pk 	simple_unlock(&fdp->fd_slock);
   1255  1.126        pk 
   1256  1.126        pk 	newfdp->fd_knlist = NULL;
   1257  1.126        pk 	newfdp->fd_knlistsize = -1;
   1258  1.126        pk 	newfdp->fd_knhash = NULL;
   1259  1.126        pk 	newfdp->fd_knhashmask = 0;
   1260  1.126        pk 
   1261   1.16       cgd 	return (newfdp);
   1262   1.16       cgd }
   1263   1.16       cgd 
   1264   1.16       cgd /*
   1265   1.16       cgd  * Release a filedesc structure.
   1266   1.16       cgd  */
   1267   1.16       cgd void
   1268  1.110      fvdl fdfree(struct proc *p)
   1269   1.16       cgd {
   1270   1.72     lukem 	struct filedesc	*fdp;
   1271   1.72     lukem 	struct file	**fpp, *fp;
   1272   1.72     lukem 	int		i;
   1273   1.16       cgd 
   1274   1.72     lukem 	fdp = p->p_fd;
   1275  1.126        pk 	simple_lock(&fdp->fd_slock);
   1276  1.126        pk 	i = --fdp->fd_refcnt;
   1277  1.126        pk 	simple_unlock(&fdp->fd_slock);
   1278  1.126        pk 	if (i > 0)
   1279   1.16       cgd 		return;
   1280  1.126        pk 
   1281   1.16       cgd 	fpp = fdp->fd_ofiles;
   1282   1.32   mycroft 	for (i = fdp->fd_lastfile; i >= 0; i--, fpp++) {
   1283   1.32   mycroft 		fp = *fpp;
   1284   1.32   mycroft 		if (fp != NULL) {
   1285   1.32   mycroft 			*fpp = NULL;
   1286  1.103        pk 			simple_lock(&fp->f_slock);
   1287   1.59   thorpej 			FILE_USE(fp);
   1288   1.96  jdolecek 			if (i < fdp->fd_knlistsize)
   1289  1.110      fvdl 				knote_fdclose(p, fdp->fd_lastfile - i);
   1290  1.110      fvdl 			(void) closef(fp, p);
   1291   1.32   mycroft 		}
   1292   1.32   mycroft 	}
   1293   1.32   mycroft 	p->p_fd = NULL;
   1294   1.16       cgd 	if (fdp->fd_nfiles > NDFILE)
   1295   1.64   thorpej 		free(fdp->fd_ofiles, M_FILEDESC);
   1296  1.115    provos 	if (NDHISLOTS(fdp->fd_nfiles) > NDHISLOTS(NDFILE)) {
   1297  1.115    provos 		free(fdp->fd_himap, M_FILEDESC);
   1298  1.115    provos 		free(fdp->fd_lomap, M_FILEDESC);
   1299  1.115    provos 	}
   1300   1.96  jdolecek 	if (fdp->fd_knlist)
   1301   1.96  jdolecek 		free(fdp->fd_knlist, M_KEVENT);
   1302   1.96  jdolecek 	if (fdp->fd_knhash)
   1303   1.96  jdolecek 		hashdone(fdp->fd_knhash, M_KEVENT);
   1304   1.64   thorpej 	pool_put(&filedesc0_pool, fdp);
   1305   1.16       cgd }
   1306   1.16       cgd 
   1307   1.16       cgd /*
   1308   1.16       cgd  * Internal form of close.
   1309   1.16       cgd  * Decrement reference count on file structure.
   1310   1.17       cgd  * Note: p may be NULL when closing a file
   1311   1.17       cgd  * that was being passed in a message.
   1312   1.59   thorpej  *
   1313   1.59   thorpej  * Note: we expect the caller is holding a usecount, and expects us
   1314   1.59   thorpej  * to drop it (the caller thinks the file is going away forever).
   1315   1.16       cgd  */
   1316   1.38  christos int
   1317  1.110      fvdl closef(struct file *fp, struct proc *p)
   1318   1.72     lukem {
   1319   1.72     lukem 	struct vnode	*vp;
   1320   1.72     lukem 	struct flock	lf;
   1321   1.72     lukem 	int		error;
   1322   1.16       cgd 
   1323   1.16       cgd 	if (fp == NULL)
   1324   1.16       cgd 		return (0);
   1325   1.59   thorpej 
   1326   1.16       cgd 	/*
   1327   1.16       cgd 	 * POSIX record locking dictates that any close releases ALL
   1328   1.16       cgd 	 * locks owned by this process.  This is handled by setting
   1329   1.16       cgd 	 * a flag in the unlock to free ONLY locks obeying POSIX
   1330   1.16       cgd 	 * semantics, and not to free BSD-style file locks.
   1331   1.17       cgd 	 * If the descriptor was in a message, POSIX-style locks
   1332   1.17       cgd 	 * aren't passed with the descriptor.
   1333   1.16       cgd 	 */
   1334   1.16       cgd 	if (p && (p->p_flag & P_ADVLOCK) && fp->f_type == DTYPE_VNODE) {
   1335   1.16       cgd 		lf.l_whence = SEEK_SET;
   1336   1.16       cgd 		lf.l_start = 0;
   1337   1.16       cgd 		lf.l_len = 0;
   1338   1.16       cgd 		lf.l_type = F_UNLCK;
   1339   1.16       cgd 		vp = (struct vnode *)fp->f_data;
   1340  1.106       dsl 		(void) VOP_ADVLOCK(vp, p, F_UNLCK, &lf, F_POSIX);
   1341   1.16       cgd 	}
   1342   1.59   thorpej 
   1343   1.59   thorpej 	/*
   1344   1.59   thorpej 	 * If WANTCLOSE is set, then the reference count on the file
   1345   1.59   thorpej 	 * is 0, but there were multiple users of the file.  This can
   1346   1.59   thorpej 	 * happen if a filedesc structure is shared by multiple
   1347   1.59   thorpej 	 * processes.
   1348   1.59   thorpej 	 */
   1349  1.103        pk 	simple_lock(&fp->f_slock);
   1350   1.83  jdolecek 	if (fp->f_iflags & FIF_WANTCLOSE) {
   1351   1.59   thorpej 		/*
   1352   1.59   thorpej 		 * Another user of the file is already closing, and is
   1353   1.59   thorpej 		 * simply waiting for other users of the file to drain.
   1354   1.59   thorpej 		 * Release our usecount, and wake up the closer if it
   1355   1.59   thorpej 		 * is the only remaining use.
   1356   1.59   thorpej 		 */
   1357   1.59   thorpej #ifdef DIAGNOSTIC
   1358   1.59   thorpej 		if (fp->f_count != 0)
   1359   1.59   thorpej 			panic("closef: wantclose and count != 0");
   1360   1.59   thorpej 		if (fp->f_usecount < 2)
   1361   1.59   thorpej 			panic("closef: wantclose and usecount < 2");
   1362   1.59   thorpej #endif
   1363   1.59   thorpej 		if (--fp->f_usecount == 1)
   1364   1.59   thorpej 			wakeup(&fp->f_usecount);
   1365  1.103        pk 		simple_unlock(&fp->f_slock);
   1366   1.16       cgd 		return (0);
   1367   1.59   thorpej 	} else {
   1368   1.59   thorpej 		/*
   1369   1.59   thorpej 		 * Decrement the reference count.  If we were not the
   1370   1.59   thorpej 		 * last reference, then release our use and just
   1371   1.59   thorpej 		 * return.
   1372   1.59   thorpej 		 */
   1373   1.59   thorpej 		if (--fp->f_count > 0) {
   1374   1.59   thorpej #ifdef DIAGNOSTIC
   1375   1.59   thorpej 			if (fp->f_usecount < 1)
   1376   1.59   thorpej 				panic("closef: no wantclose and usecount < 1");
   1377   1.59   thorpej #endif
   1378   1.59   thorpej 			fp->f_usecount--;
   1379  1.103        pk 			simple_unlock(&fp->f_slock);
   1380   1.59   thorpej 			return (0);
   1381   1.59   thorpej 		}
   1382   1.59   thorpej 	}
   1383   1.59   thorpej 
   1384   1.59   thorpej 	/*
   1385   1.59   thorpej 	 * The reference count is now 0.  However, there may be
   1386   1.59   thorpej 	 * multiple potential users of this file.  This can happen
   1387   1.59   thorpej 	 * if multiple processes shared a single filedesc structure.
   1388   1.59   thorpej 	 *
   1389   1.59   thorpej 	 * Notify these potential users that the file is closing.
   1390   1.59   thorpej 	 * This will prevent them from adding additional uses to
   1391   1.59   thorpej 	 * the file.
   1392   1.59   thorpej 	 */
   1393   1.83  jdolecek 	fp->f_iflags |= FIF_WANTCLOSE;
   1394   1.59   thorpej 
   1395   1.59   thorpej 	/*
   1396   1.59   thorpej 	 * We expect the caller to add a use to the file.  So, if we
   1397   1.59   thorpej 	 * are the last user, usecount will be 1.  If it is not, we
   1398   1.59   thorpej 	 * must wait for the usecount to drain.  When it drains back
   1399   1.59   thorpej 	 * to 1, we will be awakened so that we may proceed with the
   1400   1.59   thorpej 	 * close.
   1401   1.59   thorpej 	 */
   1402   1.59   thorpej #ifdef DIAGNOSTIC
   1403   1.59   thorpej 	if (fp->f_usecount < 1)
   1404   1.59   thorpej 		panic("closef: usecount < 1");
   1405   1.59   thorpej #endif
   1406   1.59   thorpej 	while (fp->f_usecount > 1)
   1407  1.103        pk 		(void) ltsleep(&fp->f_usecount, PRIBIO, "closef", 0,
   1408  1.103        pk 				&fp->f_slock);
   1409   1.59   thorpej #ifdef DIAGNOSTIC
   1410   1.59   thorpej 	if (fp->f_usecount != 1)
   1411   1.59   thorpej 		panic("closef: usecount != 1");
   1412   1.59   thorpej #endif
   1413   1.59   thorpej 
   1414  1.103        pk 	simple_unlock(&fp->f_slock);
   1415   1.16       cgd 	if ((fp->f_flag & FHASLOCK) && fp->f_type == DTYPE_VNODE) {
   1416   1.16       cgd 		lf.l_whence = SEEK_SET;
   1417   1.16       cgd 		lf.l_start = 0;
   1418   1.16       cgd 		lf.l_len = 0;
   1419   1.16       cgd 		lf.l_type = F_UNLCK;
   1420   1.16       cgd 		vp = (struct vnode *)fp->f_data;
   1421  1.106       dsl 		(void) VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK);
   1422   1.16       cgd 	}
   1423   1.17       cgd 	if (fp->f_ops)
   1424  1.110      fvdl 		error = (*fp->f_ops->fo_close)(fp, p);
   1425   1.17       cgd 	else
   1426   1.17       cgd 		error = 0;
   1427   1.59   thorpej 
   1428   1.59   thorpej 	/* Nothing references the file now, drop the final use (us). */
   1429   1.59   thorpej 	fp->f_usecount--;
   1430   1.59   thorpej 
   1431   1.16       cgd 	ffree(fp);
   1432   1.16       cgd 	return (error);
   1433   1.16       cgd }
   1434   1.16       cgd 
   1435   1.16       cgd /*
   1436   1.16       cgd  * Apply an advisory lock on a file descriptor.
   1437   1.16       cgd  *
   1438   1.16       cgd  * Just attempt to get a record lock of the requested type on
   1439   1.16       cgd  * the entire file (l_whence = SEEK_SET, l_start = 0, l_len = 0).
   1440   1.16       cgd  */
   1441   1.16       cgd /* ARGSUSED */
   1442   1.38  christos int
   1443   1.99   thorpej sys_flock(struct lwp *l, void *v, register_t *retval)
   1444   1.36   thorpej {
   1445   1.66  augustss 	struct sys_flock_args /* {
   1446   1.72     lukem 		syscallarg(int)	fd;
   1447   1.72     lukem 		syscallarg(int)	how;
   1448   1.36   thorpej 	} */ *uap = v;
   1449   1.72     lukem 	int		fd, how, error;
   1450   1.99   thorpej 	struct proc	*p;
   1451   1.72     lukem 	struct filedesc	*fdp;
   1452   1.72     lukem 	struct file	*fp;
   1453   1.72     lukem 	struct vnode	*vp;
   1454   1.72     lukem 	struct flock	lf;
   1455   1.16       cgd 
   1456   1.99   thorpej 	p = l->l_proc;
   1457   1.72     lukem 	fd = SCARG(uap, fd);
   1458   1.72     lukem 	how = SCARG(uap, how);
   1459   1.72     lukem 	fdp = p->p_fd;
   1460   1.72     lukem 	error = 0;
   1461   1.77   thorpej 
   1462   1.77   thorpej 	if ((fp = fd_getfile(fdp, fd)) == NULL)
   1463   1.16       cgd 		return (EBADF);
   1464   1.59   thorpej 
   1465   1.59   thorpej 	FILE_USE(fp);
   1466   1.59   thorpej 
   1467   1.59   thorpej 	if (fp->f_type != DTYPE_VNODE) {
   1468   1.59   thorpej 		error = EOPNOTSUPP;
   1469   1.59   thorpej 		goto out;
   1470   1.59   thorpej 	}
   1471   1.59   thorpej 
   1472   1.16       cgd 	vp = (struct vnode *)fp->f_data;
   1473   1.16       cgd 	lf.l_whence = SEEK_SET;
   1474   1.16       cgd 	lf.l_start = 0;
   1475   1.16       cgd 	lf.l_len = 0;
   1476   1.27   mycroft 	if (how & LOCK_UN) {
   1477   1.16       cgd 		lf.l_type = F_UNLCK;
   1478   1.16       cgd 		fp->f_flag &= ~FHASLOCK;
   1479  1.106       dsl 		error = VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK);
   1480   1.59   thorpej 		goto out;
   1481   1.16       cgd 	}
   1482   1.27   mycroft 	if (how & LOCK_EX)
   1483   1.16       cgd 		lf.l_type = F_WRLCK;
   1484   1.27   mycroft 	else if (how & LOCK_SH)
   1485   1.16       cgd 		lf.l_type = F_RDLCK;
   1486   1.59   thorpej 	else {
   1487   1.59   thorpej 		error = EINVAL;
   1488   1.59   thorpej 		goto out;
   1489   1.59   thorpej 	}
   1490   1.16       cgd 	fp->f_flag |= FHASLOCK;
   1491   1.27   mycroft 	if (how & LOCK_NB)
   1492  1.106       dsl 		error = VOP_ADVLOCK(vp, fp, F_SETLK, &lf, F_FLOCK);
   1493   1.59   thorpej 	else
   1494  1.106       dsl 		error = VOP_ADVLOCK(vp, fp, F_SETLK, &lf,
   1495   1.59   thorpej 		    F_FLOCK|F_WAIT);
   1496   1.59   thorpej  out:
   1497  1.110      fvdl 	FILE_UNUSE(fp, p);
   1498   1.59   thorpej 	return (error);
   1499   1.16       cgd }
   1500   1.16       cgd 
   1501   1.16       cgd /*
   1502   1.16       cgd  * File Descriptor pseudo-device driver (/dev/fd/).
   1503   1.16       cgd  *
   1504   1.16       cgd  * Opening minor device N dup()s the file (if any) connected to file
   1505   1.16       cgd  * descriptor N belonging to the calling process.  Note that this driver
   1506   1.16       cgd  * consists of only the ``open()'' routine, because all subsequent
   1507   1.16       cgd  * references to this file will be direct to the other driver.
   1508   1.16       cgd  */
   1509   1.16       cgd /* ARGSUSED */
   1510   1.28   mycroft int
   1511  1.110      fvdl filedescopen(dev_t dev, int mode, int type, struct proc *p)
   1512   1.16       cgd {
   1513   1.16       cgd 
   1514   1.28   mycroft 	/*
   1515  1.112  jdolecek 	 * XXX Kludge: set dupfd to contain the value of the
   1516   1.89     enami 	 * the file descriptor being sought for duplication. The error
   1517   1.28   mycroft 	 * return ensures that the vnode for this device will be released
   1518   1.28   mycroft 	 * by vn_open. Open will detect this special error and take the
   1519   1.28   mycroft 	 * actions in dupfdopen below. Other callers of vn_open or VOP_OPEN
   1520   1.28   mycroft 	 * will simply report the error.
   1521   1.28   mycroft 	 */
   1522  1.112  jdolecek 	curlwp->l_dupfd = minor(dev);	/* XXX */
   1523  1.127  christos 	return EDUPFD;
   1524   1.27   mycroft }
   1525   1.27   mycroft 
   1526   1.28   mycroft /*
   1527   1.28   mycroft  * Duplicate the specified descriptor to a free descriptor.
   1528  1.118      yamt  *
   1529  1.118      yamt  * 'indx' has been fdalloc'ed (and will be fdremove'ed on error) by the caller.
   1530   1.28   mycroft  */
   1531   1.27   mycroft int
   1532  1.110      fvdl dupfdopen(struct proc *p, int indx, int dfd, int mode, int error)
   1533   1.72     lukem {
   1534  1.110      fvdl 	struct filedesc	*fdp;
   1535  1.118      yamt 	struct file	*wfp;
   1536   1.27   mycroft 
   1537   1.72     lukem 	fdp = p->p_fd;
   1538  1.118      yamt 
   1539  1.118      yamt 	/* should be cleared by the caller */
   1540  1.118      yamt 	KASSERT(fdp->fd_ofiles[indx] == NULL);
   1541  1.118      yamt 
   1542   1.27   mycroft 	/*
   1543   1.27   mycroft 	 * If the to-be-dup'd fd number is greater than the allowed number
   1544   1.27   mycroft 	 * of file descriptors, or the fd to be dup'd has already been
   1545  1.118      yamt 	 * closed, reject.
   1546   1.27   mycroft 	 */
   1547   1.77   thorpej 
   1548  1.118      yamt 	/*
   1549  1.118      yamt 	 * Note, in the case of indx == dfd, fd_getfile below returns NULL.
   1550  1.118      yamt 	 */
   1551   1.77   thorpej 	if ((wfp = fd_getfile(fdp, dfd)) == NULL)
   1552   1.77   thorpej 		return (EBADF);
   1553   1.77   thorpej 
   1554   1.59   thorpej 	FILE_USE(wfp);
   1555   1.59   thorpej 
   1556   1.27   mycroft 	/*
   1557   1.28   mycroft 	 * There are two cases of interest here.
   1558   1.28   mycroft 	 *
   1559  1.127  christos 	 * For EDUPFD simply dup (dfd) to file descriptor
   1560   1.28   mycroft 	 * (indx) and return.
   1561   1.28   mycroft 	 *
   1562  1.127  christos 	 * For EMOVEFD steal away the file structure from (dfd) and
   1563   1.28   mycroft 	 * store it in (indx).  (dfd) is effectively closed by
   1564   1.28   mycroft 	 * this operation.
   1565   1.28   mycroft 	 *
   1566   1.28   mycroft 	 * Any other error code is just returned.
   1567   1.27   mycroft 	 */
   1568   1.28   mycroft 	switch (error) {
   1569  1.127  christos 	case EDUPFD:
   1570   1.28   mycroft 		/*
   1571   1.28   mycroft 		 * Check that the mode the file is being opened for is a
   1572   1.28   mycroft 		 * subset of the mode of the existing descriptor.
   1573   1.28   mycroft 		 */
   1574   1.59   thorpej 		if (((mode & (FREAD|FWRITE)) | wfp->f_flag) != wfp->f_flag) {
   1575  1.110      fvdl 			FILE_UNUSE(wfp, p);
   1576   1.28   mycroft 			return (EACCES);
   1577   1.59   thorpej 		}
   1578  1.126        pk 		simple_lock(&fdp->fd_slock);
   1579   1.28   mycroft 		fdp->fd_ofiles[indx] = wfp;
   1580   1.28   mycroft 		fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd];
   1581  1.126        pk 		simple_unlock(&fdp->fd_slock);
   1582  1.126        pk 		simple_lock(&wfp->f_slock);
   1583   1.28   mycroft 		wfp->f_count++;
   1584  1.119      yamt 		/* 'indx' has been fd_used'ed by caller */
   1585  1.126        pk 		FILE_UNUSE_HAVELOCK(wfp, p);
   1586   1.28   mycroft 		return (0);
   1587   1.27   mycroft 
   1588  1.127  christos 	case EMOVEFD:
   1589   1.28   mycroft 		/*
   1590   1.28   mycroft 		 * Steal away the file pointer from dfd, and stuff it into indx.
   1591   1.28   mycroft 		 */
   1592  1.126        pk 		simple_lock(&fdp->fd_slock);
   1593   1.28   mycroft 		fdp->fd_ofiles[indx] = fdp->fd_ofiles[dfd];
   1594   1.28   mycroft 		fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd];
   1595   1.28   mycroft 		fdp->fd_ofiles[dfd] = NULL;
   1596   1.28   mycroft 		fdp->fd_ofileflags[dfd] = 0;
   1597   1.28   mycroft 		/*
   1598   1.28   mycroft 		 * Complete the clean up of the filedesc structure by
   1599   1.28   mycroft 		 * recomputing the various hints.
   1600   1.28   mycroft 		 */
   1601  1.119      yamt 		/* 'indx' has been fd_used'ed by caller */
   1602   1.28   mycroft 		fd_unused(fdp, dfd);
   1603  1.126        pk 		simple_unlock(&fdp->fd_slock);
   1604  1.110      fvdl 		FILE_UNUSE(wfp, p);
   1605   1.28   mycroft 		return (0);
   1606   1.16       cgd 
   1607   1.28   mycroft 	default:
   1608  1.110      fvdl 		FILE_UNUSE(wfp, p);
   1609   1.28   mycroft 		return (error);
   1610   1.28   mycroft 	}
   1611   1.28   mycroft 	/* NOTREACHED */
   1612   1.61  wrstuden }
   1613   1.61  wrstuden 
   1614   1.61  wrstuden /*
   1615   1.61  wrstuden  * fcntl call which is being passed to the file's fs.
   1616   1.61  wrstuden  */
   1617   1.61  wrstuden int
   1618  1.110      fvdl fcntl_forfs(int fd, struct proc *p, int cmd, void *arg)
   1619   1.61  wrstuden {
   1620   1.72     lukem 	struct file	*fp;
   1621   1.72     lukem 	struct filedesc	*fdp;
   1622   1.72     lukem 	int		error;
   1623   1.72     lukem 	u_int		size;
   1624  1.106       dsl 	void		*data, *memp;
   1625   1.61  wrstuden #define STK_PARAMS	128
   1626   1.72     lukem 	char		stkbuf[STK_PARAMS];
   1627   1.61  wrstuden 
   1628   1.61  wrstuden 	/* fd's value was validated in sys_fcntl before calling this routine */
   1629   1.61  wrstuden 	fdp = p->p_fd;
   1630   1.61  wrstuden 	fp = fdp->fd_ofiles[fd];
   1631   1.61  wrstuden 
   1632   1.61  wrstuden 	if ((fp->f_flag & (FREAD | FWRITE)) == 0)
   1633   1.61  wrstuden 		return (EBADF);
   1634   1.61  wrstuden 
   1635   1.61  wrstuden 	/*
   1636   1.61  wrstuden 	 * Interpret high order word to find amount of data to be
   1637   1.61  wrstuden 	 * copied to/from the user's address space.
   1638   1.61  wrstuden 	 */
   1639   1.61  wrstuden 	size = (size_t)F_PARAM_LEN(cmd);
   1640   1.61  wrstuden 	if (size > F_PARAM_MAX)
   1641   1.61  wrstuden 		return (EINVAL);
   1642   1.61  wrstuden 	memp = NULL;
   1643   1.61  wrstuden 	if (size > sizeof(stkbuf)) {
   1644  1.106       dsl 		memp = malloc((u_long)size, M_IOCTLOPS, M_WAITOK);
   1645   1.61  wrstuden 		data = memp;
   1646   1.61  wrstuden 	} else
   1647   1.61  wrstuden 		data = stkbuf;
   1648   1.61  wrstuden 	if (cmd & F_FSIN) {
   1649   1.61  wrstuden 		if (size) {
   1650   1.61  wrstuden 			error = copyin(arg, data, size);
   1651   1.61  wrstuden 			if (error) {
   1652   1.61  wrstuden 				if (memp)
   1653   1.61  wrstuden 					free(memp, M_IOCTLOPS);
   1654   1.61  wrstuden 				return (error);
   1655   1.61  wrstuden 			}
   1656   1.61  wrstuden 		} else
   1657  1.106       dsl 			*(void **)data = arg;
   1658   1.61  wrstuden 	} else if ((cmd & F_FSOUT) && size)
   1659   1.61  wrstuden 		/*
   1660   1.61  wrstuden 		 * Zero the buffer so the user always
   1661   1.61  wrstuden 		 * gets back something deterministic.
   1662   1.61  wrstuden 		 */
   1663   1.61  wrstuden 		memset(data, 0, size);
   1664   1.61  wrstuden 	else if (cmd & F_FSVOID)
   1665  1.106       dsl 		*(void **)data = arg;
   1666   1.61  wrstuden 
   1667   1.61  wrstuden 
   1668  1.110      fvdl 	error = (*fp->f_ops->fo_fcntl)(fp, cmd, data, p);
   1669   1.61  wrstuden 
   1670   1.61  wrstuden 	/*
   1671   1.61  wrstuden 	 * Copy any data to user, size was
   1672   1.61  wrstuden 	 * already set and checked above.
   1673   1.61  wrstuden 	 */
   1674   1.61  wrstuden 	if (error == 0 && (cmd & F_FSOUT) && size)
   1675   1.61  wrstuden 		error = copyout(data, arg, size);
   1676   1.61  wrstuden 	if (memp)
   1677   1.61  wrstuden 		free(memp, M_IOCTLOPS);
   1678   1.61  wrstuden 	return (error);
   1679   1.27   mycroft }
   1680   1.16       cgd 
   1681   1.27   mycroft /*
   1682   1.27   mycroft  * Close any files on exec?
   1683   1.27   mycroft  */
   1684   1.27   mycroft void
   1685  1.110      fvdl fdcloseexec(struct proc *p)
   1686   1.27   mycroft {
   1687  1.110      fvdl 	struct filedesc	*fdp;
   1688   1.72     lukem 	int		fd;
   1689   1.80   thorpej 
   1690  1.110      fvdl 	fdunshare(p);
   1691   1.80   thorpej 	cwdunshare(p);
   1692   1.16       cgd 
   1693   1.72     lukem 	fdp = p->p_fd;
   1694   1.27   mycroft 	for (fd = 0; fd <= fdp->fd_lastfile; fd++)
   1695   1.27   mycroft 		if (fdp->fd_ofileflags[fd] & UF_EXCLOSE)
   1696  1.110      fvdl 			(void) fdrelease(p, fd);
   1697   1.86  christos }
   1698   1.86  christos 
   1699   1.86  christos /*
   1700   1.86  christos  * It is unsafe for set[ug]id processes to be started with file
   1701   1.86  christos  * descriptors 0..2 closed, as these descriptors are given implicit
   1702   1.86  christos  * significance in the Standard C library.  fdcheckstd() will create a
   1703   1.86  christos  * descriptor referencing /dev/null for each of stdin, stdout, and
   1704   1.86  christos  * stderr that is not already open.
   1705   1.86  christos  */
   1706   1.92    atatat #define CHECK_UPTO 3
   1707   1.86  christos int
   1708  1.110      fvdl fdcheckstd(p)
   1709  1.110      fvdl 	struct proc *p;
   1710  1.109   darrenr {
   1711   1.86  christos 	struct nameidata nd;
   1712   1.86  christos 	struct filedesc *fdp;
   1713   1.86  christos 	struct file *fp;
   1714   1.97       scw 	struct file *devnullfp = NULL;	/* Quell compiler warning */
   1715   1.91     enami 	struct proc *pp;
   1716   1.86  christos 	register_t retval;
   1717   1.92    atatat 	int fd, i, error, flags = FREAD|FWRITE, devnull = -1;
   1718   1.92    atatat 	char closed[CHECK_UPTO * 3 + 1], which[3 + 1];
   1719   1.86  christos 
   1720   1.92    atatat 	closed[0] = '\0';
   1721   1.86  christos 	if ((fdp = p->p_fd) == NULL)
   1722   1.89     enami 		return (0);
   1723   1.92    atatat 	for (i = 0; i < CHECK_UPTO; i++) {
   1724   1.86  christos 		if (fdp->fd_ofiles[i] != NULL)
   1725   1.86  christos 			continue;
   1726   1.92    atatat 		snprintf(which, sizeof(which), ",%d", i);
   1727  1.108    itojun 		strlcat(closed, which, sizeof(closed));
   1728   1.86  christos 		if (devnull < 0) {
   1729   1.86  christos 			if ((error = falloc(p, &fp, &fd)) != 0)
   1730   1.89     enami 				return (error);
   1731   1.86  christos 			NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, "/dev/null",
   1732  1.110      fvdl 			    p);
   1733   1.86  christos 			if ((error = vn_open(&nd, flags, 0)) != 0) {
   1734  1.110      fvdl 				FILE_UNUSE(fp, p);
   1735   1.86  christos 				ffree(fp);
   1736   1.86  christos 				fdremove(p->p_fd, fd);
   1737   1.89     enami 				return (error);
   1738   1.86  christos 			}
   1739  1.106       dsl 			fp->f_data = nd.ni_vp;
   1740   1.86  christos 			fp->f_flag = flags;
   1741   1.86  christos 			fp->f_ops = &vnops;
   1742   1.86  christos 			fp->f_type = DTYPE_VNODE;
   1743   1.86  christos 			VOP_UNLOCK(nd.ni_vp, 0);
   1744   1.86  christos 			devnull = fd;
   1745   1.88  christos 			devnullfp = fp;
   1746   1.87  christos 			FILE_SET_MATURE(fp);
   1747   1.86  christos 		} else {
   1748   1.86  christos restart:
   1749   1.86  christos 			if ((error = fdalloc(p, 0, &fd)) != 0) {
   1750   1.86  christos 				if (error == ENOSPC) {
   1751   1.86  christos 					fdexpand(p);
   1752   1.86  christos 					goto restart;
   1753   1.86  christos 				}
   1754   1.89     enami 				return (error);
   1755   1.86  christos 			}
   1756   1.88  christos 
   1757  1.104      yamt 			simple_lock(&devnullfp->f_slock);
   1758   1.88  christos 			FILE_USE(devnullfp);
   1759   1.88  christos 			/* finishdup() will unuse the descriptors for us */
   1760  1.110      fvdl 			if ((error = finishdup(p, devnull, fd, &retval)) != 0)
   1761   1.89     enami 				return (error);
   1762   1.86  christos 		}
   1763   1.86  christos 	}
   1764  1.104      yamt 	if (devnullfp)
   1765  1.110      fvdl 		FILE_UNUSE(devnullfp, p);
   1766   1.92    atatat 	if (closed[0] != '\0') {
   1767   1.92    atatat 		pp = p->p_pptr;
   1768   1.92    atatat 		log(LOG_WARNING, "set{u,g}id pid %d (%s) "
   1769   1.92    atatat 		    "was invoked by uid %d ppid %d (%s) "
   1770   1.92    atatat 		    "with fd %s closed\n",
   1771   1.92    atatat 		    p->p_pid, p->p_comm, pp->p_ucred->cr_uid,
   1772   1.92    atatat 		    pp->p_pid, pp->p_comm, &closed[1]);
   1773   1.92    atatat 	}
   1774   1.89     enami 	return (0);
   1775   1.16       cgd }
   1776   1.92    atatat #undef CHECK_UPTO
   1777  1.113  jdolecek 
   1778  1.113  jdolecek /*
   1779  1.113  jdolecek  * Sets descriptor owner. If the owner is a process, 'pgid'
   1780  1.113  jdolecek  * is set to positive value, process ID. If the owner is process group,
   1781  1.113  jdolecek  * 'pgid' is set to -pg_id.
   1782  1.113  jdolecek  */
   1783  1.113  jdolecek int
   1784  1.113  jdolecek fsetown(struct proc *p, pid_t *pgid, int cmd, const void *data)
   1785  1.113  jdolecek {
   1786  1.113  jdolecek 	int id = *(int *)data;
   1787  1.113  jdolecek 	int error;
   1788  1.113  jdolecek 
   1789  1.113  jdolecek 	switch (cmd) {
   1790  1.113  jdolecek 	case TIOCSPGRP:
   1791  1.113  jdolecek 		if (id < 0)
   1792  1.113  jdolecek 			return (EINVAL);
   1793  1.113  jdolecek 		id = -id;
   1794  1.113  jdolecek 		break;
   1795  1.113  jdolecek 	default:
   1796  1.113  jdolecek 		break;
   1797  1.113  jdolecek 	}
   1798  1.113  jdolecek 
   1799  1.113  jdolecek 	if (id > 0 && !pfind(id))
   1800  1.113  jdolecek 		return (ESRCH);
   1801  1.113  jdolecek 	else if (id < 0 && (error = pgid_in_session(p, -id)))
   1802  1.113  jdolecek 		return (error);
   1803  1.113  jdolecek 
   1804  1.113  jdolecek 	*pgid = id;
   1805  1.113  jdolecek 	return (0);
   1806  1.113  jdolecek }
   1807  1.113  jdolecek 
   1808  1.113  jdolecek /*
   1809  1.113  jdolecek  * Return descriptor owner information. If the value is positive,
   1810  1.113  jdolecek  * it's process ID. If it's negative, it's process group ID and
   1811  1.113  jdolecek  * needs the sign removed before use.
   1812  1.113  jdolecek  */
   1813  1.113  jdolecek int
   1814  1.113  jdolecek fgetown(struct proc *p, pid_t pgid, int cmd, void *data)
   1815  1.113  jdolecek {
   1816  1.113  jdolecek 	switch (cmd) {
   1817  1.113  jdolecek 	case TIOCGPGRP:
   1818  1.113  jdolecek 		*(int *)data = -pgid;
   1819  1.113  jdolecek 		break;
   1820  1.113  jdolecek 	default:
   1821  1.113  jdolecek 		*(int *)data = pgid;
   1822  1.113  jdolecek 		break;
   1823  1.113  jdolecek 	}
   1824  1.113  jdolecek 	return (0);
   1825  1.113  jdolecek }
   1826  1.113  jdolecek 
   1827  1.113  jdolecek /*
   1828  1.113  jdolecek  * Send signal to descriptor owner, either process or process group.
   1829  1.113  jdolecek  */
   1830  1.113  jdolecek void
   1831  1.114  christos fownsignal(pid_t pgid, int signo, int code, int band, void *fdescdata)
   1832  1.113  jdolecek {
   1833  1.113  jdolecek 	struct proc *p1;
   1834  1.113  jdolecek 	ksiginfo_t ksi;
   1835  1.113  jdolecek 
   1836  1.113  jdolecek 	memset(&ksi, 0, sizeof(ksi));
   1837  1.114  christos 	ksi.ksi_signo = signo;
   1838  1.113  jdolecek 	ksi.ksi_code = code;
   1839  1.113  jdolecek 	ksi.ksi_band = band;
   1840  1.113  jdolecek 
   1841  1.113  jdolecek 	if (pgid > 0 && (p1 = pfind(pgid)))
   1842  1.113  jdolecek 		kpsignal(p1, &ksi, fdescdata);
   1843  1.113  jdolecek 	else if (pgid < 0)
   1844  1.113  jdolecek 		kgsignal(-pgid, &ksi, fdescdata);
   1845  1.113  jdolecek }
   1846  1.127  christos 
   1847  1.127  christos int
   1848  1.130  christos fdclone(struct proc *p, struct file *fp, int fd, int flag,
   1849  1.130  christos     const struct fileops *fops, void *data)
   1850  1.127  christos {
   1851  1.130  christos 	fp->f_flag = flag;
   1852  1.127  christos 	fp->f_type = DTYPE_MISC;
   1853  1.127  christos 	fp->f_ops = fops;
   1854  1.127  christos 	fp->f_data = data;
   1855  1.127  christos 
   1856  1.127  christos 	curlwp->l_dupfd = fd;
   1857  1.127  christos 
   1858  1.127  christos 	FILE_SET_MATURE(fp);
   1859  1.127  christos 	FILE_UNUSE(fp, p);
   1860  1.127  christos 	return EMOVEFD;
   1861  1.127  christos }
   1862  1.127  christos 
   1863  1.127  christos /* ARGSUSED */
   1864  1.127  christos int
   1865  1.127  christos fnullop_fcntl(struct file *fp, u_int cmd, void *data, struct proc *p)
   1866  1.127  christos {
   1867  1.127  christos 	if (cmd == F_SETFL)
   1868  1.127  christos 		return 0;
   1869  1.127  christos 
   1870  1.127  christos 	return EOPNOTSUPP;
   1871  1.127  christos }
   1872  1.127  christos 
   1873  1.127  christos /* ARGSUSED */
   1874  1.127  christos int
   1875  1.127  christos fnullop_poll(struct file *fp, int which, struct proc *p)
   1876  1.127  christos {
   1877  1.127  christos 	return 0;
   1878  1.127  christos }
   1879  1.127  christos 
   1880  1.127  christos 
   1881  1.127  christos /* ARGSUSED */
   1882  1.127  christos int
   1883  1.127  christos fnullop_kqfilter(struct file *fp, struct knote *kn)
   1884  1.127  christos {
   1885  1.127  christos 
   1886  1.127  christos 	return 0;
   1887  1.127  christos }
   1888  1.127  christos 
   1889  1.127  christos /* ARGSUSED */
   1890  1.127  christos int
   1891  1.127  christos fbadop_stat(struct file *fp, struct stat *sb, struct proc *p)
   1892  1.127  christos {
   1893  1.127  christos 	return EOPNOTSUPP;
   1894  1.127  christos }
   1895