xref: /freebsd/sys/kern/kern_descrip.c (revision fe75646a0234a261c0013bf1840fdac4acaf0cec)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1982, 1986, 1989, 1991, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  * (c) UNIX System Laboratories, Inc.
7  * All or some portions of this file are derived from material licensed
8  * to the University of California by American Telephone and Telegraph
9  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10  * the permission of UNIX System Laboratories, Inc.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  * 3. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  */
36 
37 #include <sys/cdefs.h>
38 #include "opt_capsicum.h"
39 #include "opt_ddb.h"
40 #include "opt_ktrace.h"
41 
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 
45 #include <sys/capsicum.h>
46 #include <sys/conf.h>
47 #include <sys/fcntl.h>
48 #include <sys/file.h>
49 #include <sys/filedesc.h>
50 #include <sys/filio.h>
51 #include <sys/jail.h>
52 #include <sys/kernel.h>
53 #include <sys/limits.h>
54 #include <sys/lock.h>
55 #include <sys/malloc.h>
56 #include <sys/mount.h>
57 #include <sys/mutex.h>
58 #include <sys/namei.h>
59 #include <sys/selinfo.h>
60 #include <sys/poll.h>
61 #include <sys/priv.h>
62 #include <sys/proc.h>
63 #include <sys/protosw.h>
64 #include <sys/racct.h>
65 #include <sys/resourcevar.h>
66 #include <sys/sbuf.h>
67 #include <sys/signalvar.h>
68 #include <sys/kdb.h>
69 #include <sys/smr.h>
70 #include <sys/stat.h>
71 #include <sys/sx.h>
72 #include <sys/syscallsubr.h>
73 #include <sys/sysctl.h>
74 #include <sys/sysproto.h>
75 #include <sys/unistd.h>
76 #include <sys/user.h>
77 #include <sys/vnode.h>
78 #include <sys/ktrace.h>
79 
80 #include <net/vnet.h>
81 
82 #include <security/audit/audit.h>
83 
84 #include <vm/uma.h>
85 #include <vm/vm.h>
86 
87 #include <ddb/ddb.h>
88 
89 static MALLOC_DEFINE(M_FILEDESC, "filedesc", "Open file descriptor table");
90 static MALLOC_DEFINE(M_PWD, "pwd", "Descriptor table vnodes");
91 static MALLOC_DEFINE(M_PWDDESC, "pwddesc", "Pwd descriptors");
92 static MALLOC_DEFINE(M_FILEDESC_TO_LEADER, "filedesc_to_leader",
93     "file desc to leader structures");
94 static MALLOC_DEFINE(M_SIGIO, "sigio", "sigio structures");
95 MALLOC_DEFINE(M_FILECAPS, "filecaps", "descriptor capabilities");
96 
97 MALLOC_DECLARE(M_FADVISE);
98 
99 static __read_mostly uma_zone_t file_zone;
100 static __read_mostly uma_zone_t filedesc0_zone;
101 __read_mostly uma_zone_t pwd_zone;
102 VFS_SMR_DECLARE;
103 
104 static int	closefp(struct filedesc *fdp, int fd, struct file *fp,
105 		    struct thread *td, bool holdleaders, bool audit);
106 static void	export_file_to_kinfo(struct file *fp, int fd,
107 		    cap_rights_t *rightsp, struct kinfo_file *kif,
108 		    struct filedesc *fdp, int flags);
109 static int	fd_first_free(struct filedesc *fdp, int low, int size);
110 static void	fdgrowtable(struct filedesc *fdp, int nfd);
111 static void	fdgrowtable_exp(struct filedesc *fdp, int nfd);
112 static void	fdunused(struct filedesc *fdp, int fd);
113 static void	fdused(struct filedesc *fdp, int fd);
114 static int	fget_unlocked_seq(struct thread *td, int fd,
115 		    cap_rights_t *needrightsp, struct file **fpp, seqc_t *seqp);
116 static int	getmaxfd(struct thread *td);
117 static u_long	*filecaps_copy_prep(const struct filecaps *src);
118 static void	filecaps_copy_finish(const struct filecaps *src,
119 		    struct filecaps *dst, u_long *ioctls);
120 static u_long 	*filecaps_free_prep(struct filecaps *fcaps);
121 static void	filecaps_free_finish(u_long *ioctls);
122 
123 static struct pwd *pwd_alloc(void);
124 
125 /*
126  * Each process has:
127  *
128  * - An array of open file descriptors (fd_ofiles)
129  * - An array of file flags (fd_ofileflags)
130  * - A bitmap recording which descriptors are in use (fd_map)
131  *
132  * A process starts out with NDFILE descriptors.  The value of NDFILE has
133  * been selected based the historical limit of 20 open files, and an
134  * assumption that the majority of processes, especially short-lived
135  * processes like shells, will never need more.
136  *
137  * If this initial allocation is exhausted, a larger descriptor table and
138  * map are allocated dynamically, and the pointers in the process's struct
139  * filedesc are updated to point to those.  This is repeated every time
140  * the process runs out of file descriptors (provided it hasn't hit its
141  * resource limit).
142  *
143  * Since threads may hold references to individual descriptor table
144  * entries, the tables are never freed.  Instead, they are placed on a
145  * linked list and freed only when the struct filedesc is released.
146  */
147 #define NDFILE		20
148 #define NDSLOTSIZE	sizeof(NDSLOTTYPE)
149 #define	NDENTRIES	(NDSLOTSIZE * __CHAR_BIT)
150 #define NDSLOT(x)	((x) / NDENTRIES)
151 #define NDBIT(x)	((NDSLOTTYPE)1 << ((x) % NDENTRIES))
152 #define	NDSLOTS(x)	(((x) + NDENTRIES - 1) / NDENTRIES)
153 
154 #define	FILEDESC_FOREACH_FDE(fdp, _iterator, _fde)				\
155 	struct filedesc *_fdp = (fdp);						\
156 	int _lastfile = fdlastfile_single(_fdp);				\
157 	for (_iterator = 0; _iterator <= _lastfile; _iterator++)		\
158 		if ((_fde = &_fdp->fd_ofiles[_iterator])->fde_file != NULL)
159 
160 #define	FILEDESC_FOREACH_FP(fdp, _iterator, _fp)				\
161 	struct filedesc *_fdp = (fdp);						\
162 	int _lastfile = fdlastfile_single(_fdp);				\
163 	for (_iterator = 0; _iterator <= _lastfile; _iterator++)		\
164 		if ((_fp = _fdp->fd_ofiles[_iterator].fde_file) != NULL)
165 
166 /*
167  * SLIST entry used to keep track of ofiles which must be reclaimed when
168  * the process exits.
169  */
170 struct freetable {
171 	struct fdescenttbl *ft_table;
172 	SLIST_ENTRY(freetable) ft_next;
173 };
174 
175 /*
176  * Initial allocation: a filedesc structure + the head of SLIST used to
177  * keep track of old ofiles + enough space for NDFILE descriptors.
178  */
179 
180 struct fdescenttbl0 {
181 	int	fdt_nfiles;
182 	struct	filedescent fdt_ofiles[NDFILE];
183 };
184 
185 struct filedesc0 {
186 	struct filedesc fd_fd;
187 	SLIST_HEAD(, freetable) fd_free;
188 	struct	fdescenttbl0 fd_dfiles;
189 	NDSLOTTYPE fd_dmap[NDSLOTS(NDFILE)];
190 };
191 
192 /*
193  * Descriptor management.
194  */
195 static int __exclusive_cache_line openfiles; /* actual number of open files */
196 struct mtx sigio_lock;		/* mtx to protect pointers to sigio */
197 void __read_mostly (*mq_fdclose)(struct thread *td, int fd, struct file *fp);
198 
199 /*
200  * If low >= size, just return low. Otherwise find the first zero bit in the
201  * given bitmap, starting at low and not exceeding size - 1. Return size if
202  * not found.
203  */
204 static int
205 fd_first_free(struct filedesc *fdp, int low, int size)
206 {
207 	NDSLOTTYPE *map = fdp->fd_map;
208 	NDSLOTTYPE mask;
209 	int off, maxoff;
210 
211 	if (low >= size)
212 		return (low);
213 
214 	off = NDSLOT(low);
215 	if (low % NDENTRIES) {
216 		mask = ~(~(NDSLOTTYPE)0 >> (NDENTRIES - (low % NDENTRIES)));
217 		if ((mask &= ~map[off]) != 0UL)
218 			return (off * NDENTRIES + ffsl(mask) - 1);
219 		++off;
220 	}
221 	for (maxoff = NDSLOTS(size); off < maxoff; ++off)
222 		if (map[off] != ~0UL)
223 			return (off * NDENTRIES + ffsl(~map[off]) - 1);
224 	return (size);
225 }
226 
227 /*
228  * Find the last used fd.
229  *
230  * Call this variant if fdp can't be modified by anyone else (e.g, during exec).
231  * Otherwise use fdlastfile.
232  */
233 int
234 fdlastfile_single(struct filedesc *fdp)
235 {
236 	NDSLOTTYPE *map = fdp->fd_map;
237 	int off, minoff;
238 
239 	off = NDSLOT(fdp->fd_nfiles - 1);
240 	for (minoff = NDSLOT(0); off >= minoff; --off)
241 		if (map[off] != 0)
242 			return (off * NDENTRIES + flsl(map[off]) - 1);
243 	return (-1);
244 }
245 
246 int
247 fdlastfile(struct filedesc *fdp)
248 {
249 
250 	FILEDESC_LOCK_ASSERT(fdp);
251 	return (fdlastfile_single(fdp));
252 }
253 
254 static int
255 fdisused(struct filedesc *fdp, int fd)
256 {
257 
258 	KASSERT(fd >= 0 && fd < fdp->fd_nfiles,
259 	    ("file descriptor %d out of range (0, %d)", fd, fdp->fd_nfiles));
260 
261 	return ((fdp->fd_map[NDSLOT(fd)] & NDBIT(fd)) != 0);
262 }
263 
264 /*
265  * Mark a file descriptor as used.
266  */
267 static void
268 fdused_init(struct filedesc *fdp, int fd)
269 {
270 
271 	KASSERT(!fdisused(fdp, fd), ("fd=%d is already used", fd));
272 
273 	fdp->fd_map[NDSLOT(fd)] |= NDBIT(fd);
274 }
275 
276 static void
277 fdused(struct filedesc *fdp, int fd)
278 {
279 
280 	FILEDESC_XLOCK_ASSERT(fdp);
281 
282 	fdused_init(fdp, fd);
283 	if (fd == fdp->fd_freefile)
284 		fdp->fd_freefile++;
285 }
286 
287 /*
288  * Mark a file descriptor as unused.
289  */
290 static void
291 fdunused(struct filedesc *fdp, int fd)
292 {
293 
294 	FILEDESC_XLOCK_ASSERT(fdp);
295 
296 	KASSERT(fdisused(fdp, fd), ("fd=%d is already unused", fd));
297 	KASSERT(fdp->fd_ofiles[fd].fde_file == NULL,
298 	    ("fd=%d is still in use", fd));
299 
300 	fdp->fd_map[NDSLOT(fd)] &= ~NDBIT(fd);
301 	if (fd < fdp->fd_freefile)
302 		fdp->fd_freefile = fd;
303 }
304 
305 /*
306  * Free a file descriptor.
307  *
308  * Avoid some work if fdp is about to be destroyed.
309  */
310 static inline void
311 fdefree_last(struct filedescent *fde)
312 {
313 
314 	filecaps_free(&fde->fde_caps);
315 }
316 
317 static inline void
318 fdfree(struct filedesc *fdp, int fd)
319 {
320 	struct filedescent *fde;
321 
322 	FILEDESC_XLOCK_ASSERT(fdp);
323 	fde = &fdp->fd_ofiles[fd];
324 #ifdef CAPABILITIES
325 	seqc_write_begin(&fde->fde_seqc);
326 #endif
327 	fde->fde_file = NULL;
328 #ifdef CAPABILITIES
329 	seqc_write_end(&fde->fde_seqc);
330 #endif
331 	fdefree_last(fde);
332 	fdunused(fdp, fd);
333 }
334 
335 /*
336  * System calls on descriptors.
337  */
338 #ifndef _SYS_SYSPROTO_H_
339 struct getdtablesize_args {
340 	int	dummy;
341 };
342 #endif
343 /* ARGSUSED */
344 int
345 sys_getdtablesize(struct thread *td, struct getdtablesize_args *uap)
346 {
347 #ifdef	RACCT
348 	uint64_t lim;
349 #endif
350 
351 	td->td_retval[0] = getmaxfd(td);
352 #ifdef	RACCT
353 	PROC_LOCK(td->td_proc);
354 	lim = racct_get_limit(td->td_proc, RACCT_NOFILE);
355 	PROC_UNLOCK(td->td_proc);
356 	if (lim < td->td_retval[0])
357 		td->td_retval[0] = lim;
358 #endif
359 	return (0);
360 }
361 
362 /*
363  * Duplicate a file descriptor to a particular value.
364  *
365  * Note: keep in mind that a potential race condition exists when closing
366  * descriptors from a shared descriptor table (via rfork).
367  */
368 #ifndef _SYS_SYSPROTO_H_
369 struct dup2_args {
370 	u_int	from;
371 	u_int	to;
372 };
373 #endif
374 /* ARGSUSED */
375 int
376 sys_dup2(struct thread *td, struct dup2_args *uap)
377 {
378 
379 	return (kern_dup(td, FDDUP_FIXED, 0, (int)uap->from, (int)uap->to));
380 }
381 
382 /*
383  * Duplicate a file descriptor.
384  */
385 #ifndef _SYS_SYSPROTO_H_
386 struct dup_args {
387 	u_int	fd;
388 };
389 #endif
390 /* ARGSUSED */
391 int
392 sys_dup(struct thread *td, struct dup_args *uap)
393 {
394 
395 	return (kern_dup(td, FDDUP_NORMAL, 0, (int)uap->fd, 0));
396 }
397 
398 /*
399  * The file control system call.
400  */
401 #ifndef _SYS_SYSPROTO_H_
402 struct fcntl_args {
403 	int	fd;
404 	int	cmd;
405 	long	arg;
406 };
407 #endif
408 /* ARGSUSED */
409 int
410 sys_fcntl(struct thread *td, struct fcntl_args *uap)
411 {
412 
413 	return (kern_fcntl_freebsd(td, uap->fd, uap->cmd, uap->arg));
414 }
415 
416 int
417 kern_fcntl_freebsd(struct thread *td, int fd, int cmd, long arg)
418 {
419 	struct flock fl;
420 	struct __oflock ofl;
421 	intptr_t arg1;
422 	int error, newcmd;
423 
424 	error = 0;
425 	newcmd = cmd;
426 	switch (cmd) {
427 	case F_OGETLK:
428 	case F_OSETLK:
429 	case F_OSETLKW:
430 		/*
431 		 * Convert old flock structure to new.
432 		 */
433 		error = copyin((void *)(intptr_t)arg, &ofl, sizeof(ofl));
434 		fl.l_start = ofl.l_start;
435 		fl.l_len = ofl.l_len;
436 		fl.l_pid = ofl.l_pid;
437 		fl.l_type = ofl.l_type;
438 		fl.l_whence = ofl.l_whence;
439 		fl.l_sysid = 0;
440 
441 		switch (cmd) {
442 		case F_OGETLK:
443 			newcmd = F_GETLK;
444 			break;
445 		case F_OSETLK:
446 			newcmd = F_SETLK;
447 			break;
448 		case F_OSETLKW:
449 			newcmd = F_SETLKW;
450 			break;
451 		}
452 		arg1 = (intptr_t)&fl;
453 		break;
454 	case F_GETLK:
455 	case F_SETLK:
456 	case F_SETLKW:
457 	case F_SETLK_REMOTE:
458 		error = copyin((void *)(intptr_t)arg, &fl, sizeof(fl));
459 		arg1 = (intptr_t)&fl;
460 		break;
461 	default:
462 		arg1 = arg;
463 		break;
464 	}
465 	if (error)
466 		return (error);
467 	error = kern_fcntl(td, fd, newcmd, arg1);
468 	if (error)
469 		return (error);
470 	if (cmd == F_OGETLK) {
471 		ofl.l_start = fl.l_start;
472 		ofl.l_len = fl.l_len;
473 		ofl.l_pid = fl.l_pid;
474 		ofl.l_type = fl.l_type;
475 		ofl.l_whence = fl.l_whence;
476 		error = copyout(&ofl, (void *)(intptr_t)arg, sizeof(ofl));
477 	} else if (cmd == F_GETLK) {
478 		error = copyout(&fl, (void *)(intptr_t)arg, sizeof(fl));
479 	}
480 	return (error);
481 }
482 
483 int
484 kern_fcntl(struct thread *td, int fd, int cmd, intptr_t arg)
485 {
486 	struct filedesc *fdp;
487 	struct flock *flp;
488 	struct file *fp, *fp2;
489 	struct filedescent *fde;
490 	struct proc *p;
491 	struct vnode *vp;
492 	struct mount *mp;
493 	struct kinfo_file *kif;
494 	int error, flg, kif_sz, seals, tmp, got_set, got_cleared;
495 	uint64_t bsize;
496 	off_t foffset;
497 
498 	error = 0;
499 	flg = F_POSIX;
500 	p = td->td_proc;
501 	fdp = p->p_fd;
502 
503 	AUDIT_ARG_FD(cmd);
504 	AUDIT_ARG_CMD(cmd);
505 	switch (cmd) {
506 	case F_DUPFD:
507 		tmp = arg;
508 		error = kern_dup(td, FDDUP_FCNTL, 0, fd, tmp);
509 		break;
510 
511 	case F_DUPFD_CLOEXEC:
512 		tmp = arg;
513 		error = kern_dup(td, FDDUP_FCNTL, FDDUP_FLAG_CLOEXEC, fd, tmp);
514 		break;
515 
516 	case F_DUP2FD:
517 		tmp = arg;
518 		error = kern_dup(td, FDDUP_FIXED, 0, fd, tmp);
519 		break;
520 
521 	case F_DUP2FD_CLOEXEC:
522 		tmp = arg;
523 		error = kern_dup(td, FDDUP_FIXED, FDDUP_FLAG_CLOEXEC, fd, tmp);
524 		break;
525 
526 	case F_GETFD:
527 		error = EBADF;
528 		FILEDESC_SLOCK(fdp);
529 		fde = fdeget_noref(fdp, fd);
530 		if (fde != NULL) {
531 			td->td_retval[0] =
532 			    (fde->fde_flags & UF_EXCLOSE) ? FD_CLOEXEC : 0;
533 			error = 0;
534 		}
535 		FILEDESC_SUNLOCK(fdp);
536 		break;
537 
538 	case F_SETFD:
539 		error = EBADF;
540 		FILEDESC_XLOCK(fdp);
541 		fde = fdeget_noref(fdp, fd);
542 		if (fde != NULL) {
543 			fde->fde_flags = (fde->fde_flags & ~UF_EXCLOSE) |
544 			    (arg & FD_CLOEXEC ? UF_EXCLOSE : 0);
545 			error = 0;
546 		}
547 		FILEDESC_XUNLOCK(fdp);
548 		break;
549 
550 	case F_GETFL:
551 		error = fget_fcntl(td, fd, &cap_fcntl_rights, F_GETFL, &fp);
552 		if (error != 0)
553 			break;
554 		td->td_retval[0] = OFLAGS(fp->f_flag);
555 		fdrop(fp, td);
556 		break;
557 
558 	case F_SETFL:
559 		error = fget_fcntl(td, fd, &cap_fcntl_rights, F_SETFL, &fp);
560 		if (error != 0)
561 			break;
562 		if (fp->f_ops == &path_fileops) {
563 			fdrop(fp, td);
564 			error = EBADF;
565 			break;
566 		}
567 		do {
568 			tmp = flg = fp->f_flag;
569 			tmp &= ~FCNTLFLAGS;
570 			tmp |= FFLAGS(arg & ~O_ACCMODE) & FCNTLFLAGS;
571 		} while (atomic_cmpset_int(&fp->f_flag, flg, tmp) == 0);
572 		got_set = tmp & ~flg;
573 		got_cleared = flg & ~tmp;
574 		tmp = fp->f_flag & FNONBLOCK;
575 		error = fo_ioctl(fp, FIONBIO, &tmp, td->td_ucred, td);
576 		if (error != 0)
577 			goto revert_f_setfl;
578 		tmp = fp->f_flag & FASYNC;
579 		error = fo_ioctl(fp, FIOASYNC, &tmp, td->td_ucred, td);
580 		if (error == 0) {
581 			fdrop(fp, td);
582 			break;
583 		}
584 		atomic_clear_int(&fp->f_flag, FNONBLOCK);
585 		tmp = 0;
586 		(void)fo_ioctl(fp, FIONBIO, &tmp, td->td_ucred, td);
587 revert_f_setfl:
588 		do {
589 			tmp = flg = fp->f_flag;
590 			tmp &= ~FCNTLFLAGS;
591 			tmp |= got_cleared;
592 			tmp &= ~got_set;
593 		} while (atomic_cmpset_int(&fp->f_flag, flg, tmp) == 0);
594 		fdrop(fp, td);
595 		break;
596 
597 	case F_GETOWN:
598 		error = fget_fcntl(td, fd, &cap_fcntl_rights, F_GETOWN, &fp);
599 		if (error != 0)
600 			break;
601 		error = fo_ioctl(fp, FIOGETOWN, &tmp, td->td_ucred, td);
602 		if (error == 0)
603 			td->td_retval[0] = tmp;
604 		fdrop(fp, td);
605 		break;
606 
607 	case F_SETOWN:
608 		error = fget_fcntl(td, fd, &cap_fcntl_rights, F_SETOWN, &fp);
609 		if (error != 0)
610 			break;
611 		tmp = arg;
612 		error = fo_ioctl(fp, FIOSETOWN, &tmp, td->td_ucred, td);
613 		fdrop(fp, td);
614 		break;
615 
616 	case F_SETLK_REMOTE:
617 		error = priv_check(td, PRIV_NFS_LOCKD);
618 		if (error != 0)
619 			return (error);
620 		flg = F_REMOTE;
621 		goto do_setlk;
622 
623 	case F_SETLKW:
624 		flg |= F_WAIT;
625 		/* FALLTHROUGH F_SETLK */
626 
627 	case F_SETLK:
628 	do_setlk:
629 		flp = (struct flock *)arg;
630 		if ((flg & F_REMOTE) != 0 && flp->l_sysid == 0) {
631 			error = EINVAL;
632 			break;
633 		}
634 
635 		error = fget_unlocked(td, fd, &cap_flock_rights, &fp);
636 		if (error != 0)
637 			break;
638 		if (fp->f_type != DTYPE_VNODE || fp->f_ops == &path_fileops) {
639 			error = EBADF;
640 			fdrop(fp, td);
641 			break;
642 		}
643 
644 		if (flp->l_whence == SEEK_CUR) {
645 			foffset = foffset_get(fp);
646 			if (foffset < 0 ||
647 			    (flp->l_start > 0 &&
648 			     foffset > OFF_MAX - flp->l_start)) {
649 				error = EOVERFLOW;
650 				fdrop(fp, td);
651 				break;
652 			}
653 			flp->l_start += foffset;
654 		}
655 
656 		vp = fp->f_vnode;
657 		switch (flp->l_type) {
658 		case F_RDLCK:
659 			if ((fp->f_flag & FREAD) == 0) {
660 				error = EBADF;
661 				break;
662 			}
663 			if ((p->p_leader->p_flag & P_ADVLOCK) == 0) {
664 				PROC_LOCK(p->p_leader);
665 				p->p_leader->p_flag |= P_ADVLOCK;
666 				PROC_UNLOCK(p->p_leader);
667 			}
668 			error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_SETLK,
669 			    flp, flg);
670 			break;
671 		case F_WRLCK:
672 			if ((fp->f_flag & FWRITE) == 0) {
673 				error = EBADF;
674 				break;
675 			}
676 			if ((p->p_leader->p_flag & P_ADVLOCK) == 0) {
677 				PROC_LOCK(p->p_leader);
678 				p->p_leader->p_flag |= P_ADVLOCK;
679 				PROC_UNLOCK(p->p_leader);
680 			}
681 			error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_SETLK,
682 			    flp, flg);
683 			break;
684 		case F_UNLCK:
685 			error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_UNLCK,
686 			    flp, flg);
687 			break;
688 		case F_UNLCKSYS:
689 			if (flg != F_REMOTE) {
690 				error = EINVAL;
691 				break;
692 			}
693 			error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader,
694 			    F_UNLCKSYS, flp, flg);
695 			break;
696 		default:
697 			error = EINVAL;
698 			break;
699 		}
700 		if (error != 0 || flp->l_type == F_UNLCK ||
701 		    flp->l_type == F_UNLCKSYS) {
702 			fdrop(fp, td);
703 			break;
704 		}
705 
706 		/*
707 		 * Check for a race with close.
708 		 *
709 		 * The vnode is now advisory locked (or unlocked, but this case
710 		 * is not really important) as the caller requested.
711 		 * We had to drop the filedesc lock, so we need to recheck if
712 		 * the descriptor is still valid, because if it was closed
713 		 * in the meantime we need to remove advisory lock from the
714 		 * vnode - close on any descriptor leading to an advisory
715 		 * locked vnode, removes that lock.
716 		 * We will return 0 on purpose in that case, as the result of
717 		 * successful advisory lock might have been externally visible
718 		 * already. This is fine - effectively we pretend to the caller
719 		 * that the closing thread was a bit slower and that the
720 		 * advisory lock succeeded before the close.
721 		 */
722 		error = fget_unlocked(td, fd, &cap_no_rights, &fp2);
723 		if (error != 0) {
724 			fdrop(fp, td);
725 			break;
726 		}
727 		if (fp != fp2) {
728 			flp->l_whence = SEEK_SET;
729 			flp->l_start = 0;
730 			flp->l_len = 0;
731 			flp->l_type = F_UNLCK;
732 			(void) VOP_ADVLOCK(vp, (caddr_t)p->p_leader,
733 			    F_UNLCK, flp, F_POSIX);
734 		}
735 		fdrop(fp, td);
736 		fdrop(fp2, td);
737 		break;
738 
739 	case F_GETLK:
740 		error = fget_unlocked(td, fd, &cap_flock_rights, &fp);
741 		if (error != 0)
742 			break;
743 		if (fp->f_type != DTYPE_VNODE || fp->f_ops == &path_fileops) {
744 			error = EBADF;
745 			fdrop(fp, td);
746 			break;
747 		}
748 		flp = (struct flock *)arg;
749 		if (flp->l_type != F_RDLCK && flp->l_type != F_WRLCK &&
750 		    flp->l_type != F_UNLCK) {
751 			error = EINVAL;
752 			fdrop(fp, td);
753 			break;
754 		}
755 		if (flp->l_whence == SEEK_CUR) {
756 			foffset = foffset_get(fp);
757 			if ((flp->l_start > 0 &&
758 			    foffset > OFF_MAX - flp->l_start) ||
759 			    (flp->l_start < 0 &&
760 			    foffset < OFF_MIN - flp->l_start)) {
761 				error = EOVERFLOW;
762 				fdrop(fp, td);
763 				break;
764 			}
765 			flp->l_start += foffset;
766 		}
767 		vp = fp->f_vnode;
768 		error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_GETLK, flp,
769 		    F_POSIX);
770 		fdrop(fp, td);
771 		break;
772 
773 	case F_ADD_SEALS:
774 		error = fget_unlocked(td, fd, &cap_no_rights, &fp);
775 		if (error != 0)
776 			break;
777 		error = fo_add_seals(fp, arg);
778 		fdrop(fp, td);
779 		break;
780 
781 	case F_GET_SEALS:
782 		error = fget_unlocked(td, fd, &cap_no_rights, &fp);
783 		if (error != 0)
784 			break;
785 		if (fo_get_seals(fp, &seals) == 0)
786 			td->td_retval[0] = seals;
787 		else
788 			error = EINVAL;
789 		fdrop(fp, td);
790 		break;
791 
792 	case F_RDAHEAD:
793 		arg = arg ? 128 * 1024: 0;
794 		/* FALLTHROUGH */
795 	case F_READAHEAD:
796 		error = fget_unlocked(td, fd, &cap_no_rights, &fp);
797 		if (error != 0)
798 			break;
799 		if (fp->f_type != DTYPE_VNODE || fp->f_ops == &path_fileops) {
800 			fdrop(fp, td);
801 			error = EBADF;
802 			break;
803 		}
804 		vp = fp->f_vnode;
805 		if (vp->v_type != VREG) {
806 			fdrop(fp, td);
807 			error = ENOTTY;
808 			break;
809 		}
810 
811 		/*
812 		 * Exclusive lock synchronizes against f_seqcount reads and
813 		 * writes in sequential_heuristic().
814 		 */
815 		error = vn_lock(vp, LK_EXCLUSIVE);
816 		if (error != 0) {
817 			fdrop(fp, td);
818 			break;
819 		}
820 		if (arg >= 0) {
821 			bsize = fp->f_vnode->v_mount->mnt_stat.f_iosize;
822 			arg = MIN(arg, INT_MAX - bsize + 1);
823 			fp->f_seqcount[UIO_READ] = MIN(IO_SEQMAX,
824 			    (arg + bsize - 1) / bsize);
825 			atomic_set_int(&fp->f_flag, FRDAHEAD);
826 		} else {
827 			atomic_clear_int(&fp->f_flag, FRDAHEAD);
828 		}
829 		VOP_UNLOCK(vp);
830 		fdrop(fp, td);
831 		break;
832 
833 	case F_ISUNIONSTACK:
834 		/*
835 		 * Check if the vnode is part of a union stack (either the
836 		 * "union" flag from mount(2) or unionfs).
837 		 *
838 		 * Prior to introduction of this op libc's readdir would call
839 		 * fstatfs(2), in effect unnecessarily copying kilobytes of
840 		 * data just to check fs name and a mount flag.
841 		 *
842 		 * Fixing the code to handle everything in the kernel instead
843 		 * is a non-trivial endeavor and has low priority, thus this
844 		 * horrible kludge facilitates the current behavior in a much
845 		 * cheaper manner until someone(tm) sorts this out.
846 		 */
847 		error = fget_unlocked(td, fd, &cap_no_rights, &fp);
848 		if (error != 0)
849 			break;
850 		if (fp->f_type != DTYPE_VNODE) {
851 			fdrop(fp, td);
852 			error = EBADF;
853 			break;
854 		}
855 		vp = fp->f_vnode;
856 		/*
857 		 * Since we don't prevent dooming the vnode even non-null mp
858 		 * found can become immediately stale. This is tolerable since
859 		 * mount points are type-stable (providing safe memory access)
860 		 * and any vfs op on this vnode going forward will return an
861 		 * error (meaning return value in this case is meaningless).
862 		 */
863 		mp = atomic_load_ptr(&vp->v_mount);
864 		if (__predict_false(mp == NULL)) {
865 			fdrop(fp, td);
866 			error = EBADF;
867 			break;
868 		}
869 		td->td_retval[0] = 0;
870 		if (mp->mnt_kern_flag & MNTK_UNIONFS ||
871 		    mp->mnt_flag & MNT_UNION)
872 			td->td_retval[0] = 1;
873 		fdrop(fp, td);
874 		break;
875 
876 	case F_KINFO:
877 #ifdef CAPABILITY_MODE
878 		if (IN_CAPABILITY_MODE(td)) {
879 			error = ECAPMODE;
880 			break;
881 		}
882 #endif
883 		error = copyin((void *)arg, &kif_sz, sizeof(kif_sz));
884 		if (error != 0)
885 			break;
886 		if (kif_sz != sizeof(*kif)) {
887 			error = EINVAL;
888 			break;
889 		}
890 		kif = malloc(sizeof(*kif), M_TEMP, M_WAITOK | M_ZERO);
891 		FILEDESC_SLOCK(fdp);
892 		error = fget_cap_noref(fdp, fd, &cap_fcntl_rights, &fp, NULL);
893 		if (error == 0 && fhold(fp)) {
894 			export_file_to_kinfo(fp, fd, NULL, kif, fdp, 0);
895 			FILEDESC_SUNLOCK(fdp);
896 			fdrop(fp, td);
897 			if ((kif->kf_status & KF_ATTR_VALID) != 0) {
898 				kif->kf_structsize = sizeof(*kif);
899 				error = copyout(kif, (void *)arg, sizeof(*kif));
900 			} else {
901 				error = EBADF;
902 			}
903 		} else {
904 			FILEDESC_SUNLOCK(fdp);
905 			if (error == 0)
906 				error = EBADF;
907 		}
908 		free(kif, M_TEMP);
909 		break;
910 
911 	default:
912 		error = EINVAL;
913 		break;
914 	}
915 	return (error);
916 }
917 
918 static int
919 getmaxfd(struct thread *td)
920 {
921 
922 	return (min((int)lim_cur(td, RLIMIT_NOFILE), maxfilesperproc));
923 }
924 
925 /*
926  * Common code for dup, dup2, fcntl(F_DUPFD) and fcntl(F_DUP2FD).
927  */
928 int
929 kern_dup(struct thread *td, u_int mode, int flags, int old, int new)
930 {
931 	struct filedesc *fdp;
932 	struct filedescent *oldfde, *newfde;
933 	struct proc *p;
934 	struct file *delfp, *oldfp;
935 	u_long *oioctls, *nioctls;
936 	int error, maxfd;
937 
938 	p = td->td_proc;
939 	fdp = p->p_fd;
940 	oioctls = NULL;
941 
942 	MPASS((flags & ~(FDDUP_FLAG_CLOEXEC)) == 0);
943 	MPASS(mode < FDDUP_LASTMODE);
944 
945 	AUDIT_ARG_FD(old);
946 	/* XXXRW: if (flags & FDDUP_FIXED) AUDIT_ARG_FD2(new); */
947 
948 	/*
949 	 * Verify we have a valid descriptor to dup from and possibly to
950 	 * dup to. Unlike dup() and dup2(), fcntl()'s F_DUPFD should
951 	 * return EINVAL when the new descriptor is out of bounds.
952 	 */
953 	if (old < 0)
954 		return (EBADF);
955 	if (new < 0)
956 		return (mode == FDDUP_FCNTL ? EINVAL : EBADF);
957 	maxfd = getmaxfd(td);
958 	if (new >= maxfd)
959 		return (mode == FDDUP_FCNTL ? EINVAL : EBADF);
960 
961 	error = EBADF;
962 	FILEDESC_XLOCK(fdp);
963 	if (fget_noref(fdp, old) == NULL)
964 		goto unlock;
965 	if (mode == FDDUP_FIXED && old == new) {
966 		td->td_retval[0] = new;
967 		if (flags & FDDUP_FLAG_CLOEXEC)
968 			fdp->fd_ofiles[new].fde_flags |= UF_EXCLOSE;
969 		error = 0;
970 		goto unlock;
971 	}
972 
973 	oldfde = &fdp->fd_ofiles[old];
974 	oldfp = oldfde->fde_file;
975 	if (!fhold(oldfp))
976 		goto unlock;
977 
978 	/*
979 	 * If the caller specified a file descriptor, make sure the file
980 	 * table is large enough to hold it, and grab it.  Otherwise, just
981 	 * allocate a new descriptor the usual way.
982 	 */
983 	switch (mode) {
984 	case FDDUP_NORMAL:
985 	case FDDUP_FCNTL:
986 		if ((error = fdalloc(td, new, &new)) != 0) {
987 			fdrop(oldfp, td);
988 			goto unlock;
989 		}
990 		break;
991 	case FDDUP_FIXED:
992 		if (new >= fdp->fd_nfiles) {
993 			/*
994 			 * The resource limits are here instead of e.g.
995 			 * fdalloc(), because the file descriptor table may be
996 			 * shared between processes, so we can't really use
997 			 * racct_add()/racct_sub().  Instead of counting the
998 			 * number of actually allocated descriptors, just put
999 			 * the limit on the size of the file descriptor table.
1000 			 */
1001 #ifdef RACCT
1002 			if (RACCT_ENABLED()) {
1003 				error = racct_set_unlocked(p, RACCT_NOFILE, new + 1);
1004 				if (error != 0) {
1005 					error = EMFILE;
1006 					fdrop(oldfp, td);
1007 					goto unlock;
1008 				}
1009 			}
1010 #endif
1011 			fdgrowtable_exp(fdp, new + 1);
1012 		}
1013 		if (!fdisused(fdp, new))
1014 			fdused(fdp, new);
1015 		break;
1016 	default:
1017 		KASSERT(0, ("%s unsupported mode %d", __func__, mode));
1018 	}
1019 
1020 	KASSERT(old != new, ("new fd is same as old"));
1021 
1022 	/* Refetch oldfde because the table may have grown and old one freed. */
1023 	oldfde = &fdp->fd_ofiles[old];
1024 	KASSERT(oldfp == oldfde->fde_file,
1025 	    ("fdt_ofiles shift from growth observed at fd %d",
1026 	    old));
1027 
1028 	newfde = &fdp->fd_ofiles[new];
1029 	delfp = newfde->fde_file;
1030 
1031 	nioctls = filecaps_copy_prep(&oldfde->fde_caps);
1032 
1033 	/*
1034 	 * Duplicate the source descriptor.
1035 	 */
1036 #ifdef CAPABILITIES
1037 	seqc_write_begin(&newfde->fde_seqc);
1038 #endif
1039 	oioctls = filecaps_free_prep(&newfde->fde_caps);
1040 	fde_copy(oldfde, newfde);
1041 	filecaps_copy_finish(&oldfde->fde_caps, &newfde->fde_caps,
1042 	    nioctls);
1043 	if ((flags & FDDUP_FLAG_CLOEXEC) != 0)
1044 		newfde->fde_flags = oldfde->fde_flags | UF_EXCLOSE;
1045 	else
1046 		newfde->fde_flags = oldfde->fde_flags & ~UF_EXCLOSE;
1047 #ifdef CAPABILITIES
1048 	seqc_write_end(&newfde->fde_seqc);
1049 #endif
1050 	td->td_retval[0] = new;
1051 
1052 	error = 0;
1053 
1054 	if (delfp != NULL) {
1055 		(void) closefp(fdp, new, delfp, td, true, false);
1056 		FILEDESC_UNLOCK_ASSERT(fdp);
1057 	} else {
1058 unlock:
1059 		FILEDESC_XUNLOCK(fdp);
1060 	}
1061 
1062 	filecaps_free_finish(oioctls);
1063 	return (error);
1064 }
1065 
1066 static void
1067 sigiofree(struct sigio *sigio)
1068 {
1069 	crfree(sigio->sio_ucred);
1070 	free(sigio, M_SIGIO);
1071 }
1072 
1073 static struct sigio *
1074 funsetown_locked(struct sigio *sigio)
1075 {
1076 	struct proc *p;
1077 	struct pgrp *pg;
1078 
1079 	SIGIO_ASSERT_LOCKED();
1080 
1081 	if (sigio == NULL)
1082 		return (NULL);
1083 	*sigio->sio_myref = NULL;
1084 	if (sigio->sio_pgid < 0) {
1085 		pg = sigio->sio_pgrp;
1086 		PGRP_LOCK(pg);
1087 		SLIST_REMOVE(&pg->pg_sigiolst, sigio, sigio, sio_pgsigio);
1088 		PGRP_UNLOCK(pg);
1089 	} else {
1090 		p = sigio->sio_proc;
1091 		PROC_LOCK(p);
1092 		SLIST_REMOVE(&p->p_sigiolst, sigio, sigio, sio_pgsigio);
1093 		PROC_UNLOCK(p);
1094 	}
1095 	return (sigio);
1096 }
1097 
1098 /*
1099  * If sigio is on the list associated with a process or process group,
1100  * disable signalling from the device, remove sigio from the list and
1101  * free sigio.
1102  */
1103 void
1104 funsetown(struct sigio **sigiop)
1105 {
1106 	struct sigio *sigio;
1107 
1108 	/* Racy check, consumers must provide synchronization. */
1109 	if (*sigiop == NULL)
1110 		return;
1111 
1112 	SIGIO_LOCK();
1113 	sigio = funsetown_locked(*sigiop);
1114 	SIGIO_UNLOCK();
1115 	if (sigio != NULL)
1116 		sigiofree(sigio);
1117 }
1118 
1119 /*
1120  * Free a list of sigio structures.  The caller must ensure that new sigio
1121  * structures cannot be added after this point.  For process groups this is
1122  * guaranteed using the proctree lock; for processes, the P_WEXIT flag serves
1123  * as an interlock.
1124  */
1125 void
1126 funsetownlst(struct sigiolst *sigiolst)
1127 {
1128 	struct proc *p;
1129 	struct pgrp *pg;
1130 	struct sigio *sigio, *tmp;
1131 
1132 	/* Racy check. */
1133 	sigio = SLIST_FIRST(sigiolst);
1134 	if (sigio == NULL)
1135 		return;
1136 
1137 	p = NULL;
1138 	pg = NULL;
1139 
1140 	SIGIO_LOCK();
1141 	sigio = SLIST_FIRST(sigiolst);
1142 	if (sigio == NULL) {
1143 		SIGIO_UNLOCK();
1144 		return;
1145 	}
1146 
1147 	/*
1148 	 * Every entry of the list should belong to a single proc or pgrp.
1149 	 */
1150 	if (sigio->sio_pgid < 0) {
1151 		pg = sigio->sio_pgrp;
1152 		sx_assert(&proctree_lock, SX_XLOCKED);
1153 		PGRP_LOCK(pg);
1154 	} else /* if (sigio->sio_pgid > 0) */ {
1155 		p = sigio->sio_proc;
1156 		PROC_LOCK(p);
1157 		KASSERT((p->p_flag & P_WEXIT) != 0,
1158 		    ("%s: process %p is not exiting", __func__, p));
1159 	}
1160 
1161 	SLIST_FOREACH(sigio, sigiolst, sio_pgsigio) {
1162 		*sigio->sio_myref = NULL;
1163 		if (pg != NULL) {
1164 			KASSERT(sigio->sio_pgid < 0,
1165 			    ("Proc sigio in pgrp sigio list"));
1166 			KASSERT(sigio->sio_pgrp == pg,
1167 			    ("Bogus pgrp in sigio list"));
1168 		} else /* if (p != NULL) */ {
1169 			KASSERT(sigio->sio_pgid > 0,
1170 			    ("Pgrp sigio in proc sigio list"));
1171 			KASSERT(sigio->sio_proc == p,
1172 			    ("Bogus proc in sigio list"));
1173 		}
1174 	}
1175 
1176 	if (pg != NULL)
1177 		PGRP_UNLOCK(pg);
1178 	else
1179 		PROC_UNLOCK(p);
1180 	SIGIO_UNLOCK();
1181 
1182 	SLIST_FOREACH_SAFE(sigio, sigiolst, sio_pgsigio, tmp)
1183 		sigiofree(sigio);
1184 }
1185 
1186 /*
1187  * This is common code for FIOSETOWN ioctl called by fcntl(fd, F_SETOWN, arg).
1188  *
1189  * After permission checking, add a sigio structure to the sigio list for
1190  * the process or process group.
1191  */
1192 int
1193 fsetown(pid_t pgid, struct sigio **sigiop)
1194 {
1195 	struct proc *proc;
1196 	struct pgrp *pgrp;
1197 	struct sigio *osigio, *sigio;
1198 	int ret;
1199 
1200 	if (pgid == 0) {
1201 		funsetown(sigiop);
1202 		return (0);
1203 	}
1204 
1205 	sigio = malloc(sizeof(struct sigio), M_SIGIO, M_WAITOK);
1206 	sigio->sio_pgid = pgid;
1207 	sigio->sio_ucred = crhold(curthread->td_ucred);
1208 	sigio->sio_myref = sigiop;
1209 
1210 	ret = 0;
1211 	if (pgid > 0) {
1212 		ret = pget(pgid, PGET_NOTWEXIT | PGET_NOTID | PGET_HOLD, &proc);
1213 		SIGIO_LOCK();
1214 		osigio = funsetown_locked(*sigiop);
1215 		if (ret == 0) {
1216 			PROC_LOCK(proc);
1217 			_PRELE(proc);
1218 			if ((proc->p_flag & P_WEXIT) != 0) {
1219 				ret = ESRCH;
1220 			} else if (proc->p_session !=
1221 			    curthread->td_proc->p_session) {
1222 				/*
1223 				 * Policy - Don't allow a process to FSETOWN a
1224 				 * process in another session.
1225 				 *
1226 				 * Remove this test to allow maximum flexibility
1227 				 * or restrict FSETOWN to the current process or
1228 				 * process group for maximum safety.
1229 				 */
1230 				ret = EPERM;
1231 			} else {
1232 				sigio->sio_proc = proc;
1233 				SLIST_INSERT_HEAD(&proc->p_sigiolst, sigio,
1234 				    sio_pgsigio);
1235 			}
1236 			PROC_UNLOCK(proc);
1237 		}
1238 	} else /* if (pgid < 0) */ {
1239 		sx_slock(&proctree_lock);
1240 		SIGIO_LOCK();
1241 		osigio = funsetown_locked(*sigiop);
1242 		pgrp = pgfind(-pgid);
1243 		if (pgrp == NULL) {
1244 			ret = ESRCH;
1245 		} else {
1246 			if (pgrp->pg_session != curthread->td_proc->p_session) {
1247 				/*
1248 				 * Policy - Don't allow a process to FSETOWN a
1249 				 * process in another session.
1250 				 *
1251 				 * Remove this test to allow maximum flexibility
1252 				 * or restrict FSETOWN to the current process or
1253 				 * process group for maximum safety.
1254 				 */
1255 				ret = EPERM;
1256 			} else {
1257 				sigio->sio_pgrp = pgrp;
1258 				SLIST_INSERT_HEAD(&pgrp->pg_sigiolst, sigio,
1259 				    sio_pgsigio);
1260 			}
1261 			PGRP_UNLOCK(pgrp);
1262 		}
1263 		sx_sunlock(&proctree_lock);
1264 	}
1265 	if (ret == 0)
1266 		*sigiop = sigio;
1267 	SIGIO_UNLOCK();
1268 	if (osigio != NULL)
1269 		sigiofree(osigio);
1270 	return (ret);
1271 }
1272 
1273 /*
1274  * This is common code for FIOGETOWN ioctl called by fcntl(fd, F_GETOWN, arg).
1275  */
1276 pid_t
1277 fgetown(struct sigio **sigiop)
1278 {
1279 	pid_t pgid;
1280 
1281 	SIGIO_LOCK();
1282 	pgid = (*sigiop != NULL) ? (*sigiop)->sio_pgid : 0;
1283 	SIGIO_UNLOCK();
1284 	return (pgid);
1285 }
1286 
1287 static int
1288 closefp_impl(struct filedesc *fdp, int fd, struct file *fp, struct thread *td,
1289     bool audit)
1290 {
1291 	int error;
1292 
1293 	FILEDESC_XLOCK_ASSERT(fdp);
1294 
1295 	/*
1296 	 * We now hold the fp reference that used to be owned by the
1297 	 * descriptor array.  We have to unlock the FILEDESC *AFTER*
1298 	 * knote_fdclose to prevent a race of the fd getting opened, a knote
1299 	 * added, and deleteing a knote for the new fd.
1300 	 */
1301 	if (__predict_false(!TAILQ_EMPTY(&fdp->fd_kqlist)))
1302 		knote_fdclose(td, fd);
1303 
1304 	/*
1305 	 * We need to notify mqueue if the object is of type mqueue.
1306 	 */
1307 	if (__predict_false(fp->f_type == DTYPE_MQUEUE))
1308 		mq_fdclose(td, fd, fp);
1309 	FILEDESC_XUNLOCK(fdp);
1310 
1311 #ifdef AUDIT
1312 	if (AUDITING_TD(td) && audit)
1313 		audit_sysclose(td, fd, fp);
1314 #endif
1315 	error = closef(fp, td);
1316 
1317 	/*
1318 	 * All paths leading up to closefp() will have already removed or
1319 	 * replaced the fd in the filedesc table, so a restart would not
1320 	 * operate on the same file.
1321 	 */
1322 	if (error == ERESTART)
1323 		error = EINTR;
1324 
1325 	return (error);
1326 }
1327 
1328 static int
1329 closefp_hl(struct filedesc *fdp, int fd, struct file *fp, struct thread *td,
1330     bool holdleaders, bool audit)
1331 {
1332 	int error;
1333 
1334 	FILEDESC_XLOCK_ASSERT(fdp);
1335 
1336 	if (holdleaders) {
1337 		if (td->td_proc->p_fdtol != NULL) {
1338 			/*
1339 			 * Ask fdfree() to sleep to ensure that all relevant
1340 			 * process leaders can be traversed in closef().
1341 			 */
1342 			fdp->fd_holdleaderscount++;
1343 		} else {
1344 			holdleaders = false;
1345 		}
1346 	}
1347 
1348 	error = closefp_impl(fdp, fd, fp, td, audit);
1349 	if (holdleaders) {
1350 		FILEDESC_XLOCK(fdp);
1351 		fdp->fd_holdleaderscount--;
1352 		if (fdp->fd_holdleaderscount == 0 &&
1353 		    fdp->fd_holdleaderswakeup != 0) {
1354 			fdp->fd_holdleaderswakeup = 0;
1355 			wakeup(&fdp->fd_holdleaderscount);
1356 		}
1357 		FILEDESC_XUNLOCK(fdp);
1358 	}
1359 	return (error);
1360 }
1361 
1362 static int
1363 closefp(struct filedesc *fdp, int fd, struct file *fp, struct thread *td,
1364     bool holdleaders, bool audit)
1365 {
1366 
1367 	FILEDESC_XLOCK_ASSERT(fdp);
1368 
1369 	if (__predict_false(td->td_proc->p_fdtol != NULL)) {
1370 		return (closefp_hl(fdp, fd, fp, td, holdleaders, audit));
1371 	} else {
1372 		return (closefp_impl(fdp, fd, fp, td, audit));
1373 	}
1374 }
1375 
1376 /*
1377  * Close a file descriptor.
1378  */
1379 #ifndef _SYS_SYSPROTO_H_
1380 struct close_args {
1381 	int     fd;
1382 };
1383 #endif
1384 /* ARGSUSED */
1385 int
1386 sys_close(struct thread *td, struct close_args *uap)
1387 {
1388 
1389 	return (kern_close(td, uap->fd));
1390 }
1391 
1392 int
1393 kern_close(struct thread *td, int fd)
1394 {
1395 	struct filedesc *fdp;
1396 	struct file *fp;
1397 
1398 	fdp = td->td_proc->p_fd;
1399 
1400 	FILEDESC_XLOCK(fdp);
1401 	if ((fp = fget_noref(fdp, fd)) == NULL) {
1402 		FILEDESC_XUNLOCK(fdp);
1403 		return (EBADF);
1404 	}
1405 	fdfree(fdp, fd);
1406 
1407 	/* closefp() drops the FILEDESC lock for us. */
1408 	return (closefp(fdp, fd, fp, td, true, true));
1409 }
1410 
1411 static int
1412 close_range_cloexec(struct thread *td, u_int lowfd, u_int highfd)
1413 {
1414 	struct filedesc *fdp;
1415 	struct fdescenttbl *fdt;
1416 	struct filedescent *fde;
1417 	int fd;
1418 
1419 	fdp = td->td_proc->p_fd;
1420 	FILEDESC_XLOCK(fdp);
1421 	fdt = atomic_load_ptr(&fdp->fd_files);
1422 	highfd = MIN(highfd, fdt->fdt_nfiles - 1);
1423 	fd = lowfd;
1424 	if (__predict_false(fd > highfd)) {
1425 		goto out_locked;
1426 	}
1427 	for (; fd <= highfd; fd++) {
1428 		fde = &fdt->fdt_ofiles[fd];
1429 		if (fde->fde_file != NULL)
1430 			fde->fde_flags |= UF_EXCLOSE;
1431 	}
1432 out_locked:
1433 	FILEDESC_XUNLOCK(fdp);
1434 	return (0);
1435 }
1436 
1437 static int
1438 close_range_impl(struct thread *td, u_int lowfd, u_int highfd)
1439 {
1440 	struct filedesc *fdp;
1441 	const struct fdescenttbl *fdt;
1442 	struct file *fp;
1443 	int fd;
1444 
1445 	fdp = td->td_proc->p_fd;
1446 	FILEDESC_XLOCK(fdp);
1447 	fdt = atomic_load_ptr(&fdp->fd_files);
1448 	highfd = MIN(highfd, fdt->fdt_nfiles - 1);
1449 	fd = lowfd;
1450 	if (__predict_false(fd > highfd)) {
1451 		goto out_locked;
1452 	}
1453 	for (;;) {
1454 		fp = fdt->fdt_ofiles[fd].fde_file;
1455 		if (fp == NULL) {
1456 			if (fd == highfd)
1457 				goto out_locked;
1458 		} else {
1459 			fdfree(fdp, fd);
1460 			(void) closefp(fdp, fd, fp, td, true, true);
1461 			if (fd == highfd)
1462 				goto out_unlocked;
1463 			FILEDESC_XLOCK(fdp);
1464 			fdt = atomic_load_ptr(&fdp->fd_files);
1465 		}
1466 		fd++;
1467 	}
1468 out_locked:
1469 	FILEDESC_XUNLOCK(fdp);
1470 out_unlocked:
1471 	return (0);
1472 }
1473 
1474 int
1475 kern_close_range(struct thread *td, int flags, u_int lowfd, u_int highfd)
1476 {
1477 
1478 	/*
1479 	 * Check this prior to clamping; closefrom(3) with only fd 0, 1, and 2
1480 	 * open should not be a usage error.  From a close_range() perspective,
1481 	 * close_range(3, ~0U, 0) in the same scenario should also likely not
1482 	 * be a usage error as all fd above 3 are in-fact already closed.
1483 	 */
1484 	if (highfd < lowfd) {
1485 		return (EINVAL);
1486 	}
1487 
1488 	if ((flags & CLOSE_RANGE_CLOEXEC) != 0)
1489 		return (close_range_cloexec(td, lowfd, highfd));
1490 
1491 	return (close_range_impl(td, lowfd, highfd));
1492 }
1493 
1494 #ifndef _SYS_SYSPROTO_H_
1495 struct close_range_args {
1496 	u_int	lowfd;
1497 	u_int	highfd;
1498 	int	flags;
1499 };
1500 #endif
1501 int
1502 sys_close_range(struct thread *td, struct close_range_args *uap)
1503 {
1504 
1505 	AUDIT_ARG_FD(uap->lowfd);
1506 	AUDIT_ARG_CMD(uap->highfd);
1507 	AUDIT_ARG_FFLAGS(uap->flags);
1508 
1509 	if ((uap->flags & ~(CLOSE_RANGE_CLOEXEC)) != 0)
1510 		return (EINVAL);
1511 	return (kern_close_range(td, uap->flags, uap->lowfd, uap->highfd));
1512 }
1513 
1514 #ifdef COMPAT_FREEBSD12
1515 /*
1516  * Close open file descriptors.
1517  */
1518 #ifndef _SYS_SYSPROTO_H_
1519 struct freebsd12_closefrom_args {
1520 	int	lowfd;
1521 };
1522 #endif
1523 /* ARGSUSED */
1524 int
1525 freebsd12_closefrom(struct thread *td, struct freebsd12_closefrom_args *uap)
1526 {
1527 	u_int lowfd;
1528 
1529 	AUDIT_ARG_FD(uap->lowfd);
1530 
1531 	/*
1532 	 * Treat negative starting file descriptor values identical to
1533 	 * closefrom(0) which closes all files.
1534 	 */
1535 	lowfd = MAX(0, uap->lowfd);
1536 	return (kern_close_range(td, 0, lowfd, ~0U));
1537 }
1538 #endif	/* COMPAT_FREEBSD12 */
1539 
1540 #if defined(COMPAT_43)
1541 /*
1542  * Return status information about a file descriptor.
1543  */
1544 #ifndef _SYS_SYSPROTO_H_
1545 struct ofstat_args {
1546 	int	fd;
1547 	struct	ostat *sb;
1548 };
1549 #endif
1550 /* ARGSUSED */
1551 int
1552 ofstat(struct thread *td, struct ofstat_args *uap)
1553 {
1554 	struct ostat oub;
1555 	struct stat ub;
1556 	int error;
1557 
1558 	error = kern_fstat(td, uap->fd, &ub);
1559 	if (error == 0) {
1560 		cvtstat(&ub, &oub);
1561 		error = copyout(&oub, uap->sb, sizeof(oub));
1562 	}
1563 	return (error);
1564 }
1565 #endif /* COMPAT_43 */
1566 
1567 #if defined(COMPAT_FREEBSD11)
1568 int
1569 freebsd11_fstat(struct thread *td, struct freebsd11_fstat_args *uap)
1570 {
1571 	struct stat sb;
1572 	struct freebsd11_stat osb;
1573 	int error;
1574 
1575 	error = kern_fstat(td, uap->fd, &sb);
1576 	if (error != 0)
1577 		return (error);
1578 	error = freebsd11_cvtstat(&sb, &osb);
1579 	if (error == 0)
1580 		error = copyout(&osb, uap->sb, sizeof(osb));
1581 	return (error);
1582 }
1583 #endif	/* COMPAT_FREEBSD11 */
1584 
1585 /*
1586  * Return status information about a file descriptor.
1587  */
1588 #ifndef _SYS_SYSPROTO_H_
1589 struct fstat_args {
1590 	int	fd;
1591 	struct	stat *sb;
1592 };
1593 #endif
1594 /* ARGSUSED */
1595 int
1596 sys_fstat(struct thread *td, struct fstat_args *uap)
1597 {
1598 	struct stat ub;
1599 	int error;
1600 
1601 	error = kern_fstat(td, uap->fd, &ub);
1602 	if (error == 0)
1603 		error = copyout(&ub, uap->sb, sizeof(ub));
1604 	return (error);
1605 }
1606 
1607 int
1608 kern_fstat(struct thread *td, int fd, struct stat *sbp)
1609 {
1610 	struct file *fp;
1611 	int error;
1612 
1613 	AUDIT_ARG_FD(fd);
1614 
1615 	error = fget(td, fd, &cap_fstat_rights, &fp);
1616 	if (__predict_false(error != 0))
1617 		return (error);
1618 
1619 	AUDIT_ARG_FILE(td->td_proc, fp);
1620 
1621 	error = fo_stat(fp, sbp, td->td_ucred);
1622 	fdrop(fp, td);
1623 #ifdef __STAT_TIME_T_EXT
1624 	sbp->st_atim_ext = 0;
1625 	sbp->st_mtim_ext = 0;
1626 	sbp->st_ctim_ext = 0;
1627 	sbp->st_btim_ext = 0;
1628 #endif
1629 #ifdef KTRACE
1630 	if (KTRPOINT(td, KTR_STRUCT))
1631 		ktrstat_error(sbp, error);
1632 #endif
1633 	return (error);
1634 }
1635 
1636 #if defined(COMPAT_FREEBSD11)
1637 /*
1638  * Return status information about a file descriptor.
1639  */
1640 #ifndef _SYS_SYSPROTO_H_
1641 struct freebsd11_nfstat_args {
1642 	int	fd;
1643 	struct	nstat *sb;
1644 };
1645 #endif
1646 /* ARGSUSED */
1647 int
1648 freebsd11_nfstat(struct thread *td, struct freebsd11_nfstat_args *uap)
1649 {
1650 	struct nstat nub;
1651 	struct stat ub;
1652 	int error;
1653 
1654 	error = kern_fstat(td, uap->fd, &ub);
1655 	if (error != 0)
1656 		return (error);
1657 	error = freebsd11_cvtnstat(&ub, &nub);
1658 	if (error != 0)
1659 		error = copyout(&nub, uap->sb, sizeof(nub));
1660 	return (error);
1661 }
1662 #endif /* COMPAT_FREEBSD11 */
1663 
1664 /*
1665  * Return pathconf information about a file descriptor.
1666  */
1667 #ifndef _SYS_SYSPROTO_H_
1668 struct fpathconf_args {
1669 	int	fd;
1670 	int	name;
1671 };
1672 #endif
1673 /* ARGSUSED */
1674 int
1675 sys_fpathconf(struct thread *td, struct fpathconf_args *uap)
1676 {
1677 	long value;
1678 	int error;
1679 
1680 	error = kern_fpathconf(td, uap->fd, uap->name, &value);
1681 	if (error == 0)
1682 		td->td_retval[0] = value;
1683 	return (error);
1684 }
1685 
1686 int
1687 kern_fpathconf(struct thread *td, int fd, int name, long *valuep)
1688 {
1689 	struct file *fp;
1690 	struct vnode *vp;
1691 	int error;
1692 
1693 	error = fget(td, fd, &cap_fpathconf_rights, &fp);
1694 	if (error != 0)
1695 		return (error);
1696 
1697 	if (name == _PC_ASYNC_IO) {
1698 		*valuep = _POSIX_ASYNCHRONOUS_IO;
1699 		goto out;
1700 	}
1701 	vp = fp->f_vnode;
1702 	if (vp != NULL) {
1703 		vn_lock(vp, LK_SHARED | LK_RETRY);
1704 		error = VOP_PATHCONF(vp, name, valuep);
1705 		VOP_UNLOCK(vp);
1706 	} else if (fp->f_type == DTYPE_PIPE || fp->f_type == DTYPE_SOCKET) {
1707 		if (name != _PC_PIPE_BUF) {
1708 			error = EINVAL;
1709 		} else {
1710 			*valuep = PIPE_BUF;
1711 			error = 0;
1712 		}
1713 	} else {
1714 		error = EOPNOTSUPP;
1715 	}
1716 out:
1717 	fdrop(fp, td);
1718 	return (error);
1719 }
1720 
1721 /*
1722  * Copy filecaps structure allocating memory for ioctls array if needed.
1723  *
1724  * The last parameter indicates whether the fdtable is locked. If it is not and
1725  * ioctls are encountered, copying fails and the caller must lock the table.
1726  *
1727  * Note that if the table was not locked, the caller has to check the relevant
1728  * sequence counter to determine whether the operation was successful.
1729  */
1730 bool
1731 filecaps_copy(const struct filecaps *src, struct filecaps *dst, bool locked)
1732 {
1733 	size_t size;
1734 
1735 	if (src->fc_ioctls != NULL && !locked)
1736 		return (false);
1737 	memcpy(dst, src, sizeof(*src));
1738 	if (src->fc_ioctls == NULL)
1739 		return (true);
1740 
1741 	KASSERT(src->fc_nioctls > 0,
1742 	    ("fc_ioctls != NULL, but fc_nioctls=%hd", src->fc_nioctls));
1743 
1744 	size = sizeof(src->fc_ioctls[0]) * src->fc_nioctls;
1745 	dst->fc_ioctls = malloc(size, M_FILECAPS, M_WAITOK);
1746 	memcpy(dst->fc_ioctls, src->fc_ioctls, size);
1747 	return (true);
1748 }
1749 
1750 static u_long *
1751 filecaps_copy_prep(const struct filecaps *src)
1752 {
1753 	u_long *ioctls;
1754 	size_t size;
1755 
1756 	if (__predict_true(src->fc_ioctls == NULL))
1757 		return (NULL);
1758 
1759 	KASSERT(src->fc_nioctls > 0,
1760 	    ("fc_ioctls != NULL, but fc_nioctls=%hd", src->fc_nioctls));
1761 
1762 	size = sizeof(src->fc_ioctls[0]) * src->fc_nioctls;
1763 	ioctls = malloc(size, M_FILECAPS, M_WAITOK);
1764 	return (ioctls);
1765 }
1766 
1767 static void
1768 filecaps_copy_finish(const struct filecaps *src, struct filecaps *dst,
1769     u_long *ioctls)
1770 {
1771 	size_t size;
1772 
1773 	*dst = *src;
1774 	if (__predict_true(src->fc_ioctls == NULL)) {
1775 		MPASS(ioctls == NULL);
1776 		return;
1777 	}
1778 
1779 	size = sizeof(src->fc_ioctls[0]) * src->fc_nioctls;
1780 	dst->fc_ioctls = ioctls;
1781 	bcopy(src->fc_ioctls, dst->fc_ioctls, size);
1782 }
1783 
1784 /*
1785  * Move filecaps structure to the new place and clear the old place.
1786  */
1787 void
1788 filecaps_move(struct filecaps *src, struct filecaps *dst)
1789 {
1790 
1791 	*dst = *src;
1792 	bzero(src, sizeof(*src));
1793 }
1794 
1795 /*
1796  * Fill the given filecaps structure with full rights.
1797  */
1798 static void
1799 filecaps_fill(struct filecaps *fcaps)
1800 {
1801 
1802 	CAP_ALL(&fcaps->fc_rights);
1803 	fcaps->fc_ioctls = NULL;
1804 	fcaps->fc_nioctls = -1;
1805 	fcaps->fc_fcntls = CAP_FCNTL_ALL;
1806 }
1807 
1808 /*
1809  * Free memory allocated within filecaps structure.
1810  */
1811 static void
1812 filecaps_free_ioctl(struct filecaps *fcaps)
1813 {
1814 
1815 	free(fcaps->fc_ioctls, M_FILECAPS);
1816 	fcaps->fc_ioctls = NULL;
1817 }
1818 
1819 void
1820 filecaps_free(struct filecaps *fcaps)
1821 {
1822 
1823 	filecaps_free_ioctl(fcaps);
1824 	bzero(fcaps, sizeof(*fcaps));
1825 }
1826 
1827 static u_long *
1828 filecaps_free_prep(struct filecaps *fcaps)
1829 {
1830 	u_long *ioctls;
1831 
1832 	ioctls = fcaps->fc_ioctls;
1833 	bzero(fcaps, sizeof(*fcaps));
1834 	return (ioctls);
1835 }
1836 
1837 static void
1838 filecaps_free_finish(u_long *ioctls)
1839 {
1840 
1841 	free(ioctls, M_FILECAPS);
1842 }
1843 
1844 /*
1845  * Validate the given filecaps structure.
1846  */
1847 static void
1848 filecaps_validate(const struct filecaps *fcaps, const char *func)
1849 {
1850 
1851 	KASSERT(cap_rights_is_valid(&fcaps->fc_rights),
1852 	    ("%s: invalid rights", func));
1853 	KASSERT((fcaps->fc_fcntls & ~CAP_FCNTL_ALL) == 0,
1854 	    ("%s: invalid fcntls", func));
1855 	KASSERT(fcaps->fc_fcntls == 0 ||
1856 	    cap_rights_is_set(&fcaps->fc_rights, CAP_FCNTL),
1857 	    ("%s: fcntls without CAP_FCNTL", func));
1858 	/*
1859 	 * open calls without WANTIOCTLCAPS free caps but leave the counter
1860 	 */
1861 #if 0
1862 	KASSERT(fcaps->fc_ioctls != NULL ? fcaps->fc_nioctls > 0 :
1863 	    (fcaps->fc_nioctls == -1 || fcaps->fc_nioctls == 0),
1864 	    ("%s: invalid ioctls", func));
1865 #endif
1866 	KASSERT(fcaps->fc_nioctls == 0 ||
1867 	    cap_rights_is_set(&fcaps->fc_rights, CAP_IOCTL),
1868 	    ("%s: ioctls without CAP_IOCTL", func));
1869 }
1870 
1871 static void
1872 fdgrowtable_exp(struct filedesc *fdp, int nfd)
1873 {
1874 	int nfd1;
1875 
1876 	FILEDESC_XLOCK_ASSERT(fdp);
1877 
1878 	nfd1 = fdp->fd_nfiles * 2;
1879 	if (nfd1 < nfd)
1880 		nfd1 = nfd;
1881 	fdgrowtable(fdp, nfd1);
1882 }
1883 
1884 /*
1885  * Grow the file table to accommodate (at least) nfd descriptors.
1886  */
1887 static void
1888 fdgrowtable(struct filedesc *fdp, int nfd)
1889 {
1890 	struct filedesc0 *fdp0;
1891 	struct freetable *ft;
1892 	struct fdescenttbl *ntable;
1893 	struct fdescenttbl *otable;
1894 	int nnfiles, onfiles;
1895 	NDSLOTTYPE *nmap, *omap;
1896 
1897 	KASSERT(fdp->fd_nfiles > 0, ("zero-length file table"));
1898 
1899 	/* save old values */
1900 	onfiles = fdp->fd_nfiles;
1901 	otable = fdp->fd_files;
1902 	omap = fdp->fd_map;
1903 
1904 	/* compute the size of the new table */
1905 	nnfiles = NDSLOTS(nfd) * NDENTRIES; /* round up */
1906 	if (nnfiles <= onfiles)
1907 		/* the table is already large enough */
1908 		return;
1909 
1910 	/*
1911 	 * Allocate a new table.  We need enough space for the number of
1912 	 * entries, file entries themselves and the struct freetable we will use
1913 	 * when we decommission the table and place it on the freelist.
1914 	 * We place the struct freetable in the middle so we don't have
1915 	 * to worry about padding.
1916 	 */
1917 	ntable = malloc(offsetof(struct fdescenttbl, fdt_ofiles) +
1918 	    nnfiles * sizeof(ntable->fdt_ofiles[0]) +
1919 	    sizeof(struct freetable),
1920 	    M_FILEDESC, M_ZERO | M_WAITOK);
1921 	/* copy the old data */
1922 	ntable->fdt_nfiles = nnfiles;
1923 	memcpy(ntable->fdt_ofiles, otable->fdt_ofiles,
1924 	    onfiles * sizeof(ntable->fdt_ofiles[0]));
1925 
1926 	/*
1927 	 * Allocate a new map only if the old is not large enough.  It will
1928 	 * grow at a slower rate than the table as it can map more
1929 	 * entries than the table can hold.
1930 	 */
1931 	if (NDSLOTS(nnfiles) > NDSLOTS(onfiles)) {
1932 		nmap = malloc(NDSLOTS(nnfiles) * NDSLOTSIZE, M_FILEDESC,
1933 		    M_ZERO | M_WAITOK);
1934 		/* copy over the old data and update the pointer */
1935 		memcpy(nmap, omap, NDSLOTS(onfiles) * sizeof(*omap));
1936 		fdp->fd_map = nmap;
1937 	}
1938 
1939 	/*
1940 	 * Make sure that ntable is correctly initialized before we replace
1941 	 * fd_files poiner. Otherwise fget_unlocked() may see inconsistent
1942 	 * data.
1943 	 */
1944 	atomic_store_rel_ptr((volatile void *)&fdp->fd_files, (uintptr_t)ntable);
1945 
1946 	/*
1947 	 * Free the old file table when not shared by other threads or processes.
1948 	 * The old file table is considered to be shared when either are true:
1949 	 * - The process has more than one thread.
1950 	 * - The file descriptor table has been shared via fdshare().
1951 	 *
1952 	 * When shared, the old file table will be placed on a freelist
1953 	 * which will be processed when the struct filedesc is released.
1954 	 *
1955 	 * Note that if onfiles == NDFILE, we're dealing with the original
1956 	 * static allocation contained within (struct filedesc0 *)fdp,
1957 	 * which must not be freed.
1958 	 */
1959 	if (onfiles > NDFILE) {
1960 		/*
1961 		 * Note we may be called here from fdinit while allocating a
1962 		 * table for a new process in which case ->p_fd points
1963 		 * elsewhere.
1964 		 */
1965 		if (curproc->p_fd != fdp || FILEDESC_IS_ONLY_USER(fdp)) {
1966 			free(otable, M_FILEDESC);
1967 		} else {
1968 			ft = (struct freetable *)&otable->fdt_ofiles[onfiles];
1969 			fdp0 = (struct filedesc0 *)fdp;
1970 			ft->ft_table = otable;
1971 			SLIST_INSERT_HEAD(&fdp0->fd_free, ft, ft_next);
1972 		}
1973 	}
1974 	/*
1975 	 * The map does not have the same possibility of threads still
1976 	 * holding references to it.  So always free it as long as it
1977 	 * does not reference the original static allocation.
1978 	 */
1979 	if (NDSLOTS(onfiles) > NDSLOTS(NDFILE))
1980 		free(omap, M_FILEDESC);
1981 }
1982 
1983 /*
1984  * Allocate a file descriptor for the process.
1985  */
1986 int
1987 fdalloc(struct thread *td, int minfd, int *result)
1988 {
1989 	struct proc *p = td->td_proc;
1990 	struct filedesc *fdp = p->p_fd;
1991 	int fd, maxfd, allocfd;
1992 #ifdef RACCT
1993 	int error;
1994 #endif
1995 
1996 	FILEDESC_XLOCK_ASSERT(fdp);
1997 
1998 	if (fdp->fd_freefile > minfd)
1999 		minfd = fdp->fd_freefile;
2000 
2001 	maxfd = getmaxfd(td);
2002 
2003 	/*
2004 	 * Search the bitmap for a free descriptor starting at minfd.
2005 	 * If none is found, grow the file table.
2006 	 */
2007 	fd = fd_first_free(fdp, minfd, fdp->fd_nfiles);
2008 	if (__predict_false(fd >= maxfd))
2009 		return (EMFILE);
2010 	if (__predict_false(fd >= fdp->fd_nfiles)) {
2011 		allocfd = min(fd * 2, maxfd);
2012 #ifdef RACCT
2013 		if (RACCT_ENABLED()) {
2014 			error = racct_set_unlocked(p, RACCT_NOFILE, allocfd);
2015 			if (error != 0)
2016 				return (EMFILE);
2017 		}
2018 #endif
2019 		/*
2020 		 * fd is already equal to first free descriptor >= minfd, so
2021 		 * we only need to grow the table and we are done.
2022 		 */
2023 		fdgrowtable_exp(fdp, allocfd);
2024 	}
2025 
2026 	/*
2027 	 * Perform some sanity checks, then mark the file descriptor as
2028 	 * used and return it to the caller.
2029 	 */
2030 	KASSERT(fd >= 0 && fd < min(maxfd, fdp->fd_nfiles),
2031 	    ("invalid descriptor %d", fd));
2032 	KASSERT(!fdisused(fdp, fd),
2033 	    ("fd_first_free() returned non-free descriptor"));
2034 	KASSERT(fdp->fd_ofiles[fd].fde_file == NULL,
2035 	    ("file descriptor isn't free"));
2036 	fdused(fdp, fd);
2037 	*result = fd;
2038 	return (0);
2039 }
2040 
2041 /*
2042  * Allocate n file descriptors for the process.
2043  */
2044 int
2045 fdallocn(struct thread *td, int minfd, int *fds, int n)
2046 {
2047 	struct proc *p = td->td_proc;
2048 	struct filedesc *fdp = p->p_fd;
2049 	int i;
2050 
2051 	FILEDESC_XLOCK_ASSERT(fdp);
2052 
2053 	for (i = 0; i < n; i++)
2054 		if (fdalloc(td, 0, &fds[i]) != 0)
2055 			break;
2056 
2057 	if (i < n) {
2058 		for (i--; i >= 0; i--)
2059 			fdunused(fdp, fds[i]);
2060 		return (EMFILE);
2061 	}
2062 
2063 	return (0);
2064 }
2065 
2066 /*
2067  * Create a new open file structure and allocate a file descriptor for the
2068  * process that refers to it.  We add one reference to the file for the
2069  * descriptor table and one reference for resultfp. This is to prevent us
2070  * being preempted and the entry in the descriptor table closed after we
2071  * release the FILEDESC lock.
2072  */
2073 int
2074 falloc_caps(struct thread *td, struct file **resultfp, int *resultfd, int flags,
2075     struct filecaps *fcaps)
2076 {
2077 	struct file *fp;
2078 	int error, fd;
2079 
2080 	MPASS(resultfp != NULL);
2081 	MPASS(resultfd != NULL);
2082 
2083 	error = _falloc_noinstall(td, &fp, 2);
2084 	if (__predict_false(error != 0)) {
2085 		return (error);
2086 	}
2087 
2088 	error = finstall_refed(td, fp, &fd, flags, fcaps);
2089 	if (__predict_false(error != 0)) {
2090 		falloc_abort(td, fp);
2091 		return (error);
2092 	}
2093 
2094 	*resultfp = fp;
2095 	*resultfd = fd;
2096 
2097 	return (0);
2098 }
2099 
2100 /*
2101  * Create a new open file structure without allocating a file descriptor.
2102  */
2103 int
2104 _falloc_noinstall(struct thread *td, struct file **resultfp, u_int n)
2105 {
2106 	struct file *fp;
2107 	int maxuserfiles = maxfiles - (maxfiles / 20);
2108 	int openfiles_new;
2109 	static struct timeval lastfail;
2110 	static int curfail;
2111 
2112 	KASSERT(resultfp != NULL, ("%s: resultfp == NULL", __func__));
2113 	MPASS(n > 0);
2114 
2115 	openfiles_new = atomic_fetchadd_int(&openfiles, 1) + 1;
2116 	if ((openfiles_new >= maxuserfiles &&
2117 	    priv_check(td, PRIV_MAXFILES) != 0) ||
2118 	    openfiles_new >= maxfiles) {
2119 		atomic_subtract_int(&openfiles, 1);
2120 		if (ppsratecheck(&lastfail, &curfail, 1)) {
2121 			printf("kern.maxfiles limit exceeded by uid %i, (%s) "
2122 			    "please see tuning(7).\n", td->td_ucred->cr_ruid, td->td_proc->p_comm);
2123 		}
2124 		return (ENFILE);
2125 	}
2126 	fp = uma_zalloc(file_zone, M_WAITOK);
2127 	bzero(fp, sizeof(*fp));
2128 	refcount_init(&fp->f_count, n);
2129 	fp->f_cred = crhold(td->td_ucred);
2130 	fp->f_ops = &badfileops;
2131 	*resultfp = fp;
2132 	return (0);
2133 }
2134 
2135 void
2136 falloc_abort(struct thread *td, struct file *fp)
2137 {
2138 
2139 	/*
2140 	 * For assertion purposes.
2141 	 */
2142 	refcount_init(&fp->f_count, 0);
2143 	_fdrop(fp, td);
2144 }
2145 
2146 /*
2147  * Install a file in a file descriptor table.
2148  */
2149 void
2150 _finstall(struct filedesc *fdp, struct file *fp, int fd, int flags,
2151     struct filecaps *fcaps)
2152 {
2153 	struct filedescent *fde;
2154 
2155 	MPASS(fp != NULL);
2156 	if (fcaps != NULL)
2157 		filecaps_validate(fcaps, __func__);
2158 	FILEDESC_XLOCK_ASSERT(fdp);
2159 
2160 	fde = &fdp->fd_ofiles[fd];
2161 #ifdef CAPABILITIES
2162 	seqc_write_begin(&fde->fde_seqc);
2163 #endif
2164 	fde->fde_file = fp;
2165 	fde->fde_flags = (flags & O_CLOEXEC) != 0 ? UF_EXCLOSE : 0;
2166 	if (fcaps != NULL)
2167 		filecaps_move(fcaps, &fde->fde_caps);
2168 	else
2169 		filecaps_fill(&fde->fde_caps);
2170 #ifdef CAPABILITIES
2171 	seqc_write_end(&fde->fde_seqc);
2172 #endif
2173 }
2174 
2175 int
2176 finstall_refed(struct thread *td, struct file *fp, int *fd, int flags,
2177     struct filecaps *fcaps)
2178 {
2179 	struct filedesc *fdp = td->td_proc->p_fd;
2180 	int error;
2181 
2182 	MPASS(fd != NULL);
2183 
2184 	FILEDESC_XLOCK(fdp);
2185 	error = fdalloc(td, 0, fd);
2186 	if (__predict_true(error == 0)) {
2187 		_finstall(fdp, fp, *fd, flags, fcaps);
2188 	}
2189 	FILEDESC_XUNLOCK(fdp);
2190 	return (error);
2191 }
2192 
2193 int
2194 finstall(struct thread *td, struct file *fp, int *fd, int flags,
2195     struct filecaps *fcaps)
2196 {
2197 	int error;
2198 
2199 	MPASS(fd != NULL);
2200 
2201 	if (!fhold(fp))
2202 		return (EBADF);
2203 	error = finstall_refed(td, fp, fd, flags, fcaps);
2204 	if (__predict_false(error != 0)) {
2205 		fdrop(fp, td);
2206 	}
2207 	return (error);
2208 }
2209 
2210 /*
2211  * Build a new filedesc structure from another.
2212  *
2213  * If fdp is not NULL, return with it shared locked.
2214  */
2215 struct filedesc *
2216 fdinit(void)
2217 {
2218 	struct filedesc0 *newfdp0;
2219 	struct filedesc *newfdp;
2220 
2221 	newfdp0 = uma_zalloc(filedesc0_zone, M_WAITOK | M_ZERO);
2222 	newfdp = &newfdp0->fd_fd;
2223 
2224 	/* Create the file descriptor table. */
2225 	FILEDESC_LOCK_INIT(newfdp);
2226 	refcount_init(&newfdp->fd_refcnt, 1);
2227 	refcount_init(&newfdp->fd_holdcnt, 1);
2228 	newfdp->fd_map = newfdp0->fd_dmap;
2229 	newfdp->fd_files = (struct fdescenttbl *)&newfdp0->fd_dfiles;
2230 	newfdp->fd_files->fdt_nfiles = NDFILE;
2231 
2232 	return (newfdp);
2233 }
2234 
2235 /*
2236  * Build a pwddesc structure from another.
2237  * Copy the current, root, and jail root vnode references.
2238  *
2239  * If pdp is not NULL and keeplock is true, return with it (exclusively) locked.
2240  */
2241 struct pwddesc *
2242 pdinit(struct pwddesc *pdp, bool keeplock)
2243 {
2244 	struct pwddesc *newpdp;
2245 	struct pwd *newpwd;
2246 
2247 	newpdp = malloc(sizeof(*newpdp), M_PWDDESC, M_WAITOK | M_ZERO);
2248 
2249 	PWDDESC_LOCK_INIT(newpdp);
2250 	refcount_init(&newpdp->pd_refcount, 1);
2251 	newpdp->pd_cmask = CMASK;
2252 
2253 	if (pdp == NULL) {
2254 		newpwd = pwd_alloc();
2255 		smr_serialized_store(&newpdp->pd_pwd, newpwd, true);
2256 		return (newpdp);
2257 	}
2258 
2259 	PWDDESC_XLOCK(pdp);
2260 	newpwd = pwd_hold_pwddesc(pdp);
2261 	smr_serialized_store(&newpdp->pd_pwd, newpwd, true);
2262 	if (!keeplock)
2263 		PWDDESC_XUNLOCK(pdp);
2264 	return (newpdp);
2265 }
2266 
2267 /*
2268  * Hold either filedesc or pwddesc of the passed process.
2269  *
2270  * The process lock is used to synchronize against the target exiting and
2271  * freeing the data.
2272  *
2273  * Clearing can be ilustrated in 3 steps:
2274  * 1. set the pointer to NULL. Either routine can race against it, hence
2275  *   atomic_load_ptr.
2276  * 2. observe the process lock as not taken. Until then fdhold/pdhold can
2277  *   race to either still see the pointer or find NULL. It is still safe to
2278  *   grab a reference as clearing is stalled.
2279  * 3. after the lock is observed as not taken, any fdhold/pdhold calls are
2280  *   guaranteed to see NULL, making it safe to finish clearing
2281  */
2282 static struct filedesc *
2283 fdhold(struct proc *p)
2284 {
2285 	struct filedesc *fdp;
2286 
2287 	PROC_LOCK_ASSERT(p, MA_OWNED);
2288 	fdp = atomic_load_ptr(&p->p_fd);
2289 	if (fdp != NULL)
2290 		refcount_acquire(&fdp->fd_holdcnt);
2291 	return (fdp);
2292 }
2293 
2294 static struct pwddesc *
2295 pdhold(struct proc *p)
2296 {
2297 	struct pwddesc *pdp;
2298 
2299 	PROC_LOCK_ASSERT(p, MA_OWNED);
2300 	pdp = atomic_load_ptr(&p->p_pd);
2301 	if (pdp != NULL)
2302 		refcount_acquire(&pdp->pd_refcount);
2303 	return (pdp);
2304 }
2305 
2306 static void
2307 fddrop(struct filedesc *fdp)
2308 {
2309 
2310 	if (refcount_load(&fdp->fd_holdcnt) > 1) {
2311 		if (refcount_release(&fdp->fd_holdcnt) == 0)
2312 			return;
2313 	}
2314 
2315 	FILEDESC_LOCK_DESTROY(fdp);
2316 	uma_zfree(filedesc0_zone, fdp);
2317 }
2318 
2319 static void
2320 pddrop(struct pwddesc *pdp)
2321 {
2322 	struct pwd *pwd;
2323 
2324 	if (refcount_release_if_not_last(&pdp->pd_refcount))
2325 		return;
2326 
2327 	PWDDESC_XLOCK(pdp);
2328 	if (refcount_release(&pdp->pd_refcount) == 0) {
2329 		PWDDESC_XUNLOCK(pdp);
2330 		return;
2331 	}
2332 	pwd = PWDDESC_XLOCKED_LOAD_PWD(pdp);
2333 	pwd_set(pdp, NULL);
2334 	PWDDESC_XUNLOCK(pdp);
2335 	pwd_drop(pwd);
2336 
2337 	PWDDESC_LOCK_DESTROY(pdp);
2338 	free(pdp, M_PWDDESC);
2339 }
2340 
2341 /*
2342  * Share a filedesc structure.
2343  */
2344 struct filedesc *
2345 fdshare(struct filedesc *fdp)
2346 {
2347 
2348 	refcount_acquire(&fdp->fd_refcnt);
2349 	return (fdp);
2350 }
2351 
2352 /*
2353  * Share a pwddesc structure.
2354  */
2355 struct pwddesc *
2356 pdshare(struct pwddesc *pdp)
2357 {
2358 	refcount_acquire(&pdp->pd_refcount);
2359 	return (pdp);
2360 }
2361 
2362 /*
2363  * Unshare a filedesc structure, if necessary by making a copy
2364  */
2365 void
2366 fdunshare(struct thread *td)
2367 {
2368 	struct filedesc *tmp;
2369 	struct proc *p = td->td_proc;
2370 
2371 	if (refcount_load(&p->p_fd->fd_refcnt) == 1)
2372 		return;
2373 
2374 	tmp = fdcopy(p->p_fd);
2375 	fdescfree(td);
2376 	p->p_fd = tmp;
2377 }
2378 
2379 /*
2380  * Unshare a pwddesc structure.
2381  */
2382 void
2383 pdunshare(struct thread *td)
2384 {
2385 	struct pwddesc *pdp;
2386 	struct proc *p;
2387 
2388 	p = td->td_proc;
2389 	/* Not shared. */
2390 	if (refcount_load(&p->p_pd->pd_refcount) == 1)
2391 		return;
2392 
2393 	pdp = pdcopy(p->p_pd);
2394 	pdescfree(td);
2395 	p->p_pd = pdp;
2396 }
2397 
2398 /*
2399  * Copy a filedesc structure.  A NULL pointer in returns a NULL reference,
2400  * this is to ease callers, not catch errors.
2401  */
2402 struct filedesc *
2403 fdcopy(struct filedesc *fdp)
2404 {
2405 	struct filedesc *newfdp;
2406 	struct filedescent *nfde, *ofde;
2407 	int i, lastfile;
2408 
2409 	MPASS(fdp != NULL);
2410 
2411 	newfdp = fdinit();
2412 	FILEDESC_SLOCK(fdp);
2413 	for (;;) {
2414 		lastfile = fdlastfile(fdp);
2415 		if (lastfile < newfdp->fd_nfiles)
2416 			break;
2417 		FILEDESC_SUNLOCK(fdp);
2418 		fdgrowtable(newfdp, lastfile + 1);
2419 		FILEDESC_SLOCK(fdp);
2420 	}
2421 	/* copy all passable descriptors (i.e. not kqueue) */
2422 	newfdp->fd_freefile = fdp->fd_freefile;
2423 	FILEDESC_FOREACH_FDE(fdp, i, ofde) {
2424 		if ((ofde->fde_file->f_ops->fo_flags & DFLAG_PASSABLE) == 0 ||
2425 		    !fhold(ofde->fde_file)) {
2426 			if (newfdp->fd_freefile == fdp->fd_freefile)
2427 				newfdp->fd_freefile = i;
2428 			continue;
2429 		}
2430 		nfde = &newfdp->fd_ofiles[i];
2431 		*nfde = *ofde;
2432 		filecaps_copy(&ofde->fde_caps, &nfde->fde_caps, true);
2433 		fdused_init(newfdp, i);
2434 	}
2435 	MPASS(newfdp->fd_freefile != -1);
2436 	FILEDESC_SUNLOCK(fdp);
2437 	return (newfdp);
2438 }
2439 
2440 /*
2441  * Copy a pwddesc structure.
2442  */
2443 struct pwddesc *
2444 pdcopy(struct pwddesc *pdp)
2445 {
2446 	struct pwddesc *newpdp;
2447 
2448 	MPASS(pdp != NULL);
2449 
2450 	newpdp = pdinit(pdp, true);
2451 	newpdp->pd_cmask = pdp->pd_cmask;
2452 	PWDDESC_XUNLOCK(pdp);
2453 	return (newpdp);
2454 }
2455 
2456 /*
2457  * Clear POSIX style locks. This is only used when fdp looses a reference (i.e.
2458  * one of processes using it exits) and the table used to be shared.
2459  */
2460 static void
2461 fdclearlocks(struct thread *td)
2462 {
2463 	struct filedesc *fdp;
2464 	struct filedesc_to_leader *fdtol;
2465 	struct flock lf;
2466 	struct file *fp;
2467 	struct proc *p;
2468 	struct vnode *vp;
2469 	int i;
2470 
2471 	p = td->td_proc;
2472 	fdp = p->p_fd;
2473 	fdtol = p->p_fdtol;
2474 	MPASS(fdtol != NULL);
2475 
2476 	FILEDESC_XLOCK(fdp);
2477 	KASSERT(fdtol->fdl_refcount > 0,
2478 	    ("filedesc_to_refcount botch: fdl_refcount=%d",
2479 	    fdtol->fdl_refcount));
2480 	if (fdtol->fdl_refcount == 1 &&
2481 	    (p->p_leader->p_flag & P_ADVLOCK) != 0) {
2482 		FILEDESC_FOREACH_FP(fdp, i, fp) {
2483 			if (fp->f_type != DTYPE_VNODE ||
2484 			    !fhold(fp))
2485 				continue;
2486 			FILEDESC_XUNLOCK(fdp);
2487 			lf.l_whence = SEEK_SET;
2488 			lf.l_start = 0;
2489 			lf.l_len = 0;
2490 			lf.l_type = F_UNLCK;
2491 			vp = fp->f_vnode;
2492 			(void) VOP_ADVLOCK(vp,
2493 			    (caddr_t)p->p_leader, F_UNLCK,
2494 			    &lf, F_POSIX);
2495 			FILEDESC_XLOCK(fdp);
2496 			fdrop(fp, td);
2497 		}
2498 	}
2499 retry:
2500 	if (fdtol->fdl_refcount == 1) {
2501 		if (fdp->fd_holdleaderscount > 0 &&
2502 		    (p->p_leader->p_flag & P_ADVLOCK) != 0) {
2503 			/*
2504 			 * close() or kern_dup() has cleared a reference
2505 			 * in a shared file descriptor table.
2506 			 */
2507 			fdp->fd_holdleaderswakeup = 1;
2508 			sx_sleep(&fdp->fd_holdleaderscount,
2509 			    FILEDESC_LOCK(fdp), PLOCK, "fdlhold", 0);
2510 			goto retry;
2511 		}
2512 		if (fdtol->fdl_holdcount > 0) {
2513 			/*
2514 			 * Ensure that fdtol->fdl_leader remains
2515 			 * valid in closef().
2516 			 */
2517 			fdtol->fdl_wakeup = 1;
2518 			sx_sleep(fdtol, FILEDESC_LOCK(fdp), PLOCK,
2519 			    "fdlhold", 0);
2520 			goto retry;
2521 		}
2522 	}
2523 	fdtol->fdl_refcount--;
2524 	if (fdtol->fdl_refcount == 0 &&
2525 	    fdtol->fdl_holdcount == 0) {
2526 		fdtol->fdl_next->fdl_prev = fdtol->fdl_prev;
2527 		fdtol->fdl_prev->fdl_next = fdtol->fdl_next;
2528 	} else
2529 		fdtol = NULL;
2530 	p->p_fdtol = NULL;
2531 	FILEDESC_XUNLOCK(fdp);
2532 	if (fdtol != NULL)
2533 		free(fdtol, M_FILEDESC_TO_LEADER);
2534 }
2535 
2536 /*
2537  * Release a filedesc structure.
2538  */
2539 static void
2540 fdescfree_fds(struct thread *td, struct filedesc *fdp)
2541 {
2542 	struct filedesc0 *fdp0;
2543 	struct freetable *ft, *tft;
2544 	struct filedescent *fde;
2545 	struct file *fp;
2546 	int i;
2547 
2548 	KASSERT(refcount_load(&fdp->fd_refcnt) == 0,
2549 	    ("%s: fd table %p carries references", __func__, fdp));
2550 
2551 	/*
2552 	 * Serialize with threads iterating over the table, if any.
2553 	 */
2554 	if (refcount_load(&fdp->fd_holdcnt) > 1) {
2555 		FILEDESC_XLOCK(fdp);
2556 		FILEDESC_XUNLOCK(fdp);
2557 	}
2558 
2559 	FILEDESC_FOREACH_FDE(fdp, i, fde) {
2560 		fp = fde->fde_file;
2561 		fdefree_last(fde);
2562 		(void) closef(fp, td);
2563 	}
2564 
2565 	if (NDSLOTS(fdp->fd_nfiles) > NDSLOTS(NDFILE))
2566 		free(fdp->fd_map, M_FILEDESC);
2567 	if (fdp->fd_nfiles > NDFILE)
2568 		free(fdp->fd_files, M_FILEDESC);
2569 
2570 	fdp0 = (struct filedesc0 *)fdp;
2571 	SLIST_FOREACH_SAFE(ft, &fdp0->fd_free, ft_next, tft)
2572 		free(ft->ft_table, M_FILEDESC);
2573 
2574 	fddrop(fdp);
2575 }
2576 
2577 void
2578 fdescfree(struct thread *td)
2579 {
2580 	struct proc *p;
2581 	struct filedesc *fdp;
2582 
2583 	p = td->td_proc;
2584 	fdp = p->p_fd;
2585 	MPASS(fdp != NULL);
2586 
2587 #ifdef RACCT
2588 	if (RACCT_ENABLED())
2589 		racct_set_unlocked(p, RACCT_NOFILE, 0);
2590 #endif
2591 
2592 	if (p->p_fdtol != NULL)
2593 		fdclearlocks(td);
2594 
2595 	/*
2596 	 * Check fdhold for an explanation.
2597 	 */
2598 	atomic_store_ptr(&p->p_fd, NULL);
2599 	atomic_thread_fence_seq_cst();
2600 	PROC_WAIT_UNLOCKED(p);
2601 
2602 	if (refcount_release(&fdp->fd_refcnt) == 0)
2603 		return;
2604 
2605 	fdescfree_fds(td, fdp);
2606 }
2607 
2608 void
2609 pdescfree(struct thread *td)
2610 {
2611 	struct proc *p;
2612 	struct pwddesc *pdp;
2613 
2614 	p = td->td_proc;
2615 	pdp = p->p_pd;
2616 	MPASS(pdp != NULL);
2617 
2618 	/*
2619 	 * Check pdhold for an explanation.
2620 	 */
2621 	atomic_store_ptr(&p->p_pd, NULL);
2622 	atomic_thread_fence_seq_cst();
2623 	PROC_WAIT_UNLOCKED(p);
2624 
2625 	pddrop(pdp);
2626 }
2627 
2628 /*
2629  * For setugid programs, we don't want to people to use that setugidness
2630  * to generate error messages which write to a file which otherwise would
2631  * otherwise be off-limits to the process.  We check for filesystems where
2632  * the vnode can change out from under us after execve (like [lin]procfs).
2633  *
2634  * Since fdsetugidsafety calls this only for fd 0, 1 and 2, this check is
2635  * sufficient.  We also don't check for setugidness since we know we are.
2636  */
2637 static bool
2638 is_unsafe(struct file *fp)
2639 {
2640 	struct vnode *vp;
2641 
2642 	if (fp->f_type != DTYPE_VNODE)
2643 		return (false);
2644 
2645 	vp = fp->f_vnode;
2646 	return ((vp->v_vflag & VV_PROCDEP) != 0);
2647 }
2648 
2649 /*
2650  * Make this setguid thing safe, if at all possible.
2651  */
2652 void
2653 fdsetugidsafety(struct thread *td)
2654 {
2655 	struct filedesc *fdp;
2656 	struct file *fp;
2657 	int i;
2658 
2659 	fdp = td->td_proc->p_fd;
2660 	KASSERT(refcount_load(&fdp->fd_refcnt) == 1,
2661 	    ("the fdtable should not be shared"));
2662 	MPASS(fdp->fd_nfiles >= 3);
2663 	for (i = 0; i <= 2; i++) {
2664 		fp = fdp->fd_ofiles[i].fde_file;
2665 		if (fp != NULL && is_unsafe(fp)) {
2666 			FILEDESC_XLOCK(fdp);
2667 			knote_fdclose(td, i);
2668 			/*
2669 			 * NULL-out descriptor prior to close to avoid
2670 			 * a race while close blocks.
2671 			 */
2672 			fdfree(fdp, i);
2673 			FILEDESC_XUNLOCK(fdp);
2674 			(void) closef(fp, td);
2675 		}
2676 	}
2677 }
2678 
2679 /*
2680  * If a specific file object occupies a specific file descriptor, close the
2681  * file descriptor entry and drop a reference on the file object.  This is a
2682  * convenience function to handle a subsequent error in a function that calls
2683  * falloc() that handles the race that another thread might have closed the
2684  * file descriptor out from under the thread creating the file object.
2685  */
2686 void
2687 fdclose(struct thread *td, struct file *fp, int idx)
2688 {
2689 	struct filedesc *fdp = td->td_proc->p_fd;
2690 
2691 	FILEDESC_XLOCK(fdp);
2692 	if (fdp->fd_ofiles[idx].fde_file == fp) {
2693 		fdfree(fdp, idx);
2694 		FILEDESC_XUNLOCK(fdp);
2695 		fdrop(fp, td);
2696 	} else
2697 		FILEDESC_XUNLOCK(fdp);
2698 }
2699 
2700 /*
2701  * Close any files on exec?
2702  */
2703 void
2704 fdcloseexec(struct thread *td)
2705 {
2706 	struct filedesc *fdp;
2707 	struct filedescent *fde;
2708 	struct file *fp;
2709 	int i;
2710 
2711 	fdp = td->td_proc->p_fd;
2712 	KASSERT(refcount_load(&fdp->fd_refcnt) == 1,
2713 	    ("the fdtable should not be shared"));
2714 	FILEDESC_FOREACH_FDE(fdp, i, fde) {
2715 		fp = fde->fde_file;
2716 		if (fp->f_type == DTYPE_MQUEUE ||
2717 		    (fde->fde_flags & UF_EXCLOSE)) {
2718 			FILEDESC_XLOCK(fdp);
2719 			fdfree(fdp, i);
2720 			(void) closefp(fdp, i, fp, td, false, false);
2721 			FILEDESC_UNLOCK_ASSERT(fdp);
2722 		}
2723 	}
2724 }
2725 
2726 /*
2727  * It is unsafe for set[ug]id processes to be started with file
2728  * descriptors 0..2 closed, as these descriptors are given implicit
2729  * significance in the Standard C library.  fdcheckstd() will create a
2730  * descriptor referencing /dev/null for each of stdin, stdout, and
2731  * stderr that is not already open.
2732  */
2733 int
2734 fdcheckstd(struct thread *td)
2735 {
2736 	struct filedesc *fdp;
2737 	register_t save;
2738 	int i, error, devnull;
2739 
2740 	fdp = td->td_proc->p_fd;
2741 	KASSERT(refcount_load(&fdp->fd_refcnt) == 1,
2742 	    ("the fdtable should not be shared"));
2743 	MPASS(fdp->fd_nfiles >= 3);
2744 	devnull = -1;
2745 	for (i = 0; i <= 2; i++) {
2746 		if (fdp->fd_ofiles[i].fde_file != NULL)
2747 			continue;
2748 
2749 		save = td->td_retval[0];
2750 		if (devnull != -1) {
2751 			error = kern_dup(td, FDDUP_FIXED, 0, devnull, i);
2752 		} else {
2753 			error = kern_openat(td, AT_FDCWD, "/dev/null",
2754 			    UIO_SYSSPACE, O_RDWR, 0);
2755 			if (error == 0) {
2756 				devnull = td->td_retval[0];
2757 				KASSERT(devnull == i, ("we didn't get our fd"));
2758 			}
2759 		}
2760 		td->td_retval[0] = save;
2761 		if (error != 0)
2762 			return (error);
2763 	}
2764 	return (0);
2765 }
2766 
2767 /*
2768  * Internal form of close.  Decrement reference count on file structure.
2769  * Note: td may be NULL when closing a file that was being passed in a
2770  * message.
2771  */
2772 int
2773 closef(struct file *fp, struct thread *td)
2774 {
2775 	struct vnode *vp;
2776 	struct flock lf;
2777 	struct filedesc_to_leader *fdtol;
2778 	struct filedesc *fdp;
2779 
2780 	MPASS(td != NULL);
2781 
2782 	/*
2783 	 * POSIX record locking dictates that any close releases ALL
2784 	 * locks owned by this process.  This is handled by setting
2785 	 * a flag in the unlock to free ONLY locks obeying POSIX
2786 	 * semantics, and not to free BSD-style file locks.
2787 	 * If the descriptor was in a message, POSIX-style locks
2788 	 * aren't passed with the descriptor, and the thread pointer
2789 	 * will be NULL.  Callers should be careful only to pass a
2790 	 * NULL thread pointer when there really is no owning
2791 	 * context that might have locks, or the locks will be
2792 	 * leaked.
2793 	 */
2794 	if (fp->f_type == DTYPE_VNODE) {
2795 		vp = fp->f_vnode;
2796 		if ((td->td_proc->p_leader->p_flag & P_ADVLOCK) != 0) {
2797 			lf.l_whence = SEEK_SET;
2798 			lf.l_start = 0;
2799 			lf.l_len = 0;
2800 			lf.l_type = F_UNLCK;
2801 			(void) VOP_ADVLOCK(vp, (caddr_t)td->td_proc->p_leader,
2802 			    F_UNLCK, &lf, F_POSIX);
2803 		}
2804 		fdtol = td->td_proc->p_fdtol;
2805 		if (fdtol != NULL) {
2806 			/*
2807 			 * Handle special case where file descriptor table is
2808 			 * shared between multiple process leaders.
2809 			 */
2810 			fdp = td->td_proc->p_fd;
2811 			FILEDESC_XLOCK(fdp);
2812 			for (fdtol = fdtol->fdl_next;
2813 			    fdtol != td->td_proc->p_fdtol;
2814 			    fdtol = fdtol->fdl_next) {
2815 				if ((fdtol->fdl_leader->p_flag &
2816 				    P_ADVLOCK) == 0)
2817 					continue;
2818 				fdtol->fdl_holdcount++;
2819 				FILEDESC_XUNLOCK(fdp);
2820 				lf.l_whence = SEEK_SET;
2821 				lf.l_start = 0;
2822 				lf.l_len = 0;
2823 				lf.l_type = F_UNLCK;
2824 				vp = fp->f_vnode;
2825 				(void) VOP_ADVLOCK(vp,
2826 				    (caddr_t)fdtol->fdl_leader, F_UNLCK, &lf,
2827 				    F_POSIX);
2828 				FILEDESC_XLOCK(fdp);
2829 				fdtol->fdl_holdcount--;
2830 				if (fdtol->fdl_holdcount == 0 &&
2831 				    fdtol->fdl_wakeup != 0) {
2832 					fdtol->fdl_wakeup = 0;
2833 					wakeup(fdtol);
2834 				}
2835 			}
2836 			FILEDESC_XUNLOCK(fdp);
2837 		}
2838 	}
2839 	return (fdrop_close(fp, td));
2840 }
2841 
2842 /*
2843  * Hack for file descriptor passing code.
2844  */
2845 void
2846 closef_nothread(struct file *fp)
2847 {
2848 
2849 	fdrop(fp, NULL);
2850 }
2851 
2852 /*
2853  * Initialize the file pointer with the specified properties.
2854  *
2855  * The ops are set with release semantics to be certain that the flags, type,
2856  * and data are visible when ops is.  This is to prevent ops methods from being
2857  * called with bad data.
2858  */
2859 void
2860 finit(struct file *fp, u_int flag, short type, void *data, struct fileops *ops)
2861 {
2862 	fp->f_data = data;
2863 	fp->f_flag = flag;
2864 	fp->f_type = type;
2865 	atomic_store_rel_ptr((volatile uintptr_t *)&fp->f_ops, (uintptr_t)ops);
2866 }
2867 
2868 void
2869 finit_vnode(struct file *fp, u_int flag, void *data, struct fileops *ops)
2870 {
2871 	fp->f_seqcount[UIO_READ] = 1;
2872 	fp->f_seqcount[UIO_WRITE] = 1;
2873 	finit(fp, (flag & FMASK) | (fp->f_flag & FHASLOCK), DTYPE_VNODE,
2874 	    data, ops);
2875 }
2876 
2877 int
2878 fget_cap_noref(struct filedesc *fdp, int fd, cap_rights_t *needrightsp,
2879     struct file **fpp, struct filecaps *havecapsp)
2880 {
2881 	struct filedescent *fde;
2882 	int error;
2883 
2884 	FILEDESC_LOCK_ASSERT(fdp);
2885 
2886 	*fpp = NULL;
2887 	fde = fdeget_noref(fdp, fd);
2888 	if (fde == NULL) {
2889 		error = EBADF;
2890 		goto out;
2891 	}
2892 
2893 #ifdef CAPABILITIES
2894 	error = cap_check(cap_rights_fde_inline(fde), needrightsp);
2895 	if (error != 0)
2896 		goto out;
2897 #endif
2898 
2899 	if (havecapsp != NULL)
2900 		filecaps_copy(&fde->fde_caps, havecapsp, true);
2901 
2902 	*fpp = fde->fde_file;
2903 
2904 	error = 0;
2905 out:
2906 	return (error);
2907 }
2908 
2909 #ifdef CAPABILITIES
2910 int
2911 fget_cap(struct thread *td, int fd, cap_rights_t *needrightsp,
2912     struct file **fpp, struct filecaps *havecapsp)
2913 {
2914 	struct filedesc *fdp = td->td_proc->p_fd;
2915 	int error;
2916 	struct file *fp;
2917 	seqc_t seq;
2918 
2919 	*fpp = NULL;
2920 	for (;;) {
2921 		error = fget_unlocked_seq(td, fd, needrightsp, &fp, &seq);
2922 		if (error != 0)
2923 			return (error);
2924 
2925 		if (havecapsp != NULL) {
2926 			if (!filecaps_copy(&fdp->fd_ofiles[fd].fde_caps,
2927 			    havecapsp, false)) {
2928 				fdrop(fp, td);
2929 				goto get_locked;
2930 			}
2931 		}
2932 
2933 		if (!fd_modified(fdp, fd, seq))
2934 			break;
2935 		fdrop(fp, td);
2936 	}
2937 
2938 	*fpp = fp;
2939 	return (0);
2940 
2941 get_locked:
2942 	FILEDESC_SLOCK(fdp);
2943 	error = fget_cap_noref(fdp, fd, needrightsp, fpp, havecapsp);
2944 	if (error == 0 && !fhold(*fpp))
2945 		error = EBADF;
2946 	FILEDESC_SUNLOCK(fdp);
2947 	return (error);
2948 }
2949 #else
2950 int
2951 fget_cap(struct thread *td, int fd, cap_rights_t *needrightsp,
2952     struct file **fpp, struct filecaps *havecapsp)
2953 {
2954 	int error;
2955 	error = fget_unlocked(td, fd, needrightsp, fpp);
2956 	if (havecapsp != NULL && error == 0)
2957 		filecaps_fill(havecapsp);
2958 
2959 	return (error);
2960 }
2961 #endif
2962 
2963 #ifdef CAPABILITIES
2964 int
2965 fgetvp_lookup_smr(struct nameidata *ndp, struct vnode **vpp, bool *fsearch)
2966 {
2967 	const struct filedescent *fde;
2968 	const struct fdescenttbl *fdt;
2969 	struct filedesc *fdp;
2970 	struct file *fp;
2971 	struct vnode *vp;
2972 	const cap_rights_t *haverights;
2973 	cap_rights_t rights;
2974 	seqc_t seq;
2975 	int fd;
2976 
2977 	VFS_SMR_ASSERT_ENTERED();
2978 
2979 	fd = ndp->ni_dirfd;
2980 	rights = *ndp->ni_rightsneeded;
2981 	cap_rights_set_one(&rights, CAP_LOOKUP);
2982 
2983 	fdp = curproc->p_fd;
2984 	fdt = fdp->fd_files;
2985 	if (__predict_false((u_int)fd >= fdt->fdt_nfiles))
2986 		return (EBADF);
2987 	seq = seqc_read_notmodify(fd_seqc(fdt, fd));
2988 	fde = &fdt->fdt_ofiles[fd];
2989 	haverights = cap_rights_fde_inline(fde);
2990 	fp = fde->fde_file;
2991 	if (__predict_false(fp == NULL))
2992 		return (EAGAIN);
2993 	if (__predict_false(cap_check_inline_transient(haverights, &rights)))
2994 		return (EAGAIN);
2995 	*fsearch = ((fp->f_flag & FSEARCH) != 0);
2996 	vp = fp->f_vnode;
2997 	if (__predict_false(vp == NULL)) {
2998 		return (EAGAIN);
2999 	}
3000 	if (!filecaps_copy(&fde->fde_caps, &ndp->ni_filecaps, false)) {
3001 		return (EAGAIN);
3002 	}
3003 	/*
3004 	 * Use an acquire barrier to force re-reading of fdt so it is
3005 	 * refreshed for verification.
3006 	 */
3007 	atomic_thread_fence_acq();
3008 	fdt = fdp->fd_files;
3009 	if (__predict_false(!seqc_consistent_no_fence(fd_seqc(fdt, fd), seq)))
3010 		return (EAGAIN);
3011 	/*
3012 	 * If file descriptor doesn't have all rights,
3013 	 * all lookups relative to it must also be
3014 	 * strictly relative.
3015 	 *
3016 	 * Not yet supported by fast path.
3017 	 */
3018 	CAP_ALL(&rights);
3019 	if (!cap_rights_contains(&ndp->ni_filecaps.fc_rights, &rights) ||
3020 	    ndp->ni_filecaps.fc_fcntls != CAP_FCNTL_ALL ||
3021 	    ndp->ni_filecaps.fc_nioctls != -1) {
3022 #ifdef notyet
3023 		ndp->ni_lcf |= NI_LCF_STRICTRELATIVE;
3024 #else
3025 		return (EAGAIN);
3026 #endif
3027 	}
3028 	*vpp = vp;
3029 	return (0);
3030 }
3031 #else
3032 int
3033 fgetvp_lookup_smr(struct nameidata *ndp, struct vnode **vpp, bool *fsearch)
3034 {
3035 	const struct fdescenttbl *fdt;
3036 	struct filedesc *fdp;
3037 	struct file *fp;
3038 	struct vnode *vp;
3039 	int fd;
3040 
3041 	VFS_SMR_ASSERT_ENTERED();
3042 
3043 	fd = ndp->ni_dirfd;
3044 	fdp = curproc->p_fd;
3045 	fdt = fdp->fd_files;
3046 	if (__predict_false((u_int)fd >= fdt->fdt_nfiles))
3047 		return (EBADF);
3048 	fp = fdt->fdt_ofiles[fd].fde_file;
3049 	if (__predict_false(fp == NULL))
3050 		return (EAGAIN);
3051 	*fsearch = ((fp->f_flag & FSEARCH) != 0);
3052 	vp = fp->f_vnode;
3053 	if (__predict_false(vp == NULL || vp->v_type != VDIR)) {
3054 		return (EAGAIN);
3055 	}
3056 	/*
3057 	 * Use an acquire barrier to force re-reading of fdt so it is
3058 	 * refreshed for verification.
3059 	 */
3060 	atomic_thread_fence_acq();
3061 	fdt = fdp->fd_files;
3062 	if (__predict_false(fp != fdt->fdt_ofiles[fd].fde_file))
3063 		return (EAGAIN);
3064 	filecaps_fill(&ndp->ni_filecaps);
3065 	*vpp = vp;
3066 	return (0);
3067 }
3068 #endif
3069 
3070 int
3071 fgetvp_lookup(struct nameidata *ndp, struct vnode **vpp)
3072 {
3073 	struct thread *td;
3074 	struct file *fp;
3075 	struct vnode *vp;
3076 	struct componentname *cnp;
3077 	cap_rights_t rights;
3078 	int error;
3079 
3080 	td = curthread;
3081 	rights = *ndp->ni_rightsneeded;
3082 	cap_rights_set_one(&rights, CAP_LOOKUP);
3083 	cnp = &ndp->ni_cnd;
3084 
3085 	error = fget_cap(td, ndp->ni_dirfd, &rights, &fp, &ndp->ni_filecaps);
3086 	if (__predict_false(error != 0))
3087 		return (error);
3088 	if (__predict_false(fp->f_ops == &badfileops)) {
3089 		error = EBADF;
3090 		goto out_free;
3091 	}
3092 	vp = fp->f_vnode;
3093 	if (__predict_false(vp == NULL)) {
3094 		error = ENOTDIR;
3095 		goto out_free;
3096 	}
3097 	vrefact(vp);
3098 	/*
3099 	 * XXX does not check for VDIR, handled by namei_setup
3100 	 */
3101 	if ((fp->f_flag & FSEARCH) != 0)
3102 		cnp->cn_flags |= NOEXECCHECK;
3103 	fdrop(fp, td);
3104 
3105 #ifdef CAPABILITIES
3106 	/*
3107 	 * If file descriptor doesn't have all rights,
3108 	 * all lookups relative to it must also be
3109 	 * strictly relative.
3110 	 */
3111 	CAP_ALL(&rights);
3112 	if (!cap_rights_contains(&ndp->ni_filecaps.fc_rights, &rights) ||
3113 	    ndp->ni_filecaps.fc_fcntls != CAP_FCNTL_ALL ||
3114 	    ndp->ni_filecaps.fc_nioctls != -1) {
3115 		ndp->ni_lcf |= NI_LCF_STRICTRELATIVE;
3116 		ndp->ni_resflags |= NIRES_STRICTREL;
3117 	}
3118 #endif
3119 
3120 	/*
3121 	 * TODO: avoid copying ioctl caps if it can be helped to begin with
3122 	 */
3123 	if ((cnp->cn_flags & WANTIOCTLCAPS) == 0)
3124 		filecaps_free_ioctl(&ndp->ni_filecaps);
3125 
3126 	*vpp = vp;
3127 	return (0);
3128 
3129 out_free:
3130 	filecaps_free(&ndp->ni_filecaps);
3131 	fdrop(fp, td);
3132 	return (error);
3133 }
3134 
3135 /*
3136  * Fetch the descriptor locklessly.
3137  *
3138  * We avoid fdrop() races by never raising a refcount above 0.  To accomplish
3139  * this we have to use a cmpset loop rather than an atomic_add.  The descriptor
3140  * must be re-verified once we acquire a reference to be certain that the
3141  * identity is still correct and we did not lose a race due to preemption.
3142  *
3143  * Force a reload of fdt when looping. Another thread could reallocate
3144  * the table before this fd was closed, so it is possible that there is
3145  * a stale fp pointer in cached version.
3146  */
3147 #ifdef CAPABILITIES
3148 static int
3149 fget_unlocked_seq(struct thread *td, int fd, cap_rights_t *needrightsp,
3150     struct file **fpp, seqc_t *seqp)
3151 {
3152 	struct filedesc *fdp;
3153 	const struct filedescent *fde;
3154 	const struct fdescenttbl *fdt;
3155 	struct file *fp;
3156 	seqc_t seq;
3157 	cap_rights_t haverights;
3158 	int error;
3159 
3160 	fdp = td->td_proc->p_fd;
3161 	fdt = fdp->fd_files;
3162 	if (__predict_false((u_int)fd >= fdt->fdt_nfiles))
3163 		return (EBADF);
3164 
3165 	for (;;) {
3166 		seq = seqc_read_notmodify(fd_seqc(fdt, fd));
3167 		fde = &fdt->fdt_ofiles[fd];
3168 		haverights = *cap_rights_fde_inline(fde);
3169 		fp = fde->fde_file;
3170 		if (__predict_false(fp == NULL)) {
3171 			if (seqc_consistent(fd_seqc(fdt, fd), seq))
3172 				return (EBADF);
3173 			fdt = atomic_load_ptr(&fdp->fd_files);
3174 			continue;
3175 		}
3176 		error = cap_check_inline(&haverights, needrightsp);
3177 		if (__predict_false(error != 0)) {
3178 			if (seqc_consistent(fd_seqc(fdt, fd), seq))
3179 				return (error);
3180 			fdt = atomic_load_ptr(&fdp->fd_files);
3181 			continue;
3182 		}
3183 		if (__predict_false(!refcount_acquire_if_not_zero(&fp->f_count))) {
3184 			fdt = atomic_load_ptr(&fdp->fd_files);
3185 			continue;
3186 		}
3187 		/*
3188 		 * Use an acquire barrier to force re-reading of fdt so it is
3189 		 * refreshed for verification.
3190 		 */
3191 		atomic_thread_fence_acq();
3192 		fdt = fdp->fd_files;
3193 		if (seqc_consistent_no_fence(fd_seqc(fdt, fd), seq))
3194 			break;
3195 		fdrop(fp, td);
3196 	}
3197 	*fpp = fp;
3198 	if (seqp != NULL) {
3199 		*seqp = seq;
3200 	}
3201 	return (0);
3202 }
3203 #else
3204 static int
3205 fget_unlocked_seq(struct thread *td, int fd, cap_rights_t *needrightsp,
3206     struct file **fpp, seqc_t *seqp __unused)
3207 {
3208 	struct filedesc *fdp;
3209 	const struct fdescenttbl *fdt;
3210 	struct file *fp;
3211 
3212 	fdp = td->td_proc->p_fd;
3213 	fdt = fdp->fd_files;
3214 	if (__predict_false((u_int)fd >= fdt->fdt_nfiles))
3215 		return (EBADF);
3216 
3217 	for (;;) {
3218 		fp = fdt->fdt_ofiles[fd].fde_file;
3219 		if (__predict_false(fp == NULL))
3220 			return (EBADF);
3221 		if (__predict_false(!refcount_acquire_if_not_zero(&fp->f_count))) {
3222 			fdt = atomic_load_ptr(&fdp->fd_files);
3223 			continue;
3224 		}
3225 		/*
3226 		 * Use an acquire barrier to force re-reading of fdt so it is
3227 		 * refreshed for verification.
3228 		 */
3229 		atomic_thread_fence_acq();
3230 		fdt = fdp->fd_files;
3231 		if (__predict_true(fp == fdt->fdt_ofiles[fd].fde_file))
3232 			break;
3233 		fdrop(fp, td);
3234 	}
3235 	*fpp = fp;
3236 	return (0);
3237 }
3238 #endif
3239 
3240 /*
3241  * See the comments in fget_unlocked_seq for an explanation of how this works.
3242  *
3243  * This is a simplified variant which bails out to the aforementioned routine
3244  * if anything goes wrong. In practice this only happens when userspace is
3245  * racing with itself.
3246  */
3247 int
3248 fget_unlocked(struct thread *td, int fd, cap_rights_t *needrightsp,
3249     struct file **fpp)
3250 {
3251 	struct filedesc *fdp;
3252 #ifdef CAPABILITIES
3253 	const struct filedescent *fde;
3254 #endif
3255 	const struct fdescenttbl *fdt;
3256 	struct file *fp;
3257 #ifdef CAPABILITIES
3258 	seqc_t seq;
3259 	const cap_rights_t *haverights;
3260 #endif
3261 
3262 	fdp = td->td_proc->p_fd;
3263 	fdt = fdp->fd_files;
3264 	if (__predict_false((u_int)fd >= fdt->fdt_nfiles)) {
3265 		*fpp = NULL;
3266 		return (EBADF);
3267 	}
3268 #ifdef CAPABILITIES
3269 	seq = seqc_read_notmodify(fd_seqc(fdt, fd));
3270 	fde = &fdt->fdt_ofiles[fd];
3271 	haverights = cap_rights_fde_inline(fde);
3272 	fp = fde->fde_file;
3273 #else
3274 	fp = fdt->fdt_ofiles[fd].fde_file;
3275 #endif
3276 	if (__predict_false(fp == NULL))
3277 		goto out_fallback;
3278 #ifdef CAPABILITIES
3279 	if (__predict_false(cap_check_inline_transient(haverights, needrightsp)))
3280 		goto out_fallback;
3281 #endif
3282 	if (__predict_false(!refcount_acquire_if_not_zero(&fp->f_count)))
3283 		goto out_fallback;
3284 
3285 	/*
3286 	 * Use an acquire barrier to force re-reading of fdt so it is
3287 	 * refreshed for verification.
3288 	 */
3289 	atomic_thread_fence_acq();
3290 	fdt = fdp->fd_files;
3291 #ifdef	CAPABILITIES
3292 	if (__predict_false(!seqc_consistent_no_fence(fd_seqc(fdt, fd), seq)))
3293 #else
3294 	if (__predict_false(fp != fdt->fdt_ofiles[fd].fde_file))
3295 #endif
3296 		goto out_fdrop;
3297 	*fpp = fp;
3298 	return (0);
3299 out_fdrop:
3300 	fdrop(fp, td);
3301 out_fallback:
3302 	*fpp = NULL;
3303 	return (fget_unlocked_seq(td, fd, needrightsp, fpp, NULL));
3304 }
3305 
3306 /*
3307  * Translate fd -> file when the caller guarantees the file descriptor table
3308  * can't be changed by others.
3309  *
3310  * Note this does not mean the file object itself is only visible to the caller,
3311  * merely that it wont disappear without having to be referenced.
3312  *
3313  * Must be paired with fput_only_user.
3314  */
3315 #ifdef	CAPABILITIES
3316 int
3317 fget_only_user(struct filedesc *fdp, int fd, cap_rights_t *needrightsp,
3318     struct file **fpp)
3319 {
3320 	const struct filedescent *fde;
3321 	const struct fdescenttbl *fdt;
3322 	const cap_rights_t *haverights;
3323 	struct file *fp;
3324 	int error;
3325 
3326 	MPASS(FILEDESC_IS_ONLY_USER(fdp));
3327 
3328 	*fpp = NULL;
3329 	if (__predict_false(fd >= fdp->fd_nfiles))
3330 		return (EBADF);
3331 
3332 	fdt = fdp->fd_files;
3333 	fde = &fdt->fdt_ofiles[fd];
3334 	fp = fde->fde_file;
3335 	if (__predict_false(fp == NULL))
3336 		return (EBADF);
3337 	MPASS(refcount_load(&fp->f_count) > 0);
3338 	haverights = cap_rights_fde_inline(fde);
3339 	error = cap_check_inline(haverights, needrightsp);
3340 	if (__predict_false(error != 0))
3341 		return (error);
3342 	*fpp = fp;
3343 	return (0);
3344 }
3345 #else
3346 int
3347 fget_only_user(struct filedesc *fdp, int fd, cap_rights_t *needrightsp,
3348     struct file **fpp)
3349 {
3350 	struct file *fp;
3351 
3352 	MPASS(FILEDESC_IS_ONLY_USER(fdp));
3353 
3354 	*fpp = NULL;
3355 	if (__predict_false(fd >= fdp->fd_nfiles))
3356 		return (EBADF);
3357 
3358 	fp = fdp->fd_ofiles[fd].fde_file;
3359 	if (__predict_false(fp == NULL))
3360 		return (EBADF);
3361 
3362 	MPASS(refcount_load(&fp->f_count) > 0);
3363 	*fpp = fp;
3364 	return (0);
3365 }
3366 #endif
3367 
3368 /*
3369  * Extract the file pointer associated with the specified descriptor for the
3370  * current user process.
3371  *
3372  * If the descriptor doesn't exist or doesn't match 'flags', EBADF is
3373  * returned.
3374  *
3375  * File's rights will be checked against the capability rights mask.
3376  *
3377  * If an error occurred the non-zero error is returned and *fpp is set to
3378  * NULL.  Otherwise *fpp is held and set and zero is returned.  Caller is
3379  * responsible for fdrop().
3380  */
3381 static __inline int
3382 _fget(struct thread *td, int fd, struct file **fpp, int flags,
3383     cap_rights_t *needrightsp)
3384 {
3385 	struct file *fp;
3386 	int error;
3387 
3388 	*fpp = NULL;
3389 	error = fget_unlocked(td, fd, needrightsp, &fp);
3390 	if (__predict_false(error != 0))
3391 		return (error);
3392 	if (__predict_false(fp->f_ops == &badfileops)) {
3393 		fdrop(fp, td);
3394 		return (EBADF);
3395 	}
3396 
3397 	/*
3398 	 * FREAD and FWRITE failure return EBADF as per POSIX.
3399 	 */
3400 	error = 0;
3401 	switch (flags) {
3402 	case FREAD:
3403 	case FWRITE:
3404 		if ((fp->f_flag & flags) == 0)
3405 			error = EBADF;
3406 		break;
3407 	case FEXEC:
3408 		if (fp->f_ops != &path_fileops &&
3409 		    ((fp->f_flag & (FREAD | FEXEC)) == 0 ||
3410 		    (fp->f_flag & FWRITE) != 0))
3411 			error = EBADF;
3412 		break;
3413 	case 0:
3414 		break;
3415 	default:
3416 		KASSERT(0, ("wrong flags"));
3417 	}
3418 
3419 	if (error != 0) {
3420 		fdrop(fp, td);
3421 		return (error);
3422 	}
3423 
3424 	*fpp = fp;
3425 	return (0);
3426 }
3427 
3428 int
3429 fget(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp)
3430 {
3431 
3432 	return (_fget(td, fd, fpp, 0, rightsp));
3433 }
3434 
3435 int
3436 fget_mmap(struct thread *td, int fd, cap_rights_t *rightsp, vm_prot_t *maxprotp,
3437     struct file **fpp)
3438 {
3439 	int error;
3440 #ifndef CAPABILITIES
3441 	error = _fget(td, fd, fpp, 0, rightsp);
3442 	if (maxprotp != NULL)
3443 		*maxprotp = VM_PROT_ALL;
3444 	return (error);
3445 #else
3446 	cap_rights_t fdrights;
3447 	struct filedesc *fdp;
3448 	struct file *fp;
3449 	seqc_t seq;
3450 
3451 	*fpp = NULL;
3452 	fdp = td->td_proc->p_fd;
3453 	MPASS(cap_rights_is_set(rightsp, CAP_MMAP));
3454 	for (;;) {
3455 		error = fget_unlocked_seq(td, fd, rightsp, &fp, &seq);
3456 		if (__predict_false(error != 0))
3457 			return (error);
3458 		if (__predict_false(fp->f_ops == &badfileops)) {
3459 			fdrop(fp, td);
3460 			return (EBADF);
3461 		}
3462 		if (maxprotp != NULL)
3463 			fdrights = *cap_rights(fdp, fd);
3464 		if (!fd_modified(fdp, fd, seq))
3465 			break;
3466 		fdrop(fp, td);
3467 	}
3468 
3469 	/*
3470 	 * If requested, convert capability rights to access flags.
3471 	 */
3472 	if (maxprotp != NULL)
3473 		*maxprotp = cap_rights_to_vmprot(&fdrights);
3474 	*fpp = fp;
3475 	return (0);
3476 #endif
3477 }
3478 
3479 int
3480 fget_read(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp)
3481 {
3482 
3483 	return (_fget(td, fd, fpp, FREAD, rightsp));
3484 }
3485 
3486 int
3487 fget_write(struct thread *td, int fd, cap_rights_t *rightsp, struct file **fpp)
3488 {
3489 
3490 	return (_fget(td, fd, fpp, FWRITE, rightsp));
3491 }
3492 
3493 int
3494 fget_fcntl(struct thread *td, int fd, cap_rights_t *rightsp, int needfcntl,
3495     struct file **fpp)
3496 {
3497 #ifndef CAPABILITIES
3498 	return (fget_unlocked(td, fd, rightsp, fpp));
3499 #else
3500 	struct filedesc *fdp = td->td_proc->p_fd;
3501 	struct file *fp;
3502 	int error;
3503 	seqc_t seq;
3504 
3505 	*fpp = NULL;
3506 	MPASS(cap_rights_is_set(rightsp, CAP_FCNTL));
3507 	for (;;) {
3508 		error = fget_unlocked_seq(td, fd, rightsp, &fp, &seq);
3509 		if (error != 0)
3510 			return (error);
3511 		error = cap_fcntl_check(fdp, fd, needfcntl);
3512 		if (!fd_modified(fdp, fd, seq))
3513 			break;
3514 		fdrop(fp, td);
3515 	}
3516 	if (error != 0) {
3517 		fdrop(fp, td);
3518 		return (error);
3519 	}
3520 	*fpp = fp;
3521 	return (0);
3522 #endif
3523 }
3524 
3525 /*
3526  * Like fget() but loads the underlying vnode, or returns an error if the
3527  * descriptor does not represent a vnode.  Note that pipes use vnodes but
3528  * never have VM objects.  The returned vnode will be vref()'d.
3529  *
3530  * XXX: what about the unused flags ?
3531  */
3532 static __inline int
3533 _fgetvp(struct thread *td, int fd, int flags, cap_rights_t *needrightsp,
3534     struct vnode **vpp)
3535 {
3536 	struct file *fp;
3537 	int error;
3538 
3539 	*vpp = NULL;
3540 	error = _fget(td, fd, &fp, flags, needrightsp);
3541 	if (error != 0)
3542 		return (error);
3543 	if (fp->f_vnode == NULL) {
3544 		error = EINVAL;
3545 	} else {
3546 		*vpp = fp->f_vnode;
3547 		vrefact(*vpp);
3548 	}
3549 	fdrop(fp, td);
3550 
3551 	return (error);
3552 }
3553 
3554 int
3555 fgetvp(struct thread *td, int fd, cap_rights_t *rightsp, struct vnode **vpp)
3556 {
3557 
3558 	return (_fgetvp(td, fd, 0, rightsp, vpp));
3559 }
3560 
3561 int
3562 fgetvp_rights(struct thread *td, int fd, cap_rights_t *needrightsp,
3563     struct filecaps *havecaps, struct vnode **vpp)
3564 {
3565 	struct filecaps caps;
3566 	struct file *fp;
3567 	int error;
3568 
3569 	error = fget_cap(td, fd, needrightsp, &fp, &caps);
3570 	if (error != 0)
3571 		return (error);
3572 	if (fp->f_ops == &badfileops) {
3573 		error = EBADF;
3574 		goto out;
3575 	}
3576 	if (fp->f_vnode == NULL) {
3577 		error = EINVAL;
3578 		goto out;
3579 	}
3580 
3581 	*havecaps = caps;
3582 	*vpp = fp->f_vnode;
3583 	vrefact(*vpp);
3584 	fdrop(fp, td);
3585 
3586 	return (0);
3587 out:
3588 	filecaps_free(&caps);
3589 	fdrop(fp, td);
3590 	return (error);
3591 }
3592 
3593 int
3594 fgetvp_read(struct thread *td, int fd, cap_rights_t *rightsp, struct vnode **vpp)
3595 {
3596 
3597 	return (_fgetvp(td, fd, FREAD, rightsp, vpp));
3598 }
3599 
3600 int
3601 fgetvp_exec(struct thread *td, int fd, cap_rights_t *rightsp, struct vnode **vpp)
3602 {
3603 
3604 	return (_fgetvp(td, fd, FEXEC, rightsp, vpp));
3605 }
3606 
3607 #ifdef notyet
3608 int
3609 fgetvp_write(struct thread *td, int fd, cap_rights_t *rightsp,
3610     struct vnode **vpp)
3611 {
3612 
3613 	return (_fgetvp(td, fd, FWRITE, rightsp, vpp));
3614 }
3615 #endif
3616 
3617 /*
3618  * Handle the last reference to a file being closed.
3619  *
3620  * Without the noinline attribute clang keeps inlining the func thorough this
3621  * file when fdrop is used.
3622  */
3623 int __noinline
3624 _fdrop(struct file *fp, struct thread *td)
3625 {
3626 	int error;
3627 #ifdef INVARIANTS
3628 	int count;
3629 
3630 	count = refcount_load(&fp->f_count);
3631 	if (count != 0)
3632 		panic("fdrop: fp %p count %d", fp, count);
3633 #endif
3634 	error = fo_close(fp, td);
3635 	atomic_subtract_int(&openfiles, 1);
3636 	crfree(fp->f_cred);
3637 	free(fp->f_advice, M_FADVISE);
3638 	uma_zfree(file_zone, fp);
3639 
3640 	return (error);
3641 }
3642 
3643 /*
3644  * Apply an advisory lock on a file descriptor.
3645  *
3646  * Just attempt to get a record lock of the requested type on the entire file
3647  * (l_whence = SEEK_SET, l_start = 0, l_len = 0).
3648  */
3649 #ifndef _SYS_SYSPROTO_H_
3650 struct flock_args {
3651 	int	fd;
3652 	int	how;
3653 };
3654 #endif
3655 /* ARGSUSED */
3656 int
3657 sys_flock(struct thread *td, struct flock_args *uap)
3658 {
3659 	struct file *fp;
3660 	struct vnode *vp;
3661 	struct flock lf;
3662 	int error;
3663 
3664 	error = fget(td, uap->fd, &cap_flock_rights, &fp);
3665 	if (error != 0)
3666 		return (error);
3667 	error = EOPNOTSUPP;
3668 	if (fp->f_type != DTYPE_VNODE && fp->f_type != DTYPE_FIFO) {
3669 		goto done;
3670 	}
3671 	if (fp->f_ops == &path_fileops) {
3672 		goto done;
3673 	}
3674 
3675 	error = 0;
3676 	vp = fp->f_vnode;
3677 	lf.l_whence = SEEK_SET;
3678 	lf.l_start = 0;
3679 	lf.l_len = 0;
3680 	if (uap->how & LOCK_UN) {
3681 		lf.l_type = F_UNLCK;
3682 		atomic_clear_int(&fp->f_flag, FHASLOCK);
3683 		error = VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK);
3684 		goto done;
3685 	}
3686 	if (uap->how & LOCK_EX)
3687 		lf.l_type = F_WRLCK;
3688 	else if (uap->how & LOCK_SH)
3689 		lf.l_type = F_RDLCK;
3690 	else {
3691 		error = EBADF;
3692 		goto done;
3693 	}
3694 	atomic_set_int(&fp->f_flag, FHASLOCK);
3695 	error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf,
3696 	    (uap->how & LOCK_NB) ? F_FLOCK : F_FLOCK | F_WAIT);
3697 done:
3698 	fdrop(fp, td);
3699 	return (error);
3700 }
3701 /*
3702  * Duplicate the specified descriptor to a free descriptor.
3703  */
3704 int
3705 dupfdopen(struct thread *td, struct filedesc *fdp, int dfd, int mode,
3706     int openerror, int *indxp)
3707 {
3708 	struct filedescent *newfde, *oldfde;
3709 	struct file *fp;
3710 	u_long *ioctls;
3711 	int error, indx;
3712 
3713 	KASSERT(openerror == ENODEV || openerror == ENXIO,
3714 	    ("unexpected error %d in %s", openerror, __func__));
3715 
3716 	/*
3717 	 * If the to-be-dup'd fd number is greater than the allowed number
3718 	 * of file descriptors, or the fd to be dup'd has already been
3719 	 * closed, then reject.
3720 	 */
3721 	FILEDESC_XLOCK(fdp);
3722 	if ((fp = fget_noref(fdp, dfd)) == NULL) {
3723 		FILEDESC_XUNLOCK(fdp);
3724 		return (EBADF);
3725 	}
3726 
3727 	error = fdalloc(td, 0, &indx);
3728 	if (error != 0) {
3729 		FILEDESC_XUNLOCK(fdp);
3730 		return (error);
3731 	}
3732 
3733 	/*
3734 	 * There are two cases of interest here.
3735 	 *
3736 	 * For ENODEV simply dup (dfd) to file descriptor (indx) and return.
3737 	 *
3738 	 * For ENXIO steal away the file structure from (dfd) and store it in
3739 	 * (indx).  (dfd) is effectively closed by this operation.
3740 	 */
3741 	switch (openerror) {
3742 	case ENODEV:
3743 		/*
3744 		 * Check that the mode the file is being opened for is a
3745 		 * subset of the mode of the existing descriptor.
3746 		 */
3747 		if (((mode & (FREAD|FWRITE)) | fp->f_flag) != fp->f_flag) {
3748 			fdunused(fdp, indx);
3749 			FILEDESC_XUNLOCK(fdp);
3750 			return (EACCES);
3751 		}
3752 		if (!fhold(fp)) {
3753 			fdunused(fdp, indx);
3754 			FILEDESC_XUNLOCK(fdp);
3755 			return (EBADF);
3756 		}
3757 		newfde = &fdp->fd_ofiles[indx];
3758 		oldfde = &fdp->fd_ofiles[dfd];
3759 		ioctls = filecaps_copy_prep(&oldfde->fde_caps);
3760 #ifdef CAPABILITIES
3761 		seqc_write_begin(&newfde->fde_seqc);
3762 #endif
3763 		fde_copy(oldfde, newfde);
3764 		filecaps_copy_finish(&oldfde->fde_caps, &newfde->fde_caps,
3765 		    ioctls);
3766 #ifdef CAPABILITIES
3767 		seqc_write_end(&newfde->fde_seqc);
3768 #endif
3769 		break;
3770 	case ENXIO:
3771 		/*
3772 		 * Steal away the file pointer from dfd and stuff it into indx.
3773 		 */
3774 		newfde = &fdp->fd_ofiles[indx];
3775 		oldfde = &fdp->fd_ofiles[dfd];
3776 #ifdef CAPABILITIES
3777 		seqc_write_begin(&oldfde->fde_seqc);
3778 		seqc_write_begin(&newfde->fde_seqc);
3779 #endif
3780 		fde_copy(oldfde, newfde);
3781 		oldfde->fde_file = NULL;
3782 		fdunused(fdp, dfd);
3783 #ifdef CAPABILITIES
3784 		seqc_write_end(&newfde->fde_seqc);
3785 		seqc_write_end(&oldfde->fde_seqc);
3786 #endif
3787 		break;
3788 	}
3789 	FILEDESC_XUNLOCK(fdp);
3790 	*indxp = indx;
3791 	return (0);
3792 }
3793 
3794 /*
3795  * This sysctl determines if we will allow a process to chroot(2) if it
3796  * has a directory open:
3797  *	0: disallowed for all processes.
3798  *	1: allowed for processes that were not already chroot(2)'ed.
3799  *	2: allowed for all processes.
3800  */
3801 
3802 static int chroot_allow_open_directories = 1;
3803 
3804 SYSCTL_INT(_kern, OID_AUTO, chroot_allow_open_directories, CTLFLAG_RW,
3805     &chroot_allow_open_directories, 0,
3806     "Allow a process to chroot(2) if it has a directory open");
3807 
3808 /*
3809  * Helper function for raised chroot(2) security function:  Refuse if
3810  * any filedescriptors are open directories.
3811  */
3812 static int
3813 chroot_refuse_vdir_fds(struct filedesc *fdp)
3814 {
3815 	struct vnode *vp;
3816 	struct file *fp;
3817 	int i;
3818 
3819 	FILEDESC_LOCK_ASSERT(fdp);
3820 
3821 	FILEDESC_FOREACH_FP(fdp, i, fp) {
3822 		if (fp->f_type == DTYPE_VNODE) {
3823 			vp = fp->f_vnode;
3824 			if (vp->v_type == VDIR)
3825 				return (EPERM);
3826 		}
3827 	}
3828 	return (0);
3829 }
3830 
3831 static void
3832 pwd_fill(struct pwd *oldpwd, struct pwd *newpwd)
3833 {
3834 
3835 	if (newpwd->pwd_cdir == NULL && oldpwd->pwd_cdir != NULL) {
3836 		vrefact(oldpwd->pwd_cdir);
3837 		newpwd->pwd_cdir = oldpwd->pwd_cdir;
3838 	}
3839 
3840 	if (newpwd->pwd_rdir == NULL && oldpwd->pwd_rdir != NULL) {
3841 		vrefact(oldpwd->pwd_rdir);
3842 		newpwd->pwd_rdir = oldpwd->pwd_rdir;
3843 	}
3844 
3845 	if (newpwd->pwd_jdir == NULL && oldpwd->pwd_jdir != NULL) {
3846 		vrefact(oldpwd->pwd_jdir);
3847 		newpwd->pwd_jdir = oldpwd->pwd_jdir;
3848 	}
3849 
3850 	if (newpwd->pwd_adir == NULL && oldpwd->pwd_adir != NULL) {
3851 		vrefact(oldpwd->pwd_adir);
3852 		newpwd->pwd_adir = oldpwd->pwd_adir;
3853 	}
3854 }
3855 
3856 struct pwd *
3857 pwd_hold_pwddesc(struct pwddesc *pdp)
3858 {
3859 	struct pwd *pwd;
3860 
3861 	PWDDESC_ASSERT_XLOCKED(pdp);
3862 	pwd = PWDDESC_XLOCKED_LOAD_PWD(pdp);
3863 	if (pwd != NULL)
3864 		refcount_acquire(&pwd->pwd_refcount);
3865 	return (pwd);
3866 }
3867 
3868 bool
3869 pwd_hold_smr(struct pwd *pwd)
3870 {
3871 
3872 	MPASS(pwd != NULL);
3873 	if (__predict_true(refcount_acquire_if_not_zero(&pwd->pwd_refcount))) {
3874 		return (true);
3875 	}
3876 	return (false);
3877 }
3878 
3879 struct pwd *
3880 pwd_hold(struct thread *td)
3881 {
3882 	struct pwddesc *pdp;
3883 	struct pwd *pwd;
3884 
3885 	pdp = td->td_proc->p_pd;
3886 
3887 	vfs_smr_enter();
3888 	pwd = vfs_smr_entered_load(&pdp->pd_pwd);
3889 	if (pwd_hold_smr(pwd)) {
3890 		vfs_smr_exit();
3891 		return (pwd);
3892 	}
3893 	vfs_smr_exit();
3894 	PWDDESC_XLOCK(pdp);
3895 	pwd = pwd_hold_pwddesc(pdp);
3896 	MPASS(pwd != NULL);
3897 	PWDDESC_XUNLOCK(pdp);
3898 	return (pwd);
3899 }
3900 
3901 struct pwd *
3902 pwd_hold_proc(struct proc *p)
3903 {
3904 	struct pwddesc *pdp;
3905 	struct pwd *pwd;
3906 
3907 	PROC_ASSERT_HELD(p);
3908 	PROC_LOCK(p);
3909 	pdp = pdhold(p);
3910 	MPASS(pdp != NULL);
3911 	PROC_UNLOCK(p);
3912 
3913 	PWDDESC_XLOCK(pdp);
3914 	pwd = pwd_hold_pwddesc(pdp);
3915 	MPASS(pwd != NULL);
3916 	PWDDESC_XUNLOCK(pdp);
3917 	pddrop(pdp);
3918 	return (pwd);
3919 }
3920 
3921 static struct pwd *
3922 pwd_alloc(void)
3923 {
3924 	struct pwd *pwd;
3925 
3926 	pwd = uma_zalloc_smr(pwd_zone, M_WAITOK);
3927 	bzero(pwd, sizeof(*pwd));
3928 	refcount_init(&pwd->pwd_refcount, 1);
3929 	return (pwd);
3930 }
3931 
3932 void
3933 pwd_drop(struct pwd *pwd)
3934 {
3935 
3936 	if (!refcount_release(&pwd->pwd_refcount))
3937 		return;
3938 
3939 	if (pwd->pwd_cdir != NULL)
3940 		vrele(pwd->pwd_cdir);
3941 	if (pwd->pwd_rdir != NULL)
3942 		vrele(pwd->pwd_rdir);
3943 	if (pwd->pwd_jdir != NULL)
3944 		vrele(pwd->pwd_jdir);
3945 	if (pwd->pwd_adir != NULL)
3946 		vrele(pwd->pwd_adir);
3947 	uma_zfree_smr(pwd_zone, pwd);
3948 }
3949 
3950 /*
3951 * The caller is responsible for invoking priv_check() and
3952 * mac_vnode_check_chroot() to authorize this operation.
3953 */
3954 int
3955 pwd_chroot(struct thread *td, struct vnode *vp)
3956 {
3957 	struct pwddesc *pdp;
3958 	struct filedesc *fdp;
3959 	struct pwd *newpwd, *oldpwd;
3960 	int error;
3961 
3962 	fdp = td->td_proc->p_fd;
3963 	pdp = td->td_proc->p_pd;
3964 	newpwd = pwd_alloc();
3965 	FILEDESC_SLOCK(fdp);
3966 	PWDDESC_XLOCK(pdp);
3967 	oldpwd = PWDDESC_XLOCKED_LOAD_PWD(pdp);
3968 	if (chroot_allow_open_directories == 0 ||
3969 	    (chroot_allow_open_directories == 1 &&
3970 	    oldpwd->pwd_rdir != rootvnode)) {
3971 		error = chroot_refuse_vdir_fds(fdp);
3972 		FILEDESC_SUNLOCK(fdp);
3973 		if (error != 0) {
3974 			PWDDESC_XUNLOCK(pdp);
3975 			pwd_drop(newpwd);
3976 			return (error);
3977 		}
3978 	} else {
3979 		FILEDESC_SUNLOCK(fdp);
3980 	}
3981 
3982 	vrefact(vp);
3983 	newpwd->pwd_rdir = vp;
3984 	vrefact(vp);
3985 	newpwd->pwd_adir = vp;
3986 	if (oldpwd->pwd_jdir == NULL) {
3987 		vrefact(vp);
3988 		newpwd->pwd_jdir = vp;
3989 	}
3990 	pwd_fill(oldpwd, newpwd);
3991 	pwd_set(pdp, newpwd);
3992 	PWDDESC_XUNLOCK(pdp);
3993 	pwd_drop(oldpwd);
3994 	return (0);
3995 }
3996 
3997 void
3998 pwd_chdir(struct thread *td, struct vnode *vp)
3999 {
4000 	struct pwddesc *pdp;
4001 	struct pwd *newpwd, *oldpwd;
4002 
4003 	VNPASS(vp->v_usecount > 0, vp);
4004 
4005 	newpwd = pwd_alloc();
4006 	pdp = td->td_proc->p_pd;
4007 	PWDDESC_XLOCK(pdp);
4008 	oldpwd = PWDDESC_XLOCKED_LOAD_PWD(pdp);
4009 	newpwd->pwd_cdir = vp;
4010 	pwd_fill(oldpwd, newpwd);
4011 	pwd_set(pdp, newpwd);
4012 	PWDDESC_XUNLOCK(pdp);
4013 	pwd_drop(oldpwd);
4014 }
4015 
4016 /*
4017  * Process is transitioning to/from a non-native ABI.
4018  */
4019 void
4020 pwd_altroot(struct thread *td, struct vnode *altroot_vp)
4021 {
4022 	struct pwddesc *pdp;
4023 	struct pwd *newpwd, *oldpwd;
4024 
4025 	newpwd = pwd_alloc();
4026 	pdp = td->td_proc->p_pd;
4027 	PWDDESC_XLOCK(pdp);
4028 	oldpwd = PWDDESC_XLOCKED_LOAD_PWD(pdp);
4029 	if (altroot_vp != NULL) {
4030 		/*
4031 		 * Native process to a non-native ABI.
4032 		 */
4033 
4034 		vrefact(altroot_vp);
4035 		newpwd->pwd_adir = altroot_vp;
4036 	} else {
4037 		/*
4038 		 * Non-native process to the native ABI.
4039 		 */
4040 
4041 		vrefact(oldpwd->pwd_rdir);
4042 		newpwd->pwd_adir = oldpwd->pwd_rdir;
4043 	}
4044 	pwd_fill(oldpwd, newpwd);
4045 	pwd_set(pdp, newpwd);
4046 	PWDDESC_XUNLOCK(pdp);
4047 	pwd_drop(oldpwd);
4048 }
4049 
4050 /*
4051  * jail_attach(2) changes both root and working directories.
4052  */
4053 int
4054 pwd_chroot_chdir(struct thread *td, struct vnode *vp)
4055 {
4056 	struct pwddesc *pdp;
4057 	struct filedesc *fdp;
4058 	struct pwd *newpwd, *oldpwd;
4059 	int error;
4060 
4061 	fdp = td->td_proc->p_fd;
4062 	pdp = td->td_proc->p_pd;
4063 	newpwd = pwd_alloc();
4064 	FILEDESC_SLOCK(fdp);
4065 	PWDDESC_XLOCK(pdp);
4066 	oldpwd = PWDDESC_XLOCKED_LOAD_PWD(pdp);
4067 	error = chroot_refuse_vdir_fds(fdp);
4068 	FILEDESC_SUNLOCK(fdp);
4069 	if (error != 0) {
4070 		PWDDESC_XUNLOCK(pdp);
4071 		pwd_drop(newpwd);
4072 		return (error);
4073 	}
4074 
4075 	vrefact(vp);
4076 	newpwd->pwd_rdir = vp;
4077 	vrefact(vp);
4078 	newpwd->pwd_cdir = vp;
4079 	if (oldpwd->pwd_jdir == NULL) {
4080 		vrefact(vp);
4081 		newpwd->pwd_jdir = vp;
4082 	}
4083 	vrefact(vp);
4084 	newpwd->pwd_adir = vp;
4085 	pwd_fill(oldpwd, newpwd);
4086 	pwd_set(pdp, newpwd);
4087 	PWDDESC_XUNLOCK(pdp);
4088 	pwd_drop(oldpwd);
4089 	return (0);
4090 }
4091 
4092 void
4093 pwd_ensure_dirs(void)
4094 {
4095 	struct pwddesc *pdp;
4096 	struct pwd *oldpwd, *newpwd;
4097 
4098 	pdp = curproc->p_pd;
4099 	PWDDESC_XLOCK(pdp);
4100 	oldpwd = PWDDESC_XLOCKED_LOAD_PWD(pdp);
4101 	if (oldpwd->pwd_cdir != NULL && oldpwd->pwd_rdir != NULL &&
4102 	    oldpwd->pwd_adir != NULL) {
4103 		PWDDESC_XUNLOCK(pdp);
4104 		return;
4105 	}
4106 	PWDDESC_XUNLOCK(pdp);
4107 
4108 	newpwd = pwd_alloc();
4109 	PWDDESC_XLOCK(pdp);
4110 	oldpwd = PWDDESC_XLOCKED_LOAD_PWD(pdp);
4111 	pwd_fill(oldpwd, newpwd);
4112 	if (newpwd->pwd_cdir == NULL) {
4113 		vrefact(rootvnode);
4114 		newpwd->pwd_cdir = rootvnode;
4115 	}
4116 	if (newpwd->pwd_rdir == NULL) {
4117 		vrefact(rootvnode);
4118 		newpwd->pwd_rdir = rootvnode;
4119 	}
4120 	if (newpwd->pwd_adir == NULL) {
4121 		vrefact(rootvnode);
4122 		newpwd->pwd_adir = rootvnode;
4123 	}
4124 	pwd_set(pdp, newpwd);
4125 	PWDDESC_XUNLOCK(pdp);
4126 	pwd_drop(oldpwd);
4127 }
4128 
4129 void
4130 pwd_set_rootvnode(void)
4131 {
4132 	struct pwddesc *pdp;
4133 	struct pwd *oldpwd, *newpwd;
4134 
4135 	pdp = curproc->p_pd;
4136 
4137 	newpwd = pwd_alloc();
4138 	PWDDESC_XLOCK(pdp);
4139 	oldpwd = PWDDESC_XLOCKED_LOAD_PWD(pdp);
4140 	vrefact(rootvnode);
4141 	newpwd->pwd_cdir = rootvnode;
4142 	vrefact(rootvnode);
4143 	newpwd->pwd_rdir = rootvnode;
4144 	vrefact(rootvnode);
4145 	newpwd->pwd_adir = rootvnode;
4146 	pwd_fill(oldpwd, newpwd);
4147 	pwd_set(pdp, newpwd);
4148 	PWDDESC_XUNLOCK(pdp);
4149 	pwd_drop(oldpwd);
4150 }
4151 
4152 /*
4153  * Scan all active processes and prisons to see if any of them have a current
4154  * or root directory of `olddp'. If so, replace them with the new mount point.
4155  */
4156 void
4157 mountcheckdirs(struct vnode *olddp, struct vnode *newdp)
4158 {
4159 	struct pwddesc *pdp;
4160 	struct pwd *newpwd, *oldpwd;
4161 	struct prison *pr;
4162 	struct proc *p;
4163 	int nrele;
4164 
4165 	if (vrefcnt(olddp) == 1)
4166 		return;
4167 	nrele = 0;
4168 	newpwd = pwd_alloc();
4169 	sx_slock(&allproc_lock);
4170 	FOREACH_PROC_IN_SYSTEM(p) {
4171 		PROC_LOCK(p);
4172 		pdp = pdhold(p);
4173 		PROC_UNLOCK(p);
4174 		if (pdp == NULL)
4175 			continue;
4176 		PWDDESC_XLOCK(pdp);
4177 		oldpwd = PWDDESC_XLOCKED_LOAD_PWD(pdp);
4178 		if (oldpwd == NULL ||
4179 		    (oldpwd->pwd_cdir != olddp &&
4180 		    oldpwd->pwd_rdir != olddp &&
4181 		    oldpwd->pwd_jdir != olddp &&
4182 		    oldpwd->pwd_adir != olddp)) {
4183 			PWDDESC_XUNLOCK(pdp);
4184 			pddrop(pdp);
4185 			continue;
4186 		}
4187 		if (oldpwd->pwd_cdir == olddp) {
4188 			vrefact(newdp);
4189 			newpwd->pwd_cdir = newdp;
4190 		}
4191 		if (oldpwd->pwd_rdir == olddp) {
4192 			vrefact(newdp);
4193 			newpwd->pwd_rdir = newdp;
4194 		}
4195 		if (oldpwd->pwd_jdir == olddp) {
4196 			vrefact(newdp);
4197 			newpwd->pwd_jdir = newdp;
4198 		}
4199 		if (oldpwd->pwd_adir == olddp) {
4200 			vrefact(newdp);
4201 			newpwd->pwd_adir = newdp;
4202 		}
4203 		pwd_fill(oldpwd, newpwd);
4204 		pwd_set(pdp, newpwd);
4205 		PWDDESC_XUNLOCK(pdp);
4206 		pwd_drop(oldpwd);
4207 		pddrop(pdp);
4208 		newpwd = pwd_alloc();
4209 	}
4210 	sx_sunlock(&allproc_lock);
4211 	pwd_drop(newpwd);
4212 	if (rootvnode == olddp) {
4213 		vrefact(newdp);
4214 		rootvnode = newdp;
4215 		nrele++;
4216 	}
4217 	mtx_lock(&prison0.pr_mtx);
4218 	if (prison0.pr_root == olddp) {
4219 		vrefact(newdp);
4220 		prison0.pr_root = newdp;
4221 		nrele++;
4222 	}
4223 	mtx_unlock(&prison0.pr_mtx);
4224 	sx_slock(&allprison_lock);
4225 	TAILQ_FOREACH(pr, &allprison, pr_list) {
4226 		mtx_lock(&pr->pr_mtx);
4227 		if (pr->pr_root == olddp) {
4228 			vrefact(newdp);
4229 			pr->pr_root = newdp;
4230 			nrele++;
4231 		}
4232 		mtx_unlock(&pr->pr_mtx);
4233 	}
4234 	sx_sunlock(&allprison_lock);
4235 	while (nrele--)
4236 		vrele(olddp);
4237 }
4238 
4239 int
4240 descrip_check_write_mp(struct filedesc *fdp, struct mount *mp)
4241 {
4242 	struct file *fp;
4243 	struct vnode *vp;
4244 	int error, i;
4245 
4246 	error = 0;
4247 	FILEDESC_SLOCK(fdp);
4248 	FILEDESC_FOREACH_FP(fdp, i, fp) {
4249 		if (fp->f_type != DTYPE_VNODE ||
4250 		    (atomic_load_int(&fp->f_flag) & FWRITE) == 0)
4251 			continue;
4252 		vp = fp->f_vnode;
4253 		if (vp->v_mount == mp) {
4254 			error = EDEADLK;
4255 			break;
4256 		}
4257 	}
4258 	FILEDESC_SUNLOCK(fdp);
4259 	return (error);
4260 }
4261 
4262 struct filedesc_to_leader *
4263 filedesc_to_leader_alloc(struct filedesc_to_leader *old, struct filedesc *fdp,
4264     struct proc *leader)
4265 {
4266 	struct filedesc_to_leader *fdtol;
4267 
4268 	fdtol = malloc(sizeof(struct filedesc_to_leader),
4269 	    M_FILEDESC_TO_LEADER, M_WAITOK);
4270 	fdtol->fdl_refcount = 1;
4271 	fdtol->fdl_holdcount = 0;
4272 	fdtol->fdl_wakeup = 0;
4273 	fdtol->fdl_leader = leader;
4274 	if (old != NULL) {
4275 		FILEDESC_XLOCK(fdp);
4276 		fdtol->fdl_next = old->fdl_next;
4277 		fdtol->fdl_prev = old;
4278 		old->fdl_next = fdtol;
4279 		fdtol->fdl_next->fdl_prev = fdtol;
4280 		FILEDESC_XUNLOCK(fdp);
4281 	} else {
4282 		fdtol->fdl_next = fdtol;
4283 		fdtol->fdl_prev = fdtol;
4284 	}
4285 	return (fdtol);
4286 }
4287 
4288 struct filedesc_to_leader *
4289 filedesc_to_leader_share(struct filedesc_to_leader *fdtol, struct filedesc *fdp)
4290 {
4291 	FILEDESC_XLOCK(fdp);
4292 	fdtol->fdl_refcount++;
4293 	FILEDESC_XUNLOCK(fdp);
4294 	return (fdtol);
4295 }
4296 
4297 static int
4298 sysctl_kern_proc_nfds(SYSCTL_HANDLER_ARGS)
4299 {
4300 	NDSLOTTYPE *map;
4301 	struct filedesc *fdp;
4302 	u_int namelen;
4303 	int count, off, minoff;
4304 
4305 	namelen = arg2;
4306 	if (namelen != 1)
4307 		return (EINVAL);
4308 
4309 	if (*(int *)arg1 != 0)
4310 		return (EINVAL);
4311 
4312 	fdp = curproc->p_fd;
4313 	count = 0;
4314 	FILEDESC_SLOCK(fdp);
4315 	map = fdp->fd_map;
4316 	off = NDSLOT(fdp->fd_nfiles - 1);
4317 	for (minoff = NDSLOT(0); off >= minoff; --off)
4318 		count += bitcountl(map[off]);
4319 	FILEDESC_SUNLOCK(fdp);
4320 
4321 	return (SYSCTL_OUT(req, &count, sizeof(count)));
4322 }
4323 
4324 static SYSCTL_NODE(_kern_proc, KERN_PROC_NFDS, nfds,
4325     CTLFLAG_RD|CTLFLAG_CAPRD|CTLFLAG_MPSAFE, sysctl_kern_proc_nfds,
4326     "Number of open file descriptors");
4327 
4328 /*
4329  * Get file structures globally.
4330  */
4331 static int
4332 sysctl_kern_file(SYSCTL_HANDLER_ARGS)
4333 {
4334 	struct xfile xf;
4335 	struct filedesc *fdp;
4336 	struct file *fp;
4337 	struct proc *p;
4338 	int error, n;
4339 
4340 	error = sysctl_wire_old_buffer(req, 0);
4341 	if (error != 0)
4342 		return (error);
4343 	if (req->oldptr == NULL) {
4344 		n = 0;
4345 		sx_slock(&allproc_lock);
4346 		FOREACH_PROC_IN_SYSTEM(p) {
4347 			PROC_LOCK(p);
4348 			if (p->p_state == PRS_NEW) {
4349 				PROC_UNLOCK(p);
4350 				continue;
4351 			}
4352 			fdp = fdhold(p);
4353 			PROC_UNLOCK(p);
4354 			if (fdp == NULL)
4355 				continue;
4356 			/* overestimates sparse tables. */
4357 			n += fdp->fd_nfiles;
4358 			fddrop(fdp);
4359 		}
4360 		sx_sunlock(&allproc_lock);
4361 		return (SYSCTL_OUT(req, 0, n * sizeof(xf)));
4362 	}
4363 	error = 0;
4364 	bzero(&xf, sizeof(xf));
4365 	xf.xf_size = sizeof(xf);
4366 	sx_slock(&allproc_lock);
4367 	FOREACH_PROC_IN_SYSTEM(p) {
4368 		PROC_LOCK(p);
4369 		if (p->p_state == PRS_NEW) {
4370 			PROC_UNLOCK(p);
4371 			continue;
4372 		}
4373 		if (p_cansee(req->td, p) != 0) {
4374 			PROC_UNLOCK(p);
4375 			continue;
4376 		}
4377 		xf.xf_pid = p->p_pid;
4378 		xf.xf_uid = p->p_ucred->cr_uid;
4379 		fdp = fdhold(p);
4380 		PROC_UNLOCK(p);
4381 		if (fdp == NULL)
4382 			continue;
4383 		FILEDESC_SLOCK(fdp);
4384 		if (refcount_load(&fdp->fd_refcnt) == 0)
4385 			goto nextproc;
4386 		FILEDESC_FOREACH_FP(fdp, n, fp) {
4387 			xf.xf_fd = n;
4388 			xf.xf_file = (uintptr_t)fp;
4389 			xf.xf_data = (uintptr_t)fp->f_data;
4390 			xf.xf_vnode = (uintptr_t)fp->f_vnode;
4391 			xf.xf_type = (uintptr_t)fp->f_type;
4392 			xf.xf_count = refcount_load(&fp->f_count);
4393 			xf.xf_msgcount = 0;
4394 			xf.xf_offset = foffset_get(fp);
4395 			xf.xf_flag = fp->f_flag;
4396 			error = SYSCTL_OUT(req, &xf, sizeof(xf));
4397 
4398 			/*
4399 			 * There is no need to re-check the fdtable refcount
4400 			 * here since the filedesc lock is not dropped in the
4401 			 * loop body.
4402 			 */
4403 			if (error != 0)
4404 				break;
4405 		}
4406 nextproc:
4407 		FILEDESC_SUNLOCK(fdp);
4408 		fddrop(fdp);
4409 		if (error)
4410 			break;
4411 	}
4412 	sx_sunlock(&allproc_lock);
4413 	return (error);
4414 }
4415 
4416 SYSCTL_PROC(_kern, KERN_FILE, file, CTLTYPE_OPAQUE|CTLFLAG_RD|CTLFLAG_MPSAFE,
4417     0, 0, sysctl_kern_file, "S,xfile", "Entire file table");
4418 
4419 #ifdef KINFO_FILE_SIZE
4420 CTASSERT(sizeof(struct kinfo_file) == KINFO_FILE_SIZE);
4421 #endif
4422 
4423 static int
4424 xlate_fflags(int fflags)
4425 {
4426 	static const struct {
4427 		int	fflag;
4428 		int	kf_fflag;
4429 	} fflags_table[] = {
4430 		{ FAPPEND, KF_FLAG_APPEND },
4431 		{ FASYNC, KF_FLAG_ASYNC },
4432 		{ FFSYNC, KF_FLAG_FSYNC },
4433 		{ FHASLOCK, KF_FLAG_HASLOCK },
4434 		{ FNONBLOCK, KF_FLAG_NONBLOCK },
4435 		{ FREAD, KF_FLAG_READ },
4436 		{ FWRITE, KF_FLAG_WRITE },
4437 		{ O_CREAT, KF_FLAG_CREAT },
4438 		{ O_DIRECT, KF_FLAG_DIRECT },
4439 		{ O_EXCL, KF_FLAG_EXCL },
4440 		{ O_EXEC, KF_FLAG_EXEC },
4441 		{ O_EXLOCK, KF_FLAG_EXLOCK },
4442 		{ O_NOFOLLOW, KF_FLAG_NOFOLLOW },
4443 		{ O_SHLOCK, KF_FLAG_SHLOCK },
4444 		{ O_TRUNC, KF_FLAG_TRUNC }
4445 	};
4446 	unsigned int i;
4447 	int kflags;
4448 
4449 	kflags = 0;
4450 	for (i = 0; i < nitems(fflags_table); i++)
4451 		if (fflags & fflags_table[i].fflag)
4452 			kflags |=  fflags_table[i].kf_fflag;
4453 	return (kflags);
4454 }
4455 
4456 /* Trim unused data from kf_path by truncating the structure size. */
4457 void
4458 pack_kinfo(struct kinfo_file *kif)
4459 {
4460 
4461 	kif->kf_structsize = offsetof(struct kinfo_file, kf_path) +
4462 	    strlen(kif->kf_path) + 1;
4463 	kif->kf_structsize = roundup(kif->kf_structsize, sizeof(uint64_t));
4464 }
4465 
4466 static void
4467 export_file_to_kinfo(struct file *fp, int fd, cap_rights_t *rightsp,
4468     struct kinfo_file *kif, struct filedesc *fdp, int flags)
4469 {
4470 	int error;
4471 
4472 	bzero(kif, sizeof(*kif));
4473 
4474 	/* Set a default type to allow for empty fill_kinfo() methods. */
4475 	kif->kf_type = KF_TYPE_UNKNOWN;
4476 	kif->kf_flags = xlate_fflags(fp->f_flag);
4477 	if (rightsp != NULL)
4478 		kif->kf_cap_rights = *rightsp;
4479 	else
4480 		cap_rights_init_zero(&kif->kf_cap_rights);
4481 	kif->kf_fd = fd;
4482 	kif->kf_ref_count = refcount_load(&fp->f_count);
4483 	kif->kf_offset = foffset_get(fp);
4484 
4485 	/*
4486 	 * This may drop the filedesc lock, so the 'fp' cannot be
4487 	 * accessed after this call.
4488 	 */
4489 	error = fo_fill_kinfo(fp, kif, fdp);
4490 	if (error == 0)
4491 		kif->kf_status |= KF_ATTR_VALID;
4492 	if ((flags & KERN_FILEDESC_PACK_KINFO) != 0)
4493 		pack_kinfo(kif);
4494 	else
4495 		kif->kf_structsize = roundup2(sizeof(*kif), sizeof(uint64_t));
4496 }
4497 
4498 static void
4499 export_vnode_to_kinfo(struct vnode *vp, int fd, int fflags,
4500     struct kinfo_file *kif, int flags)
4501 {
4502 	int error;
4503 
4504 	bzero(kif, sizeof(*kif));
4505 
4506 	kif->kf_type = KF_TYPE_VNODE;
4507 	error = vn_fill_kinfo_vnode(vp, kif);
4508 	if (error == 0)
4509 		kif->kf_status |= KF_ATTR_VALID;
4510 	kif->kf_flags = xlate_fflags(fflags);
4511 	cap_rights_init_zero(&kif->kf_cap_rights);
4512 	kif->kf_fd = fd;
4513 	kif->kf_ref_count = -1;
4514 	kif->kf_offset = -1;
4515 	if ((flags & KERN_FILEDESC_PACK_KINFO) != 0)
4516 		pack_kinfo(kif);
4517 	else
4518 		kif->kf_structsize = roundup2(sizeof(*kif), sizeof(uint64_t));
4519 	vrele(vp);
4520 }
4521 
4522 struct export_fd_buf {
4523 	struct filedesc		*fdp;
4524 	struct pwddesc	*pdp;
4525 	struct sbuf 		*sb;
4526 	ssize_t			remainder;
4527 	struct kinfo_file	kif;
4528 	int			flags;
4529 };
4530 
4531 static int
4532 export_kinfo_to_sb(struct export_fd_buf *efbuf)
4533 {
4534 	struct kinfo_file *kif;
4535 
4536 	kif = &efbuf->kif;
4537 	if (efbuf->remainder != -1) {
4538 		if (efbuf->remainder < kif->kf_structsize)
4539 			return (ENOMEM);
4540 		efbuf->remainder -= kif->kf_structsize;
4541 	}
4542 	if (sbuf_bcat(efbuf->sb, kif, kif->kf_structsize) != 0)
4543 		return (sbuf_error(efbuf->sb));
4544 	return (0);
4545 }
4546 
4547 static int
4548 export_file_to_sb(struct file *fp, int fd, cap_rights_t *rightsp,
4549     struct export_fd_buf *efbuf)
4550 {
4551 	int error;
4552 
4553 	if (efbuf->remainder == 0)
4554 		return (ENOMEM);
4555 	export_file_to_kinfo(fp, fd, rightsp, &efbuf->kif, efbuf->fdp,
4556 	    efbuf->flags);
4557 	FILEDESC_SUNLOCK(efbuf->fdp);
4558 	error = export_kinfo_to_sb(efbuf);
4559 	FILEDESC_SLOCK(efbuf->fdp);
4560 	return (error);
4561 }
4562 
4563 static int
4564 export_vnode_to_sb(struct vnode *vp, int fd, int fflags,
4565     struct export_fd_buf *efbuf)
4566 {
4567 	int error;
4568 
4569 	if (efbuf->remainder == 0)
4570 		return (ENOMEM);
4571 	if (efbuf->pdp != NULL)
4572 		PWDDESC_XUNLOCK(efbuf->pdp);
4573 	export_vnode_to_kinfo(vp, fd, fflags, &efbuf->kif, efbuf->flags);
4574 	error = export_kinfo_to_sb(efbuf);
4575 	if (efbuf->pdp != NULL)
4576 		PWDDESC_XLOCK(efbuf->pdp);
4577 	return (error);
4578 }
4579 
4580 /*
4581  * Store a process file descriptor information to sbuf.
4582  *
4583  * Takes a locked proc as argument, and returns with the proc unlocked.
4584  */
4585 int
4586 kern_proc_filedesc_out(struct proc *p,  struct sbuf *sb, ssize_t maxlen,
4587     int flags)
4588 {
4589 	struct file *fp;
4590 	struct filedesc *fdp;
4591 	struct pwddesc *pdp;
4592 	struct export_fd_buf *efbuf;
4593 	struct vnode *cttyvp, *textvp, *tracevp;
4594 	struct pwd *pwd;
4595 	int error, i;
4596 	cap_rights_t rights;
4597 
4598 	PROC_LOCK_ASSERT(p, MA_OWNED);
4599 
4600 	/* ktrace vnode */
4601 	tracevp = ktr_get_tracevp(p, true);
4602 	/* text vnode */
4603 	textvp = p->p_textvp;
4604 	if (textvp != NULL)
4605 		vrefact(textvp);
4606 	/* Controlling tty. */
4607 	cttyvp = NULL;
4608 	if (p->p_pgrp != NULL && p->p_pgrp->pg_session != NULL) {
4609 		cttyvp = p->p_pgrp->pg_session->s_ttyvp;
4610 		if (cttyvp != NULL)
4611 			vrefact(cttyvp);
4612 	}
4613 	fdp = fdhold(p);
4614 	pdp = pdhold(p);
4615 	PROC_UNLOCK(p);
4616 
4617 	efbuf = malloc(sizeof(*efbuf), M_TEMP, M_WAITOK);
4618 	efbuf->fdp = NULL;
4619 	efbuf->pdp = NULL;
4620 	efbuf->sb = sb;
4621 	efbuf->remainder = maxlen;
4622 	efbuf->flags = flags;
4623 
4624 	error = 0;
4625 	if (tracevp != NULL)
4626 		error = export_vnode_to_sb(tracevp, KF_FD_TYPE_TRACE,
4627 		    FREAD | FWRITE, efbuf);
4628 	if (error == 0 && textvp != NULL)
4629 		error = export_vnode_to_sb(textvp, KF_FD_TYPE_TEXT, FREAD,
4630 		    efbuf);
4631 	if (error == 0 && cttyvp != NULL)
4632 		error = export_vnode_to_sb(cttyvp, KF_FD_TYPE_CTTY,
4633 		    FREAD | FWRITE, efbuf);
4634 	if (error != 0 || pdp == NULL || fdp == NULL)
4635 		goto fail;
4636 	efbuf->fdp = fdp;
4637 	efbuf->pdp = pdp;
4638 	PWDDESC_XLOCK(pdp);
4639 	pwd = pwd_hold_pwddesc(pdp);
4640 	if (pwd != NULL) {
4641 		/* working directory */
4642 		if (pwd->pwd_cdir != NULL) {
4643 			vrefact(pwd->pwd_cdir);
4644 			error = export_vnode_to_sb(pwd->pwd_cdir,
4645 			    KF_FD_TYPE_CWD, FREAD, efbuf);
4646 		}
4647 		/* root directory */
4648 		if (error == 0 && pwd->pwd_rdir != NULL) {
4649 			vrefact(pwd->pwd_rdir);
4650 			error = export_vnode_to_sb(pwd->pwd_rdir,
4651 			    KF_FD_TYPE_ROOT, FREAD, efbuf);
4652 		}
4653 		/* jail directory */
4654 		if (error == 0 && pwd->pwd_jdir != NULL) {
4655 			vrefact(pwd->pwd_jdir);
4656 			error = export_vnode_to_sb(pwd->pwd_jdir,
4657 			    KF_FD_TYPE_JAIL, FREAD, efbuf);
4658 		}
4659 	}
4660 	PWDDESC_XUNLOCK(pdp);
4661 	if (error != 0)
4662 		goto fail;
4663 	if (pwd != NULL)
4664 		pwd_drop(pwd);
4665 	FILEDESC_SLOCK(fdp);
4666 	if (refcount_load(&fdp->fd_refcnt) == 0)
4667 		goto skip;
4668 	FILEDESC_FOREACH_FP(fdp, i, fp) {
4669 #ifdef CAPABILITIES
4670 		rights = *cap_rights(fdp, i);
4671 #else /* !CAPABILITIES */
4672 		rights = cap_no_rights;
4673 #endif
4674 		/*
4675 		 * Create sysctl entry.  It is OK to drop the filedesc
4676 		 * lock inside of export_file_to_sb() as we will
4677 		 * re-validate and re-evaluate its properties when the
4678 		 * loop continues.
4679 		 */
4680 		error = export_file_to_sb(fp, i, &rights, efbuf);
4681 		if (error != 0 || refcount_load(&fdp->fd_refcnt) == 0)
4682 			break;
4683 	}
4684 skip:
4685 	FILEDESC_SUNLOCK(fdp);
4686 fail:
4687 	if (fdp != NULL)
4688 		fddrop(fdp);
4689 	if (pdp != NULL)
4690 		pddrop(pdp);
4691 	free(efbuf, M_TEMP);
4692 	return (error);
4693 }
4694 
4695 #define FILEDESC_SBUF_SIZE	(sizeof(struct kinfo_file) * 5)
4696 
4697 /*
4698  * Get per-process file descriptors for use by procstat(1), et al.
4699  */
4700 static int
4701 sysctl_kern_proc_filedesc(SYSCTL_HANDLER_ARGS)
4702 {
4703 	struct sbuf sb;
4704 	struct proc *p;
4705 	ssize_t maxlen;
4706 	u_int namelen;
4707 	int error, error2, *name;
4708 
4709 	namelen = arg2;
4710 	if (namelen != 1)
4711 		return (EINVAL);
4712 
4713 	name = (int *)arg1;
4714 
4715 	sbuf_new_for_sysctl(&sb, NULL, FILEDESC_SBUF_SIZE, req);
4716 	sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
4717 	error = pget((pid_t)name[0], PGET_CANDEBUG | PGET_NOTWEXIT, &p);
4718 	if (error != 0) {
4719 		sbuf_delete(&sb);
4720 		return (error);
4721 	}
4722 	maxlen = req->oldptr != NULL ? req->oldlen : -1;
4723 	error = kern_proc_filedesc_out(p, &sb, maxlen,
4724 	    KERN_FILEDESC_PACK_KINFO);
4725 	error2 = sbuf_finish(&sb);
4726 	sbuf_delete(&sb);
4727 	return (error != 0 ? error : error2);
4728 }
4729 
4730 #ifdef COMPAT_FREEBSD7
4731 #ifdef KINFO_OFILE_SIZE
4732 CTASSERT(sizeof(struct kinfo_ofile) == KINFO_OFILE_SIZE);
4733 #endif
4734 
4735 static void
4736 kinfo_to_okinfo(struct kinfo_file *kif, struct kinfo_ofile *okif)
4737 {
4738 
4739 	okif->kf_structsize = sizeof(*okif);
4740 	okif->kf_type = kif->kf_type;
4741 	okif->kf_fd = kif->kf_fd;
4742 	okif->kf_ref_count = kif->kf_ref_count;
4743 	okif->kf_flags = kif->kf_flags & (KF_FLAG_READ | KF_FLAG_WRITE |
4744 	    KF_FLAG_APPEND | KF_FLAG_ASYNC | KF_FLAG_FSYNC | KF_FLAG_NONBLOCK |
4745 	    KF_FLAG_DIRECT | KF_FLAG_HASLOCK);
4746 	okif->kf_offset = kif->kf_offset;
4747 	if (kif->kf_type == KF_TYPE_VNODE)
4748 		okif->kf_vnode_type = kif->kf_un.kf_file.kf_file_type;
4749 	else
4750 		okif->kf_vnode_type = KF_VTYPE_VNON;
4751 	strlcpy(okif->kf_path, kif->kf_path, sizeof(okif->kf_path));
4752 	if (kif->kf_type == KF_TYPE_SOCKET) {
4753 		okif->kf_sock_domain = kif->kf_un.kf_sock.kf_sock_domain0;
4754 		okif->kf_sock_type = kif->kf_un.kf_sock.kf_sock_type0;
4755 		okif->kf_sock_protocol = kif->kf_un.kf_sock.kf_sock_protocol0;
4756 		okif->kf_sa_local = kif->kf_un.kf_sock.kf_sa_local;
4757 		okif->kf_sa_peer = kif->kf_un.kf_sock.kf_sa_peer;
4758 	} else {
4759 		okif->kf_sa_local.ss_family = AF_UNSPEC;
4760 		okif->kf_sa_peer.ss_family = AF_UNSPEC;
4761 	}
4762 }
4763 
4764 static int
4765 export_vnode_for_osysctl(struct vnode *vp, int type, struct kinfo_file *kif,
4766     struct kinfo_ofile *okif, struct pwddesc *pdp, struct sysctl_req *req)
4767 {
4768 	int error;
4769 
4770 	vrefact(vp);
4771 	PWDDESC_XUNLOCK(pdp);
4772 	export_vnode_to_kinfo(vp, type, 0, kif, KERN_FILEDESC_PACK_KINFO);
4773 	kinfo_to_okinfo(kif, okif);
4774 	error = SYSCTL_OUT(req, okif, sizeof(*okif));
4775 	PWDDESC_XLOCK(pdp);
4776 	return (error);
4777 }
4778 
4779 /*
4780  * Get per-process file descriptors for use by procstat(1), et al.
4781  */
4782 static int
4783 sysctl_kern_proc_ofiledesc(SYSCTL_HANDLER_ARGS)
4784 {
4785 	struct kinfo_ofile *okif;
4786 	struct kinfo_file *kif;
4787 	struct filedesc *fdp;
4788 	struct pwddesc *pdp;
4789 	struct pwd *pwd;
4790 	u_int namelen;
4791 	int error, i, *name;
4792 	struct file *fp;
4793 	struct proc *p;
4794 
4795 	namelen = arg2;
4796 	if (namelen != 1)
4797 		return (EINVAL);
4798 
4799 	name = (int *)arg1;
4800 	error = pget((pid_t)name[0], PGET_CANDEBUG | PGET_NOTWEXIT, &p);
4801 	if (error != 0)
4802 		return (error);
4803 	fdp = fdhold(p);
4804 	if (fdp != NULL)
4805 		pdp = pdhold(p);
4806 	PROC_UNLOCK(p);
4807 	if (fdp == NULL || pdp == NULL) {
4808 		if (fdp != NULL)
4809 			fddrop(fdp);
4810 		return (ENOENT);
4811 	}
4812 	kif = malloc(sizeof(*kif), M_TEMP, M_WAITOK);
4813 	okif = malloc(sizeof(*okif), M_TEMP, M_WAITOK);
4814 	PWDDESC_XLOCK(pdp);
4815 	pwd = pwd_hold_pwddesc(pdp);
4816 	if (pwd != NULL) {
4817 		if (pwd->pwd_cdir != NULL)
4818 			export_vnode_for_osysctl(pwd->pwd_cdir, KF_FD_TYPE_CWD, kif,
4819 			    okif, pdp, req);
4820 		if (pwd->pwd_rdir != NULL)
4821 			export_vnode_for_osysctl(pwd->pwd_rdir, KF_FD_TYPE_ROOT, kif,
4822 			    okif, pdp, req);
4823 		if (pwd->pwd_jdir != NULL)
4824 			export_vnode_for_osysctl(pwd->pwd_jdir, KF_FD_TYPE_JAIL, kif,
4825 			    okif, pdp, req);
4826 	}
4827 	PWDDESC_XUNLOCK(pdp);
4828 	if (pwd != NULL)
4829 		pwd_drop(pwd);
4830 	FILEDESC_SLOCK(fdp);
4831 	if (refcount_load(&fdp->fd_refcnt) == 0)
4832 		goto skip;
4833 	FILEDESC_FOREACH_FP(fdp, i, fp) {
4834 		export_file_to_kinfo(fp, i, NULL, kif, fdp,
4835 		    KERN_FILEDESC_PACK_KINFO);
4836 		FILEDESC_SUNLOCK(fdp);
4837 		kinfo_to_okinfo(kif, okif);
4838 		error = SYSCTL_OUT(req, okif, sizeof(*okif));
4839 		FILEDESC_SLOCK(fdp);
4840 		if (error != 0 || refcount_load(&fdp->fd_refcnt) == 0)
4841 			break;
4842 	}
4843 skip:
4844 	FILEDESC_SUNLOCK(fdp);
4845 	fddrop(fdp);
4846 	pddrop(pdp);
4847 	free(kif, M_TEMP);
4848 	free(okif, M_TEMP);
4849 	return (0);
4850 }
4851 
4852 static SYSCTL_NODE(_kern_proc, KERN_PROC_OFILEDESC, ofiledesc,
4853     CTLFLAG_RD|CTLFLAG_MPSAFE, sysctl_kern_proc_ofiledesc,
4854     "Process ofiledesc entries");
4855 #endif	/* COMPAT_FREEBSD7 */
4856 
4857 int
4858 vntype_to_kinfo(int vtype)
4859 {
4860 	struct {
4861 		int	vtype;
4862 		int	kf_vtype;
4863 	} vtypes_table[] = {
4864 		{ VBAD, KF_VTYPE_VBAD },
4865 		{ VBLK, KF_VTYPE_VBLK },
4866 		{ VCHR, KF_VTYPE_VCHR },
4867 		{ VDIR, KF_VTYPE_VDIR },
4868 		{ VFIFO, KF_VTYPE_VFIFO },
4869 		{ VLNK, KF_VTYPE_VLNK },
4870 		{ VNON, KF_VTYPE_VNON },
4871 		{ VREG, KF_VTYPE_VREG },
4872 		{ VSOCK, KF_VTYPE_VSOCK }
4873 	};
4874 	unsigned int i;
4875 
4876 	/*
4877 	 * Perform vtype translation.
4878 	 */
4879 	for (i = 0; i < nitems(vtypes_table); i++)
4880 		if (vtypes_table[i].vtype == vtype)
4881 			return (vtypes_table[i].kf_vtype);
4882 
4883 	return (KF_VTYPE_UNKNOWN);
4884 }
4885 
4886 static SYSCTL_NODE(_kern_proc, KERN_PROC_FILEDESC, filedesc,
4887     CTLFLAG_RD|CTLFLAG_MPSAFE, sysctl_kern_proc_filedesc,
4888     "Process filedesc entries");
4889 
4890 /*
4891  * Store a process current working directory information to sbuf.
4892  *
4893  * Takes a locked proc as argument, and returns with the proc unlocked.
4894  */
4895 int
4896 kern_proc_cwd_out(struct proc *p,  struct sbuf *sb, ssize_t maxlen)
4897 {
4898 	struct pwddesc *pdp;
4899 	struct pwd *pwd;
4900 	struct export_fd_buf *efbuf;
4901 	struct vnode *cdir;
4902 	int error;
4903 
4904 	PROC_LOCK_ASSERT(p, MA_OWNED);
4905 
4906 	pdp = pdhold(p);
4907 	PROC_UNLOCK(p);
4908 	if (pdp == NULL)
4909 		return (EINVAL);
4910 
4911 	efbuf = malloc(sizeof(*efbuf), M_TEMP, M_WAITOK);
4912 	efbuf->fdp = NULL;
4913 	efbuf->pdp = pdp;
4914 	efbuf->sb = sb;
4915 	efbuf->remainder = maxlen;
4916 	efbuf->flags = 0;
4917 
4918 	PWDDESC_XLOCK(pdp);
4919 	pwd = PWDDESC_XLOCKED_LOAD_PWD(pdp);
4920 	cdir = pwd->pwd_cdir;
4921 	if (cdir == NULL) {
4922 		error = EINVAL;
4923 	} else {
4924 		vrefact(cdir);
4925 		error = export_vnode_to_sb(cdir, KF_FD_TYPE_CWD, FREAD, efbuf);
4926 	}
4927 	PWDDESC_XUNLOCK(pdp);
4928 	pddrop(pdp);
4929 	free(efbuf, M_TEMP);
4930 	return (error);
4931 }
4932 
4933 /*
4934  * Get per-process current working directory.
4935  */
4936 static int
4937 sysctl_kern_proc_cwd(SYSCTL_HANDLER_ARGS)
4938 {
4939 	struct sbuf sb;
4940 	struct proc *p;
4941 	ssize_t maxlen;
4942 	u_int namelen;
4943 	int error, error2, *name;
4944 
4945 	namelen = arg2;
4946 	if (namelen != 1)
4947 		return (EINVAL);
4948 
4949 	name = (int *)arg1;
4950 
4951 	sbuf_new_for_sysctl(&sb, NULL, sizeof(struct kinfo_file), req);
4952 	sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
4953 	error = pget((pid_t)name[0], PGET_CANDEBUG | PGET_NOTWEXIT, &p);
4954 	if (error != 0) {
4955 		sbuf_delete(&sb);
4956 		return (error);
4957 	}
4958 	maxlen = req->oldptr != NULL ? req->oldlen : -1;
4959 	error = kern_proc_cwd_out(p, &sb, maxlen);
4960 	error2 = sbuf_finish(&sb);
4961 	sbuf_delete(&sb);
4962 	return (error != 0 ? error : error2);
4963 }
4964 
4965 static SYSCTL_NODE(_kern_proc, KERN_PROC_CWD, cwd, CTLFLAG_RD|CTLFLAG_MPSAFE,
4966     sysctl_kern_proc_cwd, "Process current working directory");
4967 
4968 #ifdef DDB
4969 /*
4970  * For the purposes of debugging, generate a human-readable string for the
4971  * file type.
4972  */
4973 static const char *
4974 file_type_to_name(short type)
4975 {
4976 
4977 	switch (type) {
4978 	case 0:
4979 		return ("zero");
4980 	case DTYPE_VNODE:
4981 		return ("vnode");
4982 	case DTYPE_SOCKET:
4983 		return ("socket");
4984 	case DTYPE_PIPE:
4985 		return ("pipe");
4986 	case DTYPE_FIFO:
4987 		return ("fifo");
4988 	case DTYPE_KQUEUE:
4989 		return ("kqueue");
4990 	case DTYPE_CRYPTO:
4991 		return ("crypto");
4992 	case DTYPE_MQUEUE:
4993 		return ("mqueue");
4994 	case DTYPE_SHM:
4995 		return ("shm");
4996 	case DTYPE_SEM:
4997 		return ("ksem");
4998 	case DTYPE_PTS:
4999 		return ("pts");
5000 	case DTYPE_DEV:
5001 		return ("dev");
5002 	case DTYPE_PROCDESC:
5003 		return ("proc");
5004 	case DTYPE_EVENTFD:
5005 		return ("eventfd");
5006 	case DTYPE_TIMERFD:
5007 		return ("timerfd");
5008 	default:
5009 		return ("unkn");
5010 	}
5011 }
5012 
5013 /*
5014  * For the purposes of debugging, identify a process (if any, perhaps one of
5015  * many) that references the passed file in its file descriptor array. Return
5016  * NULL if none.
5017  */
5018 static struct proc *
5019 file_to_first_proc(struct file *fp)
5020 {
5021 	struct filedesc *fdp;
5022 	struct proc *p;
5023 	int n;
5024 
5025 	FOREACH_PROC_IN_SYSTEM(p) {
5026 		if (p->p_state == PRS_NEW)
5027 			continue;
5028 		fdp = p->p_fd;
5029 		if (fdp == NULL)
5030 			continue;
5031 		for (n = 0; n < fdp->fd_nfiles; n++) {
5032 			if (fp == fdp->fd_ofiles[n].fde_file)
5033 				return (p);
5034 		}
5035 	}
5036 	return (NULL);
5037 }
5038 
5039 static void
5040 db_print_file(struct file *fp, int header)
5041 {
5042 #define XPTRWIDTH ((int)howmany(sizeof(void *) * NBBY, 4))
5043 	struct proc *p;
5044 
5045 	if (header)
5046 		db_printf("%*s %6s %*s %8s %4s %5s %6s %*s %5s %s\n",
5047 		    XPTRWIDTH, "File", "Type", XPTRWIDTH, "Data", "Flag",
5048 		    "GCFl", "Count", "MCount", XPTRWIDTH, "Vnode", "FPID",
5049 		    "FCmd");
5050 	p = file_to_first_proc(fp);
5051 	db_printf("%*p %6s %*p %08x %04x %5d %6d %*p %5d %s\n", XPTRWIDTH,
5052 	    fp, file_type_to_name(fp->f_type), XPTRWIDTH, fp->f_data,
5053 	    fp->f_flag, 0, refcount_load(&fp->f_count), 0, XPTRWIDTH, fp->f_vnode,
5054 	    p != NULL ? p->p_pid : -1, p != NULL ? p->p_comm : "-");
5055 
5056 #undef XPTRWIDTH
5057 }
5058 
5059 DB_SHOW_COMMAND(file, db_show_file)
5060 {
5061 	struct file *fp;
5062 
5063 	if (!have_addr) {
5064 		db_printf("usage: show file <addr>\n");
5065 		return;
5066 	}
5067 	fp = (struct file *)addr;
5068 	db_print_file(fp, 1);
5069 }
5070 
5071 DB_SHOW_COMMAND_FLAGS(files, db_show_files, DB_CMD_MEMSAFE)
5072 {
5073 	struct filedesc *fdp;
5074 	struct file *fp;
5075 	struct proc *p;
5076 	int header;
5077 	int n;
5078 
5079 	header = 1;
5080 	FOREACH_PROC_IN_SYSTEM(p) {
5081 		if (p->p_state == PRS_NEW)
5082 			continue;
5083 		if ((fdp = p->p_fd) == NULL)
5084 			continue;
5085 		for (n = 0; n < fdp->fd_nfiles; ++n) {
5086 			if ((fp = fdp->fd_ofiles[n].fde_file) == NULL)
5087 				continue;
5088 			db_print_file(fp, header);
5089 			header = 0;
5090 		}
5091 	}
5092 }
5093 #endif
5094 
5095 SYSCTL_INT(_kern, KERN_MAXFILESPERPROC, maxfilesperproc,
5096     CTLFLAG_RWTUN | CTLFLAG_NOFETCH,
5097     &maxfilesperproc, 0, "Maximum files allowed open per process");
5098 
5099 SYSCTL_INT(_kern, KERN_MAXFILES, maxfiles, CTLFLAG_RWTUN | CTLFLAG_NOFETCH,
5100     &maxfiles, 0, "Maximum number of files");
5101 
5102 SYSCTL_INT(_kern, OID_AUTO, openfiles, CTLFLAG_RD,
5103     &openfiles, 0, "System-wide number of open files");
5104 
5105 /* ARGSUSED*/
5106 static void
5107 filelistinit(void *dummy)
5108 {
5109 
5110 	file_zone = uma_zcreate("Files", sizeof(struct file), NULL, NULL,
5111 	    NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
5112 	filedesc0_zone = uma_zcreate("filedesc0", sizeof(struct filedesc0),
5113 	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
5114 	pwd_zone = uma_zcreate("PWD", sizeof(struct pwd), NULL, NULL,
5115 	    NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_SMR);
5116 	/*
5117 	 * XXXMJG this is a temporary hack due to boot ordering issues against
5118 	 * the vnode zone.
5119 	 */
5120 	vfs_smr = uma_zone_get_smr(pwd_zone);
5121 	mtx_init(&sigio_lock, "sigio lock", NULL, MTX_DEF);
5122 }
5123 SYSINIT(select, SI_SUB_LOCK, SI_ORDER_FIRST, filelistinit, NULL);
5124 
5125 /*-------------------------------------------------------------------*/
5126 
5127 static int
5128 badfo_readwrite(struct file *fp, struct uio *uio, struct ucred *active_cred,
5129     int flags, struct thread *td)
5130 {
5131 
5132 	return (EBADF);
5133 }
5134 
5135 static int
5136 badfo_truncate(struct file *fp, off_t length, struct ucred *active_cred,
5137     struct thread *td)
5138 {
5139 
5140 	return (EINVAL);
5141 }
5142 
5143 static int
5144 badfo_ioctl(struct file *fp, u_long com, void *data, struct ucred *active_cred,
5145     struct thread *td)
5146 {
5147 
5148 	return (EBADF);
5149 }
5150 
5151 static int
5152 badfo_poll(struct file *fp, int events, struct ucred *active_cred,
5153     struct thread *td)
5154 {
5155 
5156 	return (0);
5157 }
5158 
5159 static int
5160 badfo_kqfilter(struct file *fp, struct knote *kn)
5161 {
5162 
5163 	return (EBADF);
5164 }
5165 
5166 static int
5167 badfo_stat(struct file *fp, struct stat *sb, struct ucred *active_cred)
5168 {
5169 
5170 	return (EBADF);
5171 }
5172 
5173 static int
5174 badfo_close(struct file *fp, struct thread *td)
5175 {
5176 
5177 	return (0);
5178 }
5179 
5180 static int
5181 badfo_chmod(struct file *fp, mode_t mode, struct ucred *active_cred,
5182     struct thread *td)
5183 {
5184 
5185 	return (EBADF);
5186 }
5187 
5188 static int
5189 badfo_chown(struct file *fp, uid_t uid, gid_t gid, struct ucred *active_cred,
5190     struct thread *td)
5191 {
5192 
5193 	return (EBADF);
5194 }
5195 
5196 static int
5197 badfo_sendfile(struct file *fp, int sockfd, struct uio *hdr_uio,
5198     struct uio *trl_uio, off_t offset, size_t nbytes, off_t *sent, int flags,
5199     struct thread *td)
5200 {
5201 
5202 	return (EBADF);
5203 }
5204 
5205 static int
5206 badfo_fill_kinfo(struct file *fp, struct kinfo_file *kif, struct filedesc *fdp)
5207 {
5208 
5209 	return (0);
5210 }
5211 
5212 struct fileops badfileops = {
5213 	.fo_read = badfo_readwrite,
5214 	.fo_write = badfo_readwrite,
5215 	.fo_truncate = badfo_truncate,
5216 	.fo_ioctl = badfo_ioctl,
5217 	.fo_poll = badfo_poll,
5218 	.fo_kqfilter = badfo_kqfilter,
5219 	.fo_stat = badfo_stat,
5220 	.fo_close = badfo_close,
5221 	.fo_chmod = badfo_chmod,
5222 	.fo_chown = badfo_chown,
5223 	.fo_sendfile = badfo_sendfile,
5224 	.fo_fill_kinfo = badfo_fill_kinfo,
5225 };
5226 
5227 static int
5228 path_poll(struct file *fp, int events, struct ucred *active_cred,
5229     struct thread *td)
5230 {
5231 	return (POLLNVAL);
5232 }
5233 
5234 static int
5235 path_close(struct file *fp, struct thread *td)
5236 {
5237 	MPASS(fp->f_type == DTYPE_VNODE);
5238 	fp->f_ops = &badfileops;
5239 	vrele(fp->f_vnode);
5240 	return (0);
5241 }
5242 
5243 struct fileops path_fileops = {
5244 	.fo_read = badfo_readwrite,
5245 	.fo_write = badfo_readwrite,
5246 	.fo_truncate = badfo_truncate,
5247 	.fo_ioctl = badfo_ioctl,
5248 	.fo_poll = path_poll,
5249 	.fo_kqfilter = vn_kqfilter_opath,
5250 	.fo_stat = vn_statfile,
5251 	.fo_close = path_close,
5252 	.fo_chmod = badfo_chmod,
5253 	.fo_chown = badfo_chown,
5254 	.fo_sendfile = badfo_sendfile,
5255 	.fo_fill_kinfo = vn_fill_kinfo,
5256 	.fo_flags = DFLAG_PASSABLE,
5257 };
5258 
5259 int
5260 invfo_rdwr(struct file *fp, struct uio *uio, struct ucred *active_cred,
5261     int flags, struct thread *td)
5262 {
5263 
5264 	return (EOPNOTSUPP);
5265 }
5266 
5267 int
5268 invfo_truncate(struct file *fp, off_t length, struct ucred *active_cred,
5269     struct thread *td)
5270 {
5271 
5272 	return (EINVAL);
5273 }
5274 
5275 int
5276 invfo_ioctl(struct file *fp, u_long com, void *data,
5277     struct ucred *active_cred, struct thread *td)
5278 {
5279 
5280 	return (ENOTTY);
5281 }
5282 
5283 int
5284 invfo_poll(struct file *fp, int events, struct ucred *active_cred,
5285     struct thread *td)
5286 {
5287 
5288 	return (poll_no_poll(events));
5289 }
5290 
5291 int
5292 invfo_kqfilter(struct file *fp, struct knote *kn)
5293 {
5294 
5295 	return (EINVAL);
5296 }
5297 
5298 int
5299 invfo_chmod(struct file *fp, mode_t mode, struct ucred *active_cred,
5300     struct thread *td)
5301 {
5302 
5303 	return (EINVAL);
5304 }
5305 
5306 int
5307 invfo_chown(struct file *fp, uid_t uid, gid_t gid, struct ucred *active_cred,
5308     struct thread *td)
5309 {
5310 
5311 	return (EINVAL);
5312 }
5313 
5314 int
5315 invfo_sendfile(struct file *fp, int sockfd, struct uio *hdr_uio,
5316     struct uio *trl_uio, off_t offset, size_t nbytes, off_t *sent, int flags,
5317     struct thread *td)
5318 {
5319 
5320 	return (EINVAL);
5321 }
5322 
5323 /*-------------------------------------------------------------------*/
5324 
5325 /*
5326  * File Descriptor pseudo-device driver (/dev/fd/).
5327  *
5328  * Opening minor device N dup()s the file (if any) connected to file
5329  * descriptor N belonging to the calling process.  Note that this driver
5330  * consists of only the ``open()'' routine, because all subsequent
5331  * references to this file will be direct to the other driver.
5332  *
5333  * XXX: we could give this one a cloning event handler if necessary.
5334  */
5335 
5336 /* ARGSUSED */
5337 static int
5338 fdopen(struct cdev *dev, int mode, int type, struct thread *td)
5339 {
5340 
5341 	/*
5342 	 * XXX Kludge: set curthread->td_dupfd to contain the value of the
5343 	 * the file descriptor being sought for duplication. The error
5344 	 * return ensures that the vnode for this device will be released
5345 	 * by vn_open. Open will detect this special error and take the
5346 	 * actions in dupfdopen below. Other callers of vn_open or VOP_OPEN
5347 	 * will simply report the error.
5348 	 */
5349 	td->td_dupfd = dev2unit(dev);
5350 	return (ENODEV);
5351 }
5352 
5353 static struct cdevsw fildesc_cdevsw = {
5354 	.d_version =	D_VERSION,
5355 	.d_open =	fdopen,
5356 	.d_name =	"FD",
5357 };
5358 
5359 static void
5360 fildesc_drvinit(void *unused)
5361 {
5362 	struct cdev *dev;
5363 
5364 	dev = make_dev_credf(MAKEDEV_ETERNAL, &fildesc_cdevsw, 0, NULL,
5365 	    UID_ROOT, GID_WHEEL, 0666, "fd/0");
5366 	make_dev_alias(dev, "stdin");
5367 	dev = make_dev_credf(MAKEDEV_ETERNAL, &fildesc_cdevsw, 1, NULL,
5368 	    UID_ROOT, GID_WHEEL, 0666, "fd/1");
5369 	make_dev_alias(dev, "stdout");
5370 	dev = make_dev_credf(MAKEDEV_ETERNAL, &fildesc_cdevsw, 2, NULL,
5371 	    UID_ROOT, GID_WHEEL, 0666, "fd/2");
5372 	make_dev_alias(dev, "stderr");
5373 }
5374 
5375 SYSINIT(fildescdev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, fildesc_drvinit, NULL);
5376