Home | History | Annotate | Line # | Download | only in kern
sys_descrip.c revision 1.36
      1  1.36  riastrad /*	$NetBSD: sys_descrip.c,v 1.36 2020/02/01 02:23:04 riastradh Exp $	*/
      2   1.1        ad 
      3   1.1        ad /*-
      4   1.1        ad  * Copyright (c) 2008 The NetBSD Foundation, Inc.
      5   1.1        ad  * All rights reserved.
      6   1.1        ad  *
      7   1.1        ad  * Redistribution and use in source and binary forms, with or without
      8   1.1        ad  * modification, are permitted provided that the following conditions
      9   1.1        ad  * are met:
     10   1.1        ad  * 1. Redistributions of source code must retain the above copyright
     11   1.1        ad  *    notice, this list of conditions and the following disclaimer.
     12   1.1        ad  * 2. Redistributions in binary form must reproduce the above copyright
     13   1.1        ad  *    notice, this list of conditions and the following disclaimer in the
     14   1.1        ad  *    documentation and/or other materials provided with the distribution.
     15   1.1        ad  *
     16   1.1        ad  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     17   1.1        ad  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     18   1.1        ad  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     19   1.1        ad  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     20   1.1        ad  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21   1.1        ad  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22   1.1        ad  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     23   1.1        ad  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     24   1.1        ad  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     25   1.1        ad  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     26   1.1        ad  * POSSIBILITY OF SUCH DAMAGE.
     27   1.1        ad  */
     28   1.1        ad 
     29   1.1        ad /*
     30   1.1        ad  * Copyright (c) 1982, 1986, 1989, 1991, 1993
     31   1.1        ad  *	The Regents of the University of California.  All rights reserved.
     32   1.1        ad  * (c) UNIX System Laboratories, Inc.
     33   1.1        ad  * All or some portions of this file are derived from material licensed
     34   1.1        ad  * to the University of California by American Telephone and Telegraph
     35   1.1        ad  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
     36   1.1        ad  * the permission of UNIX System Laboratories, Inc.
     37   1.1        ad  *
     38   1.1        ad  * Redistribution and use in source and binary forms, with or without
     39   1.1        ad  * modification, are permitted provided that the following conditions
     40   1.1        ad  * are met:
     41   1.1        ad  * 1. Redistributions of source code must retain the above copyright
     42   1.1        ad  *    notice, this list of conditions and the following disclaimer.
     43   1.1        ad  * 2. Redistributions in binary form must reproduce the above copyright
     44   1.1        ad  *    notice, this list of conditions and the following disclaimer in the
     45   1.1        ad  *    documentation and/or other materials provided with the distribution.
     46   1.1        ad  * 3. Neither the name of the University nor the names of its contributors
     47   1.1        ad  *    may be used to endorse or promote products derived from this software
     48   1.1        ad  *    without specific prior written permission.
     49   1.1        ad  *
     50   1.1        ad  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     51   1.1        ad  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     52   1.1        ad  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     53   1.1        ad  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     54   1.1        ad  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     55   1.1        ad  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     56   1.1        ad  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     57   1.1        ad  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     58   1.1        ad  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     59   1.1        ad  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     60   1.1        ad  * SUCH DAMAGE.
     61   1.1        ad  *
     62   1.1        ad  *	@(#)kern_descrip.c	8.8 (Berkeley) 2/14/95
     63   1.1        ad  */
     64   1.1        ad 
     65   1.1        ad /*
     66   1.1        ad  * System calls on descriptors.
     67   1.1        ad  */
     68   1.1        ad 
     69   1.1        ad #include <sys/cdefs.h>
     70  1.36  riastrad __KERNEL_RCSID(0, "$NetBSD: sys_descrip.c,v 1.36 2020/02/01 02:23:04 riastradh Exp $");
     71   1.1        ad 
     72   1.1        ad #include <sys/param.h>
     73   1.1        ad #include <sys/systm.h>
     74   1.1        ad #include <sys/filedesc.h>
     75   1.1        ad #include <sys/kernel.h>
     76   1.1        ad #include <sys/vnode.h>
     77   1.1        ad #include <sys/proc.h>
     78   1.1        ad #include <sys/file.h>
     79   1.1        ad #include <sys/namei.h>
     80   1.1        ad #include <sys/socket.h>
     81   1.1        ad #include <sys/socketvar.h>
     82   1.1        ad #include <sys/stat.h>
     83   1.1        ad #include <sys/ioctl.h>
     84   1.1        ad #include <sys/fcntl.h>
     85  1.10      yamt #include <sys/kmem.h>
     86   1.1        ad #include <sys/pool.h>
     87   1.1        ad #include <sys/syslog.h>
     88   1.1        ad #include <sys/unistd.h>
     89   1.1        ad #include <sys/resourcevar.h>
     90   1.1        ad #include <sys/conf.h>
     91   1.1        ad #include <sys/event.h>
     92   1.1        ad #include <sys/kauth.h>
     93   1.1        ad #include <sys/atomic.h>
     94   1.1        ad #include <sys/mount.h>
     95   1.1        ad #include <sys/syscallargs.h>
     96   1.1        ad 
     97  1.15      yamt #include <uvm/uvm_readahead.h>
     98  1.15      yamt 
     99   1.1        ad /*
    100   1.1        ad  * Duplicate a file descriptor.
    101   1.1        ad  */
    102   1.1        ad int
    103   1.1        ad sys_dup(struct lwp *l, const struct sys_dup_args *uap, register_t *retval)
    104   1.1        ad {
    105   1.1        ad 	/* {
    106   1.1        ad 		syscallarg(int)	fd;
    107   1.1        ad 	} */
    108  1.29      matt 	int error, newfd, oldfd;
    109   1.1        ad 	file_t *fp;
    110   1.1        ad 
    111  1.29      matt 	oldfd = SCARG(uap, fd);
    112   1.1        ad 
    113  1.29      matt 	if ((fp = fd_getfile(oldfd)) == NULL) {
    114   1.1        ad 		return EBADF;
    115   1.1        ad 	}
    116  1.29      matt 	error = fd_dup(fp, 0, &newfd, false);
    117  1.29      matt 	fd_putfile(oldfd);
    118  1.29      matt 	*retval = newfd;
    119   1.1        ad 	return error;
    120   1.1        ad }
    121   1.1        ad 
    122   1.1        ad /*
    123   1.1        ad  * Duplicate a file descriptor to a particular value.
    124   1.1        ad  */
    125  1.26    martin int
    126  1.22  christos dodup(struct lwp *l, int from, int to, int flags, register_t *retval)
    127   1.1        ad {
    128  1.22  christos 	int error;
    129   1.1        ad 	file_t *fp;
    130   1.1        ad 
    131  1.22  christos 	if ((fp = fd_getfile(from)) == NULL)
    132   1.1        ad 		return EBADF;
    133   1.8        ad 	mutex_enter(&fp->f_lock);
    134   1.8        ad 	fp->f_count++;
    135   1.8        ad 	mutex_exit(&fp->f_lock);
    136  1.22  christos 	fd_putfile(from);
    137   1.8        ad 
    138  1.22  christos 	if ((u_int)to >= curproc->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
    139  1.22  christos 	    (u_int)to >= maxfiles)
    140   1.1        ad 		error = EBADF;
    141  1.22  christos 	else if (from == to)
    142   1.1        ad 		error = 0;
    143  1.22  christos 	else
    144  1.22  christos 		error = fd_dup2(fp, to, flags);
    145   1.8        ad 	closef(fp);
    146  1.22  christos 	*retval = to;
    147   1.1        ad 
    148   1.6     njoly 	return error;
    149   1.1        ad }
    150   1.1        ad 
    151  1.22  christos int
    152  1.22  christos sys_dup3(struct lwp *l, const struct sys_dup3_args *uap, register_t *retval)
    153  1.22  christos {
    154  1.22  christos 	/* {
    155  1.22  christos 		syscallarg(int)	from;
    156  1.22  christos 		syscallarg(int)	to;
    157  1.22  christos 		syscallarg(int)	flags;
    158  1.22  christos 	} */
    159  1.22  christos 	return dodup(l, SCARG(uap, from), SCARG(uap, to), SCARG(uap, flags),
    160  1.22  christos 	    retval);
    161  1.22  christos }
    162  1.22  christos 
    163  1.22  christos int
    164  1.22  christos sys_dup2(struct lwp *l, const struct sys_dup2_args *uap, register_t *retval)
    165  1.22  christos {
    166  1.22  christos 	/* {
    167  1.22  christos 		syscallarg(int)	from;
    168  1.22  christos 		syscallarg(int)	to;
    169  1.22  christos 	} */
    170  1.22  christos 	return dodup(l, SCARG(uap, from), SCARG(uap, to), 0, retval);
    171  1.22  christos }
    172  1.22  christos 
    173   1.1        ad /*
    174   1.1        ad  * fcntl call which is being passed to the file's fs.
    175   1.1        ad  */
    176   1.1        ad static int
    177   1.1        ad fcntl_forfs(int fd, file_t *fp, int cmd, void *arg)
    178   1.1        ad {
    179   1.1        ad 	int		error;
    180   1.1        ad 	u_int		size;
    181   1.1        ad 	void		*data, *memp;
    182   1.1        ad #define STK_PARAMS	128
    183   1.1        ad 	char		stkbuf[STK_PARAMS];
    184   1.1        ad 
    185   1.1        ad 	if ((fp->f_flag & (FREAD | FWRITE)) == 0)
    186   1.1        ad 		return (EBADF);
    187   1.1        ad 
    188   1.1        ad 	/*
    189   1.1        ad 	 * Interpret high order word to find amount of data to be
    190   1.1        ad 	 * copied to/from the user's address space.
    191   1.1        ad 	 */
    192   1.1        ad 	size = (size_t)F_PARAM_LEN(cmd);
    193   1.1        ad 	if (size > F_PARAM_MAX)
    194   1.1        ad 		return (EINVAL);
    195   1.1        ad 	memp = NULL;
    196   1.1        ad 	if (size > sizeof(stkbuf)) {
    197   1.1        ad 		memp = kmem_alloc(size, KM_SLEEP);
    198   1.1        ad 		data = memp;
    199   1.1        ad 	} else
    200   1.1        ad 		data = stkbuf;
    201   1.1        ad 	if (cmd & F_FSIN) {
    202   1.1        ad 		if (size) {
    203   1.1        ad 			error = copyin(arg, data, size);
    204   1.1        ad 			if (error) {
    205   1.1        ad 				if (memp)
    206   1.1        ad 					kmem_free(memp, size);
    207   1.1        ad 				return (error);
    208   1.1        ad 			}
    209   1.1        ad 		} else
    210   1.1        ad 			*(void **)data = arg;
    211   1.1        ad 	} else if ((cmd & F_FSOUT) != 0 && size != 0) {
    212   1.1        ad 		/*
    213   1.1        ad 		 * Zero the buffer so the user always
    214   1.1        ad 		 * gets back something deterministic.
    215   1.1        ad 		 */
    216   1.1        ad 		memset(data, 0, size);
    217   1.1        ad 	} else if (cmd & F_FSVOID)
    218   1.1        ad 		*(void **)data = arg;
    219   1.1        ad 
    220   1.1        ad 
    221   1.1        ad 	error = (*fp->f_ops->fo_fcntl)(fp, cmd, data);
    222   1.1        ad 
    223   1.1        ad 	/*
    224   1.1        ad 	 * Copy any data to user, size was
    225   1.1        ad 	 * already set and checked above.
    226   1.1        ad 	 */
    227   1.1        ad 	if (error == 0 && (cmd & F_FSOUT) && size)
    228   1.1        ad 		error = copyout(data, arg, size);
    229   1.1        ad 	if (memp)
    230   1.1        ad 		kmem_free(memp, size);
    231   1.1        ad 	return (error);
    232   1.1        ad }
    233   1.1        ad 
    234   1.1        ad int
    235   1.1        ad do_fcntl_lock(int fd, int cmd, struct flock *fl)
    236   1.1        ad {
    237   1.1        ad 	file_t *fp;
    238   1.1        ad 	vnode_t *vp;
    239   1.1        ad 	proc_t *p;
    240   1.1        ad 	int error, flg;
    241   1.1        ad 
    242  1.35  christos 	if ((error = fd_getvnode(fd, &fp)) != 0)
    243  1.35  christos 		return error;
    244  1.35  christos 
    245  1.30      matt 	vp = fp->f_vnode;
    246   1.1        ad 	if (fl->l_whence == SEEK_CUR)
    247   1.1        ad 		fl->l_start += fp->f_offset;
    248   1.1        ad 
    249   1.1        ad 	flg = F_POSIX;
    250   1.1        ad 	p = curproc;
    251   1.1        ad 
    252   1.1        ad 	switch (cmd) {
    253   1.1        ad 	case F_SETLKW:
    254   1.1        ad 		flg |= F_WAIT;
    255   1.1        ad 		/* Fall into F_SETLK */
    256   1.1        ad 
    257  1.32       mrg 		/* FALLTHROUGH */
    258   1.1        ad 	case F_SETLK:
    259   1.1        ad 		switch (fl->l_type) {
    260   1.1        ad 		case F_RDLCK:
    261   1.1        ad 			if ((fp->f_flag & FREAD) == 0) {
    262   1.1        ad 				error = EBADF;
    263   1.1        ad 				break;
    264   1.1        ad 			}
    265   1.1        ad 			if ((p->p_flag & PK_ADVLOCK) == 0) {
    266   1.2        ad 				mutex_enter(p->p_lock);
    267   1.1        ad 				p->p_flag |= PK_ADVLOCK;
    268   1.2        ad 				mutex_exit(p->p_lock);
    269   1.1        ad 			}
    270   1.1        ad 			error = VOP_ADVLOCK(vp, p, F_SETLK, fl, flg);
    271   1.1        ad 			break;
    272   1.1        ad 
    273   1.1        ad 		case F_WRLCK:
    274   1.1        ad 			if ((fp->f_flag & FWRITE) == 0) {
    275   1.1        ad 				error = EBADF;
    276   1.1        ad 				break;
    277   1.1        ad 			}
    278   1.1        ad 			if ((p->p_flag & PK_ADVLOCK) == 0) {
    279   1.2        ad 				mutex_enter(p->p_lock);
    280   1.1        ad 				p->p_flag |= PK_ADVLOCK;
    281   1.2        ad 				mutex_exit(p->p_lock);
    282   1.1        ad 			}
    283   1.1        ad 			error = VOP_ADVLOCK(vp, p, F_SETLK, fl, flg);
    284   1.1        ad 			break;
    285   1.1        ad 
    286   1.1        ad 		case F_UNLCK:
    287   1.1        ad 			error = VOP_ADVLOCK(vp, p, F_UNLCK, fl, F_POSIX);
    288   1.1        ad 			break;
    289   1.1        ad 
    290   1.1        ad 		default:
    291   1.1        ad 			error = EINVAL;
    292   1.1        ad 			break;
    293   1.1        ad 		}
    294   1.1        ad 		break;
    295   1.1        ad 
    296   1.1        ad 	case F_GETLK:
    297   1.1        ad 		if (fl->l_type != F_RDLCK &&
    298   1.1        ad 		    fl->l_type != F_WRLCK &&
    299   1.1        ad 		    fl->l_type != F_UNLCK) {
    300   1.1        ad 			error = EINVAL;
    301   1.1        ad 			break;
    302   1.1        ad 		}
    303   1.1        ad 		error = VOP_ADVLOCK(vp, p, F_GETLK, fl, F_POSIX);
    304   1.1        ad 		break;
    305   1.1        ad 
    306   1.1        ad 	default:
    307   1.1        ad 		error = EINVAL;
    308   1.1        ad 		break;
    309   1.1        ad 	}
    310   1.1        ad 
    311   1.1        ad 	fd_putfile(fd);
    312   1.1        ad 	return error;
    313   1.1        ad }
    314   1.1        ad 
    315  1.35  christos static int
    316  1.35  christos do_fcntl_getpath(struct lwp *l, file_t *fp, char *upath)
    317  1.35  christos {
    318  1.35  christos 	char *kpath;
    319  1.35  christos 	int error;
    320  1.35  christos 
    321  1.35  christos 	if (fp->f_type != DTYPE_VNODE)
    322  1.35  christos 		return EOPNOTSUPP;
    323  1.35  christos 
    324  1.35  christos 	kpath = PNBUF_GET();
    325  1.35  christos 
    326  1.35  christos 	error = vnode_to_path(kpath, MAXPATHLEN, fp->f_vnode, l, l->l_proc);
    327  1.35  christos 	if (!error)
    328  1.35  christos 		error = copyoutstr(kpath, upath, MAXPATHLEN, NULL);
    329  1.35  christos 
    330  1.35  christos 	PNBUF_PUT(kpath);
    331  1.35  christos 
    332  1.35  christos 	return error;
    333  1.35  christos }
    334  1.35  christos 
    335   1.1        ad /*
    336   1.1        ad  * The file control system call.
    337   1.1        ad  */
    338   1.1        ad int
    339   1.1        ad sys_fcntl(struct lwp *l, const struct sys_fcntl_args *uap, register_t *retval)
    340   1.1        ad {
    341   1.1        ad 	/* {
    342   1.1        ad 		syscallarg(int)		fd;
    343   1.1        ad 		syscallarg(int)		cmd;
    344   1.1        ad 		syscallarg(void *)	arg;
    345   1.1        ad 	} */
    346   1.1        ad 	int fd, i, tmp, error, cmd, newmin;
    347   1.1        ad 	filedesc_t *fdp;
    348  1.36  riastrad 	fdtab_t *dt;
    349   1.1        ad 	file_t *fp;
    350   1.1        ad 	struct flock fl;
    351  1.22  christos 	bool cloexec = false;
    352   1.1        ad 
    353   1.1        ad 	fd = SCARG(uap, fd);
    354   1.1        ad 	cmd = SCARG(uap, cmd);
    355   1.4        ad 	fdp = l->l_fd;
    356   1.1        ad 	error = 0;
    357   1.1        ad 
    358   1.1        ad 	switch (cmd) {
    359   1.1        ad 	case F_CLOSEM:
    360   1.1        ad 		if (fd < 0)
    361   1.1        ad 			return EBADF;
    362   1.1        ad 		while ((i = fdp->fd_lastfile) >= fd) {
    363   1.1        ad 			if (fd_getfile(i) == NULL) {
    364   1.1        ad 				/* Another thread has updated. */
    365   1.1        ad 				continue;
    366   1.1        ad 			}
    367   1.1        ad 			fd_close(i);
    368   1.1        ad 		}
    369   1.1        ad 		return 0;
    370   1.1        ad 
    371   1.1        ad 	case F_MAXFD:
    372   1.1        ad 		*retval = fdp->fd_lastfile;
    373   1.1        ad 		return 0;
    374   1.1        ad 
    375   1.1        ad 	case F_SETLKW:
    376   1.1        ad 	case F_SETLK:
    377   1.1        ad 	case F_GETLK:
    378   1.1        ad 		error = copyin(SCARG(uap, arg), &fl, sizeof(fl));
    379   1.1        ad 		if (error)
    380   1.1        ad 			return error;
    381   1.1        ad 		error = do_fcntl_lock(fd, cmd, &fl);
    382   1.1        ad 		if (cmd == F_GETLK && error == 0)
    383   1.1        ad 			error = copyout(&fl, SCARG(uap, arg), sizeof(fl));
    384   1.1        ad 		return error;
    385   1.1        ad 
    386   1.1        ad 	default:
    387   1.1        ad 		/* Handled below */
    388   1.1        ad 		break;
    389   1.1        ad 	}
    390   1.1        ad 
    391   1.1        ad 	if ((fp = fd_getfile(fd)) == NULL)
    392  1.35  christos 		return EBADF;
    393   1.1        ad 
    394   1.1        ad 	if ((cmd & F_FSCTL)) {
    395   1.1        ad 		error = fcntl_forfs(fd, fp, cmd, SCARG(uap, arg));
    396   1.1        ad 		fd_putfile(fd);
    397   1.1        ad 		return error;
    398   1.1        ad 	}
    399   1.1        ad 
    400   1.1        ad 	switch (cmd) {
    401  1.22  christos 	case F_DUPFD_CLOEXEC:
    402  1.22  christos 		cloexec = true;
    403  1.22  christos 		/*FALLTHROUGH*/
    404   1.1        ad 	case F_DUPFD:
    405   1.1        ad 		newmin = (long)SCARG(uap, arg);
    406   1.4        ad 		if ((u_int)newmin >=
    407   1.4        ad 		    l->l_proc->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
    408   1.1        ad 		    (u_int)newmin >= maxfiles) {
    409   1.1        ad 			fd_putfile(fd);
    410   1.1        ad 			return EINVAL;
    411   1.1        ad 		}
    412  1.22  christos 		error = fd_dup(fp, newmin, &i, cloexec);
    413   1.1        ad 		*retval = i;
    414   1.1        ad 		break;
    415   1.1        ad 
    416   1.1        ad 	case F_GETFD:
    417  1.36  riastrad 		dt = atomic_load_consume(&fdp->fd_dt);
    418  1.36  riastrad 		*retval = dt->dt_ff[fd]->ff_exclose;
    419   1.1        ad 		break;
    420   1.1        ad 
    421   1.1        ad 	case F_SETFD:
    422  1.20  christos 		fd_set_exclose(l, fd,
    423  1.20  christos 		    ((long)SCARG(uap, arg) & FD_CLOEXEC) != 0);
    424   1.1        ad 		break;
    425   1.1        ad 
    426  1.24  christos 	case F_GETNOSIGPIPE:
    427  1.24  christos 		*retval = (fp->f_flag & FNOSIGPIPE) != 0;
    428  1.24  christos 		break;
    429  1.24  christos 
    430  1.24  christos 	case F_SETNOSIGPIPE:
    431  1.24  christos 		if (SCARG(uap, arg))
    432  1.25  christos 			atomic_or_uint(&fp->f_flag, FNOSIGPIPE);
    433  1.24  christos 		else
    434  1.25  christos 			atomic_and_uint(&fp->f_flag, ~FNOSIGPIPE);
    435  1.24  christos 		*retval = 0;
    436  1.24  christos 		break;
    437  1.24  christos 
    438   1.1        ad 	case F_GETFL:
    439   1.1        ad 		*retval = OFLAGS(fp->f_flag);
    440   1.1        ad 		break;
    441   1.1        ad 
    442   1.1        ad 	case F_SETFL:
    443   1.1        ad 		/* XXX not guaranteed to be atomic. */
    444   1.1        ad 		tmp = FFLAGS((long)SCARG(uap, arg)) & FCNTLFLAGS;
    445   1.1        ad 		error = (*fp->f_ops->fo_fcntl)(fp, F_SETFL, &tmp);
    446   1.1        ad 		if (error)
    447   1.1        ad 			break;
    448   1.1        ad 		i = tmp ^ fp->f_flag;
    449   1.1        ad 		if (i & FNONBLOCK) {
    450   1.1        ad 			int flgs = tmp & FNONBLOCK;
    451   1.1        ad 			error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, &flgs);
    452   1.1        ad 			if (error) {
    453   1.1        ad 				(*fp->f_ops->fo_fcntl)(fp, F_SETFL,
    454   1.1        ad 				    &fp->f_flag);
    455   1.1        ad 				break;
    456   1.1        ad 			}
    457   1.1        ad 		}
    458   1.1        ad 		if (i & FASYNC) {
    459   1.1        ad 			int flgs = tmp & FASYNC;
    460   1.1        ad 			error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, &flgs);
    461   1.1        ad 			if (error) {
    462   1.1        ad 				if (i & FNONBLOCK) {
    463   1.1        ad 					tmp = fp->f_flag & FNONBLOCK;
    464   1.1        ad 					(void)(*fp->f_ops->fo_ioctl)(fp,
    465   1.1        ad 						FIONBIO, &tmp);
    466   1.1        ad 				}
    467   1.1        ad 				(*fp->f_ops->fo_fcntl)(fp, F_SETFL,
    468   1.1        ad 				    &fp->f_flag);
    469   1.1        ad 				break;
    470   1.1        ad 			}
    471   1.1        ad 		}
    472   1.1        ad 		fp->f_flag = (fp->f_flag & ~FCNTLFLAGS) | tmp;
    473   1.1        ad 		break;
    474   1.1        ad 
    475   1.1        ad 	case F_GETOWN:
    476   1.1        ad 		error = (*fp->f_ops->fo_ioctl)(fp, FIOGETOWN, &tmp);
    477   1.1        ad 		*retval = tmp;
    478   1.1        ad 		break;
    479   1.1        ad 
    480   1.1        ad 	case F_SETOWN:
    481   1.7     rmind 		tmp = (int)(uintptr_t) SCARG(uap, arg);
    482   1.1        ad 		error = (*fp->f_ops->fo_ioctl)(fp, FIOSETOWN, &tmp);
    483   1.1        ad 		break;
    484   1.1        ad 
    485  1.35  christos 	case F_GETPATH:
    486  1.35  christos 		error = do_fcntl_getpath(l, fp, SCARG(uap, arg));
    487  1.35  christos 		break;
    488  1.35  christos 
    489   1.1        ad 	default:
    490   1.1        ad 		error = EINVAL;
    491   1.1        ad 	}
    492   1.1        ad 
    493   1.1        ad 	fd_putfile(fd);
    494   1.1        ad 	return (error);
    495   1.1        ad }
    496   1.1        ad 
    497   1.1        ad /*
    498   1.1        ad  * Close a file descriptor.
    499   1.1        ad  */
    500   1.1        ad int
    501   1.1        ad sys_close(struct lwp *l, const struct sys_close_args *uap, register_t *retval)
    502   1.1        ad {
    503   1.1        ad 	/* {
    504   1.1        ad 		syscallarg(int)	fd;
    505   1.1        ad 	} */
    506  1.27  riastrad 	int error;
    507  1.33  christos 	int fd = SCARG(uap, fd);
    508   1.1        ad 
    509  1.33  christos 	if (fd_getfile(fd) == NULL) {
    510   1.1        ad 		return EBADF;
    511   1.1        ad 	}
    512  1.27  riastrad 
    513  1.33  christos 	error = fd_close(fd);
    514  1.27  riastrad 	if (error == ERESTART) {
    515  1.27  riastrad #ifdef DIAGNOSTIC
    516  1.33  christos 		printf("%s[%d]: close(%d) returned ERESTART\n",
    517  1.33  christos 		    l->l_proc->p_comm, (int)l->l_proc->p_pid, fd);
    518  1.27  riastrad #endif
    519  1.27  riastrad 		error = EINTR;
    520  1.27  riastrad 	}
    521  1.27  riastrad 
    522  1.27  riastrad 	return error;
    523   1.1        ad }
    524   1.1        ad 
    525   1.1        ad /*
    526   1.1        ad  * Return status information about a file descriptor.
    527   1.1        ad  * Common function for compat code.
    528   1.1        ad  */
    529   1.1        ad int
    530   1.1        ad do_sys_fstat(int fd, struct stat *sb)
    531   1.1        ad {
    532   1.1        ad 	file_t *fp;
    533   1.1        ad 	int error;
    534   1.1        ad 
    535   1.1        ad 	if ((fp = fd_getfile(fd)) == NULL) {
    536   1.1        ad 		return EBADF;
    537   1.1        ad 	}
    538   1.1        ad 	error = (*fp->f_ops->fo_stat)(fp, sb);
    539   1.1        ad 	fd_putfile(fd);
    540   1.1        ad 
    541   1.1        ad 	return error;
    542   1.1        ad }
    543   1.1        ad 
    544   1.1        ad /*
    545   1.1        ad  * Return status information about a file descriptor.
    546   1.1        ad  */
    547   1.1        ad int
    548   1.9  christos sys___fstat50(struct lwp *l, const struct sys___fstat50_args *uap,
    549   1.1        ad 	      register_t *retval)
    550   1.1        ad {
    551   1.1        ad 	/* {
    552   1.1        ad 		syscallarg(int)			fd;
    553   1.1        ad 		syscallarg(struct stat *)	sb;
    554   1.1        ad 	} */
    555   1.1        ad 	struct stat sb;
    556   1.1        ad 	int error;
    557   1.1        ad 
    558   1.1        ad 	error = do_sys_fstat(SCARG(uap, fd), &sb);
    559   1.1        ad 	if (error == 0) {
    560   1.1        ad 		error = copyout(&sb, SCARG(uap, sb), sizeof(sb));
    561   1.1        ad 	}
    562   1.1        ad 	return error;
    563   1.1        ad }
    564   1.1        ad 
    565   1.1        ad /*
    566   1.1        ad  * Return pathconf information about a file descriptor.
    567   1.1        ad  */
    568   1.1        ad int
    569   1.1        ad sys_fpathconf(struct lwp *l, const struct sys_fpathconf_args *uap,
    570   1.1        ad 	      register_t *retval)
    571   1.1        ad {
    572   1.1        ad 	/* {
    573   1.1        ad 		syscallarg(int)	fd;
    574   1.1        ad 		syscallarg(int)	name;
    575   1.1        ad 	} */
    576   1.1        ad 	int fd, error;
    577   1.1        ad 	file_t *fp;
    578   1.1        ad 
    579   1.1        ad 	fd = SCARG(uap, fd);
    580   1.1        ad 	error = 0;
    581   1.1        ad 
    582   1.1        ad 	if ((fp = fd_getfile(fd)) == NULL) {
    583   1.1        ad 		return (EBADF);
    584   1.1        ad 	}
    585   1.1        ad 	switch (fp->f_type) {
    586   1.1        ad 	case DTYPE_SOCKET:
    587   1.1        ad 	case DTYPE_PIPE:
    588   1.1        ad 		if (SCARG(uap, name) != _PC_PIPE_BUF)
    589   1.1        ad 			error = EINVAL;
    590   1.1        ad 		else
    591   1.1        ad 			*retval = PIPE_BUF;
    592   1.1        ad 		break;
    593   1.1        ad 
    594   1.1        ad 	case DTYPE_VNODE:
    595  1.30      matt 		error = VOP_PATHCONF(fp->f_vnode, SCARG(uap, name), retval);
    596   1.1        ad 		break;
    597   1.1        ad 
    598   1.1        ad 	case DTYPE_KQUEUE:
    599   1.1        ad 		error = EINVAL;
    600   1.1        ad 		break;
    601   1.1        ad 
    602   1.1        ad 	default:
    603   1.1        ad 		error = EOPNOTSUPP;
    604   1.1        ad 		break;
    605   1.1        ad 	}
    606   1.1        ad 
    607   1.1        ad 	fd_putfile(fd);
    608   1.1        ad 	return (error);
    609   1.1        ad }
    610   1.1        ad 
    611   1.1        ad /*
    612   1.1        ad  * Apply an advisory lock on a file descriptor.
    613   1.1        ad  *
    614   1.1        ad  * Just attempt to get a record lock of the requested type on
    615   1.1        ad  * the entire file (l_whence = SEEK_SET, l_start = 0, l_len = 0).
    616   1.1        ad  */
    617   1.1        ad /* ARGSUSED */
    618   1.1        ad int
    619   1.1        ad sys_flock(struct lwp *l, const struct sys_flock_args *uap, register_t *retval)
    620   1.1        ad {
    621   1.1        ad 	/* {
    622   1.1        ad 		syscallarg(int)	fd;
    623   1.1        ad 		syscallarg(int)	how;
    624   1.1        ad 	} */
    625   1.1        ad 	int fd, how, error;
    626   1.1        ad 	file_t *fp;
    627   1.1        ad 	vnode_t	*vp;
    628   1.1        ad 	struct flock lf;
    629   1.1        ad 
    630   1.1        ad 	fd = SCARG(uap, fd);
    631   1.1        ad 	how = SCARG(uap, how);
    632   1.1        ad 
    633  1.35  christos 	if ((error = fd_getvnode(fd, &fp)) != 0)
    634  1.35  christos 		return error == EINVAL ? EOPNOTSUPP : error;
    635   1.1        ad 
    636  1.30      matt 	vp = fp->f_vnode;
    637   1.1        ad 	lf.l_whence = SEEK_SET;
    638   1.1        ad 	lf.l_start = 0;
    639   1.1        ad 	lf.l_len = 0;
    640  1.17     njoly 
    641  1.17     njoly 	switch (how & ~LOCK_NB) {
    642  1.17     njoly 	case LOCK_UN:
    643   1.1        ad 		lf.l_type = F_UNLCK;
    644   1.1        ad 		atomic_and_uint(&fp->f_flag, ~FHASLOCK);
    645   1.1        ad 		error = VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK);
    646   1.1        ad 		fd_putfile(fd);
    647   1.1        ad 		return error;
    648  1.17     njoly 	case LOCK_EX:
    649   1.1        ad 		lf.l_type = F_WRLCK;
    650  1.17     njoly 		break;
    651  1.17     njoly 	case LOCK_SH:
    652   1.1        ad 		lf.l_type = F_RDLCK;
    653  1.17     njoly 		break;
    654  1.17     njoly 	default:
    655   1.1        ad 		fd_putfile(fd);
    656   1.1        ad 		return EINVAL;
    657   1.1        ad 	}
    658  1.17     njoly 
    659   1.1        ad 	atomic_or_uint(&fp->f_flag, FHASLOCK);
    660   1.1        ad 	if (how & LOCK_NB) {
    661   1.1        ad 		error = VOP_ADVLOCK(vp, fp, F_SETLK, &lf, F_FLOCK);
    662   1.1        ad 	} else {
    663   1.1        ad 		error = VOP_ADVLOCK(vp, fp, F_SETLK, &lf, F_FLOCK|F_WAIT);
    664   1.1        ad 	}
    665   1.1        ad 	fd_putfile(fd);
    666   1.1        ad 	return error;
    667   1.1        ad }
    668   1.1        ad 
    669   1.1        ad int
    670   1.1        ad do_posix_fadvise(int fd, off_t offset, off_t len, int advice)
    671   1.1        ad {
    672   1.1        ad 	file_t *fp;
    673  1.15      yamt 	vnode_t *vp;
    674  1.16      yamt 	off_t endoffset;
    675   1.1        ad 	int error;
    676  1.18     rmind 
    677  1.14      yamt 	CTASSERT(POSIX_FADV_NORMAL == UVM_ADV_NORMAL);
    678  1.14      yamt 	CTASSERT(POSIX_FADV_RANDOM == UVM_ADV_RANDOM);
    679  1.14      yamt 	CTASSERT(POSIX_FADV_SEQUENTIAL == UVM_ADV_SEQUENTIAL);
    680   1.1        ad 
    681  1.34      maxv 	if (offset < 0) {
    682  1.34      maxv 		return EINVAL;
    683  1.34      maxv 	}
    684  1.16      yamt 	if (len == 0) {
    685  1.16      yamt 		endoffset = INT64_MAX;
    686  1.18     rmind 	} else if (len > 0 && (INT64_MAX - offset) >= len) {
    687  1.16      yamt 		endoffset = offset + len;
    688  1.16      yamt 	} else {
    689  1.16      yamt 		return EINVAL;
    690  1.16      yamt 	}
    691   1.1        ad 	if ((fp = fd_getfile(fd)) == NULL) {
    692   1.1        ad 		return EBADF;
    693   1.1        ad 	}
    694   1.1        ad 	if (fp->f_type != DTYPE_VNODE) {
    695   1.1        ad 		if (fp->f_type == DTYPE_PIPE || fp->f_type == DTYPE_SOCKET) {
    696   1.1        ad 			error = ESPIPE;
    697   1.1        ad 		} else {
    698   1.1        ad 			error = EOPNOTSUPP;
    699   1.1        ad 		}
    700   1.1        ad 		fd_putfile(fd);
    701   1.1        ad 		return error;
    702   1.1        ad 	}
    703   1.1        ad 
    704   1.1        ad 	switch (advice) {
    705  1.16      yamt 	case POSIX_FADV_WILLNEED:
    706  1.16      yamt 	case POSIX_FADV_DONTNEED:
    707  1.30      matt 		vp = fp->f_vnode;
    708  1.16      yamt 		if (vp->v_type != VREG && vp->v_type != VBLK) {
    709  1.16      yamt 			fd_putfile(fd);
    710  1.16      yamt 			return 0;
    711  1.16      yamt 		}
    712  1.16      yamt 		break;
    713  1.16      yamt 	}
    714  1.16      yamt 
    715  1.16      yamt 	switch (advice) {
    716   1.1        ad 	case POSIX_FADV_NORMAL:
    717   1.1        ad 	case POSIX_FADV_RANDOM:
    718   1.1        ad 	case POSIX_FADV_SEQUENTIAL:
    719   1.1        ad 		/*
    720  1.19     rmind 		 * We ignore offset and size.  Must lock the file to
    721   1.1        ad 		 * do this, as f_advice is sub-word sized.
    722   1.1        ad 		 */
    723   1.1        ad 		mutex_enter(&fp->f_lock);
    724   1.1        ad 		fp->f_advice = (u_char)advice;
    725   1.1        ad 		mutex_exit(&fp->f_lock);
    726   1.1        ad 		error = 0;
    727   1.1        ad 		break;
    728   1.1        ad 
    729   1.1        ad 	case POSIX_FADV_WILLNEED:
    730  1.30      matt 		vp = fp->f_vnode;
    731  1.16      yamt 		error = uvm_readahead(&vp->v_uobj, offset, endoffset - offset);
    732  1.15      yamt 		break;
    733  1.15      yamt 
    734   1.1        ad 	case POSIX_FADV_DONTNEED:
    735  1.30      matt 		vp = fp->f_vnode;
    736  1.19     rmind 		/*
    737  1.19     rmind 		 * Align the region to page boundaries as VOP_PUTPAGES expects
    738  1.19     rmind 		 * by shrinking it.  We shrink instead of expand because we
    739  1.19     rmind 		 * do not want to deactivate cache outside of the requested
    740  1.19     rmind 		 * region.  It means that if the specified region is smaller
    741  1.19     rmind 		 * than PAGE_SIZE, we do nothing.
    742  1.19     rmind 		 */
    743  1.19     rmind 		if (round_page(offset) < trunc_page(endoffset) &&
    744  1.19     rmind 		    offset <= round_page(offset)) {
    745  1.21     rmind 			mutex_enter(vp->v_interlock);
    746  1.19     rmind 			error = VOP_PUTPAGES(vp,
    747  1.19     rmind 			    round_page(offset), trunc_page(endoffset),
    748  1.19     rmind 			    PGO_DEACTIVATE | PGO_CLEANIT);
    749  1.19     rmind 		} else {
    750  1.19     rmind 			error = 0;
    751  1.19     rmind 		}
    752  1.16      yamt 		break;
    753  1.16      yamt 
    754   1.1        ad 	case POSIX_FADV_NOREUSE:
    755   1.1        ad 		/* Not implemented yet. */
    756   1.1        ad 		error = 0;
    757   1.1        ad 		break;
    758   1.1        ad 	default:
    759   1.1        ad 		error = EINVAL;
    760   1.1        ad 		break;
    761   1.1        ad 	}
    762   1.1        ad 
    763   1.1        ad 	fd_putfile(fd);
    764   1.1        ad 	return error;
    765   1.1        ad }
    766   1.1        ad 
    767   1.1        ad int
    768   1.1        ad sys___posix_fadvise50(struct lwp *l,
    769   1.1        ad 		      const struct sys___posix_fadvise50_args *uap,
    770   1.1        ad 		      register_t *retval)
    771   1.1        ad {
    772   1.1        ad 	/* {
    773   1.1        ad 		syscallarg(int) fd;
    774   1.1        ad 		syscallarg(int) pad;
    775   1.1        ad 		syscallarg(off_t) offset;
    776   1.1        ad 		syscallarg(off_t) len;
    777   1.1        ad 		syscallarg(int) advice;
    778   1.1        ad 	} */
    779   1.1        ad 
    780  1.11     skrll 	*retval = do_posix_fadvise(SCARG(uap, fd), SCARG(uap, offset),
    781   1.1        ad 	    SCARG(uap, len), SCARG(uap, advice));
    782  1.11     skrll 
    783  1.11     skrll 	return 0;
    784   1.1        ad }
    785  1.22  christos 
    786  1.22  christos int
    787  1.22  christos sys_pipe(struct lwp *l, const void *v, register_t *retval)
    788  1.22  christos {
    789  1.31     kamil 	int fd[2], error;
    790  1.31     kamil 
    791  1.31     kamil 	if ((error = pipe1(l, fd, 0)) != 0)
    792  1.31     kamil 		return error;
    793  1.31     kamil 
    794  1.31     kamil 	retval[0] = fd[0];
    795  1.31     kamil 	retval[1] = fd[1];
    796  1.31     kamil 
    797  1.31     kamil 	return 0;
    798  1.22  christos }
    799  1.22  christos 
    800  1.22  christos int
    801  1.22  christos sys_pipe2(struct lwp *l, const struct sys_pipe2_args *uap, register_t *retval)
    802  1.22  christos {
    803  1.22  christos 	/* {
    804  1.22  christos 		syscallarg(int[2]) fildes;
    805  1.22  christos 		syscallarg(int) flags;
    806  1.22  christos 	} */
    807  1.22  christos 	int fd[2], error;
    808  1.22  christos 
    809  1.31     kamil 	if ((error = pipe1(l, fd, SCARG(uap, flags))) != 0)
    810  1.22  christos 		return error;
    811  1.31     kamil 
    812  1.23  christos 	if ((error = copyout(fd, SCARG(uap, fildes), sizeof(fd))) != 0)
    813  1.23  christos 		return error;
    814  1.23  christos 	retval[0] = 0;
    815  1.23  christos 	return 0;
    816  1.22  christos }
    817