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"
|
2008-02-23 01:01:49 +00:00
|
|
|
#include "opt_ktrace.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>
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
#include <sys/domain.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>
|
2005-11-30 05:12:03 +00:00
|
|
|
#include <sys/mqueue.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>
|
2006-11-06 13:42:10 +00:00
|
|
|
#include <sys/priv.h>
|
2004-12-03 21:29:25 +00:00
|
|
|
#include <sys/proc.h>
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
#include <sys/protosw.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>
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
#include <sys/tty.h>
|
2004-12-03 21:29:25 +00:00
|
|
|
#include <sys/unistd.h>
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
#include <sys/user.h>
|
2004-12-03 21:29:25 +00:00
|
|
|
#include <sys/vnode.h>
|
2008-02-23 01:01:49 +00:00
|
|
|
#ifdef KTRACE
|
|
|
|
#include <sys/ktrace.h>
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2006-02-05 23:57:32 +00:00
|
|
|
#include <security/audit/audit.h>
|
|
|
|
|
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
|
|
|
|
2008-05-28 20:25:19 +00:00
|
|
|
/* Flags for do_dup() */
|
|
|
|
#define DUP_FIXED 0x1 /* Force fixed allocation */
|
|
|
|
#define DUP_FCNTL 0x2 /* fcntl()-style errors */
|
- 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
|
|
|
|
2008-05-28 20:25:19 +00:00
|
|
|
static int do_dup(struct thread *td, int flags, int old, int 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
|
|
|
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);
|
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.
|
|
|
|
*/
|
2007-12-30 01:42:15 +00:00
|
|
|
volatile int openfiles; /* actual number of open files */
|
2002-05-01 20:44:46 +00:00
|
|
|
struct mtx sigio_lock; /* mtx to protect pointers to sigio */
|
2005-11-30 05:12:03 +00:00
|
|
|
void (*mq_fdclose)(struct thread *td, int fd, struct file *fp);
|
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);
|
2006-03-20 00:13:47 +00:00
|
|
|
return (low - 1);
|
2004-01-15 10:15:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
|
|
|
|
FILEDESC_XLOCK_ASSERT(fdp);
|
2004-01-15 10:15:04 +00:00
|
|
|
KASSERT(!fdisused(fdp, fd),
|
|
|
|
("fd already used"));
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
|
2004-01-15 10:15:04 +00:00
|
|
|
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)
|
|
|
|
{
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
|
|
|
|
FILEDESC_XLOCK_ASSERT(fdp);
|
2004-01-15 10:15:04 +00:00
|
|
|
KASSERT(fdisused(fdp, fd),
|
|
|
|
("fd is already unused"));
|
|
|
|
KASSERT(fdp->fd_ofiles[fd] == NULL,
|
|
|
|
("fd is still in use"));
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
|
2004-01-15 10:15:04 +00:00
|
|
|
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
|
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
|
|
|
*
|
2007-03-05 13:10:58 +00:00
|
|
|
* Note: keep in mind that a potential race condition exists when closing
|
2000-11-18 21:01:04 +00:00
|
|
|
* 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
|
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
|
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
|
|
|
{
|
|
|
|
|
2008-05-28 20:25:19 +00:00
|
|
|
return (do_dup(td, 0, (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
|
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;
|
2008-03-26 15:23:12 +00:00
|
|
|
struct oflock ofl;
|
2002-09-02 22:24:14 +00:00
|
|
|
intptr_t arg;
|
|
|
|
int error;
|
2008-03-26 15:23:12 +00:00
|
|
|
int cmd;
|
2002-09-02 22:24:14 +00:00
|
|
|
|
|
|
|
error = 0;
|
2008-03-26 15:23:12 +00:00
|
|
|
cmd = uap->cmd;
|
2002-09-02 22:24:14 +00:00
|
|
|
switch (uap->cmd) {
|
2008-03-26 15:23:12 +00:00
|
|
|
case F_OGETLK:
|
|
|
|
case F_OSETLK:
|
|
|
|
case F_OSETLKW:
|
|
|
|
/*
|
|
|
|
* Convert old flock structure to new.
|
|
|
|
*/
|
|
|
|
error = copyin((void *)(intptr_t)uap->arg, &ofl, sizeof(ofl));
|
|
|
|
fl.l_start = ofl.l_start;
|
|
|
|
fl.l_len = ofl.l_len;
|
|
|
|
fl.l_pid = ofl.l_pid;
|
|
|
|
fl.l_type = ofl.l_type;
|
|
|
|
fl.l_whence = ofl.l_whence;
|
|
|
|
fl.l_sysid = 0;
|
|
|
|
|
|
|
|
switch (uap->cmd) {
|
|
|
|
case F_OGETLK:
|
|
|
|
cmd = F_GETLK;
|
|
|
|
break;
|
|
|
|
case F_OSETLK:
|
|
|
|
cmd = F_SETLK;
|
|
|
|
break;
|
|
|
|
case F_OSETLKW:
|
|
|
|
cmd = F_SETLKW;
|
|
|
|
break;
|
|
|
|
}
|
2002-09-02 22:24:14 +00:00
|
|
|
arg = (intptr_t)&fl;
|
|
|
|
break;
|
2008-03-26 15:23:12 +00:00
|
|
|
case F_GETLK:
|
|
|
|
case F_SETLK:
|
|
|
|
case F_SETLKW:
|
|
|
|
case F_SETLK_REMOTE:
|
|
|
|
error = copyin((void *)(intptr_t)uap->arg, &fl, sizeof(fl));
|
|
|
|
arg = (intptr_t)&fl;
|
|
|
|
break;
|
2002-09-02 22:24:14 +00:00
|
|
|
default:
|
|
|
|
arg = uap->arg;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (error)
|
|
|
|
return (error);
|
2008-03-26 15:23:12 +00:00
|
|
|
error = kern_fcntl(td, uap->fd, cmd, arg);
|
2002-09-02 22:24:14 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2008-03-26 15:23:12 +00:00
|
|
|
if (uap->cmd == F_OGETLK) {
|
|
|
|
ofl.l_start = fl.l_start;
|
|
|
|
ofl.l_len = fl.l_len;
|
|
|
|
ofl.l_pid = fl.l_pid;
|
|
|
|
ofl.l_type = fl.l_type;
|
|
|
|
ofl.l_whence = fl.l_whence;
|
|
|
|
error = copyout(&ofl, (void *)(intptr_t)uap->arg, sizeof(ofl));
|
|
|
|
} else if (uap->cmd == F_GETLK) {
|
2002-10-16 15:45:37 +00:00
|
|
|
error = copyout(&fl, (void *)(intptr_t)uap->arg, sizeof(fl));
|
2008-03-26 15:23:12 +00:00
|
|
|
}
|
2002-09-02 22:24:14 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2007-07-03 21:26:06 +00:00
|
|
|
static inline struct file *
|
|
|
|
fdtofp(int fd, struct filedesc *fdp)
|
|
|
|
{
|
|
|
|
struct file *fp;
|
|
|
|
|
|
|
|
FILEDESC_LOCK_ASSERT(fdp);
|
|
|
|
if ((unsigned)fd >= fdp->fd_nfiles ||
|
|
|
|
(fp = fdp->fd_ofiles[fd]) == NULL)
|
|
|
|
return (NULL);
|
|
|
|
return (fp);
|
|
|
|
}
|
|
|
|
|
2002-09-02 22:24:14 +00:00
|
|
|
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;
|
2002-10-16 15:45:37 +00:00
|
|
|
int error, flg, tmp;
|
2007-07-03 21:26:06 +00:00
|
|
|
int vfslocked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2007-07-03 21:26:06 +00:00
|
|
|
vfslocked = 0;
|
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;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
|
2002-09-02 22:24:14 +00:00
|
|
|
switch (cmd) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case F_DUPFD:
|
2008-05-28 20:25:19 +00:00
|
|
|
tmp = arg;
|
|
|
|
error = do_dup(td, DUP_FCNTL, fd, tmp, td->td_retval);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2008-03-08 22:02:21 +00:00
|
|
|
case F_DUP2FD:
|
|
|
|
tmp = arg;
|
|
|
|
error = do_dup(td, DUP_FIXED, fd, tmp, td->td_retval);
|
|
|
|
break;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
case F_GETFD:
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SLOCK(fdp);
|
|
|
|
if ((fp = fdtofp(fd, fdp)) == NULL) {
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pop = &fdp->fd_ofileflags[fd];
|
2002-04-13 10:16:53 +00:00
|
|
|
td->td_retval[0] = (*pop & UF_EXCLOSE) ? FD_CLOEXEC : 0;
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case F_SETFD:
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
|
|
|
if ((fp = fdtofp(fd, fdp)) == NULL) {
|
|
|
|
FILEDESC_XUNLOCK(fdp);
|
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pop = &fdp->fd_ofileflags[fd];
|
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);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case F_GETFL:
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SLOCK(fdp);
|
|
|
|
if ((fp = fdtofp(fd, fdp)) == NULL) {
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_retval[0] = OFLAGS(fp->f_flag);
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(fdp);
|
2001-09-01 19:04:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case F_SETFL:
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SLOCK(fdp);
|
|
|
|
if ((fp = fdtofp(fd, fdp)) == NULL) {
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
2007-12-30 01:42:15 +00:00
|
|
|
fhold(fp);
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(fdp);
|
2007-12-30 01:42:15 +00:00
|
|
|
do {
|
|
|
|
tmp = flg = fp->f_flag;
|
|
|
|
tmp &= ~FCNTLFLAGS;
|
|
|
|
tmp |= FFLAGS(arg & ~O_ACCMODE) & FCNTLFLAGS;
|
|
|
|
} while(atomic_cmpset_int(&fp->f_flag, flg, tmp) == 0);
|
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
|
|
|
}
|
2007-12-30 01:42:15 +00:00
|
|
|
atomic_clear_int(&fp->f_flag, FNONBLOCK);
|
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:
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SLOCK(fdp);
|
|
|
|
if ((fp = fdtofp(fd, fdp)) == NULL) {
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
2000-11-18 21:01:04 +00:00
|
|
|
fhold(fp);
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(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:
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SLOCK(fdp);
|
|
|
|
if ((fp = fdtofp(fd, fdp)) == NULL) {
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
2000-11-18 21:01:04 +00:00
|
|
|
fhold(fp);
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(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
|
|
|
|
2008-03-26 15:23:12 +00:00
|
|
|
case F_SETLK_REMOTE:
|
|
|
|
error = priv_check(td, PRIV_NFS_LOCKD);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
flg = F_REMOTE;
|
|
|
|
goto do_setlk;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
case F_SETLKW:
|
|
|
|
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:
|
2008-03-26 15:23:12 +00:00
|
|
|
do_setlk:
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SLOCK(fdp);
|
|
|
|
if ((fp = fdtofp(fd, fdp)) == NULL) {
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
2001-09-01 19:04:37 +00:00
|
|
|
if (fp->f_type != DTYPE_VNODE) {
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(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_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)) {
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(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);
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(fdp);
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
2007-07-03 21:26:06 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
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,
|
2008-03-26 15:23:12 +00:00
|
|
|
flp, flg);
|
|
|
|
break;
|
|
|
|
case F_UNLCKSYS:
|
|
|
|
/*
|
|
|
|
* Temporary api for testing remote lock
|
|
|
|
* infrastructure.
|
|
|
|
*/
|
|
|
|
if (flg != F_REMOTE) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader,
|
|
|
|
F_UNLCKSYS, flp, flg);
|
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
|
|
|
}
|
2007-07-03 21:26:06 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
vfslocked = 0;
|
2003-02-15 22:43:05 +00:00
|
|
|
/* Check for race with close */
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SLOCK(fdp);
|
2003-02-15 22:43:05 +00:00
|
|
|
if ((unsigned) fd >= fdp->fd_nfiles ||
|
|
|
|
fp != fdp->fd_ofiles[fd]) {
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(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;
|
2007-07-03 21:26:06 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2003-02-15 22:43:05 +00:00
|
|
|
(void) VOP_ADVLOCK(vp, (caddr_t)p->p_leader,
|
|
|
|
F_UNLCK, flp, F_POSIX);
|
2007-07-03 21:26:06 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
vfslocked = 0;
|
2003-02-15 22:43:05 +00:00
|
|
|
} else
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(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:
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SLOCK(fdp);
|
|
|
|
if ((fp = fdtofp(fd, fdp)) == NULL) {
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
error = EBADF;
|
|
|
|
break;
|
|
|
|
}
|
2001-09-01 19:04:37 +00:00
|
|
|
if (fp->f_type != DTYPE_VNODE) {
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(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) {
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(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)) {
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(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);
|
2007-07-03 21:26:06 +00:00
|
|
|
FILEDESC_SUNLOCK(fdp);
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
2007-07-03 21:26:06 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2002-09-02 22:24:14 +00:00
|
|
|
error = VOP_ADVLOCK(vp, (caddr_t)p->p_leader, F_GETLK, flp,
|
|
|
|
F_POSIX);
|
2007-07-03 21:26:06 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
vfslocked = 0;
|
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:
|
2001-09-01 19:04:37 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2007-07-03 21:26:06 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2001-09-01 19:04:37 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-03-08 22:02:21 +00:00
|
|
|
* Common code for dup, dup2, fcntl(F_DUPFD) and fcntl(F_DUP2FD).
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-12-14 08:32:45 +00:00
|
|
|
static int
|
2008-05-28 20:25:19 +00:00
|
|
|
do_dup(struct thread *td, int flags, int old, int new,
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
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;
|
|
|
|
|
- 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
|
2008-05-28 20:25:19 +00:00
|
|
|
* dup to. Unlike dup() and dup2(), fcntl()'s F_DUPFD should
|
|
|
|
* return EINVAL when the new descriptor is out of bounds.
|
- 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
|
|
|
*/
|
2008-05-28 20:25:19 +00:00
|
|
|
if (old < 0)
|
2002-11-26 17:22:15 +00:00
|
|
|
return (EBADF);
|
2008-05-28 20:25:19 +00:00
|
|
|
if (new < 0)
|
|
|
|
return (flags & DUP_FCNTL ? EINVAL : 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)
|
2008-05-28 20:25:19 +00:00
|
|
|
return (flags & DUP_FCNTL ? EINVAL : EMFILE);
|
2004-01-15 10:15:04 +00:00
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2002-11-26 17:22:15 +00:00
|
|
|
if (old >= fdp->fd_nfiles || fdp->fd_ofiles[old] == NULL) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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
|
|
|
return (EBADF);
|
|
|
|
}
|
2008-05-28 20:25:19 +00:00
|
|
|
if (flags & DUP_FIXED && old == 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;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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
|
|
|
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
|
|
|
*/
|
2008-05-28 20:25:19 +00:00
|
|
|
if (flags & DUP_FIXED) {
|
2004-01-15 10:15:04 +00:00
|
|
|
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) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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.
|
|
|
|
*/
|
2007-05-31 11:51:53 +00:00
|
|
|
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);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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
|
|
|
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);
|
2005-11-30 05:12:03 +00:00
|
|
|
if (delfp->f_type == DTYPE_MQUEUE)
|
|
|
|
mq_fdclose(td, new, delfp);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2001-09-12 08:38:13 +00:00
|
|
|
(void) closef(delfp, td);
|
2003-06-02 16:05:32 +00:00
|
|
|
if (holdleaders) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(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);
|
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
}
|
2004-08-16 03:09:01 +00:00
|
|
|
} else {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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
|
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;
|
|
|
|
{
|
2006-07-08 20:03:39 +00:00
|
|
|
|
|
|
|
return (kern_close(td, uap->fd));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kern_close(td, fd)
|
|
|
|
struct thread *td;
|
|
|
|
int fd;
|
|
|
|
{
|
2003-01-01 01:05:54 +00:00
|
|
|
struct filedesc *fdp;
|
|
|
|
struct file *fp;
|
2006-07-08 20:03:39 +00:00
|
|
|
int 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
|
|
|
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;
|
2006-02-05 23:57:32 +00:00
|
|
|
|
|
|
|
AUDIT_SYSCLOSE(td, fd);
|
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((unsigned)fd >= fdp->fd_nfiles ||
|
2007-05-31 11:51:53 +00:00
|
|
|
(fp = fdp->fd_ofiles[fd]) == NULL) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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
|
|
|
|
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* We now hold the fp reference that used to be owned by the
|
|
|
|
* descriptor array. 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);
|
2005-11-30 05:12:03 +00:00
|
|
|
if (fp->f_type == DTYPE_MQUEUE)
|
|
|
|
mq_fdclose(td, fd, fp);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(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);
|
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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
|
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
|
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;
|
|
|
|
|
2006-02-05 23:57:32 +00:00
|
|
|
AUDIT_ARG(fd, fd);
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
if ((error = fget(td, fd, &fp)) != 0)
|
|
|
|
return (error);
|
2006-02-05 23:57:32 +00:00
|
|
|
|
|
|
|
AUDIT_ARG(file, td->td_proc, fp);
|
|
|
|
|
2005-02-07 18:44:55 +00:00
|
|
|
error = fo_stat(fp, sbp, td->td_ucred, td);
|
2001-09-12 08:38:13 +00:00
|
|
|
fdrop(fp, td);
|
2008-02-23 01:01:49 +00:00
|
|
|
#ifdef KTRACE
|
|
|
|
if (error == 0 && KTRPOINT(td, KTR_STRUCT))
|
|
|
|
ktrstat(sbp);
|
|
|
|
#endif
|
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
|
|
|
|
/* 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
|
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);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
2001-09-12 08:38:13 +00:00
|
|
|
error = VOP_PATHCONF(vp, uap->name, td->td_retval);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
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;
|
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK_ASSERT(fdp);
|
2004-01-15 10:15:04 +00:00
|
|
|
|
|
|
|
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 */
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2004-01-15 10:15:04 +00:00
|
|
|
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;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2004-01-15 10:15:04 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK_ASSERT(fdp);
|
2002-01-13 11:58:06 +00:00
|
|
|
|
2006-03-20 00:13:47 +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
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* Check to see whether n user file descriptors are available to the process
|
|
|
|
* p.
|
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
|
|
|
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
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_LOCK_ASSERT(fdp);
|
2002-01-13 11:58:06 +00:00
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* Create a new open file structure and allocate a file decriptor for the
|
|
|
|
* process that refers to it. We add one reference to the file for the
|
|
|
|
* descriptor table and one reference for resultfp. This is to prevent us
|
|
|
|
* being preempted and the entry in the descriptor table closed after 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;
|
2007-12-30 01:42:15 +00:00
|
|
|
struct file *fp;
|
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);
|
2006-06-27 11:32:08 +00:00
|
|
|
if ((openfiles >= maxuserfiles &&
|
2007-06-16 23:41:43 +00:00
|
|
|
priv_check(td, PRIV_MAXFILES) != 0) ||
|
2006-06-27 11:32:08 +00:00
|
|
|
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-07-17 02:48:43 +00:00
|
|
|
uma_zfree(file_zone, fp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (ENFILE);
|
|
|
|
}
|
2007-12-30 01:42:15 +00:00
|
|
|
atomic_add_int(&openfiles, 1);
|
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
|
|
|
*/
|
2008-05-25 14:57:43 +00:00
|
|
|
refcount_init(&fp->f_count, 1);
|
2003-10-19 20:41:07 +00:00
|
|
|
if (resultfp)
|
2008-05-25 14:57:43 +00:00
|
|
|
fhold(fp);
|
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;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(p->p_fd);
|
2004-01-17 00:59:04 +00:00
|
|
|
if ((error = fdalloc(td, 0, &i))) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(p->p_fd);
|
- 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
|
|
|
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;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_LOCK_INIT(&newfdp->fd_fd);
|
2004-11-07 12:39:28 +00:00
|
|
|
if (fdp != NULL) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2004-11-07 12:39:28 +00:00
|
|
|
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);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2004-11-07 12:39:28 +00:00
|
|
|
}
|
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;
|
2006-03-20 00:13:47 +00:00
|
|
|
newfdp->fd_fd.fd_lastfile = -1;
|
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;
|
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_LOCK_DESTROY(fdp);
|
2004-12-14 09:09:51 +00:00
|
|
|
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
|
|
|
{
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
|
|
|
|
FILEDESC_XLOCK(fdp);
|
2003-01-01 01:01:14 +00:00
|
|
|
fdp->fd_refcnt++;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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)
|
|
|
|
{
|
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(p->p_fd);
|
2004-12-14 07:20:03 +00:00
|
|
|
if (p->p_fd->fd_refcnt > 1) {
|
|
|
|
struct filedesc *tmp;
|
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(p->p_fd);
|
2004-12-14 07:20:03 +00:00
|
|
|
tmp = fdcopy(p->p_fd);
|
|
|
|
fdfree(td);
|
|
|
|
p->p_fd = tmp;
|
|
|
|
} else
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(p->p_fd);
|
2004-12-14 07:20:03 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* Copy a filedesc structure. 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);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SLOCK(fdp);
|
2004-01-15 18:50:11 +00:00
|
|
|
while (fdp->fd_lastfile >= newfdp->fd_nfiles) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
FILEDESC_XLOCK(newfdp);
|
2004-01-15 10:15:04 +00:00
|
|
|
fdgrowtable(newfdp, fdp->fd_lastfile + 1);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(newfdp);
|
|
|
|
FILEDESC_SLOCK(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) &&
|
2007-05-31 11:51:53 +00:00
|
|
|
fdp->fd_ofiles[i]->f_type != DTYPE_KQUEUE) {
|
2004-01-15 10:15:04 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
FILEDESC_XLOCK(newfdp);
|
2004-01-16 21:54:56 +00:00
|
|
|
for (i = 0; i <= newfdp->fd_lastfile; ++i)
|
|
|
|
if (newfdp->fd_ofiles[i] != NULL)
|
|
|
|
fdused(newfdp, i);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(newfdp);
|
|
|
|
FILEDESC_SLOCK(fdp);
|
2004-01-15 10:15:04 +00:00
|
|
|
if (newfdp->fd_freefile == -1)
|
|
|
|
newfdp->fd_freefile = i;
|
|
|
|
newfdp->fd_cmask = fdp->fd_cmask;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(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) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
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);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
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);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
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;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
sx_sleep(&fdp->fd_holdleaderscount,
|
|
|
|
FILEDESC_LOCK(fdp), PLOCK, "fdlhold", 0);
|
2003-06-02 16:05:32 +00:00
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
if (fdtol->fdl_holdcount > 0) {
|
2004-01-11 19:39:14 +00:00
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* Ensure that fdtol->fdl_leader remains
|
|
|
|
* valid in closef().
|
2003-06-02 16:05:32 +00:00
|
|
|
*/
|
|
|
|
fdtol->fdl_wakeup = 1;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
sx_sleep(fdtol, FILEDESC_LOCK(fdp), PLOCK,
|
|
|
|
"fdlhold", 0);
|
2003-06-02 16:05:32 +00:00
|
|
|
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;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
if (fdtol != NULL)
|
|
|
|
FREE(fdtol, M_FILEDESC_TO_LEADER);
|
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2004-12-14 20:48:40 +00:00
|
|
|
i = --fdp->fd_refcnt;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2004-12-14 20:48:40 +00:00
|
|
|
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
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(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;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2004-12-14 09:09:51 +00:00
|
|
|
|
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!
|
|
|
|
*/
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(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);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2001-09-12 08:38:13 +00:00
|
|
|
(void) closef(fp, td);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2000-01-20 07:12:52 +00:00
|
|
|
}
|
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2000-01-20 07:12:52 +00:00
|
|
|
}
|
|
|
|
|
2006-07-21 20:24:00 +00:00
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* If a specific file object occupies a specific file descriptor, close the
|
|
|
|
* file descriptor entry and drop a reference on the file object. This is a
|
|
|
|
* convenience function to handle a subsequent error in a function that calls
|
|
|
|
* falloc() that handles the race that another thread might have closed the
|
|
|
|
* file descriptor out from under the thread creating the file object.
|
2006-07-21 20:24:00 +00:00
|
|
|
*/
|
2004-11-07 22:16:07 +00:00
|
|
|
void
|
|
|
|
fdclose(struct filedesc *fdp, struct file *fp, int idx, struct thread *td)
|
|
|
|
{
|
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2004-11-07 22:16:07 +00:00
|
|
|
if (fdp->fd_ofiles[idx] == fp) {
|
|
|
|
fdp->fd_ofiles[idx] = NULL;
|
|
|
|
fdunused(fdp, idx);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2004-11-07 22:16:07 +00:00
|
|
|
fdrop(fp, td);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
} else
|
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2004-11-07 22:16:07 +00:00
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2002-01-13 11:58:06 +00:00
|
|
|
|
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 &&
|
2005-11-30 05:12:03 +00:00
|
|
|
(fdp->fd_ofiles[i]->f_type == DTYPE_MQUEUE ||
|
|
|
|
(fdp->fd_ofileflags[i] & UF_EXCLOSE))) {
|
2000-11-18 21:01:04 +00:00
|
|
|
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);
|
2005-11-30 05:12:03 +00:00
|
|
|
if (fp->f_type == DTYPE_MQUEUE)
|
|
|
|
mq_fdclose(td, i, fp);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2001-09-12 08:38:13 +00:00
|
|
|
(void) closef(fp, td);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
1994-05-25 09:21:21 +00:00
|
|
|
}
|
2000-11-18 21:01:04 +00:00
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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 filedesc *fdp;
|
2007-04-26 18:01:19 +00:00
|
|
|
register_t retval, save;
|
|
|
|
int i, error, 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) {
|
2007-04-26 18:01:19 +00:00
|
|
|
save = td->td_retval[0];
|
|
|
|
error = kern_open(td, "/dev/null", UIO_SYSSPACE,
|
|
|
|
O_RDWR, 0);
|
|
|
|
devnull = td->td_retval[0];
|
|
|
|
KASSERT(devnull == i, ("oof, we didn't get our fd"));
|
|
|
|
td->td_retval[0] = save;
|
|
|
|
if (error)
|
2002-04-19 00:45:29 +00:00
|
|
|
break;
|
|
|
|
} 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
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +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) {
|
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* Handle special case where file descriptor table is
|
|
|
|
* shared between multiple process leaders.
|
2003-06-02 16:05:32 +00:00
|
|
|
*/
|
|
|
|
fdp = td->td_proc->p_fd;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
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++;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
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);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
fdtol->fdl_holdcount--;
|
|
|
|
if (fdtol->fdl_holdcount == 0 &&
|
|
|
|
fdtol->fdl_wakeup != 0) {
|
|
|
|
fdtol->fdl_wakeup = 0;
|
|
|
|
wakeup(fdtol);
|
|
|
|
}
|
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
2007-12-30 01:42:15 +00:00
|
|
|
/*
|
|
|
|
* Initialize the file pointer with the specified properties.
|
|
|
|
*
|
|
|
|
* The ops are set with release semantics to be certain that the flags, type,
|
|
|
|
* and data are visible when ops is. This is to prevent ops methods from being
|
|
|
|
* called with bad data.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
finit(struct file *fp, u_int flag, short type, void *data, struct fileops *ops)
|
|
|
|
{
|
|
|
|
fp->f_data = data;
|
|
|
|
fp->f_flag = flag;
|
|
|
|
fp->f_type = type;
|
|
|
|
atomic_store_rel_ptr((volatile uintptr_t *)&fp->f_ops, (uintptr_t)ops);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-11-14 06:30:36 +00:00
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* Extract the file pointer associated with the specified descriptor for the
|
|
|
|
* current user process.
|
2002-01-14 00:13:45 +00:00
|
|
|
*
|
|
|
|
* If the descriptor doesn't exist, EBADF is returned.
|
|
|
|
*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* 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.
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* It should be dropped with fdrop(). If it is not set, then the refcount
|
|
|
|
* will not be bumped however the thread's filedesc struct will be returned
|
|
|
|
* locked (for fgetsock).
|
2002-01-14 00:13:45 +00:00
|
|
|
*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* 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);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SLOCK(fdp);
|
2002-01-29 22:54:19 +00:00
|
|
|
if ((fp = fget_locked(fdp, fd)) == NULL || fp->f_ops == &badfileops) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(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
|
|
|
|
|
|
|
/*
|
2006-01-06 16:30:30 +00:00
|
|
|
* FREAD and FWRITE failure return EBADF as per POSIX.
|
2001-11-14 06:30:36 +00:00
|
|
|
*
|
|
|
|
* Only one flag, or 0, may be specified.
|
|
|
|
*/
|
2002-01-14 00:13:45 +00:00
|
|
|
if (flags == FREAD && (fp->f_flag & FREAD) == 0) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(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) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(fdp);
|
2006-01-06 16:30:30 +00:00
|
|
|
return (EBADF);
|
2002-01-14 00:13:45 +00:00
|
|
|
}
|
|
|
|
if (hold) {
|
|
|
|
fhold(fp);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(fdp);
|
2002-01-14 00:13:45 +00:00
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +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 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;
|
2008-02-14 11:44:31 +00:00
|
|
|
if ((error = _fget(td, fd, &fp, flags, 0)) != 0)
|
2002-01-14 00:13:45 +00:00
|
|
|
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);
|
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(td->td_proc->p_fd);
|
2002-01-14 00:13:45 +00:00
|
|
|
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
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* Like fget() but loads the underlying socket, or returns an error if the
|
|
|
|
* descriptor does not represent a socket.
|
2001-11-17 03:07:11 +00:00
|
|
|
*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* We bump the ref count on the returned socket. XXX Also obtain the SX lock
|
|
|
|
* in the future.
|
2006-04-01 11:09:54 +00:00
|
|
|
*
|
|
|
|
* XXXRW: fgetsock() and fputsock() are deprecated, as consumers should rely
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* on their file descriptor reference to prevent the socket from being free'd
|
|
|
|
* during use.
|
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
|
|
|
|
|
|
|
*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
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(td->td_proc->p_fd);
|
2002-10-16 15:45:37 +00:00
|
|
|
return (error);
|
2001-11-17 03:07:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-04-01 11:09:54 +00:00
|
|
|
* Drop the reference count on the socket and XXX release the SX lock in the
|
|
|
|
* future. The last reference closes the socket.
|
|
|
|
*
|
|
|
|
* XXXRW: fputsock() is deprecated, see comment for fgetsock().
|
2001-11-17 03:07:11 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
fputsock(struct socket *so)
|
|
|
|
{
|
2002-10-16 15:45:37 +00:00
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2002-01-13 12:58:14 +00:00
|
|
|
/*
|
2007-12-30 01:42:15 +00:00
|
|
|
* Handle the last reference to a file being closed.
|
2002-01-13 12:58:14 +00:00
|
|
|
*/
|
2007-12-30 01:42:15 +00:00
|
|
|
int
|
|
|
|
_fdrop(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;
|
|
|
|
|
2007-12-30 01:42:15 +00:00
|
|
|
error = 0;
|
|
|
|
if (fp->f_count != 0)
|
|
|
|
panic("fdrop: count %d", fp->f_count);
|
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);
|
2008-05-21 09:31:44 +00:00
|
|
|
/*
|
|
|
|
* The f_cdevpriv cannot be assigned non-NULL value while we
|
|
|
|
* are destroying the file.
|
|
|
|
*/
|
|
|
|
if (fp->f_cdevpriv != NULL)
|
|
|
|
devfs_fpdrop(fp);
|
2007-12-30 01:42:15 +00:00
|
|
|
atomic_subtract_int(&openfiles, 1);
|
2004-12-02 12:17:27 +00:00
|
|
|
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.
|
|
|
|
*
|
2007-03-05 13:10:58 +00:00
|
|
|
* 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).
|
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 flock_args {
|
|
|
|
int fd;
|
|
|
|
int how;
|
|
|
|
};
|
1995-11-12 06:43:28 +00:00
|
|
|
#endif
|
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;
|
2007-07-03 21:26:06 +00:00
|
|
|
int vfslocked;
|
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
|
|
|
|
2003-06-22 08:41:43 +00:00
|
|
|
vp = fp->f_vnode;
|
2007-07-03 21:26:06 +00:00
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
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;
|
2007-12-30 01:42:15 +00:00
|
|
|
atomic_clear_int(&fp->f_flag, FHASLOCK);
|
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;
|
|
|
|
}
|
2007-12-30 01:42:15 +00:00
|
|
|
atomic_set_int(&fp->f_flag, FHASLOCK);
|
2002-01-13 11:58:06 +00:00
|
|
|
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);
|
2007-07-03 21:26:06 +00:00
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2001-09-01 19:04:37 +00:00
|
|
|
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
|
|
|
*/
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(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) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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.
|
|
|
|
*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* For ENODEV simply dup (dfd) to file descriptor (indx) and return.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
* For ENXIO steal away the file structure from (dfd) and store it in
|
|
|
|
* (indx). (dfd) is effectively closed by this operation.
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
|
|
|
* 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
|
|
|
if (((mode & (FREAD|FWRITE)) | wfp->f_flag) != wfp->f_flag) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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);
|
2007-12-30 01:42:15 +00:00
|
|
|
fhold(wfp);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2007-03-15 21:19:21 +00:00
|
|
|
if (fp != NULL)
|
2004-11-16 09:12:03 +00:00
|
|
|
/*
|
|
|
|
* We now own the reference to fp that the ofiles[]
|
|
|
|
* array used to own. Release it.
|
|
|
|
*/
|
2007-03-15 21:19:21 +00:00
|
|
|
fdrop(fp, td);
|
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);
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2002-01-13 11:58:06 +00:00
|
|
|
|
|
|
|
/*
|
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)
|
2007-03-15 21:19:21 +00:00
|
|
|
fdrop(fp, td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
default:
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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
|
|
|
/*
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +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.
|
2004-12-14 08:23:18 +00:00
|
|
|
*/
|
|
|
|
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);
|
2007-01-17 14:58:53 +00:00
|
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
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;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2004-12-14 08:23:18 +00:00
|
|
|
if (fdp->fd_cdir == olddp) {
|
|
|
|
vref(newdp);
|
|
|
|
fdp->fd_cdir = newdp;
|
|
|
|
nrele++;
|
|
|
|
}
|
|
|
|
if (fdp->fd_rdir == olddp) {
|
|
|
|
vref(newdp);
|
|
|
|
fdp->fd_rdir = newdp;
|
|
|
|
nrele++;
|
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(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) {
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XLOCK(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
fdtol->fdl_next = old->fdl_next;
|
|
|
|
fdtol->fdl_prev = old;
|
|
|
|
old->fdl_next = fdtol;
|
|
|
|
fdtol->fdl_next->fdl_prev = fdtol;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_XUNLOCK(fdp);
|
2003-06-02 16:05:32 +00:00
|
|
|
} 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
|
|
|
/*
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
* Get file structures globally.
|
1995-11-14 08:58:35 +00:00
|
|
|
*/
|
|
|
|
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
|
|
|
|
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) {
|
2007-12-30 01:42:15 +00:00
|
|
|
n = 0;
|
|
|
|
sx_slock(&allproc_lock);
|
|
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
|
|
|
if (p->p_state == PRS_NEW)
|
|
|
|
continue;
|
|
|
|
fdp = fdhold(p);
|
|
|
|
if (fdp == NULL)
|
|
|
|
continue;
|
|
|
|
/* overestimates sparse tables. */
|
2008-01-03 01:26:59 +00:00
|
|
|
if (fdp->fd_lastfile > 0)
|
|
|
|
n += fdp->fd_lastfile;
|
2007-12-30 01:42:15 +00:00
|
|
|
fddrop(fdp);
|
2002-07-31 12:26:52 +00:00
|
|
|
}
|
2007-12-30 01:42:15 +00:00
|
|
|
sx_sunlock(&allproc_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);
|
2007-01-17 14:58:53 +00:00
|
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
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;
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SLOCK(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;
|
2007-12-30 01:42:15 +00:00
|
|
|
xf.xf_msgcount = 0;
|
2003-01-13 00:33:17 +00:00
|
|
|
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
|
|
|
}
|
Replace custom file descriptor array sleep lock constructed using a mutex
and flags with an sxlock. This leads to a significant and measurable
performance improvement as a result of access to shared locking for
frequent lookup operations, reduced general overhead, and reduced overhead
in the event of contention. All of these are imported for threaded
applications where simultaneous access to a shared file descriptor array
occurs frequently. Kris has reported 2x-4x transaction rate improvements
on 8-core MySQL benchmarks; smaller improvements can be expected for many
workloads as a result of reduced overhead.
- Generally eliminate the distinction between "fast" and regular
acquisisition of the filedesc lock; the plan is that they will now all
be fast. Change all locking instances to either shared or exclusive
locks.
- Correct a bug (pointed out by kib) in fdfree() where previously msleep()
was called without the mutex held; sx_sleep() is now always called with
the sxlock held exclusively.
- Universally hold the struct file lock over changes to struct file,
rather than the filedesc lock or no lock. Always update the f_ops
field last. A further memory barrier is required here in the future
(discussed with jhb).
- Improve locking and reference management in linux_at(), which fails to
properly acquire vnode references before using vnode pointers. Annotate
improper use of vn_fullpath(), which will be replaced at a future date.
In fcntl(), we conservatively acquire an exclusive lock, even though in
some cases a shared lock may be sufficient, which should be revisited.
The dropping of the filedesc lock in fdgrowtable() is no longer required
as the sxlock can be held over the sleep operation; we should consider
removing that (pointed out by attilio).
Tested by: kris
Discussed with: jhb, kris, attilio, jeff
2007-04-04 09:11:34 +00:00
|
|
|
FILEDESC_SUNLOCK(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
|
|
|
|
2008-02-09 05:16:26 +00:00
|
|
|
static int
|
|
|
|
export_vnode_for_sysctl(struct vnode *vp, int type,
|
|
|
|
struct kinfo_file *kif, struct filedesc *fdp, struct sysctl_req *req)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
char *fullpath, *freepath;
|
|
|
|
int vfslocked;
|
|
|
|
|
|
|
|
bzero(kif, sizeof(*kif));
|
|
|
|
kif->kf_structsize = sizeof(*kif);
|
|
|
|
|
|
|
|
vref(vp);
|
|
|
|
kif->kf_fd = type;
|
|
|
|
kif->kf_type = KF_TYPE_VNODE;
|
|
|
|
/* This function only handles directories. */
|
|
|
|
KASSERT(vp->v_type == VDIR, ("export_vnode_for_sysctl: vnode not directory"));
|
|
|
|
kif->kf_vnode_type = KF_VTYPE_VDIR;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is not a true file descriptor, so we set a bogus refcount
|
|
|
|
* and offset to indicate these fields should be ignored.
|
|
|
|
*/
|
|
|
|
kif->kf_ref_count = -1;
|
|
|
|
kif->kf_offset = -1;
|
|
|
|
|
|
|
|
freepath = NULL;
|
|
|
|
fullpath = "-";
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
|
|
|
vn_fullpath(curthread, vp, &fullpath, &freepath);
|
|
|
|
vput(vp);
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
strlcpy(kif->kf_path, fullpath, sizeof(kif->kf_path));
|
|
|
|
if (freepath != NULL)
|
|
|
|
free(freepath, M_TEMP);
|
|
|
|
error = SYSCTL_OUT(req, kif, sizeof(*kif));
|
|
|
|
FILEDESC_SLOCK(fdp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
/*
|
|
|
|
* Get per-process file descriptors for use by procstat(1), et al.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
sysctl_kern_proc_filedesc(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
char *fullpath, *freepath;
|
|
|
|
struct kinfo_file *kif;
|
|
|
|
struct filedesc *fdp;
|
|
|
|
int error, i, *name;
|
|
|
|
struct socket *so;
|
|
|
|
struct vnode *vp;
|
|
|
|
struct file *fp;
|
|
|
|
struct proc *p;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
struct tty *tp;
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
int vfslocked;
|
|
|
|
|
|
|
|
name = (int *)arg1;
|
|
|
|
if ((p = pfind((pid_t)name[0])) == NULL)
|
|
|
|
return (ESRCH);
|
|
|
|
if ((error = p_candebug(curthread, p))) {
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
fdp = fdhold(p);
|
|
|
|
PROC_UNLOCK(p);
|
2008-04-26 13:16:55 +00:00
|
|
|
if (fdp == NULL)
|
|
|
|
return (ENOENT);
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
kif = malloc(sizeof(*kif), M_TEMP, M_WAITOK);
|
|
|
|
FILEDESC_SLOCK(fdp);
|
2008-02-09 05:16:26 +00:00
|
|
|
if (fdp->fd_cdir != NULL)
|
|
|
|
export_vnode_for_sysctl(fdp->fd_cdir, KF_FD_TYPE_CWD, kif,
|
|
|
|
fdp, req);
|
|
|
|
if (fdp->fd_rdir != NULL)
|
|
|
|
export_vnode_for_sysctl(fdp->fd_rdir, KF_FD_TYPE_ROOT, kif,
|
|
|
|
fdp, req);
|
|
|
|
if (fdp->fd_jdir != NULL)
|
|
|
|
export_vnode_for_sysctl(fdp->fd_jdir, KF_FD_TYPE_JAIL, kif,
|
|
|
|
fdp, req);
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
for (i = 0; i < fdp->fd_nfiles; i++) {
|
|
|
|
if ((fp = fdp->fd_ofiles[i]) == NULL)
|
|
|
|
continue;
|
|
|
|
bzero(kif, sizeof(*kif));
|
|
|
|
kif->kf_structsize = sizeof(*kif);
|
|
|
|
vp = NULL;
|
|
|
|
so = NULL;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
tp = NULL;
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
kif->kf_fd = i;
|
|
|
|
switch (fp->f_type) {
|
|
|
|
case DTYPE_VNODE:
|
|
|
|
kif->kf_type = KF_TYPE_VNODE;
|
|
|
|
vp = fp->f_vnode;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DTYPE_SOCKET:
|
|
|
|
kif->kf_type = KF_TYPE_SOCKET;
|
|
|
|
so = fp->f_data;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DTYPE_PIPE:
|
|
|
|
kif->kf_type = KF_TYPE_PIPE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DTYPE_FIFO:
|
|
|
|
kif->kf_type = KF_TYPE_FIFO;
|
|
|
|
vp = fp->f_vnode;
|
|
|
|
vref(vp);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DTYPE_KQUEUE:
|
|
|
|
kif->kf_type = KF_TYPE_KQUEUE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DTYPE_CRYPTO:
|
|
|
|
kif->kf_type = KF_TYPE_CRYPTO;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DTYPE_MQUEUE:
|
|
|
|
kif->kf_type = KF_TYPE_MQUEUE;
|
|
|
|
break;
|
|
|
|
|
2008-01-20 19:55:52 +00:00
|
|
|
case DTYPE_SHM:
|
|
|
|
kif->kf_type = KF_TYPE_SHM;
|
|
|
|
break;
|
|
|
|
|
Rework the lifetime management of the kernel implementation of POSIX
semaphores. Specifically, semaphores are now represented as new file
descriptor type that is set to close on exec. This removes the need for
all of the manual process reference counting (and fork, exec, and exit
event handlers) as the normal file descriptor operations handle all of
that for us nicely. It is also suggested as one possible implementation
in the spec and at least one other OS (OS X) uses this approach.
Some bugs that were fixed as a result include:
- References to a named semaphore whose name is removed still work after
the sem_unlink() operation. Prior to this patch, if a semaphore's name
was removed, valid handles from sem_open() would get EINVAL errors from
sem_getvalue(), sem_post(), etc. This fixes that.
- Unnamed semaphores created with sem_init() were not cleaned up when a
process exited or exec'd. They were only cleaned up if the process
did an explicit sem_destroy(). This could result in a leak of semaphore
objects that could never be cleaned up.
- On the other hand, if another process guessed the id (kernel pointer to
'struct ksem' of an unnamed semaphore (created via sem_init)) and had
write access to the semaphore based on UID/GID checks, then that other
process could manipulate the semaphore via sem_destroy(), sem_post(),
sem_wait(), etc.
- As part of the permission check (UID/GID), the umask of the proces
creating the semaphore was not honored. Thus if your umask denied group
read/write access but the explicit mode in the sem_init() call allowed
it, the semaphore would be readable/writable by other users in the
same group, for example. This includes access via the previous bug.
- If the module refused to unload because there were active semaphores,
then it might have deregistered one or more of the semaphore system
calls before it noticed that there was a problem. I'm not sure if
this actually happened as the order that modules are discovered by the
kernel linker depends on how the actual .ko file is linked. One can
make the order deterministic by using a single module with a mod_event
handler that explicitly registers syscalls (and deregisters during
unload after any checks). This also fixes a race where even if the
sem_module unloaded first it would have destroyed locks that the
syscalls might be trying to access if they are still executing when
they are unloaded.
XXX: By the way, deregistering system calls doesn't do any blocking
to drain any threads from the calls.
- Some minor fixes to errno values on error. For example, sem_init()
isn't documented to return ENFILE or EMFILE if we run out of semaphores
the way that sem_open() can. Instead, it should return ENOSPC in that
case.
Other changes:
- Kernel semaphores now use a hash table to manage the namespace of
named semaphores nearly in a similar fashion to the POSIX shared memory
object file descriptors. Kernel semaphores can now also have names
longer than 14 chars (up to MAXPATHLEN) and can include subdirectories
in their pathname.
- The UID/GID permission checks for access to a named semaphore are now
done via vaccess() rather than a home-rolled set of checks.
- Now that kernel semaphores have an associated file object, the various
MAC checks for POSIX semaphores accept both a file credential and an
active credential. There is also a new posixsem_check_stat() since it
is possible to fstat() a semaphore file descriptor.
- A small set of regression tests (using the ksem API directly) is present
in src/tools/regression/posixsem.
Reported by: kris (1)
Tested by: kris
Reviewed by: rwatson (lightly)
MFC after: 1 month
2008-06-27 05:39:04 +00:00
|
|
|
case DTYPE_SEM:
|
|
|
|
kif->kf_type = KF_TYPE_SEM;
|
|
|
|
break;
|
|
|
|
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
case DTYPE_PTS:
|
|
|
|
kif->kf_type = KF_TYPE_PTS;
|
|
|
|
tp = fp->f_data;
|
|
|
|
break;
|
|
|
|
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
default:
|
|
|
|
kif->kf_type = KF_TYPE_UNKNOWN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
kif->kf_ref_count = fp->f_count;
|
|
|
|
if (fp->f_flag & FREAD)
|
|
|
|
kif->kf_flags |= KF_FLAG_READ;
|
|
|
|
if (fp->f_flag & FWRITE)
|
|
|
|
kif->kf_flags |= KF_FLAG_WRITE;
|
|
|
|
if (fp->f_flag & FAPPEND)
|
|
|
|
kif->kf_flags |= KF_FLAG_APPEND;
|
|
|
|
if (fp->f_flag & FASYNC)
|
|
|
|
kif->kf_flags |= KF_FLAG_ASYNC;
|
|
|
|
if (fp->f_flag & FFSYNC)
|
|
|
|
kif->kf_flags |= KF_FLAG_FSYNC;
|
|
|
|
if (fp->f_flag & FNONBLOCK)
|
|
|
|
kif->kf_flags |= KF_FLAG_NONBLOCK;
|
|
|
|
if (fp->f_flag & O_DIRECT)
|
|
|
|
kif->kf_flags |= KF_FLAG_DIRECT;
|
|
|
|
if (fp->f_flag & FHASLOCK)
|
|
|
|
kif->kf_flags |= KF_FLAG_HASLOCK;
|
|
|
|
kif->kf_offset = fp->f_offset;
|
|
|
|
if (vp != NULL) {
|
2007-12-30 01:42:15 +00:00
|
|
|
vref(vp);
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
switch (vp->v_type) {
|
|
|
|
case VNON:
|
|
|
|
kif->kf_vnode_type = KF_VTYPE_VNON;
|
|
|
|
break;
|
|
|
|
case VREG:
|
|
|
|
kif->kf_vnode_type = KF_VTYPE_VREG;
|
|
|
|
break;
|
|
|
|
case VDIR:
|
|
|
|
kif->kf_vnode_type = KF_VTYPE_VDIR;
|
|
|
|
break;
|
|
|
|
case VBLK:
|
|
|
|
kif->kf_vnode_type = KF_VTYPE_VBLK;
|
|
|
|
break;
|
|
|
|
case VCHR:
|
|
|
|
kif->kf_vnode_type = KF_VTYPE_VCHR;
|
|
|
|
break;
|
|
|
|
case VLNK:
|
|
|
|
kif->kf_vnode_type = KF_VTYPE_VLNK;
|
|
|
|
break;
|
|
|
|
case VSOCK:
|
|
|
|
kif->kf_vnode_type = KF_VTYPE_VSOCK;
|
|
|
|
break;
|
|
|
|
case VFIFO:
|
|
|
|
kif->kf_vnode_type = KF_VTYPE_VFIFO;
|
|
|
|
break;
|
|
|
|
case VBAD:
|
|
|
|
kif->kf_vnode_type = KF_VTYPE_VBAD;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
kif->kf_vnode_type = KF_VTYPE_UNKNOWN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* It is OK to drop the filedesc lock here as we will
|
|
|
|
* re-validate and re-evaluate its properties when
|
|
|
|
* the loop continues.
|
|
|
|
*/
|
|
|
|
freepath = NULL;
|
|
|
|
fullpath = "-";
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
|
2008-01-10 01:10:58 +00:00
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
vn_fullpath(curthread, vp, &fullpath, &freepath);
|
|
|
|
vput(vp);
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
|
|
|
strlcpy(kif->kf_path, fullpath,
|
|
|
|
sizeof(kif->kf_path));
|
|
|
|
if (freepath != NULL)
|
|
|
|
free(freepath, M_TEMP);
|
|
|
|
FILEDESC_SLOCK(fdp);
|
|
|
|
}
|
|
|
|
if (so != NULL) {
|
|
|
|
struct sockaddr *sa;
|
|
|
|
|
|
|
|
if (so->so_proto->pr_usrreqs->pru_sockaddr(so, &sa)
|
|
|
|
== 0 && sa->sa_len <= sizeof(kif->kf_sa_local)) {
|
|
|
|
bcopy(sa, &kif->kf_sa_local, sa->sa_len);
|
|
|
|
free(sa, M_SONAME);
|
|
|
|
}
|
|
|
|
if (so->so_proto->pr_usrreqs->pru_peeraddr(so, &sa)
|
|
|
|
== 00 && sa->sa_len <= sizeof(kif->kf_sa_peer)) {
|
|
|
|
bcopy(sa, &kif->kf_sa_peer, sa->sa_len);
|
|
|
|
free(sa, M_SONAME);
|
|
|
|
}
|
|
|
|
kif->kf_sock_domain =
|
|
|
|
so->so_proto->pr_domain->dom_family;
|
|
|
|
kif->kf_sock_type = so->so_type;
|
|
|
|
kif->kf_sock_protocol = so->so_proto->pr_protocol;
|
|
|
|
}
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
if (tp != NULL) {
|
|
|
|
strlcpy(kif->kf_path, tty_devname(tp),
|
|
|
|
sizeof(kif->kf_path));
|
|
|
|
}
|
Add two new sysctls in support of the forthcoming procstat(1) to support
its -f and -v arguments:
kern.proc.filedesc - dump file descriptor information for a process, if
debugging is permitted, including socket addresses, open flags, file
offsets, file paths, etc.
kern.proc.vmmap - dump virtual memory mapping information for a process,
if debugging is permitted, including layout and information on
underlying objects, such as the type of object and path.
These provide a superset of the information historically available
through the now-deprecated procfs(4), and are intended to be exported
in an ABI-robust form.
2007-12-02 10:10:27 +00:00
|
|
|
error = SYSCTL_OUT(req, kif, sizeof(*kif));
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
FILEDESC_SUNLOCK(fdp);
|
|
|
|
fddrop(fdp);
|
|
|
|
free(kif, M_TEMP);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static SYSCTL_NODE(_kern_proc, KERN_PROC_FILEDESC, filedesc, CTLFLAG_RD,
|
|
|
|
sysctl_kern_proc_filedesc, "Process filedesc entries");
|
|
|
|
|
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");
|
2007-02-15 10:55:43 +00:00
|
|
|
case DTYPE_KQUEUE:
|
|
|
|
return ("kque");
|
2005-11-10 10:42:50 +00:00
|
|
|
case DTYPE_CRYPTO:
|
|
|
|
return ("crpt");
|
2007-02-15 10:55:43 +00:00
|
|
|
case DTYPE_MQUEUE:
|
|
|
|
return ("mque");
|
Add a new file descriptor type for IPC shared memory objects and use it to
implement shm_open(2) and shm_unlink(2) in the kernel:
- Each shared memory file descriptor is associated with a swap-backed vm
object which provides the backing store. Each descriptor starts off with
a size of zero, but the size can be altered via ftruncate(2). The shared
memory file descriptors also support fstat(2). read(2), write(2),
ioctl(2), select(2), poll(2), and kevent(2) are not supported on shared
memory file descriptors.
- shm_open(2) and shm_unlink(2) are now implemented as system calls that
manage shared memory file descriptors. The virtual namespace that maps
pathnames to shared memory file descriptors is implemented as a hash
table where the hash key is generated via the 32-bit Fowler/Noll/Vo hash
of the pathname.
- As an extension, the constant 'SHM_ANON' may be specified in place of the
path argument to shm_open(2). In this case, an unnamed shared memory
file descriptor will be created similar to the IPC_PRIVATE key for
shmget(2). Note that the shared memory object can still be shared among
processes by sharing the file descriptor via fork(2) or sendmsg(2), but
it is unnamed. This effectively serves to implement the getmemfd() idea
bandied about the lists several times over the years.
- The backing store for shared memory file descriptors are garbage
collected when they are not referenced by any open file descriptors or
the shm_open(2) virtual namespace.
Submitted by: dillon, peter (previous versions)
Submitted by: rwatson (I based this on his version)
Reviewed by: alc (suggested converting getmemfd() to shm_open())
2008-01-08 21:58:16 +00:00
|
|
|
case DTYPE_SHM:
|
|
|
|
return ("shm");
|
Rework the lifetime management of the kernel implementation of POSIX
semaphores. Specifically, semaphores are now represented as new file
descriptor type that is set to close on exec. This removes the need for
all of the manual process reference counting (and fork, exec, and exit
event handlers) as the normal file descriptor operations handle all of
that for us nicely. It is also suggested as one possible implementation
in the spec and at least one other OS (OS X) uses this approach.
Some bugs that were fixed as a result include:
- References to a named semaphore whose name is removed still work after
the sem_unlink() operation. Prior to this patch, if a semaphore's name
was removed, valid handles from sem_open() would get EINVAL errors from
sem_getvalue(), sem_post(), etc. This fixes that.
- Unnamed semaphores created with sem_init() were not cleaned up when a
process exited or exec'd. They were only cleaned up if the process
did an explicit sem_destroy(). This could result in a leak of semaphore
objects that could never be cleaned up.
- On the other hand, if another process guessed the id (kernel pointer to
'struct ksem' of an unnamed semaphore (created via sem_init)) and had
write access to the semaphore based on UID/GID checks, then that other
process could manipulate the semaphore via sem_destroy(), sem_post(),
sem_wait(), etc.
- As part of the permission check (UID/GID), the umask of the proces
creating the semaphore was not honored. Thus if your umask denied group
read/write access but the explicit mode in the sem_init() call allowed
it, the semaphore would be readable/writable by other users in the
same group, for example. This includes access via the previous bug.
- If the module refused to unload because there were active semaphores,
then it might have deregistered one or more of the semaphore system
calls before it noticed that there was a problem. I'm not sure if
this actually happened as the order that modules are discovered by the
kernel linker depends on how the actual .ko file is linked. One can
make the order deterministic by using a single module with a mod_event
handler that explicitly registers syscalls (and deregisters during
unload after any checks). This also fixes a race where even if the
sem_module unloaded first it would have destroyed locks that the
syscalls might be trying to access if they are still executing when
they are unloaded.
XXX: By the way, deregistering system calls doesn't do any blocking
to drain any threads from the calls.
- Some minor fixes to errno values on error. For example, sem_init()
isn't documented to return ENFILE or EMFILE if we run out of semaphores
the way that sem_open() can. Instead, it should return ENOSPC in that
case.
Other changes:
- Kernel semaphores now use a hash table to manage the namespace of
named semaphores nearly in a similar fashion to the POSIX shared memory
object file descriptors. Kernel semaphores can now also have names
longer than 14 chars (up to MAXPATHLEN) and can include subdirectories
in their pathname.
- The UID/GID permission checks for access to a named semaphore are now
done via vaccess() rather than a home-rolled set of checks.
- Now that kernel semaphores have an associated file object, the various
MAC checks for POSIX semaphores accept both a file credential and an
active credential. There is also a new posixsem_check_stat() since it
is possible to fstat() a semaphore file descriptor.
- A small set of regression tests (using the ksem API directly) is present
in src/tools/regression/posixsem.
Reported by: kris (1)
Tested by: kris
Reviewed by: rwatson (lightly)
MFC after: 1 month
2008-06-27 05:39:04 +00:00
|
|
|
case DTYPE_SEM:
|
|
|
|
return ("ksem");
|
2005-11-10 10:42:50 +00:00
|
|
|
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;
|
|
|
|
|
2007-01-17 14:58:53 +00:00
|
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
2005-11-10 10:42:50 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-02-15 10:50:48 +00:00
|
|
|
static void
|
|
|
|
db_print_file(struct file *fp, int header)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
if (header)
|
|
|
|
db_printf("%8s %4s %8s %8s %4s %5s %6s %8s %5s %12s\n",
|
|
|
|
"File", "Type", "Data", "Flag", "GCFl", "Count",
|
|
|
|
"MCount", "Vnode", "FPID", "FCmd");
|
|
|
|
p = file_to_first_proc(fp);
|
|
|
|
db_printf("%8p %4s %8p %08x %04x %5d %6d %8p %5d %12s\n", fp,
|
|
|
|
file_type_to_name(fp->f_type), fp->f_data, fp->f_flag,
|
2007-12-30 01:42:15 +00:00
|
|
|
0, fp->f_count, 0, fp->f_vnode,
|
2007-02-15 10:50:48 +00:00
|
|
|
p != NULL ? p->p_pid : -1, p != NULL ? p->p_comm : "-");
|
|
|
|
}
|
|
|
|
|
|
|
|
DB_SHOW_COMMAND(file, db_show_file)
|
|
|
|
{
|
|
|
|
struct file *fp;
|
|
|
|
|
|
|
|
if (!have_addr) {
|
|
|
|
db_printf("usage: show file <addr>\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
fp = (struct file *)addr;
|
|
|
|
db_print_file(fp, 1);
|
|
|
|
}
|
|
|
|
|
2005-11-10 10:42:50 +00:00
|
|
|
DB_SHOW_COMMAND(files, db_show_files)
|
|
|
|
{
|
2007-12-30 01:42:15 +00:00
|
|
|
struct filedesc *fdp;
|
2005-11-10 10:42:50 +00:00
|
|
|
struct file *fp;
|
2007-12-30 01:42:15 +00:00
|
|
|
struct proc *p;
|
2007-02-15 10:50:48 +00:00
|
|
|
int header;
|
2007-12-30 01:42:15 +00:00
|
|
|
int n;
|
2005-11-10 10:42:50 +00:00
|
|
|
|
2007-02-15 10:50:48 +00:00
|
|
|
header = 1;
|
2007-12-30 01:42:15 +00:00
|
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
|
|
|
if (p->p_state == PRS_NEW)
|
|
|
|
continue;
|
|
|
|
if ((fdp = p->p_fd) == NULL)
|
|
|
|
continue;
|
|
|
|
for (n = 0; n < fdp->fd_nfiles; ++n) {
|
|
|
|
if ((fp = fdp->fd_ofiles[n]) == NULL)
|
|
|
|
continue;
|
|
|
|
db_print_file(fp, header);
|
|
|
|
header = 0;
|
|
|
|
}
|
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
|
|
|
|
2008-03-19 09:58:25 +00:00
|
|
|
SYSCTL_INT(_kern, KERN_MAXFILES, maxfiles, CTLFLAG_RW,
|
|
|
|
&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,
|
2007-12-30 01:42:15 +00:00
|
|
|
__DEVOLATILE(int *, &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);
|
|
|
|
mtx_init(&sigio_lock, "sigio lock", NULL, MTX_DEF);
|
|
|
|
mtx_init(&fdesc_mtx, "fdesc", NULL, MTX_DEF);
|
|
|
|
}
|
2008-03-19 09:58:25 +00:00
|
|
|
SYSINIT(select, SI_SUB_LOCK, SI_ORDER_FIRST, filelistinit, NULL);
|
2004-12-01 09:42:35 +00:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------*/
|
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);
|
|
|
|
}
|
|
|
|
|
2008-01-07 20:05:19 +00:00
|
|
|
static int
|
|
|
|
badfo_truncate(struct file *fp, off_t length, struct ucred *active_cred, struct thread *td)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
|
1999-08-04 18:53:50 +00:00
|
|
|
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
|
|
|
{
|
|
|
|
|
2006-09-24 02:29:53 +00:00
|
|
|
return (EBADF);
|
2001-02-15 16:34:11 +00:00
|
|
|
}
|
|
|
|
|
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,
|
2008-01-07 20:05:19 +00:00
|
|
|
.fo_truncate = badfo_truncate,
|
2004-12-01 09:42:35 +00:00
|
|
|
.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_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");
|
|
|
|
}
|
|
|
|
|
2008-03-16 10:58:09 +00:00
|
|
|
SYSINIT(fildescdev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, fildesc_drvinit, NULL);
|