2 * Copyright (c) 2005 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * Copyright (c) 1982, 1986, 1989, 1991, 1993
36 * The Regents of the University of California. All rights reserved.
37 * (c) UNIX System Laboratories, Inc.
38 * All or some portions of this file are derived from material licensed
39 * to the University of California by American Telephone and Telegraph
40 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
41 * the permission of UNIX System Laboratories, Inc.
43 * Redistribution and use in source and binary forms, with or without
44 * modification, are permitted provided that the following conditions
46 * 1. Redistributions of source code must retain the above copyright
47 * notice, this list of conditions and the following disclaimer.
48 * 2. Redistributions in binary form must reproduce the above copyright
49 * notice, this list of conditions and the following disclaimer in the
50 * documentation and/or other materials provided with the distribution.
51 * 3. All advertising materials mentioning features or use of this software
52 * must display the following acknowledgement:
53 * This product includes software developed by the University of
54 * California, Berkeley and its contributors.
55 * 4. Neither the name of the University nor the names of its contributors
56 * may be used to endorse or promote products derived from this software
57 * without specific prior written permission.
59 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
60 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
63 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
71 * @(#)kern_descrip.c 8.6 (Berkeley) 4/19/94
72 * $FreeBSD: src/sys/kern/kern_descrip.c,v 1.81.2.19 2004/02/28 00:43:31 tegge Exp $
73 * $DragonFly: src/sys/kern/kern_descrip.c,v 1.51 2005/12/01 18:30:08 dillon Exp $
76 #include "opt_compat.h"
77 #include <sys/param.h>
78 #include <sys/systm.h>
79 #include <sys/malloc.h>
80 #include <sys/sysproto.h>
82 #include <sys/filedesc.h>
83 #include <sys/kernel.h>
84 #include <sys/sysctl.h>
85 #include <sys/vnode.h>
87 #include <sys/nlookup.h>
90 #include <sys/filio.h>
91 #include <sys/fcntl.h>
92 #include <sys/unistd.h>
93 #include <sys/resourcevar.h>
94 #include <sys/event.h>
95 #include <sys/kern_syscall.h>
96 #include <sys/kcore.h>
97 #include <sys/kinfo.h>
100 #include <vm/vm_extern.h>
102 #include <sys/thread2.h>
103 #include <sys/file2.h>
105 static MALLOC_DEFINE(M_FILEDESC
, "file desc", "Open file descriptor table");
106 static MALLOC_DEFINE(M_FILEDESC_TO_LEADER
, "file desc to leader",
107 "file desc to leader structures");
108 MALLOC_DEFINE(M_FILE
, "file", "Open file structure");
109 static MALLOC_DEFINE(M_SIGIO
, "sigio", "sigio structures");
111 static d_open_t fdopen
;
114 #define CDEV_MAJOR 22
115 static struct cdevsw fildesc_cdevsw
= {
117 /* maj */ CDEV_MAJOR
,
129 /* strategy */ nostrategy
,
134 static int badfo_readwrite (struct file
*fp
, struct uio
*uio
,
135 struct ucred
*cred
, int flags
, struct thread
*td
);
136 static int badfo_ioctl (struct file
*fp
, u_long com
, caddr_t data
,
138 static int badfo_poll (struct file
*fp
, int events
,
139 struct ucred
*cred
, struct thread
*td
);
140 static int badfo_kqfilter (struct file
*fp
, struct knote
*kn
);
141 static int badfo_stat (struct file
*fp
, struct stat
*sb
, struct thread
*td
);
142 static int badfo_close (struct file
*fp
, struct thread
*td
);
143 static int badfo_shutdown (struct file
*fp
, int how
, struct thread
*td
);
146 * Descriptor management.
148 struct filelist filehead
; /* head of list of open files */
149 int nfiles
; /* actual number of open files */
153 * System calls on descriptors.
157 getdtablesize(struct getdtablesize_args
*uap
)
159 struct proc
*p
= curproc
;
162 min((int)p
->p_rlimit
[RLIMIT_NOFILE
].rlim_cur
, maxfilesperproc
);
167 * Duplicate a file descriptor to a particular value.
169 * note: keep in mind that a potential race condition exists when closing
170 * descriptors from a shared descriptor table (via rfork).
174 dup2(struct dup2_args
*uap
)
178 error
= kern_dup(DUP_FIXED
, uap
->from
, uap
->to
, uap
->sysmsg_fds
);
184 * Duplicate a file descriptor.
188 dup(struct dup_args
*uap
)
192 error
= kern_dup(DUP_VARIABLE
, uap
->fd
, 0, uap
->sysmsg_fds
);
198 kern_fcntl(int fd
, int cmd
, union fcntl_dat
*dat
)
200 struct thread
*td
= curthread
;
201 struct proc
*p
= td
->td_proc
;
202 struct filedesc
*fdp
= p
->p_fd
;
207 int tmp
, error
, flg
= F_POSIX
;
211 if ((unsigned)fd
>= fdp
->fd_nfiles
||
212 (fp
= fdp
->fd_files
[fd
].fp
) == NULL
)
214 pop
= &fdp
->fd_files
[fd
].fileflags
;
219 if (newmin
>= p
->p_rlimit
[RLIMIT_NOFILE
].rlim_cur
||
220 newmin
> maxfilesperproc
)
222 error
= kern_dup(DUP_VARIABLE
, fd
, newmin
, &dat
->fc_fd
);
226 dat
->fc_cloexec
= (*pop
& UF_EXCLOSE
) ? FD_CLOEXEC
: 0;
230 *pop
= (*pop
&~ UF_EXCLOSE
) |
231 (dat
->fc_cloexec
& FD_CLOEXEC
? UF_EXCLOSE
: 0);
235 dat
->fc_flags
= OFLAGS(fp
->f_flag
);
240 fp
->f_flag
&= ~FCNTLFLAGS
;
241 fp
->f_flag
|= FFLAGS(dat
->fc_flags
& ~O_ACCMODE
) & FCNTLFLAGS
;
242 tmp
= fp
->f_flag
& FNONBLOCK
;
243 error
= fo_ioctl(fp
, FIONBIO
, (caddr_t
)&tmp
, td
);
248 tmp
= fp
->f_flag
& FASYNC
;
249 error
= fo_ioctl(fp
, FIOASYNC
, (caddr_t
)&tmp
, td
);
254 fp
->f_flag
&= ~FNONBLOCK
;
256 fo_ioctl(fp
, FIONBIO
, (caddr_t
)&tmp
, td
);
262 error
= fo_ioctl(fp
, FIOGETOWN
, (caddr_t
)&dat
->fc_owner
, td
);
268 error
= fo_ioctl(fp
, FIOSETOWN
, (caddr_t
)&dat
->fc_owner
, td
);
274 /* Fall into F_SETLK */
277 if (fp
->f_type
!= DTYPE_VNODE
)
279 vp
= (struct vnode
*)fp
->f_data
;
282 * copyin/lockop may block
285 if (dat
->fc_flock
.l_whence
== SEEK_CUR
)
286 dat
->fc_flock
.l_start
+= fp
->f_offset
;
288 switch (dat
->fc_flock
.l_type
) {
290 if ((fp
->f_flag
& FREAD
) == 0) {
294 p
->p_leader
->p_flag
|= P_ADVLOCK
;
295 error
= VOP_ADVLOCK(vp
, (caddr_t
)p
->p_leader
, F_SETLK
,
296 &dat
->fc_flock
, flg
);
299 if ((fp
->f_flag
& FWRITE
) == 0) {
303 p
->p_leader
->p_flag
|= P_ADVLOCK
;
304 error
= VOP_ADVLOCK(vp
, (caddr_t
)p
->p_leader
, F_SETLK
,
305 &dat
->fc_flock
, flg
);
308 error
= VOP_ADVLOCK(vp
, (caddr_t
)p
->p_leader
, F_UNLCK
,
309 &dat
->fc_flock
, F_POSIX
);
315 /* Check for race with close */
316 if ((unsigned) fd
>= fdp
->fd_nfiles
||
317 fp
!= fdp
->fd_files
[fd
].fp
) {
318 dat
->fc_flock
.l_whence
= SEEK_SET
;
319 dat
->fc_flock
.l_start
= 0;
320 dat
->fc_flock
.l_len
= 0;
321 dat
->fc_flock
.l_type
= F_UNLCK
;
322 (void) VOP_ADVLOCK(vp
, (caddr_t
)p
->p_leader
,
323 F_UNLCK
, &dat
->fc_flock
, F_POSIX
);
329 if (fp
->f_type
!= DTYPE_VNODE
)
331 vp
= (struct vnode
*)fp
->f_data
;
333 * copyin/lockop may block
336 if (dat
->fc_flock
.l_type
!= F_RDLCK
&&
337 dat
->fc_flock
.l_type
!= F_WRLCK
&&
338 dat
->fc_flock
.l_type
!= F_UNLCK
) {
342 if (dat
->fc_flock
.l_whence
== SEEK_CUR
)
343 dat
->fc_flock
.l_start
+= fp
->f_offset
;
344 error
= VOP_ADVLOCK(vp
, (caddr_t
)p
->p_leader
, F_GETLK
,
345 &dat
->fc_flock
, F_POSIX
);
355 * The file control system call.
358 fcntl(struct fcntl_args
*uap
)
365 dat
.fc_fd
= uap
->arg
;
368 dat
.fc_cloexec
= uap
->arg
;
371 dat
.fc_flags
= uap
->arg
;
374 dat
.fc_owner
= uap
->arg
;
379 error
= copyin((caddr_t
)uap
->arg
, &dat
.fc_flock
,
380 sizeof(struct flock
));
386 error
= kern_fcntl(uap
->fd
, uap
->cmd
, &dat
);
391 uap
->sysmsg_result
= dat
.fc_fd
;
394 uap
->sysmsg_result
= dat
.fc_cloexec
;
397 uap
->sysmsg_result
= dat
.fc_flags
;
400 uap
->sysmsg_result
= dat
.fc_owner
;
402 error
= copyout(&dat
.fc_flock
, (caddr_t
)uap
->arg
,
403 sizeof(struct flock
));
412 * Common code for dup, dup2, and fcntl(F_DUPFD).
414 * The type flag can be either DUP_FIXED or DUP_VARIABLE. DUP_FIXED tells
415 * kern_dup() to destructively dup over an existing file descriptor if new
416 * is already open. DUP_VARIABLE tells kern_dup() to find the lowest
417 * unused file descriptor that is greater than or equal to new.
420 kern_dup(enum dup_type type
, int old
, int new, int *res
)
422 struct thread
*td
= curthread
;
423 struct proc
*p
= td
->td_proc
;
424 struct filedesc
*fdp
= p
->p_fd
;
428 boolean_t fdalloced
= FALSE
;
432 * Verify that we have a valid descriptor to dup from and
433 * possibly to dup to.
435 if (old
< 0 || new < 0 || new > p
->p_rlimit
[RLIMIT_NOFILE
].rlim_cur
||
436 new >= maxfilesperproc
)
438 if (old
>= fdp
->fd_nfiles
|| fdp
->fd_files
[old
].fp
== NULL
)
440 if (type
== DUP_FIXED
&& old
== new) {
444 fp
= fdp
->fd_files
[old
].fp
;
448 * Expand the table for the new descriptor if needed. This may
449 * block and drop and reacquire the fidedesc lock.
451 if (type
== DUP_VARIABLE
|| new >= fdp
->fd_nfiles
) {
452 error
= fdalloc(p
, new, &newfd
);
459 if (type
== DUP_VARIABLE
)
463 * If the old file changed out from under us then treat it as a
464 * bad file descriptor. Userland should do its own locking to
467 if (fdp
->fd_files
[old
].fp
!= fp
) {
468 if (fdp
->fd_files
[new].fp
== NULL
) {
470 fdreserve(fdp
, newfd
, -1);
471 if (new < fdp
->fd_freefile
)
472 fdp
->fd_freefile
= new;
473 while (fdp
->fd_lastfile
> 0 &&
474 fdp
->fd_files
[fdp
->fd_lastfile
].fp
== NULL
)
480 KASSERT(old
!= new, ("new fd is same as old"));
483 * Save info on the descriptor being overwritten. We have
484 * to do the unmap now, but we cannot close it without
485 * introducing an ownership race for the slot.
487 delfp
= fdp
->fd_files
[new].fp
;
488 if (delfp
!= NULL
&& p
->p_fdtol
!= NULL
) {
490 * Ask fdfree() to sleep to ensure that all relevant
491 * process leaders can be traversed in closef().
493 fdp
->fd_holdleaderscount
++;
497 KASSERT(delfp
== NULL
|| type
== DUP_FIXED
,
498 ("dup() picked an open file"));
500 if (delfp
&& (fdp
->fd_files
[new].fileflags
& UF_MAPPED
))
501 (void) munmapfd(p
, new);
505 * Duplicate the source descriptor, update lastfile
507 if (new > fdp
->fd_lastfile
)
508 fdp
->fd_lastfile
= new;
509 if (!fdalloced
&& fdp
->fd_files
[new].fp
== NULL
)
510 fdreserve(fdp
, new, 1);
511 fdp
->fd_files
[new].fp
= fp
;
512 fdp
->fd_files
[new].fileflags
=
513 fdp
->fd_files
[old
].fileflags
& ~UF_EXCLOSE
;
517 * If we dup'd over a valid file, we now own the reference to it
518 * and must dispose of it using closef() semantics (as if a
519 * close() were performed on it).
522 (void) closef(delfp
, td
);
524 fdp
->fd_holdleaderscount
--;
525 if (fdp
->fd_holdleaderscount
== 0 &&
526 fdp
->fd_holdleaderswakeup
!= 0) {
527 fdp
->fd_holdleaderswakeup
= 0;
528 wakeup(&fdp
->fd_holdleaderscount
);
536 * If sigio is on the list associated with a process or process group,
537 * disable signalling from the device, remove sigio from the list and
541 funsetown(struct sigio
*sigio
)
546 *(sigio
->sio_myref
) = NULL
;
548 if (sigio
->sio_pgid
< 0) {
549 SLIST_REMOVE(&sigio
->sio_pgrp
->pg_sigiolst
, sigio
,
551 } else /* if ((*sigiop)->sio_pgid > 0) */ {
552 SLIST_REMOVE(&sigio
->sio_proc
->p_sigiolst
, sigio
,
555 crfree(sigio
->sio_ucred
);
556 free(sigio
, M_SIGIO
);
559 /* Free a list of sigio structures. */
561 funsetownlst(struct sigiolst
*sigiolst
)
565 while ((sigio
= SLIST_FIRST(sigiolst
)) != NULL
)
570 * This is common code for FIOSETOWN ioctl called by fcntl(fd, F_SETOWN, arg).
572 * After permission checking, add a sigio structure to the sigio list for
573 * the process or process group.
576 fsetown(pid_t pgid
, struct sigio
**sigiop
)
592 * Policy - Don't allow a process to FSETOWN a process
593 * in another session.
595 * Remove this test to allow maximum flexibility or
596 * restrict FSETOWN to the current process or process
597 * group for maximum safety.
599 if (proc
->p_session
!= curproc
->p_session
)
603 } else /* if (pgid < 0) */ {
604 pgrp
= pgfind(-pgid
);
609 * Policy - Don't allow a process to FSETOWN a process
610 * in another session.
612 * Remove this test to allow maximum flexibility or
613 * restrict FSETOWN to the current process or process
614 * group for maximum safety.
616 if (pgrp
->pg_session
!= curproc
->p_session
)
622 sigio
= malloc(sizeof(struct sigio
), M_SIGIO
, M_WAITOK
);
624 SLIST_INSERT_HEAD(&proc
->p_sigiolst
, sigio
, sio_pgsigio
);
625 sigio
->sio_proc
= proc
;
627 SLIST_INSERT_HEAD(&pgrp
->pg_sigiolst
, sigio
, sio_pgsigio
);
628 sigio
->sio_pgrp
= pgrp
;
630 sigio
->sio_pgid
= pgid
;
631 sigio
->sio_ucred
= crhold(curproc
->p_ucred
);
632 /* It would be convenient if p_ruid was in ucred. */
633 sigio
->sio_ruid
= curproc
->p_ucred
->cr_ruid
;
634 sigio
->sio_myref
= sigiop
;
642 * This is common code for FIOGETOWN ioctl called by fcntl(fd, F_GETOWN, arg).
645 fgetown(struct sigio
*sigio
)
647 return (sigio
!= NULL
? sigio
->sio_pgid
: 0);
651 * Close many file descriptors.
656 closefrom(struct closefrom_args
*uap
)
658 return(kern_closefrom(uap
->fd
));
662 kern_closefrom(int fd
)
664 struct thread
*td
= curthread
;
665 struct proc
*p
= td
->td_proc
;
666 struct filedesc
*fdp
;
671 if (fd
< 0 || fd
> fdp
->fd_lastfile
)
675 if (kern_close(fdp
->fd_lastfile
) == EINTR
)
677 } while (fdp
->fd_lastfile
> fd
);
683 * Close a file descriptor.
688 close(struct close_args
*uap
)
690 return(kern_close(uap
->fd
));
696 struct thread
*td
= curthread
;
697 struct proc
*p
= td
->td_proc
;
698 struct filedesc
*fdp
;
706 if ((unsigned)fd
>= fdp
->fd_nfiles
||
707 (fp
= fdp
->fd_files
[fd
].fp
) == NULL
)
710 if (fdp
->fd_files
[fd
].fileflags
& UF_MAPPED
)
711 (void) munmapfd(p
, fd
);
715 if (p
->p_fdtol
!= NULL
) {
717 * Ask fdfree() to sleep to ensure that all relevant
718 * process leaders can be traversed in closef().
720 fdp
->fd_holdleaderscount
++;
725 * we now hold the fp reference that used to be owned by the descriptor
728 while (fdp
->fd_lastfile
> 0 && fdp
->fd_files
[fdp
->fd_lastfile
].fp
== NULL
)
730 if (fd
< fdp
->fd_knlistsize
)
731 knote_fdclose(p
, fd
);
732 error
= closef(fp
, td
);
734 fdp
->fd_holdleaderscount
--;
735 if (fdp
->fd_holdleaderscount
== 0 &&
736 fdp
->fd_holdleaderswakeup
!= 0) {
737 fdp
->fd_holdleaderswakeup
= 0;
738 wakeup(&fdp
->fd_holdleaderscount
);
745 * shutdown_args(int fd, int how)
748 kern_shutdown(int fd
, int how
)
750 struct thread
*td
= curthread
;
751 struct proc
*p
= td
->td_proc
;
752 struct filedesc
*fdp
;
759 if ((unsigned)fd
>= fdp
->fd_nfiles
||
760 (fp
= fdp
->fd_files
[fd
].fp
) == NULL
)
763 error
= fo_shutdown(fp
, how
, td
);
770 shutdown(struct shutdown_args
*uap
)
774 error
= kern_shutdown(uap
->s
, uap
->how
);
780 kern_fstat(int fd
, struct stat
*ub
)
782 struct thread
*td
= curthread
;
783 struct proc
*p
= td
->td_proc
;
784 struct filedesc
*fdp
;
791 if ((unsigned)fd
>= fdp
->fd_nfiles
||
792 (fp
= fdp
->fd_files
[fd
].fp
) == NULL
)
795 error
= fo_stat(fp
, ub
, td
);
802 * Return status information about a file descriptor.
805 fstat(struct fstat_args
*uap
)
810 error
= kern_fstat(uap
->fd
, &st
);
813 error
= copyout(&st
, uap
->sb
, sizeof(st
));
818 * Return pathconf information about a file descriptor.
822 fpathconf(struct fpathconf_args
*uap
)
824 struct thread
*td
= curthread
;
825 struct proc
*p
= td
->td_proc
;
826 struct filedesc
*fdp
;
833 if ((unsigned)uap
->fd
>= fdp
->fd_nfiles
||
834 (fp
= fdp
->fd_files
[uap
->fd
].fp
) == NULL
)
839 switch (fp
->f_type
) {
842 if (uap
->name
!= _PC_PIPE_BUF
) {
845 uap
->sysmsg_result
= PIPE_BUF
;
851 vp
= (struct vnode
*)fp
->f_data
;
852 error
= VOP_PATHCONF(vp
, uap
->name
, uap
->sysmsg_fds
);
863 SYSCTL_INT(_debug
, OID_AUTO
, fdexpand
, CTLFLAG_RD
, &fdexpand
, 0, "");
866 fdgrow(struct filedesc
*fdp
, int want
)
868 struct fdnode
*newfiles
;
869 struct fdnode
*oldfiles
;
874 /* nf has to be of the form 2^n - 1 */
876 } while (nf
<= want
);
878 newfiles
= malloc(nf
* sizeof(struct fdnode
), M_FILEDESC
, M_WAITOK
);
881 * deal with file-table extend race that might have occured
882 * when malloc was blocked.
884 if (fdp
->fd_nfiles
>= nf
) {
885 free(newfiles
, M_FILEDESC
);
889 * Copy the existing ofile and ofileflags arrays
890 * and zero the new portion of each array.
892 extra
= nf
- fdp
->fd_nfiles
;
893 bcopy(fdp
->fd_files
, newfiles
, fdp
->fd_nfiles
* sizeof(struct fdnode
));
894 bzero(&newfiles
[fdp
->fd_nfiles
], extra
* sizeof(struct fdnode
));
896 oldfiles
= fdp
->fd_files
;
897 fdp
->fd_files
= newfiles
;
900 if (oldfiles
!= fdp
->fd_builtin_files
)
901 free(oldfiles
, M_FILEDESC
);
906 * Number of nodes in right subtree, including the root.
909 right_subtree_size(int n
)
911 return (n
^ (n
| (n
+ 1)));
918 right_ancestor(int n
)
920 return (n
| (n
+ 1));
929 return ((n
& (n
+ 1)) - 1);
933 fdreserve(struct filedesc
*fdp
, int fd
, int incr
)
936 fdp
->fd_files
[fd
].allocated
+= incr
;
937 KKASSERT(fdp
->fd_files
[fd
].allocated
>= 0);
938 fd
= left_ancestor(fd
);
943 * Allocate a file descriptor for the process.
946 fdalloc(struct proc
*p
, int want
, int *result
)
948 struct filedesc
*fdp
= p
->p_fd
;
949 int fd
, rsize
, rsum
, node
, lim
;
951 lim
= min((int)p
->p_rlimit
[RLIMIT_NOFILE
].rlim_cur
, maxfilesperproc
);
954 if (want
>= fdp
->fd_nfiles
)
958 * Search for a free descriptor starting at the higher
959 * of want or fd_freefile. If that fails, consider
960 * expanding the ofile array.
963 /* move up the tree looking for a subtree with a free node */
964 for (fd
= max(want
, fdp
->fd_freefile
); fd
< min(fdp
->fd_nfiles
, lim
);
965 fd
= right_ancestor(fd
)) {
966 if (fdp
->fd_files
[fd
].allocated
== 0)
969 rsize
= right_subtree_size(fd
);
970 if (fdp
->fd_files
[fd
].allocated
== rsize
)
971 continue; /* right subtree full */
974 * Free fd is in the right subtree of the tree rooted at fd.
975 * Call that subtree R. Look for the smallest (leftmost)
976 * subtree of R with an unallocated fd: continue moving
977 * down the left branch until encountering a full left
978 * subtree, then move to the right.
980 for (rsum
= 0, rsize
/= 2; rsize
> 0; rsize
/= 2) {
982 rsum
+= fdp
->fd_files
[node
].allocated
;
983 if (fdp
->fd_files
[fd
].allocated
== rsum
+ rsize
) {
984 fd
= node
; /* move to the right */
985 if (fdp
->fd_files
[node
].allocated
== 0)
994 * No space in current array. Expand?
996 if (fdp
->fd_nfiles
>= lim
)
1002 KKASSERT(fd
< fdp
->fd_nfiles
);
1003 fdp
->fd_files
[fd
].fileflags
= 0;
1004 if (fd
> fdp
->fd_lastfile
)
1005 fdp
->fd_lastfile
= fd
;
1006 if (want
<= fdp
->fd_freefile
)
1007 fdp
->fd_freefile
= fd
;
1009 KKASSERT(fdp
->fd_files
[fd
].fp
== NULL
);
1010 fdreserve(fdp
, fd
, 1);
1015 * Check to see whether n user file descriptors
1016 * are available to the process p.
1019 fdavail(struct proc
*p
, int n
)
1021 struct filedesc
*fdp
= p
->p_fd
;
1022 struct fdnode
*fdnode
;
1025 lim
= min((int)p
->p_rlimit
[RLIMIT_NOFILE
].rlim_cur
, maxfilesperproc
);
1026 if ((i
= lim
- fdp
->fd_nfiles
) > 0 && (n
-= i
) <= 0)
1029 last
= min(fdp
->fd_nfiles
, lim
);
1030 fdnode
= &fdp
->fd_files
[fdp
->fd_freefile
];
1031 for (i
= last
- fdp
->fd_freefile
; --i
>= 0; ++fdnode
) {
1032 if (fdnode
->fp
== NULL
&& --n
<= 0)
1040 * Create a new open file structure and allocate a file decriptor
1041 * for the process that refers to it. If p is NULL, no descriptor
1042 * is allocated and the file pointer is returned unassociated with
1043 * any process. resultfd is only used if p is not NULL and may
1044 * separately be NULL indicating that you don't need the returned fd.
1046 * A held file pointer is returned. If a descriptor has been allocated
1047 * an additional hold on the fp will be made due to the fd_files[]
1051 falloc(struct proc
*p
, struct file
**resultfp
, int *resultfd
)
1053 static struct timeval lastfail
;
1061 * Handle filetable full issues and root overfill.
1063 if (nfiles
>= maxfiles
- maxfilesrootres
&&
1064 ((p
&& p
->p_ucred
->cr_ruid
!= 0) || nfiles
>= maxfiles
)) {
1065 if (ppsratecheck(&lastfail
, &curfail
, 1)) {
1066 printf("kern.maxfiles limit exceeded by uid %d, please see tuning(7).\n",
1067 (p
? p
->p_ucred
->cr_ruid
: -1));
1074 * Allocate a new file descriptor.
1077 fp
= malloc(sizeof(struct file
), M_FILE
, M_WAITOK
| M_ZERO
);
1079 fp
->f_ops
= &badfileops
;
1082 fp
->f_cred
= crhold(p
->p_ucred
);
1084 fp
->f_cred
= crhold(proc0
.p_ucred
);
1085 LIST_INSERT_HEAD(&filehead
, fp
, f_list
);
1087 if ((error
= fsetfd(p
, fp
, resultfd
)) != 0) {
1088 fdrop(fp
, p
->p_thread
);
1100 * Associate a file pointer with a file descriptor. On success the fp
1101 * will have an additional ref representing the fd_files[] association.
1104 fsetfd(struct proc
*p
, struct file
*fp
, int *resultfd
)
1109 if ((error
= fdalloc(p
, 0, &fd
)) == 0) {
1111 p
->p_fd
->fd_files
[fd
].fp
= fp
;
1118 funsetfd(struct filedesc
*fdp
, int fd
)
1120 fdp
->fd_files
[fd
].fp
= NULL
;
1121 fdp
->fd_files
[fd
].fileflags
= 0;
1122 fdreserve(fdp
, fd
, -1);
1123 if (fd
< fdp
->fd_freefile
)
1124 fdp
->fd_freefile
= fd
;
1128 fsetcred(struct file
*fp
, struct ucred
*cr
)
1136 * Free a file descriptor.
1139 ffree(struct file
*fp
)
1141 KASSERT((fp
->f_count
== 0), ("ffree: fp_fcount not 0!"));
1142 LIST_REMOVE(fp
, f_list
);
1145 cache_drop(fp
->f_ncp
);
1153 * Build a new filedesc structure.
1156 fdinit(struct proc
*p
)
1158 struct filedesc
*newfdp
;
1159 struct filedesc
*fdp
= p
->p_fd
;
1161 newfdp
= malloc(sizeof(struct filedesc
), M_FILEDESC
, M_WAITOK
|M_ZERO
);
1163 newfdp
->fd_cdir
= fdp
->fd_cdir
;
1164 vref(newfdp
->fd_cdir
);
1165 newfdp
->fd_ncdir
= cache_hold(fdp
->fd_ncdir
);
1169 * rdir may not be set in e.g. proc0 or anything vm_fork'd off of
1170 * proc0, but should unconditionally exist in other processes.
1173 newfdp
->fd_rdir
= fdp
->fd_rdir
;
1174 vref(newfdp
->fd_rdir
);
1175 newfdp
->fd_nrdir
= cache_hold(fdp
->fd_nrdir
);
1178 newfdp
->fd_jdir
= fdp
->fd_jdir
;
1179 vref(newfdp
->fd_jdir
);
1180 newfdp
->fd_njdir
= cache_hold(fdp
->fd_njdir
);
1183 /* Create the file descriptor table. */
1184 newfdp
->fd_refcnt
= 1;
1185 newfdp
->fd_cmask
= cmask
;
1186 newfdp
->fd_files
= newfdp
->fd_builtin_files
;
1187 newfdp
->fd_nfiles
= NDFILE
;
1188 newfdp
->fd_knlistsize
= -1;
1194 * Share a filedesc structure.
1197 fdshare(struct proc
*p
)
1199 p
->p_fd
->fd_refcnt
++;
1204 * Copy a filedesc structure.
1207 fdcopy(struct proc
*p
)
1209 struct filedesc
*newfdp
, *fdp
= p
->p_fd
;
1210 struct fdnode
*fdnode
;
1213 /* Certain daemons might not have file descriptors. */
1217 newfdp
= malloc(sizeof(struct filedesc
), M_FILEDESC
, M_WAITOK
);
1219 if (newfdp
->fd_cdir
) {
1220 vref(newfdp
->fd_cdir
);
1221 newfdp
->fd_ncdir
= cache_hold(newfdp
->fd_ncdir
);
1224 * We must check for fd_rdir here, at least for now because
1225 * the init process is created before we have access to the
1226 * rootvode to take a reference to it.
1228 if (newfdp
->fd_rdir
) {
1229 vref(newfdp
->fd_rdir
);
1230 newfdp
->fd_nrdir
= cache_hold(newfdp
->fd_nrdir
);
1232 if (newfdp
->fd_jdir
) {
1233 vref(newfdp
->fd_jdir
);
1234 newfdp
->fd_njdir
= cache_hold(newfdp
->fd_njdir
);
1236 newfdp
->fd_refcnt
= 1;
1239 * If the number of open files fits in the internal arrays
1240 * of the open file structure, use them, otherwise allocate
1241 * additional memory for the number of descriptors currently
1244 if (newfdp
->fd_lastfile
< NDFILE
) {
1245 newfdp
->fd_files
= newfdp
->fd_builtin_files
;
1249 * Compute the smallest file table size
1250 * for the file descriptors currently in use,
1251 * allowing the table to shrink.
1253 i
= newfdp
->fd_nfiles
;
1254 while ((i
-1)/2 > newfdp
->fd_lastfile
&& (i
-1)/2 > NDFILE
)
1256 newfdp
->fd_files
= malloc(i
* sizeof(struct fdnode
),
1257 M_FILEDESC
, M_WAITOK
);
1259 newfdp
->fd_nfiles
= i
;
1261 if (fdp
->fd_files
!= fdp
->fd_builtin_files
||
1262 newfdp
->fd_files
!= newfdp
->fd_builtin_files
1264 bcopy(fdp
->fd_files
, newfdp
->fd_files
,
1265 i
* sizeof(struct fdnode
));
1269 * kq descriptors cannot be copied.
1271 if (newfdp
->fd_knlistsize
!= -1) {
1272 fdnode
= &newfdp
->fd_files
[newfdp
->fd_lastfile
];
1273 for (i
= newfdp
->fd_lastfile
; i
>= 0; i
--, fdnode
--) {
1274 if (fdnode
->fp
!= NULL
&& fdnode
->fp
->f_type
== DTYPE_KQUEUE
)
1275 funsetfd(newfdp
, i
); /* nulls out *fpp */
1276 if (fdnode
->fp
== NULL
&& i
== newfdp
->fd_lastfile
&& i
> 0)
1277 newfdp
->fd_lastfile
--;
1279 newfdp
->fd_knlist
= NULL
;
1280 newfdp
->fd_knlistsize
= -1;
1281 newfdp
->fd_knhash
= NULL
;
1282 newfdp
->fd_knhashmask
= 0;
1285 fdnode
= newfdp
->fd_files
;
1286 for (i
= newfdp
->fd_lastfile
; i
-- >= 0; fdnode
++) {
1287 if (fdnode
->fp
!= NULL
)
1294 * Release a filedesc structure.
1297 fdfree(struct proc
*p
)
1299 struct thread
*td
= p
->p_thread
;
1300 struct filedesc
*fdp
= p
->p_fd
;
1301 struct fdnode
*fdnode
;
1303 struct filedesc_to_leader
*fdtol
;
1308 /* Certain daemons might not have file descriptors. */
1312 /* Check for special need to clear POSIX style locks */
1314 if (fdtol
!= NULL
) {
1315 KASSERT(fdtol
->fdl_refcount
> 0,
1316 ("filedesc_to_refcount botch: fdl_refcount=%d",
1317 fdtol
->fdl_refcount
));
1318 if (fdtol
->fdl_refcount
== 1 &&
1319 (p
->p_leader
->p_flag
& P_ADVLOCK
) != 0) {
1321 fdnode
= fdp
->fd_files
;
1322 for (i
= 0; i
<= fdp
->fd_lastfile
; i
++, fdnode
++) {
1323 if (fdnode
->fp
== NULL
||
1324 fdnode
->fp
->f_type
!= DTYPE_VNODE
)
1328 lf
.l_whence
= SEEK_SET
;
1331 lf
.l_type
= F_UNLCK
;
1332 vp
= (struct vnode
*)fp
->f_data
;
1333 (void) VOP_ADVLOCK(vp
,
1334 (caddr_t
)p
->p_leader
,
1338 fdrop(fp
, p
->p_thread
);
1339 /* reload due to possible reallocation */
1340 fdnode
= &fdp
->fd_files
[i
];
1344 if (fdtol
->fdl_refcount
== 1) {
1345 if (fdp
->fd_holdleaderscount
> 0 &&
1346 (p
->p_leader
->p_flag
& P_ADVLOCK
) != 0) {
1348 * close() or do_dup() has cleared a reference
1349 * in a shared file descriptor table.
1351 fdp
->fd_holdleaderswakeup
= 1;
1352 tsleep(&fdp
->fd_holdleaderscount
,
1356 if (fdtol
->fdl_holdcount
> 0) {
1358 * Ensure that fdtol->fdl_leader
1359 * remains valid in closef().
1361 fdtol
->fdl_wakeup
= 1;
1362 tsleep(fdtol
, 0, "fdlhold", 0);
1366 fdtol
->fdl_refcount
--;
1367 if (fdtol
->fdl_refcount
== 0 &&
1368 fdtol
->fdl_holdcount
== 0) {
1369 fdtol
->fdl_next
->fdl_prev
= fdtol
->fdl_prev
;
1370 fdtol
->fdl_prev
->fdl_next
= fdtol
->fdl_next
;
1375 free(fdtol
, M_FILEDESC_TO_LEADER
);
1377 if (--fdp
->fd_refcnt
> 0)
1380 * we are the last reference to the structure, we can
1381 * safely assume it will not change out from under us.
1383 for (i
= 0; i
<= fdp
->fd_lastfile
; ++i
) {
1384 if (fdp
->fd_files
[i
].fp
)
1385 closef(fdp
->fd_files
[i
].fp
, td
);
1387 if (fdp
->fd_files
!= fdp
->fd_builtin_files
)
1388 free(fdp
->fd_files
, M_FILEDESC
);
1390 cache_drop(fdp
->fd_ncdir
);
1391 vrele(fdp
->fd_cdir
);
1394 cache_drop(fdp
->fd_nrdir
);
1395 vrele(fdp
->fd_rdir
);
1398 cache_drop(fdp
->fd_njdir
);
1399 vrele(fdp
->fd_jdir
);
1402 free(fdp
->fd_knlist
, M_KQUEUE
);
1404 free(fdp
->fd_knhash
, M_KQUEUE
);
1405 free(fdp
, M_FILEDESC
);
1409 * For setugid programs, we don't want to people to use that setugidness
1410 * to generate error messages which write to a file which otherwise would
1411 * otherwise be off-limits to the process.
1413 * This is a gross hack to plug the hole. A better solution would involve
1414 * a special vop or other form of generalized access control mechanism. We
1415 * go ahead and just reject all procfs file systems accesses as dangerous.
1417 * Since setugidsafety calls this only for fd 0, 1 and 2, this check is
1418 * sufficient. We also don't for check setugidness since we know we are.
1421 is_unsafe(struct file
*fp
)
1423 if (fp
->f_type
== DTYPE_VNODE
&&
1424 ((struct vnode
*)(fp
->f_data
))->v_tag
== VT_PROCFS
)
1430 * Make this setguid thing safe, if at all possible.
1433 setugidsafety(struct proc
*p
)
1435 struct thread
*td
= p
->p_thread
;
1436 struct filedesc
*fdp
= p
->p_fd
;
1439 /* Certain daemons might not have file descriptors. */
1444 * note: fdp->fd_files may be reallocated out from under us while
1445 * we are blocked in a close. Be careful!
1447 for (i
= 0; i
<= fdp
->fd_lastfile
; i
++) {
1450 if (fdp
->fd_files
[i
].fp
&& is_unsafe(fdp
->fd_files
[i
].fp
)) {
1454 if ((fdp
->fd_files
[i
].fileflags
& UF_MAPPED
) != 0)
1455 (void) munmapfd(p
, i
);
1457 if (i
< fdp
->fd_knlistsize
)
1458 knote_fdclose(p
, i
);
1460 * NULL-out descriptor prior to close to avoid
1461 * a race while close blocks.
1463 fp
= fdp
->fd_files
[i
].fp
;
1468 while (fdp
->fd_lastfile
> 0 && fdp
->fd_files
[fdp
->fd_lastfile
].fp
== NULL
)
1473 * Close any files on exec?
1476 fdcloseexec(struct proc
*p
)
1478 struct thread
*td
= p
->p_thread
;
1479 struct filedesc
*fdp
= p
->p_fd
;
1482 /* Certain daemons might not have file descriptors. */
1487 * We cannot cache fd_files since operations may block and rip
1488 * them out from under us.
1490 for (i
= 0; i
<= fdp
->fd_lastfile
; i
++) {
1491 if (fdp
->fd_files
[i
].fp
!= NULL
&&
1492 (fdp
->fd_files
[i
].fileflags
& UF_EXCLOSE
)) {
1496 if (fdp
->fd_files
[i
].fileflags
& UF_MAPPED
)
1497 (void) munmapfd(p
, i
);
1499 if (i
< fdp
->fd_knlistsize
)
1500 knote_fdclose(p
, i
);
1502 * NULL-out descriptor prior to close to avoid
1503 * a race while close blocks.
1505 fp
= fdp
->fd_files
[i
].fp
;
1510 while (fdp
->fd_lastfile
> 0 && fdp
->fd_files
[fdp
->fd_lastfile
].fp
== NULL
)
1515 * It is unsafe for set[ug]id processes to be started with file
1516 * descriptors 0..2 closed, as these descriptors are given implicit
1517 * significance in the Standard C library. fdcheckstd() will create a
1518 * descriptor referencing /dev/null for each of stdin, stdout, and
1519 * stderr that is not already open.
1522 fdcheckstd(struct proc
*p
)
1524 struct thread
*td
= p
->p_thread
;
1525 struct nlookupdata nd
;
1526 struct filedesc
*fdp
;
1529 int fd
, i
, error
, flags
, devnull
;
1536 for (i
= 0; i
< 3; i
++) {
1537 if (fdp
->fd_files
[i
].fp
!= NULL
)
1540 if ((error
= falloc(p
, &fp
, NULL
)) != 0)
1543 error
= nlookup_init(&nd
, "/dev/null", UIO_SYSSPACE
,
1544 NLC_FOLLOW
|NLC_LOCKVP
);
1545 flags
= FREAD
| FWRITE
;
1547 error
= vn_open(&nd
, fp
, flags
, 0);
1549 error
= fsetfd(p
, fp
, &fd
);
1557 error
= kern_dup(DUP_FIXED
, devnull
, i
, &retval
);
1566 * Internal form of close.
1567 * Decrement reference count on file structure.
1568 * Note: td and/or p may be NULL when closing a file
1569 * that was being passed in a message.
1572 closef(struct file
*fp
, struct thread
*td
)
1576 struct filedesc_to_leader
*fdtol
;
1583 p
= NULL
; /* allow no proc association */
1585 p
= td
->td_proc
; /* can also be NULL */
1588 * POSIX record locking dictates that any close releases ALL
1589 * locks owned by this process. This is handled by setting
1590 * a flag in the unlock to free ONLY locks obeying POSIX
1591 * semantics, and not to free BSD-style file locks.
1592 * If the descriptor was in a message, POSIX-style locks
1593 * aren't passed with the descriptor.
1596 fp
->f_type
== DTYPE_VNODE
) {
1597 if ((p
->p_leader
->p_flag
& P_ADVLOCK
) != 0) {
1598 lf
.l_whence
= SEEK_SET
;
1601 lf
.l_type
= F_UNLCK
;
1602 vp
= (struct vnode
*)fp
->f_data
;
1603 (void) VOP_ADVLOCK(vp
, (caddr_t
)p
->p_leader
, F_UNLCK
,
1607 if (fdtol
!= NULL
) {
1609 * Handle special case where file descriptor table
1610 * is shared between multiple process leaders.
1612 for (fdtol
= fdtol
->fdl_next
;
1613 fdtol
!= p
->p_fdtol
;
1614 fdtol
= fdtol
->fdl_next
) {
1615 if ((fdtol
->fdl_leader
->p_flag
&
1618 fdtol
->fdl_holdcount
++;
1619 lf
.l_whence
= SEEK_SET
;
1622 lf
.l_type
= F_UNLCK
;
1623 vp
= (struct vnode
*)fp
->f_data
;
1624 (void) VOP_ADVLOCK(vp
,
1625 (caddr_t
)p
->p_leader
,
1626 F_UNLCK
, &lf
, F_POSIX
);
1627 fdtol
->fdl_holdcount
--;
1628 if (fdtol
->fdl_holdcount
== 0 &&
1629 fdtol
->fdl_wakeup
!= 0) {
1630 fdtol
->fdl_wakeup
= 0;
1636 return (fdrop(fp
, td
));
1640 fdrop(struct file
*fp
, struct thread
*td
)
1646 if (--fp
->f_count
> 0)
1648 if (fp
->f_count
< 0)
1649 panic("fdrop: count < 0");
1650 if ((fp
->f_flag
& FHASLOCK
) && fp
->f_type
== DTYPE_VNODE
) {
1651 lf
.l_whence
= SEEK_SET
;
1654 lf
.l_type
= F_UNLCK
;
1655 vp
= (struct vnode
*)fp
->f_data
;
1656 (void) VOP_ADVLOCK(vp
, (caddr_t
)fp
, F_UNLCK
, &lf
, F_FLOCK
);
1658 if (fp
->f_ops
!= &badfileops
)
1659 error
= fo_close(fp
, td
);
1667 * Apply an advisory lock on a file descriptor.
1669 * Just attempt to get a record lock of the requested type on
1670 * the entire file (l_whence = SEEK_SET, l_start = 0, l_len = 0).
1674 flock(struct flock_args
*uap
)
1676 struct proc
*p
= curproc
;
1677 struct filedesc
*fdp
= p
->p_fd
;
1682 if ((unsigned)uap
->fd
>= fdp
->fd_nfiles
||
1683 (fp
= fdp
->fd_files
[uap
->fd
].fp
) == NULL
)
1685 if (fp
->f_type
!= DTYPE_VNODE
)
1686 return (EOPNOTSUPP
);
1687 vp
= (struct vnode
*)fp
->f_data
;
1688 lf
.l_whence
= SEEK_SET
;
1691 if (uap
->how
& LOCK_UN
) {
1692 lf
.l_type
= F_UNLCK
;
1693 fp
->f_flag
&= ~FHASLOCK
;
1694 return (VOP_ADVLOCK(vp
, (caddr_t
)fp
, F_UNLCK
, &lf
, F_FLOCK
));
1696 if (uap
->how
& LOCK_EX
)
1697 lf
.l_type
= F_WRLCK
;
1698 else if (uap
->how
& LOCK_SH
)
1699 lf
.l_type
= F_RDLCK
;
1702 fp
->f_flag
|= FHASLOCK
;
1703 if (uap
->how
& LOCK_NB
)
1704 return (VOP_ADVLOCK(vp
, (caddr_t
)fp
, F_SETLK
, &lf
, F_FLOCK
));
1705 return (VOP_ADVLOCK(vp
, (caddr_t
)fp
, F_SETLK
, &lf
, F_FLOCK
|F_WAIT
));
1709 * File Descriptor pseudo-device driver (/dev/fd/).
1711 * Opening minor device N dup()s the file (if any) connected to file
1712 * descriptor N belonging to the calling process. Note that this driver
1713 * consists of only the ``open()'' routine, because all subsequent
1714 * references to this file will be direct to the other driver.
1718 fdopen(dev_t dev
, int mode
, int type
, struct thread
*td
)
1720 KKASSERT(td
->td_lwp
!= NULL
);
1723 * XXX Kludge: set curlwp->lwp_dupfd to contain the value of the
1724 * the file descriptor being sought for duplication. The error
1725 * return ensures that the vnode for this device will be released
1726 * by vn_open. Open will detect this special error and take the
1727 * actions in dupfdopen below. Other callers of vn_open or VOP_OPEN
1728 * will simply report the error.
1730 td
->td_lwp
->lwp_dupfd
= minor(dev
);
1735 * Duplicate the specified descriptor to a free descriptor.
1738 dupfdopen(struct filedesc
*fdp
, int indx
, int dfd
, int mode
, int error
)
1744 * If the to-be-dup'd fd number is greater than the allowed number
1745 * of file descriptors, or the fd to be dup'd has already been
1746 * closed, then reject.
1748 if ((u_int
)dfd
>= fdp
->fd_nfiles
||
1749 (wfp
= fdp
->fd_files
[dfd
].fp
) == NULL
) {
1754 * There are two cases of interest here.
1756 * For ENODEV simply dup (dfd) to file descriptor
1757 * (indx) and return.
1759 * For ENXIO steal away the file structure from (dfd) and
1760 * store it in (indx). (dfd) is effectively closed by
1763 * Any other error code is just returned.
1768 * Check that the mode the file is being opened for is a
1769 * subset of the mode of the existing descriptor.
1771 if (((mode
& (FREAD
|FWRITE
)) | wfp
->f_flag
) != wfp
->f_flag
)
1773 fp
= fdp
->fd_files
[indx
].fp
;
1775 if (fp
&& fdp
->fd_files
[indx
].fileflags
& UF_MAPPED
)
1776 (void) munmapfd(p
, indx
);
1778 fdp
->fd_files
[indx
].fp
= wfp
;
1779 fdp
->fd_files
[indx
].fileflags
= fdp
->fd_files
[dfd
].fileflags
;
1781 if (indx
> fdp
->fd_lastfile
)
1782 fdp
->fd_lastfile
= indx
;
1784 * we now own the reference to fp that the ofiles[] array
1785 * used to own. Release it.
1788 fdrop(fp
, curthread
);
1793 * Steal away the file pointer from dfd, and stuff it into indx.
1795 fp
= fdp
->fd_files
[indx
].fp
;
1797 if (fp
&& fdp
->fd_files
[indx
].fileflags
& UF_MAPPED
)
1798 (void) munmapfd(p
, indx
);
1800 fdp
->fd_files
[indx
].fp
= fdp
->fd_files
[dfd
].fp
;
1801 fdp
->fd_files
[indx
].fileflags
= fdp
->fd_files
[dfd
].fileflags
;
1805 * we now own the reference to fp that the files[] array
1806 * used to own. Release it.
1809 fdrop(fp
, curthread
);
1811 * Complete the clean up of the filedesc structure by
1812 * recomputing the various hints.
1814 if (indx
> fdp
->fd_lastfile
) {
1815 fdp
->fd_lastfile
= indx
;
1817 while (fdp
->fd_lastfile
> 0 &&
1818 fdp
->fd_files
[fdp
->fd_lastfile
].fp
== NULL
) {
1831 struct filedesc_to_leader
*
1832 filedesc_to_leader_alloc(struct filedesc_to_leader
*old
,
1833 struct proc
*leader
)
1835 struct filedesc_to_leader
*fdtol
;
1837 fdtol
= malloc(sizeof(struct filedesc_to_leader
),
1838 M_FILEDESC_TO_LEADER
, M_WAITOK
);
1839 fdtol
->fdl_refcount
= 1;
1840 fdtol
->fdl_holdcount
= 0;
1841 fdtol
->fdl_wakeup
= 0;
1842 fdtol
->fdl_leader
= leader
;
1844 fdtol
->fdl_next
= old
->fdl_next
;
1845 fdtol
->fdl_prev
= old
;
1846 old
->fdl_next
= fdtol
;
1847 fdtol
->fdl_next
->fdl_prev
= fdtol
;
1849 fdtol
->fdl_next
= fdtol
;
1850 fdtol
->fdl_prev
= fdtol
;
1856 * Get file structures.
1859 sysctl_kern_file(SYSCTL_HANDLER_ARGS
)
1861 struct kinfo_file kf
;
1862 struct filedesc
*fdp
;
1871 * Note: because the number of file descriptors is calculated
1872 * in different ways for sizing vs returning the data,
1873 * there is information leakage from the first loop. However,
1874 * it is of a similar order of magnitude to the leakage from
1875 * global system statistics such as kern.openfiles.
1877 * When just doing a count, note that we cannot just count
1878 * the elements and add f_count via the filehead list because
1879 * threaded processes share their descriptor table and f_count might
1880 * still be '1' in that case.
1882 * Since the SYSCTL op can block, we must hold the process to
1883 * prevent it being ripped out from under us either in the
1884 * file descriptor loop or in the greater LIST_FOREACH. The
1885 * process may be in varying states of disrepair. If the process
1886 * is in SZOMB we may have caught it just as it is being removed
1887 * from the allproc list, we must skip it in that case to maintain
1888 * an unbroken chain through the allproc list.
1892 LIST_FOREACH(p
, &allproc
, p_list
) {
1893 if (p
->p_stat
== SIDL
|| (p
->p_flag
& P_ZOMBIE
))
1895 if (!PRISON_CHECK(req
->td
->td_proc
->p_ucred
, p
->p_ucred
) != 0)
1897 if ((fdp
= p
->p_fd
) == NULL
)
1900 for (n
= 0; n
< fdp
->fd_nfiles
; ++n
) {
1901 if ((fp
= fdp
->fd_files
[n
].fp
) == NULL
)
1903 if (req
->oldptr
== NULL
) {
1906 uid
= p
->p_ucred
? p
->p_ucred
->cr_uid
: -1;
1907 kcore_make_file(&kf
, fp
, p
->p_pid
, uid
, n
);
1908 error
= SYSCTL_OUT(req
, &kf
, sizeof(kf
));
1919 * When just calculating the size, overestimate a bit to try to
1920 * prevent system activity from causing the buffer-fill call
1923 if (req
->oldptr
== NULL
) {
1924 count
= (count
+ 16) + (count
/ 10);
1925 error
= SYSCTL_OUT(req
, NULL
, count
* sizeof(kf
));
1930 SYSCTL_PROC(_kern
, KERN_FILE
, file
, CTLTYPE_OPAQUE
|CTLFLAG_RD
,
1931 0, 0, sysctl_kern_file
, "S,file", "Entire file table");
1933 SYSCTL_INT(_kern
, KERN_MAXFILESPERPROC
, maxfilesperproc
, CTLFLAG_RW
,
1934 &maxfilesperproc
, 0, "Maximum files allowed open per process");
1936 SYSCTL_INT(_kern
, KERN_MAXFILES
, maxfiles
, CTLFLAG_RW
,
1937 &maxfiles
, 0, "Maximum number of files");
1939 SYSCTL_INT(_kern
, OID_AUTO
, maxfilesrootres
, CTLFLAG_RW
,
1940 &maxfilesrootres
, 0, "Descriptors reserved for root use");
1942 SYSCTL_INT(_kern
, OID_AUTO
, openfiles
, CTLFLAG_RD
,
1943 &nfiles
, 0, "System-wide number of open files");
1946 fildesc_drvinit(void *unused
)
1950 cdevsw_add(&fildesc_cdevsw
, 0, 0);
1951 for (fd
= 0; fd
< NUMFDESC
; fd
++) {
1952 make_dev(&fildesc_cdevsw
, fd
,
1953 UID_BIN
, GID_BIN
, 0666, "fd/%d", fd
);
1955 make_dev(&fildesc_cdevsw
, 0, UID_ROOT
, GID_WHEEL
, 0666, "stdin");
1956 make_dev(&fildesc_cdevsw
, 1, UID_ROOT
, GID_WHEEL
, 0666, "stdout");
1957 make_dev(&fildesc_cdevsw
, 2, UID_ROOT
, GID_WHEEL
, 0666, "stderr");
1960 struct fileops badfileops
= {
1985 badfo_ioctl(struct file
*fp
, u_long com
, caddr_t data
, struct thread
*td
)
1991 badfo_poll(struct file
*fp
, int events
, struct ucred
*cred
, struct thread
*td
)
1997 badfo_kqfilter(struct file
*fp
, struct knote
*kn
)
2003 badfo_stat(struct file
*fp
, struct stat
*sb
, struct thread
*td
)
2009 badfo_close(struct file
*fp
, struct thread
*td
)
2015 badfo_shutdown(struct file
*fp
, int how
, struct thread
*td
)
2021 nofo_shutdown(struct file
*fp
, int how
, struct thread
*td
)
2023 return (EOPNOTSUPP
);
2026 SYSINIT(fildescdev
,SI_SUB_DRIVERS
,SI_ORDER_MIDDLE
+CDEV_MAJOR
,
2027 fildesc_drvinit
,NULL
)