2005-01-06 23:35:40 +00:00
|
|
|
/*-
|
1997-10-16 17:48:22 +00:00
|
|
|
* Copyright (c) 1989, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* This code is derived from software contributed
|
|
|
|
* to Berkeley by John Heidemann of the UCLA Ficus project.
|
|
|
|
*
|
|
|
|
* Source: * @(#)i405_init.c 2.10 92/04/27 UCLA Ficus project
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
2016-09-15 13:16:20 +00:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
1997-10-16 17:48:22 +00:00
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1997-10-16 17:48:22 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2000-05-05 09:59:14 +00:00
|
|
|
#include <sys/bio.h>
|
1999-02-25 15:54:06 +00:00
|
|
|
#include <sys/buf.h>
|
2000-09-12 09:49:08 +00:00
|
|
|
#include <sys/conf.h>
|
2005-06-09 20:20:31 +00:00
|
|
|
#include <sys/event.h>
|
1997-10-16 17:48:22 +00:00
|
|
|
#include <sys/kernel.h>
|
2003-04-29 13:36:06 +00:00
|
|
|
#include <sys/limits.h>
|
1997-12-05 19:55:52 +00:00
|
|
|
#include <sys/lock.h>
|
Move the head of byte-level advisory lock list from the
filesystem-specific vnode data to the struct vnode. Provide the
default implementation for the vop_advlock and vop_advlockasync.
Purge the locks on the vnode reclaim by using the lf_purgelocks().
The default implementation is augmented for the nfs and smbfs.
In the nfs_advlock, push the Giant inside the nfs_dolock.
Before the change, the vop_advlock and vop_advlockasync have taken the
unlocked vnode and dereferenced the fs-private inode data, racing with
with the vnode reclamation due to forced unmount. Now, the vop_getattr
under the shared vnode lock is used to obtain the inode size, and
later, in the lf_advlockasync, after locking the vnode interlock, the
VI_DOOMED flag is checked to prevent an operation on the doomed vnode.
The implementation of the lf_purgelocks() is submitted by dfr.
Reported by: kris
Tested by: kris, pho
Discussed with: jeff, dfr
MFC after: 2 weeks
2008-04-16 11:33:32 +00:00
|
|
|
#include <sys/lockf.h>
|
1997-10-26 20:55:39 +00:00
|
|
|
#include <sys/malloc.h>
|
1999-09-07 22:42:38 +00:00
|
|
|
#include <sys/mount.h>
|
2009-03-08 19:05:53 +00:00
|
|
|
#include <sys/namei.h>
|
2013-03-09 02:32:23 +00:00
|
|
|
#include <sys/rwlock.h>
|
2009-03-08 19:05:53 +00:00
|
|
|
#include <sys/fcntl.h>
|
1997-10-16 20:32:40 +00:00
|
|
|
#include <sys/unistd.h>
|
1997-10-16 17:48:22 +00:00
|
|
|
#include <sys/vnode.h>
|
2009-03-08 19:05:53 +00:00
|
|
|
#include <sys/dirent.h>
|
1997-10-26 20:55:39 +00:00
|
|
|
#include <sys/poll.h>
|
1997-10-16 17:48:22 +00:00
|
|
|
|
2009-06-05 14:23:24 +00:00
|
|
|
#include <security/mac/mac_framework.h>
|
|
|
|
|
2000-09-12 09:49:08 +00:00
|
|
|
#include <vm/vm.h>
|
|
|
|
#include <vm/vm_object.h>
|
|
|
|
#include <vm/vm_extern.h>
|
|
|
|
#include <vm/pmap.h>
|
|
|
|
#include <vm/vm_map.h>
|
|
|
|
#include <vm/vm_page.h>
|
|
|
|
#include <vm/vm_pager.h>
|
|
|
|
#include <vm/vnode_pager.h>
|
|
|
|
|
2002-03-19 21:25:46 +00:00
|
|
|
static int vop_nolookup(struct vop_lookup_args *);
|
2010-04-02 14:03:43 +00:00
|
|
|
static int vop_norename(struct vop_rename_args *);
|
2002-03-19 21:25:46 +00:00
|
|
|
static int vop_nostrategy(struct vop_strategy_args *);
|
2009-03-08 19:05:53 +00:00
|
|
|
static int get_next_dirent(struct vnode *vp, struct dirent **dpp,
|
|
|
|
char *dirbuf, int dirbuflen, off_t *off,
|
|
|
|
char **cpos, int *len, int *eofflag,
|
|
|
|
struct thread *td);
|
|
|
|
static int dirent_exists(struct vnode *vp, const char *dirname,
|
|
|
|
struct thread *td);
|
|
|
|
|
|
|
|
#define DIRENT_MINSIZE (sizeof(struct dirent) - (MAXNAMLEN+1) + 4)
|
1997-10-16 17:48:22 +00:00
|
|
|
|
2012-09-28 11:25:02 +00:00
|
|
|
static int vop_stdis_text(struct vop_is_text_args *ap);
|
|
|
|
static int vop_stdset_text(struct vop_set_text_args *ap);
|
|
|
|
static int vop_stdunset_text(struct vop_unset_text_args *ap);
|
2012-11-02 13:56:36 +00:00
|
|
|
static int vop_stdget_writecount(struct vop_get_writecount_args *ap);
|
|
|
|
static int vop_stdadd_writecount(struct vop_add_writecount_args *ap);
|
2016-08-15 19:08:51 +00:00
|
|
|
static int vop_stdfdatasync(struct vop_fdatasync_args *ap);
|
2014-11-23 12:01:52 +00:00
|
|
|
static int vop_stdgetpages_async(struct vop_getpages_async_args *ap);
|
2012-09-28 11:25:02 +00:00
|
|
|
|
1997-10-16 17:48:22 +00:00
|
|
|
/*
|
|
|
|
* This vnode table stores what we want to do if the filesystem doesn't
|
|
|
|
* implement a particular VOP.
|
|
|
|
*
|
|
|
|
* If there is no specific entry here, we will return EOPNOTSUPP.
|
|
|
|
*
|
2009-10-01 17:22:03 +00:00
|
|
|
* Note that every filesystem has to implement either vop_access
|
|
|
|
* or vop_accessx; failing to do so will result in immediate crash
|
|
|
|
* due to stack overflow, as vop_stdaccess() calls vop_stdaccessx(),
|
|
|
|
* which calls vop_stdaccess() etc.
|
1997-10-16 17:48:22 +00:00
|
|
|
*/
|
|
|
|
|
2004-12-01 23:16:38 +00:00
|
|
|
struct vop_vector default_vnodeops = {
|
|
|
|
.vop_default = NULL,
|
2004-12-03 08:56:30 +00:00
|
|
|
.vop_bypass = VOP_EOPNOTSUPP,
|
|
|
|
|
2009-10-01 17:22:03 +00:00
|
|
|
.vop_access = vop_stdaccess,
|
2009-05-30 13:59:05 +00:00
|
|
|
.vop_accessx = vop_stdaccessx,
|
2011-11-04 04:02:50 +00:00
|
|
|
.vop_advise = vop_stdadvise,
|
Move the head of byte-level advisory lock list from the
filesystem-specific vnode data to the struct vnode. Provide the
default implementation for the vop_advlock and vop_advlockasync.
Purge the locks on the vnode reclaim by using the lf_purgelocks().
The default implementation is augmented for the nfs and smbfs.
In the nfs_advlock, push the Giant inside the nfs_dolock.
Before the change, the vop_advlock and vop_advlockasync have taken the
unlocked vnode and dereferenced the fs-private inode data, racing with
with the vnode reclamation due to forced unmount. Now, the vop_getattr
under the shared vnode lock is used to obtain the inode size, and
later, in the lf_advlockasync, after locking the vnode interlock, the
VI_DOOMED flag is checked to prevent an operation on the doomed vnode.
The implementation of the lf_purgelocks() is submitted by dfr.
Reported by: kris
Tested by: kris, pho
Discussed with: jeff, dfr
MFC after: 2 weeks
2008-04-16 11:33:32 +00:00
|
|
|
.vop_advlock = vop_stdadvlock,
|
|
|
|
.vop_advlockasync = vop_stdadvlockasync,
|
2010-05-12 21:24:46 +00:00
|
|
|
.vop_advlockpurge = vop_stdadvlockpurge,
|
2011-04-18 16:32:22 +00:00
|
|
|
.vop_allocate = vop_stdallocate,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_bmap = vop_stdbmap,
|
|
|
|
.vop_close = VOP_NULL,
|
|
|
|
.vop_fsync = VOP_NULL,
|
2016-08-15 19:08:51 +00:00
|
|
|
.vop_fdatasync = vop_stdfdatasync,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_getpages = vop_stdgetpages,
|
2014-11-23 12:01:52 +00:00
|
|
|
.vop_getpages_async = vop_stdgetpages_async,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_getwritemount = vop_stdgetwritemount,
|
2005-03-13 11:45:01 +00:00
|
|
|
.vop_inactive = VOP_NULL,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_ioctl = VOP_ENOTTY,
|
2005-06-09 20:20:31 +00:00
|
|
|
.vop_kqfilter = vop_stdkqfilter,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_islocked = vop_stdislocked,
|
2007-05-18 13:02:13 +00:00
|
|
|
.vop_lock1 = vop_stdlock,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_lookup = vop_nolookup,
|
|
|
|
.vop_open = VOP_NULL,
|
|
|
|
.vop_pathconf = VOP_EINVAL,
|
|
|
|
.vop_poll = vop_nopoll,
|
|
|
|
.vop_putpages = vop_stdputpages,
|
|
|
|
.vop_readlink = VOP_EINVAL,
|
2010-04-02 14:03:43 +00:00
|
|
|
.vop_rename = vop_norename,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_revoke = VOP_PANIC,
|
|
|
|
.vop_strategy = vop_nostrategy,
|
|
|
|
.vop_unlock = vop_stdunlock,
|
2009-03-08 19:05:53 +00:00
|
|
|
.vop_vptocnp = vop_stdvptocnp,
|
2007-02-15 22:08:35 +00:00
|
|
|
.vop_vptofh = vop_stdvptofh,
|
2012-02-29 21:38:31 +00:00
|
|
|
.vop_unp_bind = vop_stdunp_bind,
|
|
|
|
.vop_unp_connect = vop_stdunp_connect,
|
|
|
|
.vop_unp_detach = vop_stdunp_detach,
|
2012-09-28 11:25:02 +00:00
|
|
|
.vop_is_text = vop_stdis_text,
|
|
|
|
.vop_set_text = vop_stdset_text,
|
|
|
|
.vop_unset_text = vop_stdunset_text,
|
2012-11-02 13:56:36 +00:00
|
|
|
.vop_get_writecount = vop_stdget_writecount,
|
|
|
|
.vop_add_writecount = vop_stdadd_writecount,
|
1997-10-16 17:48:22 +00:00
|
|
|
};
|
|
|
|
|
2002-03-05 15:38:49 +00:00
|
|
|
/*
|
|
|
|
* Series of placeholder functions for various error returns for
|
|
|
|
* VOPs.
|
|
|
|
*/
|
|
|
|
|
1997-10-16 17:48:22 +00:00
|
|
|
int
|
1997-10-16 20:32:40 +00:00
|
|
|
vop_eopnotsupp(struct vop_generic_args *ap)
|
1997-10-16 17:48:22 +00:00
|
|
|
{
|
|
|
|
/*
|
1997-10-16 20:32:40 +00:00
|
|
|
printf("vop_notsupp[%s]\n", ap->a_desc->vdesc_name);
|
1997-10-16 17:48:22 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
return (EOPNOTSUPP);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
1997-10-16 20:32:40 +00:00
|
|
|
vop_ebadf(struct vop_generic_args *ap)
|
1997-10-16 17:48:22 +00:00
|
|
|
{
|
|
|
|
|
1997-10-16 20:32:40 +00:00
|
|
|
return (EBADF);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
vop_enotty(struct vop_generic_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (ENOTTY);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
vop_einval(struct vop_generic_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
|
2008-12-12 00:57:38 +00:00
|
|
|
int
|
|
|
|
vop_enoent(struct vop_generic_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (ENOENT);
|
|
|
|
}
|
|
|
|
|
1997-10-16 20:32:40 +00:00
|
|
|
int
|
|
|
|
vop_null(struct vop_generic_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (0);
|
1997-10-16 17:48:22 +00:00
|
|
|
}
|
|
|
|
|
2002-03-05 15:38:49 +00:00
|
|
|
/*
|
|
|
|
* Helper function to panic on some bad VOPs in some filesystems.
|
|
|
|
*/
|
1998-11-10 09:04:09 +00:00
|
|
|
int
|
|
|
|
vop_panic(struct vop_generic_args *ap)
|
|
|
|
{
|
|
|
|
|
2001-02-18 02:22:58 +00:00
|
|
|
panic("filesystem goof: vop_panic[%s]", ap->a_desc->vdesc_name);
|
|
|
|
}
|
|
|
|
|
2002-03-05 15:38:49 +00:00
|
|
|
/*
|
|
|
|
* vop_std<something> and vop_no<something> are default functions for use by
|
|
|
|
* filesystems that need the "default reasonable" implementation for a
|
|
|
|
* particular operation.
|
|
|
|
*
|
|
|
|
* The documentation for the operations they implement exists (if it exists)
|
|
|
|
* in the VOP_<SOMETHING>(9) manpage (all uppercase).
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Default vop for filesystems that do not support name lookup
|
|
|
|
*/
|
2001-02-18 02:22:58 +00:00
|
|
|
static int
|
|
|
|
vop_nolookup(ap)
|
|
|
|
struct vop_lookup_args /* {
|
|
|
|
struct vnode *a_dvp;
|
|
|
|
struct vnode **a_vpp;
|
|
|
|
struct componentname *a_cnp;
|
|
|
|
} */ *ap;
|
|
|
|
{
|
|
|
|
|
|
|
|
*ap->a_vpp = NULL;
|
|
|
|
return (ENOTDIR);
|
1998-11-10 09:04:09 +00:00
|
|
|
}
|
|
|
|
|
2010-04-02 14:03:43 +00:00
|
|
|
/*
|
|
|
|
* vop_norename:
|
|
|
|
*
|
|
|
|
* Handle unlock and reference counting for arguments of vop_rename
|
|
|
|
* for filesystems that do not implement rename operation.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
vop_norename(struct vop_rename_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
vop_rename_fail(ap);
|
|
|
|
return (EOPNOTSUPP);
|
|
|
|
}
|
|
|
|
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
/*
|
|
|
|
* vop_nostrategy:
|
|
|
|
*
|
|
|
|
* Strategy routine for VFS devices that have none.
|
|
|
|
*
|
2000-04-02 15:24:56 +00:00
|
|
|
* BIO_ERROR and B_INVAL must be cleared prior to calling any strategy
|
2000-03-20 10:44:49 +00:00
|
|
|
* routine. Typically this is done for a BIO_READ strategy call.
|
2003-03-10 21:55:00 +00:00
|
|
|
* Typically B_INVAL is assumed to already be clear prior to a write
|
2000-03-20 10:44:49 +00:00
|
|
|
* and should not be cleared manually unless you just made the buffer
|
2000-04-02 15:24:56 +00:00
|
|
|
* invalid. BIO_ERROR should be cleared either way.
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
*/
|
|
|
|
|
1997-10-16 17:48:22 +00:00
|
|
|
static int
|
|
|
|
vop_nostrategy (struct vop_strategy_args *ap)
|
|
|
|
{
|
|
|
|
printf("No strategy for buffer at %p\n", ap->a_bp);
|
2016-08-10 16:12:31 +00:00
|
|
|
vn_printf(ap->a_vp, "vnode ");
|
2000-04-02 15:24:56 +00:00
|
|
|
ap->a_bp->b_ioflags |= BIO_ERROR;
|
1997-10-16 17:48:22 +00:00
|
|
|
ap->a_bp->b_error = EOPNOTSUPP;
|
2000-04-15 05:54:02 +00:00
|
|
|
bufdone(ap->a_bp);
|
1997-10-16 17:48:22 +00:00
|
|
|
return (EOPNOTSUPP);
|
|
|
|
}
|
1997-10-16 20:32:40 +00:00
|
|
|
|
2009-03-08 19:05:53 +00:00
|
|
|
static int
|
|
|
|
get_next_dirent(struct vnode *vp, struct dirent **dpp, char *dirbuf,
|
|
|
|
int dirbuflen, off_t *off, char **cpos, int *len,
|
|
|
|
int *eofflag, struct thread *td)
|
|
|
|
{
|
|
|
|
int error, reclen;
|
|
|
|
struct uio uio;
|
|
|
|
struct iovec iov;
|
|
|
|
struct dirent *dp;
|
|
|
|
|
|
|
|
KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
|
|
|
|
KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
|
|
|
|
|
|
|
|
if (*len == 0) {
|
|
|
|
iov.iov_base = dirbuf;
|
|
|
|
iov.iov_len = dirbuflen;
|
|
|
|
|
|
|
|
uio.uio_iov = &iov;
|
|
|
|
uio.uio_iovcnt = 1;
|
|
|
|
uio.uio_offset = *off;
|
|
|
|
uio.uio_resid = dirbuflen;
|
|
|
|
uio.uio_segflg = UIO_SYSSPACE;
|
|
|
|
uio.uio_rw = UIO_READ;
|
|
|
|
uio.uio_td = td;
|
|
|
|
|
|
|
|
*eofflag = 0;
|
|
|
|
|
|
|
|
#ifdef MAC
|
|
|
|
error = mac_vnode_check_readdir(td->td_ucred, vp);
|
|
|
|
if (error == 0)
|
|
|
|
#endif
|
|
|
|
error = VOP_READDIR(vp, &uio, td->td_ucred, eofflag,
|
|
|
|
NULL, NULL);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
2010-08-23 05:33:31 +00:00
|
|
|
*off = uio.uio_offset;
|
2010-08-25 18:09:51 +00:00
|
|
|
|
|
|
|
*cpos = dirbuf;
|
|
|
|
*len = (dirbuflen - uio.uio_resid);
|
|
|
|
|
|
|
|
if (*len == 0)
|
|
|
|
return (ENOENT);
|
2009-03-08 19:05:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
dp = (struct dirent *)(*cpos);
|
|
|
|
reclen = dp->d_reclen;
|
|
|
|
*dpp = dp;
|
|
|
|
|
|
|
|
/* check for malformed directory.. */
|
|
|
|
if (reclen < DIRENT_MINSIZE)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
*cpos += reclen;
|
|
|
|
*len -= reclen;
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if a named file exists in a given directory vnode.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
dirent_exists(struct vnode *vp, const char *dirname, struct thread *td)
|
|
|
|
{
|
|
|
|
char *dirbuf, *cpos;
|
|
|
|
int error, eofflag, dirbuflen, len, found;
|
|
|
|
off_t off;
|
|
|
|
struct dirent *dp;
|
|
|
|
struct vattr va;
|
|
|
|
|
|
|
|
KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
|
|
|
|
KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
|
|
|
|
|
|
|
|
found = 0;
|
|
|
|
|
|
|
|
error = VOP_GETATTR(vp, &va, td->td_ucred);
|
|
|
|
if (error)
|
|
|
|
return (found);
|
|
|
|
|
|
|
|
dirbuflen = DEV_BSIZE;
|
|
|
|
if (dirbuflen < va.va_blocksize)
|
|
|
|
dirbuflen = va.va_blocksize;
|
|
|
|
dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
|
|
|
|
|
|
|
|
off = 0;
|
|
|
|
len = 0;
|
|
|
|
do {
|
|
|
|
error = get_next_dirent(vp, &dp, dirbuf, dirbuflen, &off,
|
|
|
|
&cpos, &len, &eofflag, td);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
2012-05-16 10:44:09 +00:00
|
|
|
if (dp->d_type != DT_WHT && dp->d_fileno != 0 &&
|
|
|
|
strcmp(dp->d_name, dirname) == 0) {
|
2009-03-08 19:05:53 +00:00
|
|
|
found = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} while (len > 0 || !eofflag);
|
|
|
|
|
|
|
|
out:
|
|
|
|
free(dirbuf, M_TEMP);
|
|
|
|
return (found);
|
|
|
|
}
|
|
|
|
|
2009-10-01 17:22:03 +00:00
|
|
|
int
|
|
|
|
vop_stdaccess(struct vop_access_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
KASSERT((ap->a_accmode & ~(VEXEC | VWRITE | VREAD | VADMIN |
|
|
|
|
VAPPEND)) == 0, ("invalid bit in accmode"));
|
|
|
|
|
|
|
|
return (VOP_ACCESSX(ap->a_vp, ap->a_accmode, ap->a_cred, ap->a_td));
|
|
|
|
}
|
|
|
|
|
2009-05-30 13:59:05 +00:00
|
|
|
int
|
|
|
|
vop_stdaccessx(struct vop_accessx_args *ap)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
accmode_t accmode = ap->a_accmode;
|
|
|
|
|
|
|
|
error = vfs_unixify_accmode(&accmode);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
if (accmode == 0)
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
return (VOP_ACCESS(ap->a_vp, accmode, ap->a_cred, ap->a_td));
|
|
|
|
}
|
|
|
|
|
Move the head of byte-level advisory lock list from the
filesystem-specific vnode data to the struct vnode. Provide the
default implementation for the vop_advlock and vop_advlockasync.
Purge the locks on the vnode reclaim by using the lf_purgelocks().
The default implementation is augmented for the nfs and smbfs.
In the nfs_advlock, push the Giant inside the nfs_dolock.
Before the change, the vop_advlock and vop_advlockasync have taken the
unlocked vnode and dereferenced the fs-private inode data, racing with
with the vnode reclamation due to forced unmount. Now, the vop_getattr
under the shared vnode lock is used to obtain the inode size, and
later, in the lf_advlockasync, after locking the vnode interlock, the
VI_DOOMED flag is checked to prevent an operation on the doomed vnode.
The implementation of the lf_purgelocks() is submitted by dfr.
Reported by: kris
Tested by: kris, pho
Discussed with: jeff, dfr
MFC after: 2 weeks
2008-04-16 11:33:32 +00:00
|
|
|
/*
|
|
|
|
* Advisory record locking support
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vop_stdadvlock(struct vop_advlock_args *ap)
|
|
|
|
{
|
2008-08-28 15:23:18 +00:00
|
|
|
struct vnode *vp;
|
Move the head of byte-level advisory lock list from the
filesystem-specific vnode data to the struct vnode. Provide the
default implementation for the vop_advlock and vop_advlockasync.
Purge the locks on the vnode reclaim by using the lf_purgelocks().
The default implementation is augmented for the nfs and smbfs.
In the nfs_advlock, push the Giant inside the nfs_dolock.
Before the change, the vop_advlock and vop_advlockasync have taken the
unlocked vnode and dereferenced the fs-private inode data, racing with
with the vnode reclamation due to forced unmount. Now, the vop_getattr
under the shared vnode lock is used to obtain the inode size, and
later, in the lf_advlockasync, after locking the vnode interlock, the
VI_DOOMED flag is checked to prevent an operation on the doomed vnode.
The implementation of the lf_purgelocks() is submitted by dfr.
Reported by: kris
Tested by: kris, pho
Discussed with: jeff, dfr
MFC after: 2 weeks
2008-04-16 11:33:32 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
|
2008-08-28 15:23:18 +00:00
|
|
|
vp = ap->a_vp;
|
2014-12-24 22:58:08 +00:00
|
|
|
if (ap->a_fl->l_whence == SEEK_END) {
|
|
|
|
/*
|
2014-12-25 14:44:04 +00:00
|
|
|
* The NFSv4 server must avoid doing a vn_lock() here, since it
|
|
|
|
* can deadlock the nfsd threads, due to a LOR. Fortunately
|
|
|
|
* the NFSv4 server always uses SEEK_SET and this code is
|
|
|
|
* only required for the SEEK_END case.
|
2014-12-24 22:58:08 +00:00
|
|
|
*/
|
|
|
|
vn_lock(vp, LK_SHARED | LK_RETRY);
|
|
|
|
error = VOP_GETATTR(vp, &vattr, curthread->td_ucred);
|
|
|
|
VOP_UNLOCK(vp, 0);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
} else
|
|
|
|
vattr.va_size = 0;
|
Move the head of byte-level advisory lock list from the
filesystem-specific vnode data to the struct vnode. Provide the
default implementation for the vop_advlock and vop_advlockasync.
Purge the locks on the vnode reclaim by using the lf_purgelocks().
The default implementation is augmented for the nfs and smbfs.
In the nfs_advlock, push the Giant inside the nfs_dolock.
Before the change, the vop_advlock and vop_advlockasync have taken the
unlocked vnode and dereferenced the fs-private inode data, racing with
with the vnode reclamation due to forced unmount. Now, the vop_getattr
under the shared vnode lock is used to obtain the inode size, and
later, in the lf_advlockasync, after locking the vnode interlock, the
VI_DOOMED flag is checked to prevent an operation on the doomed vnode.
The implementation of the lf_purgelocks() is submitted by dfr.
Reported by: kris
Tested by: kris, pho
Discussed with: jeff, dfr
MFC after: 2 weeks
2008-04-16 11:33:32 +00:00
|
|
|
|
|
|
|
return (lf_advlock(ap, &(vp->v_lockf), vattr.va_size));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
vop_stdadvlockasync(struct vop_advlockasync_args *ap)
|
|
|
|
{
|
2008-08-28 15:23:18 +00:00
|
|
|
struct vnode *vp;
|
Move the head of byte-level advisory lock list from the
filesystem-specific vnode data to the struct vnode. Provide the
default implementation for the vop_advlock and vop_advlockasync.
Purge the locks on the vnode reclaim by using the lf_purgelocks().
The default implementation is augmented for the nfs and smbfs.
In the nfs_advlock, push the Giant inside the nfs_dolock.
Before the change, the vop_advlock and vop_advlockasync have taken the
unlocked vnode and dereferenced the fs-private inode data, racing with
with the vnode reclamation due to forced unmount. Now, the vop_getattr
under the shared vnode lock is used to obtain the inode size, and
later, in the lf_advlockasync, after locking the vnode interlock, the
VI_DOOMED flag is checked to prevent an operation on the doomed vnode.
The implementation of the lf_purgelocks() is submitted by dfr.
Reported by: kris
Tested by: kris, pho
Discussed with: jeff, dfr
MFC after: 2 weeks
2008-04-16 11:33:32 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
|
2008-08-28 15:23:18 +00:00
|
|
|
vp = ap->a_vp;
|
2014-12-24 22:58:08 +00:00
|
|
|
if (ap->a_fl->l_whence == SEEK_END) {
|
|
|
|
/* The size argument is only needed for SEEK_END. */
|
|
|
|
vn_lock(vp, LK_SHARED | LK_RETRY);
|
|
|
|
error = VOP_GETATTR(vp, &vattr, curthread->td_ucred);
|
|
|
|
VOP_UNLOCK(vp, 0);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
} else
|
|
|
|
vattr.va_size = 0;
|
Move the head of byte-level advisory lock list from the
filesystem-specific vnode data to the struct vnode. Provide the
default implementation for the vop_advlock and vop_advlockasync.
Purge the locks on the vnode reclaim by using the lf_purgelocks().
The default implementation is augmented for the nfs and smbfs.
In the nfs_advlock, push the Giant inside the nfs_dolock.
Before the change, the vop_advlock and vop_advlockasync have taken the
unlocked vnode and dereferenced the fs-private inode data, racing with
with the vnode reclamation due to forced unmount. Now, the vop_getattr
under the shared vnode lock is used to obtain the inode size, and
later, in the lf_advlockasync, after locking the vnode interlock, the
VI_DOOMED flag is checked to prevent an operation on the doomed vnode.
The implementation of the lf_purgelocks() is submitted by dfr.
Reported by: kris
Tested by: kris, pho
Discussed with: jeff, dfr
MFC after: 2 weeks
2008-04-16 11:33:32 +00:00
|
|
|
|
|
|
|
return (lf_advlockasync(ap, &(vp->v_lockf), vattr.va_size));
|
|
|
|
}
|
|
|
|
|
2010-05-12 21:24:46 +00:00
|
|
|
int
|
|
|
|
vop_stdadvlockpurge(struct vop_advlockpurge_args *ap)
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
|
|
|
|
|
|
|
vp = ap->a_vp;
|
|
|
|
lf_purgelocks(vp, &vp->v_lockf);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2002-03-05 15:38:49 +00:00
|
|
|
/*
|
|
|
|
* vop_stdpathconf:
|
2003-03-10 21:55:00 +00:00
|
|
|
*
|
2002-03-05 15:38:49 +00:00
|
|
|
* Standard implementation of POSIX pathconf, to get information about limits
|
|
|
|
* for a filesystem.
|
|
|
|
* Override per filesystem for the case where the filesystem has smaller
|
|
|
|
* limits.
|
|
|
|
*/
|
1997-10-16 20:32:40 +00:00
|
|
|
int
|
|
|
|
vop_stdpathconf(ap)
|
|
|
|
struct vop_pathconf_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
int a_name;
|
|
|
|
int *a_retval;
|
|
|
|
} */ *ap;
|
|
|
|
{
|
|
|
|
|
|
|
|
switch (ap->a_name) {
|
2016-03-09 19:05:11 +00:00
|
|
|
case _PC_ASYNC_IO:
|
|
|
|
*ap->a_retval = _POSIX_ASYNCHRONOUS_IO;
|
|
|
|
return (0);
|
2005-08-17 06:59:23 +00:00
|
|
|
case _PC_NAME_MAX:
|
|
|
|
*ap->a_retval = NAME_MAX;
|
|
|
|
return (0);
|
|
|
|
case _PC_PATH_MAX:
|
|
|
|
*ap->a_retval = PATH_MAX;
|
|
|
|
return (0);
|
1997-10-16 20:32:40 +00:00
|
|
|
case _PC_LINK_MAX:
|
|
|
|
*ap->a_retval = LINK_MAX;
|
|
|
|
return (0);
|
|
|
|
case _PC_MAX_CANON:
|
|
|
|
*ap->a_retval = MAX_CANON;
|
|
|
|
return (0);
|
|
|
|
case _PC_MAX_INPUT:
|
|
|
|
*ap->a_retval = MAX_INPUT;
|
|
|
|
return (0);
|
|
|
|
case _PC_PIPE_BUF:
|
|
|
|
*ap->a_retval = PIPE_BUF;
|
|
|
|
return (0);
|
|
|
|
case _PC_CHOWN_RESTRICTED:
|
|
|
|
*ap->a_retval = 1;
|
|
|
|
return (0);
|
|
|
|
case _PC_VDISABLE:
|
|
|
|
*ap->a_retval = _POSIX_VDISABLE;
|
|
|
|
return (0);
|
|
|
|
default:
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
1997-10-17 12:36:19 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Standard lock, unlock and islocked functions.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vop_stdlock(ap)
|
2007-05-18 13:02:13 +00:00
|
|
|
struct vop_lock1_args /* {
|
1997-10-17 12:36:19 +00:00
|
|
|
struct vnode *a_vp;
|
|
|
|
int a_flags;
|
2006-11-13 05:51:22 +00:00
|
|
|
char *file;
|
|
|
|
int line;
|
1997-10-17 12:36:19 +00:00
|
|
|
} */ *ap;
|
2003-03-10 21:55:00 +00:00
|
|
|
{
|
2000-09-25 15:24:04 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
2017-02-12 09:49:44 +00:00
|
|
|
struct mtx *ilk;
|
1997-10-17 12:36:19 +00:00
|
|
|
|
2017-02-12 09:49:44 +00:00
|
|
|
ilk = VI_MTX(vp);
|
|
|
|
return (lockmgr_lock_fast_path(vp->v_vnlock, ap->a_flags,
|
|
|
|
(ilk != NULL) ? &ilk->lock_object : NULL, ap->a_file, ap->a_line));
|
1997-10-17 12:36:19 +00:00
|
|
|
}
|
|
|
|
|
2002-03-05 15:38:49 +00:00
|
|
|
/* See above. */
|
1997-10-17 12:36:19 +00:00
|
|
|
int
|
|
|
|
vop_stdunlock(ap)
|
|
|
|
struct vop_unlock_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
int a_flags;
|
|
|
|
} */ *ap;
|
|
|
|
{
|
2000-09-25 15:24:04 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
2017-02-12 09:49:44 +00:00
|
|
|
struct mtx *ilk;
|
1997-10-17 12:36:19 +00:00
|
|
|
|
2017-02-12 09:49:44 +00:00
|
|
|
ilk = VI_MTX(vp);
|
|
|
|
return (lockmgr_unlock_fast_path(vp->v_vnlock, ap->a_flags,
|
|
|
|
(ilk != NULL) ? &ilk->lock_object : NULL));
|
1997-10-17 12:36:19 +00:00
|
|
|
}
|
|
|
|
|
2002-03-05 15:38:49 +00:00
|
|
|
/* See above. */
|
1997-10-17 12:36:19 +00:00
|
|
|
int
|
|
|
|
vop_stdislocked(ap)
|
|
|
|
struct vop_islocked_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
} */ *ap;
|
|
|
|
{
|
Make our v_usecount vnode reference count work identically to the
original BSD code. The association between the vnode and the vm_object
no longer includes reference counts. The major difference is that
vm_object's are no longer freed gratuitiously from the vnode, and so
once an object is created for the vnode, it will last as long as the
vnode does.
When a vnode object reference count is incremented, then the underlying
vnode reference count is incremented also. The two "objects" are now
more intimately related, and so the interactions are now much less
complex.
When vnodes are now normally placed onto the free queue with an object still
attached. The rundown of the object happens at vnode rundown time, and
happens with exactly the same filesystem semantics of the original VFS
code. There is absolutely no need for vnode_pager_uncache and other
travesties like that anymore.
A side-effect of these changes is that SMP locking should be much simpler,
the I/O copyin/copyout optimizations work, NFS should be more ponderable,
and further work on layered filesystems should be less frustrating, because
of the totally coherent management of the vnode objects and vnodes.
Please be careful with your system while running this code, but I would
greatly appreciate feedback as soon a reasonably possible.
1998-01-06 05:26:17 +00:00
|
|
|
|
2008-02-25 18:45:57 +00:00
|
|
|
return (lockstatus(ap->a_vp->v_vnlock));
|
2000-08-18 10:01:02 +00:00
|
|
|
}
|
|
|
|
|
1997-10-26 20:55:39 +00:00
|
|
|
/*
|
|
|
|
* Return true for select/poll.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vop_nopoll(ap)
|
|
|
|
struct vop_poll_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
int a_events;
|
|
|
|
struct ucred *a_cred;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *a_td;
|
1997-10-26 20:55:39 +00:00
|
|
|
} */ *ap;
|
|
|
|
{
|
1997-12-15 03:09:59 +00:00
|
|
|
|
2009-03-06 15:35:37 +00:00
|
|
|
return (poll_no_poll(ap->a_events));
|
1997-10-26 20:55:39 +00:00
|
|
|
}
|
|
|
|
|
1997-12-15 03:09:59 +00:00
|
|
|
/*
|
|
|
|
* Implement poll for local filesystems that support it.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vop_stdpoll(ap)
|
|
|
|
struct vop_poll_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
int a_events;
|
|
|
|
struct ucred *a_cred;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *a_td;
|
1997-12-15 03:09:59 +00:00
|
|
|
} */ *ap;
|
|
|
|
{
|
2001-05-14 14:37:25 +00:00
|
|
|
if (ap->a_events & ~POLLSTANDARD)
|
2001-09-12 08:38:13 +00:00
|
|
|
return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events));
|
2001-05-14 14:37:25 +00:00
|
|
|
return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
|
1997-12-15 03:09:59 +00:00
|
|
|
}
|
|
|
|
|
2000-07-11 22:07:57 +00:00
|
|
|
/*
|
|
|
|
* Return our mount point, as we will take charge of the writes.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
vop_stdgetwritemount(ap)
|
|
|
|
struct vop_getwritemount_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
struct mount **a_mpp;
|
|
|
|
} */ *ap;
|
|
|
|
{
|
2006-03-31 03:52:24 +00:00
|
|
|
struct mount *mp;
|
2000-07-11 22:07:57 +00:00
|
|
|
|
2006-03-31 03:52:24 +00:00
|
|
|
/*
|
|
|
|
* XXX Since this is called unlocked we may be recycled while
|
|
|
|
* attempting to ref the mount. If this is the case or mountpoint
|
|
|
|
* will be set to NULL. We only have to prevent this call from
|
|
|
|
* returning with a ref to an incorrect mountpoint. It is not
|
|
|
|
* harmful to return with a ref to our previous mountpoint.
|
|
|
|
*/
|
|
|
|
mp = ap->a_vp->v_mount;
|
2006-09-20 00:27:02 +00:00
|
|
|
if (mp != NULL) {
|
|
|
|
vfs_ref(mp);
|
|
|
|
if (mp != ap->a_vp->v_mount) {
|
|
|
|
vfs_rel(mp);
|
|
|
|
mp = NULL;
|
|
|
|
}
|
2006-03-31 03:52:24 +00:00
|
|
|
}
|
|
|
|
*(ap->a_mpp) = mp;
|
2000-07-11 22:07:57 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2002-03-05 15:38:49 +00:00
|
|
|
/* XXX Needs good comment and VOP_BMAP(9) manpage */
|
2001-04-29 11:48:41 +00:00
|
|
|
int
|
|
|
|
vop_stdbmap(ap)
|
2003-03-10 21:55:00 +00:00
|
|
|
struct vop_bmap_args /* {
|
2001-04-29 11:48:41 +00:00
|
|
|
struct vnode *a_vp;
|
|
|
|
daddr_t a_bn;
|
2004-11-15 09:18:27 +00:00
|
|
|
struct bufobj **a_bop;
|
2001-04-29 11:48:41 +00:00
|
|
|
daddr_t *a_bnp;
|
|
|
|
int *a_runp;
|
|
|
|
int *a_runb;
|
|
|
|
} */ *ap;
|
|
|
|
{
|
|
|
|
|
2004-11-15 09:18:27 +00:00
|
|
|
if (ap->a_bop != NULL)
|
|
|
|
*ap->a_bop = &ap->a_vp->v_bufobj;
|
2001-04-29 11:48:41 +00:00
|
|
|
if (ap->a_bnp != NULL)
|
|
|
|
*ap->a_bnp = ap->a_bn * btodb(ap->a_vp->v_mount->mnt_stat.f_iosize);
|
|
|
|
if (ap->a_runp != NULL)
|
|
|
|
*ap->a_runp = 0;
|
|
|
|
if (ap->a_runb != NULL)
|
|
|
|
*ap->a_runb = 0;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2003-02-09 11:28:35 +00:00
|
|
|
int
|
|
|
|
vop_stdfsync(ap)
|
|
|
|
struct vop_fsync_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
int a_waitfor;
|
|
|
|
struct thread *a_td;
|
|
|
|
} */ *ap;
|
|
|
|
{
|
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct buf *bp;
|
2004-10-21 15:53:54 +00:00
|
|
|
struct bufobj *bo;
|
2003-02-09 11:28:35 +00:00
|
|
|
struct buf *nbp;
|
2005-05-01 00:59:34 +00:00
|
|
|
int error = 0;
|
2005-04-03 10:24:03 +00:00
|
|
|
int maxretry = 1000; /* large, arbitrarily chosen */
|
2003-02-09 11:28:35 +00:00
|
|
|
|
2008-03-22 09:15:16 +00:00
|
|
|
bo = &vp->v_bufobj;
|
|
|
|
BO_LOCK(bo);
|
2003-02-09 11:28:35 +00:00
|
|
|
loop1:
|
|
|
|
/*
|
|
|
|
* MARK/SCAN initialization to avoid infinite loops.
|
|
|
|
*/
|
2008-03-22 09:15:16 +00:00
|
|
|
TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs) {
|
2003-02-09 11:28:35 +00:00
|
|
|
bp->b_vflags &= ~BV_SCANNED;
|
|
|
|
bp->b_error = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2005-04-03 10:24:03 +00:00
|
|
|
* Flush all dirty buffers associated with a vnode.
|
2003-02-09 11:28:35 +00:00
|
|
|
*/
|
|
|
|
loop2:
|
2008-03-22 09:15:16 +00:00
|
|
|
TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
|
2003-02-09 11:28:35 +00:00
|
|
|
if ((bp->b_vflags & BV_SCANNED) != 0)
|
|
|
|
continue;
|
|
|
|
bp->b_vflags |= BV_SCANNED;
|
2012-06-09 22:26:53 +00:00
|
|
|
if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) {
|
|
|
|
if (ap->a_waitfor != MNT_WAIT)
|
|
|
|
continue;
|
|
|
|
if (BUF_LOCK(bp,
|
|
|
|
LK_EXCLUSIVE | LK_INTERLOCK | LK_SLEEPFAIL,
|
2013-05-31 00:43:41 +00:00
|
|
|
BO_LOCKPTR(bo)) != 0) {
|
2012-06-09 22:26:53 +00:00
|
|
|
BO_LOCK(bo);
|
|
|
|
goto loop1;
|
|
|
|
}
|
|
|
|
BO_LOCK(bo);
|
|
|
|
}
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_UNLOCK(bo);
|
|
|
|
KASSERT(bp->b_bufobj == bo,
|
2005-06-14 20:32:27 +00:00
|
|
|
("bp %p wrong b_bufobj %p should be %p",
|
2008-03-22 09:15:16 +00:00
|
|
|
bp, bp->b_bufobj, bo));
|
2003-02-09 11:28:35 +00:00
|
|
|
if ((bp->b_flags & B_DELWRI) == 0)
|
2003-02-09 12:29:38 +00:00
|
|
|
panic("fsync: not dirty");
|
2005-01-24 13:13:57 +00:00
|
|
|
if ((vp->v_object != NULL) && (bp->b_flags & B_CLUSTEROK)) {
|
2003-02-09 11:28:35 +00:00
|
|
|
vfs_bio_awrite(bp);
|
|
|
|
} else {
|
|
|
|
bremfree(bp);
|
|
|
|
bawrite(bp);
|
|
|
|
}
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_LOCK(bo);
|
2003-02-09 11:28:35 +00:00
|
|
|
goto loop2;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If synchronous the caller expects us to completely resolve all
|
|
|
|
* dirty buffers in the system. Wait for in-progress I/O to
|
|
|
|
* complete (which could include background bitmap writes), then
|
|
|
|
* retry if dirty blocks still exist.
|
|
|
|
*/
|
|
|
|
if (ap->a_waitfor == MNT_WAIT) {
|
2004-10-21 15:53:54 +00:00
|
|
|
bufobj_wwait(bo, 0, 0);
|
|
|
|
if (bo->bo_dirty.bv_cnt > 0) {
|
2003-02-09 11:28:35 +00:00
|
|
|
/*
|
|
|
|
* If we are unable to write any of these buffers
|
|
|
|
* then we fail now rather than trying endlessly
|
|
|
|
* to write them out.
|
|
|
|
*/
|
2004-10-21 15:53:54 +00:00
|
|
|
TAILQ_FOREACH(bp, &bo->bo_dirty.bv_hd, b_bobufs)
|
2017-02-21 18:56:06 +00:00
|
|
|
if ((error = bp->b_error) != 0)
|
|
|
|
break;
|
2005-05-01 00:59:34 +00:00
|
|
|
if (error == 0 && --maxretry >= 0)
|
2003-02-09 11:28:35 +00:00
|
|
|
goto loop1;
|
|
|
|
error = EAGAIN;
|
|
|
|
}
|
|
|
|
}
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_UNLOCK(bo);
|
2005-04-03 10:24:03 +00:00
|
|
|
if (error == EAGAIN)
|
2016-08-10 16:12:31 +00:00
|
|
|
vn_printf(vp, "fsync: giving up on dirty ");
|
2003-03-10 21:55:00 +00:00
|
|
|
|
2003-02-09 11:28:35 +00:00
|
|
|
return (error);
|
|
|
|
}
|
2003-03-10 21:55:00 +00:00
|
|
|
|
2016-08-15 19:08:51 +00:00
|
|
|
static int
|
|
|
|
vop_stdfdatasync(struct vop_fdatasync_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (VOP_FSYNC(ap->a_vp, MNT_WAIT, ap->a_td));
|
|
|
|
}
|
|
|
|
|
2016-08-15 19:17:00 +00:00
|
|
|
int
|
|
|
|
vop_stdfdatasync_buf(struct vop_fdatasync_args *ap)
|
|
|
|
{
|
|
|
|
struct vop_fsync_args apf;
|
|
|
|
|
|
|
|
apf.a_vp = ap->a_vp;
|
|
|
|
apf.a_waitfor = MNT_WAIT;
|
|
|
|
apf.a_td = ap->a_td;
|
|
|
|
return (vop_stdfsync(&apf));
|
|
|
|
}
|
|
|
|
|
2002-03-05 15:38:49 +00:00
|
|
|
/* XXX Needs good comment and more info in the manpage (VOP_GETPAGES(9)). */
|
2001-05-01 08:34:45 +00:00
|
|
|
int
|
|
|
|
vop_stdgetpages(ap)
|
|
|
|
struct vop_getpages_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
vm_page_t *a_m;
|
|
|
|
int a_count;
|
A change to KPI of vm_pager_get_pages() and underlying VOP_GETPAGES().
o With new KPI consumers can request contiguous ranges of pages, and
unlike before, all pages will be kept busied on return, like it was
done before with the 'reqpage' only. Now the reqpage goes away. With
new interface it is easier to implement code protected from race
conditions.
Such arrayed requests for now should be preceeded by a call to
vm_pager_haspage() to make sure that request is possible. This
could be improved later, making vm_pager_haspage() obsolete.
Strenghtening the promises on the business of the array of pages
allows us to remove such hacks as swp_pager_free_nrpage() and
vm_pager_free_nonreq().
o New KPI accepts two integer pointers that may optionally point at
values for read ahead and read behind, that a pager may do, if it
can. These pages are completely owned by pager, and not controlled
by the caller.
This shifts the UFS-specific readahead logic from vm_fault.c, which
should be file system agnostic, into vnode_pager.c. It also removes
one VOP_BMAP() request per hard fault.
Discussed with: kib, alc, jeff, scottl
Sponsored by: Nginx, Inc.
Sponsored by: Netflix
2015-12-16 21:30:45 +00:00
|
|
|
int *a_rbehind;
|
|
|
|
int *a_rahead;
|
2001-05-01 08:34:45 +00:00
|
|
|
} */ *ap;
|
|
|
|
{
|
|
|
|
|
|
|
|
return vnode_pager_generic_getpages(ap->a_vp, ap->a_m,
|
A change to KPI of vm_pager_get_pages() and underlying VOP_GETPAGES().
o With new KPI consumers can request contiguous ranges of pages, and
unlike before, all pages will be kept busied on return, like it was
done before with the 'reqpage' only. Now the reqpage goes away. With
new interface it is easier to implement code protected from race
conditions.
Such arrayed requests for now should be preceeded by a call to
vm_pager_haspage() to make sure that request is possible. This
could be improved later, making vm_pager_haspage() obsolete.
Strenghtening the promises on the business of the array of pages
allows us to remove such hacks as swp_pager_free_nrpage() and
vm_pager_free_nonreq().
o New KPI accepts two integer pointers that may optionally point at
values for read ahead and read behind, that a pager may do, if it
can. These pages are completely owned by pager, and not controlled
by the caller.
This shifts the UFS-specific readahead logic from vm_fault.c, which
should be file system agnostic, into vnode_pager.c. It also removes
one VOP_BMAP() request per hard fault.
Discussed with: kib, alc, jeff, scottl
Sponsored by: Nginx, Inc.
Sponsored by: Netflix
2015-12-16 21:30:45 +00:00
|
|
|
ap->a_count, ap->a_rbehind, ap->a_rahead, NULL, NULL);
|
2014-11-23 12:01:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vop_stdgetpages_async(struct vop_getpages_async_args *ap)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
A change to KPI of vm_pager_get_pages() and underlying VOP_GETPAGES().
o With new KPI consumers can request contiguous ranges of pages, and
unlike before, all pages will be kept busied on return, like it was
done before with the 'reqpage' only. Now the reqpage goes away. With
new interface it is easier to implement code protected from race
conditions.
Such arrayed requests for now should be preceeded by a call to
vm_pager_haspage() to make sure that request is possible. This
could be improved later, making vm_pager_haspage() obsolete.
Strenghtening the promises on the business of the array of pages
allows us to remove such hacks as swp_pager_free_nrpage() and
vm_pager_free_nonreq().
o New KPI accepts two integer pointers that may optionally point at
values for read ahead and read behind, that a pager may do, if it
can. These pages are completely owned by pager, and not controlled
by the caller.
This shifts the UFS-specific readahead logic from vm_fault.c, which
should be file system agnostic, into vnode_pager.c. It also removes
one VOP_BMAP() request per hard fault.
Discussed with: kib, alc, jeff, scottl
Sponsored by: Nginx, Inc.
Sponsored by: Netflix
2015-12-16 21:30:45 +00:00
|
|
|
error = VOP_GETPAGES(ap->a_vp, ap->a_m, ap->a_count, ap->a_rbehind,
|
|
|
|
ap->a_rahead);
|
|
|
|
ap->a_iodone(ap->a_arg, ap->a_m, ap->a_count, error);
|
2014-11-23 12:01:52 +00:00
|
|
|
return (error);
|
2001-05-01 08:34:45 +00:00
|
|
|
}
|
|
|
|
|
2005-06-09 20:20:31 +00:00
|
|
|
int
|
|
|
|
vop_stdkqfilter(struct vop_kqfilter_args *ap)
|
|
|
|
{
|
|
|
|
return vfs_kqfilter(ap);
|
|
|
|
}
|
|
|
|
|
2002-03-05 15:38:49 +00:00
|
|
|
/* XXX Needs good comment and more info in the manpage (VOP_PUTPAGES(9)). */
|
2001-05-06 17:40:22 +00:00
|
|
|
int
|
2001-05-01 08:34:45 +00:00
|
|
|
vop_stdputpages(ap)
|
|
|
|
struct vop_putpages_args /* {
|
|
|
|
struct vnode *a_vp;
|
|
|
|
vm_page_t *a_m;
|
|
|
|
int a_count;
|
|
|
|
int a_sync;
|
|
|
|
int *a_rtvals;
|
|
|
|
} */ *ap;
|
|
|
|
{
|
|
|
|
|
2001-05-06 17:40:22 +00:00
|
|
|
return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
|
2001-05-01 08:34:45 +00:00
|
|
|
ap->a_sync, ap->a_rtvals);
|
|
|
|
}
|
|
|
|
|
2007-02-15 22:08:35 +00:00
|
|
|
int
|
|
|
|
vop_stdvptofh(struct vop_vptofh_args *ap)
|
|
|
|
{
|
2007-02-16 17:32:41 +00:00
|
|
|
return (EOPNOTSUPP);
|
2007-02-15 22:08:35 +00:00
|
|
|
}
|
|
|
|
|
2009-03-08 19:05:53 +00:00
|
|
|
int
|
|
|
|
vop_stdvptocnp(struct vop_vptocnp_args *ap)
|
|
|
|
{
|
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct vnode **dvp = ap->a_vpp;
|
2009-06-21 19:21:01 +00:00
|
|
|
struct ucred *cred = ap->a_cred;
|
2009-03-08 19:05:53 +00:00
|
|
|
char *buf = ap->a_buf;
|
|
|
|
int *buflen = ap->a_buflen;
|
|
|
|
char *dirbuf, *cpos;
|
|
|
|
int i, error, eofflag, dirbuflen, flags, locked, len, covered;
|
|
|
|
off_t off;
|
|
|
|
ino_t fileno;
|
|
|
|
struct vattr va;
|
|
|
|
struct nameidata nd;
|
|
|
|
struct thread *td;
|
|
|
|
struct dirent *dp;
|
|
|
|
struct vnode *mvp;
|
|
|
|
|
|
|
|
i = *buflen;
|
|
|
|
error = 0;
|
|
|
|
covered = 0;
|
|
|
|
td = curthread;
|
|
|
|
|
|
|
|
if (vp->v_type != VDIR)
|
|
|
|
return (ENOENT);
|
|
|
|
|
2009-06-21 19:21:01 +00:00
|
|
|
error = VOP_GETATTR(vp, &va, cred);
|
2009-03-08 19:05:53 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
VREF(vp);
|
|
|
|
locked = VOP_ISLOCKED(vp);
|
|
|
|
VOP_UNLOCK(vp, 0);
|
2015-07-04 15:46:39 +00:00
|
|
|
NDINIT_ATVP(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF, UIO_SYSSPACE,
|
2009-03-08 19:05:53 +00:00
|
|
|
"..", vp, td);
|
|
|
|
flags = FREAD;
|
2009-06-21 19:21:01 +00:00
|
|
|
error = vn_open_cred(&nd, &flags, 0, VN_OPEN_NOAUDIT, cred, NULL);
|
2009-03-08 19:05:53 +00:00
|
|
|
if (error) {
|
|
|
|
vn_lock(vp, locked | LK_RETRY);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
NDFREE(&nd, NDF_ONLY_PNBUF);
|
|
|
|
|
|
|
|
mvp = *dvp = nd.ni_vp;
|
|
|
|
|
|
|
|
if (vp->v_mount != (*dvp)->v_mount &&
|
|
|
|
((*dvp)->v_vflag & VV_ROOT) &&
|
|
|
|
((*dvp)->v_mount->mnt_flag & MNT_UNION)) {
|
|
|
|
*dvp = (*dvp)->v_mount->mnt_vnodecovered;
|
|
|
|
VREF(mvp);
|
|
|
|
VOP_UNLOCK(mvp, 0);
|
2009-06-21 19:21:01 +00:00
|
|
|
vn_close(mvp, FREAD, cred, td);
|
2009-03-08 19:05:53 +00:00
|
|
|
VREF(*dvp);
|
2015-07-04 15:46:39 +00:00
|
|
|
vn_lock(*dvp, LK_SHARED | LK_RETRY);
|
2009-03-08 19:05:53 +00:00
|
|
|
covered = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
fileno = va.va_fileid;
|
|
|
|
|
|
|
|
dirbuflen = DEV_BSIZE;
|
|
|
|
if (dirbuflen < va.va_blocksize)
|
|
|
|
dirbuflen = va.va_blocksize;
|
|
|
|
dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
|
|
|
|
|
|
|
|
if ((*dvp)->v_type != VDIR) {
|
|
|
|
error = ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
off = 0;
|
|
|
|
len = 0;
|
|
|
|
do {
|
|
|
|
/* call VOP_READDIR of parent */
|
|
|
|
error = get_next_dirent(*dvp, &dp, dirbuf, dirbuflen, &off,
|
|
|
|
&cpos, &len, &eofflag, td);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if ((dp->d_type != DT_WHT) &&
|
|
|
|
(dp->d_fileno == fileno)) {
|
|
|
|
if (covered) {
|
|
|
|
VOP_UNLOCK(*dvp, 0);
|
2015-07-04 15:46:39 +00:00
|
|
|
vn_lock(mvp, LK_SHARED | LK_RETRY);
|
2009-03-08 19:05:53 +00:00
|
|
|
if (dirent_exists(mvp, dp->d_name, td)) {
|
|
|
|
error = ENOENT;
|
|
|
|
VOP_UNLOCK(mvp, 0);
|
2015-07-04 15:46:39 +00:00
|
|
|
vn_lock(*dvp, LK_SHARED | LK_RETRY);
|
2009-03-08 19:05:53 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
VOP_UNLOCK(mvp, 0);
|
2015-07-04 15:46:39 +00:00
|
|
|
vn_lock(*dvp, LK_SHARED | LK_RETRY);
|
2009-03-08 19:05:53 +00:00
|
|
|
}
|
|
|
|
i -= dp->d_namlen;
|
|
|
|
|
|
|
|
if (i < 0) {
|
|
|
|
error = ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2013-03-01 18:40:14 +00:00
|
|
|
if (dp->d_namlen == 1 && dp->d_name[0] == '.') {
|
|
|
|
error = ENOENT;
|
|
|
|
} else {
|
|
|
|
bcopy(dp->d_name, buf + i, dp->d_namlen);
|
|
|
|
error = 0;
|
|
|
|
}
|
2009-03-08 19:05:53 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} while (len > 0 || !eofflag);
|
|
|
|
error = ENOENT;
|
|
|
|
|
|
|
|
out:
|
|
|
|
free(dirbuf, M_TEMP);
|
|
|
|
if (!error) {
|
|
|
|
*buflen = i;
|
2011-11-19 07:50:49 +00:00
|
|
|
vref(*dvp);
|
2009-03-08 19:05:53 +00:00
|
|
|
}
|
|
|
|
if (covered) {
|
|
|
|
vput(*dvp);
|
|
|
|
vrele(mvp);
|
|
|
|
} else {
|
|
|
|
VOP_UNLOCK(mvp, 0);
|
2009-06-21 19:21:01 +00:00
|
|
|
vn_close(mvp, FREAD, cred, td);
|
2009-03-08 19:05:53 +00:00
|
|
|
}
|
|
|
|
vn_lock(vp, locked | LK_RETRY);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-04-18 16:32:22 +00:00
|
|
|
int
|
|
|
|
vop_stdallocate(struct vop_allocate_args *ap)
|
|
|
|
{
|
|
|
|
#ifdef __notyet__
|
2017-01-05 17:19:26 +00:00
|
|
|
struct statfs *sfs;
|
|
|
|
off_t maxfilesize = 0;
|
2011-04-18 16:32:22 +00:00
|
|
|
#endif
|
|
|
|
struct iovec aiov;
|
|
|
|
struct vattr vattr, *vap;
|
|
|
|
struct uio auio;
|
2011-04-19 16:36:24 +00:00
|
|
|
off_t fsize, len, cur, offset;
|
2011-04-18 16:32:22 +00:00
|
|
|
uint8_t *buf;
|
|
|
|
struct thread *td;
|
|
|
|
struct vnode *vp;
|
|
|
|
size_t iosize;
|
2011-04-19 16:36:24 +00:00
|
|
|
int error;
|
2011-04-18 16:32:22 +00:00
|
|
|
|
|
|
|
buf = NULL;
|
|
|
|
error = 0;
|
|
|
|
td = curthread;
|
|
|
|
vap = &vattr;
|
|
|
|
vp = ap->a_vp;
|
2011-04-19 16:36:24 +00:00
|
|
|
len = *ap->a_len;
|
|
|
|
offset = *ap->a_offset;
|
2011-04-18 16:32:22 +00:00
|
|
|
|
|
|
|
error = VOP_GETATTR(vp, vap, td->td_ucred);
|
|
|
|
if (error != 0)
|
|
|
|
goto out;
|
2011-04-19 16:36:24 +00:00
|
|
|
fsize = vap->va_size;
|
2011-04-18 16:32:22 +00:00
|
|
|
iosize = vap->va_blocksize;
|
|
|
|
if (iosize == 0)
|
|
|
|
iosize = BLKDEV_IOSIZE;
|
|
|
|
if (iosize > MAXPHYS)
|
|
|
|
iosize = MAXPHYS;
|
|
|
|
buf = malloc(iosize, M_TEMP, M_WAITOK);
|
|
|
|
|
|
|
|
#ifdef __notyet__
|
|
|
|
/*
|
|
|
|
* Check if the filesystem sets f_maxfilesize; if not use
|
|
|
|
* VOP_SETATTR to perform the check.
|
|
|
|
*/
|
2017-01-05 17:19:26 +00:00
|
|
|
sfs = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
|
|
|
|
error = VFS_STATFS(vp->v_mount, sfs, td);
|
|
|
|
if (error == 0)
|
|
|
|
maxfilesize = sfs->f_maxfilesize;
|
|
|
|
free(sfs, M_STATFS);
|
2011-04-18 16:32:22 +00:00
|
|
|
if (error != 0)
|
|
|
|
goto out;
|
2017-01-05 17:19:26 +00:00
|
|
|
if (maxfilesize) {
|
|
|
|
if (offset > maxfilesize || len > maxfilesize ||
|
|
|
|
offset + len > maxfilesize) {
|
2011-04-18 16:32:22 +00:00
|
|
|
error = EFBIG;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
if (offset + len > vap->va_size) {
|
2011-04-19 16:36:24 +00:00
|
|
|
/*
|
|
|
|
* Test offset + len against the filesystem's maxfilesize.
|
|
|
|
*/
|
2011-04-18 16:32:22 +00:00
|
|
|
VATTR_NULL(vap);
|
|
|
|
vap->va_size = offset + len;
|
|
|
|
error = VOP_SETATTR(vp, vap, td->td_ucred);
|
|
|
|
if (error != 0)
|
|
|
|
goto out;
|
2011-04-19 16:36:24 +00:00
|
|
|
VATTR_NULL(vap);
|
|
|
|
vap->va_size = fsize;
|
|
|
|
error = VOP_SETATTR(vp, vap, td->td_ucred);
|
|
|
|
if (error != 0)
|
|
|
|
goto out;
|
2011-04-18 16:32:22 +00:00
|
|
|
}
|
|
|
|
|
2011-04-19 16:36:24 +00:00
|
|
|
for (;;) {
|
2011-04-18 16:32:22 +00:00
|
|
|
/*
|
|
|
|
* Read and write back anything below the nominal file
|
|
|
|
* size. There's currently no way outside the filesystem
|
|
|
|
* to know whether this area is sparse or not.
|
|
|
|
*/
|
|
|
|
cur = iosize;
|
|
|
|
if ((offset % iosize) != 0)
|
|
|
|
cur -= (offset % iosize);
|
|
|
|
if (cur > len)
|
|
|
|
cur = len;
|
2011-04-19 16:36:24 +00:00
|
|
|
if (offset < fsize) {
|
2011-04-18 16:32:22 +00:00
|
|
|
aiov.iov_base = buf;
|
|
|
|
aiov.iov_len = cur;
|
|
|
|
auio.uio_iov = &aiov;
|
|
|
|
auio.uio_iovcnt = 1;
|
|
|
|
auio.uio_offset = offset;
|
|
|
|
auio.uio_resid = cur;
|
|
|
|
auio.uio_segflg = UIO_SYSSPACE;
|
|
|
|
auio.uio_rw = UIO_READ;
|
|
|
|
auio.uio_td = td;
|
|
|
|
error = VOP_READ(vp, &auio, 0, td->td_ucred);
|
|
|
|
if (error != 0)
|
|
|
|
break;
|
|
|
|
if (auio.uio_resid > 0) {
|
|
|
|
bzero(buf + cur - auio.uio_resid,
|
|
|
|
auio.uio_resid);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
bzero(buf, cur);
|
|
|
|
}
|
|
|
|
|
|
|
|
aiov.iov_base = buf;
|
|
|
|
aiov.iov_len = cur;
|
|
|
|
auio.uio_iov = &aiov;
|
|
|
|
auio.uio_iovcnt = 1;
|
|
|
|
auio.uio_offset = offset;
|
|
|
|
auio.uio_resid = cur;
|
|
|
|
auio.uio_segflg = UIO_SYSSPACE;
|
|
|
|
auio.uio_rw = UIO_WRITE;
|
|
|
|
auio.uio_td = td;
|
|
|
|
|
|
|
|
error = VOP_WRITE(vp, &auio, 0, td->td_ucred);
|
|
|
|
if (error != 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
len -= cur;
|
|
|
|
offset += cur;
|
2011-04-19 16:36:24 +00:00
|
|
|
if (len == 0)
|
|
|
|
break;
|
|
|
|
if (should_yield())
|
|
|
|
break;
|
2011-04-18 16:32:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2011-04-19 16:36:24 +00:00
|
|
|
*ap->a_len = len;
|
|
|
|
*ap->a_offset = offset;
|
2011-04-18 16:32:22 +00:00
|
|
|
free(buf, M_TEMP);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-11-04 04:02:50 +00:00
|
|
|
int
|
|
|
|
vop_stdadvise(struct vop_advise_args *ap)
|
|
|
|
{
|
|
|
|
struct vnode *vp;
|
2015-12-16 08:48:37 +00:00
|
|
|
struct bufobj *bo;
|
|
|
|
daddr_t startn, endn;
|
2011-11-04 04:02:50 +00:00
|
|
|
off_t start, end;
|
2015-09-30 23:06:29 +00:00
|
|
|
int bsize, error;
|
2011-11-04 04:02:50 +00:00
|
|
|
|
|
|
|
vp = ap->a_vp;
|
|
|
|
switch (ap->a_advice) {
|
|
|
|
case POSIX_FADV_WILLNEED:
|
|
|
|
/*
|
|
|
|
* Do nothing for now. Filesystems should provide a
|
|
|
|
* custom method which starts an asynchronous read of
|
|
|
|
* the requested region.
|
|
|
|
*/
|
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
case POSIX_FADV_DONTNEED:
|
|
|
|
error = 0;
|
|
|
|
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
|
|
|
|
if (vp->v_iflag & VI_DOOMED) {
|
|
|
|
VOP_UNLOCK(vp, 0);
|
|
|
|
break;
|
|
|
|
}
|
2015-09-30 23:06:29 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Deactivate pages in the specified range from the backing VM
|
|
|
|
* object. Pages that are resident in the buffer cache will
|
|
|
|
* remain wired until their corresponding buffers are released
|
|
|
|
* below.
|
|
|
|
*/
|
2011-11-04 04:02:50 +00:00
|
|
|
if (vp->v_object != NULL) {
|
|
|
|
start = trunc_page(ap->a_start);
|
|
|
|
end = round_page(ap->a_end);
|
2017-03-15 17:43:45 +00:00
|
|
|
VM_OBJECT_RLOCK(vp->v_object);
|
2015-09-30 23:06:29 +00:00
|
|
|
vm_object_page_noreuse(vp->v_object, OFF_TO_IDX(start),
|
2011-11-04 04:02:50 +00:00
|
|
|
OFF_TO_IDX(end));
|
2017-03-15 17:43:45 +00:00
|
|
|
VM_OBJECT_RUNLOCK(vp->v_object);
|
2011-11-04 04:02:50 +00:00
|
|
|
}
|
2015-09-30 23:06:29 +00:00
|
|
|
|
2015-12-16 08:48:37 +00:00
|
|
|
bo = &vp->v_bufobj;
|
|
|
|
BO_RLOCK(bo);
|
2015-09-30 23:06:29 +00:00
|
|
|
bsize = vp->v_bufobj.bo_bsize;
|
|
|
|
startn = ap->a_start / bsize;
|
2015-12-16 08:48:37 +00:00
|
|
|
endn = ap->a_end / bsize;
|
2016-01-05 14:48:40 +00:00
|
|
|
error = bnoreuselist(&bo->bo_clean, bo, startn, endn);
|
|
|
|
if (error == 0)
|
2015-12-16 08:48:37 +00:00
|
|
|
error = bnoreuselist(&bo->bo_dirty, bo, startn, endn);
|
|
|
|
BO_RUNLOCK(bo);
|
2011-11-04 04:02:50 +00:00
|
|
|
VOP_UNLOCK(vp, 0);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2012-02-29 21:38:31 +00:00
|
|
|
int
|
|
|
|
vop_stdunp_bind(struct vop_unp_bind_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
ap->a_vp->v_socket = ap->a_socket;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
vop_stdunp_connect(struct vop_unp_connect_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
*ap->a_socket = ap->a_vp->v_socket;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
vop_stdunp_detach(struct vop_unp_detach_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
ap->a_vp->v_socket = NULL;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2012-09-28 11:25:02 +00:00
|
|
|
static int
|
|
|
|
vop_stdis_text(struct vop_is_text_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
return ((ap->a_vp->v_vflag & VV_TEXT) != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vop_stdset_text(struct vop_set_text_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
ap->a_vp->v_vflag |= VV_TEXT;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vop_stdunset_text(struct vop_unset_text_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
ap->a_vp->v_vflag &= ~VV_TEXT;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2012-11-02 13:56:36 +00:00
|
|
|
static int
|
|
|
|
vop_stdget_writecount(struct vop_get_writecount_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
*ap->a_writecount = ap->a_vp->v_writecount;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vop_stdadd_writecount(struct vop_add_writecount_args *ap)
|
|
|
|
{
|
|
|
|
|
|
|
|
ap->a_vp->v_writecount += ap->a_inc;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2003-03-10 21:55:00 +00:00
|
|
|
/*
|
1999-09-07 22:42:38 +00:00
|
|
|
* vfs default ops
|
2002-03-05 15:38:49 +00:00
|
|
|
* used to fill the vfs function table to get reasonable default return values.
|
1999-09-07 22:42:38 +00:00
|
|
|
*/
|
2002-03-05 15:38:49 +00:00
|
|
|
int
|
2009-05-11 15:33:26 +00:00
|
|
|
vfs_stdroot (mp, flags, vpp)
|
1999-09-07 22:42:38 +00:00
|
|
|
struct mount *mp;
|
2005-03-24 07:30:00 +00:00
|
|
|
int flags;
|
1999-09-07 22:42:38 +00:00
|
|
|
struct vnode **vpp;
|
|
|
|
{
|
2004-07-07 07:00:02 +00:00
|
|
|
|
1999-09-07 22:42:38 +00:00
|
|
|
return (EOPNOTSUPP);
|
|
|
|
}
|
|
|
|
|
2002-03-05 15:38:49 +00:00
|
|
|
int
|
2009-05-11 15:33:26 +00:00
|
|
|
vfs_stdstatfs (mp, sbp)
|
1999-09-07 22:42:38 +00:00
|
|
|
struct mount *mp;
|
|
|
|
struct statfs *sbp;
|
|
|
|
{
|
2004-07-07 07:00:02 +00:00
|
|
|
|
1999-09-07 22:42:38 +00:00
|
|
|
return (EOPNOTSUPP);
|
|
|
|
}
|
|
|
|
|
2003-03-10 21:55:00 +00:00
|
|
|
int
|
2009-05-11 15:33:26 +00:00
|
|
|
vfs_stdquotactl (mp, cmds, uid, arg)
|
1999-09-07 22:42:38 +00:00
|
|
|
struct mount *mp;
|
|
|
|
int cmds;
|
|
|
|
uid_t uid;
|
2005-12-14 00:49:52 +00:00
|
|
|
void *arg;
|
1999-09-07 22:42:38 +00:00
|
|
|
{
|
2004-07-07 07:00:02 +00:00
|
|
|
|
1999-09-07 22:42:38 +00:00
|
|
|
return (EOPNOTSUPP);
|
|
|
|
}
|
|
|
|
|
2003-03-10 21:55:00 +00:00
|
|
|
int
|
2009-05-11 15:33:26 +00:00
|
|
|
vfs_stdsync(mp, waitfor)
|
2003-03-11 22:15:10 +00:00
|
|
|
struct mount *mp;
|
|
|
|
int waitfor;
|
|
|
|
{
|
2006-01-09 20:42:19 +00:00
|
|
|
struct vnode *vp, *mvp;
|
2009-05-11 15:33:26 +00:00
|
|
|
struct thread *td;
|
2003-03-11 22:15:10 +00:00
|
|
|
int error, lockreq, allerror = 0;
|
|
|
|
|
2009-05-11 15:33:26 +00:00
|
|
|
td = curthread;
|
2003-03-11 22:15:10 +00:00
|
|
|
lockreq = LK_EXCLUSIVE | LK_INTERLOCK;
|
|
|
|
if (waitfor != MNT_WAIT)
|
|
|
|
lockreq |= LK_NOWAIT;
|
|
|
|
/*
|
|
|
|
* Force stale buffer cache information to be flushed.
|
|
|
|
*/
|
|
|
|
loop:
|
2012-04-17 16:28:22 +00:00
|
|
|
MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
|
|
|
|
if (vp->v_bufobj.bo_dirty.bv_cnt == 0) {
|
|
|
|
VI_UNLOCK(vp);
|
2003-03-11 22:15:10 +00:00
|
|
|
continue;
|
2012-04-17 16:28:22 +00:00
|
|
|
}
|
2003-03-11 22:15:10 +00:00
|
|
|
if ((error = vget(vp, lockreq, td)) != 0) {
|
2006-01-09 20:42:19 +00:00
|
|
|
if (error == ENOENT) {
|
2012-04-17 16:28:22 +00:00
|
|
|
MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
|
2003-03-11 22:15:10 +00:00
|
|
|
goto loop;
|
2006-01-09 20:42:19 +00:00
|
|
|
}
|
2003-03-11 22:15:10 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-01-11 07:36:22 +00:00
|
|
|
error = VOP_FSYNC(vp, waitfor, td);
|
2003-03-11 22:15:10 +00:00
|
|
|
if (error)
|
|
|
|
allerror = error;
|
2010-02-18 22:14:44 +00:00
|
|
|
vput(vp);
|
2003-03-11 22:15:10 +00:00
|
|
|
}
|
|
|
|
return (allerror);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-05-11 15:33:26 +00:00
|
|
|
vfs_stdnosync (mp, waitfor)
|
1999-09-07 22:42:38 +00:00
|
|
|
struct mount *mp;
|
|
|
|
int waitfor;
|
|
|
|
{
|
2004-07-07 07:00:02 +00:00
|
|
|
|
1999-09-07 22:42:38 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2003-03-10 21:55:00 +00:00
|
|
|
int
|
2002-03-17 01:25:47 +00:00
|
|
|
vfs_stdvget (mp, ino, flags, vpp)
|
1999-09-07 22:42:38 +00:00
|
|
|
struct mount *mp;
|
|
|
|
ino_t ino;
|
2002-03-17 01:25:47 +00:00
|
|
|
int flags;
|
1999-09-07 22:42:38 +00:00
|
|
|
struct vnode **vpp;
|
|
|
|
{
|
2004-07-07 07:00:02 +00:00
|
|
|
|
1999-09-07 22:42:38 +00:00
|
|
|
return (EOPNOTSUPP);
|
|
|
|
}
|
|
|
|
|
2003-03-10 21:55:00 +00:00
|
|
|
int
|
2011-05-22 01:07:54 +00:00
|
|
|
vfs_stdfhtovp (mp, fhp, flags, vpp)
|
1999-09-07 22:42:38 +00:00
|
|
|
struct mount *mp;
|
|
|
|
struct fid *fhp;
|
2011-05-22 01:07:54 +00:00
|
|
|
int flags;
|
1999-09-07 22:42:38 +00:00
|
|
|
struct vnode **vpp;
|
1999-09-11 00:46:08 +00:00
|
|
|
{
|
2004-07-07 07:00:02 +00:00
|
|
|
|
1999-09-11 00:46:08 +00:00
|
|
|
return (EOPNOTSUPP);
|
|
|
|
}
|
|
|
|
|
1999-09-07 22:42:38 +00:00
|
|
|
int
|
2003-03-10 21:55:00 +00:00
|
|
|
vfs_stdinit (vfsp)
|
1999-09-07 22:42:38 +00:00
|
|
|
struct vfsconf *vfsp;
|
|
|
|
{
|
2004-07-07 07:00:02 +00:00
|
|
|
|
1999-09-07 22:42:38 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
vfs_stduninit (vfsp)
|
|
|
|
struct vfsconf *vfsp;
|
|
|
|
{
|
2004-07-07 07:00:02 +00:00
|
|
|
|
1999-09-07 22:42:38 +00:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
1999-12-19 06:08:07 +00:00
|
|
|
int
|
2009-05-11 15:33:26 +00:00
|
|
|
vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname)
|
1999-12-19 06:08:07 +00:00
|
|
|
struct mount *mp;
|
|
|
|
int cmd;
|
o Change the API and ABI of the Extended Attribute kernel interfaces to
introduce a new argument, "namespace", rather than relying on a first-
character namespace indicator. This is in line with more recent
thinking on EA interfaces on various mailing lists, including the
posix1e, Linux acl-devel, and trustedbsd-discuss forums. Two namespaces
are defined by default, EXTATTR_NAMESPACE_SYSTEM and
EXTATTR_NAMESPACE_USER, where the primary distinction lies in the
access control model: user EAs are accessible based on the normal
MAC and DAC file/directory protections, and system attributes are
limited to kernel-originated or appropriately privileged userland
requests.
o These API changes occur at several levels: the namespace argument is
introduced in the extattr_{get,set}_file() system call interfaces,
at the vnode operation level in the vop_{get,set}extattr() interfaces,
and in the UFS extended attribute implementation. Changes are also
introduced in the VFS extattrctl() interface (system call, VFS,
and UFS implementation), where the arguments are modified to include
a namespace field, as well as modified to advoid direct access to
userspace variables from below the VFS layer (in the style of recent
changes to mount by adrian@FreeBSD.org). This required some cleanup
and bug fixing regarding VFS locks and the VFS interface, as a vnode
pointer may now be optionally submitted to the VFS_EXTATTRCTL()
call. Updated documentation for the VFS interface will be committed
shortly.
o In the near future, the auto-starting feature will be updated to
search two sub-directories to the ".attribute" directory in appropriate
file systems: "user" and "system" to locate attributes intended for
those namespaces, as the single filename is no longer sufficient
to indicate what namespace the attribute is intended for. Until this
is committed, all attributes auto-started by UFS will be placed in
the EXTATTR_NAMESPACE_SYSTEM namespace.
o The default POSIX.1e attribute names for ACLs and Capabilities have
been updated to no longer include the '$' in their filename. As such,
if you're using these features, you'll need to rename the attribute
backing files to the same names without '$' symbols in front.
o Note that these changes will require changes in userland, which will
be committed shortly. These include modifications to the extended
attribute utilities, as well as to libutil for new namespace
string conversion routines. Once the matching userland changes are
committed, a buildworld is recommended to update all the necessary
include files and verify that the kernel and userland environments
are in sync. Note: If you do not use extended attributes (most people
won't), upgrading is not imperative although since the system call
API has changed, the new userland extended attribute code will no longer
compile with old include files.
o Couple of minor cleanups while I'm there: make more code compilation
conditional on FFS_EXTATTR, which should recover a bit of space on
kernels running without EA's, as well as update copyright dates.
Obtained from: TrustedBSD Project
2001-03-15 02:54:29 +00:00
|
|
|
struct vnode *filename_vp;
|
2001-03-19 05:44:15 +00:00
|
|
|
int attrnamespace;
|
2000-01-19 06:07:34 +00:00
|
|
|
const char *attrname;
|
1999-12-19 06:08:07 +00:00
|
|
|
{
|
2004-07-07 07:00:02 +00:00
|
|
|
|
2002-08-13 11:11:51 +00:00
|
|
|
if (filename_vp != NULL)
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(filename_vp, 0);
|
2004-07-07 07:00:02 +00:00
|
|
|
return (EOPNOTSUPP);
|
1999-12-19 06:08:07 +00:00
|
|
|
}
|
|
|
|
|
2004-07-07 06:58:29 +00:00
|
|
|
int
|
|
|
|
vfs_stdsysctl(mp, op, req)
|
|
|
|
struct mount *mp;
|
|
|
|
fsctlop_t op;
|
|
|
|
struct sysctl_req *req;
|
|
|
|
{
|
|
|
|
|
|
|
|
return (EOPNOTSUPP);
|
|
|
|
}
|
|
|
|
|
1999-09-07 22:42:38 +00:00
|
|
|
/* end of vfs default ops */
|