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