2005-01-06 23:35:40 +00:00
|
|
|
/*-
|
1994-05-24 10:09:53 +00:00
|
|
|
* Copyright (c) 1982, 1986, 1989, 1991, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
* (c) UNIX System Laboratories, Inc.
|
|
|
|
* All or some portions of this file are derived from material licensed
|
|
|
|
* to the University of California by American Telephone and Telegraph
|
|
|
|
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
|
|
|
|
* the permission of UNIX System Laboratories, Inc.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)kern_descrip.c 8.6 (Berkeley) 4/19/94
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1997-12-16 17:40:42 +00:00
|
|
|
#include "opt_compat.h"
|
2005-11-10 10:42:50 +00:00
|
|
|
#include "opt_ddb.h"
|
2001-08-23 13:19:32 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2004-12-03 21:29:25 +00:00
|
|
|
|
1995-12-02 18:58:56 +00:00
|
|
|
#include <sys/conf.h>
|
2004-12-03 21:29:25 +00:00
|
|
|
#include <sys/fcntl.h>
|
|
|
|
#include <sys/file.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/filedesc.h>
|
2004-12-03 21:29:25 +00:00
|
|
|
#include <sys/filio.h>
|
2004-07-14 19:04:31 +00:00
|
|
|
#include <sys/jail.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/kernel.h>
|
2003-04-29 13:36:06 +00:00
|
|
|
#include <sys/limits.h>
|
2004-12-03 21:29:25 +00:00
|
|
|
#include <sys/lock.h>
|
2002-10-16 15:14:31 +00:00
|
|
|
#include <sys/malloc.h>
|
2002-09-14 09:02:28 +00:00
|
|
|
#include <sys/mount.h>
|
2004-12-03 21:29:25 +00:00
|
|
|
#include <sys/mutex.h>
|
2002-04-19 00:45:29 +00:00
|
|
|
#include <sys/namei.h>
|
2004-12-03 21:29:25 +00:00
|
|
|
#include <sys/proc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/resourcevar.h>
|
2002-05-01 20:44:46 +00:00
|
|
|
#include <sys/signalvar.h>
|
2004-12-03 21:29:25 +00:00
|
|
|
#include <sys/socketvar.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/sx.h>
|
|
|
|
#include <sys/syscallsubr.h>
|
|
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <sys/sysproto.h>
|
|
|
|
#include <sys/unistd.h>
|
|
|
|
#include <sys/vnode.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-03-20 04:09:59 +00:00
|
|
|
#include <vm/uma.h>
|
1995-12-05 21:51:45 +00:00
|
|
|
|
2005-11-10 10:42:50 +00:00
|
|
|
#include <ddb/ddb.h>
|
|
|
|
|
2005-10-31 15:41:29 +00:00
|
|
|
static MALLOC_DEFINE(M_FILEDESC, "filedesc", "Open file descriptor table");
|
|
|
|
static MALLOC_DEFINE(M_FILEDESC_TO_LEADER, "filedesc_to_leader",
|
2003-06-02 16:05:32 +00:00
|
|
|
"file desc to leader structures");
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
static MALLOC_DEFINE(M_SIGIO, "sigio", "sigio structures");
|
1997-10-12 20:26:33 +00:00
|
|
|
|
2003-04-30 12:57:40 +00:00
|
|
|
static uma_zone_t file_zone;
|
2002-03-19 09:11:49 +00:00
|
|
|
|
1995-11-29 10:49:16 +00:00
|
|
|
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
/* How to treat 'new' parameter when allocating a fd for do_dup(). */
|
|
|
|
enum dup_type { DUP_VARIABLE, DUP_FIXED };
|
|
|
|
|
|
|
|
static int do_dup(struct thread *td, enum dup_type type, int old, int new,
|
|
|
|
register_t *retval);
|
2004-01-15 10:15:04 +00:00
|
|
|
static int fd_first_free(struct filedesc *, int, int);
|
|
|
|
static int fd_last_used(struct filedesc *, int, int);
|
|
|
|
static void fdgrowtable(struct filedesc *, int);
|
2005-02-10 12:27:58 +00:00
|
|
|
static int fdrop_locked(struct file *fp, struct thread *td);
|
2004-11-07 22:16:07 +00:00
|
|
|
static void fdunused(struct filedesc *fdp, int fd);
|
2005-02-10 12:27:58 +00:00
|
|
|
static void fdused(struct filedesc *fdp, int fd);
|
1999-11-08 03:27:14 +00:00
|
|
|
|
2004-11-07 15:34:45 +00:00
|
|
|
/*
|
|
|
|
* A process is initially started out with NDFILE descriptors stored within
|
|
|
|
* this structure, selected to be enough for typical applications based on
|
|
|
|
* the historical limit of 20 open files (and the usage of descriptors by
|
|
|
|
* shells). If these descriptors are exhausted, a larger descriptor table
|
|
|
|
* may be allocated, up to a process' resource limit; the internal arrays
|
|
|
|
* are then unused.
|
|
|
|
*/
|
|
|
|
#define NDFILE 20
|
|
|
|
#define NDSLOTSIZE sizeof(NDSLOTTYPE)
|
|
|
|
#define NDENTRIES (NDSLOTSIZE * __CHAR_BIT)
|
|
|
|
#define NDSLOT(x) ((x) / NDENTRIES)
|
|
|
|
#define NDBIT(x) ((NDSLOTTYPE)1 << ((x) % NDENTRIES))
|
|
|
|
#define NDSLOTS(x) (((x) + NDENTRIES - 1) / NDENTRIES)
|
|
|
|
|
2004-11-14 09:21:01 +00:00
|
|
|
/*
|
|
|
|
* Storage required per open file descriptor.
|
|
|
|
*/
|
|
|
|
#define OFILESIZE (sizeof(struct file *) + sizeof(char))
|
|
|
|
|
2004-11-07 15:34:45 +00:00
|
|
|
/*
|
|
|
|
* Basic allocation of descriptors:
|
|
|
|
* one of the above, plus arrays for NDFILE descriptors.
|
|
|
|
*/
|
|
|
|
struct filedesc0 {
|
|
|
|
struct filedesc fd_fd;
|
|
|
|
/*
|
|
|
|
* These arrays are used when the number of open files is
|
|
|
|
* <= NDFILE, and are then pointed to by the pointers above.
|
|
|
|
*/
|
|
|
|
struct file *fd_dfiles[NDFILE];
|
|
|
|
char fd_dfileflags[NDFILE];
|
|
|
|
NDSLOTTYPE fd_dmap[NDSLOTS(NDFILE)];
|
|
|
|
};
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Descriptor management.
|
|
|
|
*/
|
1996-03-11 02:17:30 +00:00
|
|
|
struct filelist filehead; /* head of list of open files */
|
2004-12-01 09:22:26 +00:00
|
|
|
int openfiles; /* actual number of open files */
|
2002-01-13 11:58:06 +00:00
|
|
|
struct sx filelist_lock; /* sx to protect filelist */
|
2002-05-01 20:44:46 +00:00
|
|
|
struct mtx sigio_lock; /* mtx to protect pointers to sigio */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-12-01 08:06:27 +00:00
|
|
|
/* A mutex to protect the association between a proc and filedesc. */
|
2004-12-14 08:44:51 +00:00
|
|
|
static struct mtx fdesc_mtx;
|
2004-12-01 08:06:27 +00:00
|
|
|
|
2004-01-15 10:15:04 +00:00
|
|
|
/*
|
|
|
|
* Find the first zero bit in the given bitmap, starting at low and not
|
|
|
|
* exceeding size - 1.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
fd_first_free(struct filedesc *fdp, int low, int size)
|
|
|
|
{
|
|
|
|
NDSLOTTYPE *map = fdp->fd_map;
|
|
|
|
NDSLOTTYPE mask;
|
|
|
|
int off, maxoff;
|
|
|
|
|
|
|
|
if (low >= size)
|
|
|
|
return (low);
|
|
|
|
|
|
|
|
off = NDSLOT(low);
|
|
|
|
if (low % NDENTRIES) {
|
|
|
|
mask = ~(~(NDSLOTTYPE)0 >> (NDENTRIES - (low % NDENTRIES)));
|
2004-02-16 18:38:46 +00:00
|
|
|
if ((mask &= ~map[off]) != 0UL)
|
2004-01-15 10:15:04 +00:00
|
|
|
return (off * NDENTRIES + ffsl(mask) - 1);
|
|
|
|
++off;
|
|
|
|
}
|
|
|
|
for (maxoff = NDSLOTS(size); off < maxoff; ++off)
|
2004-02-16 18:38:46 +00:00
|
|
|
if (map[off] != ~0UL)
|
|
|
|
return (off * NDENTRIES + ffsl(~map[off]) - 1);
|
2004-01-15 10:15:04 +00:00
|
|
|
return (size);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the highest non-zero bit in the given bitmap, starting at low and
|
|
|
|
* not exceeding size - 1.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
fd_last_used(struct filedesc *fdp, int low, int size)
|
|
|
|
{
|
|
|
|
NDSLOTTYPE *map = fdp->fd_map;
|
|
|
|
NDSLOTTYPE mask;
|
|
|
|
int off, minoff;
|
|
|
|
|
|
|
|
if (low >= size)
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
off = NDSLOT(size);
|
|
|
|
if (size % NDENTRIES) {
|
|
|
|
mask = ~(~(NDSLOTTYPE)0 << (size % NDENTRIES));
|
|
|
|
if ((mask &= map[off]) != 0)
|
|
|
|
return (off * NDENTRIES + flsl(mask) - 1);
|
|
|
|
--off;
|
|
|
|
}
|
|
|
|
for (minoff = NDSLOT(low); off >= minoff; --off)
|
2004-02-16 18:38:46 +00:00
|
|
|
if (map[off] != 0)
|
|
|
|
return (off * NDENTRIES + flsl(map[off]) - 1);
|
2004-01-15 10:15:04 +00:00
|
|
|
return (size - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fdisused(struct filedesc *fdp, int fd)
|
|
|
|
{
|
|
|
|
KASSERT(fd >= 0 && fd < fdp->fd_nfiles,
|
|
|
|
("file descriptor %d out of range (0, %d)", fd, fdp->fd_nfiles));
|
|
|
|
return ((fdp->fd_map[NDSLOT(fd)] & NDBIT(fd)) != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark a file descriptor as used.
|
|
|
|
*/
|
2005-02-10 12:27:58 +00:00
|
|
|
static void
|
2004-01-15 10:15:04 +00:00
|
|
|
fdused(struct filedesc *fdp, int fd)
|
|
|
|
{
|
|
|
|
FILEDESC_LOCK_ASSERT(fdp, MA_OWNED);
|
|
|
|
KASSERT(!fdisused(fdp, fd),
|
|
|
|
("fd already used"));
|
|
|
|
fdp->fd_map[NDSLOT(fd)] |= NDBIT(fd);
|
|
|
|
if (fd > fdp->fd_lastfile)
|
|
|
|
fdp->fd_lastfile = fd;
|
|
|
|
if (fd == fdp->fd_freefile)
|
|
|
|
fdp->fd_freefile = fd_first_free(fdp, fd, fdp->fd_nfiles);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark a file descriptor as unused.
|
|
|
|
*/
|
2004-11-07 22:16:07 +00:00
|
|
|
static void
|
2004-01-15 10:15:04 +00:00
|
|
|
fdunused(struct filedesc *fdp, int fd)
|
|
|
|
{
|
|
|
|
FILEDESC_LOCK_ASSERT(fdp, MA_OWNED);
|
|
|
|
KASSERT(fdisused(fdp, fd),
|
|
|
|
("fd is already unused"));
|
|
|
|
KASSERT(fdp->fd_ofiles[fd] == NULL,
|
|
|
|
("fd is still in use"));
|
|
|
|
fdp->fd_map[NDSLOT(fd)] &= ~NDBIT(fd);
|
|
|
|
if (fd < fdp->fd_freefile)
|
|
|
|
fdp->fd_freefile = fd;
|
|
|
|
if (fd == fdp->fd_lastfile)
|
|
|
|
fdp->fd_lastfile = fd_last_used(fdp, 0, fd);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* System calls on descriptors.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct getdtablesize_args {
|
|
|
|
int dummy;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
2001-09-01 19:04:37 +00:00
|
|
|
/*
|
|
|
|
* MPSAFE
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
getdtablesize(struct thread *td, struct getdtablesize_args *uap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct proc *p = td->td_proc;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-02-04 21:52:57 +00:00
|
|
|
PROC_LOCK(p);
|
2004-01-11 19:39:14 +00:00
|
|
|
td->td_retval[0] =
|
2004-02-04 21:52:57 +00:00
|
|
|
min((int)lim_cur(p, RLIMIT_NOFILE), maxfilesperproc);
|
|
|
|
PROC_UNLOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Duplicate a file descriptor to a particular value.
|
2000-11-18 21:01:04 +00:00
|
|
|
*
|
|
|
|
* note: keep in mind that a potential race condition exists when closing
|
|
|
|
* descriptors from a shared descriptor table (via rfork).
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct dup2_args {
|
|
|
|
u_int from;
|
|
|
|
u_int to;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
2001-09-01 19:04:37 +00:00
|
|
|
/*
|
|
|
|
* MPSAFE
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
dup2(struct thread *td, struct dup2_args *uap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
return (do_dup(td, DUP_FIXED, (int)uap->from, (int)uap->to,
|
|
|
|
td->td_retval));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1994-09-25 19:34:02 +00:00
|
|
|
/*
|
|
|
|
* Duplicate a file descriptor.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-09-25 19:34:02 +00:00
|
|
|
struct dup_args {
|
|
|
|
u_int fd;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
2001-09-01 19:04:37 +00:00
|
|
|
/*
|
|
|
|
* MPSAFE
|
|
|
|
*/
|
1994-09-25 19:34:02 +00:00
|
|
|
/* ARGSUSED */
|
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
dup(struct thread *td, struct dup_args *uap)
|
1994-09-25 19:34:02 +00:00
|
|
|
{
|
|
|
|
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
return (do_dup(td, DUP_VARIABLE, (int)uap->fd, 0, td->td_retval));
|
1994-09-25 19:34:02 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* The file control system call.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct fcntl_args {
|
|
|
|
int fd;
|
|
|
|
int cmd;
|
1998-07-15 06:10:16 +00:00
|
|
|
long arg;
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
2001-09-01 19:04:37 +00:00
|
|
|
/*
|
|
|
|
* MPSAFE
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
fcntl(struct thread *td, struct fcntl_args *uap)
|
2002-09-02 22:24:14 +00:00
|
|
|
{
|
|
|
|
struct flock fl;
|
|
|
|
intptr_t arg;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
switch (uap->cmd) {
|
|
|
|
case F_GETLK:
|
2002-10-16 15:45:37 +00:00
|
|
|
case F_SETLK:
|
|
|
|
case F_SETLKW:
|
|
|
|
error = copyin((void *)(intptr_t)uap->arg, &fl, sizeof(fl));
|
2002-09-02 22:24:14 +00:00
|
|
|
arg = (intptr_t)&fl;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
arg = uap->arg;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
error = kern_fcntl(td, uap->fd, uap->cmd, arg);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
2002-10-16 15:45:37 +00:00
|
|
|
if (uap->cmd == F_GETLK)
|
|
|
|
error = copyout(&fl, (void *)(intptr_t)uap->arg, sizeof(fl));
|
2002-09-02 22:24:14 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_fcntl(struct thread *td, int fd, int cmd, intptr_t arg)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-01-01 01:05:54 +00:00
|
|
|
struct filedesc *fdp;
|
2002-10-16 15:45:37 +00:00
|
|
|
struct flock *flp;
|
2003-01-01 01:05:54 +00:00
|
|
|
struct file *fp;
|
2002-10-16 15:45:37 +00:00
|
|
|
struct proc *p;
|
2003-01-01 01:05:54 +00:00
|
|
|
char *pop;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
u_int newmin;
|
2002-10-16 15:45:37 +00:00
|
|
|
int error, flg, tmp;
|
2004-08-06 22:00:55 +00:00
|
|
|
int giant_locked;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXXRW: Some fcntl() calls require Giant -- others don't. Try to
|
|
|
|
* avoid grabbing Giant for calls we know don't need it.
|
|
|
|
*/
|
|
|
|
switch (cmd) {
|
|
|
|
case F_DUPFD:
|
|
|
|
case F_GETFD:
|
|
|
|
case F_SETFD:
|
|
|
|
case F_GETFL:
|
|
|
|
giant_locked = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
giant_locked = 1;
|
|
|
|
mtx_lock(&Giant);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-10-16 15:45:37 +00:00
|
|
|
error = 0;
|
|
|
|
flg = F_POSIX;
|
|
|
|
p = td->td_proc;
|
2001-09-01 19:04:37 +00:00
|
|
|
fdp = p->p_fd;
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
2002-09-02 22:24:14 +00:00
|
|
|
if ((unsigned)fd >= fdp->fd_nfiles ||
|
|
|
|
(fp = fdp->fd_ofiles[fd]) == NULL) {
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
error = EBADF;
|
|
|
|
goto done2;
|
|
|
|
}
|
2002-09-02 22:24:14 +00:00
|
|
|
pop = &fdp->fd_ofileflags[fd];
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-09-02 22:24:14 +00:00
|
|
|
switch (cmd) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case F_DUPFD:
|
2004-08-07 14:09:02 +00:00
|
|
|
/* mtx_assert(&Giant, MA_NOTOWNED); */
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2002-09-02 22:24:14 +00:00
|
|
|
newmin = arg;
|
2004-02-04 21:52:57 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
if (newmin >= lim_cur(p, RLIMIT_NOFILE) ||
|
2001-09-01 19:04:37 +00:00
|
|
|
newmin >= maxfilesperproc) {
|
2004-02-04 21:52:57 +00:00
|
|
|
PROC_UNLOCK(p);
|
2001-09-01 19:04:37 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2004-02-04 21:52:57 +00:00
|
|
|
PROC_UNLOCK(p);
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
error = do_dup(td, DUP_VARIABLE, fd, newmin, td->td_retval);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case F_GETFD:
|
2004-08-07 14:09:02 +00:00
|
|
|
/* mtx_assert(&Giant, MA_NOTOWNED); */
|
2002-04-13 10:16:53 +00:00
|
|
|
td->td_retval[0] = (*pop & UF_EXCLOSE) ? FD_CLOEXEC : 0;
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case F_SETFD:
|
2004-08-07 14:09:02 +00:00
|
|
|
/* mtx_assert(&Giant, MA_NOTOWNED); */
|
2002-04-13 10:16:53 +00:00
|
|
|
*pop = (*pop &~ UF_EXCLOSE) |
|
2002-09-02 22:24:14 +00:00
|
|
|
(arg & FD_CLOEXEC ? UF_EXCLOSE : 0);
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case F_GETFL:
|
2004-08-07 14:09:02 +00:00
|
|
|
/* mtx_assert(&Giant, MA_NOTOWNED); */
|
2002-01-13 11:58:06 +00:00
|
|
|
FILE_LOCK(fp);
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_retval[0] = OFLAGS(fp->f_flag);
|
2002-01-13 11:58:06 +00:00
|
|
|
FILE_UNLOCK(fp);
|
2004-11-15 16:10:55 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case F_SETFL:
|
2004-08-06 22:00:55 +00:00
|
|
|
mtx_assert(&Giant, MA_OWNED);
|
2003-01-21 20:20:48 +00:00
|
|
|
FILE_LOCK(fp);
|
|
|
|
fhold_locked(fp);
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->f_flag &= ~FCNTLFLAGS;
|
2002-09-02 22:24:14 +00:00
|
|
|
fp->f_flag |= FFLAGS(arg & ~O_ACCMODE) & FCNTLFLAGS;
|
2003-01-21 20:20:48 +00:00
|
|
|
FILE_UNLOCK(fp);
|
2004-11-15 16:10:55 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
1994-05-24 10:09:53 +00:00
|
|
|
tmp = fp->f_flag & FNONBLOCK;
|
2002-08-17 02:36:16 +00:00
|
|
|
error = fo_ioctl(fp, FIONBIO, &tmp, td->td_ucred, td);
|
2000-11-18 21:01:04 +00:00
|
|
|
if (error) {
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
2000-11-18 21:01:04 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
tmp = fp->f_flag & FASYNC;
|
2002-08-17 02:36:16 +00:00
|
|
|
error = fo_ioctl(fp, FIOASYNC, &tmp, td->td_ucred, td);
|
2002-10-16 15:45:37 +00:00
|
|
|
if (error == 0) {
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
2000-11-18 21:01:04 +00:00
|
|
|
}
|
2003-01-21 20:20:48 +00:00
|
|
|
FILE_LOCK(fp);
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->f_flag &= ~FNONBLOCK;
|
2003-01-21 20:20:48 +00:00
|
|
|
FILE_UNLOCK(fp);
|
1994-05-24 10:09:53 +00:00
|
|
|
tmp = 0;
|
2002-08-17 02:36:16 +00:00
|
|
|
(void)fo_ioctl(fp, FIONBIO, &tmp, td->td_ucred, td);
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case F_GETOWN:
|
2004-08-06 22:00:55 +00:00
|
|
|
mtx_assert(&Giant, MA_OWNED);
|
2000-11-18 21:01:04 +00:00
|
|
|
fhold(fp);
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2002-09-13 15:15:16 +00:00
|
|
|
error = fo_ioctl(fp, FIOGETOWN, &tmp, td->td_ucred, td);
|
|
|
|
if (error == 0)
|
|
|
|
td->td_retval[0] = tmp;
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case F_SETOWN:
|
2004-08-06 22:00:55 +00:00
|
|
|
mtx_assert(&Giant, MA_OWNED);
|
2000-11-18 21:01:04 +00:00
|
|
|
fhold(fp);
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2002-09-13 15:15:16 +00:00
|
|
|
tmp = arg;
|
|
|
|
error = fo_ioctl(fp, FIOSETOWN, &tmp, td->td_ucred, td);
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case F_SETLKW:
|
2004-08-06 22:00:55 +00:00
|
|
|
mtx_assert(&Giant, MA_OWNED);
|
1994-05-24 10:09:53 +00:00
|
|
|
flg |= F_WAIT;
|
2002-08-25 13:23:09 +00:00
|
|
|
/* FALLTHROUGH F_SETLK */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case F_SETLK:
|
2004-08-06 22:00:55 +00:00
|
|
|
mtx_assert(&Giant, MA_OWNED);
|
2001-09-01 19:04:37 +00:00
|
|
|
if (fp->f_type != DTYPE_VNODE) {
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
2002-10-16 15:45:37 +00:00
|
|
|
|
2002-09-02 22:24:14 +00:00
|
|
|
flp = (struct flock *)arg;
|
|
|
|
if (flp->l_whence == SEEK_CUR) {
|
2001-08-29 18:53:53 +00:00
|
|
|
if (fp->f_offset < 0 ||
|
2002-09-02 22:24:14 +00:00
|
|
|
(flp->l_start > 0 &&
|
|
|
|
fp->f_offset > OFF_MAX - flp->l_start)) {
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
error = EOVERFLOW;
|
|
|
|
break;
|
2001-08-23 13:19:32 +00:00
|
|
|
}
|
2002-09-02 22:24:14 +00:00
|
|
|
flp->l_start += fp->f_offset;
|
2001-08-23 07:42:40 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-09-02 22:24:14 +00:00
|
|
|
/*
|
2002-10-16 15:45:37 +00:00
|
|
|
* VOP_ADVLOCK() may block.
|
2002-09-02 22:24:14 +00:00
|
|
|
*/
|
|
|
|
fhold(fp);
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
2002-09-02 22:24:14 +00:00
|
|
|
|
|
|
|
switch (flp->l_type) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case F_RDLCK:
|
2000-11-18 21:01:04 +00:00
|
|
|
if ((fp->f_flag & FREAD) == 0) {
|
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
2003-02-15 22:43:05 +00:00
|
|
|
PROC_LOCK(p->p_leader);
|
|
|
|
p->p_leader->p_flag |= P_ADVLOCK;
|
|
|
|
PROC_UNLOCK(p->p_leader);
|
2002-10-15 00:03:40 +00:00
|
|
|
error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_SETLK,
|
2002-09-02 22:24:14 +00:00
|
|
|
flp, flg);
|
2000-11-18 21:01:04 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
case F_WRLCK:
|
2000-11-18 21:01:04 +00:00
|
|
|
if ((fp->f_flag & FWRITE) == 0) {
|
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
2003-02-15 22:43:05 +00:00
|
|
|
PROC_LOCK(p->p_leader);
|
|
|
|
p->p_leader->p_flag |= P_ADVLOCK;
|
|
|
|
PROC_UNLOCK(p->p_leader);
|
2002-10-16 15:45:37 +00:00
|
|
|
error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_SETLK,
|
|
|
|
flp, flg);
|
2000-11-18 21:01:04 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
case F_UNLCK:
|
2002-10-16 15:45:37 +00:00
|
|
|
error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_UNLCK,
|
|
|
|
flp, F_POSIX);
|
2000-11-18 21:01:04 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
2000-11-18 21:01:04 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2003-02-15 22:43:05 +00:00
|
|
|
/* Check for race with close */
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_LOCK_FAST(fdp);
|
2003-02-15 22:43:05 +00:00
|
|
|
if ((unsigned) fd >= fdp->fd_nfiles ||
|
|
|
|
fp != fdp->fd_ofiles[fd]) {
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_UNLOCK_FAST(fdp);
|
2003-02-15 22:43:05 +00:00
|
|
|
flp->l_whence = SEEK_SET;
|
|
|
|
flp->l_start = 0;
|
|
|
|
flp->l_len = 0;
|
|
|
|
flp->l_type = F_UNLCK;
|
|
|
|
(void) VOP_ADVLOCK(vp, (caddr_t)p->p_leader,
|
|
|
|
F_UNLCK, flp, F_POSIX);
|
|
|
|
} else
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_UNLOCK_FAST(fdp);
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
2001-09-12 08:38:13 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
case F_GETLK:
|
2004-08-06 22:00:55 +00:00
|
|
|
mtx_assert(&Giant, MA_OWNED);
|
2001-09-01 19:04:37 +00:00
|
|
|
if (fp->f_type != DTYPE_VNODE) {
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
2002-09-02 22:24:14 +00:00
|
|
|
flp = (struct flock *)arg;
|
|
|
|
if (flp->l_type != F_RDLCK && flp->l_type != F_WRLCK &&
|
|
|
|
flp->l_type != F_UNLCK) {
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
2000-11-18 21:01:04 +00:00
|
|
|
}
|
2002-09-02 22:24:14 +00:00
|
|
|
if (flp->l_whence == SEEK_CUR) {
|
|
|
|
if ((flp->l_start > 0 &&
|
|
|
|
fp->f_offset > OFF_MAX - flp->l_start) ||
|
|
|
|
(flp->l_start < 0 &&
|
|
|
|
fp->f_offset < OFF_MIN - flp->l_start)) {
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
error = EOVERFLOW;
|
|
|
|
break;
|
2001-08-23 13:19:32 +00:00
|
|
|
}
|
2002-09-02 22:24:14 +00:00
|
|
|
flp->l_start += fp->f_offset;
|
2001-08-23 07:42:40 +00:00
|
|
|
}
|
2002-09-02 22:24:14 +00:00
|
|
|
/*
|
2002-10-16 15:45:37 +00:00
|
|
|
* VOP_ADVLOCK() may block.
|
2002-09-02 22:24:14 +00:00
|
|
|
*/
|
|
|
|
fhold(fp);
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
2002-09-02 22:24:14 +00:00
|
|
|
error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_GETLK, flp,
|
|
|
|
F_POSIX);
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-09-01 19:04:37 +00:00
|
|
|
done2:
|
2004-08-06 22:00:55 +00:00
|
|
|
if (giant_locked)
|
|
|
|
mtx_unlock(&Giant);
|
2001-09-01 19:04:37 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Common code for dup, dup2, and fcntl(F_DUPFD).
|
|
|
|
*/
|
1995-12-14 08:32:45 +00:00
|
|
|
static int
|
2004-12-02 11:56:13 +00:00
|
|
|
do_dup(struct thread *td, enum dup_type type, int old, int new, register_t *retval)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-01-01 01:05:54 +00:00
|
|
|
struct filedesc *fdp;
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
struct proc *p;
|
2000-11-18 21:01:04 +00:00
|
|
|
struct file *fp;
|
|
|
|
struct file *delfp;
|
2004-01-15 10:15:04 +00:00
|
|
|
int error, holdleaders, maxfd;
|
|
|
|
|
|
|
|
KASSERT((type == DUP_VARIABLE || type == DUP_FIXED),
|
|
|
|
("invalid dup type %d", type));
|
2000-11-18 21:01:04 +00:00
|
|
|
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
p = td->td_proc;
|
|
|
|
fdp = p->p_fd;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Verify we have a valid descriptor to dup from and possibly to
|
|
|
|
* dup to.
|
|
|
|
*/
|
2004-01-15 10:15:04 +00:00
|
|
|
if (old < 0 || new < 0)
|
2002-11-26 17:22:15 +00:00
|
|
|
return (EBADF);
|
2004-02-04 21:52:57 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
maxfd = min((int)lim_cur(p, RLIMIT_NOFILE), maxfilesperproc);
|
|
|
|
PROC_UNLOCK(p);
|
2004-01-15 10:15:04 +00:00
|
|
|
if (new >= maxfd)
|
|
|
|
return (EMFILE);
|
|
|
|
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
2002-11-26 17:22:15 +00:00
|
|
|
if (old >= fdp->fd_nfiles || fdp->fd_ofiles[old] == NULL) {
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
return (EBADF);
|
|
|
|
}
|
|
|
|
if (type == DUP_FIXED && old == new) {
|
|
|
|
*retval = new;
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
fp = fdp->fd_ofiles[old];
|
|
|
|
fhold(fp);
|
|
|
|
|
|
|
|
/*
|
2004-01-15 10:15:04 +00:00
|
|
|
* If the caller specified a file descriptor, make sure the file
|
|
|
|
* table is large enough to hold it, and grab it. Otherwise, just
|
|
|
|
* allocate a new descriptor the usual way. Since the filedesc
|
|
|
|
* lock may be temporarily dropped in the process, we have to look
|
|
|
|
* out for a race.
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
*/
|
2004-01-15 10:15:04 +00:00
|
|
|
if (type == DUP_FIXED) {
|
|
|
|
if (new >= fdp->fd_nfiles)
|
|
|
|
fdgrowtable(fdp, new + 1);
|
|
|
|
if (fdp->fd_ofiles[new] == NULL)
|
|
|
|
fdused(fdp, new);
|
|
|
|
} else {
|
2004-01-17 00:59:04 +00:00
|
|
|
if ((error = fdalloc(td, new, &new)) != 0) {
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2003-01-06 13:19:05 +00:00
|
|
|
fdrop(fp, td);
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the old file changed out from under us then treat it as a
|
|
|
|
* bad file descriptor. Userland should do its own locking to
|
|
|
|
* avoid this case.
|
|
|
|
*/
|
|
|
|
if (fdp->fd_ofiles[old] != fp) {
|
2004-01-15 10:15:04 +00:00
|
|
|
/* we've allocated a descriptor which we won't use */
|
|
|
|
if (fdp->fd_ofiles[new] == NULL)
|
|
|
|
fdunused(fdp, new);
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
fdrop(fp, td);
|
|
|
|
return (EBADF);
|
|
|
|
}
|
2004-01-15 10:15:04 +00:00
|
|
|
KASSERT(old != new,
|
|
|
|
("new fd is same as old"));
|
2002-01-13 11:58:06 +00:00
|
|
|
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
2004-01-15 10:15:04 +00:00
|
|
|
* Save info on the descriptor being overwritten. We cannot close
|
|
|
|
* it without introducing an ownership race for the slot, since we
|
|
|
|
* need to drop the filedesc lock to call closef().
|
|
|
|
*
|
|
|
|
* XXX this duplicates parts of close().
|
2000-11-18 21:01:04 +00:00
|
|
|
*/
|
|
|
|
delfp = fdp->fd_ofiles[new];
|
2004-01-15 10:15:04 +00:00
|
|
|
holdleaders = 0;
|
|
|
|
if (delfp != NULL) {
|
|
|
|
if (td->td_proc->p_fdtol != NULL) {
|
|
|
|
/*
|
|
|
|
* Ask fdfree() to sleep to ensure that all relevant
|
|
|
|
* process leaders can be traversed in closef().
|
|
|
|
*/
|
|
|
|
fdp->fd_holdleaderscount++;
|
|
|
|
holdleaders = 1;
|
|
|
|
}
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
2004-01-15 10:15:04 +00:00
|
|
|
* Duplicate the source descriptor
|
2000-11-18 21:01:04 +00:00
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
fdp->fd_ofiles[new] = fp;
|
2004-01-11 19:39:14 +00:00
|
|
|
fdp->fd_ofileflags[new] = fdp->fd_ofileflags[old] &~ UF_EXCLOSE;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (new > fdp->fd_lastfile)
|
|
|
|
fdp->fd_lastfile = new;
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
*retval = new;
|
2002-01-13 11:58:06 +00:00
|
|
|
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
|
|
|
* If we dup'd over a valid file, we now own the reference to it
|
|
|
|
* and must dispose of it using closef() semantics (as if a
|
|
|
|
* close() were performed on it).
|
2004-01-15 10:15:04 +00:00
|
|
|
*
|
|
|
|
* XXX this duplicates parts of close().
|
2000-11-18 21:01:04 +00:00
|
|
|
*/
|
2004-01-15 10:15:04 +00:00
|
|
|
if (delfp != NULL) {
|
2004-08-16 03:09:01 +00:00
|
|
|
knote_fdclose(td, new);
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-12 08:38:13 +00:00
|
|
|
(void) closef(delfp, td);
|
2003-06-02 16:05:32 +00:00
|
|
|
if (holdleaders) {
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_LOCK_FAST(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
fdp->fd_holdleaderscount--;
|
|
|
|
if (fdp->fd_holdleaderscount == 0 &&
|
|
|
|
fdp->fd_holdleaderswakeup != 0) {
|
|
|
|
fdp->fd_holdleaderswakeup = 0;
|
|
|
|
wakeup(&fdp->fd_holdleaderscount);
|
|
|
|
}
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_UNLOCK_FAST(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
}
|
2004-08-16 03:09:01 +00:00
|
|
|
} else {
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
2002-01-15 00:58:40 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
/*
|
|
|
|
* If sigio is on the list associated with a process or process group,
|
|
|
|
* disable signalling from the device, remove sigio from the list and
|
|
|
|
* free sigio.
|
|
|
|
*/
|
|
|
|
void
|
2004-12-02 11:56:13 +00:00
|
|
|
funsetown(struct sigio **sigiop)
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
{
|
2002-05-06 19:31:28 +00:00
|
|
|
struct sigio *sigio;
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
|
2002-05-01 20:44:46 +00:00
|
|
|
SIGIO_LOCK();
|
2002-05-06 19:31:28 +00:00
|
|
|
sigio = *sigiop;
|
2002-05-01 20:44:46 +00:00
|
|
|
if (sigio == NULL) {
|
|
|
|
SIGIO_UNLOCK();
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
return;
|
2002-05-01 20:44:46 +00:00
|
|
|
}
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
*(sigio->sio_myref) = NULL;
|
2002-02-23 11:12:57 +00:00
|
|
|
if ((sigio)->sio_pgid < 0) {
|
|
|
|
struct pgrp *pg = (sigio)->sio_pgrp;
|
|
|
|
PGRP_LOCK(pg);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
SLIST_REMOVE(&sigio->sio_pgrp->pg_sigiolst, sigio,
|
2000-05-26 02:09:24 +00:00
|
|
|
sigio, sio_pgsigio);
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_UNLOCK(pg);
|
|
|
|
} else {
|
|
|
|
struct proc *p = (sigio)->sio_proc;
|
|
|
|
PROC_LOCK(p);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
SLIST_REMOVE(&sigio->sio_proc->p_sigiolst, sigio,
|
2000-05-26 02:09:24 +00:00
|
|
|
sigio, sio_pgsigio);
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(p);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
}
|
2002-05-06 19:31:28 +00:00
|
|
|
SIGIO_UNLOCK();
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
crfree(sigio->sio_ucred);
|
|
|
|
FREE(sigio, M_SIGIO);
|
|
|
|
}
|
|
|
|
|
2002-05-06 19:31:28 +00:00
|
|
|
/*
|
|
|
|
* Free a list of sigio structures.
|
|
|
|
* We only need to lock the SIGIO_LOCK because we have made ourselves
|
2005-03-08 00:58:50 +00:00
|
|
|
* inaccessible to callers of fsetown and therefore do not need to lock
|
2002-05-06 19:31:28 +00:00
|
|
|
* the proc or pgrp struct for the list manipulation.
|
|
|
|
*/
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
void
|
2004-12-02 11:56:13 +00:00
|
|
|
funsetownlst(struct sigiolst *sigiolst)
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
{
|
2002-02-23 11:12:57 +00:00
|
|
|
struct proc *p;
|
|
|
|
struct pgrp *pg;
|
2002-10-16 15:45:37 +00:00
|
|
|
struct sigio *sigio;
|
2002-02-23 11:12:57 +00:00
|
|
|
|
|
|
|
sigio = SLIST_FIRST(sigiolst);
|
|
|
|
if (sigio == NULL)
|
|
|
|
return;
|
|
|
|
p = NULL;
|
|
|
|
pg = NULL;
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
|
2002-02-23 11:12:57 +00:00
|
|
|
/*
|
|
|
|
* Every entry of the list should belong
|
|
|
|
* to a single proc or pgrp.
|
|
|
|
*/
|
|
|
|
if (sigio->sio_pgid < 0) {
|
|
|
|
pg = sigio->sio_pgrp;
|
2002-05-06 19:31:28 +00:00
|
|
|
PGRP_LOCK_ASSERT(pg, MA_NOTOWNED);
|
2002-02-23 11:12:57 +00:00
|
|
|
} else /* if (sigio->sio_pgid > 0) */ {
|
|
|
|
p = sigio->sio_proc;
|
2002-05-06 19:31:28 +00:00
|
|
|
PROC_LOCK_ASSERT(p, MA_NOTOWNED);
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
|
|
|
|
2002-05-06 19:31:28 +00:00
|
|
|
SIGIO_LOCK();
|
2002-02-23 11:12:57 +00:00
|
|
|
while ((sigio = SLIST_FIRST(sigiolst)) != NULL) {
|
|
|
|
*(sigio->sio_myref) = NULL;
|
|
|
|
if (pg != NULL) {
|
2002-05-06 19:31:28 +00:00
|
|
|
KASSERT(sigio->sio_pgid < 0,
|
|
|
|
("Proc sigio in pgrp sigio list"));
|
|
|
|
KASSERT(sigio->sio_pgrp == pg,
|
|
|
|
("Bogus pgrp in sigio list"));
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_LOCK(pg);
|
2002-05-06 19:31:28 +00:00
|
|
|
SLIST_REMOVE(&pg->pg_sigiolst, sigio, sigio,
|
|
|
|
sio_pgsigio);
|
|
|
|
PGRP_UNLOCK(pg);
|
2002-02-23 11:12:57 +00:00
|
|
|
} else /* if (p != NULL) */ {
|
2002-05-06 19:31:28 +00:00
|
|
|
KASSERT(sigio->sio_pgid > 0,
|
|
|
|
("Pgrp sigio in proc sigio list"));
|
|
|
|
KASSERT(sigio->sio_proc == p,
|
|
|
|
("Bogus proc in sigio list"));
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK(p);
|
2002-05-06 19:31:28 +00:00
|
|
|
SLIST_REMOVE(&p->p_sigiolst, sigio, sigio,
|
|
|
|
sio_pgsigio);
|
|
|
|
PROC_UNLOCK(p);
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
2002-05-06 19:31:28 +00:00
|
|
|
SIGIO_UNLOCK();
|
|
|
|
crfree(sigio->sio_ucred);
|
|
|
|
FREE(sigio, M_SIGIO);
|
|
|
|
SIGIO_LOCK();
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
2002-05-06 19:31:28 +00:00
|
|
|
SIGIO_UNLOCK();
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is common code for FIOSETOWN ioctl called by fcntl(fd, F_SETOWN, arg).
|
|
|
|
*
|
|
|
|
* After permission checking, add a sigio structure to the sigio list for
|
|
|
|
* the process or process group.
|
|
|
|
*/
|
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
fsetown(pid_t pgid, struct sigio **sigiop)
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
{
|
1998-11-11 10:56:07 +00:00
|
|
|
struct proc *proc;
|
|
|
|
struct pgrp *pgrp;
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
struct sigio *sigio;
|
2002-05-01 20:44:46 +00:00
|
|
|
int ret;
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
|
|
|
|
if (pgid == 0) {
|
2002-05-06 19:31:28 +00:00
|
|
|
funsetown(sigiop);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
return (0);
|
1998-11-11 10:56:07 +00:00
|
|
|
}
|
2002-02-23 11:12:57 +00:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
/* Allocate and fill in the new sigio out of locks. */
|
2003-02-19 05:47:46 +00:00
|
|
|
MALLOC(sigio, struct sigio *, sizeof(struct sigio), M_SIGIO, M_WAITOK);
|
2002-02-23 11:12:57 +00:00
|
|
|
sigio->sio_pgid = pgid;
|
2002-02-27 18:32:23 +00:00
|
|
|
sigio->sio_ucred = crhold(curthread->td_ucred);
|
2002-02-23 11:12:57 +00:00
|
|
|
sigio->sio_myref = sigiop;
|
|
|
|
|
2002-04-16 17:11:34 +00:00
|
|
|
sx_slock(&proctree_lock);
|
1998-11-11 10:56:07 +00:00
|
|
|
if (pgid > 0) {
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
proc = pfind(pgid);
|
2002-02-23 11:12:57 +00:00
|
|
|
if (proc == NULL) {
|
|
|
|
ret = ESRCH;
|
|
|
|
goto fail;
|
|
|
|
}
|
1999-12-26 14:07:43 +00:00
|
|
|
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
/*
|
|
|
|
* Policy - Don't allow a process to FSETOWN a process
|
|
|
|
* in another session.
|
|
|
|
*
|
|
|
|
* Remove this test to allow maximum flexibility or
|
|
|
|
* restrict FSETOWN to the current process or process
|
|
|
|
* group for maximum safety.
|
|
|
|
*/
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(proc);
|
2001-09-12 08:38:13 +00:00
|
|
|
if (proc->p_session != curthread->td_proc->p_session) {
|
2002-02-23 11:12:57 +00:00
|
|
|
ret = EPERM;
|
|
|
|
goto fail;
|
2001-04-24 00:51:53 +00:00
|
|
|
}
|
1999-12-26 14:07:43 +00:00
|
|
|
|
1998-11-11 10:56:07 +00:00
|
|
|
pgrp = NULL;
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
} else /* if (pgid < 0) */ {
|
|
|
|
pgrp = pgfind(-pgid);
|
2002-02-23 11:12:57 +00:00
|
|
|
if (pgrp == NULL) {
|
|
|
|
ret = ESRCH;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
PGRP_UNLOCK(pgrp);
|
1999-12-26 14:07:43 +00:00
|
|
|
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
/*
|
|
|
|
* Policy - Don't allow a process to FSETOWN a process
|
|
|
|
* in another session.
|
|
|
|
*
|
|
|
|
* Remove this test to allow maximum flexibility or
|
|
|
|
* restrict FSETOWN to the current process or process
|
|
|
|
* group for maximum safety.
|
|
|
|
*/
|
2002-02-23 11:12:57 +00:00
|
|
|
if (pgrp->pg_session != curthread->td_proc->p_session) {
|
|
|
|
ret = EPERM;
|
|
|
|
goto fail;
|
|
|
|
}
|
1999-12-26 14:07:43 +00:00
|
|
|
|
1998-11-11 10:56:07 +00:00
|
|
|
proc = NULL;
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
}
|
2002-05-06 19:31:28 +00:00
|
|
|
funsetown(sigiop);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
if (pgid > 0) {
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK(proc);
|
2004-01-11 19:39:14 +00:00
|
|
|
/*
|
2002-10-16 15:45:37 +00:00
|
|
|
* Since funsetownlst() is called without the proctree
|
|
|
|
* locked, we need to check for P_WEXIT.
|
2002-05-06 19:31:28 +00:00
|
|
|
* XXX: is ESRCH correct?
|
|
|
|
*/
|
|
|
|
if ((proc->p_flag & P_WEXIT) != 0) {
|
|
|
|
PROC_UNLOCK(proc);
|
|
|
|
ret = ESRCH;
|
|
|
|
goto fail;
|
|
|
|
}
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
SLIST_INSERT_HEAD(&proc->p_sigiolst, sigio, sio_pgsigio);
|
|
|
|
sigio->sio_proc = proc;
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(proc);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
} else {
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_LOCK(pgrp);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
SLIST_INSERT_HEAD(&pgrp->pg_sigiolst, sigio, sio_pgsigio);
|
|
|
|
sigio->sio_pgrp = pgrp;
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_UNLOCK(pgrp);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
}
|
2002-04-16 17:11:34 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
2002-05-01 20:44:46 +00:00
|
|
|
SIGIO_LOCK();
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
*sigiop = sigio;
|
2002-05-01 20:44:46 +00:00
|
|
|
SIGIO_UNLOCK();
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
return (0);
|
2002-02-23 11:12:57 +00:00
|
|
|
|
|
|
|
fail:
|
2002-04-16 17:11:34 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
crfree(sigio->sio_ucred);
|
|
|
|
FREE(sigio, M_SIGIO);
|
|
|
|
return (ret);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is common code for FIOGETOWN ioctl called by fcntl(fd, F_GETOWN, arg).
|
|
|
|
*/
|
|
|
|
pid_t
|
2002-10-03 02:13:00 +00:00
|
|
|
fgetown(sigiop)
|
|
|
|
struct sigio **sigiop;
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
{
|
2002-10-03 02:13:00 +00:00
|
|
|
pid_t pgid;
|
|
|
|
|
|
|
|
SIGIO_LOCK();
|
|
|
|
pgid = (*sigiop != NULL) ? (*sigiop)->sio_pgid : 0;
|
|
|
|
SIGIO_UNLOCK();
|
|
|
|
return (pgid);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Close a file descriptor.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1995-10-08 00:06:22 +00:00
|
|
|
struct close_args {
|
2004-01-11 19:39:14 +00:00
|
|
|
int fd;
|
1995-10-08 00:06:22 +00:00
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
2001-09-01 19:04:37 +00:00
|
|
|
/*
|
|
|
|
* MPSAFE
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
close(td, uap)
|
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct close_args *uap;
|
|
|
|
{
|
2003-01-01 01:05:54 +00:00
|
|
|
struct filedesc *fdp;
|
|
|
|
struct file *fp;
|
2002-10-16 15:45:37 +00:00
|
|
|
int fd, error;
|
2003-06-02 16:05:32 +00:00
|
|
|
int holdleaders;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-10-16 15:45:37 +00:00
|
|
|
fd = uap->fd;
|
|
|
|
error = 0;
|
2003-06-02 16:05:32 +00:00
|
|
|
holdleaders = 0;
|
2001-09-12 08:38:13 +00:00
|
|
|
fdp = td->td_proc->p_fd;
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((unsigned)fd >= fdp->fd_nfiles ||
|
2001-09-01 19:04:37 +00:00
|
|
|
(fp = fdp->fd_ofiles[fd]) == NULL) {
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2004-01-15 10:15:04 +00:00
|
|
|
return (EBADF);
|
2001-09-01 19:04:37 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
fdp->fd_ofiles[fd] = NULL;
|
2000-11-18 21:01:04 +00:00
|
|
|
fdp->fd_ofileflags[fd] = 0;
|
2004-01-15 10:15:04 +00:00
|
|
|
fdunused(fdp, fd);
|
2003-06-02 16:05:32 +00:00
|
|
|
if (td->td_proc->p_fdtol != NULL) {
|
|
|
|
/*
|
|
|
|
* Ask fdfree() to sleep to ensure that all relevant
|
|
|
|
* process leaders can be traversed in closef().
|
|
|
|
*/
|
|
|
|
fdp->fd_holdleaderscount++;
|
|
|
|
holdleaders = 1;
|
|
|
|
}
|
2000-11-18 21:01:04 +00:00
|
|
|
|
|
|
|
/*
|
2005-03-08 00:58:50 +00:00
|
|
|
* We now hold the fp reference that used to be owned by the descriptor
|
2000-11-18 21:01:04 +00:00
|
|
|
* array.
|
2004-08-15 06:24:42 +00:00
|
|
|
* We have to unlock the FILEDESC *AFTER* knote_fdclose to prevent a
|
|
|
|
* race of the fd getting opened, a knote added, and deleteing a knote
|
|
|
|
* for the new fd.
|
2000-11-18 21:01:04 +00:00
|
|
|
*/
|
2004-08-15 06:24:42 +00:00
|
|
|
knote_fdclose(td, fd);
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
2002-01-13 11:58:06 +00:00
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
error = closef(fp, td);
|
2003-06-02 16:05:32 +00:00
|
|
|
if (holdleaders) {
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_LOCK_FAST(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
fdp->fd_holdleaderscount--;
|
|
|
|
if (fdp->fd_holdleaderscount == 0 &&
|
|
|
|
fdp->fd_holdleaderswakeup != 0) {
|
|
|
|
fdp->fd_holdleaderswakeup = 0;
|
|
|
|
wakeup(&fdp->fd_holdleaderscount);
|
|
|
|
}
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_UNLOCK_FAST(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
}
|
2002-10-16 15:45:37 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2004-06-11 11:16:26 +00:00
|
|
|
#if defined(COMPAT_43)
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Return status information about a file descriptor.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ofstat_args {
|
|
|
|
int fd;
|
|
|
|
struct ostat *sb;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
2001-09-01 19:04:37 +00:00
|
|
|
/*
|
|
|
|
* MPSAFE
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
ofstat(struct thread *td, struct ofstat_args *uap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct ostat oub;
|
2005-02-07 18:44:55 +00:00
|
|
|
struct stat ub;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
error = kern_fstat(td, uap->fd, &ub);
|
1999-11-18 08:08:28 +00:00
|
|
|
if (error == 0) {
|
|
|
|
cvtstat(&ub, &oub);
|
2002-10-16 15:45:37 +00:00
|
|
|
error = copyout(&oub, uap->sb, sizeof(oub));
|
1999-11-18 08:08:28 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
2004-06-11 11:16:26 +00:00
|
|
|
#endif /* COMPAT_43 */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Return status information about a file descriptor.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct fstat_args {
|
|
|
|
int fd;
|
|
|
|
struct stat *sb;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
2001-09-01 19:04:37 +00:00
|
|
|
/*
|
|
|
|
* MPSAFE
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
fstat(struct thread *td, struct fstat_args *uap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct stat ub;
|
|
|
|
int error;
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
error = kern_fstat(td, uap->fd, &ub);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error == 0)
|
2002-10-16 15:45:37 +00:00
|
|
|
error = copyout(&ub, uap->sb, sizeof(ub));
|
2005-02-07 18:44:55 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_fstat(struct thread *td, int fd, struct stat *sbp)
|
|
|
|
{
|
|
|
|
struct file *fp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if ((error = fget(td, fd, &fp)) != 0)
|
|
|
|
return (error);
|
|
|
|
error = fo_stat(fp, sbp, td->td_ucred, td);
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1998-05-11 03:55:28 +00:00
|
|
|
/*
|
|
|
|
* Return status information about a file descriptor.
|
|
|
|
*/
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct nfstat_args {
|
|
|
|
int fd;
|
|
|
|
struct nstat *sb;
|
|
|
|
};
|
|
|
|
#endif
|
2001-09-01 19:04:37 +00:00
|
|
|
/*
|
|
|
|
* MPSAFE
|
|
|
|
*/
|
1998-05-11 03:55:28 +00:00
|
|
|
/* ARGSUSED */
|
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
nfstat(struct thread *td, struct nfstat_args *uap)
|
1998-05-11 03:55:28 +00:00
|
|
|
{
|
|
|
|
struct nstat nub;
|
2005-02-07 18:44:55 +00:00
|
|
|
struct stat ub;
|
1998-05-11 03:55:28 +00:00
|
|
|
int error;
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
error = kern_fstat(td, uap->fd, &ub);
|
1998-05-11 03:55:28 +00:00
|
|
|
if (error == 0) {
|
|
|
|
cvtnstat(&ub, &nub);
|
2002-10-16 15:45:37 +00:00
|
|
|
error = copyout(&nub, uap->sb, sizeof(nub));
|
1998-05-11 03:55:28 +00:00
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Return pathconf information about a file descriptor.
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct fpathconf_args {
|
|
|
|
int fd;
|
|
|
|
int name;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
2001-09-01 19:04:37 +00:00
|
|
|
/*
|
|
|
|
* MPSAFE
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
fpathconf(struct thread *td, struct fpathconf_args *uap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct file *fp;
|
|
|
|
struct vnode *vp;
|
2001-11-14 06:30:36 +00:00
|
|
|
int error;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-11-14 06:30:36 +00:00
|
|
|
if ((error = fget(td, uap->fd, &fp)) != 0)
|
2002-01-14 00:13:45 +00:00
|
|
|
return (error);
|
2002-10-27 18:07:41 +00:00
|
|
|
|
|
|
|
/* If asynchronous I/O is available, it works for all descriptors. */
|
|
|
|
if (uap->name == _PC_ASYNC_IO) {
|
|
|
|
td->td_retval[0] = async_io_version;
|
|
|
|
goto out;
|
|
|
|
}
|
2003-07-04 12:20:27 +00:00
|
|
|
vp = fp->f_vnode;
|
|
|
|
if (vp != NULL) {
|
2005-01-24 10:19:31 +00:00
|
|
|
int vfslocked;
|
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2003-05-15 21:13:08 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
|
2001-09-12 08:38:13 +00:00
|
|
|
error = VOP_PATHCONF(vp, uap->name, td->td_retval);
|
2003-05-15 21:13:08 +00:00
|
|
|
VOP_UNLOCK(vp, 0, td);
|
2005-01-24 10:19:31 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2003-07-04 12:20:27 +00:00
|
|
|
} else if (fp->f_type == DTYPE_PIPE || fp->f_type == DTYPE_SOCKET) {
|
|
|
|
if (uap->name != _PC_PIPE_BUF) {
|
|
|
|
error = EINVAL;
|
|
|
|
} else {
|
|
|
|
td->td_retval[0] = PIPE_BUF;
|
|
|
|
error = 0;
|
|
|
|
}
|
|
|
|
} else {
|
2000-11-18 21:01:04 +00:00
|
|
|
error = EOPNOTSUPP;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2002-10-27 18:07:41 +00:00
|
|
|
out:
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
2002-10-16 15:45:37 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2004-01-15 10:15:04 +00:00
|
|
|
* Grow the file table to accomodate (at least) nfd descriptors. This may
|
|
|
|
* block and drop the filedesc lock, but it will reacquire it before
|
2005-03-08 00:58:50 +00:00
|
|
|
* returning.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2004-01-15 10:15:04 +00:00
|
|
|
static void
|
|
|
|
fdgrowtable(struct filedesc *fdp, int nfd)
|
|
|
|
{
|
|
|
|
struct file **ntable;
|
|
|
|
char *nfileflags;
|
|
|
|
int nnfiles, onfiles;
|
|
|
|
NDSLOTTYPE *nmap;
|
|
|
|
|
|
|
|
FILEDESC_LOCK_ASSERT(fdp, MA_OWNED);
|
|
|
|
|
|
|
|
KASSERT(fdp->fd_nfiles > 0,
|
|
|
|
("zero-length file table"));
|
|
|
|
|
|
|
|
/* compute the size of the new table */
|
|
|
|
onfiles = fdp->fd_nfiles;
|
|
|
|
nnfiles = NDSLOTS(nfd) * NDENTRIES; /* round up */
|
|
|
|
if (nnfiles <= onfiles)
|
|
|
|
/* the table is already large enough */
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* allocate a new table and (if required) new bitmaps */
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
MALLOC(ntable, struct file **, nnfiles * OFILESIZE,
|
|
|
|
M_FILEDESC, M_ZERO | M_WAITOK);
|
|
|
|
nfileflags = (char *)&ntable[nnfiles];
|
|
|
|
if (NDSLOTS(nnfiles) > NDSLOTS(onfiles))
|
|
|
|
MALLOC(nmap, NDSLOTTYPE *, NDSLOTS(nnfiles) * NDSLOTSIZE,
|
|
|
|
M_FILEDESC, M_ZERO | M_WAITOK);
|
|
|
|
else
|
|
|
|
nmap = NULL;
|
|
|
|
FILEDESC_LOCK(fdp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We now have new tables ready to go. Since we dropped the
|
|
|
|
* filedesc lock to call malloc(), watch out for a race.
|
|
|
|
*/
|
|
|
|
onfiles = fdp->fd_nfiles;
|
|
|
|
if (onfiles >= nnfiles) {
|
|
|
|
/* we lost the race, but that's OK */
|
|
|
|
free(ntable, M_FILEDESC);
|
|
|
|
if (nmap != NULL)
|
|
|
|
free(nmap, M_FILEDESC);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
bcopy(fdp->fd_ofiles, ntable, onfiles * sizeof(*ntable));
|
|
|
|
bcopy(fdp->fd_ofileflags, nfileflags, onfiles);
|
|
|
|
if (onfiles > NDFILE)
|
|
|
|
free(fdp->fd_ofiles, M_FILEDESC);
|
|
|
|
fdp->fd_ofiles = ntable;
|
|
|
|
fdp->fd_ofileflags = nfileflags;
|
|
|
|
if (NDSLOTS(nnfiles) > NDSLOTS(onfiles)) {
|
|
|
|
bcopy(fdp->fd_map, nmap, NDSLOTS(onfiles) * sizeof(*nmap));
|
|
|
|
if (NDSLOTS(onfiles) > NDSLOTS(NDFILE))
|
|
|
|
free(fdp->fd_map, M_FILEDESC);
|
|
|
|
fdp->fd_map = nmap;
|
|
|
|
}
|
|
|
|
fdp->fd_nfiles = nnfiles;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-01-15 10:15:04 +00:00
|
|
|
/*
|
|
|
|
* Allocate a file descriptor for the process.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-01-17 00:59:04 +00:00
|
|
|
fdalloc(struct thread *td, int minfd, int *result)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct proc *p = td->td_proc;
|
2004-01-15 10:15:04 +00:00
|
|
|
struct filedesc *fdp = p->p_fd;
|
|
|
|
int fd = -1, maxfd;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_LOCK_ASSERT(fdp, MA_OWNED);
|
|
|
|
|
2005-08-26 11:16:39 +00:00
|
|
|
if (fdp->fd_freefile > minfd)
|
|
|
|
minfd = fdp->fd_freefile;
|
|
|
|
|
2004-02-04 21:52:57 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
maxfd = min((int)lim_cur(p, RLIMIT_NOFILE), maxfilesperproc);
|
|
|
|
PROC_UNLOCK(p);
|
2004-01-15 10:15:04 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2004-01-15 10:15:04 +00:00
|
|
|
* Search the bitmap for a free descriptor. If none is found, try
|
|
|
|
* to grow the file table. Keep at it until we either get a file
|
|
|
|
* descriptor or run into process or system limits; fdgrowtable()
|
|
|
|
* may drop the filedesc lock, so we're in a race.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
for (;;) {
|
2004-01-17 00:59:04 +00:00
|
|
|
fd = fd_first_free(fdp, minfd, fdp->fd_nfiles);
|
2004-01-15 10:15:04 +00:00
|
|
|
if (fd >= maxfd)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EMFILE);
|
2004-01-15 10:15:04 +00:00
|
|
|
if (fd < fdp->fd_nfiles)
|
|
|
|
break;
|
|
|
|
fdgrowtable(fdp, min(fdp->fd_nfiles * 2, maxfd));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2004-01-15 10:15:04 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform some sanity checks, then mark the file descriptor as
|
|
|
|
* used and return it to the caller.
|
|
|
|
*/
|
|
|
|
KASSERT(!fdisused(fdp, fd),
|
|
|
|
("fd_first_free() returned non-free descriptor"));
|
|
|
|
KASSERT(fdp->fd_ofiles[fd] == NULL,
|
|
|
|
("free descriptor isn't"));
|
|
|
|
fdp->fd_ofileflags[fd] = 0; /* XXX needed? */
|
|
|
|
fdused(fdp, fd);
|
|
|
|
*result = fd;
|
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check to see whether n user file descriptors
|
|
|
|
* are available to the process p.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
fdavail(struct thread *td, int n)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct proc *p = td->td_proc;
|
2003-01-01 01:05:54 +00:00
|
|
|
struct filedesc *fdp = td->td_proc->p_fd;
|
|
|
|
struct file **fpp;
|
|
|
|
int i, lim, last;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_LOCK_ASSERT(fdp, MA_OWNED);
|
|
|
|
|
2004-02-04 21:52:57 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
lim = min((int)lim_cur(p, RLIMIT_NOFILE), maxfilesperproc);
|
|
|
|
PROC_UNLOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((i = lim - fdp->fd_nfiles) > 0 && (n -= i) <= 0)
|
|
|
|
return (1);
|
1996-08-15 16:33:32 +00:00
|
|
|
last = min(fdp->fd_nfiles, lim);
|
1994-05-24 10:09:53 +00:00
|
|
|
fpp = &fdp->fd_ofiles[fdp->fd_freefile];
|
2000-11-18 21:01:04 +00:00
|
|
|
for (i = last - fdp->fd_freefile; --i >= 0; fpp++) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (*fpp == NULL && --n <= 0)
|
|
|
|
return (1);
|
2000-11-18 21:01:04 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a new open file structure and allocate
|
|
|
|
* a file decriptor for the process that refers to it.
|
2003-10-19 20:41:07 +00:00
|
|
|
* We add one reference to the file for the descriptor table
|
|
|
|
* and one reference for resultfp. This is to prevent us being
|
2005-03-08 00:58:50 +00:00
|
|
|
* preempted and the entry in the descriptor table closed after
|
2003-10-19 20:41:07 +00:00
|
|
|
* we release the FILEDESC lock.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
falloc(struct thread *td, struct file **resultfp, int *resultfd)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
struct proc *p = td->td_proc;
|
2003-01-01 01:05:54 +00:00
|
|
|
struct file *fp, *fq;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error, i;
|
2003-06-18 18:57:58 +00:00
|
|
|
int maxuserfiles = maxfiles - (maxfiles / 20);
|
2003-06-19 04:07:12 +00:00
|
|
|
static struct timeval lastfail;
|
|
|
|
static int curfail;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
fp = uma_zalloc(file_zone, M_WAITOK | M_ZERO);
|
2002-01-13 11:58:06 +00:00
|
|
|
sx_xlock(&filelist_lock);
|
2004-12-01 09:22:26 +00:00
|
|
|
if ((openfiles >= maxuserfiles && (td->td_ucred->cr_ruid != 0 ||
|
|
|
|
jailed(td->td_ucred))) || openfiles >= maxfiles) {
|
2003-06-19 04:07:12 +00:00
|
|
|
if (ppsratecheck(&lastfail, &curfail, 1)) {
|
|
|
|
printf("kern.maxfiles limit exceeded by uid %i, please see tuning(7).\n",
|
|
|
|
td->td_ucred->cr_ruid);
|
2004-01-11 19:39:14 +00:00
|
|
|
}
|
2002-01-13 11:58:06 +00:00
|
|
|
sx_xunlock(&filelist_lock);
|
2002-07-17 02:48:43 +00:00
|
|
|
uma_zfree(file_zone, fp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (ENFILE);
|
|
|
|
}
|
2004-12-01 09:22:26 +00:00
|
|
|
openfiles++;
|
2000-11-18 21:01:04 +00:00
|
|
|
|
|
|
|
/*
|
2002-07-17 02:48:43 +00:00
|
|
|
* If the process has file descriptor zero open, add the new file
|
|
|
|
* descriptor to the list of open files at that point, otherwise
|
|
|
|
* put it at the front of the list of open files.
|
2000-11-18 21:01:04 +00:00
|
|
|
*/
|
2003-07-13 01:22:21 +00:00
|
|
|
fp->f_mtxp = mtx_pool_alloc(mtxpool_sleep);
|
1999-08-04 18:53:50 +00:00
|
|
|
fp->f_count = 1;
|
2003-10-19 20:41:07 +00:00
|
|
|
if (resultfp)
|
|
|
|
fp->f_count++;
|
2002-02-27 18:32:23 +00:00
|
|
|
fp->f_cred = crhold(td->td_ucred);
|
1999-08-04 18:53:50 +00:00
|
|
|
fp->f_ops = &badfileops;
|
2004-06-19 11:40:08 +00:00
|
|
|
fp->f_data = NULL;
|
|
|
|
fp->f_vnode = NULL;
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
FILEDESC_LOCK(p->p_fd);
|
1996-03-11 02:17:30 +00:00
|
|
|
if ((fq = p->p_fd->fd_ofiles[0])) {
|
|
|
|
LIST_INSERT_AFTER(fq, fp, f_list);
|
|
|
|
} else {
|
|
|
|
LIST_INSERT_HEAD(&filehead, fp, f_list);
|
|
|
|
}
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
sx_xunlock(&filelist_lock);
|
2004-01-17 00:59:04 +00:00
|
|
|
if ((error = fdalloc(td, 0, &i))) {
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
FILEDESC_UNLOCK(p->p_fd);
|
|
|
|
fdrop(fp, td);
|
2003-10-19 20:41:07 +00:00
|
|
|
if (resultfp)
|
|
|
|
fdrop(fp, td);
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
return (error);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_fd->fd_ofiles[i] = fp;
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(p->p_fd);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (resultfp)
|
|
|
|
*resultfp = fp;
|
|
|
|
if (resultfd)
|
|
|
|
*resultfd = i;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1996-02-23 18:49:25 +00:00
|
|
|
/*
|
2003-01-01 01:01:14 +00:00
|
|
|
* Build a new filedesc structure from another.
|
|
|
|
* Copy the current, root, and jail root vnode references.
|
1996-02-23 18:49:25 +00:00
|
|
|
*/
|
|
|
|
struct filedesc *
|
2004-11-16 09:12:03 +00:00
|
|
|
fdinit(struct filedesc *fdp)
|
1996-02-23 18:49:25 +00:00
|
|
|
{
|
2003-01-01 01:05:54 +00:00
|
|
|
struct filedesc0 *newfdp;
|
1996-02-23 18:49:25 +00:00
|
|
|
|
2004-11-07 12:39:28 +00:00
|
|
|
newfdp = malloc(sizeof *newfdp, M_FILEDESC, M_WAITOK | M_ZERO);
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&newfdp->fd_fd.fd_mtx, FILEDESC_LOCK_DESC, NULL, MTX_DEF);
|
2004-11-07 12:39:28 +00:00
|
|
|
if (fdp != NULL) {
|
|
|
|
FILEDESC_LOCK(fdp);
|
|
|
|
newfdp->fd_fd.fd_cdir = fdp->fd_cdir;
|
|
|
|
if (newfdp->fd_fd.fd_cdir)
|
|
|
|
VREF(newfdp->fd_fd.fd_cdir);
|
|
|
|
newfdp->fd_fd.fd_rdir = fdp->fd_rdir;
|
|
|
|
if (newfdp->fd_fd.fd_rdir)
|
|
|
|
VREF(newfdp->fd_fd.fd_rdir);
|
|
|
|
newfdp->fd_fd.fd_jdir = fdp->fd_jdir;
|
|
|
|
if (newfdp->fd_fd.fd_jdir)
|
|
|
|
VREF(newfdp->fd_fd.fd_jdir);
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
}
|
1996-02-23 18:49:25 +00:00
|
|
|
|
|
|
|
/* Create the file descriptor table. */
|
|
|
|
newfdp->fd_fd.fd_refcnt = 1;
|
2004-12-14 09:09:51 +00:00
|
|
|
newfdp->fd_fd.fd_holdcnt = 1;
|
2003-10-02 03:57:59 +00:00
|
|
|
newfdp->fd_fd.fd_cmask = CMASK;
|
1996-02-23 18:49:25 +00:00
|
|
|
newfdp->fd_fd.fd_ofiles = newfdp->fd_dfiles;
|
|
|
|
newfdp->fd_fd.fd_ofileflags = newfdp->fd_dfileflags;
|
|
|
|
newfdp->fd_fd.fd_nfiles = NDFILE;
|
2004-01-15 10:15:04 +00:00
|
|
|
newfdp->fd_fd.fd_map = newfdp->fd_dmap;
|
1996-02-23 18:49:25 +00:00
|
|
|
return (&newfdp->fd_fd);
|
|
|
|
}
|
|
|
|
|
2004-12-14 09:09:51 +00:00
|
|
|
static struct filedesc *
|
|
|
|
fdhold(struct proc *p)
|
|
|
|
{
|
|
|
|
struct filedesc *fdp;
|
|
|
|
|
|
|
|
mtx_lock(&fdesc_mtx);
|
|
|
|
fdp = p->p_fd;
|
|
|
|
if (fdp != NULL)
|
|
|
|
fdp->fd_holdcnt++;
|
|
|
|
mtx_unlock(&fdesc_mtx);
|
|
|
|
return (fdp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
fddrop(struct filedesc *fdp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mtx_lock(&fdesc_mtx);
|
|
|
|
i = --fdp->fd_holdcnt;
|
|
|
|
mtx_unlock(&fdesc_mtx);
|
|
|
|
if (i > 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mtx_destroy(&fdp->fd_mtx);
|
|
|
|
FREE(fdp, M_FILEDESC);
|
|
|
|
}
|
|
|
|
|
1996-02-23 18:49:25 +00:00
|
|
|
/*
|
|
|
|
* Share a filedesc structure.
|
|
|
|
*/
|
|
|
|
struct filedesc *
|
2004-12-02 11:56:13 +00:00
|
|
|
fdshare(struct filedesc *fdp)
|
1996-02-23 18:49:25 +00:00
|
|
|
{
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_LOCK_FAST(fdp);
|
2003-01-01 01:01:14 +00:00
|
|
|
fdp->fd_refcnt++;
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_UNLOCK_FAST(fdp);
|
2003-01-01 01:01:14 +00:00
|
|
|
return (fdp);
|
1996-02-23 18:49:25 +00:00
|
|
|
}
|
|
|
|
|
2004-12-14 07:20:03 +00:00
|
|
|
/*
|
|
|
|
* Unshare a filedesc structure, if necessary by making a copy
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
fdunshare(struct proc *p, struct thread *td)
|
|
|
|
{
|
|
|
|
|
|
|
|
FILEDESC_LOCK_FAST(p->p_fd);
|
|
|
|
if (p->p_fd->fd_refcnt > 1) {
|
|
|
|
struct filedesc *tmp;
|
|
|
|
|
|
|
|
FILEDESC_UNLOCK_FAST(p->p_fd);
|
|
|
|
tmp = fdcopy(p->p_fd);
|
|
|
|
fdfree(td);
|
|
|
|
p->p_fd = tmp;
|
|
|
|
} else
|
|
|
|
FILEDESC_UNLOCK_FAST(p->p_fd);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Copy a filedesc structure.
|
2003-01-01 01:19:31 +00:00
|
|
|
* A NULL pointer in returns a NULL reference, this is to ease callers,
|
|
|
|
* not catch errors.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
struct filedesc *
|
2004-12-02 11:56:13 +00:00
|
|
|
fdcopy(struct filedesc *fdp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-01-01 01:19:31 +00:00
|
|
|
struct filedesc *newfdp;
|
2004-01-15 10:15:04 +00:00
|
|
|
int i;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-12-26 14:07:43 +00:00
|
|
|
/* Certain daemons might not have file descriptors. */
|
1997-11-29 01:33:10 +00:00
|
|
|
if (fdp == NULL)
|
1999-12-26 14:07:43 +00:00
|
|
|
return (NULL);
|
1997-11-29 01:33:10 +00:00
|
|
|
|
2004-01-15 10:15:04 +00:00
|
|
|
newfdp = fdinit(fdp);
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_LOCK_FAST(fdp);
|
2004-01-15 18:50:11 +00:00
|
|
|
while (fdp->fd_lastfile >= newfdp->fd_nfiles) {
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_UNLOCK_FAST(fdp);
|
2004-01-16 21:54:56 +00:00
|
|
|
FILEDESC_LOCK(newfdp);
|
2004-01-15 10:15:04 +00:00
|
|
|
fdgrowtable(newfdp, fdp->fd_lastfile + 1);
|
2004-01-16 21:54:56 +00:00
|
|
|
FILEDESC_UNLOCK(newfdp);
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_LOCK_FAST(fdp);
|
2004-01-15 18:50:11 +00:00
|
|
|
}
|
2004-01-15 10:15:04 +00:00
|
|
|
/* copy everything except kqueue descriptors */
|
|
|
|
newfdp->fd_freefile = -1;
|
|
|
|
for (i = 0; i <= fdp->fd_lastfile; ++i) {
|
|
|
|
if (fdisused(fdp, i) &&
|
|
|
|
fdp->fd_ofiles[i]->f_type != DTYPE_KQUEUE) {
|
|
|
|
newfdp->fd_ofiles[i] = fdp->fd_ofiles[i];
|
|
|
|
newfdp->fd_ofileflags[i] = fdp->fd_ofileflags[i];
|
|
|
|
fhold(newfdp->fd_ofiles[i]);
|
|
|
|
newfdp->fd_lastfile = i;
|
|
|
|
} else {
|
|
|
|
if (newfdp->fd_freefile == -1)
|
|
|
|
newfdp->fd_freefile = i;
|
2000-11-18 21:01:04 +00:00
|
|
|
}
|
|
|
|
}
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_UNLOCK_FAST(fdp);
|
2004-01-16 21:54:56 +00:00
|
|
|
FILEDESC_LOCK(newfdp);
|
|
|
|
for (i = 0; i <= newfdp->fd_lastfile; ++i)
|
|
|
|
if (newfdp->fd_ofiles[i] != NULL)
|
|
|
|
fdused(newfdp, i);
|
|
|
|
FILEDESC_UNLOCK(newfdp);
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_LOCK_FAST(fdp);
|
2004-01-15 10:15:04 +00:00
|
|
|
if (newfdp->fd_freefile == -1)
|
|
|
|
newfdp->fd_freefile = i;
|
|
|
|
newfdp->fd_cmask = fdp->fd_cmask;
|
2004-11-13 11:53:02 +00:00
|
|
|
FILEDESC_UNLOCK_FAST(fdp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (newfdp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Release a filedesc structure.
|
|
|
|
*/
|
|
|
|
void
|
2004-12-02 11:56:13 +00:00
|
|
|
fdfree(struct thread *td)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-01-01 01:05:54 +00:00
|
|
|
struct filedesc *fdp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct file **fpp;
|
2005-11-01 17:13:05 +00:00
|
|
|
int i, locked;
|
2003-06-02 16:05:32 +00:00
|
|
|
struct filedesc_to_leader *fdtol;
|
|
|
|
struct file *fp;
|
2005-11-01 17:13:05 +00:00
|
|
|
struct vnode *cdir, *jdir, *rdir, *vp;
|
2003-06-02 16:05:32 +00:00
|
|
|
struct flock lf;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-12-26 14:07:43 +00:00
|
|
|
/* Certain daemons might not have file descriptors. */
|
2002-10-16 15:45:37 +00:00
|
|
|
fdp = td->td_proc->p_fd;
|
1997-11-29 01:33:10 +00:00
|
|
|
if (fdp == NULL)
|
|
|
|
return;
|
|
|
|
|
2003-06-02 16:05:32 +00:00
|
|
|
/* Check for special need to clear POSIX style locks */
|
|
|
|
fdtol = td->td_proc->p_fdtol;
|
|
|
|
if (fdtol != NULL) {
|
|
|
|
FILEDESC_LOCK(fdp);
|
|
|
|
KASSERT(fdtol->fdl_refcount > 0,
|
|
|
|
("filedesc_to_refcount botch: fdl_refcount=%d",
|
|
|
|
fdtol->fdl_refcount));
|
|
|
|
if (fdtol->fdl_refcount == 1 &&
|
|
|
|
(td->td_proc->p_leader->p_flag & P_ADVLOCK) != 0) {
|
|
|
|
for (i = 0, fpp = fdp->fd_ofiles;
|
2004-01-15 10:15:04 +00:00
|
|
|
i <= fdp->fd_lastfile;
|
2003-06-02 16:05:32 +00:00
|
|
|
i++, fpp++) {
|
|
|
|
if (*fpp == NULL ||
|
|
|
|
(*fpp)->f_type != DTYPE_VNODE)
|
|
|
|
continue;
|
|
|
|
fp = *fpp;
|
|
|
|
fhold(fp);
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
lf.l_whence = SEEK_SET;
|
|
|
|
lf.l_start = 0;
|
|
|
|
lf.l_len = 0;
|
|
|
|
lf.l_type = F_UNLCK;
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
2005-11-01 17:13:05 +00:00
|
|
|
locked = VFS_LOCK_GIANT(vp->v_mount);
|
2003-06-02 16:05:32 +00:00
|
|
|
(void) VOP_ADVLOCK(vp,
|
|
|
|
(caddr_t)td->td_proc->
|
|
|
|
p_leader,
|
|
|
|
F_UNLCK,
|
|
|
|
&lf,
|
|
|
|
F_POSIX);
|
2005-11-01 17:13:05 +00:00
|
|
|
VFS_UNLOCK_GIANT(locked);
|
2003-06-02 16:05:32 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
|
|
|
fdrop(fp, td);
|
|
|
|
fpp = fdp->fd_ofiles + i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
retry:
|
|
|
|
if (fdtol->fdl_refcount == 1) {
|
|
|
|
if (fdp->fd_holdleaderscount > 0 &&
|
|
|
|
(td->td_proc->p_leader->p_flag & P_ADVLOCK) != 0) {
|
|
|
|
/*
|
|
|
|
* close() or do_dup() has cleared a reference
|
|
|
|
* in a shared file descriptor table.
|
|
|
|
*/
|
|
|
|
fdp->fd_holdleaderswakeup = 1;
|
|
|
|
msleep(&fdp->fd_holdleaderscount, &fdp->fd_mtx,
|
|
|
|
PLOCK, "fdlhold", 0);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
if (fdtol->fdl_holdcount > 0) {
|
2004-01-11 19:39:14 +00:00
|
|
|
/*
|
2003-06-02 16:05:32 +00:00
|
|
|
* Ensure that fdtol->fdl_leader
|
|
|
|
* remains valid in closef().
|
|
|
|
*/
|
|
|
|
fdtol->fdl_wakeup = 1;
|
|
|
|
msleep(fdtol, &fdp->fd_mtx,
|
|
|
|
PLOCK, "fdlhold", 0);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fdtol->fdl_refcount--;
|
|
|
|
if (fdtol->fdl_refcount == 0 &&
|
|
|
|
fdtol->fdl_holdcount == 0) {
|
|
|
|
fdtol->fdl_next->fdl_prev = fdtol->fdl_prev;
|
|
|
|
fdtol->fdl_prev->fdl_next = fdtol->fdl_next;
|
|
|
|
} else
|
|
|
|
fdtol = NULL;
|
|
|
|
td->td_proc->p_fdtol = NULL;
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
if (fdtol != NULL)
|
|
|
|
FREE(fdtol, M_FILEDESC_TO_LEADER);
|
|
|
|
}
|
2004-12-14 20:48:40 +00:00
|
|
|
FILEDESC_LOCK_FAST(fdp);
|
|
|
|
i = --fdp->fd_refcnt;
|
|
|
|
FILEDESC_UNLOCK_FAST(fdp);
|
|
|
|
if (i > 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return;
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
2002-10-16 15:45:37 +00:00
|
|
|
* We are the last reference to the structure, so we can
|
2000-11-18 21:01:04 +00:00
|
|
|
* safely assume it will not change out from under us.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
fpp = fdp->fd_ofiles;
|
2000-11-18 21:01:04 +00:00
|
|
|
for (i = fdp->fd_lastfile; i-- >= 0; fpp++) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (*fpp)
|
2001-09-12 08:38:13 +00:00
|
|
|
(void) closef(*fpp, td);
|
2000-11-18 21:01:04 +00:00
|
|
|
}
|
2004-12-14 20:48:40 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
2003-02-24 05:46:55 +00:00
|
|
|
|
|
|
|
/* XXX This should happen earlier. */
|
|
|
|
mtx_lock(&fdesc_mtx);
|
|
|
|
td->td_proc->p_fd = NULL;
|
|
|
|
mtx_unlock(&fdesc_mtx);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if (fdp->fd_nfiles > NDFILE)
|
|
|
|
FREE(fdp->fd_ofiles, M_FILEDESC);
|
2004-01-15 10:15:04 +00:00
|
|
|
if (NDSLOTS(fdp->fd_nfiles) > NDSLOTS(NDFILE))
|
|
|
|
FREE(fdp->fd_map, M_FILEDESC);
|
2004-12-14 09:09:51 +00:00
|
|
|
|
|
|
|
fdp->fd_nfiles = 0;
|
|
|
|
|
2005-11-01 17:13:05 +00:00
|
|
|
cdir = fdp->fd_cdir;
|
2004-12-14 09:09:51 +00:00
|
|
|
fdp->fd_cdir = NULL;
|
2005-11-01 17:13:05 +00:00
|
|
|
rdir = fdp->fd_rdir;
|
2004-12-14 09:09:51 +00:00
|
|
|
fdp->fd_rdir = NULL;
|
2005-11-01 17:13:05 +00:00
|
|
|
jdir = fdp->fd_jdir;
|
2004-12-14 09:09:51 +00:00
|
|
|
fdp->fd_jdir = NULL;
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
|
2005-11-01 17:13:05 +00:00
|
|
|
if (cdir) {
|
|
|
|
locked = VFS_LOCK_GIANT(cdir->v_mount);
|
|
|
|
vrele(cdir);
|
|
|
|
VFS_UNLOCK_GIANT(locked);
|
|
|
|
}
|
|
|
|
if (rdir) {
|
|
|
|
locked = VFS_LOCK_GIANT(rdir->v_mount);
|
|
|
|
vrele(rdir);
|
|
|
|
VFS_UNLOCK_GIANT(locked);
|
|
|
|
}
|
|
|
|
if (jdir) {
|
|
|
|
locked = VFS_LOCK_GIANT(jdir->v_mount);
|
|
|
|
vrele(jdir);
|
|
|
|
VFS_UNLOCK_GIANT(locked);
|
|
|
|
}
|
|
|
|
|
2004-12-14 09:09:51 +00:00
|
|
|
fddrop(fdp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2000-01-20 07:12:52 +00:00
|
|
|
/*
|
2000-01-21 02:52:54 +00:00
|
|
|
* For setugid programs, we don't want to people to use that setugidness
|
2000-01-20 07:12:52 +00:00
|
|
|
* to generate error messages which write to a file which otherwise would
|
2002-09-14 09:02:28 +00:00
|
|
|
* otherwise be off-limits to the process. We check for filesystems where
|
|
|
|
* the vnode can change out from under us after execve (like [lin]procfs).
|
2000-01-20 07:12:52 +00:00
|
|
|
*
|
|
|
|
* Since setugidsafety calls this only for fd 0, 1 and 2, this check is
|
2005-03-08 00:58:50 +00:00
|
|
|
* sufficient. We also don't check for setugidness since we know we are.
|
2000-01-20 07:12:52 +00:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
is_unsafe(struct file *fp)
|
|
|
|
{
|
2002-09-14 09:02:28 +00:00
|
|
|
if (fp->f_type == DTYPE_VNODE) {
|
2003-06-22 08:41:43 +00:00
|
|
|
struct vnode *vp = fp->f_vnode;
|
2002-09-14 09:02:28 +00:00
|
|
|
|
|
|
|
if ((vp->v_vflag & VV_PROCDEP) != 0)
|
|
|
|
return (1);
|
|
|
|
}
|
2000-01-20 07:12:52 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make this setguid thing safe, if at all possible.
|
|
|
|
*/
|
|
|
|
void
|
2004-12-02 11:56:13 +00:00
|
|
|
setugidsafety(struct thread *td)
|
2000-01-20 07:12:52 +00:00
|
|
|
{
|
2002-10-16 15:45:37 +00:00
|
|
|
struct filedesc *fdp;
|
2003-01-01 01:05:54 +00:00
|
|
|
int i;
|
2000-01-20 07:12:52 +00:00
|
|
|
|
|
|
|
/* Certain daemons might not have file descriptors. */
|
2002-10-16 15:45:37 +00:00
|
|
|
fdp = td->td_proc->p_fd;
|
2000-01-20 07:12:52 +00:00
|
|
|
if (fdp == NULL)
|
|
|
|
return;
|
|
|
|
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
2002-10-16 15:45:37 +00:00
|
|
|
* Note: fdp->fd_ofiles may be reallocated out from under us while
|
2000-11-18 21:01:04 +00:00
|
|
|
* we are blocked in a close. Be careful!
|
|
|
|
*/
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
2000-11-18 21:01:04 +00:00
|
|
|
for (i = 0; i <= fdp->fd_lastfile; i++) {
|
2000-01-21 06:57:52 +00:00
|
|
|
if (i > 2)
|
|
|
|
break;
|
2000-11-18 21:01:04 +00:00
|
|
|
if (fdp->fd_ofiles[i] && is_unsafe(fdp->fd_ofiles[i])) {
|
|
|
|
struct file *fp;
|
|
|
|
|
2004-08-15 06:24:42 +00:00
|
|
|
knote_fdclose(td, i);
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
|
|
|
* NULL-out descriptor prior to close to avoid
|
|
|
|
* a race while close blocks.
|
|
|
|
*/
|
|
|
|
fp = fdp->fd_ofiles[i];
|
|
|
|
fdp->fd_ofiles[i] = NULL;
|
|
|
|
fdp->fd_ofileflags[i] = 0;
|
2004-01-15 10:15:04 +00:00
|
|
|
fdunused(fdp, i);
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-12 08:38:13 +00:00
|
|
|
(void) closef(fp, td);
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
2000-01-20 07:12:52 +00:00
|
|
|
}
|
|
|
|
}
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2000-01-20 07:12:52 +00:00
|
|
|
}
|
|
|
|
|
2004-11-07 22:16:07 +00:00
|
|
|
void
|
|
|
|
fdclose(struct filedesc *fdp, struct file *fp, int idx, struct thread *td)
|
|
|
|
{
|
|
|
|
|
|
|
|
FILEDESC_LOCK(fdp);
|
|
|
|
if (fdp->fd_ofiles[idx] == fp) {
|
|
|
|
fdp->fd_ofiles[idx] = NULL;
|
|
|
|
fdunused(fdp, idx);
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
fdrop(fp, td);
|
|
|
|
} else {
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
/*
|
|
|
|
* Close any files on exec?
|
|
|
|
*/
|
|
|
|
void
|
2004-12-02 11:56:13 +00:00
|
|
|
fdcloseexec(struct thread *td)
|
1994-05-25 09:21:21 +00:00
|
|
|
{
|
2002-10-16 15:45:37 +00:00
|
|
|
struct filedesc *fdp;
|
2003-01-01 01:05:54 +00:00
|
|
|
int i;
|
1994-05-25 09:21:21 +00:00
|
|
|
|
1999-12-26 14:07:43 +00:00
|
|
|
/* Certain daemons might not have file descriptors. */
|
2002-10-16 15:45:37 +00:00
|
|
|
fdp = td->td_proc->p_fd;
|
1997-11-29 01:33:10 +00:00
|
|
|
if (fdp == NULL)
|
|
|
|
return;
|
|
|
|
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
|
|
|
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
|
|
|
* We cannot cache fd_ofiles or fd_ofileflags since operations
|
|
|
|
* may block and rip them out from under us.
|
|
|
|
*/
|
|
|
|
for (i = 0; i <= fdp->fd_lastfile; i++) {
|
|
|
|
if (fdp->fd_ofiles[i] != NULL &&
|
|
|
|
(fdp->fd_ofileflags[i] & UF_EXCLOSE)) {
|
|
|
|
struct file *fp;
|
|
|
|
|
2004-08-15 06:24:42 +00:00
|
|
|
knote_fdclose(td, i);
|
2000-11-18 21:01:04 +00:00
|
|
|
/*
|
|
|
|
* NULL-out descriptor prior to close to avoid
|
|
|
|
* a race while close blocks.
|
|
|
|
*/
|
|
|
|
fp = fdp->fd_ofiles[i];
|
|
|
|
fdp->fd_ofiles[i] = NULL;
|
|
|
|
fdp->fd_ofileflags[i] = 0;
|
2004-01-15 10:15:04 +00:00
|
|
|
fdunused(fdp, i);
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2001-09-12 08:38:13 +00:00
|
|
|
(void) closef(fp, td);
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
1994-05-25 09:21:21 +00:00
|
|
|
}
|
2000-11-18 21:01:04 +00:00
|
|
|
}
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
1994-05-25 09:21:21 +00:00
|
|
|
}
|
|
|
|
|
2002-04-19 00:45:29 +00:00
|
|
|
/*
|
|
|
|
* It is unsafe for set[ug]id processes to be started with file
|
|
|
|
* descriptors 0..2 closed, as these descriptors are given implicit
|
|
|
|
* significance in the Standard C library. fdcheckstd() will create a
|
|
|
|
* descriptor referencing /dev/null for each of stdin, stdout, and
|
|
|
|
* stderr that is not already open.
|
|
|
|
*/
|
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
fdcheckstd(struct thread *td)
|
2002-04-19 00:45:29 +00:00
|
|
|
{
|
|
|
|
struct nameidata nd;
|
|
|
|
struct filedesc *fdp;
|
|
|
|
struct file *fp;
|
|
|
|
register_t retval;
|
2004-02-15 21:14:48 +00:00
|
|
|
int fd, i, error, flags, devnull;
|
2002-04-19 00:45:29 +00:00
|
|
|
|
|
|
|
fdp = td->td_proc->p_fd;
|
|
|
|
if (fdp == NULL)
|
|
|
|
return (0);
|
2004-02-15 21:14:48 +00:00
|
|
|
KASSERT(fdp->fd_refcnt == 1, ("the fdtable should not be shared"));
|
2002-04-19 00:45:29 +00:00
|
|
|
devnull = -1;
|
|
|
|
error = 0;
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
if (fdp->fd_ofiles[i] != NULL)
|
|
|
|
continue;
|
|
|
|
if (devnull < 0) {
|
2005-05-03 10:52:22 +00:00
|
|
|
int vfslocked;
|
2002-04-19 00:45:29 +00:00
|
|
|
error = falloc(td, &fp, &fd);
|
|
|
|
if (error != 0)
|
|
|
|
break;
|
2003-10-19 20:41:07 +00:00
|
|
|
/* Note extra ref on `fp' held for us by falloc(). */
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
KASSERT(fd == i, ("oof, we didn't get our fd"));
|
2005-05-03 10:52:22 +00:00
|
|
|
NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE,
|
|
|
|
"/dev/null", td);
|
2002-04-19 00:45:29 +00:00
|
|
|
flags = FREAD | FWRITE;
|
2005-06-25 03:34:49 +00:00
|
|
|
error = vn_open(&nd, &flags, 0, fd);
|
2002-04-19 00:45:29 +00:00
|
|
|
if (error != 0) {
|
2003-10-19 20:41:07 +00:00
|
|
|
/*
|
|
|
|
* Someone may have closed the entry in the
|
|
|
|
* file descriptor table, so check it hasn't
|
|
|
|
* changed before dropping the reference count.
|
|
|
|
*/
|
2002-04-19 00:45:29 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
2004-02-15 21:14:48 +00:00
|
|
|
KASSERT(fdp->fd_ofiles[fd] == fp,
|
|
|
|
("table not shared, how did it change?"));
|
|
|
|
fdp->fd_ofiles[fd] = NULL;
|
|
|
|
fdunused(fdp, fd);
|
2002-04-19 00:45:29 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
fdrop(fp, td);
|
2004-02-15 21:14:48 +00:00
|
|
|
fdrop(fp, td);
|
2002-04-19 00:45:29 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-05-03 10:52:22 +00:00
|
|
|
vfslocked = NDHASGIANT(&nd);
|
2002-04-19 00:45:29 +00:00
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
fp->f_flag = flags;
|
2004-11-06 23:36:09 +00:00
|
|
|
fp->f_vnode = nd.ni_vp;
|
|
|
|
if (fp->f_data == NULL)
|
|
|
|
fp->f_data = nd.ni_vp;
|
|
|
|
if (fp->f_ops == &badfileops)
|
|
|
|
fp->f_ops = &vnops;
|
2002-04-19 00:45:29 +00:00
|
|
|
fp->f_type = DTYPE_VNODE;
|
|
|
|
VOP_UNLOCK(nd.ni_vp, 0, td);
|
2005-05-03 10:52:22 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2002-04-19 00:45:29 +00:00
|
|
|
devnull = fd;
|
2003-12-28 19:27:14 +00:00
|
|
|
fdrop(fp, td);
|
2002-04-19 00:45:29 +00:00
|
|
|
} else {
|
- Change falloc() to acquire an fd from the process table last so that
it can do it w/o needing to hold the filelist_lock sx lock.
- fdalloc() doesn't need Giant to call free() anymore. It also doesn't
need to drop and reacquire the filedesc lock around free() now as a
result.
- Try to make the code that copies fd tables when extending the fd table in
fdalloc() a bit more readable by performing assignments in separate
statements. This is still a bit ugly though.
- Use max() instead of an if statement so to figure out the starting point
in the search-for-a-free-fd loop in fdalloc() so it reads better next to
the min() in the previous line.
- Don't grow nfiles in steps up to the size needed if we dup2() to some
really large number. Go ahead and double 'nfiles' in a loop prior
to doing the malloc().
- malloc() doesn't need Giant now.
- Use malloc() and free() instead of MALLOC() and FREE() in fdalloc().
- Check to see if the size we are going to grow to is too big, not if the
current size of the fd table is too big in the loop in fdalloc(). This
means if we are out of space or if dup2() requests too high of a fd,
then we will return an error before we go off and try to allocate some
huge table and copy the existing table into it.
- Move all of the logic for dup'ing a file descriptor into do_dup() instead
of putting some of it in do_dup() and duplicating other parts in four
different places. This makes dup(), dup2(), and fcntl(F_DUPFD) basically
wrappers of do_dup now. fcntl() still has an extra check since it uses
a different error return value in one case then the other functions.
- Add a KASSERT() for an assertion that may not always be true where the
fdcheckstd() function assumes that falloc() returns the fd requested and
not some other fd. I think that the assertion is always true because we
are always single-threaded when we get to this point, but if one was
using rfork() and another process sharing the fd table were playing with
the fd table, there might could be a problem.
- To handle the problem of a file descriptor we are dup()'ing being closed
out from under us in dup() in general, do_dup() now obtains a reference
on the file in question before calling fdalloc(). If after the call to
fdalloc() the file for the fd we are dup'ing is a different file, then
we drop our reference on the original file and return EBADF. This
race was only handled in the dup2() case before and would just retry
the operation. The error return allows the user to know they are being
stupid since they have a locking bug in their app instead of dup'ing
some other descriptor and returning it to them.
Tested on: i386, alpha, sparc64
2002-09-03 20:16:31 +00:00
|
|
|
error = do_dup(td, DUP_FIXED, devnull, i, &retval);
|
2002-04-19 00:45:29 +00:00
|
|
|
if (error != 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Internal form of close.
|
|
|
|
* Decrement reference count on file structure.
|
2004-11-28 14:37:17 +00:00
|
|
|
* Note: td may be NULL when closing a file that was being passed in a
|
|
|
|
* message.
|
|
|
|
*
|
|
|
|
* XXXRW: Giant is not required for the caller, but often will be held; this
|
|
|
|
* makes it moderately likely the Giant will be recursed in the VFS case.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
closef(struct file *fp, struct thread *td)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct vnode *vp;
|
|
|
|
struct flock lf;
|
2003-06-02 16:05:32 +00:00
|
|
|
struct filedesc_to_leader *fdtol;
|
|
|
|
struct filedesc *fdp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* POSIX record locking dictates that any close releases ALL
|
|
|
|
* locks owned by this process. This is handled by setting
|
|
|
|
* a flag in the unlock to free ONLY locks obeying POSIX
|
|
|
|
* semantics, and not to free BSD-style file locks.
|
|
|
|
* If the descriptor was in a message, POSIX-style locks
|
2005-11-09 22:02:02 +00:00
|
|
|
* aren't passed with the descriptor, and the thread pointer
|
2005-11-09 20:54:25 +00:00
|
|
|
* will be NULL. Callers should be careful only to pass a
|
|
|
|
* NULL thread pointer when there really is no owning
|
|
|
|
* context that might have locks, or the locks will be
|
|
|
|
* leaked.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-11-09 20:54:25 +00:00
|
|
|
if (fp->f_type == DTYPE_VNODE && td != NULL) {
|
2005-01-24 10:19:31 +00:00
|
|
|
int vfslocked;
|
|
|
|
|
|
|
|
vp = fp->f_vnode;
|
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2003-06-02 16:05:32 +00:00
|
|
|
if ((td->td_proc->p_leader->p_flag & P_ADVLOCK) != 0) {
|
|
|
|
lf.l_whence = SEEK_SET;
|
|
|
|
lf.l_start = 0;
|
|
|
|
lf.l_len = 0;
|
|
|
|
lf.l_type = F_UNLCK;
|
|
|
|
(void) VOP_ADVLOCK(vp, (caddr_t)td->td_proc->p_leader,
|
|
|
|
F_UNLCK, &lf, F_POSIX);
|
|
|
|
}
|
|
|
|
fdtol = td->td_proc->p_fdtol;
|
|
|
|
if (fdtol != NULL) {
|
|
|
|
/*
|
|
|
|
* Handle special case where file descriptor table
|
|
|
|
* is shared between multiple process leaders.
|
|
|
|
*/
|
|
|
|
fdp = td->td_proc->p_fd;
|
|
|
|
FILEDESC_LOCK(fdp);
|
|
|
|
for (fdtol = fdtol->fdl_next;
|
|
|
|
fdtol != td->td_proc->p_fdtol;
|
|
|
|
fdtol = fdtol->fdl_next) {
|
|
|
|
if ((fdtol->fdl_leader->p_flag &
|
|
|
|
P_ADVLOCK) == 0)
|
|
|
|
continue;
|
|
|
|
fdtol->fdl_holdcount++;
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
lf.l_whence = SEEK_SET;
|
|
|
|
lf.l_start = 0;
|
|
|
|
lf.l_len = 0;
|
|
|
|
lf.l_type = F_UNLCK;
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
2003-06-02 16:05:32 +00:00
|
|
|
(void) VOP_ADVLOCK(vp,
|
|
|
|
(caddr_t)fdtol->fdl_leader,
|
|
|
|
F_UNLCK, &lf, F_POSIX);
|
|
|
|
FILEDESC_LOCK(fdp);
|
|
|
|
fdtol->fdl_holdcount--;
|
|
|
|
if (fdtol->fdl_holdcount == 0 &&
|
|
|
|
fdtol->fdl_wakeup != 0) {
|
|
|
|
fdtol->fdl_wakeup = 0;
|
|
|
|
wakeup(fdtol);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
}
|
2005-01-24 10:19:31 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-09-12 08:38:13 +00:00
|
|
|
return (fdrop(fp, td));
|
This is what was "fdfix2.patch," a fix for fd sharing. It's pretty
far-reaching in fd-land, so you'll want to consult the code for
changes. The biggest change is that now, you don't use
fp->f_ops->fo_foo(fp, bar)
but instead
fo_foo(fp, bar),
which increments and decrements the fp refcount upon entry and exit.
Two new calls, fhold() and fdrop(), are provided. Each does what it
seems like it should, and if fdrop() brings the refcount to zero, the
fd is freed as well.
Thanks to peter ("to hell with it, it looks ok to me.") for his review.
Thanks to msmith for keeping me from putting locks everywhere :)
Reviewed by: peter
1999-09-19 17:00:25 +00:00
|
|
|
}
|
|
|
|
|
2001-11-14 06:30:36 +00:00
|
|
|
/*
|
|
|
|
* Extract the file pointer associated with the specified descriptor for
|
2002-01-14 00:13:45 +00:00
|
|
|
* the current user process.
|
|
|
|
*
|
|
|
|
* If the descriptor doesn't exist, EBADF is returned.
|
|
|
|
*
|
|
|
|
* If the descriptor exists but doesn't match 'flags' then
|
|
|
|
* return EBADF for read attempts and EINVAL for write attempts.
|
2001-11-14 06:30:36 +00:00
|
|
|
*
|
2002-01-14 00:13:45 +00:00
|
|
|
* If 'hold' is set (non-zero) the file's refcount will be bumped on return.
|
2005-03-08 00:58:50 +00:00
|
|
|
* It should be dropped with fdrop().
|
2002-01-14 00:13:45 +00:00
|
|
|
* If it is not set, then the refcount will not be bumped however the
|
|
|
|
* thread's filedesc struct will be returned locked (for fgetsock).
|
|
|
|
*
|
|
|
|
* If an error occured the non-zero error is returned and *fpp is set to NULL.
|
|
|
|
* Otherwise *fpp is set and zero is returned.
|
2001-11-14 06:30:36 +00:00
|
|
|
*/
|
2002-10-16 15:45:37 +00:00
|
|
|
static __inline int
|
2002-01-14 00:13:45 +00:00
|
|
|
_fget(struct thread *td, int fd, struct file **fpp, int flags, int hold)
|
2001-11-14 06:30:36 +00:00
|
|
|
{
|
|
|
|
struct filedesc *fdp;
|
|
|
|
struct file *fp;
|
|
|
|
|
|
|
|
*fpp = NULL;
|
2002-01-14 00:13:45 +00:00
|
|
|
if (td == NULL || (fdp = td->td_proc->p_fd) == NULL)
|
2002-10-16 15:45:37 +00:00
|
|
|
return (EBADF);
|
2002-01-14 00:13:45 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
2002-01-29 22:54:19 +00:00
|
|
|
if ((fp = fget_locked(fdp, fd)) == NULL || fp->f_ops == &badfileops) {
|
2002-01-14 00:13:45 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
2002-10-16 15:45:37 +00:00
|
|
|
return (EBADF);
|
2002-01-14 00:13:45 +00:00
|
|
|
}
|
2001-11-14 06:30:36 +00:00
|
|
|
|
|
|
|
/*
|
2005-03-08 00:58:50 +00:00
|
|
|
* Note: FREAD failure returns EBADF to maintain backwards
|
2001-11-14 06:30:36 +00:00
|
|
|
* compatibility with what routines returned before.
|
|
|
|
*
|
|
|
|
* Only one flag, or 0, may be specified.
|
|
|
|
*/
|
2002-01-14 00:13:45 +00:00
|
|
|
if (flags == FREAD && (fp->f_flag & FREAD) == 0) {
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
2002-10-16 15:45:37 +00:00
|
|
|
return (EBADF);
|
2002-01-14 00:13:45 +00:00
|
|
|
}
|
|
|
|
if (flags == FWRITE && (fp->f_flag & FWRITE) == 0) {
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
2002-10-16 15:45:37 +00:00
|
|
|
return (EINVAL);
|
2002-01-14 00:13:45 +00:00
|
|
|
}
|
|
|
|
if (hold) {
|
|
|
|
fhold(fp);
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
}
|
2001-11-14 06:30:36 +00:00
|
|
|
*fpp = fp;
|
2002-10-16 15:45:37 +00:00
|
|
|
return (0);
|
2001-11-14 06:30:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fget(struct thread *td, int fd, struct file **fpp)
|
|
|
|
{
|
2002-10-16 15:45:37 +00:00
|
|
|
|
|
|
|
return(_fget(td, fd, fpp, 0, 1));
|
2001-11-14 06:30:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fget_read(struct thread *td, int fd, struct file **fpp)
|
|
|
|
{
|
2002-10-16 15:45:37 +00:00
|
|
|
|
|
|
|
return(_fget(td, fd, fpp, FREAD, 1));
|
2001-11-14 06:30:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fget_write(struct thread *td, int fd, struct file **fpp)
|
|
|
|
{
|
2002-10-16 15:45:37 +00:00
|
|
|
|
|
|
|
return(_fget(td, fd, fpp, FWRITE, 1));
|
2001-11-14 06:30:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Like fget() but loads the underlying vnode, or returns an error if
|
|
|
|
* the descriptor does not represent a vnode. Note that pipes use vnodes
|
2005-01-25 00:40:01 +00:00
|
|
|
* but never have VM objects. The returned vnode will be vref()d.
|
2004-12-02 11:56:13 +00:00
|
|
|
*
|
|
|
|
* XXX: what about the unused flags ?
|
2001-11-14 06:30:36 +00:00
|
|
|
*/
|
2002-10-16 15:45:37 +00:00
|
|
|
static __inline int
|
2001-11-14 06:30:36 +00:00
|
|
|
_fgetvp(struct thread *td, int fd, struct vnode **vpp, int flags)
|
|
|
|
{
|
|
|
|
struct file *fp;
|
2002-01-14 00:13:45 +00:00
|
|
|
int error;
|
2001-11-14 06:30:36 +00:00
|
|
|
|
|
|
|
*vpp = NULL;
|
2002-01-14 00:13:45 +00:00
|
|
|
if ((error = _fget(td, fd, &fp, 0, 0)) != 0)
|
|
|
|
return (error);
|
2003-07-04 12:20:27 +00:00
|
|
|
if (fp->f_vnode == NULL) {
|
2002-01-14 00:13:45 +00:00
|
|
|
error = EINVAL;
|
|
|
|
} else {
|
2003-06-22 08:41:43 +00:00
|
|
|
*vpp = fp->f_vnode;
|
2002-01-14 00:13:45 +00:00
|
|
|
vref(*vpp);
|
|
|
|
}
|
|
|
|
FILEDESC_UNLOCK(td->td_proc->p_fd);
|
|
|
|
return (error);
|
2001-11-14 06:30:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fgetvp(struct thread *td, int fd, struct vnode **vpp)
|
|
|
|
{
|
2002-10-16 15:45:37 +00:00
|
|
|
|
|
|
|
return (_fgetvp(td, fd, vpp, 0));
|
2001-11-14 06:30:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fgetvp_read(struct thread *td, int fd, struct vnode **vpp)
|
|
|
|
{
|
2002-10-16 15:45:37 +00:00
|
|
|
|
|
|
|
return (_fgetvp(td, fd, vpp, FREAD));
|
2001-11-14 06:30:36 +00:00
|
|
|
}
|
|
|
|
|
2004-12-02 11:56:13 +00:00
|
|
|
#ifdef notyet
|
2001-11-14 06:30:36 +00:00
|
|
|
int
|
|
|
|
fgetvp_write(struct thread *td, int fd, struct vnode **vpp)
|
|
|
|
{
|
2002-10-16 15:45:37 +00:00
|
|
|
|
|
|
|
return (_fgetvp(td, fd, vpp, FWRITE));
|
2001-11-14 06:30:36 +00:00
|
|
|
}
|
2004-12-02 11:56:13 +00:00
|
|
|
#endif
|
2001-11-14 06:30:36 +00:00
|
|
|
|
2001-11-17 03:07:11 +00:00
|
|
|
/*
|
|
|
|
* Like fget() but loads the underlying socket, or returns an error if
|
|
|
|
* the descriptor does not represent a socket.
|
|
|
|
*
|
2002-10-16 15:45:37 +00:00
|
|
|
* We bump the ref count on the returned socket. XXX Also obtain the SX
|
|
|
|
* lock in the future.
|
2001-11-17 03:07:11 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
fgetsock(struct thread *td, int fd, struct socket **spp, u_int *fflagp)
|
|
|
|
{
|
|
|
|
struct file *fp;
|
2002-01-14 00:13:45 +00:00
|
|
|
int error;
|
2001-11-17 03:07:11 +00:00
|
|
|
|
2004-08-04 18:35:33 +00:00
|
|
|
NET_ASSERT_GIANT();
|
|
|
|
|
2001-11-17 03:07:11 +00:00
|
|
|
*spp = NULL;
|
2002-10-16 15:45:37 +00:00
|
|
|
if (fflagp != NULL)
|
2001-11-17 03:07:11 +00:00
|
|
|
*fflagp = 0;
|
2002-01-14 00:13:45 +00:00
|
|
|
if ((error = _fget(td, fd, &fp, 0, 0)) != 0)
|
|
|
|
return (error);
|
|
|
|
if (fp->f_type != DTYPE_SOCKET) {
|
|
|
|
error = ENOTSOCK;
|
|
|
|
} else {
|
2003-01-13 00:33:17 +00:00
|
|
|
*spp = fp->f_data;
|
2002-01-14 00:13:45 +00:00
|
|
|
if (fflagp)
|
|
|
|
*fflagp = fp->f_flag;
|
2004-06-12 20:47:32 +00:00
|
|
|
SOCK_LOCK(*spp);
|
2002-01-14 00:13:45 +00:00
|
|
|
soref(*spp);
|
2004-06-12 20:47:32 +00:00
|
|
|
SOCK_UNLOCK(*spp);
|
2002-01-14 00:13:45 +00:00
|
|
|
}
|
|
|
|
FILEDESC_UNLOCK(td->td_proc->p_fd);
|
2002-10-16 15:45:37 +00:00
|
|
|
return (error);
|
2001-11-17 03:07:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2005-03-08 00:58:50 +00:00
|
|
|
* Drop the reference count on the socket and XXX release the SX lock in
|
2002-05-31 11:52:35 +00:00
|
|
|
* the future. The last reference closes the socket.
|
2001-11-17 03:07:11 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
fputsock(struct socket *so)
|
|
|
|
{
|
2002-10-16 15:45:37 +00:00
|
|
|
|
2004-03-29 00:33:02 +00:00
|
|
|
NET_ASSERT_GIANT();
|
2004-10-18 22:19:43 +00:00
|
|
|
ACCEPT_LOCK();
|
2004-06-12 20:47:32 +00:00
|
|
|
SOCK_LOCK(so);
|
2001-11-17 03:07:11 +00:00
|
|
|
sorele(so);
|
|
|
|
}
|
|
|
|
|
2004-12-02 11:56:13 +00:00
|
|
|
int
|
|
|
|
fdrop(struct file *fp, struct thread *td)
|
|
|
|
{
|
|
|
|
|
|
|
|
FILE_LOCK(fp);
|
|
|
|
return (fdrop_locked(fp, td));
|
|
|
|
}
|
|
|
|
|
2002-01-13 12:58:14 +00:00
|
|
|
/*
|
|
|
|
* Drop reference on struct file passed in, may call closef if the
|
|
|
|
* reference hits zero.
|
|
|
|
* Expects struct file locked, and will unlock it.
|
|
|
|
*/
|
2005-02-10 12:27:58 +00:00
|
|
|
static int
|
2004-12-02 11:56:13 +00:00
|
|
|
fdrop_locked(struct file *fp, struct thread *td)
|
This is what was "fdfix2.patch," a fix for fd sharing. It's pretty
far-reaching in fd-land, so you'll want to consult the code for
changes. The biggest change is that now, you don't use
fp->f_ops->fo_foo(fp, bar)
but instead
fo_foo(fp, bar),
which increments and decrements the fp refcount upon entry and exit.
Two new calls, fhold() and fdrop(), are provided. Each does what it
seems like it should, and if fdrop() brings the refcount to zero, the
fd is freed as well.
Thanks to peter ("to hell with it, it looks ok to me.") for his review.
Thanks to msmith for keeping me from putting locks everywhere :)
Reviewed by: peter
1999-09-19 17:00:25 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2002-01-13 11:58:06 +00:00
|
|
|
FILE_LOCK_ASSERT(fp, MA_OWNED);
|
|
|
|
|
|
|
|
if (--fp->f_count > 0) {
|
|
|
|
FILE_UNLOCK(fp);
|
This is what was "fdfix2.patch," a fix for fd sharing. It's pretty
far-reaching in fd-land, so you'll want to consult the code for
changes. The biggest change is that now, you don't use
fp->f_ops->fo_foo(fp, bar)
but instead
fo_foo(fp, bar),
which increments and decrements the fp refcount upon entry and exit.
Two new calls, fhold() and fdrop(), are provided. Each does what it
seems like it should, and if fdrop() brings the refcount to zero, the
fd is freed as well.
Thanks to peter ("to hell with it, it looks ok to me.") for his review.
Thanks to msmith for keeping me from putting locks everywhere :)
Reviewed by: peter
1999-09-19 17:00:25 +00:00
|
|
|
return (0);
|
2002-01-13 11:58:06 +00:00
|
|
|
}
|
2003-06-19 18:13:07 +00:00
|
|
|
/* We have the last ref so we can proceed without the file lock. */
|
|
|
|
FILE_UNLOCK(fp);
|
This is what was "fdfix2.patch," a fix for fd sharing. It's pretty
far-reaching in fd-land, so you'll want to consult the code for
changes. The biggest change is that now, you don't use
fp->f_ops->fo_foo(fp, bar)
but instead
fo_foo(fp, bar),
which increments and decrements the fp refcount upon entry and exit.
Two new calls, fhold() and fdrop(), are provided. Each does what it
seems like it should, and if fdrop() brings the refcount to zero, the
fd is freed as well.
Thanks to peter ("to hell with it, it looks ok to me.") for his review.
Thanks to msmith for keeping me from putting locks everywhere :)
Reviewed by: peter
1999-09-19 17:00:25 +00:00
|
|
|
if (fp->f_count < 0)
|
|
|
|
panic("fdrop: count < 0");
|
1999-08-04 18:53:50 +00:00
|
|
|
if (fp->f_ops != &badfileops)
|
2001-09-12 08:38:13 +00:00
|
|
|
error = fo_close(fp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
|
|
|
error = 0;
|
2004-12-02 12:17:27 +00:00
|
|
|
|
|
|
|
sx_xlock(&filelist_lock);
|
|
|
|
LIST_REMOVE(fp, f_list);
|
|
|
|
openfiles--;
|
|
|
|
sx_xunlock(&filelist_lock);
|
|
|
|
crfree(fp->f_cred);
|
|
|
|
uma_zfree(file_zone, fp);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Apply an advisory lock on a file descriptor.
|
|
|
|
*
|
|
|
|
* Just attempt to get a record lock of the requested type on
|
|
|
|
* the entire file (l_whence = SEEK_SET, l_start = 0, l_len = 0).
|
|
|
|
*/
|
1995-11-12 06:43:28 +00:00
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
1994-05-24 10:09:53 +00:00
|
|
|
struct flock_args {
|
|
|
|
int fd;
|
|
|
|
int how;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
2001-09-01 19:04:37 +00:00
|
|
|
/*
|
|
|
|
* MPSAFE
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
/* ARGSUSED */
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
flock(struct thread *td, struct flock_args *uap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-01-14 00:13:45 +00:00
|
|
|
struct file *fp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vnode *vp;
|
|
|
|
struct flock lf;
|
2001-09-01 19:04:37 +00:00
|
|
|
int error;
|
|
|
|
|
2002-01-14 00:13:45 +00:00
|
|
|
if ((error = fget(td, uap->fd, &fp)) != 0)
|
|
|
|
return (error);
|
2001-09-01 19:04:37 +00:00
|
|
|
if (fp->f_type != DTYPE_VNODE) {
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop(fp, td);
|
|
|
|
return (EOPNOTSUPP);
|
2001-09-01 19:04:37 +00:00
|
|
|
}
|
2002-01-13 11:58:06 +00:00
|
|
|
|
|
|
|
mtx_lock(&Giant);
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
1994-05-24 10:09:53 +00:00
|
|
|
lf.l_whence = SEEK_SET;
|
|
|
|
lf.l_start = 0;
|
|
|
|
lf.l_len = 0;
|
|
|
|
if (uap->how & LOCK_UN) {
|
|
|
|
lf.l_type = F_UNLCK;
|
2002-01-13 11:58:06 +00:00
|
|
|
FILE_LOCK(fp);
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->f_flag &= ~FHASLOCK;
|
2002-01-13 11:58:06 +00:00
|
|
|
FILE_UNLOCK(fp);
|
2001-09-01 19:04:37 +00:00
|
|
|
error = VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK);
|
|
|
|
goto done2;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
if (uap->how & LOCK_EX)
|
|
|
|
lf.l_type = F_WRLCK;
|
|
|
|
else if (uap->how & LOCK_SH)
|
|
|
|
lf.l_type = F_RDLCK;
|
2001-09-01 19:04:37 +00:00
|
|
|
else {
|
|
|
|
error = EBADF;
|
|
|
|
goto done2;
|
|
|
|
}
|
2002-01-13 11:58:06 +00:00
|
|
|
FILE_LOCK(fp);
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->f_flag |= FHASLOCK;
|
2002-01-13 11:58:06 +00:00
|
|
|
FILE_UNLOCK(fp);
|
|
|
|
error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf,
|
|
|
|
(uap->how & LOCK_NB) ? F_FLOCK : F_FLOCK | F_WAIT);
|
2001-09-01 19:04:37 +00:00
|
|
|
done2:
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop(fp, td);
|
2001-09-01 19:04:37 +00:00
|
|
|
mtx_unlock(&Giant);
|
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Duplicate the specified descriptor to a free descriptor.
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2004-12-02 11:56:13 +00:00
|
|
|
dupfdopen(struct thread *td, struct filedesc *fdp, int indx, int dfd, int mode, int error)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-01-01 01:05:54 +00:00
|
|
|
struct file *wfp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct file *fp;
|
1995-05-30 08:16:23 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* If the to-be-dup'd fd number is greater than the allowed number
|
|
|
|
* of file descriptors, or the fd to be dup'd has already been
|
2000-11-18 21:01:04 +00:00
|
|
|
* closed, then reject.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_LOCK(fdp);
|
2002-10-16 15:45:37 +00:00
|
|
|
if (dfd < 0 || dfd >= fdp->fd_nfiles ||
|
2000-11-18 21:01:04 +00:00
|
|
|
(wfp = fdp->fd_ofiles[dfd]) == NULL) {
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EBADF);
|
2000-11-18 21:01:04 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* There are two cases of interest here.
|
|
|
|
*
|
|
|
|
* For ENODEV simply dup (dfd) to file descriptor
|
|
|
|
* (indx) and return.
|
|
|
|
*
|
|
|
|
* For ENXIO steal away the file structure from (dfd) and
|
|
|
|
* store it in (indx). (dfd) is effectively closed by
|
|
|
|
* this operation.
|
|
|
|
*
|
|
|
|
* Any other error code is just returned.
|
|
|
|
*/
|
|
|
|
switch (error) {
|
|
|
|
case ENODEV:
|
|
|
|
/*
|
|
|
|
* Check that the mode the file is being opened for is a
|
|
|
|
* subset of the mode of the existing descriptor.
|
|
|
|
*/
|
2002-01-13 11:58:06 +00:00
|
|
|
FILE_LOCK(wfp);
|
|
|
|
if (((mode & (FREAD|FWRITE)) | wfp->f_flag) != wfp->f_flag) {
|
|
|
|
FILE_UNLOCK(wfp);
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EACCES);
|
2002-01-13 11:58:06 +00:00
|
|
|
}
|
2000-11-18 21:01:04 +00:00
|
|
|
fp = fdp->fd_ofiles[indx];
|
1994-05-24 10:09:53 +00:00
|
|
|
fdp->fd_ofiles[indx] = wfp;
|
|
|
|
fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd];
|
2004-01-15 10:15:04 +00:00
|
|
|
if (fp == NULL)
|
|
|
|
fdused(fdp, indx);
|
2002-01-13 11:58:06 +00:00
|
|
|
fhold_locked(wfp);
|
|
|
|
FILE_UNLOCK(wfp);
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
2004-11-16 09:12:03 +00:00
|
|
|
if (fp != NULL) {
|
|
|
|
/*
|
|
|
|
* We now own the reference to fp that the ofiles[]
|
|
|
|
* array used to own. Release it.
|
|
|
|
*/
|
|
|
|
FILE_LOCK(fp);
|
2002-01-13 11:58:06 +00:00
|
|
|
fdrop_locked(fp, td);
|
2004-11-16 09:12:03 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
case ENXIO:
|
|
|
|
/*
|
2002-10-16 15:45:37 +00:00
|
|
|
* Steal away the file pointer from dfd and stuff it into indx.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2000-11-18 21:01:04 +00:00
|
|
|
fp = fdp->fd_ofiles[indx];
|
1994-05-24 10:09:53 +00:00
|
|
|
fdp->fd_ofiles[indx] = fdp->fd_ofiles[dfd];
|
|
|
|
fdp->fd_ofiles[dfd] = NULL;
|
|
|
|
fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd];
|
|
|
|
fdp->fd_ofileflags[dfd] = 0;
|
2004-01-15 10:15:04 +00:00
|
|
|
fdunused(fdp, dfd);
|
|
|
|
if (fp == NULL)
|
|
|
|
fdused(fdp, indx);
|
2002-01-13 11:58:06 +00:00
|
|
|
if (fp != NULL)
|
|
|
|
FILE_LOCK(fp);
|
|
|
|
|
|
|
|
/*
|
2005-03-08 00:58:50 +00:00
|
|
|
* We now own the reference to fp that the ofiles[] array
|
2002-01-13 11:58:06 +00:00
|
|
|
* used to own. Release it.
|
|
|
|
*/
|
|
|
|
if (fp != NULL)
|
|
|
|
fdrop_locked(fp, td);
|
2005-10-04 16:27:54 +00:00
|
|
|
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
default:
|
2002-01-13 11:58:06 +00:00
|
|
|
FILEDESC_UNLOCK(fdp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
1995-11-14 08:58:35 +00:00
|
|
|
|
2004-12-14 08:23:18 +00:00
|
|
|
/*
|
|
|
|
* Scan all active processes to see if any of them have a current
|
|
|
|
* or root directory of `olddp'. If so, replace them with the new
|
|
|
|
* mount point.
|
|
|
|
*/
|
|
|
|
void
|
2004-12-14 09:09:51 +00:00
|
|
|
mountcheckdirs(struct vnode *olddp, struct vnode *newdp)
|
2004-12-14 08:23:18 +00:00
|
|
|
{
|
|
|
|
struct filedesc *fdp;
|
|
|
|
struct proc *p;
|
|
|
|
int nrele;
|
|
|
|
|
|
|
|
if (vrefcnt(olddp) == 1)
|
|
|
|
return;
|
|
|
|
sx_slock(&allproc_lock);
|
|
|
|
LIST_FOREACH(p, &allproc, p_list) {
|
2004-12-14 09:09:51 +00:00
|
|
|
fdp = fdhold(p);
|
|
|
|
if (fdp == NULL)
|
2004-12-14 08:23:18 +00:00
|
|
|
continue;
|
|
|
|
nrele = 0;
|
|
|
|
FILEDESC_LOCK_FAST(fdp);
|
|
|
|
if (fdp->fd_cdir == olddp) {
|
|
|
|
vref(newdp);
|
|
|
|
fdp->fd_cdir = newdp;
|
|
|
|
nrele++;
|
|
|
|
}
|
|
|
|
if (fdp->fd_rdir == olddp) {
|
|
|
|
vref(newdp);
|
|
|
|
fdp->fd_rdir = newdp;
|
|
|
|
nrele++;
|
|
|
|
}
|
|
|
|
FILEDESC_UNLOCK_FAST(fdp);
|
2004-12-14 20:48:40 +00:00
|
|
|
fddrop(fdp);
|
2004-12-14 08:23:18 +00:00
|
|
|
while (nrele--)
|
|
|
|
vrele(olddp);
|
|
|
|
}
|
|
|
|
sx_sunlock(&allproc_lock);
|
|
|
|
if (rootvnode == olddp) {
|
|
|
|
vrele(rootvnode);
|
|
|
|
vref(newdp);
|
|
|
|
rootvnode = newdp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-06-02 16:05:32 +00:00
|
|
|
struct filedesc_to_leader *
|
2004-12-02 11:56:13 +00:00
|
|
|
filedesc_to_leader_alloc(struct filedesc_to_leader *old, struct filedesc *fdp, struct proc *leader)
|
2003-06-02 16:05:32 +00:00
|
|
|
{
|
|
|
|
struct filedesc_to_leader *fdtol;
|
2004-01-11 19:39:14 +00:00
|
|
|
|
2003-06-02 16:05:32 +00:00
|
|
|
MALLOC(fdtol, struct filedesc_to_leader *,
|
|
|
|
sizeof(struct filedesc_to_leader),
|
|
|
|
M_FILEDESC_TO_LEADER,
|
|
|
|
M_WAITOK);
|
|
|
|
fdtol->fdl_refcount = 1;
|
|
|
|
fdtol->fdl_holdcount = 0;
|
|
|
|
fdtol->fdl_wakeup = 0;
|
|
|
|
fdtol->fdl_leader = leader;
|
|
|
|
if (old != NULL) {
|
|
|
|
FILEDESC_LOCK(fdp);
|
|
|
|
fdtol->fdl_next = old->fdl_next;
|
|
|
|
fdtol->fdl_prev = old;
|
|
|
|
old->fdl_next = fdtol;
|
|
|
|
fdtol->fdl_next->fdl_prev = fdtol;
|
|
|
|
FILEDESC_UNLOCK(fdp);
|
|
|
|
} else {
|
|
|
|
fdtol->fdl_next = fdtol;
|
|
|
|
fdtol->fdl_prev = fdtol;
|
|
|
|
}
|
2004-01-15 10:15:04 +00:00
|
|
|
return (fdtol);
|
2003-06-02 16:05:32 +00:00
|
|
|
}
|
|
|
|
|
1995-11-14 08:58:35 +00:00
|
|
|
/*
|
|
|
|
* Get file structures.
|
|
|
|
*/
|
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_kern_file(SYSCTL_HANDLER_ARGS)
|
1995-11-14 08:58:35 +00:00
|
|
|
{
|
2002-10-16 15:45:37 +00:00
|
|
|
struct xfile xf;
|
2002-07-31 12:26:52 +00:00
|
|
|
struct filedesc *fdp;
|
1995-11-14 08:58:35 +00:00
|
|
|
struct file *fp;
|
2002-10-16 15:45:37 +00:00
|
|
|
struct proc *p;
|
2002-07-31 12:26:52 +00:00
|
|
|
int error, n;
|
1995-11-14 08:58:35 +00:00
|
|
|
|
2003-07-28 16:03:53 +00:00
|
|
|
/*
|
|
|
|
* Note: because the number of file descriptors is calculated
|
|
|
|
* in different ways for sizing vs returning the data,
|
|
|
|
* there is information leakage from the first loop. However,
|
|
|
|
* it is of a similar order of magnitude to the leakage from
|
|
|
|
* global system statistics such as kern.openfiles.
|
|
|
|
*/
|
2004-02-26 00:27:04 +00:00
|
|
|
error = sysctl_wire_old_buffer(req, 0);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
2002-10-16 15:45:37 +00:00
|
|
|
if (req->oldptr == NULL) {
|
|
|
|
n = 16; /* A slight overestimate. */
|
2002-07-31 12:26:52 +00:00
|
|
|
sx_slock(&filelist_lock);
|
|
|
|
LIST_FOREACH(fp, &filehead, f_list) {
|
|
|
|
/*
|
|
|
|
* We should grab the lock, but this is an
|
|
|
|
* estimate, so does it really matter?
|
|
|
|
*/
|
|
|
|
/* mtx_lock(fp->f_mtxp); */
|
|
|
|
n += fp->f_count;
|
|
|
|
/* mtx_unlock(f->f_mtxp); */
|
|
|
|
}
|
2002-01-13 11:58:06 +00:00
|
|
|
sx_sunlock(&filelist_lock);
|
2002-10-16 15:45:37 +00:00
|
|
|
return (SYSCTL_OUT(req, 0, n * sizeof(xf)));
|
2002-01-13 11:58:06 +00:00
|
|
|
}
|
2002-07-31 12:26:52 +00:00
|
|
|
error = 0;
|
2002-10-16 15:45:37 +00:00
|
|
|
bzero(&xf, sizeof(xf));
|
|
|
|
xf.xf_size = sizeof(xf);
|
2002-07-31 12:26:52 +00:00
|
|
|
sx_slock(&allproc_lock);
|
|
|
|
LIST_FOREACH(p, &allproc, p_list) {
|
2004-10-04 06:45:48 +00:00
|
|
|
if (p->p_state == PRS_NEW)
|
|
|
|
continue;
|
2002-07-31 12:26:52 +00:00
|
|
|
PROC_LOCK(p);
|
2003-07-28 16:03:53 +00:00
|
|
|
if (p_cansee(req->td, p) != 0) {
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
continue;
|
|
|
|
}
|
2002-07-31 12:26:52 +00:00
|
|
|
xf.xf_pid = p->p_pid;
|
|
|
|
xf.xf_uid = p->p_ucred->cr_uid;
|
2003-02-11 07:20:52 +00:00
|
|
|
PROC_UNLOCK(p);
|
2004-12-14 09:09:51 +00:00
|
|
|
fdp = fdhold(p);
|
|
|
|
if (fdp == NULL)
|
2002-07-31 12:26:52 +00:00
|
|
|
continue;
|
2004-11-26 06:14:04 +00:00
|
|
|
FILEDESC_LOCK_FAST(fdp);
|
2004-12-14 20:48:40 +00:00
|
|
|
for (n = 0; fdp->fd_refcnt > 0 && n < fdp->fd_nfiles; ++n) {
|
2002-07-31 12:26:52 +00:00
|
|
|
if ((fp = fdp->fd_ofiles[n]) == NULL)
|
|
|
|
continue;
|
|
|
|
xf.xf_fd = n;
|
|
|
|
xf.xf_file = fp;
|
2003-01-13 00:33:17 +00:00
|
|
|
xf.xf_data = fp->f_data;
|
2004-06-19 11:40:08 +00:00
|
|
|
xf.xf_vnode = fp->f_vnode;
|
2003-01-13 00:33:17 +00:00
|
|
|
xf.xf_type = fp->f_type;
|
|
|
|
xf.xf_count = fp->f_count;
|
|
|
|
xf.xf_msgcount = fp->f_msgcount;
|
|
|
|
xf.xf_offset = fp->f_offset;
|
|
|
|
xf.xf_flag = fp->f_flag;
|
2002-10-16 15:45:37 +00:00
|
|
|
error = SYSCTL_OUT(req, &xf, sizeof(xf));
|
2002-07-31 12:26:52 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
2002-01-13 11:58:06 +00:00
|
|
|
}
|
2004-11-26 06:14:04 +00:00
|
|
|
FILEDESC_UNLOCK_FAST(fdp);
|
2004-12-14 09:09:51 +00:00
|
|
|
fddrop(fdp);
|
2002-07-31 12:26:52 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
1995-11-14 08:58:35 +00:00
|
|
|
}
|
2002-07-31 12:26:52 +00:00
|
|
|
sx_sunlock(&allproc_lock);
|
|
|
|
return (error);
|
1995-11-14 08:58:35 +00:00
|
|
|
}
|
1995-12-04 16:48:58 +00:00
|
|
|
|
|
|
|
SYSCTL_PROC(_kern, KERN_FILE, file, CTLTYPE_OPAQUE|CTLFLAG_RD,
|
2002-07-31 12:26:52 +00:00
|
|
|
0, 0, sysctl_kern_file, "S,xfile", "Entire file table");
|
1995-12-04 16:48:58 +00:00
|
|
|
|
2005-11-10 10:42:50 +00:00
|
|
|
#ifdef DDB
|
|
|
|
/*
|
|
|
|
* For the purposes of debugging, generate a human-readable string for the
|
|
|
|
* file type.
|
|
|
|
*/
|
|
|
|
static const char *
|
|
|
|
file_type_to_name(short type)
|
|
|
|
{
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case 0:
|
|
|
|
return ("zero");
|
|
|
|
case DTYPE_VNODE:
|
|
|
|
return ("vnod");
|
|
|
|
case DTYPE_SOCKET:
|
|
|
|
return ("sock");
|
|
|
|
case DTYPE_PIPE:
|
|
|
|
return ("pipe");
|
|
|
|
case DTYPE_FIFO:
|
|
|
|
return ("fifo");
|
|
|
|
case DTYPE_CRYPTO:
|
|
|
|
return ("crpt");
|
|
|
|
default:
|
|
|
|
return ("unkn");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For the purposes of debugging, identify a process (if any, perhaps one of
|
|
|
|
* many) that references the passed file in its file descriptor array. Return
|
|
|
|
* NULL if none.
|
|
|
|
*/
|
|
|
|
static struct proc *
|
|
|
|
file_to_first_proc(struct file *fp)
|
|
|
|
{
|
|
|
|
struct filedesc *fdp;
|
|
|
|
struct proc *p;
|
|
|
|
int n;
|
|
|
|
|
|
|
|
LIST_FOREACH(p, &allproc, p_list) {
|
|
|
|
if (p->p_state == PRS_NEW)
|
|
|
|
continue;
|
|
|
|
fdp = p->p_fd;
|
|
|
|
if (fdp == NULL)
|
|
|
|
continue;
|
|
|
|
for (n = 0; n < fdp->fd_nfiles; n++) {
|
|
|
|
if (fp == fdp->fd_ofiles[n])
|
|
|
|
return (p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
DB_SHOW_COMMAND(files, db_show_files)
|
|
|
|
{
|
|
|
|
struct file *fp;
|
|
|
|
struct proc *p;
|
|
|
|
|
2005-11-10 13:26:29 +00:00
|
|
|
db_printf("%8s %4s %8s %8s %4s %5s %6s %8s %5s %12s\n", "File",
|
|
|
|
"Type", "Data", "Flag", "GCFl", "Count", "MCount", "Vnode",
|
|
|
|
"FPID", "FCmd");
|
2005-11-10 10:42:50 +00:00
|
|
|
LIST_FOREACH(fp, &filehead, f_list) {
|
|
|
|
p = file_to_first_proc(fp);
|
2005-11-10 13:26:29 +00:00
|
|
|
db_printf("%8p %4s %8p %08x %04x %5d %6d %8p %5d %12s\n", fp,
|
2005-11-10 10:42:50 +00:00
|
|
|
file_type_to_name(fp->f_type), fp->f_data, fp->f_flag,
|
2005-11-10 13:26:29 +00:00
|
|
|
fp->f_gcflag, fp->f_count, fp->f_msgcount, fp->f_vnode,
|
2005-11-10 11:35:59 +00:00
|
|
|
p != NULL ? p->p_pid : -1, p != NULL ? p->p_comm : "-");
|
2005-11-10 10:42:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-01-11 19:39:14 +00:00
|
|
|
SYSCTL_INT(_kern, KERN_MAXFILESPERPROC, maxfilesperproc, CTLFLAG_RW,
|
1999-05-03 23:57:32 +00:00
|
|
|
&maxfilesperproc, 0, "Maximum files allowed open per process");
|
1995-12-04 16:48:58 +00:00
|
|
|
|
2004-01-11 19:39:14 +00:00
|
|
|
SYSCTL_INT(_kern, KERN_MAXFILES, maxfiles, CTLFLAG_RW,
|
1999-05-03 23:57:32 +00:00
|
|
|
&maxfiles, 0, "Maximum number of files");
|
1995-12-04 16:48:58 +00:00
|
|
|
|
2004-01-11 19:39:14 +00:00
|
|
|
SYSCTL_INT(_kern, OID_AUTO, openfiles, CTLFLAG_RD,
|
2004-12-01 09:22:26 +00:00
|
|
|
&openfiles, 0, "System-wide number of open files");
|
2000-08-26 23:49:44 +00:00
|
|
|
|
2004-12-01 09:42:35 +00:00
|
|
|
/* ARGSUSED*/
|
|
|
|
static void
|
|
|
|
filelistinit(void *dummy)
|
|
|
|
{
|
2002-12-23 21:53:20 +00:00
|
|
|
|
2004-12-01 09:42:35 +00:00
|
|
|
file_zone = uma_zcreate("Files", sizeof(struct file), NULL, NULL,
|
|
|
|
NULL, NULL, UMA_ALIGN_PTR, 0);
|
|
|
|
sx_init(&filelist_lock, "filelist lock");
|
|
|
|
mtx_init(&sigio_lock, "sigio lock", NULL, MTX_DEF);
|
|
|
|
mtx_init(&fdesc_mtx, "fdesc", NULL, MTX_DEF);
|
|
|
|
}
|
|
|
|
SYSINIT(select, SI_SUB_LOCK, SI_ORDER_FIRST, filelistinit, NULL)
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------*/
|
1999-08-04 18:53:50 +00:00
|
|
|
|
|
|
|
static int
|
2004-12-01 09:42:35 +00:00
|
|
|
badfo_readwrite(struct file *fp, struct uio *uio, struct ucred *active_cred, int flags, struct thread *td)
|
1999-08-04 18:53:50 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (EBADF);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2004-12-01 09:42:35 +00:00
|
|
|
badfo_ioctl(struct file *fp, u_long com, void *data, struct ucred *active_cred, struct thread *td)
|
1999-08-04 18:53:50 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (EBADF);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2004-12-01 09:42:35 +00:00
|
|
|
badfo_poll(struct file *fp, int events, struct ucred *active_cred, struct thread *td)
|
1999-08-04 18:53:50 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2001-02-15 16:34:11 +00:00
|
|
|
static int
|
2004-12-01 09:42:35 +00:00
|
|
|
badfo_kqfilter(struct file *fp, struct knote *kn)
|
2001-02-15 16:34:11 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1999-11-08 03:27:14 +00:00
|
|
|
static int
|
2004-12-01 09:42:35 +00:00
|
|
|
badfo_stat(struct file *fp, struct stat *sb, struct ucred *active_cred, struct thread *td)
|
1999-11-08 03:27:14 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (EBADF);
|
|
|
|
}
|
|
|
|
|
1999-08-04 18:53:50 +00:00
|
|
|
static int
|
2004-12-01 09:42:35 +00:00
|
|
|
badfo_close(struct file *fp, struct thread *td)
|
1999-08-04 18:53:50 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (EBADF);
|
|
|
|
}
|
|
|
|
|
2004-12-01 09:42:35 +00:00
|
|
|
struct fileops badfileops = {
|
|
|
|
.fo_read = badfo_readwrite,
|
|
|
|
.fo_write = badfo_readwrite,
|
|
|
|
.fo_ioctl = badfo_ioctl,
|
|
|
|
.fo_poll = badfo_poll,
|
|
|
|
.fo_kqfilter = badfo_kqfilter,
|
|
|
|
.fo_stat = badfo_stat,
|
|
|
|
.fo_close = badfo_close,
|
|
|
|
};
|
2002-10-16 15:45:37 +00:00
|
|
|
|
2004-12-01 09:29:31 +00:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* File Descriptor pseudo-device driver (/dev/fd/).
|
|
|
|
*
|
|
|
|
* Opening minor device N dup()s the file (if any) connected to file
|
|
|
|
* descriptor N belonging to the calling process. Note that this driver
|
|
|
|
* consists of only the ``open()'' routine, because all subsequent
|
|
|
|
* references to this file will be direct to the other driver.
|
|
|
|
*
|
|
|
|
* XXX: we could give this one a cloning event handler if necessary.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* ARGSUSED */
|
|
|
|
static int
|
|
|
|
fdopen(struct cdev *dev, int mode, int type, struct thread *td)
|
|
|
|
{
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX Kludge: set curthread->td_dupfd to contain the value of the
|
|
|
|
* the file descriptor being sought for duplication. The error
|
|
|
|
* return ensures that the vnode for this device will be released
|
|
|
|
* by vn_open. Open will detect this special error and take the
|
|
|
|
* actions in dupfdopen below. Other callers of vn_open or VOP_OPEN
|
|
|
|
* will simply report the error.
|
|
|
|
*/
|
|
|
|
td->td_dupfd = dev2unit(dev);
|
|
|
|
return (ENODEV);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct cdevsw fildesc_cdevsw = {
|
|
|
|
.d_version = D_VERSION,
|
|
|
|
.d_flags = D_NEEDGIANT,
|
|
|
|
.d_open = fdopen,
|
|
|
|
.d_name = "FD",
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
fildesc_drvinit(void *unused)
|
|
|
|
{
|
|
|
|
struct cdev *dev;
|
|
|
|
|
|
|
|
dev = make_dev(&fildesc_cdevsw, 0, UID_ROOT, GID_WHEEL, 0666, "fd/0");
|
|
|
|
make_dev_alias(dev, "stdin");
|
|
|
|
dev = make_dev(&fildesc_cdevsw, 1, UID_ROOT, GID_WHEEL, 0666, "fd/1");
|
|
|
|
make_dev_alias(dev, "stdout");
|
|
|
|
dev = make_dev(&fildesc_cdevsw, 2, UID_ROOT, GID_WHEEL, 0666, "fd/2");
|
|
|
|
make_dev_alias(dev, "stderr");
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSINIT(fildescdev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, fildesc_drvinit, NULL)
|