d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
a41992e8ea
freebsd-skq/sys/fs/pseudofs/pseudofs_vnops.c

1013 lines
22 KiB
C
Raw Normal View History

Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
/*-
* Copyright (c) 2001 Dag-Erling Co<EFBFBD>dan Sm<EFBFBD>rgrav
* All rights reserved.
*
* 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
* in this position and unchanged.
* 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
fbsdidize.
2005-03-14 15:54:11 +00:00
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "opt_pseudofs.h"
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/ctype.h>
#include <sys/dirent.h>
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
#include <sys/fcntl.h>
Introduce a uiomove_frombuf helper routine that handles computing and validating the offset within a given memory buffer before handing the real work off to uiomove(9). Use uiomove_frombuf in procfs to correct several issues with integer arithmetic that could result in underflows/overflows. As a side-effect, the code is significantly simplified. Add additional sanity checks when computing a memory allocation size in pfs_read. Submitted by: rwatson (original uiomove_frombuf -- bugs are mine :-) Reported by: Joost Pol <joost@pine.nl> (integer underflows/overflows)
2003-10-02 15:00:55 +00:00
#include <sys/limits.h>
For some reason, though the module builds just fine without <sys/lock.h>, LINT fails to build without it.
2001-06-11 15:04:48 +00:00
#include <sys/lock.h>
Fix two long-standing bugs in pfs_readdir(): Since we used an sbuf of size resid to accumulate dirents, we would end up returning one byte short when we had enough dirents to fill or exceed the size of the sbuf (the last byte being lost to bogus NUL termination) causing the next call to return EINVAL due to an unaligned offset. This went undetected for a long time because I did most of my testing in single-user mode, where there are rarely enough processes to fill the 4096-byte buffer ls(1) uses. The most common symptom of this bug is that tab completion of /proc or /compat/linux/proc does not work properly when many processes are running. Also, a check near the top would return EINVAL if resid was smaller than PFS_DELEN, even if it was 0, which is frequently the case and perfectly allowable. Change the test so that it returns 0 if resid is 0. MFC after: 2 weeks
2005-03-14 16:21:32 +00:00
#include <sys/malloc.h>
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
#include <sys/mount.h>
Blah, not my day. This file needs <sys/mutex.h> now.
2001-06-10 10:42:55 +00:00
#include <sys/mutex.h>
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
#include <sys/namei.h>
#include <sys/proc.h>
#include <sys/sbuf.h>
#include <sys/sx.h>
#include <sys/sysctl.h>
#include <sys/vnode.h>
#include <fs/pseudofs/pseudofs.h>
#include <fs/pseudofs/pseudofs_internal.h>
Fix an inverted KASSERT. Add similar assertions in other similar places. Reported by: Andrew Brampton <me@bramp.net> MFC after: 1 week
2009-04-07 16:13:10 +00:00
#define KASSERT_PN_IS_DIR(pn) \
KASSERT((pn)->pn_type == pfstype_root || \
(pn)->pn_type == pfstype_dir || \
(pn)->pn_type == pfstype_procdir, \
("%s(): VDIR vnode refers to non-directory pfs_node", __func__))
#define KASSERT_PN_IS_FILE(pn) \
KASSERT((pn)->pn_type == pfstype_file, \
("%s(): VREG vnode refers to non-file pfs_node", __func__))
#define KASSERT_PN_IS_LINK(pn) \
KASSERT((pn)->pn_type == pfstype_symlink, \
("%s(): VLNK vnode refers to non-link pfs_node", __func__))
Further pseudofs improvements: The pfs_info mutex is only needed to lock pi_unrhdr. Everything else in struct pfs_info is modified only while Giant is held (during vfs_init() / vfs_uninit()); add assertions to that effect. Simplify pfs_destroy somewhat. Remove superfluous arguments from pfs_fileno_{alloc,free}(), and the assertions which were added in the previous commit to ensure they were consistent. Assert that Giant is held while the vnode cache is initialized and destroyed. Also assert that the cache is empty when it is destroyed. Rename the vnode cache mutex for consistency. Fix a long-standing bug in pfs_getattr(): it would uncritically return the node's pn_fileno as st_ino. This would result in st_ino being 0 if the node had not previously been visited by readdir(), and also in an incorrect st_ino for process directories and any files contained therein. Correct this by abstracting the fileno manipulations previously done in pfs_readdir() into a new function, pfs_fileno(), which is used by both pfs_getattr() and pfs_readdir().
2007-04-14 14:08:30 +00:00
/*
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
* Returns the fileno, adjusted for target pid
Further pseudofs improvements: The pfs_info mutex is only needed to lock pi_unrhdr. Everything else in struct pfs_info is modified only while Giant is held (during vfs_init() / vfs_uninit()); add assertions to that effect. Simplify pfs_destroy somewhat. Remove superfluous arguments from pfs_fileno_{alloc,free}(), and the assertions which were added in the previous commit to ensure they were consistent. Assert that Giant is held while the vnode cache is initialized and destroyed. Also assert that the cache is empty when it is destroyed. Rename the vnode cache mutex for consistency. Fix a long-standing bug in pfs_getattr(): it would uncritically return the node's pn_fileno as st_ino. This would result in st_ino being 0 if the node had not previously been visited by readdir(), and also in an incorrect st_ino for process directories and any files contained therein. Correct this by abstracting the fileno manipulations previously done in pfs_readdir() into a new function, pfs_fileno(), which is used by both pfs_getattr() and pfs_readdir().
2007-04-14 14:08:30 +00:00
*/
static uint32_t
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pn_fileno(struct pfs_node *pn, pid_t pid)
Further pseudofs improvements: The pfs_info mutex is only needed to lock pi_unrhdr. Everything else in struct pfs_info is modified only while Giant is held (during vfs_init() / vfs_uninit()); add assertions to that effect. Simplify pfs_destroy somewhat. Remove superfluous arguments from pfs_fileno_{alloc,free}(), and the assertions which were added in the previous commit to ensure they were consistent. Assert that Giant is held while the vnode cache is initialized and destroyed. Also assert that the cache is empty when it is destroyed. Rename the vnode cache mutex for consistency. Fix a long-standing bug in pfs_getattr(): it would uncritically return the node's pn_fileno as st_ino. This would result in st_ino being 0 if the node had not previously been visited by readdir(), and also in an incorrect st_ino for process directories and any files contained therein. Correct this by abstracting the fileno manipulations previously done in pfs_readdir() into a new function, pfs_fileno(), which is used by both pfs_getattr() and pfs_readdir().
2007-04-14 14:08:30 +00:00
{
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
KASSERT(pn->pn_fileno > 0,
("%s(): no fileno allocated", __func__));
Further pseudofs improvements: The pfs_info mutex is only needed to lock pi_unrhdr. Everything else in struct pfs_info is modified only while Giant is held (during vfs_init() / vfs_uninit()); add assertions to that effect. Simplify pfs_destroy somewhat. Remove superfluous arguments from pfs_fileno_{alloc,free}(), and the assertions which were added in the previous commit to ensure they were consistent. Assert that Giant is held while the vnode cache is initialized and destroyed. Also assert that the cache is empty when it is destroyed. Rename the vnode cache mutex for consistency. Fix a long-standing bug in pfs_getattr(): it would uncritically return the node's pn_fileno as st_ino. This would result in st_ino being 0 if the node had not previously been visited by readdir(), and also in an incorrect st_ino for process directories and any files contained therein. Correct this by abstracting the fileno manipulations previously done in pfs_readdir() into a new function, pfs_fileno(), which is used by both pfs_getattr() and pfs_readdir().
2007-04-14 14:08:30 +00:00
if (pid != NO_PID)
return (pn->pn_fileno * NO_PID + pid);
return (pn->pn_fileno);
}
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
/*
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
* Returns non-zero if given file is visible to given thread.
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
*/
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
static int
pfs_visible_proc(struct thread *td, struct pfs_node *pn, struct proc *proc)
{
int visible;
if (proc == NULL)
return (0);
PROC_LOCK_ASSERT(proc, MA_OWNED);
visible = ((proc->p_flag & P_WEXIT) == 0);
if (visible)
visible = (p_cansee(td, proc) == 0);
if (visible && pn->pn_vis != NULL)
visible = pn_vis(td, proc, pn);
if (!visible)
return (0);
return (1);
}
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
static int
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
pfs_visible(struct thread *td, struct pfs_node *pn, pid_t pid, struct proc **p)
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
{
struct proc *proc;
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
PFS_TRACE(("%s (pid: %d, req: %d)",
pn->pn_name, pid, td->td_proc->p_pid));
Add a PFS_DISABLED flag; pfs_visible() automatically returns 0 if it is set on the node in question. Also add two API functions for setting and clearing this flag; setting it also reclaims all vnodes associated with the node.
2001-10-02 22:22:42 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (p)
*p = NULL;
if (pid == NO_PID)
PFS_RETURN (1);
if ((proc = pfind(pid)) == NULL)
Add a PFS_DISABLED flag; pfs_visible() automatically returns 0 if it is set on the node in question. Also add two API functions for setting and clearing this flag; setting it also reclaims all vnodes associated with the node.
2001-10-02 22:22:42 +00:00
PFS_RETURN (0);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (pfs_visible_proc(td, pn, proc)) {
if (p)
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
*p = proc;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
else
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
PROC_UNLOCK(proc);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PFS_RETURN (1);
}
PROC_UNLOCK(proc);
PFS_RETURN (0);
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
}
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
/*
* Verify permissions
*/
static int
pfs_access(struct vop_access_args *va)
{
struct vnode *vn = va->a_vp;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct pfs_vdata *pvd = vn->v_data;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
struct vattr vattr;
int error;
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PFS_TRACE(("%s", pvd->pvd_pn->pn_name));
Avoid "unused variable" warning when building without PSEUDOFS_TRACE.
2007-04-15 20:35:18 +00:00
(void)pvd;
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Decontextualize the couplet VOP_GETATTR / VOP_SETATTR as the passed thread was always curthread and totally unuseful. Tested by: Giovanni Trematerra <giovanni dot trematerra at gmail dot com>
2008-08-28 15:23:18 +00:00
error = VOP_GETATTR(vn, &vattr, va->a_cred);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
if (error)
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
PFS_RETURN (error);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
error = vaccess(vn->v_type, vattr.va_mode, vattr.va_uid,
Introduce accmode_t. This is required for NFSv4 ACLs - it will be neccessary to add more V* constants, and the variables changed by this patch were often being assigned to mode_t variables, which is 16 bit. Approved by: rwatson (mentor)
2008-10-28 13:44:11 +00:00
vattr.va_gid, va->a_accmode, va->a_cred, NULL);
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
PFS_RETURN (error);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
/*
* Close a file or directory
*/
static int
pfs_close(struct vop_close_args *va)
{
Add support for a last-close handler. Revert the module version bumps; they're quite pointless as long as the only pseudofs consumer is linprocfs, which is in the tree.
2001-11-27 13:26:27 +00:00
struct vnode *vn = va->a_vp;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct pfs_vdata *pvd = vn->v_data;
Add support for a last-close handler. Revert the module version bumps; they're quite pointless as long as the only pseudofs consumer is linprocfs, which is in the tree.
2001-11-27 13:26:27 +00:00
struct pfs_node *pn = pvd->pvd_pn;
struct proc *proc;
int error;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PFS_TRACE(("%s", pn->pn_name));
pfs_assert_not_owned(pn);
Add support for a last-close handler. Revert the module version bumps; they're quite pointless as long as the only pseudofs consumer is linprocfs, which is in the tree.
2001-11-27 13:26:27 +00:00
/*
* Do nothing unless this is the last close and the node has a
* last-close handler.
*/
- Use vrefcnt() where it is safe to do so instead of doing direct and unlocked accesses to v_usecount. - Lock access to the buf lists in the various sync routines. interlock locking could be avoided almost entirely in leaf filesystems if the fsync function had a generic helper.
2002-09-25 02:32:42 +00:00
if (vrefcnt(vn) > 1 || pn->pn_close == NULL)
Add support for a last-close handler. Revert the module version bumps; they're quite pointless as long as the only pseudofs consumer is linprocfs, which is in the tree.
2001-11-27 13:26:27 +00:00
PFS_RETURN (0);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (pvd->pvd_pid != NO_PID) {
Add support for a last-close handler. Revert the module version bumps; they're quite pointless as long as the only pseudofs consumer is linprocfs, which is in the tree.
2001-11-27 13:26:27 +00:00
proc = pfind(pvd->pvd_pid);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
} else {
Add support for a last-close handler. Revert the module version bumps; they're quite pointless as long as the only pseudofs consumer is linprocfs, which is in the tree.
2001-11-27 13:26:27 +00:00
proc = NULL;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
}
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
error = pn_close(va->a_td, proc, pn);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Add support for a last-close handler. Revert the module version bumps; they're quite pointless as long as the only pseudofs consumer is linprocfs, which is in the tree.
2001-11-27 13:26:27 +00:00
if (proc != NULL)
PROC_UNLOCK(proc);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Add support for a last-close handler. Revert the module version bumps; they're quite pointless as long as the only pseudofs consumer is linprocfs, which is in the tree.
2001-11-27 13:26:27 +00:00
PFS_RETURN (error);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
/*
* Get file attributes
*/
static int
pfs_getattr(struct vop_getattr_args *va)
{
struct vnode *vn = va->a_vp;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct pfs_vdata *pvd = vn->v_data;
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
struct pfs_node *pn = pvd->pvd_pn;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
struct vattr *vap = va->a_vap;
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
struct proc *proc;
int error = 0;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PFS_TRACE(("%s", pn->pn_name));
pfs_assert_not_owned(pn);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
Add pfs_visible() checks to pfs_getattr() and pfs_getextattr(). This also fixes pfs_access() since it relies on VOP_GETATTR() which will call pfs_getattr(). This prevents jailed processes from discovering the existence, start time and ownership of processes outside the jail. PR: kern/48156
2003-08-19 10:26:41 +00:00
PFS_RETURN (ENOENT);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
vap->va_type = vn->v_type;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
vap->va_fileid = pn_fileno(pn, pvd->pvd_pid);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
vap->va_flags = 0;
vap->va_blocksize = PAGE_SIZE;
vap->va_bytes = vap->va_size = 0;
fdescfs, devfs, mqueuefs, nfs, portalfs, pseudofs, tmpfs and xfs initialize the vattr structure in VOP_GETATTR() with VATTR_NULL(), vattr_null() or by zeroing it. Remove these to allow preinitialization of fields work in vn_stat(). This is needed to get birthtime initialized correctly. Submitted by: Jaakko Heinonen <jh saunalahti fi> Discussed on: freebsd-fs MFC after: 1 month
2008-09-20 19:50:52 +00:00
vap->va_filerev = 0;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
vap->va_fsid = vn->v_mount->mnt_stat.f_fsid.val[0];
vap->va_nlink = 1;
nanotime(&vap->va_ctime);
vap->va_atime = vap->va_mtime = vap->va_ctime;
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
switch (pn->pn_type) {
case pfstype_procdir:
case pfstype_root:
case pfstype_dir:
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
#if 0
pfs_lock(pn);
/* compute link count */
pfs_unlock(pn);
#endif
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
vap->va_mode = 0555;
break;
case pfstype_file:
case pfstype_symlink:
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
vap->va_mode = 0444;
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
break;
default:
printf("shouldn't be here!\n");
vap->va_mode = 0;
break;
}
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
if (proc != NULL) {
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
vap->va_uid = proc->p_ucred->cr_ruid;
vap->va_gid = proc->p_ucred->cr_rgid;
} else {
vap->va_uid = 0;
vap->va_gid = 0;
}
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Fix a logic bug that caused the pfs_attr method to be called only for PFS_PROCDEP nodes. Submitted by: Andrew Brampton <brampton@gmail.com> MFC after: 2 weeks
2009-02-16 15:17:26 +00:00
if (pn->pn_attr != NULL)
error = pn_attr(curthread, proc, pn, vap);
if(proc != NULL)
PROC_UNLOCK(proc);
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
PFS_RETURN (error);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
/*
* Perform an ioctl
*/
static int
pfs_ioctl(struct vop_ioctl_args *va)
{
VOP_IOCTL takes unlocked vnode as an argument. Due to this, v_data may be NULL or derefenced memory may become free at arbitrary moment. Lock the vnode in cd9660, devfs and pseudofs implementation of VOP_IOCTL to prevent reclaim; check whether the vnode was already reclaimed after the lock is granted. Reported by: georg at dts su Reviewed by: des (pseudofs) MFC after: 2 weeks
2009-06-10 13:57:36 +00:00
struct vnode *vn;
struct pfs_vdata *pvd;
struct pfs_node *pn;
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
struct proc *proc;
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
int error;
VOP_IOCTL takes unlocked vnode as an argument. Due to this, v_data may be NULL or derefenced memory may become free at arbitrary moment. Lock the vnode in cd9660, devfs and pseudofs implementation of VOP_IOCTL to prevent reclaim; check whether the vnode was already reclaimed after the lock is granted. Reported by: georg at dts su Reviewed by: des (pseudofs) MFC after: 2 weeks
2009-06-10 13:57:36 +00:00
vn = va->a_vp;
vn_lock(vn, LK_SHARED | LK_RETRY);
if (vn->v_iflag & VI_DOOMED) {
VOP_UNLOCK(vn, 0);
return (EBADF);
}
pvd = vn->v_data;
pn = pvd->pvd_pn;
Fix an incorrect PFS_TRACE. Also, use __func__ instead of __FUNCTION__.
2001-12-09 00:28:12 +00:00
PFS_TRACE(("%s: %lx", pn->pn_name, va->a_command));
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pfs_assert_not_owned(pn);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
VOP_IOCTL takes unlocked vnode as an argument. Due to this, v_data may be NULL or derefenced memory may become free at arbitrary moment. Lock the vnode in cd9660, devfs and pseudofs implementation of VOP_IOCTL to prevent reclaim; check whether the vnode was already reclaimed after the lock is granted. Reported by: georg at dts su Reviewed by: des (pseudofs) MFC after: 2 weeks
2009-06-10 13:57:36 +00:00
if (vn->v_type != VREG) {
VOP_UNLOCK(vn, 0);
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
PFS_RETURN (EINVAL);
VOP_IOCTL takes unlocked vnode as an argument. Due to this, v_data may be NULL or derefenced memory may become free at arbitrary moment. Lock the vnode in cd9660, devfs and pseudofs implementation of VOP_IOCTL to prevent reclaim; check whether the vnode was already reclaimed after the lock is granted. Reported by: georg at dts su Reviewed by: des (pseudofs) MFC after: 2 weeks
2009-06-10 13:57:36 +00:00
}
Fix an inverted KASSERT. Add similar assertions in other similar places. Reported by: Andrew Brampton <me@bramp.net> MFC after: 1 week
2009-04-07 16:13:10 +00:00
KASSERT_PN_IS_FILE(pn);
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
VOP_IOCTL takes unlocked vnode as an argument. Due to this, v_data may be NULL or derefenced memory may become free at arbitrary moment. Lock the vnode in cd9660, devfs and pseudofs implementation of VOP_IOCTL to prevent reclaim; check whether the vnode was already reclaimed after the lock is granted. Reported by: georg at dts su Reviewed by: des (pseudofs) MFC after: 2 weeks
2009-06-10 13:57:36 +00:00
if (pn->pn_ioctl == NULL) {
VOP_UNLOCK(vn, 0);
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
PFS_RETURN (ENOTTY);
VOP_IOCTL takes unlocked vnode as an argument. Due to this, v_data may be NULL or derefenced memory may become free at arbitrary moment. Lock the vnode in cd9660, devfs and pseudofs implementation of VOP_IOCTL to prevent reclaim; check whether the vnode was already reclaimed after the lock is granted. Reported by: georg at dts su Reviewed by: des (pseudofs) MFC after: 2 weeks
2009-06-10 13:57:36 +00:00
}
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
/*
fix grammar in comment
2003-06-20 23:29:04 +00:00
* This is necessary because process' privileges may
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
* have changed since the open() call.
*/
VOP_IOCTL takes unlocked vnode as an argument. Due to this, v_data may be NULL or derefenced memory may become free at arbitrary moment. Lock the vnode in cd9660, devfs and pseudofs implementation of VOP_IOCTL to prevent reclaim; check whether the vnode was already reclaimed after the lock is granted. Reported by: georg at dts su Reviewed by: des (pseudofs) MFC after: 2 weeks
2009-06-10 13:57:36 +00:00
if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc)) {
VOP_UNLOCK(vn, 0);
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
PFS_RETURN (EIO);
VOP_IOCTL takes unlocked vnode as an argument. Due to this, v_data may be NULL or derefenced memory may become free at arbitrary moment. Lock the vnode in cd9660, devfs and pseudofs implementation of VOP_IOCTL to prevent reclaim; check whether the vnode was already reclaimed after the lock is granted. Reported by: georg at dts su Reviewed by: des (pseudofs) MFC after: 2 weeks
2009-06-10 13:57:36 +00:00
}
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
error = pn_ioctl(curthread, proc, pn, va->a_command, va->a_data);
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
if (proc != NULL)
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PROC_UNLOCK(proc);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
VOP_IOCTL takes unlocked vnode as an argument. Due to this, v_data may be NULL or derefenced memory may become free at arbitrary moment. Lock the vnode in cd9660, devfs and pseudofs implementation of VOP_IOCTL to prevent reclaim; check whether the vnode was already reclaimed after the lock is granted. Reported by: georg at dts su Reviewed by: des (pseudofs) MFC after: 2 weeks
2009-06-10 13:57:36 +00:00
VOP_UNLOCK(vn, 0);
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
PFS_RETURN (error);
}
Add VOP_GETEXTATTR(9) passthrough support to pseudofs. Obtained from: TrustedBSD Project Sponsored by: DARPA, NAI Labs
2001-12-11 20:48:20 +00:00
/*
* Perform getextattr
*/
static int
pfs_getextattr(struct vop_getextattr_args *va)
{
struct vnode *vn = va->a_vp;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct pfs_vdata *pvd = vn->v_data;
Add VOP_GETEXTATTR(9) passthrough support to pseudofs. Obtained from: TrustedBSD Project Sponsored by: DARPA, NAI Labs
2001-12-11 20:48:20 +00:00
struct pfs_node *pn = pvd->pvd_pn;
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
struct proc *proc;
Add VOP_GETEXTATTR(9) passthrough support to pseudofs. Obtained from: TrustedBSD Project Sponsored by: DARPA, NAI Labs
2001-12-11 20:48:20 +00:00
int error;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PFS_TRACE(("%s", pn->pn_name));
pfs_assert_not_owned(pn);
Add VOP_GETEXTATTR(9) passthrough support to pseudofs. Obtained from: TrustedBSD Project Sponsored by: DARPA, NAI Labs
2001-12-11 20:48:20 +00:00
/*
* This is necessary because either process' privileges may
* have changed since the open() call.
*/
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
Add VOP_GETEXTATTR(9) passthrough support to pseudofs. Obtained from: TrustedBSD Project Sponsored by: DARPA, NAI Labs
2001-12-11 20:48:20 +00:00
PFS_RETURN (EIO);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (pn->pn_getextattr == NULL)
error = EOPNOTSUPP;
else
error = pn_getextattr(curthread, proc, pn,
va->a_attrnamespace, va->a_name, va->a_uio,
va->a_size, va->a_cred);
Add VOP_GETEXTATTR(9) passthrough support to pseudofs. Obtained from: TrustedBSD Project Sponsored by: DARPA, NAI Labs
2001-12-11 20:48:20 +00:00
if (proc != NULL)
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PROC_UNLOCK(proc);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Add VOP_GETEXTATTR(9) passthrough support to pseudofs. Obtained from: TrustedBSD Project Sponsored by: DARPA, NAI Labs
2001-12-11 20:48:20 +00:00
PFS_RETURN (error);
}
Add a VOP_VPTOCNP implementation for pseudofs which covers file systems such as procfs and linprocfs. This implementation's locking was enhanced by kib. Reviewed by: kib des Approved by: des kib Tested by: pho
2008-12-30 21:49:39 +00:00
/*
* Convert a vnode to its component name
*/
static int
pfs_vptocnp(struct vop_vptocnp_args *ap)
{
struct vnode *vp = ap->a_vp;
struct vnode **dvp = ap->a_vpp;
struct pfs_vdata *pvd = vp->v_data;
struct pfs_node *pd = pvd->pvd_pn;
struct pfs_node *pn;
struct mount *mp;
char *buf = ap->a_buf;
int *buflen = ap->a_buflen;
char pidbuf[PFS_NAMELEN];
pid_t pid = pvd->pvd_pid;
int len, i, error, locked;
i = *buflen;
error = 0;
pfs_lock(pd);
if (vp->v_type == VDIR && pd->pn_type == pfstype_root) {
*dvp = vp;
vhold(*dvp);
pfs_unlock(pd);
PFS_RETURN (0);
} else if (vp->v_type == VDIR && pd->pn_type == pfstype_procdir) {
len = snprintf(pidbuf, sizeof(pidbuf), "%d", pid);
i -= len;
if (i < 0) {
error = ENOMEM;
goto failed;
}
bcopy(pidbuf, buf + i, len);
} else {
Use a temporary variable to avoid a duplicate strlen(). Submitted by: kib MFC after: 1 week
2009-05-28 10:24:26 +00:00
len = strlen(pd->pn_name);
i -= len;
Add a VOP_VPTOCNP implementation for pseudofs which covers file systems such as procfs and linprocfs. This implementation's locking was enhanced by kib. Reviewed by: kib des Approved by: des kib Tested by: pho
2008-12-30 21:49:39 +00:00
if (i < 0) {
error = ENOMEM;
goto failed;
}
Use a temporary variable to avoid a duplicate strlen(). Submitted by: kib MFC after: 1 week
2009-05-28 10:24:26 +00:00
bcopy(pd->pn_name, buf + i, len);
Add a VOP_VPTOCNP implementation for pseudofs which covers file systems such as procfs and linprocfs. This implementation's locking was enhanced by kib. Reviewed by: kib des Approved by: des kib Tested by: pho
2008-12-30 21:49:39 +00:00
}
pn = pd->pn_parent;
pfs_unlock(pd);
mp = vp->v_mount;
error = vfs_busy(mp, 0);
if (error)
return (error);
/*
* vp is held by caller.
*/
locked = VOP_ISLOCKED(vp);
VOP_UNLOCK(vp, 0);
error = pfs_vncache_alloc(mp, dvp, pn, pid);
if (error) {
vn_lock(vp, locked | LK_RETRY);
vfs_unbusy(mp);
PFS_RETURN(error);
}
*buflen = i;
vhold(*dvp);
vput(*dvp);
vn_lock(vp, locked | LK_RETRY);
vfs_unbusy(mp);
PFS_RETURN (0);
failed:
pfs_unlock(pd);
PFS_RETURN(error);
}
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
/*
* Look up a file or directory
*/
static int
Hook pfs_lookup() up to vfs_cachedlookup_desc instead of vfs_lookup_desc, as suggested by Matt's comment. Also fix some style and paranoia issues. The entire function could benefit from review by a VFS guru. MFC after: 6 weeks
2005-03-14 16:24:50 +00:00
pfs_lookup(struct vop_cachedlookup_args *va)
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
{
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
struct vnode *vn = va->a_dvp;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
struct vnode **vpp = va->a_vpp;
struct componentname *cnp = va->a_cnp;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct pfs_vdata *pvd = vn->v_data;
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
struct pfs_node *pd = pvd->pvd_pn;
struct pfs_node *pn, *pdn = NULL;
pid_t pid = pvd->pvd_pid;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
char *pname;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
int error, i, namelen, visible;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
PFS_TRACE(("%.*s", (int)cnp->cn_namelen, cnp->cn_nameptr));
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pfs_assert_not_owned(pd);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
if (vn->v_type != VDIR)
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
PFS_RETURN (ENOTDIR);
Fix an inverted KASSERT. Add similar assertions in other similar places. Reported by: Andrew Brampton <me@bramp.net> MFC after: 1 week
2009-04-07 16:13:10 +00:00
KASSERT_PN_IS_DIR(pd);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Hook pfs_lookup() up to vfs_cachedlookup_desc instead of vfs_lookup_desc, as suggested by Matt's comment. Also fix some style and paranoia issues. The entire function could benefit from review by a VFS guru. MFC after: 6 weeks
2005-03-14 16:24:50 +00:00
error = VOP_ACCESS(vn, VEXEC, cnp->cn_cred, cnp->cn_thread);
if (error)
PFS_RETURN (error);
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
/*
* Don't support DELETE or RENAME. CREATE is supported so
* that O_CREAT will work, but the lookup will still fail if
* the file does not exist.
*/
Hook pfs_lookup() up to vfs_cachedlookup_desc instead of vfs_lookup_desc, as suggested by Matt's comment. Also fix some style and paranoia issues. The entire function could benefit from review by a VFS guru. MFC after: 6 weeks
2005-03-14 16:24:50 +00:00
if ((cnp->cn_flags & ISLASTCN) &&
(cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (EOPNOTSUPP);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
/* shortcut: check if the name is too long */
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
if (cnp->cn_namelen >= PFS_NAMELEN)
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
PFS_RETURN (ENOENT);
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
/* check that parent directory is visible... */
if (!pfs_visible(curthread, pd, pvd->pvd_pid, NULL))
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
PFS_RETURN (ENOENT);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
/* self */
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
namelen = cnp->cn_namelen;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
pname = cnp->cn_nameptr;
Hook pfs_lookup() up to vfs_cachedlookup_desc instead of vfs_lookup_desc, as suggested by Matt's comment. Also fix some style and paranoia issues. The entire function could benefit from review by a VFS guru. MFC after: 6 weeks
2005-03-14 16:24:50 +00:00
if (namelen == 1 && pname[0] == '.') {
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
pn = pd;
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
*vpp = vn;
VREF(vn);
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
PFS_RETURN (0);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
/* parent */
if (cnp->cn_flags & ISDOTDOT) {
if (pd->pn_type == pfstype_root)
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
PFS_RETURN (EIO);
VOP_LOCK1() (and so VOP_LOCK()) and VOP_UNLOCK() are only used in conjuction with 'thread' argument passing which is always curthread. Remove the unuseful extra-argument and pass explicitly curthread to lower layer functions, when necessary. KPI results broken by this change, which should affect several ports, so version bumping and manpage update will be further committed. Tested by: kris, pho, Diego Sardina <siarodx at gmail dot com>
2008-01-13 14:44:15 +00:00
VOP_UNLOCK(vn, 0);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
KASSERT(pd->pn_parent != NULL,
("%s(): non-root directory has no parent", __func__));
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
/*
* This one is tricky. Descendents of procdir nodes
* inherit their parent's process affinity, but
* there's no easy reverse mapping. For simplicity,
* we assume that if this node is a procdir, its
* parent isn't (which is correct as long as
* descendents of procdir nodes are never procdir
* nodes themselves)
*/
if (pd->pn_type == pfstype_procdir)
pid = NO_PID;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pfs_lock(pd);
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
pn = pd->pn_parent;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pfs_unlock(pd);
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
goto got_pnode;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pfs_lock(pd);
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
/* named node */
Switch to dynamic rather than static initialization. This makes it possible (in theory) for nodes to be added and / or removed from pseudofs filesystems at runtime.
2001-10-19 01:43:06 +00:00
for (pn = pd->pn_nodes; pn != NULL; pn = pn->pn_next)
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
if (pn->pn_type == pfstype_procdir)
pdn = pn;
Hook pfs_lookup() up to vfs_cachedlookup_desc instead of vfs_lookup_desc, as suggested by Matt's comment. Also fix some style and paranoia issues. The entire function could benefit from review by a VFS guru. MFC after: 6 weeks
2005-03-14 16:24:50 +00:00
else if (pn->pn_name[namelen] == '\0' &&
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
bcmp(pname, pn->pn_name, namelen) == 0) {
pfs_unlock(pd);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
goto got_pnode;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
}
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
/* process dependent node */
if ((pn = pdn) != NULL) {
pid = 0;
for (pid = 0, i = 0; i < namelen && isdigit(pname[i]); ++i)
if ((pid = pid * 10 + pname[i] - '0') > PID_MAX)
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
break;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (i == cnp->cn_namelen) {
pfs_unlock(pd);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
goto got_pnode;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
}
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pfs_unlock(pd);
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (ENOENT);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
got_pnode:
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pfs_assert_not_owned(pd);
pfs_assert_not_owned(pn);
Use the correct pid when checking to see whether or not the /proc/<pid> directory itself (rather than any of its contents) is visible to the current thread. MFC after: 1 week PR: kern/90063 Submitted by: john of 8192.net Approved by: re (kensmith)
2007-10-05 17:37:25 +00:00
visible = pfs_visible(curthread, pn, pid, NULL);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (!visible) {
- We no longer have to bother with PDIRUNLOCK, lookup() handles it for us. Sponsored by: Isilon Systems, Inc.
2005-03-28 09:34:36 +00:00
error = ENOENT;
goto failed;
}
Lock down pseudofs: - Initialize lock structure in vncache_alloc - Return locked vnodes from vncache_alloc - Setup vnode op vectors to use default lock, unlock, and islocked - Implement simple locking scheme required for lookup
2002-07-08 01:50:14 +00:00
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
error = pfs_vncache_alloc(vn->v_mount, vpp, pn, pid);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
if (error)
- We no longer have to bother with PDIRUNLOCK, lookup() handles it for us. Sponsored by: Isilon Systems, Inc.
2005-03-28 09:34:36 +00:00
goto failed;
Lock down pseudofs: - Initialize lock structure in vncache_alloc - Return locked vnodes from vncache_alloc - Setup vnode op vectors to use default lock, unlock, and islocked - Implement simple locking scheme required for lookup
2002-07-08 01:50:14 +00:00
- Change all filesystems and vfs_cache to relock the dvp once the child is locked in the ISDOTDOT case. Se vfs_lookup.c r1.79 for details. Sponsored by: Isilon Systems, Inc.
2005-04-13 10:59:09 +00:00
if (cnp->cn_flags & ISDOTDOT)
vn_lock() is currently only used with the 'curthread' passed as argument. Remove this argument and pass curthread directly to underlying VOP_LOCK1() VFS method. This modify makes the code cleaner and in particular remove an annoying dependence helping next lockmgr() cleanup. KPI results, obviously, changed. Manpage and FreeBSD_version will be updated through further commits. As a side note, would be valuable to say that next commits will address a similar cleanup about VFS methods, in particular vop_lock1 and vop_unlock. Tested by: Diego Sardina <siarodx at gmail dot com>, Andrea Di Pasquale <whyx dot it at gmail dot com>
2008-01-10 01:10:58 +00:00
vn_lock(vn, LK_EXCLUSIVE|LK_RETRY);
The cache_enter(9) function shall not be called for doomed dvp. Assert this. In the reported panic, vdestroy() fired the assertion "vp has namecache for ..", because pseudofs may end up doing cache_enter() with reclaimed dvp, after dotdot lookup temporary unlocked dvp. Similar problem exists in ufs_lookup() for "." lookup, when vnode lock needs to be upgraded. Verify that dvp is not reclaimed before calling cache_enter(). Reported and tested by: pho Reviewed by: kan MFC after: 2 weeks
2010-04-20 10:19:27 +00:00
if (cnp->cn_flags & MAKEENTRY && !(vn->v_iflag & VI_DOOMED))
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
cache_enter(vn, *vpp, cnp);
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
PFS_RETURN (0);
- We no longer have to bother with PDIRUNLOCK, lookup() handles it for us. Sponsored by: Isilon Systems, Inc.
2005-03-28 09:34:36 +00:00
failed:
if (cnp->cn_flags & ISDOTDOT)
vn_lock() is currently only used with the 'curthread' passed as argument. Remove this argument and pass curthread directly to underlying VOP_LOCK1() VFS method. This modify makes the code cleaner and in particular remove an annoying dependence helping next lockmgr() cleanup. KPI results, obviously, changed. Manpage and FreeBSD_version will be updated through further commits. As a side note, would be valuable to say that next commits will address a similar cleanup about VFS methods, in particular vop_lock1 and vop_unlock. Tested by: Diego Sardina <siarodx at gmail dot com>, Andrea Di Pasquale <whyx dot it at gmail dot com>
2008-01-10 01:10:58 +00:00
vn_lock(vn, LK_EXCLUSIVE|LK_RETRY);
- We no longer have to bother with PDIRUNLOCK, lookup() handles it for us. Sponsored by: Isilon Systems, Inc.
2005-03-28 09:34:36 +00:00
PFS_RETURN(error);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
/*
* Open a file or directory.
*/
static int
pfs_open(struct vop_open_args *va)
{
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
struct vnode *vn = va->a_vp;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct pfs_vdata *pvd = vn->v_data;
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
struct pfs_node *pn = pvd->pvd_pn;
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
int mode = va->a_mode;
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_TRACE(("%s (mode 0x%x)", pn->pn_name, mode));
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pfs_assert_not_owned(pn);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
/* check if the requested mode is permitted */
if (((mode & FREAD) && !(mode & PFS_RD)) ||
((mode & FWRITE) && !(mode & PFS_WR)))
PFS_RETURN (EPERM);
/* we don't support locking */
if ((mode & O_SHLOCK) || (mode & O_EXLOCK))
PFS_RETURN (EOPNOTSUPP);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
PFS_RETURN (0);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
/*
* Read from a file
*/
static int
pfs_read(struct vop_read_args *va)
{
struct vnode *vn = va->a_vp;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct pfs_vdata *pvd = vn->v_data;
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
struct pfs_node *pn = pvd->pvd_pn;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
struct uio *uio = va->a_uio;
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
struct proc *proc;
Catch up with the change in sbuf_new's prototype.
2001-06-10 10:34:21 +00:00
struct sbuf *sb = NULL;
Drop the pseudofs vnode lock around call to pfs_read handler. The handler may need to lock arbitrary vnodes, causing either lock order reversal or recursive vnode lock acquisition. Tested by: pho Approved by: des MFC after: 2 weeks
2008-12-29 12:12:23 +00:00
int error, locked;
Introduce a uiomove_frombuf helper routine that handles computing and validating the offset within a given memory buffer before handing the real work off to uiomove(9). Use uiomove_frombuf in procfs to correct several issues with integer arithmetic that could result in underflows/overflows. As a side-effect, the code is significantly simplified. Add additional sanity checks when computing a memory allocation size in pfs_read. Submitted by: rwatson (original uiomove_frombuf -- bugs are mine :-) Reported by: Joost Pol <joost@pine.nl> (integer underflows/overflows)
2003-10-02 15:00:55 +00:00
unsigned int buflen, offset, resid;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PFS_TRACE(("%s", pn->pn_name));
pfs_assert_not_owned(pn);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
if (vn->v_type != VREG)
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (EINVAL);
Fix an inverted KASSERT. Add similar assertions in other similar places. Reported by: Andrew Brampton <me@bramp.net> MFC after: 1 week
2009-04-07 16:13:10 +00:00
KASSERT_PN_IS_FILE(pn);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
if (!(pn->pn_flags & PFS_RD))
PFS_RETURN (EBADF);
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (pn->pn_fill == NULL)
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
PFS_RETURN (EIO);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
/*
* This is necessary because either process' privileges may
* have changed since the open() call.
*/
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
PFS_RETURN (EIO);
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
if (proc != NULL) {
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
_PHOLD(proc);
PROC_UNLOCK(proc);
}
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
Drop the pseudofs vnode lock around call to pfs_read handler. The handler may need to lock arbitrary vnodes, causing either lock order reversal or recursive vnode lock acquisition. Tested by: pho Approved by: des MFC after: 2 weeks
2008-12-29 12:12:23 +00:00
vhold(vn);
locked = VOP_ISLOCKED(vn);
VOP_UNLOCK(vn, 0);
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
if (pn->pn_flags & PFS_RAWRD) {
Change the type of uio_resid member of struct uio from int to ssize_t. Note that this does not actually enable full-range i/o requests for 64 architectures, and is done now to update KBI only. Tested by: pho Reviewed by: jhb, bde (as part of the review of the bigger patch)
2009-06-25 18:46:30 +00:00
PFS_TRACE(("%zd resid", uio->uio_resid));
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
error = pn_fill(curthread, proc, pn, NULL, uio);
Change the type of uio_resid member of struct uio from int to ssize_t. Note that this does not actually enable full-range i/o requests for 64 architectures, and is done now to update KBI only. Tested by: pho Reviewed by: jhb, bde (as part of the review of the bigger patch)
2009-06-25 18:46:30 +00:00
PFS_TRACE(("%zd resid", uio->uio_resid));
Drop the pseudofs vnode lock around call to pfs_read handler. The handler may need to lock arbitrary vnodes, causing either lock order reversal or recursive vnode lock acquisition. Tested by: pho Approved by: des MFC after: 2 weeks
2008-12-29 12:12:23 +00:00
goto ret;
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
}
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
/* beaucoup sanity checks so we don't ask for bogus allocation */
Introduce a uiomove_frombuf helper routine that handles computing and validating the offset within a given memory buffer before handing the real work off to uiomove(9). Use uiomove_frombuf in procfs to correct several issues with integer arithmetic that could result in underflows/overflows. As a side-effect, the code is significantly simplified. Add additional sanity checks when computing a memory allocation size in pfs_read. Submitted by: rwatson (original uiomove_frombuf -- bugs are mine :-) Reported by: Joost Pol <joost@pine.nl> (integer underflows/overflows)
2003-10-02 15:00:55 +00:00
if (uio->uio_offset < 0 || uio->uio_resid < 0 ||
(offset = uio->uio_offset) != uio->uio_offset ||
(resid = uio->uio_resid) != uio->uio_resid ||
Correctly calculate a buffer length. It was off by one so a read() returned one byte less than needed. This is a RELENG_x_y candidate, since it fixes a problem with Oracle 10. Noticed by: Dmitry Ganenko <dima@apk-inform.com> Testcase by: Dmitry Ganenko <dima@apk-inform.com> Reviewed by: des Submitted by: rdivacky Sponsored by: Google SoC 2006 MFC after: 1 week
2006-06-27 20:21:38 +00:00
(buflen = offset + resid + 1) < offset || buflen > INT_MAX) {
Introduce a uiomove_frombuf helper routine that handles computing and validating the offset within a given memory buffer before handing the real work off to uiomove(9). Use uiomove_frombuf in procfs to correct several issues with integer arithmetic that could result in underflows/overflows. As a side-effect, the code is significantly simplified. Add additional sanity checks when computing a memory allocation size in pfs_read. Submitted by: rwatson (original uiomove_frombuf -- bugs are mine :-) Reported by: Joost Pol <joost@pine.nl> (integer underflows/overflows)
2003-10-02 15:00:55 +00:00
if (proc != NULL)
PRELE(proc);
Drop the pseudofs vnode lock around call to pfs_read handler. The handler may need to lock arbitrary vnodes, causing either lock order reversal or recursive vnode lock acquisition. Tested by: pho Approved by: des MFC after: 2 weeks
2008-12-29 12:12:23 +00:00
error = EINVAL;
goto ret;
Introduce a uiomove_frombuf helper routine that handles computing and validating the offset within a given memory buffer before handing the real work off to uiomove(9). Use uiomove_frombuf in procfs to correct several issues with integer arithmetic that could result in underflows/overflows. As a side-effect, the code is significantly simplified. Add additional sanity checks when computing a memory allocation size in pfs_read. Submitted by: rwatson (original uiomove_frombuf -- bugs are mine :-) Reported by: Joost Pol <joost@pine.nl> (integer underflows/overflows)
2003-10-02 15:00:55 +00:00
}
Truncate read request rather than returning EIO if the request is larger than MAXPHYS + 1. This fixes a problem with cat(1) when it uses a large I/O buffer. Reported by: Fernando Apesteguía Suggested by: jilles Reviewed by: des Approved by: trasz (mentor)
2010-01-22 08:45:12 +00:00
if (buflen > MAXPHYS + 1)
buflen = MAXPHYS + 1;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
Introduce a uiomove_frombuf helper routine that handles computing and validating the offset within a given memory buffer before handing the real work off to uiomove(9). Use uiomove_frombuf in procfs to correct several issues with integer arithmetic that could result in underflows/overflows. As a side-effect, the code is significantly simplified. Add additional sanity checks when computing a memory allocation size in pfs_read. Submitted by: rwatson (original uiomove_frombuf -- bugs are mine :-) Reported by: Joost Pol <joost@pine.nl> (integer underflows/overflows)
2003-10-02 15:00:55 +00:00
sb = sbuf_new(sb, NULL, buflen, 0);
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
if (sb == NULL) {
Drop the pseudofs vnode lock around call to pfs_read handler. The handler may need to lock arbitrary vnodes, causing either lock order reversal or recursive vnode lock acquisition. Tested by: pho Approved by: des MFC after: 2 weeks
2008-12-29 12:12:23 +00:00
error = EIO;
goto ret;
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
}
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
error = pn_fill(curthread, proc, pn, sb, uio);
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
Bail out if the fill function failed.
2001-06-10 21:39:01 +00:00
if (error) {
sbuf_delete(sb);
Drop the pseudofs vnode lock around call to pfs_read handler. The handler may need to lock arbitrary vnodes, causing either lock order reversal or recursive vnode lock acquisition. Tested by: pho Approved by: des MFC after: 2 weeks
2008-12-29 12:12:23 +00:00
goto ret;
Bail out if the fill function failed.
2001-06-10 21:39:01 +00:00
}
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Catch up with the change in sbuf_new's prototype.
2001-06-10 10:34:21 +00:00
sbuf_finish(sb);
Introduce a uiomove_frombuf helper routine that handles computing and validating the offset within a given memory buffer before handing the real work off to uiomove(9). Use uiomove_frombuf in procfs to correct several issues with integer arithmetic that could result in underflows/overflows. As a side-effect, the code is significantly simplified. Add additional sanity checks when computing a memory allocation size in pfs_read. Submitted by: rwatson (original uiomove_frombuf -- bugs are mine :-) Reported by: Joost Pol <joost@pine.nl> (integer underflows/overflows)
2003-10-02 15:00:55 +00:00
error = uiomove_frombuf(sbuf_data(sb), sbuf_len(sb), uio);
Catch up with the change in sbuf_new's prototype.
2001-06-10 10:34:21 +00:00
sbuf_delete(sb);
Drop the pseudofs vnode lock around call to pfs_read handler. The handler may need to lock arbitrary vnodes, causing either lock order reversal or recursive vnode lock acquisition. Tested by: pho Approved by: des MFC after: 2 weeks
2008-12-29 12:12:23 +00:00
ret:
vn_lock(vn, locked | LK_RETRY);
vdrop(vn);
if (proc != NULL)
PRELE(proc);
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (error);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
/*
* Iterate through directory entries
*/
static int
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pfs_iterate(struct thread *td, struct proc *proc, struct pfs_node *pd,
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
struct pfs_node **pn, struct proc **p)
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
{
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
int visible;
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
sx_assert(&allproc_lock, SX_SLOCKED);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pfs_assert_owned(pd);
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
again:
Rework pfs_iterate() a bit to eliminate a bug related to process directories. Previously, pfs_iterate() would return -1 when it reached the end of the process list while processing a process directory node, even if the parent directory contained further nodes (which is the case for the linprocfs root directory, where the process directory node is actually first in the list). With this patch, pfs_iterate() will continue to traverse the parent directory's node list after exhausting the process list (as was the intention all along). The code should hopefully be easier to read as well. While I'm here, have pfs_iterate() assert that the allproc lock is held.
2003-08-18 13:36:09 +00:00
if (*pn == NULL) {
/* first node */
*pn = pd->pn_nodes;
} else if ((*pn)->pn_type != pfstype_procdir) {
/* next node */
Switch to dynamic rather than static initialization. This makes it possible (in theory) for nodes to be added and / or removed from pseudofs filesystems at runtime.
2001-10-19 01:43:06 +00:00
*pn = (*pn)->pn_next;
Rework pfs_iterate() a bit to eliminate a bug related to process directories. Previously, pfs_iterate() would return -1 when it reached the end of the process list while processing a process directory node, even if the parent directory contained further nodes (which is the case for the linprocfs root directory, where the process directory node is actually first in the list). With this patch, pfs_iterate() will continue to traverse the parent directory's node list after exhausting the process list (as was the intention all along). The code should hopefully be easier to read as well. While I'm here, have pfs_iterate() assert that the allproc lock is held.
2003-08-18 13:36:09 +00:00
}
if (*pn != NULL && (*pn)->pn_type == pfstype_procdir) {
/* next process */
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
if (*p == NULL)
*p = LIST_FIRST(&allproc);
else
*p = LIST_NEXT(*p, p_list);
Rework pfs_iterate() a bit to eliminate a bug related to process directories. Previously, pfs_iterate() would return -1 when it reached the end of the process list while processing a process directory node, even if the parent directory contained further nodes (which is the case for the linprocfs root directory, where the process directory node is actually first in the list). With this patch, pfs_iterate() will continue to traverse the parent directory's node list after exhausting the process list (as was the intention all along). The code should hopefully be easier to read as well. While I'm here, have pfs_iterate() assert that the allproc lock is held.
2003-08-18 13:36:09 +00:00
/* out of processes: next node */
if (*p == NULL)
*pn = (*pn)->pn_next;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
else
PROC_LOCK(*p);
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
}
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Switch to dynamic rather than static initialization. This makes it possible (in theory) for nodes to be added and / or removed from pseudofs filesystems at runtime.
2001-10-19 01:43:06 +00:00
if ((*pn) == NULL)
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
return (-1);
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (*p != NULL) {
visible = pfs_visible_proc(td, *pn, *p);
PROC_UNLOCK(*p);
} else if (proc != NULL) {
visible = pfs_visible_proc(td, *pn, proc);
} else {
visible = 1;
}
if (!visible)
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
goto again;
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
return (0);
}
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
/*
* Return directory entries.
*/
static int
pfs_readdir(struct vop_readdir_args *va)
{
struct vnode *vn = va->a_vp;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct pfs_vdata *pvd = vn->v_data;
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
struct pfs_node *pd = pvd->pvd_pn;
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
pid_t pid = pvd->pvd_pid;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct proc *p, *proc;
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
struct pfs_node *pn;
Eliminate an unnecessary bcopy().
2005-08-12 12:22:05 +00:00
struct dirent *entry;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
struct uio *uio;
off_t offset;
int error, i, resid;
Fix two long-standing bugs in pfs_readdir(): Since we used an sbuf of size resid to accumulate dirents, we would end up returning one byte short when we had enough dirents to fill or exceed the size of the sbuf (the last byte being lost to bogus NUL termination) causing the next call to return EINVAL due to an unaligned offset. This went undetected for a long time because I did most of my testing in single-user mode, where there are rarely enough processes to fill the 4096-byte buffer ls(1) uses. The most common symptom of this bug is that tab completion of /proc or /compat/linux/proc does not work properly when many processes are running. Also, a check near the top would return EINVAL if resid was smaller than PFS_DELEN, even if it was 0, which is frequently the case and perfectly allowable. Change the test so that it returns 0 if resid is 0. MFC after: 2 weeks
2005-03-14 16:21:32 +00:00
char *buf, *ent;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
Further pseudofs improvements: The pfs_info mutex is only needed to lock pi_unrhdr. Everything else in struct pfs_info is modified only while Giant is held (during vfs_init() / vfs_uninit()); add assertions to that effect. Simplify pfs_destroy somewhat. Remove superfluous arguments from pfs_fileno_{alloc,free}(), and the assertions which were added in the previous commit to ensure they were consistent. Assert that Giant is held while the vnode cache is initialized and destroyed. Also assert that the cache is empty when it is destroyed. Rename the vnode cache mutex for consistency. Fix a long-standing bug in pfs_getattr(): it would uncritically return the node's pn_fileno as st_ino. This would result in st_ino being 0 if the node had not previously been visited by readdir(), and also in an incorrect st_ino for process directories and any files contained therein. Correct this by abstracting the fileno manipulations previously done in pfs_readdir() into a new function, pfs_fileno(), which is used by both pfs_getattr() and pfs_readdir().
2007-04-14 14:08:30 +00:00
KASSERT(pd->pn_info == vn->v_mount->mnt_data,
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
("%s(): pn_info does not match mountpoint", __func__));
PFS_TRACE(("%s pid %lu", pd->pn_name, (unsigned long)pid));
pfs_assert_not_owned(pd);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
if (vn->v_type != VDIR)
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (ENOTDIR);
Fix an inverted KASSERT. Add similar assertions in other similar places. Reported by: Andrew Brampton <me@bramp.net> MFC after: 1 week
2009-04-07 16:13:10 +00:00
KASSERT_PN_IS_DIR(pd);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
uio = va->a_uio;
/* only allow reading entire entries */
offset = uio->uio_offset;
resid = uio->uio_resid;
Fix two long-standing bugs in pfs_readdir(): Since we used an sbuf of size resid to accumulate dirents, we would end up returning one byte short when we had enough dirents to fill or exceed the size of the sbuf (the last byte being lost to bogus NUL termination) causing the next call to return EINVAL due to an unaligned offset. This went undetected for a long time because I did most of my testing in single-user mode, where there are rarely enough processes to fill the 4096-byte buffer ls(1) uses. The most common symptom of this bug is that tab completion of /proc or /compat/linux/proc does not work properly when many processes are running. Also, a check near the top would return EINVAL if resid was smaller than PFS_DELEN, even if it was 0, which is frequently the case and perfectly allowable. Change the test so that it returns 0 if resid is 0. MFC after: 2 weeks
2005-03-14 16:21:32 +00:00
if (offset < 0 || offset % PFS_DELEN != 0 ||
(resid && resid < PFS_DELEN))
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (EINVAL);
Fix two long-standing bugs in pfs_readdir(): Since we used an sbuf of size resid to accumulate dirents, we would end up returning one byte short when we had enough dirents to fill or exceed the size of the sbuf (the last byte being lost to bogus NUL termination) causing the next call to return EINVAL due to an unaligned offset. This went undetected for a long time because I did most of my testing in single-user mode, where there are rarely enough processes to fill the 4096-byte buffer ls(1) uses. The most common symptom of this bug is that tab completion of /proc or /compat/linux/proc does not work properly when many processes are running. Also, a check near the top would return EINVAL if resid was smaller than PFS_DELEN, even if it was 0, which is frequently the case and perfectly allowable. Change the test so that it returns 0 if resid is 0. MFC after: 2 weeks
2005-03-14 16:21:32 +00:00
if (resid == 0)
PFS_RETURN (0);
Accumulate directory entries in a fixed-length sbuf, and uiomove them in one go before returning. This avoids calling uiomove() while holding allproc_lock. Don't adjust uio->uio_offset manually, uiomove() does that for us. Don't drop allproc_lock before calling panic(). Suggested by: alfred
2004-07-09 11:43:37 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
/* can't do this while holding the proc lock... */
buf = malloc(resid, M_IOV, M_WAITOK | M_ZERO);
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
sx_slock(&allproc_lock);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
pfs_lock(pd);
/* check if the directory is visible to the caller */
if (!pfs_visible(curthread, pd, pid, &proc)) {
sx_sunlock(&allproc_lock);
pfs_unlock(pd);
free(buf, M_IOV);
PFS_RETURN (ENOENT);
}
KASSERT(pid == NO_PID || proc != NULL,
("%s(): no process for pid %lu", __func__, (unsigned long)pid));
/* skip unwanted entries */
for (pn = NULL, p = NULL; offset > 0; offset -= PFS_DELEN) {
if (pfs_iterate(curthread, proc, pd, &pn, &p) == -1) {
Switch to dynamic rather than static initialization. This makes it possible (in theory) for nodes to be added and / or removed from pseudofs filesystems at runtime.
2001-10-19 01:43:06 +00:00
/* nothing left... */
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (proc != NULL)
PROC_UNLOCK(proc);
pfs_unlock(pd);
Switch to dynamic rather than static initialization. This makes it possible (in theory) for nodes to be added and / or removed from pseudofs filesystems at runtime.
2001-10-19 01:43:06 +00:00
sx_sunlock(&allproc_lock);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
free(buf, M_IOV);
Switch to dynamic rather than static initialization. This makes it possible (in theory) for nodes to be added and / or removed from pseudofs filesystems at runtime.
2001-10-19 01:43:06 +00:00
PFS_RETURN (0);
}
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
}
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
/* fill in entries */
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
ent = buf;
while (pfs_iterate(curthread, proc, pd, &pn, &p) != -1 &&
Fix two long-standing bugs in pfs_readdir(): Since we used an sbuf of size resid to accumulate dirents, we would end up returning one byte short when we had enough dirents to fill or exceed the size of the sbuf (the last byte being lost to bogus NUL termination) causing the next call to return EINVAL due to an unaligned offset. This went undetected for a long time because I did most of my testing in single-user mode, where there are rarely enough processes to fill the 4096-byte buffer ls(1) uses. The most common symptom of this bug is that tab completion of /proc or /compat/linux/proc does not work properly when many processes are running. Also, a check near the top would return EINVAL if resid was smaller than PFS_DELEN, even if it was 0, which is frequently the case and perfectly allowable. Change the test so that it returns 0 if resid is 0. MFC after: 2 weeks
2005-03-14 16:21:32 +00:00
resid >= PFS_DELEN) {
Eliminate an unnecessary bcopy().
2005-08-12 12:22:05 +00:00
entry = (struct dirent *)ent;
entry->d_reclen = PFS_DELEN;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
entry->d_fileno = pn_fileno(pn, pid);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
/* PFS_DELEN was picked to fit PFS_NAMLEN */
for (i = 0; i < PFS_NAMELEN - 1 && pn->pn_name[i] != '\0'; ++i)
Eliminate an unnecessary bcopy().
2005-08-12 12:22:05 +00:00
entry->d_name[i] = pn->pn_name[i];
entry->d_name[i] = 0;
entry->d_namlen = i;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
switch (pn->pn_type) {
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
case pfstype_procdir:
KASSERT(p != NULL,
("reached procdir node with p == NULL"));
Eliminate an unnecessary bcopy().
2005-08-12 12:22:05 +00:00
entry->d_namlen = snprintf(entry->d_name,
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
PFS_NAMELEN, "%d", p->p_pid);
/* fall through */
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
case pfstype_root:
case pfstype_dir:
case pfstype_this:
case pfstype_parent:
Eliminate an unnecessary bcopy().
2005-08-12 12:22:05 +00:00
entry->d_type = DT_DIR;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
break;
case pfstype_file:
Eliminate an unnecessary bcopy().
2005-08-12 12:22:05 +00:00
entry->d_type = DT_REG;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
break;
case pfstype_symlink:
Eliminate an unnecessary bcopy().
2005-08-12 12:22:05 +00:00
entry->d_type = DT_LNK;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
break;
default:
panic("%s has unexpected node type: %d", pn->pn_name, pn->pn_type);
}
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PFS_TRACE(("%s", entry->d_name));
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
offset += PFS_DELEN;
resid -= PFS_DELEN;
Fix two long-standing bugs in pfs_readdir(): Since we used an sbuf of size resid to accumulate dirents, we would end up returning one byte short when we had enough dirents to fill or exceed the size of the sbuf (the last byte being lost to bogus NUL termination) causing the next call to return EINVAL due to an unaligned offset. This went undetected for a long time because I did most of my testing in single-user mode, where there are rarely enough processes to fill the 4096-byte buffer ls(1) uses. The most common symptom of this bug is that tab completion of /proc or /compat/linux/proc does not work properly when many processes are running. Also, a check near the top would return EINVAL if resid was smaller than PFS_DELEN, even if it was 0, which is frequently the case and perfectly allowable. Change the test so that it returns 0 if resid is 0. MFC after: 2 weeks
2005-03-14 16:21:32 +00:00
ent += PFS_DELEN;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (proc != NULL)
PROC_UNLOCK(proc);
pfs_unlock(pd);
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
sx_sunlock(&allproc_lock);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PFS_TRACE(("%zd bytes", ent - buf));
Fix two long-standing bugs in pfs_readdir(): Since we used an sbuf of size resid to accumulate dirents, we would end up returning one byte short when we had enough dirents to fill or exceed the size of the sbuf (the last byte being lost to bogus NUL termination) causing the next call to return EINVAL due to an unaligned offset. This went undetected for a long time because I did most of my testing in single-user mode, where there are rarely enough processes to fill the 4096-byte buffer ls(1) uses. The most common symptom of this bug is that tab completion of /proc or /compat/linux/proc does not work properly when many processes are running. Also, a check near the top would return EINVAL if resid was smaller than PFS_DELEN, even if it was 0, which is frequently the case and perfectly allowable. Change the test so that it returns 0 if resid is 0. MFC after: 2 weeks
2005-03-14 16:21:32 +00:00
error = uiomove(buf, ent - buf, uio);
free(buf, M_IOV);
Accumulate directory entries in a fixed-length sbuf, and uiomove them in one go before returning. This avoids calling uiomove() while holding allproc_lock. Don't adjust uio->uio_offset manually, uiomove() does that for us. Don't drop allproc_lock before calling panic(). Suggested by: alfred
2004-07-09 11:43:37 +00:00
PFS_RETURN (error);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
/*
* Read a symbolic link
*/
static int
pfs_readlink(struct vop_readlink_args *va)
{
struct vnode *vn = va->a_vp;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct pfs_vdata *pvd = vn->v_data;
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
struct pfs_node *pn = pvd->pvd_pn;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
struct uio *uio = va->a_uio;
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
struct proc *proc = NULL;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
char buf[PATH_MAX];
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
struct sbuf sb;
Unlock the pseudofs vnode before calling fill method for pfs_readlink(). The fill code may need to lock another vnode, e.g. procfs file implementation. Reviewed by: des Tested by: pho MFC after: 2 weeks
2009-05-31 15:01:50 +00:00
int error, locked;
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PFS_TRACE(("%s", pn->pn_name));
pfs_assert_not_owned(pn);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
if (vn->v_type != VLNK)
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (EINVAL);
Fix an inverted KASSERT. Add similar assertions in other similar places. Reported by: Andrew Brampton <me@bramp.net> MFC after: 1 week
2009-04-07 16:13:10 +00:00
KASSERT_PN_IS_LINK(pn);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (pn->pn_fill == NULL)
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
PFS_RETURN (EIO);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
if (pvd->pvd_pid != NO_PID) {
if ((proc = pfind(pvd->pvd_pid)) == NULL)
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (EIO);
Close some races between procfs/ptrace and exit(2): - Reorder the events in exit(2) slightly so that we trigger the S_EXIT stop event earlier. After we have signalled that, we set P_WEXIT and then wait for any processes with a hold on the vmspace via PHOLD to release it. PHOLD now KASSERT()'s that P_WEXIT is clear when it is invoked, and PRELE now does a wakeup if P_WEXIT is set and p_lock drops to zero. - Change proc_rwmem() to require that the processing read from has its vmspace held via PHOLD by the caller and get rid of all the junk to screw around with the vmspace reference count as we no longer need it. - In ptrace() and pseudofs(), treat a process with P_WEXIT set as if it doesn't exist. - Only do one PHOLD in kern_ptrace() now, and do it earlier so it covers FIX_SSTEP() (since on alpha at least this can end up calling proc_rwmem() to clear an earlier single-step simualted via a breakpoint). We only do one to avoid races. Also, by making the EINVAL error for unknown requests be part of the default: case in the switch, the various switch cases can now just break out to return which removes a _lot_ of duplicated PRELE and proc unlocks, etc. Also, it fixes at least one bug where a LWP ptrace command could return EINVAL with the proc lock still held. - Changed the locking for ptrace_single_step(), ptrace_set_pc(), and ptrace_clear_single_step() to always be called with the proc lock held (it was a mixed bag previously). Alpha and arm have to drop the lock while the mess around with breakpoints, but other archs avoid extra lock release/acquires in ptrace(). I did have to fix a couple of other consumers in kern_kse and a few other places to hold the proc lock and PHOLD. Tested by: ps (1 mostly, but some bits of 2-4 as well) MFC after: 1 week
2006-02-22 18:57:50 +00:00
if (proc->p_flag & P_WEXIT) {
PROC_UNLOCK(proc);
PFS_RETURN (EIO);
}
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
_PHOLD(proc);
PROC_UNLOCK(proc);
}
Unlock the pseudofs vnode before calling fill method for pfs_readlink(). The fill code may need to lock another vnode, e.g. procfs file implementation. Reviewed by: des Tested by: pho MFC after: 2 weeks
2009-05-31 15:01:50 +00:00
vhold(vn);
locked = VOP_ISLOCKED(vn);
VOP_UNLOCK(vn, 0);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
/* sbuf_new() can't fail with a static buffer */
sbuf_new(&sb, buf, sizeof buf, 0);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
error = pn_fill(curthread, proc, pn, &sb, NULL);
Add support for process-dependent directories. This means that save for the lack of a man page, pseudofs is mostly complete now.
2001-06-10 18:39:21 +00:00
if (proc != NULL)
PRELE(proc);
Unlock the pseudofs vnode before calling fill method for pfs_readlink(). The fill code may need to lock another vnode, e.g. procfs file implementation. Reviewed by: des Tested by: pho MFC after: 2 weeks
2009-05-31 15:01:50 +00:00
vn_lock(vn, locked | LK_RETRY);
vdrop(vn);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Bail out if the fill function failed.
2001-06-10 21:39:01 +00:00
if (error) {
sbuf_delete(&sb);
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (error);
Bail out if the fill function failed.
2001-06-10 21:39:01 +00:00
}
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
sbuf_finish(&sb);
Introduce a uiomove_frombuf helper routine that handles computing and validating the offset within a given memory buffer before handing the real work off to uiomove(9). Use uiomove_frombuf in procfs to correct several issues with integer arithmetic that could result in underflows/overflows. As a side-effect, the code is significantly simplified. Add additional sanity checks when computing a memory allocation size in pfs_read. Submitted by: rwatson (original uiomove_frombuf -- bugs are mine :-) Reported by: Joost Pol <joost@pine.nl> (integer underflows/overflows)
2003-10-02 15:00:55 +00:00
error = uiomove_frombuf(sbuf_data(&sb), sbuf_len(&sb), uio);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
sbuf_delete(&sb);
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (error);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
/*
* Reclaim a vnode
*/
static int
pfs_reclaim(struct vop_reclaim_args *va)
{
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct vnode *vn = va->a_vp;
struct pfs_vdata *pvd = vn->v_data;
struct pfs_node *pn = pvd->pvd_pn;
PFS_TRACE(("%s", pn->pn_name));
pfs_assert_not_owned(pn);
Pseudofs was leaking VFS cache entries badly due to its cache and use of the wrong VOP descriptor. This misuse caused VFS-cached vnodes to be re-cached, resulting in the leak. This commit is an interim fix until DES has a chance to rework the code involved.
2001-12-19 23:58:09 +00:00
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
return (pfs_vncache_free(va->a_vp));
}
/*
* Set attributes
*/
static int
pfs_setattr(struct vop_setattr_args *va)
{
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct vnode *vn = va->a_vp;
struct pfs_vdata *pvd = vn->v_data;
struct pfs_node *pn = pvd->pvd_pn;
PFS_TRACE(("%s", pn->pn_name));
pfs_assert_not_owned(pn);
Change EPERM to EOPNOTSUPP when failing pseudofs_setattr() arbitrarily. Quoth the alfred: The latter would be better.
2002-02-04 18:21:59 +00:00
PFS_RETURN (EOPNOTSUPP);
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
}
/*
Fix an old pasto.
2005-04-30 16:27:20 +00:00
* Write to a file
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
*/
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
static int
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
pfs_write(struct vop_write_args *va)
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
{
struct vnode *vn = va->a_vp;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
struct pfs_vdata *pvd = vn->v_data;
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
struct pfs_node *pn = pvd->pvd_pn;
struct uio *uio = va->a_uio;
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
struct proc *proc;
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
struct sbuf sb;
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
int error;
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
PFS_TRACE(("%s", pn->pn_name));
pfs_assert_not_owned(pn);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
if (vn->v_type != VREG)
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (EINVAL);
Fix an inverted KASSERT. Add similar assertions in other similar places. Reported by: Andrew Brampton <me@bramp.net> MFC after: 1 week
2009-04-07 16:13:10 +00:00
KASSERT_PN_IS_FILE(pn);
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
if (!(pn->pn_flags & PFS_WR))
PFS_RETURN (EBADF);
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (pn->pn_fill == NULL)
Add VOP_IOCTL support, and fix a bug that would cause a panic if a file or symlink lacked a filler function.
2001-10-26 18:52:47 +00:00
PFS_RETURN (EIO);
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
/*
* This is necessary because either process' privileges may
* have changed since the open() call.
*/
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
YA pseudofs megacommit, part 1: - Add a third callback to the pfs_node structure. This one simply returns non-zero if the specified requesting process is allowed to access the specified node for the specified target process. This is used in addition to the usual permission checks, e.g. when certain files don't make sense for certain (system) processes. - Make sure that pfs_lookup() and pfs_readdir() don't yap about files which aren't pfs_visible(). Also check pfs_visible() before performing reads and writes, to prevent the kind of races reported in SA-00:77 and SA-01:55 (fork a child, open /proc/child/ctl, have that child fork a setuid binary, and assume control of it). - Add some more trace points.
2001-10-01 04:22:20 +00:00
PFS_RETURN (EIO);
Change pfs_visible() to optionally return a pointer to the process associated with the passed in pfs_node. If it does return a pointer, it keeps the process locked. This allows a lot of places that were calling pfind() again right after pfs_visible() to not have to do that and avoids races since we don't drop the proc lock just to turn around and lock it again. This will become more important with future changes to fix races between procfs/ptrace and exit(2). Also, removed a duplicate pfs_visible() call in pfs_getextattr(). Reviewed by: des MFC after: 1 week
2006-02-22 17:24:54 +00:00
if (proc != NULL) {
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
_PHOLD(proc);
PROC_UNLOCK(proc);
}
if (pn->pn_flags & PFS_RAWWR) {
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
error = pn_fill(curthread, proc, pn, NULL, uio);
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
if (proc != NULL)
PRELE(proc);
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (error);
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
}
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
sbuf_uionew(&sb, uio, &error);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
if (error) {
if (proc != NULL)
PRELE(proc);
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (error);
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
}
Gratuitous whitespace cleanup.
2002-06-06 16:59:24 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
error = pn_fill(curthread, proc, pn, &sb, uio);
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
Make pseudofs (and consequently procfs, linprocfs and linsysfs) MPSAFE.
2007-04-15 17:10:01 +00:00
sbuf_delete(&sb);
Pseudofs take 2: - Remove hardcoded uid, gid, mode from struct pfs_node; make pfs_getattr() smart enough to get it right most of the time, and allow for callbacks to handle the remaining cases. Rework the definition macros to match. - Add lots of (conditional) debugging output. - Fix a long-standing bug inherited from procfs: don't pretend to be a read-only file system. Instead, return EOPNOTSUPP for operations we truly can't support and allow others to fail silently. In particular, pfs_lookup() now treats CREATE as LOOKUP. This may need more work. - In pfs_lookup(), if the parent node is process-dependent, check that the process in question still exists. - Implement pfs_open() - its only current function is to check that the process opening the file can see the process it belongs to. - Finish adding support for writeable nodes. - Bump module version number. - Introduce lots of new bugs.
2001-09-29 00:49:29 +00:00
if (proc != NULL)
PRELE(proc);
pseudofs.h: - Rearrange the flag constants a little to simplify specifying and testing for readability and writeability. pseudofs_vnops.c: - Track the aforementioned change. - Add checks to pfs_open() to prevent opening read-only files for writing or vice versa (pfs_{read,write} would block the actual reads and writes, but it's still a bug to allow the open() to succeed). Also, return EOPNOTSUPP if the caller attempts to lock the file. - Add more trace points.
2001-09-30 19:41:29 +00:00
PFS_RETURN (error);
Clean up my source tree to avoid getting hit too badly by the next KSE or whatever mega-commit. This goes some way towards adding support for writeable files (needed by procfs).
2001-09-25 13:25:30 +00:00
}
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
/*
* Vnode operations
*/
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
struct vop_vector pfs_vnodeops = {
.vop_default = &default_vnodeops,
Whitespace in vop_vector{} initializations.
2005-01-13 18:59:48 +00:00
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
.vop_access = pfs_access,
Hook pfs_lookup() up to vfs_cachedlookup_desc instead of vfs_lookup_desc, as suggested by Matt's comment. Also fix some style and paranoia issues. The entire function could benefit from review by a VFS guru. MFC after: 6 weeks
2005-03-14 16:24:50 +00:00
.vop_cachedlookup = pfs_lookup,
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
.vop_close = pfs_close,
.vop_create = VOP_EOPNOTSUPP,
.vop_getattr = pfs_getattr,
.vop_getextattr = pfs_getextattr,
.vop_ioctl = pfs_ioctl,
.vop_link = VOP_EOPNOTSUPP,
Hook pfs_lookup() up to vfs_cachedlookup_desc instead of vfs_lookup_desc, as suggested by Matt's comment. Also fix some style and paranoia issues. The entire function could benefit from review by a VFS guru. MFC after: 6 weeks
2005-03-14 16:24:50 +00:00
.vop_lookup = vfs_cache_lookup,
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
.vop_mkdir = VOP_EOPNOTSUPP,
.vop_mknod = VOP_EOPNOTSUPP,
.vop_open = pfs_open,
.vop_read = pfs_read,
.vop_readdir = pfs_readdir,
.vop_readlink = pfs_readlink,
.vop_reclaim = pfs_reclaim,
.vop_remove = VOP_EOPNOTSUPP,
.vop_rename = VOP_EOPNOTSUPP,
.vop_rmdir = VOP_EOPNOTSUPP,
.vop_setattr = pfs_setattr,
.vop_symlink = VOP_EOPNOTSUPP,
Add a VOP_VPTOCNP implementation for pseudofs which covers file systems such as procfs and linprocfs. This implementation's locking was enhanced by kib. Reviewed by: kib des Approved by: des kib Tested by: pho
2008-12-30 21:49:39 +00:00
.vop_vptocnp = pfs_vptocnp,
Back when VOP_* was introduced, we did not have new-style struct initializations but we did have lofty goals and big ideals. Adjust to more contemporary circumstances and gain type checking. Replace the entire vop_t frobbing thing with properly typed structures. The only casualty is that we can not add a new VOP_ method with a loadable module. History has not given us reason to belive this would ever be feasible in the the first place. Eliminate in toto VOCALL(), vop_t, VNODEOP_SET() etc. Give coda correct prototypes and function definitions for all vop_()s. Generate a bit more data from the vnode_if.src file: a struct vop_vector and protype typedefs for all vop methods. Add a new vop_bypass() and make vop_default be a pointer to another struct vop_vector. Remove a lot of vfs_init since vop_vector is ready to use from the compiler. Cast various vop_mumble() to void * with uppercase name, for instance VOP_PANIC, VOP_NULL etc. Implement VCALL() by making vdesc_offset the offsetof() the relevant function pointer in vop_vector. This is disgusting but since the code is generated by a script comparatively safe. The alternative for nullfs etc. would be much worse. Fix up all vnode method vectors to remove casts so they become typesafe. (The bulk of this is generated by scripts)
2004-12-01 23:16:38 +00:00
.vop_write = pfs_write,
/* XXX I've probably forgotten a few that need VOP_EOPNOTSUPP */
Let pseudofs into the warmth of the FreeBSD CVS repo. It's not finished yet (I still have to find a way to implement process- dependent nodes without consuming too much memory, and the permission system needs tightening up), but it's becoming hard to work on without a repo (I've accidentally almost nuked it once already), and it works (except for the lack of process-dependent nodes, that is). I was supposed to commit this a week ago, but timed out waiting for jkh to reply to some questions I had. Pass him a spoonful of bad karma :)
2001-04-07 19:51:12 +00:00
};
Reference in New Issue Copy Permalink