2005-01-07 01:45:51 +00:00
|
|
|
/*-
|
1994-05-24 10:09:53 +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
|
|
|
|
* Rick Macklem at The University of Guelph.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
1997-02-10 02:22:35 +00:00
|
|
|
* @(#)nfs_vnops.c 8.16 (Berkeley) 5/27/95
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
2001-09-18 23:32:09 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
1997-02-10 02:22:35 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1995-06-27 11:07:30 +00:00
|
|
|
* vnode op calls for Sun NFS version 2 and 3
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
1998-01-08 23:42:31 +00:00
|
|
|
#include "opt_inet.h"
|
2009-03-24 17:14:34 +00:00
|
|
|
#include "opt_kdtrace.h"
|
1998-01-08 23:42:31 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/systm.h>
|
1995-06-27 11:07:30 +00:00
|
|
|
#include <sys/resourcevar.h>
|
|
|
|
#include <sys/proc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/mount.h>
|
2000-05-05 09:59:14 +00:00
|
|
|
#include <sys/bio.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/buf.h>
|
2009-08-24 10:09:30 +00:00
|
|
|
#include <sys/jail.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/mbuf.h>
|
|
|
|
#include <sys/namei.h>
|
1998-03-28 12:04:40 +00:00
|
|
|
#include <sys/socket.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/vnode.h>
|
|
|
|
#include <sys/dirent.h>
|
1995-06-27 11:07:30 +00:00
|
|
|
#include <sys/fcntl.h>
|
1994-08-08 17:31:01 +00:00
|
|
|
#include <sys/lockf.h>
|
1998-05-31 20:09:01 +00:00
|
|
|
#include <sys/stat.h>
|
1998-11-13 02:39:09 +00:00
|
|
|
#include <sys/sysctl.h>
|
2004-12-06 21:11:15 +00:00
|
|
|
#include <sys/signalvar.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
#include <vm/vm.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/vm_extern.h>
|
2004-12-01 07:34:08 +00:00
|
|
|
#include <vm/vm_object.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
#include <nfs/nfsproto.h>
|
2001-09-18 23:32:09 +00:00
|
|
|
#include <nfsclient/nfs.h>
|
|
|
|
#include <nfsclient/nfsnode.h>
|
|
|
|
#include <nfsclient/nfsmount.h>
|
2011-05-06 20:02:19 +00:00
|
|
|
#include <nfs/nfs_kdtrace.h>
|
2010-07-24 22:11:11 +00:00
|
|
|
#include <nfs/nfs_lock.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <nfs/xdr_subs.h>
|
2001-09-18 23:32:09 +00:00
|
|
|
#include <nfsclient/nfsm_subs.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
#include <net/if.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/in_var.h>
|
|
|
|
|
2009-03-24 17:14:34 +00:00
|
|
|
#include <machine/stdarg.h>
|
|
|
|
|
|
|
|
#ifdef KDTRACE_HOOKS
|
|
|
|
#include <sys/dtrace_bsd.h>
|
|
|
|
|
|
|
|
dtrace_nfsclient_accesscache_flush_probe_func_t
|
|
|
|
dtrace_nfsclient_accesscache_flush_done_probe;
|
|
|
|
uint32_t nfsclient_accesscache_flush_done_id;
|
|
|
|
|
|
|
|
dtrace_nfsclient_accesscache_get_probe_func_t
|
|
|
|
dtrace_nfsclient_accesscache_get_hit_probe,
|
|
|
|
dtrace_nfsclient_accesscache_get_miss_probe;
|
|
|
|
uint32_t nfsclient_accesscache_get_hit_id;
|
|
|
|
uint32_t nfsclient_accesscache_get_miss_id;
|
|
|
|
|
|
|
|
dtrace_nfsclient_accesscache_load_probe_func_t
|
|
|
|
dtrace_nfsclient_accesscache_load_done_probe;
|
|
|
|
uint32_t nfsclient_accesscache_load_done_id;
|
|
|
|
#endif /* !KDTRACE_HOOKS */
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/* Defs */
|
|
|
|
#define TRUE 1
|
|
|
|
#define FALSE 0
|
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
/*
|
|
|
|
* Ifdef for FreeBSD-current merged buffer cache. It is unfortunate that these
|
|
|
|
* calls are not in getblk() and brelse() so that they would not be necessary
|
|
|
|
* here.
|
|
|
|
*/
|
|
|
|
#ifndef B_VMIO
|
|
|
|
#define vfs_busy_pages(bp, f)
|
|
|
|
#endif
|
|
|
|
|
2004-12-01 19:08:40 +00:00
|
|
|
static vop_read_t nfsfifo_read;
|
|
|
|
static vop_write_t nfsfifo_write;
|
|
|
|
static vop_close_t nfsfifo_close;
|
2008-08-28 15:23:18 +00:00
|
|
|
static int nfs_flush(struct vnode *, int, int);
|
|
|
|
static int nfs_setattrrpc(struct vnode *, struct vattr *, struct ucred *);
|
2004-12-01 19:08:40 +00:00
|
|
|
static vop_lookup_t nfs_lookup;
|
|
|
|
static vop_create_t nfs_create;
|
|
|
|
static vop_mknod_t nfs_mknod;
|
|
|
|
static vop_open_t nfs_open;
|
|
|
|
static vop_close_t nfs_close;
|
|
|
|
static vop_access_t nfs_access;
|
|
|
|
static vop_getattr_t nfs_getattr;
|
|
|
|
static vop_setattr_t nfs_setattr;
|
|
|
|
static vop_read_t nfs_read;
|
|
|
|
static vop_fsync_t nfs_fsync;
|
|
|
|
static vop_remove_t nfs_remove;
|
|
|
|
static vop_link_t nfs_link;
|
|
|
|
static vop_rename_t nfs_rename;
|
|
|
|
static vop_mkdir_t nfs_mkdir;
|
|
|
|
static vop_rmdir_t nfs_rmdir;
|
|
|
|
static vop_symlink_t nfs_symlink;
|
|
|
|
static vop_readdir_t nfs_readdir;
|
|
|
|
static vop_strategy_t nfs_strategy;
|
2001-09-18 23:32:09 +00:00
|
|
|
static int nfs_lookitup(struct vnode *, const char *, int,
|
|
|
|
struct ucred *, struct thread *, struct nfsnode **);
|
|
|
|
static int nfs_sillyrename(struct vnode *, struct vnode *,
|
|
|
|
struct componentname *);
|
2004-12-01 19:08:40 +00:00
|
|
|
static vop_access_t nfsspec_access;
|
|
|
|
static vop_readlink_t nfs_readlink;
|
|
|
|
static vop_print_t nfs_print;
|
|
|
|
static vop_advlock_t nfs_advlock;
|
2008-03-26 15:23:12 +00:00
|
|
|
static vop_advlockasync_t nfs_advlockasync;
|
2001-09-18 23:32:09 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Global vfs data structures for nfs
|
|
|
|
*/
|
2004-12-01 23:16:38 +00:00
|
|
|
struct vop_vector nfs_vnodeops = {
|
|
|
|
.vop_default = &default_vnodeops,
|
|
|
|
.vop_access = nfs_access,
|
|
|
|
.vop_advlock = nfs_advlock,
|
2008-03-26 15:23:12 +00:00
|
|
|
.vop_advlockasync = nfs_advlockasync,
|
2004-12-01 23:16:38 +00:00
|
|
|
.vop_close = nfs_close,
|
|
|
|
.vop_create = nfs_create,
|
|
|
|
.vop_fsync = nfs_fsync,
|
|
|
|
.vop_getattr = nfs_getattr,
|
|
|
|
.vop_getpages = nfs_getpages,
|
|
|
|
.vop_putpages = nfs_putpages,
|
|
|
|
.vop_inactive = nfs_inactive,
|
|
|
|
.vop_link = nfs_link,
|
|
|
|
.vop_lookup = nfs_lookup,
|
|
|
|
.vop_mkdir = nfs_mkdir,
|
|
|
|
.vop_mknod = nfs_mknod,
|
|
|
|
.vop_open = nfs_open,
|
|
|
|
.vop_print = nfs_print,
|
|
|
|
.vop_read = nfs_read,
|
|
|
|
.vop_readdir = nfs_readdir,
|
|
|
|
.vop_readlink = nfs_readlink,
|
|
|
|
.vop_reclaim = nfs_reclaim,
|
|
|
|
.vop_remove = nfs_remove,
|
|
|
|
.vop_rename = nfs_rename,
|
|
|
|
.vop_rmdir = nfs_rmdir,
|
|
|
|
.vop_setattr = nfs_setattr,
|
|
|
|
.vop_strategy = nfs_strategy,
|
|
|
|
.vop_symlink = nfs_symlink,
|
|
|
|
.vop_write = nfs_write,
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
2004-12-01 23:16:38 +00:00
|
|
|
|
|
|
|
struct vop_vector nfs_fifoops = {
|
|
|
|
.vop_default = &fifo_specops,
|
|
|
|
.vop_access = nfsspec_access,
|
|
|
|
.vop_close = nfsfifo_close,
|
|
|
|
.vop_fsync = nfs_fsync,
|
|
|
|
.vop_getattr = nfs_getattr,
|
|
|
|
.vop_inactive = nfs_inactive,
|
|
|
|
.vop_print = nfs_print,
|
|
|
|
.vop_read = nfsfifo_read,
|
|
|
|
.vop_reclaim = nfs_reclaim,
|
|
|
|
.vop_setattr = nfs_setattr,
|
|
|
|
.vop_write = nfsfifo_write,
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
|
|
|
|
2001-09-18 23:32:09 +00:00
|
|
|
static int nfs_mknodrpc(struct vnode *dvp, struct vnode **vpp,
|
|
|
|
struct componentname *cnp, struct vattr *vap);
|
|
|
|
static int nfs_removerpc(struct vnode *dvp, const char *name, int namelen,
|
|
|
|
struct ucred *cred, struct thread *td);
|
|
|
|
static int nfs_renamerpc(struct vnode *fdvp, const char *fnameptr,
|
|
|
|
int fnamelen, struct vnode *tdvp,
|
|
|
|
const char *tnameptr, int tnamelen,
|
|
|
|
struct ucred *cred, struct thread *td);
|
|
|
|
static int nfs_renameit(struct vnode *sdvp, struct componentname *scnp,
|
|
|
|
struct sillyrename *sp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Global variables
|
|
|
|
*/
|
2006-05-19 00:04:24 +00:00
|
|
|
struct mtx nfs_iod_mtx;
|
2010-01-27 15:22:20 +00:00
|
|
|
enum nfsiod_state nfs_iodwant[NFS_MAXASYNCDAEMON];
|
1996-11-06 10:53:16 +00:00
|
|
|
struct nfsmount *nfs_iodmount[NFS_MAXASYNCDAEMON];
|
2001-09-18 23:32:09 +00:00
|
|
|
int nfs_numasync = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
#define DIRHDSIZ (sizeof (struct dirent) - (MAXNAMLEN + 1))
|
|
|
|
|
2011-05-15 20:52:43 +00:00
|
|
|
SYSCTL_DECL(_vfs_oldnfs);
|
1999-02-16 10:49:55 +00:00
|
|
|
|
1999-07-31 01:51:58 +00:00
|
|
|
static int nfsaccess_cache_timeout = NFS_MAXATTRTIMO;
|
2011-05-15 20:52:43 +00:00
|
|
|
SYSCTL_INT(_vfs_oldnfs, OID_AUTO, access_cache_timeout, CTLFLAG_RW,
|
1998-11-13 02:39:09 +00:00
|
|
|
&nfsaccess_cache_timeout, 0, "NFS ACCESS cache timeout");
|
|
|
|
|
2009-02-24 16:01:56 +00:00
|
|
|
static int nfs_prime_access_cache = 0;
|
2011-05-15 20:52:43 +00:00
|
|
|
SYSCTL_INT(_vfs_oldnfs, OID_AUTO, prime_access_cache, CTLFLAG_RW,
|
2009-02-24 16:01:56 +00:00
|
|
|
&nfs_prime_access_cache, 0,
|
|
|
|
"Prime NFS ACCESS cache when fetching attributes");
|
|
|
|
|
2000-01-05 00:32:18 +00:00
|
|
|
static int nfsv3_commit_on_close = 0;
|
2011-05-15 20:52:43 +00:00
|
|
|
SYSCTL_INT(_vfs_oldnfs, OID_AUTO, nfsv3_commit_on_close, CTLFLAG_RW,
|
2000-01-05 00:32:18 +00:00
|
|
|
&nfsv3_commit_on_close, 0, "write+commit on close, else only write");
|
2004-12-01 06:48:54 +00:00
|
|
|
|
|
|
|
static int nfs_clean_pages_on_close = 1;
|
2011-05-15 20:52:43 +00:00
|
|
|
SYSCTL_INT(_vfs_oldnfs, OID_AUTO, clean_pages_on_close, CTLFLAG_RW,
|
2004-12-01 06:48:54 +00:00
|
|
|
&nfs_clean_pages_on_close, 0, "NFS clean dirty pages on close");
|
|
|
|
|
2004-12-23 21:30:30 +00:00
|
|
|
int nfs_directio_enable = 0;
|
2011-05-15 20:52:43 +00:00
|
|
|
SYSCTL_INT(_vfs_oldnfs, OID_AUTO, nfs_directio_enable, CTLFLAG_RW,
|
2004-12-15 22:20:22 +00:00
|
|
|
&nfs_directio_enable, 0, "Enable NFS directio");
|
|
|
|
|
|
|
|
/*
|
2005-01-29 23:19:08 +00:00
|
|
|
* This sysctl allows other processes to mmap a file that has been opened
|
|
|
|
* O_DIRECT by a process. In general, having processes mmap the file while
|
|
|
|
* Direct IO is in progress can lead to Data Inconsistencies. But, we allow
|
|
|
|
* this by default to prevent DoS attacks - to prevent a malicious user from
|
|
|
|
* opening up files O_DIRECT preventing other users from mmap'ing these
|
|
|
|
* files. "Protected" environments where stricter consistency guarantees are
|
|
|
|
* required can disable this knob. The process that opened the file O_DIRECT
|
|
|
|
* cannot mmap() the file, because mmap'ed IO on an O_DIRECT open() is not
|
|
|
|
* meaningful.
|
2004-12-15 22:20:22 +00:00
|
|
|
*/
|
|
|
|
int nfs_directio_allow_mmap = 1;
|
2011-05-15 20:52:43 +00:00
|
|
|
SYSCTL_INT(_vfs_oldnfs, OID_AUTO, nfs_directio_allow_mmap, CTLFLAG_RW,
|
2004-12-15 22:20:22 +00:00
|
|
|
&nfs_directio_allow_mmap, 0, "Enable mmaped IO on file with O_DIRECT opens");
|
|
|
|
|
1999-10-25 19:22:33 +00:00
|
|
|
#if 0
|
2011-05-15 20:52:43 +00:00
|
|
|
SYSCTL_INT(_vfs_oldnfs, OID_AUTO, access_cache_hits, CTLFLAG_RD,
|
1999-10-25 19:22:33 +00:00
|
|
|
&nfsstats.accesscache_hits, 0, "NFS ACCESS cache hit count");
|
1998-11-13 02:39:09 +00:00
|
|
|
|
2011-05-15 20:52:43 +00:00
|
|
|
SYSCTL_INT(_vfs_oldnfs, OID_AUTO, access_cache_misses, CTLFLAG_RD,
|
1999-10-25 19:22:33 +00:00
|
|
|
&nfsstats.accesscache_misses, 0, "NFS ACCESS cache miss count");
|
|
|
|
#endif
|
1999-07-31 01:51:58 +00:00
|
|
|
|
|
|
|
#define NFSV3ACCESS_ALL (NFSV3ACCESS_READ | NFSV3ACCESS_MODIFY \
|
|
|
|
| NFSV3ACCESS_EXTEND | NFSV3ACCESS_EXECUTE \
|
|
|
|
| NFSV3ACCESS_DELETE | NFSV3ACCESS_LOOKUP)
|
2006-05-19 00:04:24 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* SMP Locking Note :
|
|
|
|
* The list of locks after the description of the lock is the ordering
|
|
|
|
* of other locks acquired with the lock held.
|
|
|
|
* np->n_mtx : Protects the fields in the nfsnode.
|
|
|
|
VM Object Lock
|
|
|
|
VI_MTX (acquired indirectly)
|
|
|
|
* nmp->nm_mtx : Protects the fields in the nfsmount.
|
|
|
|
rep->r_mtx
|
|
|
|
* nfs_iod_mtx : Global lock, protects shared nfsiod state.
|
|
|
|
* nfs_reqq_mtx : Global lock, protects the nfs_reqq list.
|
|
|
|
nmp->nm_mtx
|
|
|
|
rep->r_mtx
|
|
|
|
* rep->r_mtx : Protects the fields in an nfsreq.
|
|
|
|
*/
|
|
|
|
|
1999-07-31 01:51:58 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs3_access_otw(struct vnode *vp, int wmode, struct thread *td,
|
2009-03-20 21:12:38 +00:00
|
|
|
struct ucred *cred, uint32_t *retmode)
|
1999-07-31 01:51:58 +00:00
|
|
|
{
|
|
|
|
const int v3 = 1;
|
|
|
|
u_int32_t *tl;
|
2009-03-20 21:12:38 +00:00
|
|
|
int error = 0, attrflag, i, lrupos;
|
2001-09-18 23:32:09 +00:00
|
|
|
|
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
|
|
|
caddr_t bpos, dpos;
|
1999-07-31 01:51:58 +00:00
|
|
|
u_int32_t rmode;
|
|
|
|
struct nfsnode *np = VTONFS(vp);
|
|
|
|
|
|
|
|
nfsstats.rpccnt[NFSPROC_ACCESS]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED, M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1999-07-31 01:51:58 +00:00
|
|
|
nfsm_fhtom(vp, v3);
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
|
2001-09-18 23:32:09 +00:00
|
|
|
*tl = txdr_unsigned(wmode);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(vp, NFSPROC_ACCESS, td, cred);
|
1999-07-31 01:51:58 +00:00
|
|
|
nfsm_postop_attr(vp, attrflag);
|
|
|
|
if (!error) {
|
2009-03-20 21:12:38 +00:00
|
|
|
lrupos = 0;
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
|
1999-07-31 01:51:58 +00:00
|
|
|
rmode = fxdr_unsigned(u_int32_t, *tl);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2009-03-20 21:12:38 +00:00
|
|
|
for (i = 0; i < NFS_ACCESSCACHESIZE; i++) {
|
|
|
|
if (np->n_accesscache[i].uid == cred->cr_uid) {
|
|
|
|
np->n_accesscache[i].mode = rmode;
|
|
|
|
np->n_accesscache[i].stamp = time_second;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i > 0 && np->n_accesscache[i].stamp <
|
|
|
|
np->n_accesscache[lrupos].stamp)
|
|
|
|
lrupos = i;
|
|
|
|
}
|
|
|
|
if (i == NFS_ACCESSCACHESIZE) {
|
|
|
|
np->n_accesscache[lrupos].uid = cred->cr_uid;
|
|
|
|
np->n_accesscache[lrupos].mode = rmode;
|
|
|
|
np->n_accesscache[lrupos].stamp = time_second;
|
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2009-03-20 21:12:38 +00:00
|
|
|
if (retmode != NULL)
|
|
|
|
*retmode = rmode;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ACCESSCACHE_LOAD_DONE(vp, cred->cr_uid, rmode, 0);
|
1999-07-31 01:51:58 +00:00
|
|
|
}
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
2009-03-24 23:16:48 +00:00
|
|
|
#ifdef KDTRACE_HOOKS
|
|
|
|
if (error) {
|
|
|
|
KDTRACE_NFS_ACCESSCACHE_LOAD_DONE(vp, cred->cr_uid, 0,
|
|
|
|
error);
|
|
|
|
}
|
|
|
|
#endif
|
2003-09-04 11:27:13 +00:00
|
|
|
return (error);
|
1999-07-31 01:51:58 +00:00
|
|
|
}
|
1998-11-13 02:39:09 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* nfs access vnode op.
|
1995-06-27 11:07:30 +00:00
|
|
|
* For nfs version 2, just return ok. File accesses may fail later.
|
|
|
|
* For nfs version 3, use the access rpc to check accessibility. If file modes
|
|
|
|
* are changed on the server, accesses might still fail later.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_access(struct vop_access_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
2009-03-20 21:12:38 +00:00
|
|
|
int error = 0, i, gotahit;
|
|
|
|
u_int32_t mode, rmode, wmode;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(vp);
|
1998-11-13 02:39:09 +00:00
|
|
|
struct nfsnode *np = VTONFS(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-10-22 09:32:48 +00:00
|
|
|
/*
|
|
|
|
* Disallow write attempts on filesystems mounted read-only;
|
|
|
|
* unless the file is a socket, fifo, or a block or character
|
|
|
|
* device resident on the filesystem.
|
|
|
|
*/
|
2008-10-28 13:44:11 +00:00
|
|
|
if ((ap->a_accmode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
|
1995-10-22 09:32:48 +00:00
|
|
|
switch (vp->v_type) {
|
1998-05-31 17:27:58 +00:00
|
|
|
case VREG:
|
|
|
|
case VDIR:
|
|
|
|
case VLNK:
|
1995-10-22 09:32:48 +00:00
|
|
|
return (EROFS);
|
1998-05-31 17:27:58 +00:00
|
|
|
default:
|
|
|
|
break;
|
1995-10-22 09:32:48 +00:00
|
|
|
}
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1998-11-13 02:39:09 +00:00
|
|
|
* For nfs v3, check to see if we have done this recently, and if
|
|
|
|
* so return our cached result instead of making an ACCESS call.
|
|
|
|
* If not, do an access rpc, otherwise you are stuck emulating
|
1994-05-24 10:09:53 +00:00
|
|
|
* ufs_access() locally using the vattr. This may not be correct,
|
|
|
|
* since the server may apply other access criteria such as
|
1998-11-13 02:39:09 +00:00
|
|
|
* client uid-->server uid mapping that we do not know about.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
2008-10-28 13:44:11 +00:00
|
|
|
if (ap->a_accmode & VREAD)
|
1995-06-27 11:07:30 +00:00
|
|
|
mode = NFSV3ACCESS_READ;
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
1995-06-27 11:07:30 +00:00
|
|
|
mode = 0;
|
1998-05-31 17:27:58 +00:00
|
|
|
if (vp->v_type != VDIR) {
|
2008-10-28 13:44:11 +00:00
|
|
|
if (ap->a_accmode & VWRITE)
|
1998-05-31 17:27:58 +00:00
|
|
|
mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
|
2008-10-28 13:44:11 +00:00
|
|
|
if (ap->a_accmode & VEXEC)
|
1998-05-31 17:27:58 +00:00
|
|
|
mode |= NFSV3ACCESS_EXECUTE;
|
1995-06-27 11:07:30 +00:00
|
|
|
} else {
|
2008-10-28 13:44:11 +00:00
|
|
|
if (ap->a_accmode & VWRITE)
|
1998-05-31 17:27:58 +00:00
|
|
|
mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
|
|
|
|
NFSV3ACCESS_DELETE);
|
2008-10-28 13:44:11 +00:00
|
|
|
if (ap->a_accmode & VEXEC)
|
1998-05-31 17:27:58 +00:00
|
|
|
mode |= NFSV3ACCESS_LOOKUP;
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
1998-11-13 02:39:09 +00:00
|
|
|
/* XXX safety belt, only make blanket request if caching */
|
|
|
|
if (nfsaccess_cache_timeout > 0) {
|
2001-09-18 23:32:09 +00:00
|
|
|
wmode = NFSV3ACCESS_READ | NFSV3ACCESS_MODIFY |
|
|
|
|
NFSV3ACCESS_EXTEND | NFSV3ACCESS_EXECUTE |
|
1998-11-13 02:39:09 +00:00
|
|
|
NFSV3ACCESS_DELETE | NFSV3ACCESS_LOOKUP;
|
|
|
|
} else {
|
|
|
|
wmode = mode;
|
|
|
|
}
|
|
|
|
|
Reimplement the NFS ACCESS RPC cache as an "accelerator" rather than a true
cache. If the cached result lets us say "yes", then go with that. If
we're not sure, or we think the answer might be "no", go to the wire to be
certain. This avoids all of the possible false veto cases, and allows us
to key the cached value with just the UID for which the cached value holds,
reducing the bloat of the nfsnode structure from 104 bytes to just 12 bytes.
Since the "yes" case is by far the most common, this should still provide
a substantial performance improvement. Also default the cache to on, with
a conservative timeout (2 seconds). This improves performance if NFS is
loaded as a KLD module, as there's not (yet) code to parse an option out
of the module arguments to set it, and sysctl doesn't work (yet) for OIDs
in modules.
The 'accelerator' mode was suggested by Bjoern Groenvall (bg@sics.se)
Feedback on this would be appreciated as testing has been necessarily
limited by Comdex, and it would be valuable to have this in 2.2.8.
1998-11-15 20:36:18 +00:00
|
|
|
/*
|
|
|
|
* Does our cached result allow us to give a definite yes to
|
|
|
|
* this request?
|
|
|
|
*/
|
2009-03-20 21:12:38 +00:00
|
|
|
gotahit = 0;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2009-03-20 21:12:38 +00:00
|
|
|
for (i = 0; i < NFS_ACCESSCACHESIZE; i++) {
|
|
|
|
if (ap->a_cred->cr_uid == np->n_accesscache[i].uid) {
|
|
|
|
if (time_second < (np->n_accesscache[i].stamp +
|
|
|
|
nfsaccess_cache_timeout) &&
|
|
|
|
(np->n_accesscache[i].mode & mode) == mode) {
|
|
|
|
nfsstats.accesscache_hits++;
|
|
|
|
gotahit = 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mtx_unlock(&np->n_mtx);
|
2009-03-24 17:14:34 +00:00
|
|
|
#ifdef KDTRACE_HOOKS
|
|
|
|
if (gotahit)
|
|
|
|
KDTRACE_NFS_ACCESSCACHE_GET_HIT(vp,
|
|
|
|
ap->a_cred->cr_uid, mode);
|
|
|
|
else
|
|
|
|
KDTRACE_NFS_ACCESSCACHE_GET_MISS(vp,
|
|
|
|
ap->a_cred->cr_uid, mode);
|
|
|
|
#endif
|
2009-03-20 21:12:38 +00:00
|
|
|
if (gotahit == 0) {
|
Reimplement the NFS ACCESS RPC cache as an "accelerator" rather than a true
cache. If the cached result lets us say "yes", then go with that. If
we're not sure, or we think the answer might be "no", go to the wire to be
certain. This avoids all of the possible false veto cases, and allows us
to key the cached value with just the UID for which the cached value holds,
reducing the bloat of the nfsnode structure from 104 bytes to just 12 bytes.
Since the "yes" case is by far the most common, this should still provide
a substantial performance improvement. Also default the cache to on, with
a conservative timeout (2 seconds). This improves performance if NFS is
loaded as a KLD module, as there's not (yet) code to parse an option out
of the module arguments to set it, and sysctl doesn't work (yet) for OIDs
in modules.
The 'accelerator' mode was suggested by Bjoern Groenvall (bg@sics.se)
Feedback on this would be appreciated as testing has been necessarily
limited by Comdex, and it would be valuable to have this in 2.2.8.
1998-11-15 20:36:18 +00:00
|
|
|
/*
|
|
|
|
* Either a no, or a don't know. Go to the wire.
|
|
|
|
*/
|
1999-10-25 19:22:33 +00:00
|
|
|
nfsstats.accesscache_misses++;
|
2009-03-20 21:12:38 +00:00
|
|
|
error = nfs3_access_otw(vp, wmode, ap->a_td, ap->a_cred,
|
|
|
|
&rmode);
|
1998-11-13 02:39:09 +00:00
|
|
|
if (!error) {
|
2009-03-20 21:12:38 +00:00
|
|
|
if ((rmode & mode) != mode)
|
1998-11-13 02:39:09 +00:00
|
|
|
error = EACCES;
|
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1997-05-09 13:18:42 +00:00
|
|
|
} else {
|
2006-05-19 00:04:24 +00:00
|
|
|
if ((error = nfsspec_access(ap)) != 0) {
|
1997-05-09 13:18:42 +00:00
|
|
|
return (error);
|
2006-05-19 00:04:24 +00:00
|
|
|
}
|
1997-05-09 13:18:42 +00:00
|
|
|
/*
|
|
|
|
* Attempt to prevent a mapped root from accessing a file
|
|
|
|
* which it shouldn't. We try to read a byte from the file
|
|
|
|
* if the user is root and the file is not zero length.
|
|
|
|
* After calling nfsspec_access, we should have the correct
|
|
|
|
* file size cached.
|
|
|
|
*/
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2008-10-28 13:44:11 +00:00
|
|
|
if (ap->a_cred->cr_uid == 0 && (ap->a_accmode & VREAD)
|
1997-05-09 13:18:42 +00:00
|
|
|
&& VTONFS(vp)->n_size > 0) {
|
|
|
|
struct iovec aiov;
|
|
|
|
struct uio auio;
|
|
|
|
char buf[1];
|
|
|
|
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
1997-05-09 13:18:42 +00:00
|
|
|
aiov.iov_base = buf;
|
|
|
|
aiov.iov_len = 1;
|
|
|
|
auio.uio_iov = &aiov;
|
|
|
|
auio.uio_iovcnt = 1;
|
|
|
|
auio.uio_offset = 0;
|
|
|
|
auio.uio_resid = 1;
|
|
|
|
auio.uio_segflg = UIO_SYSSPACE;
|
|
|
|
auio.uio_rw = UIO_READ;
|
2001-09-12 08:38:13 +00:00
|
|
|
auio.uio_td = ap->a_td;
|
1997-05-09 13:18:42 +00:00
|
|
|
|
|
|
|
if (vp->v_type == VREG)
|
|
|
|
error = nfs_readrpc(vp, &auio, ap->a_cred);
|
|
|
|
else if (vp->v_type == VDIR) {
|
1997-11-07 09:21:01 +00:00
|
|
|
char* bp;
|
2003-02-19 05:47:46 +00:00
|
|
|
bp = malloc(NFS_DIRBLKSIZ, M_TEMP, M_WAITOK);
|
1997-11-07 09:21:01 +00:00
|
|
|
aiov.iov_base = bp;
|
1999-05-03 20:59:14 +00:00
|
|
|
aiov.iov_len = auio.uio_resid = NFS_DIRBLKSIZ;
|
1997-05-09 13:18:42 +00:00
|
|
|
error = nfs_readdirrpc(vp, &auio, ap->a_cred);
|
1997-11-07 09:21:01 +00:00
|
|
|
free(bp, M_TEMP);
|
1999-01-27 22:45:49 +00:00
|
|
|
} else if (vp->v_type == VLNK)
|
1997-05-09 13:18:42 +00:00
|
|
|
error = nfs_readlinkrpc(vp, &auio, ap->a_cred);
|
|
|
|
else
|
|
|
|
error = EACCES;
|
2006-05-19 00:04:24 +00:00
|
|
|
} else
|
|
|
|
mtx_unlock(&np->n_mtx);
|
1997-05-09 13:18:42 +00:00
|
|
|
return (error);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2007-03-09 04:02:38 +00:00
|
|
|
int nfs_otw_getattr_avoid = 0;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* nfs open vnode op
|
|
|
|
* Check to see if the type is ok
|
|
|
|
* and that deletion is not in progress.
|
|
|
|
* For paged in text files, you will need to flush the page cache
|
|
|
|
* if consistency is lost.
|
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_open(struct vop_open_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nfsnode *np = VTONFS(vp);
|
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
2004-12-15 22:20:22 +00:00
|
|
|
int fmode = ap->a_mode;
|
2012-05-12 12:02:51 +00:00
|
|
|
struct ucred *cred;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-09-28 08:50:01 +00:00
|
|
|
if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK)
|
2003-09-02 16:46:31 +00:00
|
|
|
return (EOPNOTSUPP);
|
2004-09-28 08:50:01 +00:00
|
|
|
|
1994-08-29 06:09:15 +00:00
|
|
|
/*
|
|
|
|
* Get a valid lease. If cached data is stale, flush it.
|
|
|
|
*/
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2001-09-18 23:32:09 +00:00
|
|
|
if (np->n_flag & NMODIFIED) {
|
2010-08-04 01:19:11 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2005-01-24 12:31:06 +00:00
|
|
|
error = nfs_vinvalbuf(vp, V_SAVE, ap->a_td, 1);
|
2004-07-06 09:12:03 +00:00
|
|
|
if (error == EINTR || error == EIO)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2010-07-12 14:19:23 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2001-09-18 23:32:09 +00:00
|
|
|
np->n_attrstamp = 0;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
|
2001-09-18 23:32:09 +00:00
|
|
|
if (vp->v_type == VDIR)
|
|
|
|
np->n_direofoffset = 0;
|
2010-07-12 14:19:23 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_GETATTR(vp, &vattr, ap->a_cred);
|
2001-09-18 23:32:09 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2004-12-06 19:18:00 +00:00
|
|
|
np->n_mtime = vattr.va_mtime;
|
1994-08-29 06:09:15 +00:00
|
|
|
} else {
|
2010-08-04 01:19:11 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_GETATTR(vp, &vattr, ap->a_cred);
|
2001-09-18 23:32:09 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2004-12-06 19:18:00 +00:00
|
|
|
if (NFS_TIMESPEC_COMPARE(&np->n_mtime, &vattr.va_mtime)) {
|
1995-06-27 11:07:30 +00:00
|
|
|
if (vp->v_type == VDIR)
|
|
|
|
np->n_direofoffset = 0;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2005-01-24 12:31:06 +00:00
|
|
|
error = nfs_vinvalbuf(vp, V_SAVE, ap->a_td, 1);
|
2006-05-19 00:04:24 +00:00
|
|
|
if (error == EINTR || error == EIO) {
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2006-05-19 00:04:24 +00:00
|
|
|
}
|
|
|
|
mtx_lock(&np->n_mtx);
|
2004-12-06 19:18:00 +00:00
|
|
|
np->n_mtime = vattr.va_mtime;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1994-08-29 06:09:15 +00:00
|
|
|
}
|
2004-12-15 22:20:22 +00:00
|
|
|
/*
|
|
|
|
* If the object has >= 1 O_DIRECT active opens, we disable caching.
|
|
|
|
*/
|
|
|
|
if (nfs_directio_enable && (fmode & O_DIRECT) && (vp->v_type == VREG)) {
|
|
|
|
if (np->n_directio_opens == 0) {
|
2010-08-04 01:19:11 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2005-01-24 12:31:06 +00:00
|
|
|
error = nfs_vinvalbuf(vp, V_SAVE, ap->a_td, 1);
|
2004-12-15 22:20:22 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2004-12-15 22:20:22 +00:00
|
|
|
np->n_flag |= NNONCACHE;
|
|
|
|
}
|
|
|
|
np->n_directio_opens++;
|
|
|
|
}
|
2012-05-12 12:02:51 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is an open for writing, capture a reference to the
|
|
|
|
* credentials, so they can be used by nfs_putpages(). Using
|
|
|
|
* these write credentials is preferable to the credentials of
|
|
|
|
* whatever thread happens to be doing the VOP_PUTPAGES() since
|
|
|
|
* the write RPCs are less likely to fail with EACCES.
|
|
|
|
*/
|
|
|
|
if ((fmode & FWRITE) != 0) {
|
|
|
|
cred = np->n_writecred;
|
|
|
|
np->n_writecred = crhold(ap->a_cred);
|
|
|
|
} else
|
|
|
|
cred = NULL;
|
2010-08-04 01:19:11 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2012-05-12 12:02:51 +00:00
|
|
|
if (cred != NULL)
|
|
|
|
crfree(cred);
|
2005-01-24 23:03:29 +00:00
|
|
|
vnode_create_vobject(vp, vattr.va_size, ap->a_td);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs close vnode op
|
1995-06-27 11:07:30 +00:00
|
|
|
* What an NFS client should do upon close after writing is a debatable issue.
|
|
|
|
* Most NFS clients push delayed writes to the server upon close, basically for
|
|
|
|
* two reasons:
|
|
|
|
* 1 - So that any write errors may be reported back to the client process
|
|
|
|
* doing the close system call. By far the two most likely errors are
|
|
|
|
* NFSERR_NOSPC and NFSERR_DQUOT to indicate space allocation failure.
|
|
|
|
* 2 - To put a worst case upper bound on cache inconsistency between
|
|
|
|
* multiple clients for the file.
|
|
|
|
* There is also a consistency problem for Version 2 of the protocol w.r.t.
|
|
|
|
* not being able to tell if other clients are writing a file concurrently,
|
|
|
|
* since there is no way of knowing if the changed modify time in the reply
|
|
|
|
* is only due to the write for this client.
|
|
|
|
* (NFS Version 3 provides weak cache consistency data in the reply that
|
|
|
|
* should be sufficient to detect and handle this case.)
|
|
|
|
*
|
|
|
|
* The current code does the following:
|
|
|
|
* for NFS Version 2 - play it safe and flush/invalidate all dirty buffers
|
|
|
|
* for NFS Version 3 - flush dirty buffers to the server but don't invalidate
|
|
|
|
* or commit them (this satisfies 1 and 2 except for the
|
|
|
|
* case where the server crashes after this close but
|
|
|
|
* before the commit RPC, which is felt to be "good
|
|
|
|
* enough". Changing the last argument to nfs_flush() to
|
|
|
|
* a 1 would force a commit operation, if it is felt a
|
|
|
|
* commit is necessary now.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_close(struct vop_close_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct nfsnode *np = VTONFS(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
int error = 0;
|
2004-12-15 22:20:22 +00:00
|
|
|
int fmode = ap->a_fflag;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (vp->v_type == VREG) {
|
2004-12-01 06:48:54 +00:00
|
|
|
/*
|
|
|
|
* Examine and clean dirty pages, regardless of NMODIFIED.
|
|
|
|
* This closes a major hole in close-to-open consistency.
|
|
|
|
* We want to push out all dirty pages (and buffers) on
|
|
|
|
* close, regardless of whether they were dirtied by
|
|
|
|
* mmap'ed writes or via write().
|
|
|
|
*/
|
|
|
|
if (nfs_clean_pages_on_close && vp->v_object) {
|
2013-02-20 12:03:20 +00:00
|
|
|
VM_OBJECT_WLOCK(vp->v_object);
|
2004-12-01 06:48:54 +00:00
|
|
|
vm_object_page_clean(vp->v_object, 0, 0, 0);
|
2013-02-20 12:03:20 +00:00
|
|
|
VM_OBJECT_WUNLOCK(vp->v_object);
|
2004-12-01 06:48:54 +00:00
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2001-09-18 23:32:09 +00:00
|
|
|
if (np->n_flag & NMODIFIED) {
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
1995-07-13 17:55:12 +00:00
|
|
|
if (NFS_ISV3(vp)) {
|
2000-01-05 00:32:18 +00:00
|
|
|
/*
|
|
|
|
* Under NFSv3 we have dirty buffers to dispose of. We
|
|
|
|
* must flush them to the NFS server. We have the option
|
|
|
|
* of waiting all the way through the commit rpc or just
|
|
|
|
* waiting for the initial write. The default is to only
|
|
|
|
* wait through the initial write so the data is in the
|
|
|
|
* server's cache, which is roughly similar to the state
|
|
|
|
* a standard disk subsystem leaves the file in on close().
|
|
|
|
*
|
|
|
|
* We cannot clear the NMODIFIED bit in np->n_flag due to
|
|
|
|
* potential races with other processes, and certainly
|
|
|
|
* cannot clear it if we don't commit.
|
|
|
|
*/
|
|
|
|
int cm = nfsv3_commit_on_close ? 1 : 0;
|
2008-08-28 15:23:18 +00:00
|
|
|
error = nfs_flush(vp, MNT_WAIT, cm);
|
2000-01-05 00:32:18 +00:00
|
|
|
/* np->n_flag &= ~NMODIFIED; */
|
2005-03-13 12:11:23 +00:00
|
|
|
} else
|
2005-01-24 12:31:06 +00:00
|
|
|
error = nfs_vinvalbuf(vp, V_SAVE, ap->a_td, 1);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
if (np->n_flag & NWRITEERR) {
|
|
|
|
np->n_flag &= ~NWRITEERR;
|
|
|
|
error = np->n_error;
|
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2007-04-25 20:34:55 +00:00
|
|
|
if (nfs_directio_enable)
|
|
|
|
KASSERT((np->n_directio_asyncwr == 0),
|
|
|
|
("nfs_close: dirty unflushed (%d) directio buffers\n",
|
|
|
|
np->n_directio_asyncwr));
|
2004-12-15 22:20:22 +00:00
|
|
|
if (nfs_directio_enable && (fmode & O_DIRECT) && (vp->v_type == VREG)) {
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2004-12-15 22:20:22 +00:00
|
|
|
KASSERT((np->n_directio_opens > 0),
|
2006-05-19 00:04:24 +00:00
|
|
|
("nfs_close: unexpectedly value (0) of n_directio_opens\n"));
|
2004-12-15 22:20:22 +00:00
|
|
|
np->n_directio_opens--;
|
|
|
|
if (np->n_directio_opens == 0)
|
|
|
|
np->n_flag &= ~NNONCACHE;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2004-12-15 22:20:22 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs getattr call from vfs.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_getattr(struct vop_getattr_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct nfsnode *np = VTONFS(vp);
|
2008-08-28 15:23:18 +00:00
|
|
|
struct thread *td = curthread;
|
2008-09-20 19:50:52 +00:00
|
|
|
struct vattr *vap = ap->a_vap;
|
|
|
|
struct vattr vattr;
|
1994-05-24 10:09:53 +00:00
|
|
|
caddr_t bpos, dpos;
|
|
|
|
int error = 0;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(vp);
|
2001-09-18 23:32:09 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Update local times for special files.
|
|
|
|
*/
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (np->n_flag & (NACC | NUPD))
|
|
|
|
np->n_flag |= NCHG;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* First look in the cache.
|
|
|
|
*/
|
2008-09-20 19:50:52 +00:00
|
|
|
if (nfs_getattrcache(vp, &vattr) == 0)
|
2006-05-19 00:04:24 +00:00
|
|
|
goto nfsmout;
|
2009-02-24 16:01:56 +00:00
|
|
|
if (v3 && nfs_prime_access_cache && nfsaccess_cache_timeout > 0) {
|
|
|
|
nfsstats.accesscache_misses++;
|
2009-03-20 21:12:38 +00:00
|
|
|
nfs3_access_otw(vp, NFSV3ACCESS_ALL, td, ap->a_cred, NULL);
|
2009-02-24 16:01:56 +00:00
|
|
|
if (nfs_getattrcache(vp, &vattr) == 0)
|
|
|
|
goto nfsmout;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsstats.rpccnt[NFSPROC_GETATTR]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3), M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(vp, v3);
|
2008-08-28 15:23:18 +00:00
|
|
|
nfsm_request(vp, NFSPROC_GETATTR, td, ap->a_cred);
|
1998-05-31 17:27:58 +00:00
|
|
|
if (!error) {
|
2008-09-20 19:50:52 +00:00
|
|
|
nfsm_loadattr(vp, &vattr);
|
1998-05-31 17:27:58 +00:00
|
|
|
}
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
2008-09-20 19:50:52 +00:00
|
|
|
vap->va_type = vattr.va_type;
|
|
|
|
vap->va_mode = vattr.va_mode;
|
|
|
|
vap->va_nlink = vattr.va_nlink;
|
|
|
|
vap->va_uid = vattr.va_uid;
|
|
|
|
vap->va_gid = vattr.va_gid;
|
|
|
|
vap->va_fsid = vattr.va_fsid;
|
|
|
|
vap->va_fileid = vattr.va_fileid;
|
|
|
|
vap->va_size = vattr.va_size;
|
|
|
|
vap->va_blocksize = vattr.va_blocksize;
|
|
|
|
vap->va_atime = vattr.va_atime;
|
|
|
|
vap->va_mtime = vattr.va_mtime;
|
|
|
|
vap->va_ctime = vattr.va_ctime;
|
|
|
|
vap->va_gen = vattr.va_gen;
|
|
|
|
vap->va_flags = vattr.va_flags;
|
|
|
|
vap->va_rdev = vattr.va_rdev;
|
|
|
|
vap->va_bytes = vattr.va_bytes;
|
|
|
|
vap->va_filerev = vattr.va_filerev;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs setattr call.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_setattr(struct vop_setattr_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct nfsnode *np = VTONFS(vp);
|
|
|
|
struct vattr *vap = ap->a_vap;
|
2008-08-28 15:23:18 +00:00
|
|
|
struct thread *td = curthread;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0;
|
|
|
|
u_quad_t tsize;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
#ifndef nolint
|
|
|
|
tsize = (u_quad_t)0;
|
|
|
|
#endif
|
1998-05-31 19:24:19 +00:00
|
|
|
|
|
|
|
/*
|
2009-01-21 14:42:00 +00:00
|
|
|
* Setting of flags is not supported.
|
1998-05-31 19:24:19 +00:00
|
|
|
*/
|
2009-01-21 14:42:00 +00:00
|
|
|
if (vap->va_flags != VNOVAL)
|
1998-05-31 19:24:19 +00:00
|
|
|
return (EOPNOTSUPP);
|
|
|
|
|
1995-10-22 09:32:48 +00:00
|
|
|
/*
|
|
|
|
* Disallow write attempts if the filesystem is mounted read-only.
|
|
|
|
*/
|
1997-02-10 02:22:35 +00:00
|
|
|
if ((vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL ||
|
1996-09-19 18:21:32 +00:00
|
|
|
vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
|
|
|
|
vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) &&
|
2006-05-19 00:04:24 +00:00
|
|
|
(vp->v_mount->mnt_flag & MNT_RDONLY)) {
|
|
|
|
error = EROFS;
|
|
|
|
goto out;
|
|
|
|
}
|
1994-10-17 17:47:45 +00:00
|
|
|
if (vap->va_size != VNOVAL) {
|
1995-06-27 11:07:30 +00:00
|
|
|
switch (vp->v_type) {
|
|
|
|
case VDIR:
|
|
|
|
return (EISDIR);
|
|
|
|
case VCHR:
|
|
|
|
case VBLK:
|
1997-02-10 02:22:35 +00:00
|
|
|
case VSOCK:
|
|
|
|
case VFIFO:
|
1996-09-19 18:21:32 +00:00
|
|
|
if (vap->va_mtime.tv_sec == VNOVAL &&
|
|
|
|
vap->va_atime.tv_sec == VNOVAL &&
|
1998-05-31 20:09:01 +00:00
|
|
|
vap->va_mode == (mode_t)VNOVAL &&
|
1995-06-27 11:07:30 +00:00
|
|
|
vap->va_uid == (uid_t)VNOVAL &&
|
|
|
|
vap->va_gid == (gid_t)VNOVAL)
|
2006-05-19 00:04:24 +00:00
|
|
|
return (0);
|
1995-06-27 11:07:30 +00:00
|
|
|
vap->va_size = VNOVAL;
|
|
|
|
break;
|
|
|
|
default:
|
1995-10-22 09:32:48 +00:00
|
|
|
/*
|
|
|
|
* Disallow write attempts if the filesystem is
|
|
|
|
* mounted read-only.
|
|
|
|
*/
|
|
|
|
if (vp->v_mount->mnt_flag & MNT_RDONLY)
|
|
|
|
return (EROFS);
|
2001-12-14 01:16:57 +00:00
|
|
|
/*
|
|
|
|
* We run vnode_pager_setsize() early (why?),
|
|
|
|
* we must set np->n_size now to avoid vinvalbuf
|
|
|
|
* V_SAVE races that might setsize a lower
|
|
|
|
* value.
|
|
|
|
*/
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2001-12-14 01:16:57 +00:00
|
|
|
tsize = np->n_size;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2008-08-28 15:23:18 +00:00
|
|
|
error = nfs_meta_setsize(vp, ap->a_cred, td,
|
|
|
|
vap->va_size);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
1997-02-10 02:22:35 +00:00
|
|
|
if (np->n_flag & NMODIFIED) {
|
2006-05-19 00:04:24 +00:00
|
|
|
tsize = np->n_size;
|
|
|
|
mtx_unlock(&np->n_mtx);
|
1997-02-10 02:22:35 +00:00
|
|
|
if (vap->va_size == 0)
|
2008-08-28 15:23:18 +00:00
|
|
|
error = nfs_vinvalbuf(vp, 0, td, 1);
|
1997-02-10 02:22:35 +00:00
|
|
|
else
|
2008-08-28 15:23:18 +00:00
|
|
|
error = nfs_vinvalbuf(vp, V_SAVE, td, 1);
|
1998-09-29 23:28:32 +00:00
|
|
|
if (error) {
|
2006-05-19 00:04:24 +00:00
|
|
|
vnode_pager_setsize(vp, tsize);
|
|
|
|
goto out;
|
1998-09-29 23:28:32 +00:00
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
} else
|
|
|
|
mtx_unlock(&np->n_mtx);
|
2003-07-29 00:17:29 +00:00
|
|
|
/*
|
|
|
|
* np->n_size has already been set to vap->va_size
|
|
|
|
* in nfs_meta_setsize(). We must set it again since
|
|
|
|
* nfs_loadattrcache() could be called through
|
|
|
|
* nfs_meta_setsize() and could modify np->n_size.
|
|
|
|
*/
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2003-07-29 00:17:29 +00:00
|
|
|
np->n_vattr.va_size = np->n_size = vap->va_size;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
};
|
2006-05-19 00:04:24 +00:00
|
|
|
} else {
|
|
|
|
mtx_lock(&np->n_mtx);
|
|
|
|
if ((vap->va_mtime.tv_sec != VNOVAL || vap->va_atime.tv_sec != VNOVAL) &&
|
|
|
|
(np->n_flag & NMODIFIED) && vp->v_type == VREG) {
|
|
|
|
mtx_unlock(&np->n_mtx);
|
2008-08-28 15:23:18 +00:00
|
|
|
if ((error = nfs_vinvalbuf(vp, V_SAVE, td, 1)) != 0 &&
|
2006-05-19 00:04:24 +00:00
|
|
|
(error == EINTR || error == EIO))
|
|
|
|
return error;
|
|
|
|
} else
|
|
|
|
mtx_unlock(&np->n_mtx);
|
|
|
|
}
|
2008-08-28 15:23:18 +00:00
|
|
|
error = nfs_setattrrpc(vp, vap, ap->a_cred);
|
1995-07-24 16:38:05 +00:00
|
|
|
if (error && vap->va_size != VNOVAL) {
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
1995-07-24 16:38:05 +00:00
|
|
|
np->n_size = np->n_vattr.va_size = tsize;
|
2006-05-19 00:04:24 +00:00
|
|
|
vnode_pager_setsize(vp, tsize);
|
|
|
|
mtx_unlock(&np->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
out:
|
1995-06-27 11:07:30 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do an nfs setattr rpc.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2008-08-28 15:23:18 +00:00
|
|
|
nfs_setattrrpc(struct vnode *vp, struct vattr *vap, struct ucred *cred)
|
1995-06-27 11:07:30 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct nfsv2_sattr *sp;
|
2004-04-03 17:23:46 +00:00
|
|
|
struct nfsnode *np = VTONFS(vp);
|
2001-09-18 23:32:09 +00:00
|
|
|
caddr_t bpos, dpos;
|
1998-05-31 20:09:01 +00:00
|
|
|
u_int32_t *tl;
|
2009-03-20 21:12:38 +00:00
|
|
|
int error = 0, i, wccflag = NFSV3_WCCRATTR;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(vp);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsstats.rpccnt[NFSPROC_SETATTR]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + NFSX_SATTR(v3), M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(vp, v3);
|
|
|
|
if (v3) {
|
1998-12-25 10:34:27 +00:00
|
|
|
nfsm_v3attrbuild(vap, TRUE);
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl = nfs_false;
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
2001-09-27 02:33:36 +00:00
|
|
|
sp = nfsm_build(struct nfsv2_sattr *, NFSX_V2SATTR);
|
1998-05-31 20:09:01 +00:00
|
|
|
if (vap->va_mode == (mode_t)VNOVAL)
|
1998-05-31 19:00:19 +00:00
|
|
|
sp->sa_mode = nfs_xdrneg1;
|
1995-06-27 11:07:30 +00:00
|
|
|
else
|
|
|
|
sp->sa_mode = vtonfsv2_mode(vp->v_type, vap->va_mode);
|
|
|
|
if (vap->va_uid == (uid_t)VNOVAL)
|
1998-05-31 19:00:19 +00:00
|
|
|
sp->sa_uid = nfs_xdrneg1;
|
1995-06-27 11:07:30 +00:00
|
|
|
else
|
|
|
|
sp->sa_uid = txdr_unsigned(vap->va_uid);
|
|
|
|
if (vap->va_gid == (gid_t)VNOVAL)
|
1998-05-31 19:00:19 +00:00
|
|
|
sp->sa_gid = nfs_xdrneg1;
|
1995-06-27 11:07:30 +00:00
|
|
|
else
|
|
|
|
sp->sa_gid = txdr_unsigned(vap->va_gid);
|
|
|
|
sp->sa_size = txdr_unsigned(vap->va_size);
|
|
|
|
txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
|
|
|
|
txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2008-08-28 15:23:18 +00:00
|
|
|
nfsm_request(vp, NFSPROC_SETATTR, curthread, cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
2009-03-20 21:12:38 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
|
|
|
for (i = 0; i < NFS_ACCESSCACHESIZE; i++)
|
|
|
|
np->n_accesscache[i].stamp = 0;
|
|
|
|
mtx_unlock(&np->n_mtx);
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ACCESSCACHE_FLUSH_DONE(vp);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_wcc_data(vp, wccflag);
|
|
|
|
} else
|
2002-07-11 17:54:58 +00:00
|
|
|
nfsm_loadattr(vp, NULL);
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs lookup call, one step at a time...
|
1997-10-05 12:28:59 +00:00
|
|
|
* First look in cache
|
|
|
|
* If not found, unlock the directory nfsnode and do the rpc
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_lookup(struct vop_lookup_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1998-05-31 17:27:58 +00:00
|
|
|
struct componentname *cnp = ap->a_cnp;
|
|
|
|
struct vnode *dvp = ap->a_dvp;
|
|
|
|
struct vnode **vpp = ap->a_vpp;
|
2009-06-17 12:47:27 +00:00
|
|
|
struct mount *mp = dvp->v_mount;
|
2012-03-03 01:06:54 +00:00
|
|
|
struct vattr dvattr, vattr;
|
2012-01-20 20:02:01 +00:00
|
|
|
struct timespec nctime;
|
1998-05-31 17:27:58 +00:00
|
|
|
int flags = cnp->cn_flags;
|
|
|
|
struct vnode *newvp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nfsmount *nmp;
|
2001-09-18 23:32:09 +00:00
|
|
|
caddr_t bpos, dpos;
|
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1994-05-24 10:09:53 +00:00
|
|
|
long len;
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsfh_t *fhp;
|
2010-05-27 18:07:20 +00:00
|
|
|
struct nfsnode *np, *newnp;
|
2012-01-20 20:02:01 +00:00
|
|
|
int error = 0, attrflag, dattrflag, fhsize, ltype, ncticks;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(dvp);
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = cnp->cn_thread;
|
2009-10-16 19:30:48 +00:00
|
|
|
|
1998-05-13 05:47:09 +00:00
|
|
|
*vpp = NULLVP;
|
2009-06-17 12:47:27 +00:00
|
|
|
if ((flags & ISLASTCN) && (mp->mnt_flag & MNT_RDONLY) &&
|
1997-10-05 12:28:59 +00:00
|
|
|
(cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
|
|
|
|
return (EROFS);
|
|
|
|
if (dvp->v_type != VDIR)
|
|
|
|
return (ENOTDIR);
|
2009-06-17 12:47:27 +00:00
|
|
|
nmp = VFSTONFS(mp);
|
1994-05-24 10:09:53 +00:00
|
|
|
np = VTONFS(dvp);
|
2005-03-29 13:00:37 +00:00
|
|
|
if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, td)) != 0) {
|
|
|
|
*vpp = NULLVP;
|
|
|
|
return (error);
|
|
|
|
}
|
2012-02-06 17:00:28 +00:00
|
|
|
error = cache_lookup(dvp, vpp, cnp, &nctime, &ncticks);
|
2008-09-24 18:51:33 +00:00
|
|
|
if (error > 0 && error != ENOENT)
|
|
|
|
return (error);
|
|
|
|
if (error == -1) {
|
2012-01-20 20:02:01 +00:00
|
|
|
/*
|
|
|
|
* Lookups of "." are special and always return the
|
|
|
|
* current directory. cache_lookup() already handles
|
|
|
|
* associated locking bookkeeping, etc.
|
|
|
|
*/
|
|
|
|
if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
|
|
|
|
/* XXX: Is this really correct? */
|
|
|
|
if (cnp->cn_nameiop != LOOKUP &&
|
|
|
|
(flags & ISLASTCN))
|
|
|
|
cnp->cn_flags |= SAVENAME;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2009-02-19 22:28:48 +00:00
|
|
|
/*
|
|
|
|
* We only accept a positive hit in the cache if the
|
|
|
|
* change time of the file matches our cached copy.
|
|
|
|
* Otherwise, we discard the cache entry and fallback
|
2012-01-25 20:05:58 +00:00
|
|
|
* to doing a lookup RPC. We also only trust cache
|
|
|
|
* entries for less than nm_nametimeo seconds.
|
2010-05-27 18:07:20 +00:00
|
|
|
*
|
|
|
|
* To better handle stale file handles and attributes,
|
|
|
|
* clear the attribute cache of this node if it is a
|
|
|
|
* leaf component, part of an open() call, and not
|
|
|
|
* locally modified before fetching the attributes.
|
|
|
|
* This should allow stale file handles to be detected
|
|
|
|
* here where we can fall back to a LOOKUP RPC to
|
|
|
|
* recover rather than having nfs_open() detect the
|
|
|
|
* stale file handle and failing open(2) with ESTALE.
|
2009-02-19 22:28:48 +00:00
|
|
|
*/
|
1997-10-05 12:28:59 +00:00
|
|
|
newvp = *vpp;
|
2010-05-27 18:07:20 +00:00
|
|
|
newnp = VTONFS(newvp);
|
2011-05-04 13:27:45 +00:00
|
|
|
if (!(nmp->nm_flag & NFSMNT_NOCTO) &&
|
|
|
|
(flags & (ISLASTCN | ISOPEN)) == (ISLASTCN | ISOPEN) &&
|
2010-07-12 14:19:23 +00:00
|
|
|
!(newnp->n_flag & NMODIFIED)) {
|
2010-05-27 18:07:20 +00:00
|
|
|
mtx_lock(&newnp->n_mtx);
|
|
|
|
newnp->n_attrstamp = 0;
|
2010-05-27 22:59:37 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(newvp);
|
2010-05-27 18:07:20 +00:00
|
|
|
mtx_unlock(&newnp->n_mtx);
|
|
|
|
}
|
2012-01-25 20:05:58 +00:00
|
|
|
if ((u_int)(ticks - ncticks) < (nmp->nm_nametimeo * hz) &&
|
|
|
|
VOP_GETATTR(newvp, &vattr, cnp->cn_cred) == 0 &&
|
2012-01-20 20:02:01 +00:00
|
|
|
timespeccmp(&vattr.va_ctime, &nctime, ==)) {
|
2009-02-18 16:34:13 +00:00
|
|
|
nfsstats.lookupcache_hits++;
|
|
|
|
if (cnp->cn_nameiop != LOOKUP &&
|
|
|
|
(flags & ISLASTCN))
|
|
|
|
cnp->cn_flags |= SAVENAME;
|
|
|
|
return (0);
|
1997-10-05 12:28:59 +00:00
|
|
|
}
|
2005-03-29 13:00:37 +00:00
|
|
|
cache_purge(newvp);
|
|
|
|
if (dvp != newvp)
|
|
|
|
vput(newvp);
|
|
|
|
else
|
|
|
|
vrele(newvp);
|
1997-10-05 12:28:59 +00:00
|
|
|
*vpp = NULLVP;
|
2009-02-19 22:28:48 +00:00
|
|
|
} else if (error == ENOENT) {
|
2009-04-10 10:22:44 +00:00
|
|
|
if (dvp->v_iflag & VI_DOOMED)
|
|
|
|
return (ENOENT);
|
2009-02-19 22:28:48 +00:00
|
|
|
/*
|
|
|
|
* We only accept a negative hit in the cache if the
|
|
|
|
* modification time of the parent directory matches
|
2012-01-20 20:02:01 +00:00
|
|
|
* the cached copy in the name cache entry.
|
|
|
|
* Otherwise, we discard all of the negative cache
|
|
|
|
* entries for this directory. We also only trust
|
|
|
|
* negative cache entries for up to nm_negnametimeo
|
|
|
|
* seconds.
|
2009-02-19 22:28:48 +00:00
|
|
|
*/
|
2012-01-20 20:02:01 +00:00
|
|
|
if ((u_int)(ticks - ncticks) < (nmp->nm_negnametimeo * hz) &&
|
2010-01-21 20:57:25 +00:00
|
|
|
VOP_GETATTR(dvp, &vattr, cnp->cn_cred) == 0 &&
|
2012-01-20 20:02:01 +00:00
|
|
|
timespeccmp(&vattr.va_mtime, &nctime, ==)) {
|
2009-02-19 22:28:48 +00:00
|
|
|
nfsstats.lookupcache_hits++;
|
|
|
|
return (ENOENT);
|
|
|
|
}
|
|
|
|
cache_purge_negative(dvp);
|
1997-10-05 12:28:59 +00:00
|
|
|
}
|
2009-10-16 19:30:48 +00:00
|
|
|
|
2012-01-20 20:02:01 +00:00
|
|
|
attrflag = dattrflag = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
error = 0;
|
1995-06-27 11:07:30 +00:00
|
|
|
newvp = NULLVP;
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsstats.lookupcache_misses++;
|
|
|
|
nfsstats.rpccnt[NFSPROC_LOOKUP]++;
|
|
|
|
len = cnp->cn_namelen;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len), M_WAITOK,
|
|
|
|
MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(dvp, v3);
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(dvp, NFSPROC_LOOKUP, cnp->cn_thread, cnp->cn_cred);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error) {
|
2005-11-10 23:25:16 +00:00
|
|
|
if (v3) {
|
2012-01-20 20:02:01 +00:00
|
|
|
nfsm_postop_attr_va(dvp, dattrflag, &vattr);
|
2005-11-10 23:25:16 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
goto nfsmout;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_getfh(fhp, fhsize, v3);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle RENAME case...
|
|
|
|
*/
|
2005-03-29 13:09:42 +00:00
|
|
|
if (cnp->cn_nameiop == RENAME && (flags & ISLASTCN)) {
|
1995-06-27 11:07:30 +00:00
|
|
|
if (NFS_CMPFH(np, fhp, fhsize)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
return (EISDIR);
|
|
|
|
}
|
2009-06-17 12:47:27 +00:00
|
|
|
error = nfs_nget(mp, fhp, fhsize, &np, LK_EXCLUSIVE);
|
1998-05-31 17:27:58 +00:00
|
|
|
if (error) {
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
newvp = NFSTOV(np);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
|
|
|
nfsm_postop_attr(newvp, attrflag);
|
|
|
|
nfsm_postop_attr(dvp, attrflag);
|
|
|
|
} else
|
2002-07-11 17:54:58 +00:00
|
|
|
nfsm_loadattr(newvp, NULL);
|
1994-05-24 10:09:53 +00:00
|
|
|
*vpp = newvp;
|
|
|
|
m_freem(mrep);
|
|
|
|
cnp->cn_flags |= SAVENAME;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
if (flags & ISDOTDOT) {
|
2009-06-17 12:47:27 +00:00
|
|
|
ltype = VOP_ISLOCKED(dvp);
|
|
|
|
error = vfs_busy(mp, MBF_NOWAIT);
|
|
|
|
if (error != 0) {
|
2009-07-02 18:02:55 +00:00
|
|
|
vfs_ref(mp);
|
2009-06-17 12:47:27 +00:00
|
|
|
VOP_UNLOCK(dvp, 0);
|
|
|
|
error = vfs_busy(mp, 0);
|
|
|
|
vn_lock(dvp, ltype | LK_RETRY);
|
2009-07-02 18:02:55 +00:00
|
|
|
vfs_rel(mp);
|
2009-06-17 12:47:27 +00:00
|
|
|
if (error == 0 && (dvp->v_iflag & VI_DOOMED)) {
|
|
|
|
vfs_unbusy(mp);
|
|
|
|
error = ENOENT;
|
|
|
|
}
|
|
|
|
if (error != 0) {
|
|
|
|
m_freem(mrep);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(dvp, 0);
|
2009-06-17 12:47:27 +00:00
|
|
|
error = nfs_nget(mp, fhp, fhsize, &np, cnp->cn_lkflags);
|
|
|
|
if (error == 0)
|
|
|
|
newvp = NFSTOV(np);
|
|
|
|
vfs_unbusy(mp);
|
2009-07-17 19:38:07 +00:00
|
|
|
if (newvp != dvp)
|
|
|
|
vn_lock(dvp, ltype | LK_RETRY);
|
2009-06-17 12:47:27 +00:00
|
|
|
if (dvp->v_iflag & VI_DOOMED) {
|
|
|
|
if (error == 0) {
|
|
|
|
if (newvp == dvp)
|
|
|
|
vrele(newvp);
|
|
|
|
else
|
|
|
|
vput(newvp);
|
|
|
|
}
|
|
|
|
error = ENOENT;
|
|
|
|
}
|
|
|
|
if (error) {
|
|
|
|
m_freem(mrep);
|
1995-06-27 11:07:30 +00:00
|
|
|
return (error);
|
2009-06-17 12:47:27 +00:00
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
} else if (NFS_CMPFH(np, fhp, fhsize)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
VREF(dvp);
|
|
|
|
newvp = dvp;
|
|
|
|
} else {
|
2009-06-17 12:47:27 +00:00
|
|
|
error = nfs_nget(mp, fhp, fhsize, &np, cnp->cn_lkflags);
|
1998-05-31 17:27:58 +00:00
|
|
|
if (error) {
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
newvp = NFSTOV(np);
|
2010-07-12 14:27:49 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush the attribute cache when opening a leaf node
|
|
|
|
* to ensure that fresh attributes are fetched in
|
|
|
|
* nfs_open() if we are unable to fetch attributes
|
|
|
|
* from the LOOKUP reply.
|
|
|
|
*/
|
|
|
|
if ((flags & (ISLASTCN | ISOPEN)) == (ISLASTCN | ISOPEN) &&
|
|
|
|
!(np->n_flag & NMODIFIED)) {
|
|
|
|
mtx_lock(&np->n_mtx);
|
|
|
|
np->n_attrstamp = 0;
|
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(newvp);
|
|
|
|
mtx_unlock(&np->n_mtx);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
2012-01-20 20:02:01 +00:00
|
|
|
nfsm_postop_attr_va(newvp, attrflag, &vattr);
|
2012-03-03 01:06:54 +00:00
|
|
|
nfsm_postop_attr_va(dvp, dattrflag, &dvattr);
|
2012-01-20 20:02:01 +00:00
|
|
|
} else {
|
|
|
|
nfsm_loadattr(newvp, &vattr);
|
|
|
|
attrflag = 1;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
|
|
|
|
cnp->cn_flags |= SAVENAME;
|
|
|
|
if ((cnp->cn_flags & MAKEENTRY) &&
|
2012-03-03 01:06:54 +00:00
|
|
|
(cnp->cn_nameiop != DELETE || !(flags & ISLASTCN)) &&
|
|
|
|
attrflag != 0 && (newvp->v_type != VDIR || dattrflag != 0))
|
|
|
|
cache_enter_time(dvp, newvp, cnp, &vattr.va_ctime,
|
|
|
|
newvp->v_type != VDIR ? NULL : &dvattr.va_ctime);
|
1995-06-27 11:07:30 +00:00
|
|
|
*vpp = newvp;
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
1995-06-27 11:07:30 +00:00
|
|
|
if (error) {
|
1997-06-25 08:32:33 +00:00
|
|
|
if (newvp != NULLVP) {
|
2005-11-03 19:24:54 +00:00
|
|
|
vput(newvp);
|
1997-06-25 08:32:33 +00:00
|
|
|
*vpp = NULLVP;
|
|
|
|
}
|
2009-02-19 22:28:48 +00:00
|
|
|
|
|
|
|
if (error != ENOENT)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* The requested file was not found. */
|
1995-06-27 11:07:30 +00:00
|
|
|
if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
|
2009-02-19 22:28:48 +00:00
|
|
|
(flags & ISLASTCN)) {
|
|
|
|
/*
|
|
|
|
* XXX: UFS does a full VOP_ACCESS(dvp,
|
|
|
|
* VWRITE) here instead of just checking
|
|
|
|
* MNT_RDONLY.
|
|
|
|
*/
|
2009-06-17 12:47:27 +00:00
|
|
|
if (mp->mnt_flag & MNT_RDONLY)
|
2009-02-19 22:28:48 +00:00
|
|
|
return (EROFS);
|
1995-06-27 11:07:30 +00:00
|
|
|
cnp->cn_flags |= SAVENAME;
|
2009-02-19 22:28:48 +00:00
|
|
|
return (EJUSTRETURN);
|
|
|
|
}
|
|
|
|
|
2012-01-20 20:02:01 +00:00
|
|
|
if ((cnp->cn_flags & MAKEENTRY) && cnp->cn_nameiop != CREATE &&
|
|
|
|
dattrflag) {
|
2009-02-19 22:28:48 +00:00
|
|
|
/*
|
2012-01-20 20:02:01 +00:00
|
|
|
* Cache the modification time of the parent
|
|
|
|
* directory from the post-op attributes in
|
|
|
|
* the name cache entry. The negative cache
|
|
|
|
* entry will be ignored once the directory
|
|
|
|
* has changed. Don't bother adding the entry
|
|
|
|
* if the directory has already changed.
|
2009-02-19 22:28:48 +00:00
|
|
|
*/
|
2009-03-10 18:41:06 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2012-01-20 20:02:01 +00:00
|
|
|
if (timespeccmp(&np->n_vattr.va_mtime,
|
|
|
|
&vattr.va_mtime, ==)) {
|
2009-10-16 19:30:48 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2012-01-20 20:02:01 +00:00
|
|
|
cache_enter_time(dvp, NULL, cnp,
|
2012-03-03 01:06:54 +00:00
|
|
|
&vattr.va_mtime, NULL);
|
2009-10-16 19:30:48 +00:00
|
|
|
} else
|
|
|
|
mtx_unlock(&np->n_mtx);
|
2009-02-19 22:28:48 +00:00
|
|
|
}
|
|
|
|
return (ENOENT);
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
2009-02-19 22:28:48 +00:00
|
|
|
done:
|
1995-06-27 11:07:30 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs read call.
|
|
|
|
* Just call nfs_bioread() to do the work.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_read(struct vop_read_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-09-02 16:46:31 +00:00
|
|
|
switch (vp->v_type) {
|
|
|
|
case VREG:
|
|
|
|
return (nfs_bioread(vp, ap->a_uio, ap->a_ioflag, ap->a_cred));
|
|
|
|
case VDIR:
|
2003-09-04 11:27:13 +00:00
|
|
|
return (EISDIR);
|
2003-09-02 16:46:31 +00:00
|
|
|
default:
|
2003-09-04 11:27:13 +00:00
|
|
|
return (EOPNOTSUPP);
|
2003-09-02 16:46:31 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs readlink call
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_readlink(struct vop_readlink_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (vp->v_type != VLNK)
|
1998-06-01 10:59:23 +00:00
|
|
|
return (EINVAL);
|
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
|
|
|
return (nfs_bioread(vp, ap->a_uio, 0, ap->a_cred));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do a readlink rpc.
|
|
|
|
* Called by nfs_doio() from below the buffer cache.
|
|
|
|
*/
|
|
|
|
int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_readlinkrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
caddr_t bpos, dpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, len, attrflag;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
nfsstats.rpccnt[NFSPROC_READLINK]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3), M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(vp, v3);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(vp, NFSPROC_READLINK, uiop->uio_td, cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3)
|
|
|
|
nfsm_postop_attr(vp, attrflag);
|
|
|
|
if (!error) {
|
|
|
|
nfsm_strsiz(len, NFS_MAXPATHLEN);
|
1999-06-30 02:53:51 +00:00
|
|
|
if (len == NFS_MAXPATHLEN) {
|
|
|
|
struct nfsnode *np = VTONFS(vp);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
1999-06-30 02:53:51 +00:00
|
|
|
if (np->n_size && np->n_size < NFS_MAXPATHLEN)
|
|
|
|
len = np->n_size;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
1999-06-30 02:53:51 +00:00
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_mtouio(uiop, len);
|
|
|
|
}
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs read rpc call
|
|
|
|
* Ditto above
|
|
|
|
*/
|
|
|
|
int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_readrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
u_int32_t *tl;
|
|
|
|
caddr_t bpos, dpos;
|
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nfsmount *nmp;
|
2011-08-09 15:29:58 +00:00
|
|
|
off_t end;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, len, retlen, tsiz, eof, attrflag;
|
|
|
|
int v3 = NFS_ISV3(vp);
|
2006-05-19 00:04:24 +00:00
|
|
|
int rsize;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
#ifndef nolint
|
|
|
|
eof = 0;
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
nmp = VFSTONFS(vp->v_mount);
|
|
|
|
tsiz = uiop->uio_resid;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&nmp->nm_mtx);
|
2011-08-09 15:29:58 +00:00
|
|
|
end = uiop->uio_offset + tsiz;
|
|
|
|
if (end > nmp->nm_maxfilesize || end < uiop->uio_offset) {
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&nmp->nm_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EFBIG);
|
2006-05-19 00:04:24 +00:00
|
|
|
}
|
|
|
|
rsize = nmp->nm_rsize;
|
|
|
|
mtx_unlock(&nmp->nm_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
while (tsiz > 0) {
|
|
|
|
nfsstats.rpccnt[NFSPROC_READ]++;
|
2006-05-19 00:04:24 +00:00
|
|
|
len = (tsiz > rsize) ? rsize : tsiz;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED * 3, M_WAITOK,
|
|
|
|
MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(vp, v3);
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED * 3);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
1999-06-05 05:35:03 +00:00
|
|
|
txdr_hyper(uiop->uio_offset, tl);
|
1994-05-24 10:09:53 +00:00
|
|
|
*(tl + 2) = txdr_unsigned(len);
|
|
|
|
} else {
|
|
|
|
*tl++ = txdr_unsigned(uiop->uio_offset);
|
|
|
|
*tl++ = txdr_unsigned(len);
|
|
|
|
*tl = 0;
|
|
|
|
}
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(vp, NFSPROC_READ, uiop->uio_td, cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
|
|
|
nfsm_postop_attr(vp, attrflag);
|
|
|
|
if (error) {
|
|
|
|
m_freem(mrep);
|
|
|
|
goto nfsmout;
|
|
|
|
}
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, 2 * NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
eof = fxdr_unsigned(int, *(tl + 1));
|
2006-05-19 00:04:24 +00:00
|
|
|
} else {
|
2002-07-11 17:54:58 +00:00
|
|
|
nfsm_loadattr(vp, NULL);
|
2006-05-19 00:04:24 +00:00
|
|
|
}
|
|
|
|
nfsm_strsiz(retlen, rsize);
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsm_mtouio(uiop, retlen);
|
|
|
|
m_freem(mrep);
|
1995-06-27 11:07:30 +00:00
|
|
|
tsiz -= retlen;
|
|
|
|
if (v3) {
|
2001-12-14 01:16:57 +00:00
|
|
|
if (eof || retlen == 0) {
|
1995-06-27 11:07:30 +00:00
|
|
|
tsiz = 0;
|
2001-12-14 01:16:57 +00:00
|
|
|
}
|
|
|
|
} else if (retlen < len) {
|
1994-05-24 10:09:53 +00:00
|
|
|
tsiz = 0;
|
2001-12-14 01:16:57 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
nfsmout:
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs write call
|
|
|
|
*/
|
|
|
|
int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_writerpc(struct vnode *vp, struct uio *uiop, struct ucred *cred,
|
2006-05-19 00:04:24 +00:00
|
|
|
int *iomode, int *must_commit)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
u_int32_t *tl;
|
|
|
|
int32_t backup;
|
|
|
|
caddr_t bpos, dpos;
|
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1995-06-27 11:07:30 +00:00
|
|
|
struct nfsmount *nmp = VFSTONFS(vp->v_mount);
|
2011-08-09 15:29:58 +00:00
|
|
|
off_t end;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, len, tsiz, wccflag = NFSV3_WCCRATTR, rlen, commit;
|
|
|
|
int v3 = NFS_ISV3(vp), committed = NFSV3WRITE_FILESYNC;
|
2006-05-19 00:04:24 +00:00
|
|
|
int wsize;
|
|
|
|
|
2010-06-13 05:24:27 +00:00
|
|
|
KASSERT(uiop->uio_iovcnt == 1, ("nfs: writerpc iovcnt > 1"));
|
1995-06-27 11:07:30 +00:00
|
|
|
*must_commit = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
tsiz = uiop->uio_resid;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&nmp->nm_mtx);
|
2011-08-09 15:29:58 +00:00
|
|
|
end = uiop->uio_offset + tsiz;
|
|
|
|
if (end > nmp->nm_maxfilesize || end < uiop->uio_offset) {
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&nmp->nm_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EFBIG);
|
2006-05-19 00:04:24 +00:00
|
|
|
}
|
|
|
|
wsize = nmp->nm_wsize;
|
|
|
|
mtx_unlock(&nmp->nm_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
while (tsiz > 0) {
|
|
|
|
nfsstats.rpccnt[NFSPROC_WRITE]++;
|
2006-05-19 00:04:24 +00:00
|
|
|
len = (tsiz > wsize) ? wsize : tsiz;
|
2013-07-01 21:16:19 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + 5 * NFSX_UNSIGNED, M_WAITOK,
|
|
|
|
MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(vp, v3);
|
|
|
|
if (v3) {
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, 5 * NFSX_UNSIGNED);
|
1999-06-05 05:35:03 +00:00
|
|
|
txdr_hyper(uiop->uio_offset, tl);
|
1994-05-24 10:09:53 +00:00
|
|
|
tl += 2;
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl++ = txdr_unsigned(len);
|
|
|
|
*tl++ = txdr_unsigned(*iomode);
|
1998-05-31 19:28:15 +00:00
|
|
|
*tl = txdr_unsigned(len);
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
2001-09-18 23:32:09 +00:00
|
|
|
u_int32_t x;
|
1998-05-31 19:28:15 +00:00
|
|
|
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, 4 * NFSX_UNSIGNED);
|
1998-05-31 19:28:15 +00:00
|
|
|
/* Set both "begin" and "current" to non-garbage. */
|
1998-05-31 20:09:01 +00:00
|
|
|
x = txdr_unsigned((u_int32_t)uiop->uio_offset);
|
1998-05-31 19:28:15 +00:00
|
|
|
*tl++ = x; /* "begin offset" */
|
|
|
|
*tl++ = x; /* "current offset" */
|
|
|
|
x = txdr_unsigned(len);
|
|
|
|
*tl++ = x; /* total to this offset */
|
|
|
|
*tl = x; /* size of this write */
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
nfsm_uiotom(uiop, len);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(vp, NFSPROC_WRITE, uiop->uio_td, cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
|
|
|
wccflag = NFSV3_WCCCHK;
|
|
|
|
nfsm_wcc_data(vp, wccflag);
|
|
|
|
if (!error) {
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, 2 * NFSX_UNSIGNED
|
1998-05-31 20:09:01 +00:00
|
|
|
+ NFSX_V3WRITEVERF);
|
1995-06-27 11:07:30 +00:00
|
|
|
rlen = fxdr_unsigned(int, *tl++);
|
|
|
|
if (rlen == 0) {
|
|
|
|
error = NFSERR_IO;
|
1998-05-31 18:25:32 +00:00
|
|
|
m_freem(mrep);
|
1995-06-27 11:07:30 +00:00
|
|
|
break;
|
|
|
|
} else if (rlen < len) {
|
|
|
|
backup = len - rlen;
|
2002-10-11 14:58:34 +00:00
|
|
|
uiop->uio_iov->iov_base =
|
|
|
|
(char *)uiop->uio_iov->iov_base -
|
|
|
|
backup;
|
1995-06-27 11:07:30 +00:00
|
|
|
uiop->uio_iov->iov_len += backup;
|
|
|
|
uiop->uio_offset -= backup;
|
|
|
|
uiop->uio_resid += backup;
|
|
|
|
len = rlen;
|
|
|
|
}
|
|
|
|
commit = fxdr_unsigned(int, *tl++);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the lowest committment level
|
|
|
|
* obtained by any of the RPCs.
|
|
|
|
*/
|
|
|
|
if (committed == NFSV3WRITE_FILESYNC)
|
|
|
|
committed = commit;
|
|
|
|
else if (committed == NFSV3WRITE_DATASYNC &&
|
|
|
|
commit == NFSV3WRITE_UNSTABLE)
|
|
|
|
committed = commit;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&nmp->nm_mtx);
|
1998-05-31 17:27:58 +00:00
|
|
|
if ((nmp->nm_state & NFSSTA_HASWRITEVERF) == 0){
|
1995-06-27 11:07:30 +00:00
|
|
|
bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
|
|
|
|
NFSX_V3WRITEVERF);
|
1998-05-19 07:11:27 +00:00
|
|
|
nmp->nm_state |= NFSSTA_HASWRITEVERF;
|
1995-06-27 11:07:30 +00:00
|
|
|
} else if (bcmp((caddr_t)tl,
|
|
|
|
(caddr_t)nmp->nm_verf, NFSX_V3WRITEVERF)) {
|
|
|
|
*must_commit = 1;
|
|
|
|
bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
|
|
|
|
NFSX_V3WRITEVERF);
|
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&nmp->nm_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
} else {
|
|
|
|
nfsm_loadattr(vp, NULL);
|
|
|
|
}
|
|
|
|
if (wccflag) {
|
|
|
|
mtx_lock(&(VTONFS(vp))->n_mtx);
|
|
|
|
VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.va_mtime;
|
|
|
|
mtx_unlock(&(VTONFS(vp))->n_mtx);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(mrep);
|
1998-05-31 18:27:07 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
tsiz -= len;
|
|
|
|
}
|
|
|
|
nfsmout:
|
2012-02-06 11:04:36 +00:00
|
|
|
if (DOINGASYNC(vp))
|
1997-06-03 13:56:55 +00:00
|
|
|
committed = NFSV3WRITE_FILESYNC;
|
1995-06-27 11:07:30 +00:00
|
|
|
*iomode = committed;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error)
|
|
|
|
uiop->uio_resid = tsiz;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1995-06-27 11:07:30 +00:00
|
|
|
* nfs mknod rpc
|
|
|
|
* For NFS v2 this is a kludge. Use a create rpc but with the IFMT bits of the
|
|
|
|
* mode set to specify the file type and the size field for rdev.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_mknodrpc(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
|
|
|
|
struct vattr *vap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct nfsv2_sattr *sp;
|
|
|
|
u_int32_t *tl;
|
2002-07-11 17:54:58 +00:00
|
|
|
struct vnode *newvp = NULL;
|
|
|
|
struct nfsnode *np = NULL;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
caddr_t bpos, dpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1998-05-31 20:09:01 +00:00
|
|
|
u_int32_t rdev;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(dvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (vap->va_type == VCHR || vap->va_type == VBLK)
|
|
|
|
rdev = txdr_unsigned(vap->va_rdev);
|
1995-06-27 11:07:30 +00:00
|
|
|
else if (vap->va_type == VFIFO || vap->va_type == VSOCK)
|
1998-05-31 19:29:28 +00:00
|
|
|
rdev = nfs_xdrneg1;
|
1994-05-24 10:09:53 +00:00
|
|
|
else {
|
|
|
|
return (EOPNOTSUPP);
|
|
|
|
}
|
2008-08-28 15:23:18 +00:00
|
|
|
if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsstats.rpccnt[NFSPROC_MKNOD]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + 4 * NFSX_UNSIGNED +
|
|
|
|
nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3), M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(dvp, v3);
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl++ = vtonfsv3_type(vap->va_type);
|
1998-12-25 10:34:27 +00:00
|
|
|
nfsm_v3attrbuild(vap, FALSE);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (vap->va_type == VCHR || vap->va_type == VBLK) {
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, 2 * NFSX_UNSIGNED);
|
2009-01-28 17:57:16 +00:00
|
|
|
*tl++ = txdr_unsigned(major(vap->va_rdev));
|
|
|
|
*tl = txdr_unsigned(minor(vap->va_rdev));
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
2001-09-27 02:33:36 +00:00
|
|
|
sp = nfsm_build(struct nfsv2_sattr *, NFSX_V2SATTR);
|
1995-06-27 11:07:30 +00:00
|
|
|
sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
|
1998-05-31 19:00:19 +00:00
|
|
|
sp->sa_uid = nfs_xdrneg1;
|
|
|
|
sp->sa_gid = nfs_xdrneg1;
|
1995-06-27 11:07:30 +00:00
|
|
|
sp->sa_size = rdev;
|
|
|
|
txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
|
|
|
|
txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(dvp, NFSPROC_MKNOD, cnp->cn_thread, cnp->cn_cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (!error) {
|
|
|
|
nfsm_mtofh(dvp, newvp, v3, gotvp);
|
|
|
|
if (!gotvp) {
|
|
|
|
if (newvp) {
|
|
|
|
vput(newvp);
|
2002-07-11 17:54:58 +00:00
|
|
|
newvp = NULL;
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
|
|
|
error = nfs_lookitup(dvp, cnp->cn_nameptr,
|
2001-09-12 08:38:13 +00:00
|
|
|
cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (!error)
|
|
|
|
newvp = NFSTOV(np);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (v3)
|
|
|
|
nfsm_wcc_data(dvp, wccflag);
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
1995-06-27 11:07:30 +00:00
|
|
|
if (error) {
|
|
|
|
if (newvp)
|
|
|
|
vput(newvp);
|
|
|
|
} else {
|
|
|
|
*vpp = newvp;
|
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&(VTONFS(dvp))->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
VTONFS(dvp)->n_flag |= NMODIFIED;
|
2009-03-24 17:14:34 +00:00
|
|
|
if (!wccflag) {
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(dvp)->n_attrstamp = 0;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
|
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&(VTONFS(dvp))->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs mknod vop
|
|
|
|
* just call nfs_mknodrpc() to do the work.
|
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_mknod(struct vop_mknod_args *ap)
|
1995-06-27 11:07:30 +00:00
|
|
|
{
|
2003-09-04 11:27:13 +00:00
|
|
|
return (nfs_mknodrpc(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
static u_long create_verf;
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* nfs file create call
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_create(struct vop_create_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *dvp = ap->a_dvp;
|
|
|
|
struct vattr *vap = ap->a_vap;
|
|
|
|
struct componentname *cnp = ap->a_cnp;
|
|
|
|
struct nfsv2_sattr *sp;
|
|
|
|
u_int32_t *tl;
|
2002-07-11 17:54:58 +00:00
|
|
|
struct nfsnode *np = NULL;
|
|
|
|
struct vnode *newvp = NULL;
|
2001-09-18 23:32:09 +00:00
|
|
|
caddr_t bpos, dpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0, fmode = 0;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(dvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
/*
|
|
|
|
* Oops, not for me..
|
|
|
|
*/
|
2009-12-13 11:06:39 +00:00
|
|
|
if (vap->va_type == VSOCK) {
|
|
|
|
error = nfs_mknodrpc(dvp, ap->a_vpp, cnp, vap);
|
|
|
|
return (error);
|
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
|
2009-12-13 11:06:39 +00:00
|
|
|
if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred)) != 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2009-12-13 11:06:39 +00:00
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
if (vap->va_vaflags & VA_EXCLUSIVE)
|
|
|
|
fmode |= O_EXCL;
|
|
|
|
again:
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsstats.rpccnt[NFSPROC_CREATE]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + 2 * NFSX_UNSIGNED +
|
|
|
|
nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3), M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(dvp, v3);
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (fmode & O_EXCL) {
|
1998-12-25 10:34:27 +00:00
|
|
|
*tl = txdr_unsigned(NFSV3CREATE_EXCLUSIVE);
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, NFSX_V3CREATEVERF);
|
1998-01-08 23:42:31 +00:00
|
|
|
#ifdef INET
|
2009-08-24 10:09:30 +00:00
|
|
|
CURVNET_SET(CRED_TO_VNET(cnp->cn_cred));
|
2009-06-25 11:52:33 +00:00
|
|
|
IN_IFADDR_RLOCK();
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
if (!TAILQ_EMPTY(&V_in_ifaddrhead))
|
|
|
|
*tl++ = IA_SIN(TAILQ_FIRST(&V_in_ifaddrhead))->sin_addr.s_addr;
|
1998-12-25 10:34:27 +00:00
|
|
|
else
|
1998-01-08 23:42:31 +00:00
|
|
|
#endif
|
1998-12-25 10:34:27 +00:00
|
|
|
*tl++ = create_verf;
|
2009-06-25 11:52:33 +00:00
|
|
|
#ifdef INET
|
|
|
|
IN_IFADDR_RUNLOCK();
|
2009-08-24 10:09:30 +00:00
|
|
|
CURVNET_RESTORE();
|
2009-06-25 11:52:33 +00:00
|
|
|
#endif
|
1998-12-25 10:34:27 +00:00
|
|
|
*tl = ++create_verf;
|
1995-06-27 11:07:30 +00:00
|
|
|
} else {
|
1998-12-25 10:34:27 +00:00
|
|
|
*tl = txdr_unsigned(NFSV3CREATE_UNCHECKED);
|
|
|
|
nfsm_v3attrbuild(vap, FALSE);
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
2001-09-27 02:33:36 +00:00
|
|
|
sp = nfsm_build(struct nfsv2_sattr *, NFSX_V2SATTR);
|
1995-06-27 11:07:30 +00:00
|
|
|
sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
|
1998-05-31 19:00:19 +00:00
|
|
|
sp->sa_uid = nfs_xdrneg1;
|
|
|
|
sp->sa_gid = nfs_xdrneg1;
|
1995-06-27 11:07:30 +00:00
|
|
|
sp->sa_size = 0;
|
|
|
|
txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
|
|
|
|
txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(dvp, NFSPROC_CREATE, cnp->cn_thread, cnp->cn_cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (!error) {
|
|
|
|
nfsm_mtofh(dvp, newvp, v3, gotvp);
|
|
|
|
if (!gotvp) {
|
|
|
|
if (newvp) {
|
|
|
|
vput(newvp);
|
2002-07-11 17:54:58 +00:00
|
|
|
newvp = NULL;
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
|
|
|
error = nfs_lookitup(dvp, cnp->cn_nameptr,
|
2001-09-12 08:38:13 +00:00
|
|
|
cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (!error)
|
|
|
|
newvp = NFSTOV(np);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (v3)
|
|
|
|
nfsm_wcc_data(dvp, wccflag);
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
1995-06-27 11:07:30 +00:00
|
|
|
if (error) {
|
|
|
|
if (v3 && (fmode & O_EXCL) && error == NFSERR_NOTSUPP) {
|
|
|
|
fmode &= ~O_EXCL;
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
if (newvp)
|
|
|
|
vput(newvp);
|
2001-01-04 22:45:19 +00:00
|
|
|
} else if (v3 && (fmode & O_EXCL)) {
|
|
|
|
/*
|
|
|
|
* We are normally called with only a partially initialized
|
|
|
|
* VAP. Since the NFSv3 spec says that server may use the
|
|
|
|
* file attributes to store the verifier, the spec requires
|
|
|
|
* us to do a SETATTR RPC. FreeBSD servers store the verifier
|
|
|
|
* in atime, but we can't really assume that all servers will
|
|
|
|
* so we ensure that our SETATTR sets both atime and mtime.
|
|
|
|
*/
|
|
|
|
if (vap->va_mtime.tv_sec == VNOVAL)
|
|
|
|
vfs_timestamp(&vap->va_mtime);
|
|
|
|
if (vap->va_atime.tv_sec == VNOVAL)
|
|
|
|
vap->va_atime = vap->va_mtime;
|
2008-08-28 15:23:18 +00:00
|
|
|
error = nfs_setattrrpc(newvp, vap, cnp->cn_cred);
|
2007-01-31 23:10:27 +00:00
|
|
|
if (error)
|
|
|
|
vput(newvp);
|
2001-01-04 22:45:19 +00:00
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
if (!error) {
|
|
|
|
*ap->a_vpp = newvp;
|
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&(VTONFS(dvp))->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
VTONFS(dvp)->n_flag |= NMODIFIED;
|
2009-03-24 17:14:34 +00:00
|
|
|
if (!wccflag) {
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(dvp)->n_attrstamp = 0;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
|
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&(VTONFS(dvp))->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs file remove call
|
|
|
|
* To try and make nfs semantics closer to ufs semantics, a file that has
|
|
|
|
* other processes using the vnode is renamed instead of removed and then
|
|
|
|
* removed later on the last close.
|
|
|
|
* - If v_usecount > 1
|
|
|
|
* If a rename is not already in the works
|
|
|
|
* call nfs_sillyrename() to set it up
|
|
|
|
* else
|
|
|
|
* do the remove rpc
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_remove(struct vop_remove_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct vnode *dvp = ap->a_dvp;
|
|
|
|
struct componentname *cnp = ap->a_cnp;
|
|
|
|
struct nfsnode *np = VTONFS(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
int error = 0;
|
1994-10-17 17:47:45 +00:00
|
|
|
struct vattr vattr;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2010-06-13 05:24:27 +00:00
|
|
|
KASSERT((cnp->cn_flags & HASBUF) != 0, ("nfs_remove: no name"));
|
|
|
|
KASSERT(vrefcnt(vp) > 0, ("nfs_remove: bad v_usecount"));
|
1998-05-31 18:28:45 +00:00
|
|
|
if (vp->v_type == VDIR)
|
|
|
|
error = EPERM;
|
2002-09-25 02:38:43 +00:00
|
|
|
else if (vrefcnt(vp) == 1 || (np->n_sillyrename &&
|
2008-08-28 15:23:18 +00:00
|
|
|
!VOP_GETATTR(vp, &vattr, cnp->cn_cred) && vattr.va_nlink > 1)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Purge the name cache so that the chance of a lookup for
|
|
|
|
* the name succeeding while the remove is in progress is
|
|
|
|
* minimized. Without node locking it can still happen, such
|
|
|
|
* that an I/O op returns ESTALE, but since you get this if
|
|
|
|
* another host removes the file..
|
|
|
|
*/
|
|
|
|
cache_purge(vp);
|
|
|
|
/*
|
1995-06-27 11:07:30 +00:00
|
|
|
* throw away biocache buffers, mainly to avoid
|
|
|
|
* unnecessary delayed writes later.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2005-01-24 12:31:06 +00:00
|
|
|
error = nfs_vinvalbuf(vp, 0, cnp->cn_thread, 1);
|
1994-05-24 10:09:53 +00:00
|
|
|
/* Do the rpc */
|
2004-07-06 09:12:03 +00:00
|
|
|
if (error != EINTR && error != EIO)
|
1995-06-27 11:07:30 +00:00
|
|
|
error = nfs_removerpc(dvp, cnp->cn_nameptr,
|
2001-09-12 08:38:13 +00:00
|
|
|
cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Kludge City: If the first reply to the remove rpc is lost..
|
|
|
|
* the reply to the retransmitted request will be ENOENT
|
|
|
|
* since the file was in fact removed
|
|
|
|
* Therefore, we cheat and return success.
|
|
|
|
*/
|
|
|
|
if (error == ENOENT)
|
|
|
|
error = 0;
|
1995-06-27 11:07:30 +00:00
|
|
|
} else if (!np->n_sillyrename)
|
|
|
|
error = nfs_sillyrename(dvp, vp, cnp);
|
2010-08-04 01:19:11 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
np->n_attrstamp = 0;
|
2010-08-04 01:19:11 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs file remove rpc called from nfs_inactive
|
|
|
|
*/
|
|
|
|
int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_removeit(struct sillyrename *sp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-06-12 15:41:20 +00:00
|
|
|
/*
|
|
|
|
* Make sure that the directory vnode is still valid.
|
|
|
|
* XXX we should lock sp->s_dvp here.
|
|
|
|
*/
|
|
|
|
if (sp->s_dvp->v_type == VBAD)
|
|
|
|
return (0);
|
1995-06-27 11:07:30 +00:00
|
|
|
return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred,
|
2002-07-11 17:54:58 +00:00
|
|
|
NULL));
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Nfs remove rpc, called from nfs_remove() and nfs_removeit().
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_removerpc(struct vnode *dvp, const char *name, int namelen,
|
|
|
|
struct ucred *cred, struct thread *td)
|
1995-06-27 11:07:30 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
caddr_t bpos, dpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, wccflag = NFSV3_WCCRATTR;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(dvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
nfsstats.rpccnt[NFSPROC_REMOVE]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(namelen),
|
|
|
|
M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(dvp, v3);
|
|
|
|
nfsm_strtom(name, namelen, NFS_MAXNAMLEN);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(dvp, NFSPROC_REMOVE, td, cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3)
|
|
|
|
nfsm_wcc_data(dvp, wccflag);
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&(VTONFS(dvp))->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(dvp)->n_flag |= NMODIFIED;
|
2009-03-24 17:14:34 +00:00
|
|
|
if (!wccflag) {
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(dvp)->n_attrstamp = 0;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
|
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&(VTONFS(dvp))->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs file rename call
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_rename(struct vop_rename_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *fvp = ap->a_fvp;
|
|
|
|
struct vnode *tvp = ap->a_tvp;
|
|
|
|
struct vnode *fdvp = ap->a_fdvp;
|
|
|
|
struct vnode *tdvp = ap->a_tdvp;
|
|
|
|
struct componentname *tcnp = ap->a_tcnp;
|
|
|
|
struct componentname *fcnp = ap->a_fcnp;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2010-06-13 05:24:27 +00:00
|
|
|
KASSERT((tcnp->cn_flags & HASBUF) != 0 &&
|
|
|
|
(fcnp->cn_flags & HASBUF) != 0, ("nfs_rename: no name"));
|
1994-05-24 10:09:53 +00:00
|
|
|
/* Check for cross-device rename */
|
|
|
|
if ((fvp->v_mount != tdvp->v_mount) ||
|
|
|
|
(tvp && (fvp->v_mount != tvp->v_mount))) {
|
|
|
|
error = EXDEV;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2003-04-24 20:39:40 +00:00
|
|
|
if (fvp == tvp) {
|
2006-05-19 00:04:24 +00:00
|
|
|
nfs_printf("nfs_rename: fvp == tvp (can't happen)\n");
|
2003-04-24 20:39:40 +00:00
|
|
|
error = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
2008-01-10 01:10:58 +00:00
|
|
|
if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
|
2003-04-24 20:39:40 +00:00
|
|
|
goto out;
|
|
|
|
|
1999-02-06 07:48:56 +00:00
|
|
|
/*
|
|
|
|
* We have to flush B_DELWRI data prior to renaming
|
|
|
|
* the file. If we don't, the delayed-write buffers
|
|
|
|
* can be flushed out later after the file has gone stale
|
|
|
|
* under NFSV3. NFSV2 does not have this problem because
|
|
|
|
* ( as far as I can tell ) it flushes dirty buffers more
|
|
|
|
* often.
|
2004-12-10 03:29:02 +00:00
|
|
|
*
|
|
|
|
* Skip the rename operation if the fsync fails, this can happen
|
|
|
|
* due to the server's volume being full, when we pushed out data
|
|
|
|
* that was written back to our cache earlier. Not checking for
|
|
|
|
* this condition can result in potential (silent) data loss.
|
1999-02-06 07:48:56 +00:00
|
|
|
*/
|
2005-01-11 07:36:22 +00:00
|
|
|
error = VOP_FSYNC(fvp, MNT_WAIT, fcnp->cn_thread);
|
2008-01-13 14:44:15 +00:00
|
|
|
VOP_UNLOCK(fvp, 0);
|
2004-12-10 03:29:02 +00:00
|
|
|
if (!error && tvp)
|
2005-01-11 07:36:22 +00:00
|
|
|
error = VOP_FSYNC(tvp, MNT_WAIT, tcnp->cn_thread);
|
2004-12-10 03:29:02 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
1999-02-06 07:48:56 +00:00
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
/*
|
|
|
|
* If the tvp exists and is in use, sillyrename it before doing the
|
|
|
|
* rename of the new file over it.
|
1996-12-31 07:10:19 +00:00
|
|
|
* XXX Can't sillyrename a directory.
|
1995-06-27 11:07:30 +00:00
|
|
|
*/
|
2002-09-25 02:38:43 +00:00
|
|
|
if (tvp && vrefcnt(tvp) > 1 && !VTONFS(tvp)->n_sillyrename &&
|
1996-12-31 07:10:19 +00:00
|
|
|
tvp->v_type != VDIR && !nfs_sillyrename(tdvp, tvp, tcnp)) {
|
1997-04-04 17:49:35 +00:00
|
|
|
vput(tvp);
|
1995-06-27 11:07:30 +00:00
|
|
|
tvp = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = nfs_renamerpc(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen,
|
|
|
|
tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, tcnp->cn_cred,
|
2001-09-12 08:38:13 +00:00
|
|
|
tcnp->cn_thread);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (fvp->v_type == VDIR) {
|
|
|
|
if (tvp != NULL && tvp->v_type == VDIR)
|
|
|
|
cache_purge(tdvp);
|
|
|
|
cache_purge(fdvp);
|
|
|
|
}
|
1998-11-13 02:39:09 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
out:
|
|
|
|
if (tdvp == tvp)
|
|
|
|
vrele(tdvp);
|
|
|
|
else
|
|
|
|
vput(tdvp);
|
|
|
|
if (tvp)
|
|
|
|
vput(tvp);
|
|
|
|
vrele(fdvp);
|
|
|
|
vrele(fvp);
|
|
|
|
/*
|
|
|
|
* Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
|
|
|
|
*/
|
|
|
|
if (error == ENOENT)
|
|
|
|
error = 0;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs file rename rpc called from nfs_remove() above
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_renameit(struct vnode *sdvp, struct componentname *scnp,
|
|
|
|
struct sillyrename *sp)
|
1995-06-27 11:07:30 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
|
|
|
|
return (nfs_renamerpc(sdvp, scnp->cn_nameptr, scnp->cn_namelen, sdvp,
|
|
|
|
sp->s_name, sp->s_namlen, scnp->cn_cred, scnp->cn_thread));
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do an nfs rename rpc. Called from nfs_rename() and nfs_renameit().
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_renamerpc(struct vnode *fdvp, const char *fnameptr, int fnamelen,
|
|
|
|
struct vnode *tdvp, const char *tnameptr, int tnamelen, struct ucred *cred,
|
|
|
|
struct thread *td)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
caddr_t bpos, dpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, fwccflag = NFSV3_WCCRATTR, twccflag = NFSV3_WCCRATTR;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(fdvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
nfsstats.rpccnt[NFSPROC_RENAME]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2((NFSX_FH(v3) + NFSX_UNSIGNED)*2 + nfsm_rndup(fnamelen) +
|
|
|
|
nfsm_rndup(tnamelen), M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(fdvp, v3);
|
|
|
|
nfsm_strtom(fnameptr, fnamelen, NFS_MAXNAMLEN);
|
|
|
|
nfsm_fhtom(tdvp, v3);
|
|
|
|
nfsm_strtom(tnameptr, tnamelen, NFS_MAXNAMLEN);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(fdvp, NFSPROC_RENAME, td, cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
|
|
|
nfsm_wcc_data(fdvp, fwccflag);
|
|
|
|
nfsm_wcc_data(tdvp, twccflag);
|
|
|
|
}
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&(VTONFS(fdvp))->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(fdvp)->n_flag |= NMODIFIED;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&(VTONFS(fdvp))->n_mtx);
|
|
|
|
mtx_lock(&(VTONFS(tdvp))->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(tdvp)->n_flag |= NMODIFIED;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&(VTONFS(tdvp))->n_mtx);
|
2009-03-24 17:14:34 +00:00
|
|
|
if (!fwccflag) {
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(fdvp)->n_attrstamp = 0;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(fdvp);
|
|
|
|
}
|
|
|
|
if (!twccflag) {
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(tdvp)->n_attrstamp = 0;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(tdvp);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs hard link create call
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_link(struct vop_link_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct vnode *tdvp = ap->a_tdvp;
|
|
|
|
struct componentname *cnp = ap->a_cnp;
|
|
|
|
caddr_t bpos, dpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, wccflag = NFSV3_WCCRATTR, attrflag = 0;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1998-09-29 23:39:37 +00:00
|
|
|
int v3;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (vp->v_mount != tdvp->v_mount) {
|
|
|
|
return (EXDEV);
|
|
|
|
}
|
|
|
|
|
1994-10-17 17:47:45 +00:00
|
|
|
/*
|
|
|
|
* Push all writes to the server, so that the attribute cache
|
|
|
|
* doesn't get "out of sync" with the server.
|
|
|
|
* XXX There should be a better way!
|
|
|
|
*/
|
2005-01-11 07:36:22 +00:00
|
|
|
VOP_FSYNC(vp, MNT_WAIT, cnp->cn_thread);
|
1994-10-17 17:47:45 +00:00
|
|
|
|
1998-09-29 23:39:37 +00:00
|
|
|
v3 = NFS_ISV3(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsstats.rpccnt[NFSPROC_LINK]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3)*2 + NFSX_UNSIGNED +
|
|
|
|
nfsm_rndup(cnp->cn_namelen), M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(vp, v3);
|
|
|
|
nfsm_fhtom(tdvp, v3);
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(vp, NFSPROC_LINK, cnp->cn_thread, cnp->cn_cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
|
|
|
nfsm_postop_attr(vp, attrflag);
|
|
|
|
nfsm_wcc_data(tdvp, wccflag);
|
|
|
|
}
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&(VTONFS(tdvp))->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(tdvp)->n_flag |= NMODIFIED;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&(VTONFS(tdvp))->n_mtx);
|
2009-03-24 17:14:34 +00:00
|
|
|
if (!attrflag) {
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(vp)->n_attrstamp = 0;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
|
|
|
|
}
|
|
|
|
if (!wccflag) {
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(tdvp)->n_attrstamp = 0;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(tdvp);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs symbolic link create call
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_symlink(struct vop_symlink_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *dvp = ap->a_dvp;
|
|
|
|
struct vattr *vap = ap->a_vap;
|
|
|
|
struct componentname *cnp = ap->a_cnp;
|
|
|
|
struct nfsv2_sattr *sp;
|
|
|
|
caddr_t bpos, dpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
int slen, error = 0, wccflag = NFSV3_WCCRATTR, gotvp;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
2002-07-11 17:54:58 +00:00
|
|
|
struct vnode *newvp = NULL;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(dvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
nfsstats.rpccnt[NFSPROC_SYMLINK]++;
|
|
|
|
slen = strlen(ap->a_target);
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + 2*NFSX_UNSIGNED +
|
|
|
|
nfsm_rndup(cnp->cn_namelen) + nfsm_rndup(slen) + NFSX_SATTR(v3),
|
|
|
|
M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(dvp, v3);
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
1998-12-25 10:34:27 +00:00
|
|
|
nfsm_v3attrbuild(vap, FALSE);
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsm_strtom(ap->a_target, slen, NFS_MAXPATHLEN);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (!v3) {
|
2001-09-27 02:33:36 +00:00
|
|
|
sp = nfsm_build(struct nfsv2_sattr *, NFSX_V2SATTR);
|
1995-06-27 11:07:30 +00:00
|
|
|
sp->sa_mode = vtonfsv2_mode(VLNK, vap->va_mode);
|
1998-05-31 19:00:19 +00:00
|
|
|
sp->sa_uid = nfs_xdrneg1;
|
|
|
|
sp->sa_gid = nfs_xdrneg1;
|
|
|
|
sp->sa_size = nfs_xdrneg1;
|
1995-06-27 11:07:30 +00:00
|
|
|
txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
|
|
|
|
txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1999-11-30 06:56:15 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Issue the NFS request and get the rpc response.
|
|
|
|
*
|
|
|
|
* Only NFSv3 responses returning an error of 0 actually return
|
|
|
|
* a file handle that can be converted into newvp without having
|
|
|
|
* to do an extra lookup rpc.
|
|
|
|
*/
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(dvp, NFSPROC_SYMLINK, cnp->cn_thread, cnp->cn_cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
1999-11-30 06:56:15 +00:00
|
|
|
if (error == 0)
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_mtofh(dvp, newvp, v3, gotvp);
|
|
|
|
nfsm_wcc_data(dvp, wccflag);
|
|
|
|
}
|
1999-11-30 06:56:15 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* out code jumps -> here, mrep is also freed.
|
|
|
|
*/
|
|
|
|
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
1999-11-30 06:56:15 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
Remove hacks from the NFSv2/3 client intended to handle a lack of a
server-side RPC retranmission cache for non-idempotent operations: these
hacks substituted 0 (success) for the expected EEXIST in the event that
a target name already existed for LINK, SYMLINK, and MKDIR operations,
under the assumption that EEXIST represented a second application of the
original RPC rather than a true failure.
Background: certain NFS operations (in this case, LINK, SYMLINK, and
MKDIR) are not idempotent, as they leave behind persisting state on the
server that prevents them from being replayed without an error;if an UDP
RPC reply is lost leading to a retransmission by theclient, the second
reply will return EEXIST rather than success, asthe new object has
already been created. The NFS client previouslysilently mapped the
EEXIST return into success to paper over thisproblem.
However, in all modern NFS server implementations, a reply cache is kept
in order to retransmit the original reply to a retransmitted request,
rather than performing the operation a second time, allowing this hack
to be avoided. This allows link()-based filelocking over NFS to operate
correctly, as an application requestingthe creation of a new link for a
file to tell if it succeededatomically or not.
Other NFS clients, including Solaris and Linux, generally follow this
behavior for the same reasons. Most clients also now default to TCP,
which also helps avoid the issue of retransmitted but non-idempotent
requests in most cases.
Reported by: Adam McDougall <mcdouga9 at egr dot msu dot edu>,
Timo Sirainen <tss at iki dot fi>
Reviewed by: mohans
MFC after: 1 week
2007-11-19 16:03:21 +00:00
|
|
|
* If we do not have an error and we could not extract the newvp from
|
|
|
|
* the response due to the request being NFSv2, we have to do a
|
|
|
|
* lookup in order to obtain a newvp to return.
|
1999-11-30 06:56:15 +00:00
|
|
|
*/
|
|
|
|
if (error == 0 && newvp == NULL) {
|
|
|
|
struct nfsnode *np = NULL;
|
|
|
|
|
|
|
|
error = nfs_lookitup(dvp, cnp->cn_nameptr, cnp->cn_namelen,
|
2001-09-12 08:38:13 +00:00
|
|
|
cnp->cn_cred, cnp->cn_thread, &np);
|
1999-11-30 06:56:15 +00:00
|
|
|
if (!error)
|
|
|
|
newvp = NFSTOV(np);
|
|
|
|
}
|
1999-11-27 18:14:41 +00:00
|
|
|
if (error) {
|
|
|
|
if (newvp)
|
|
|
|
vput(newvp);
|
1999-11-30 06:56:15 +00:00
|
|
|
} else {
|
1999-11-27 18:14:41 +00:00
|
|
|
*ap->a_vpp = newvp;
|
1999-11-30 06:56:15 +00:00
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&(VTONFS(dvp))->n_mtx);
|
1999-11-27 18:14:41 +00:00
|
|
|
VTONFS(dvp)->n_flag |= NMODIFIED;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&(VTONFS(dvp))->n_mtx);
|
2009-03-24 17:14:34 +00:00
|
|
|
if (!wccflag) {
|
1999-11-27 18:14:41 +00:00
|
|
|
VTONFS(dvp)->n_attrstamp = 0;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs make dir call
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_mkdir(struct vop_mkdir_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *dvp = ap->a_dvp;
|
|
|
|
struct vattr *vap = ap->a_vap;
|
|
|
|
struct componentname *cnp = ap->a_cnp;
|
|
|
|
struct nfsv2_sattr *sp;
|
|
|
|
int len;
|
2002-07-11 17:54:58 +00:00
|
|
|
struct nfsnode *np = NULL;
|
|
|
|
struct vnode *newvp = NULL;
|
2001-09-18 23:32:09 +00:00
|
|
|
caddr_t bpos, dpos;
|
1995-10-29 15:33:36 +00:00
|
|
|
int error = 0, wccflag = NFSV3_WCCRATTR;
|
|
|
|
int gotvp = 0;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(dvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2008-08-28 15:23:18 +00:00
|
|
|
if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
len = cnp->cn_namelen;
|
|
|
|
nfsstats.rpccnt[NFSPROC_MKDIR]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len) +
|
|
|
|
NFSX_SATTR(v3), M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(dvp, v3);
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
1998-12-25 10:34:27 +00:00
|
|
|
nfsm_v3attrbuild(vap, FALSE);
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
2001-09-27 02:33:36 +00:00
|
|
|
sp = nfsm_build(struct nfsv2_sattr *, NFSX_V2SATTR);
|
1995-06-27 11:07:30 +00:00
|
|
|
sp->sa_mode = vtonfsv2_mode(VDIR, vap->va_mode);
|
1998-05-31 19:00:19 +00:00
|
|
|
sp->sa_uid = nfs_xdrneg1;
|
|
|
|
sp->sa_gid = nfs_xdrneg1;
|
|
|
|
sp->sa_size = nfs_xdrneg1;
|
1995-06-27 11:07:30 +00:00
|
|
|
txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
|
|
|
|
txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(dvp, NFSPROC_MKDIR, cnp->cn_thread, cnp->cn_cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (!error)
|
|
|
|
nfsm_mtofh(dvp, newvp, v3, gotvp);
|
|
|
|
if (v3)
|
|
|
|
nfsm_wcc_data(dvp, wccflag);
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&(VTONFS(dvp))->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
VTONFS(dvp)->n_flag |= NMODIFIED;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&(VTONFS(dvp))->n_mtx);
|
2009-03-24 17:14:34 +00:00
|
|
|
if (!wccflag) {
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(dvp)->n_attrstamp = 0;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
|
|
|
|
}
|
Remove hacks from the NFSv2/3 client intended to handle a lack of a
server-side RPC retranmission cache for non-idempotent operations: these
hacks substituted 0 (success) for the expected EEXIST in the event that
a target name already existed for LINK, SYMLINK, and MKDIR operations,
under the assumption that EEXIST represented a second application of the
original RPC rather than a true failure.
Background: certain NFS operations (in this case, LINK, SYMLINK, and
MKDIR) are not idempotent, as they leave behind persisting state on the
server that prevents them from being replayed without an error;if an UDP
RPC reply is lost leading to a retransmission by theclient, the second
reply will return EEXIST rather than success, asthe new object has
already been created. The NFS client previouslysilently mapped the
EEXIST return into success to paper over thisproblem.
However, in all modern NFS server implementations, a reply cache is kept
in order to retransmit the original reply to a retransmitted request,
rather than performing the operation a second time, allowing this hack
to be avoided. This allows link()-based filelocking over NFS to operate
correctly, as an application requestingthe creation of a new link for a
file to tell if it succeededatomically or not.
Other NFS clients, including Solaris and Linux, generally follow this
behavior for the same reasons. Most clients also now default to TCP,
which also helps avoid the issue of retransmitted but non-idempotent
requests in most cases.
Reported by: Adam McDougall <mcdouga9 at egr dot msu dot edu>,
Timo Sirainen <tss at iki dot fi>
Reviewed by: mohans
MFC after: 1 week
2007-11-19 16:03:21 +00:00
|
|
|
if (error == 0 && newvp == NULL) {
|
1995-06-27 11:07:30 +00:00
|
|
|
error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred,
|
2001-09-12 08:38:13 +00:00
|
|
|
cnp->cn_thread, &np);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (!error) {
|
|
|
|
newvp = NFSTOV(np);
|
|
|
|
if (newvp->v_type != VDIR)
|
|
|
|
error = EEXIST;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
if (error) {
|
|
|
|
if (newvp)
|
2004-11-29 23:05:30 +00:00
|
|
|
vput(newvp);
|
1995-06-27 11:07:30 +00:00
|
|
|
} else
|
|
|
|
*ap->a_vpp = newvp;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs remove directory call
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_rmdir(struct vop_rmdir_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct vnode *dvp = ap->a_dvp;
|
|
|
|
struct componentname *cnp = ap->a_cnp;
|
|
|
|
caddr_t bpos, dpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, wccflag = NFSV3_WCCRATTR;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(dvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-05-31 18:30:42 +00:00
|
|
|
if (dvp == vp)
|
|
|
|
return (EINVAL);
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsstats.rpccnt[NFSPROC_RMDIR]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED +
|
|
|
|
nfsm_rndup(cnp->cn_namelen), M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(dvp, v3);
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(dvp, NFSPROC_RMDIR, cnp->cn_thread, cnp->cn_cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3)
|
|
|
|
nfsm_wcc_data(dvp, wccflag);
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&(VTONFS(dvp))->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
VTONFS(dvp)->n_flag |= NMODIFIED;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&(VTONFS(dvp))->n_mtx);
|
2009-03-24 17:14:34 +00:00
|
|
|
if (!wccflag) {
|
1995-06-27 11:07:30 +00:00
|
|
|
VTONFS(dvp)->n_attrstamp = 0;
|
2009-03-24 17:14:34 +00:00
|
|
|
KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
cache_purge(dvp);
|
|
|
|
cache_purge(vp);
|
|
|
|
/*
|
|
|
|
* Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
|
|
|
|
*/
|
|
|
|
if (error == ENOENT)
|
|
|
|
error = 0;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs readdir call
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_readdir(struct vop_readdir_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct nfsnode *np = VTONFS(vp);
|
|
|
|
struct uio *uio = ap->a_uio;
|
2006-05-19 00:04:24 +00:00
|
|
|
int tresid, error = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
2006-05-19 00:04:24 +00:00
|
|
|
|
|
|
|
if (vp->v_type != VDIR)
|
|
|
|
return(EPERM);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* First, check for hit on the EOF offset cache
|
|
|
|
*/
|
1995-06-27 11:07:30 +00:00
|
|
|
if (np->n_direofoffset > 0 && uio->uio_offset >= np->n_direofoffset &&
|
1994-05-24 10:09:53 +00:00
|
|
|
(np->n_flag & NMODIFIED) == 0) {
|
2008-08-28 15:23:18 +00:00
|
|
|
if (VOP_GETATTR(vp, &vattr, ap->a_cred) == 0) {
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
|
|
|
if (!NFS_TIMESPEC_COMPARE(&np->n_mtime, &vattr.va_mtime)) {
|
|
|
|
mtx_unlock(&np->n_mtx);
|
|
|
|
nfsstats.direofcache_hits++;
|
|
|
|
goto out;
|
|
|
|
} else
|
|
|
|
mtx_unlock(&np->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call nfs_bioread() to do the real work.
|
|
|
|
*/
|
|
|
|
tresid = uio->uio_resid;
|
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
|
|
|
error = nfs_bioread(vp, uio, 0, ap->a_cred);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2006-05-19 00:04:24 +00:00
|
|
|
if (!error && uio->uio_resid == tresid) {
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsstats.direofcache_misses++;
|
2006-05-19 00:04:24 +00:00
|
|
|
}
|
|
|
|
out:
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Readdir rpc call.
|
|
|
|
* Called from below the buffer cache by nfs_doio().
|
|
|
|
*/
|
|
|
|
int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_readdirrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
int len, left;
|
|
|
|
struct dirent *dp = NULL;
|
|
|
|
u_int32_t *tl;
|
|
|
|
caddr_t cp;
|
|
|
|
nfsuint64 *cookiep;
|
|
|
|
caddr_t bpos, dpos;
|
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsuint64 cookie;
|
|
|
|
struct nfsmount *nmp = VFSTONFS(vp->v_mount);
|
|
|
|
struct nfsnode *dnp = VTONFS(vp);
|
1995-10-29 15:33:36 +00:00
|
|
|
u_quad_t fileno;
|
|
|
|
int error = 0, tlen, more_dirs = 1, blksiz = 0, bigenough = 1;
|
|
|
|
int attrflag;
|
1995-06-27 11:07:30 +00:00
|
|
|
int v3 = NFS_ISV3(vp);
|
|
|
|
|
2010-06-13 05:24:27 +00:00
|
|
|
KASSERT(uiop->uio_iovcnt == 1 &&
|
|
|
|
(uiop->uio_offset & (DIRBLKSIZ - 1)) == 0 &&
|
|
|
|
(uiop->uio_resid & (DIRBLKSIZ - 1)) == 0,
|
|
|
|
("nfs readdirrpc bad uio"));
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
1996-10-21 10:07:52 +00:00
|
|
|
* If there is no cookie, assume directory was stale.
|
1995-06-27 11:07:30 +00:00
|
|
|
*/
|
2006-05-19 00:04:24 +00:00
|
|
|
nfs_dircookie_lock(dnp);
|
1995-06-27 11:07:30 +00:00
|
|
|
cookiep = nfs_getcookie(dnp, uiop->uio_offset, 0);
|
2006-05-19 00:04:24 +00:00
|
|
|
if (cookiep) {
|
1995-06-27 11:07:30 +00:00
|
|
|
cookie = *cookiep;
|
2006-05-19 00:04:24 +00:00
|
|
|
nfs_dircookie_unlock(dnp);
|
|
|
|
} else {
|
|
|
|
nfs_dircookie_unlock(dnp);
|
1996-10-21 10:07:52 +00:00
|
|
|
return (NFSERR_BAD_COOKIE);
|
2006-05-19 00:04:24 +00:00
|
|
|
}
|
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
/*
|
|
|
|
* Loop around doing readdir rpc's of size nm_readdirsize
|
|
|
|
* truncated to a multiple of DIRBLKSIZ.
|
1994-05-24 10:09:53 +00:00
|
|
|
* The stopping criteria is EOF or buffer full.
|
|
|
|
*/
|
1995-06-27 11:07:30 +00:00
|
|
|
while (more_dirs && bigenough) {
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsstats.rpccnt[NFSPROC_READDIR]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + NFSX_READDIR(v3), M_WAITOK,
|
|
|
|
MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(vp, v3);
|
|
|
|
if (v3) {
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, 5 * NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl++ = cookie.nfsuquad[0];
|
|
|
|
*tl++ = cookie.nfsuquad[1];
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&dnp->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl++ = dnp->n_cookieverf.nfsuquad[0];
|
|
|
|
*tl++ = dnp->n_cookieverf.nfsuquad[1];
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&dnp->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
} else {
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, 2 * NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl++ = cookie.nfsuquad[0];
|
|
|
|
}
|
|
|
|
*tl = txdr_unsigned(nmp->nm_readdirsize);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(vp, NFSPROC_READDIR, uiop->uio_td, cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (v3) {
|
|
|
|
nfsm_postop_attr(vp, attrflag);
|
|
|
|
if (!error) {
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *,
|
1998-05-31 20:09:01 +00:00
|
|
|
2 * NFSX_UNSIGNED);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&dnp->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
dnp->n_cookieverf.nfsuquad[0] = *tl++;
|
|
|
|
dnp->n_cookieverf.nfsuquad[1] = *tl;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&dnp->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
} else {
|
|
|
|
m_freem(mrep);
|
|
|
|
goto nfsmout;
|
|
|
|
}
|
|
|
|
}
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
|
1994-05-24 10:09:53 +00:00
|
|
|
more_dirs = fxdr_unsigned(int, *tl);
|
2001-09-18 23:32:09 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/* loop thru the dir entries, doctoring them to 4bsd form */
|
1995-06-27 11:07:30 +00:00
|
|
|
while (more_dirs && bigenough) {
|
|
|
|
if (v3) {
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *,
|
1998-05-31 20:09:01 +00:00
|
|
|
3 * NFSX_UNSIGNED);
|
1999-06-05 05:35:03 +00:00
|
|
|
fileno = fxdr_hyper(tl);
|
1995-06-27 11:07:30 +00:00
|
|
|
len = fxdr_unsigned(int, *(tl + 2));
|
|
|
|
} else {
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *,
|
1998-05-31 20:09:01 +00:00
|
|
|
2 * NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
fileno = fxdr_unsigned(u_quad_t, *tl++);
|
|
|
|
len = fxdr_unsigned(int, *tl);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if (len <= 0 || len > NFS_MAXNAMLEN) {
|
|
|
|
error = EBADRPC;
|
|
|
|
m_freem(mrep);
|
|
|
|
goto nfsmout;
|
|
|
|
}
|
|
|
|
tlen = nfsm_rndup(len);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (tlen == len)
|
|
|
|
tlen += 4; /* To ensure null termination */
|
|
|
|
left = DIRBLKSIZ - blksiz;
|
|
|
|
if ((tlen + DIRHDSIZ) > left) {
|
|
|
|
dp->d_reclen += left;
|
2002-10-11 14:58:34 +00:00
|
|
|
uiop->uio_iov->iov_base =
|
|
|
|
(char *)uiop->uio_iov->iov_base + left;
|
1995-06-27 11:07:30 +00:00
|
|
|
uiop->uio_iov->iov_len -= left;
|
|
|
|
uiop->uio_offset += left;
|
|
|
|
uiop->uio_resid -= left;
|
|
|
|
blksiz = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
if ((tlen + DIRHDSIZ) > uiop->uio_resid)
|
|
|
|
bigenough = 0;
|
|
|
|
if (bigenough) {
|
|
|
|
dp = (struct dirent *)uiop->uio_iov->iov_base;
|
|
|
|
dp->d_fileno = (int)fileno;
|
|
|
|
dp->d_namlen = len;
|
|
|
|
dp->d_reclen = tlen + DIRHDSIZ;
|
|
|
|
dp->d_type = DT_UNKNOWN;
|
|
|
|
blksiz += dp->d_reclen;
|
|
|
|
if (blksiz == DIRBLKSIZ)
|
|
|
|
blksiz = 0;
|
|
|
|
uiop->uio_offset += DIRHDSIZ;
|
|
|
|
uiop->uio_resid -= DIRHDSIZ;
|
2002-10-11 14:58:34 +00:00
|
|
|
uiop->uio_iov->iov_base =
|
|
|
|
(char *)uiop->uio_iov->iov_base + DIRHDSIZ;
|
1995-06-27 11:07:30 +00:00
|
|
|
uiop->uio_iov->iov_len -= DIRHDSIZ;
|
|
|
|
nfsm_mtouio(uiop, len);
|
|
|
|
cp = uiop->uio_iov->iov_base;
|
|
|
|
tlen -= len;
|
|
|
|
*cp = '\0'; /* null terminate */
|
2002-10-11 14:58:34 +00:00
|
|
|
uiop->uio_iov->iov_base =
|
|
|
|
(char *)uiop->uio_iov->iov_base + tlen;
|
1995-06-27 11:07:30 +00:00
|
|
|
uiop->uio_iov->iov_len -= tlen;
|
|
|
|
uiop->uio_offset += tlen;
|
|
|
|
uiop->uio_resid -= tlen;
|
|
|
|
} else
|
|
|
|
nfsm_adv(nfsm_rndup(len));
|
|
|
|
if (v3) {
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *,
|
1998-05-31 20:09:01 +00:00
|
|
|
3 * NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
} else {
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *,
|
1998-05-31 20:09:01 +00:00
|
|
|
2 * NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
|
|
|
if (bigenough) {
|
|
|
|
cookie.nfsuquad[0] = *tl++;
|
|
|
|
if (v3)
|
|
|
|
cookie.nfsuquad[1] = *tl++;
|
|
|
|
} else if (v3)
|
|
|
|
tl += 2;
|
|
|
|
else
|
|
|
|
tl++;
|
1994-05-24 10:09:53 +00:00
|
|
|
more_dirs = fxdr_unsigned(int, *tl);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If at end of rpc data, get the eof boolean
|
|
|
|
*/
|
|
|
|
if (!more_dirs) {
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
|
1994-05-24 10:09:53 +00:00
|
|
|
more_dirs = (fxdr_unsigned(int, *tl) == 0);
|
|
|
|
}
|
|
|
|
m_freem(mrep);
|
|
|
|
}
|
|
|
|
/*
|
1995-06-27 11:07:30 +00:00
|
|
|
* Fill last record, iff any, out to a multiple of DIRBLKSIZ
|
1994-05-24 10:09:53 +00:00
|
|
|
* by increasing d_reclen for the last record.
|
|
|
|
*/
|
1995-06-27 11:07:30 +00:00
|
|
|
if (blksiz > 0) {
|
|
|
|
left = DIRBLKSIZ - blksiz;
|
|
|
|
dp->d_reclen += left;
|
2002-10-11 14:58:34 +00:00
|
|
|
uiop->uio_iov->iov_base =
|
|
|
|
(char *)uiop->uio_iov->iov_base + left;
|
1995-06-27 11:07:30 +00:00
|
|
|
uiop->uio_iov->iov_len -= left;
|
|
|
|
uiop->uio_offset += left;
|
|
|
|
uiop->uio_resid -= left;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We are now either at the end of the directory or have filled the
|
|
|
|
* block.
|
|
|
|
*/
|
|
|
|
if (bigenough)
|
|
|
|
dnp->n_direofoffset = uiop->uio_offset;
|
|
|
|
else {
|
|
|
|
if (uiop->uio_resid > 0)
|
2006-05-19 00:04:24 +00:00
|
|
|
nfs_printf("EEK! readdirrpc resid > 0\n");
|
|
|
|
nfs_dircookie_lock(dnp);
|
1995-06-27 11:07:30 +00:00
|
|
|
cookiep = nfs_getcookie(dnp, uiop->uio_offset, 1);
|
|
|
|
*cookiep = cookie;
|
2006-05-19 00:04:24 +00:00
|
|
|
nfs_dircookie_unlock(dnp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
nfsmout:
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1995-06-27 11:07:30 +00:00
|
|
|
* NFS V3 readdir plus RPC. Used in place of nfs_readdirrpc().
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_readdirplusrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
int len, left;
|
|
|
|
struct dirent *dp;
|
|
|
|
u_int32_t *tl;
|
|
|
|
caddr_t cp;
|
|
|
|
struct vnode *newvp;
|
|
|
|
nfsuint64 *cookiep;
|
|
|
|
caddr_t bpos, dpos, dpossav1, dpossav2;
|
|
|
|
struct mbuf *mreq, *mrep, *md, *mb, *mdsav1, *mdsav2;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct nameidata nami, *ndp = &nami;
|
|
|
|
struct componentname *cnp = &ndp->ni_cnd;
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsuint64 cookie;
|
|
|
|
struct nfsmount *nmp = VFSTONFS(vp->v_mount);
|
|
|
|
struct nfsnode *dnp = VTONFS(vp), *np;
|
2012-03-03 01:06:54 +00:00
|
|
|
struct vattr vattr, dvattr;
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsfh_t *fhp;
|
1995-10-29 15:33:36 +00:00
|
|
|
u_quad_t fileno;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, tlen, more_dirs = 1, blksiz = 0, doit, bigenough = 1, i;
|
2012-03-03 01:06:54 +00:00
|
|
|
int attrflag, dattrflag, fhsize;
|
1995-06-27 11:07:30 +00:00
|
|
|
|
|
|
|
#ifndef nolint
|
2002-07-11 17:54:58 +00:00
|
|
|
dp = NULL;
|
1995-06-27 11:07:30 +00:00
|
|
|
#endif
|
2010-06-13 05:24:27 +00:00
|
|
|
KASSERT(uiop->uio_iovcnt == 1 &&
|
|
|
|
(uiop->uio_offset & (DIRBLKSIZ - 1)) == 0 &&
|
|
|
|
(uiop->uio_resid & (DIRBLKSIZ - 1)) == 0,
|
|
|
|
("nfs readdirplusrpc bad uio"));
|
1994-05-24 10:09:53 +00:00
|
|
|
ndp->ni_dvp = vp;
|
|
|
|
newvp = NULLVP;
|
1995-06-27 11:07:30 +00:00
|
|
|
|
|
|
|
/*
|
1996-10-21 10:07:52 +00:00
|
|
|
* If there is no cookie, assume directory was stale.
|
1995-06-27 11:07:30 +00:00
|
|
|
*/
|
2006-05-19 00:04:24 +00:00
|
|
|
nfs_dircookie_lock(dnp);
|
1995-06-27 11:07:30 +00:00
|
|
|
cookiep = nfs_getcookie(dnp, uiop->uio_offset, 0);
|
2006-05-19 00:04:24 +00:00
|
|
|
if (cookiep) {
|
1995-06-27 11:07:30 +00:00
|
|
|
cookie = *cookiep;
|
2006-05-19 00:04:24 +00:00
|
|
|
nfs_dircookie_unlock(dnp);
|
|
|
|
} else {
|
|
|
|
nfs_dircookie_unlock(dnp);
|
1996-10-21 10:07:52 +00:00
|
|
|
return (NFSERR_BAD_COOKIE);
|
2006-05-19 00:04:24 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1995-06-27 11:07:30 +00:00
|
|
|
* Loop around doing readdir rpc's of size nm_readdirsize
|
|
|
|
* truncated to a multiple of DIRBLKSIZ.
|
1994-05-24 10:09:53 +00:00
|
|
|
* The stopping criteria is EOF or buffer full.
|
|
|
|
*/
|
1995-06-27 11:07:30 +00:00
|
|
|
while (more_dirs && bigenough) {
|
|
|
|
nfsstats.rpccnt[NFSPROC_READDIRPLUS]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(1) + 6 * NFSX_UNSIGNED, M_WAITOK,
|
|
|
|
MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(vp, 1);
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, 6 * NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl++ = cookie.nfsuquad[0];
|
|
|
|
*tl++ = cookie.nfsuquad[1];
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&dnp->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl++ = dnp->n_cookieverf.nfsuquad[0];
|
|
|
|
*tl++ = dnp->n_cookieverf.nfsuquad[1];
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&dnp->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl++ = txdr_unsigned(nmp->nm_readdirsize);
|
|
|
|
*tl = txdr_unsigned(nmp->nm_rsize);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(vp, NFSPROC_READDIRPLUS, uiop->uio_td, cred);
|
2012-03-03 01:06:54 +00:00
|
|
|
nfsm_postop_attr_va(vp, dattrflag, &dvattr);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (error) {
|
|
|
|
m_freem(mrep);
|
|
|
|
goto nfsmout;
|
|
|
|
}
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, 3 * NFSX_UNSIGNED);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&dnp->n_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
dnp->n_cookieverf.nfsuquad[0] = *tl++;
|
|
|
|
dnp->n_cookieverf.nfsuquad[1] = *tl++;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&dnp->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
more_dirs = fxdr_unsigned(int, *tl);
|
1995-05-30 08:16:23 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/* loop thru the dir entries, doctoring them to 4bsd form */
|
|
|
|
while (more_dirs && bigenough) {
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, 3 * NFSX_UNSIGNED);
|
1999-06-05 05:35:03 +00:00
|
|
|
fileno = fxdr_hyper(tl);
|
1995-06-27 11:07:30 +00:00
|
|
|
len = fxdr_unsigned(int, *(tl + 2));
|
1994-05-24 10:09:53 +00:00
|
|
|
if (len <= 0 || len > NFS_MAXNAMLEN) {
|
|
|
|
error = EBADRPC;
|
|
|
|
m_freem(mrep);
|
|
|
|
goto nfsmout;
|
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
tlen = nfsm_rndup(len);
|
|
|
|
if (tlen == len)
|
|
|
|
tlen += 4; /* To ensure null termination*/
|
|
|
|
left = DIRBLKSIZ - blksiz;
|
|
|
|
if ((tlen + DIRHDSIZ) > left) {
|
|
|
|
dp->d_reclen += left;
|
2002-10-11 14:58:34 +00:00
|
|
|
uiop->uio_iov->iov_base =
|
|
|
|
(char *)uiop->uio_iov->iov_base + left;
|
1995-06-27 11:07:30 +00:00
|
|
|
uiop->uio_iov->iov_len -= left;
|
|
|
|
uiop->uio_offset += left;
|
|
|
|
uiop->uio_resid -= left;
|
|
|
|
blksiz = 0;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((tlen + DIRHDSIZ) > uiop->uio_resid)
|
|
|
|
bigenough = 0;
|
1995-06-27 11:07:30 +00:00
|
|
|
if (bigenough) {
|
1994-05-24 10:09:53 +00:00
|
|
|
dp = (struct dirent *)uiop->uio_iov->iov_base;
|
1995-06-27 11:07:30 +00:00
|
|
|
dp->d_fileno = (int)fileno;
|
1994-05-24 10:09:53 +00:00
|
|
|
dp->d_namlen = len;
|
|
|
|
dp->d_reclen = tlen + DIRHDSIZ;
|
1995-06-27 11:07:30 +00:00
|
|
|
dp->d_type = DT_UNKNOWN;
|
|
|
|
blksiz += dp->d_reclen;
|
|
|
|
if (blksiz == DIRBLKSIZ)
|
|
|
|
blksiz = 0;
|
|
|
|
uiop->uio_offset += DIRHDSIZ;
|
1994-05-24 10:09:53 +00:00
|
|
|
uiop->uio_resid -= DIRHDSIZ;
|
2002-10-11 14:58:34 +00:00
|
|
|
uiop->uio_iov->iov_base =
|
|
|
|
(char *)uiop->uio_iov->iov_base + DIRHDSIZ;
|
1994-05-24 10:09:53 +00:00
|
|
|
uiop->uio_iov->iov_len -= DIRHDSIZ;
|
|
|
|
cnp->cn_nameptr = uiop->uio_iov->iov_base;
|
|
|
|
cnp->cn_namelen = len;
|
|
|
|
nfsm_mtouio(uiop, len);
|
|
|
|
cp = uiop->uio_iov->iov_base;
|
|
|
|
tlen -= len;
|
1995-06-27 11:07:30 +00:00
|
|
|
*cp = '\0';
|
2002-10-11 14:58:34 +00:00
|
|
|
uiop->uio_iov->iov_base =
|
|
|
|
(char *)uiop->uio_iov->iov_base + tlen;
|
1994-05-24 10:09:53 +00:00
|
|
|
uiop->uio_iov->iov_len -= tlen;
|
1995-06-27 11:07:30 +00:00
|
|
|
uiop->uio_offset += tlen;
|
1994-05-24 10:09:53 +00:00
|
|
|
uiop->uio_resid -= tlen;
|
1995-06-27 11:07:30 +00:00
|
|
|
} else
|
|
|
|
nfsm_adv(nfsm_rndup(len));
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, 3 * NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (bigenough) {
|
|
|
|
cookie.nfsuquad[0] = *tl++;
|
|
|
|
cookie.nfsuquad[1] = *tl++;
|
|
|
|
} else
|
|
|
|
tl += 2;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since the attributes are before the file handle
|
|
|
|
* (sigh), we must skip over the attributes and then
|
|
|
|
* come back and get them.
|
|
|
|
*/
|
|
|
|
attrflag = fxdr_unsigned(int, *tl);
|
|
|
|
if (attrflag) {
|
|
|
|
dpossav1 = dpos;
|
|
|
|
mdsav1 = md;
|
|
|
|
nfsm_adv(NFSX_V3FATTR);
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
doit = fxdr_unsigned(int, *tl);
|
2004-12-01 06:51:07 +00:00
|
|
|
/*
|
|
|
|
* Skip loading the attrs for "..". There's a
|
|
|
|
* race between loading the attrs here and
|
|
|
|
* lookups that look for the directory currently
|
|
|
|
* being read (in the parent). We try to acquire
|
|
|
|
* the exclusive lock on ".." here, owning the
|
|
|
|
* lock on the directory being read. Lookup will
|
|
|
|
* hold the lock on ".." and try to acquire the
|
|
|
|
* lock on the directory being read.
|
|
|
|
*
|
|
|
|
* There are other ways of fixing this, one would
|
|
|
|
* be to do a trylock on the ".." vnode and skip
|
|
|
|
* loading the attrs on ".." if it happens to be
|
|
|
|
* locked by another process. But skipping the
|
|
|
|
* attrload on ".." seems the easiest option.
|
|
|
|
*/
|
|
|
|
if (strcmp(dp->d_name, "..") == 0) {
|
|
|
|
doit = 0;
|
|
|
|
/*
|
|
|
|
* We've already skipped over the attrs,
|
|
|
|
* skip over the filehandle. And store d_type
|
|
|
|
* as VDIR.
|
|
|
|
*/
|
|
|
|
tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
|
|
|
|
i = fxdr_unsigned(int, *tl);
|
|
|
|
nfsm_adv(nfsm_rndup(i));
|
|
|
|
dp->d_type = IFTODT(VTTOIF(VDIR));
|
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
if (doit) {
|
|
|
|
nfsm_getfh(fhp, fhsize, 1);
|
|
|
|
if (NFS_CMPFH(dnp, fhp, fhsize)) {
|
|
|
|
VREF(vp);
|
|
|
|
newvp = vp;
|
|
|
|
np = dnp;
|
|
|
|
} else {
|
1998-05-31 17:27:58 +00:00
|
|
|
error = nfs_nget(vp->v_mount, fhp,
|
2006-09-13 18:39:09 +00:00
|
|
|
fhsize, &np, LK_EXCLUSIVE);
|
1998-05-31 17:27:58 +00:00
|
|
|
if (error)
|
1995-06-27 11:07:30 +00:00
|
|
|
doit = 0;
|
|
|
|
else
|
|
|
|
newvp = NFSTOV(np);
|
|
|
|
}
|
|
|
|
}
|
1999-07-30 04:02:04 +00:00
|
|
|
if (doit && bigenough) {
|
1995-06-27 11:07:30 +00:00
|
|
|
dpossav2 = dpos;
|
|
|
|
dpos = dpossav1;
|
|
|
|
mdsav2 = md;
|
|
|
|
md = mdsav1;
|
2012-01-20 20:02:01 +00:00
|
|
|
nfsm_loadattr(newvp, &vattr);
|
1995-06-27 11:07:30 +00:00
|
|
|
dpos = dpossav2;
|
|
|
|
md = mdsav2;
|
2012-01-20 20:02:01 +00:00
|
|
|
dp->d_type = IFTODT(VTTOIF(vattr.va_type));
|
1995-06-27 11:07:30 +00:00
|
|
|
ndp->ni_vp = newvp;
|
2012-03-03 01:06:54 +00:00
|
|
|
if (newvp->v_type != VDIR || dattrflag != 0)
|
|
|
|
cache_enter_time(ndp->ni_dvp, ndp->ni_vp,
|
|
|
|
cnp, &vattr.va_ctime,
|
|
|
|
newvp->v_type != VDIR ? NULL :
|
|
|
|
&dvattr.va_ctime);
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
1995-06-27 11:07:30 +00:00
|
|
|
/* Just skip over the file handle */
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
i = fxdr_unsigned(int, *tl);
|
2006-03-08 01:43:01 +00:00
|
|
|
if (i) {
|
2006-05-19 00:04:24 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
|
|
|
|
fhsize = fxdr_unsigned(int, *tl);
|
|
|
|
nfsm_adv(nfsm_rndup(fhsize));
|
2006-03-08 01:43:01 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
if (newvp != NULLVP) {
|
1999-07-30 04:02:04 +00:00
|
|
|
if (newvp == vp)
|
|
|
|
vrele(newvp);
|
|
|
|
else
|
|
|
|
vput(newvp);
|
1995-06-27 11:07:30 +00:00
|
|
|
newvp = NULLVP;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
|
1994-05-24 10:09:53 +00:00
|
|
|
more_dirs = fxdr_unsigned(int, *tl);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If at end of rpc data, get the eof boolean
|
|
|
|
*/
|
|
|
|
if (!more_dirs) {
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
|
1994-05-24 10:09:53 +00:00
|
|
|
more_dirs = (fxdr_unsigned(int, *tl) == 0);
|
|
|
|
}
|
|
|
|
m_freem(mrep);
|
|
|
|
}
|
|
|
|
/*
|
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
|
|
|
* Fill last record, iff any, out to a multiple of DIRBLKSIZ
|
1994-05-24 10:09:53 +00:00
|
|
|
* by increasing d_reclen for the last record.
|
|
|
|
*/
|
1995-06-27 11:07:30 +00:00
|
|
|
if (blksiz > 0) {
|
|
|
|
left = DIRBLKSIZ - blksiz;
|
|
|
|
dp->d_reclen += left;
|
2002-10-11 14:58:34 +00:00
|
|
|
uiop->uio_iov->iov_base =
|
|
|
|
(char *)uiop->uio_iov->iov_base + left;
|
1995-06-27 11:07:30 +00:00
|
|
|
uiop->uio_iov->iov_len -= left;
|
|
|
|
uiop->uio_offset += left;
|
|
|
|
uiop->uio_resid -= left;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We are now either at the end of the directory or have filled the
|
|
|
|
* block.
|
|
|
|
*/
|
|
|
|
if (bigenough)
|
|
|
|
dnp->n_direofoffset = uiop->uio_offset;
|
|
|
|
else {
|
|
|
|
if (uiop->uio_resid > 0)
|
2006-05-19 00:04:24 +00:00
|
|
|
nfs_printf("EEK! readdirplusrpc resid > 0\n");
|
|
|
|
nfs_dircookie_lock(dnp);
|
1995-06-27 11:07:30 +00:00
|
|
|
cookiep = nfs_getcookie(dnp, uiop->uio_offset, 1);
|
|
|
|
*cookiep = cookie;
|
2006-05-19 00:04:24 +00:00
|
|
|
nfs_dircookie_unlock(dnp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
nfsmout:
|
1995-06-27 11:07:30 +00:00
|
|
|
if (newvp != NULLVP) {
|
|
|
|
if (newvp == vp)
|
|
|
|
vrele(newvp);
|
|
|
|
else
|
|
|
|
vput(newvp);
|
|
|
|
newvp = NULLVP;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Silly rename. To make the NFS filesystem that is stateless look a little
|
|
|
|
* more like the "ufs" a remove of an active vnode is translated to a rename
|
|
|
|
* to a funny looking filename that is removed by nfs_inactive on the
|
|
|
|
* nfsnode. There is the potential for another process on a different client
|
|
|
|
* to create the same funny name between the nfs_lookitup() fails and the
|
|
|
|
* nfs_rename() completes, but...
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_sillyrename(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct sillyrename *sp;
|
1995-06-27 11:07:30 +00:00
|
|
|
struct nfsnode *np;
|
1994-05-24 10:09:53 +00:00
|
|
|
int error;
|
|
|
|
short pid;
|
2004-12-16 19:28:37 +00:00
|
|
|
unsigned int lticks;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
cache_purge(dvp);
|
|
|
|
np = VTONFS(vp);
|
2010-06-13 05:24:27 +00:00
|
|
|
KASSERT(vp->v_type != VDIR, ("nfs: sillyrename dir"));
|
2008-10-23 15:53:51 +00:00
|
|
|
sp = malloc(sizeof (struct sillyrename),
|
2003-02-19 05:47:46 +00:00
|
|
|
M_NFSREQ, M_WAITOK);
|
2001-10-11 23:38:17 +00:00
|
|
|
sp->s_cred = crhold(cnp->cn_cred);
|
1994-05-24 10:09:53 +00:00
|
|
|
sp->s_dvp = dvp;
|
2003-11-14 20:54:10 +00:00
|
|
|
sp->s_removeit = nfs_removeit;
|
1994-05-24 10:09:53 +00:00
|
|
|
VREF(dvp);
|
|
|
|
|
2004-12-16 19:28:37 +00:00
|
|
|
/*
|
|
|
|
* Fudge together a funny name.
|
|
|
|
* Changing the format of the funny name to accomodate more
|
|
|
|
* sillynames per directory.
|
|
|
|
* The name is now changed to .nfs.<ticks>.<pid>.4, where ticks is
|
|
|
|
* CPU ticks since boot.
|
|
|
|
*/
|
2001-09-12 08:38:13 +00:00
|
|
|
pid = cnp->cn_thread->td_proc->p_pid;
|
2004-12-16 19:28:37 +00:00
|
|
|
lticks = (unsigned int)ticks;
|
|
|
|
for ( ; ; ) {
|
|
|
|
sp->s_namlen = sprintf(sp->s_name,
|
|
|
|
".nfs.%08x.%04x4.4", lticks,
|
|
|
|
pid);
|
|
|
|
if (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
|
|
|
|
cnp->cn_thread, NULL))
|
|
|
|
break;
|
|
|
|
lticks++;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1998-05-31 17:27:58 +00:00
|
|
|
error = nfs_renameit(dvp, cnp, sp);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
1995-06-27 11:07:30 +00:00
|
|
|
error = nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
|
2001-09-12 08:38:13 +00:00
|
|
|
cnp->cn_thread, &np);
|
1994-05-24 10:09:53 +00:00
|
|
|
np->n_sillyrename = sp;
|
|
|
|
return (0);
|
|
|
|
bad:
|
|
|
|
vrele(sp->s_dvp);
|
|
|
|
crfree(sp->s_cred);
|
|
|
|
free((caddr_t)sp, M_NFSREQ);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1995-06-27 11:07:30 +00:00
|
|
|
* Look up a file name and optionally either update the file handle or
|
|
|
|
* allocate an nfsnode, depending on the value of npp.
|
|
|
|
* npp == NULL --> just do the lookup
|
|
|
|
* *npp == NULL --> allocate a new nfsnode and make sure attributes are
|
|
|
|
* handled too
|
|
|
|
* *npp != NULL --> update the file handle in the vnode
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_lookitup(struct vnode *dvp, const char *name, int len, struct ucred *cred,
|
|
|
|
struct thread *td, struct nfsnode **npp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-07-11 17:54:58 +00:00
|
|
|
struct vnode *newvp = NULL;
|
1995-06-27 11:07:30 +00:00
|
|
|
struct nfsnode *np, *dnp = VTONFS(dvp);
|
2001-09-18 23:32:09 +00:00
|
|
|
caddr_t bpos, dpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, fhlen, attrflag;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsfh_t *nfhp;
|
|
|
|
int v3 = NFS_ISV3(dvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
nfsstats.rpccnt[NFSPROC_LOOKUP]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len),
|
|
|
|
M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(dvp, v3);
|
|
|
|
nfsm_strtom(name, len, NFS_MAXNAMLEN);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(dvp, NFSPROC_LOOKUP, td, cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (npp && !error) {
|
|
|
|
nfsm_getfh(nfhp, fhlen, v3);
|
|
|
|
if (*npp) {
|
|
|
|
np = *npp;
|
|
|
|
if (np->n_fhsize > NFS_SMALLFH && fhlen <= NFS_SMALLFH) {
|
|
|
|
free((caddr_t)np->n_fhp, M_NFSBIGFH);
|
|
|
|
np->n_fhp = &np->n_fh;
|
|
|
|
} else if (np->n_fhsize <= NFS_SMALLFH && fhlen>NFS_SMALLFH)
|
2003-02-19 05:47:46 +00:00
|
|
|
np->n_fhp =(nfsfh_t *)malloc(fhlen, M_NFSBIGFH, M_WAITOK);
|
1995-06-27 11:07:30 +00:00
|
|
|
bcopy((caddr_t)nfhp, (caddr_t)np->n_fhp, fhlen);
|
|
|
|
np->n_fhsize = fhlen;
|
|
|
|
newvp = NFSTOV(np);
|
|
|
|
} else if (NFS_CMPFH(dnp, nfhp, fhlen)) {
|
|
|
|
VREF(dvp);
|
|
|
|
newvp = dvp;
|
|
|
|
} else {
|
2006-09-13 18:39:09 +00:00
|
|
|
error = nfs_nget(dvp->v_mount, nfhp, fhlen, &np, LK_EXCLUSIVE);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (error) {
|
|
|
|
m_freem(mrep);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
newvp = NFSTOV(np);
|
|
|
|
}
|
|
|
|
if (v3) {
|
|
|
|
nfsm_postop_attr(newvp, attrflag);
|
|
|
|
if (!attrflag && *npp == NULL) {
|
|
|
|
m_freem(mrep);
|
|
|
|
if (newvp == dvp)
|
|
|
|
vrele(newvp);
|
|
|
|
else
|
|
|
|
vput(newvp);
|
|
|
|
return (ENOENT);
|
|
|
|
}
|
|
|
|
} else
|
2002-07-11 17:54:58 +00:00
|
|
|
nfsm_loadattr(newvp, NULL);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
1995-06-27 11:07:30 +00:00
|
|
|
if (npp && *npp == NULL) {
|
|
|
|
if (error) {
|
1999-05-06 18:13:11 +00:00
|
|
|
if (newvp) {
|
1995-06-27 11:07:30 +00:00
|
|
|
if (newvp == dvp)
|
|
|
|
vrele(newvp);
|
|
|
|
else
|
|
|
|
vput(newvp);
|
1999-05-06 18:13:11 +00:00
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
} else
|
|
|
|
*npp = np;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Nfs Version 3 commit rpc
|
|
|
|
*/
|
1999-09-17 05:57:57 +00:00
|
|
|
int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_commit(struct vnode *vp, u_quad_t offset, int cnt, struct ucred *cred,
|
2006-05-19 00:04:24 +00:00
|
|
|
struct thread *td)
|
1995-06-27 11:07:30 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
u_int32_t *tl;
|
|
|
|
struct nfsmount *nmp = VFSTONFS(vp->v_mount);
|
|
|
|
caddr_t bpos, dpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
int error = 0, wccflag = NFSV3_WCCRATTR;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mreq, *mrep, *md, *mb;
|
|
|
|
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&nmp->nm_mtx);
|
|
|
|
if ((nmp->nm_state & NFSSTA_HASWRITEVERF) == 0) {
|
|
|
|
mtx_unlock(&nmp->nm_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
return (0);
|
2006-05-19 00:04:24 +00:00
|
|
|
}
|
|
|
|
mtx_unlock(&nmp->nm_mtx);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsstats.rpccnt[NFSPROC_COMMIT]++;
|
2013-03-12 13:42:47 +00:00
|
|
|
mreq = m_get2(NFSX_FH(1), M_WAITOK, MT_DATA, 0);
|
2001-09-18 23:32:09 +00:00
|
|
|
mb = mreq;
|
|
|
|
bpos = mtod(mb, caddr_t);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_fhtom(vp, 1);
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, 3 * NFSX_UNSIGNED);
|
1999-06-05 05:35:03 +00:00
|
|
|
txdr_hyper(offset, tl);
|
1995-06-27 11:07:30 +00:00
|
|
|
tl += 2;
|
|
|
|
*tl = txdr_unsigned(cnt);
|
2001-09-12 08:38:13 +00:00
|
|
|
nfsm_request(vp, NFSPROC_COMMIT, td, cred);
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsm_wcc_data(vp, wccflag);
|
|
|
|
if (!error) {
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, NFSX_V3WRITEVERF);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (bcmp((caddr_t)nmp->nm_verf, (caddr_t)tl,
|
|
|
|
NFSX_V3WRITEVERF)) {
|
|
|
|
bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
|
|
|
|
NFSX_V3WRITEVERF);
|
|
|
|
error = NFSERR_STALEWRITEVERF;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-09-18 23:32:09 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
nfsmout:
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Strategy routine.
|
|
|
|
* For async requests when nfsiod(s) are running, queue the request by
|
|
|
|
* calling nfs_asyncio(), otherwise just all nfs_doio() to do the
|
|
|
|
* request.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_strategy(struct vop_strategy_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct buf *bp = ap->a_bp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ucred *cr;
|
|
|
|
|
2008-01-19 17:36:23 +00:00
|
|
|
KASSERT(!(bp->b_flags & B_DONE),
|
|
|
|
("nfs_strategy: buffer %p unexpectedly marked B_DONE", bp));
|
2008-02-13 20:44:19 +00:00
|
|
|
BUF_ASSERT_HELD(bp);
|
1999-03-12 02:24:58 +00:00
|
|
|
|
2000-03-20 10:44:49 +00:00
|
|
|
if (bp->b_iocmd == BIO_READ)
|
1994-05-24 10:09:53 +00:00
|
|
|
cr = bp->b_rcred;
|
|
|
|
else
|
|
|
|
cr = bp->b_wcred;
|
1999-01-21 08:29:12 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* If the op is asynchronous and an i/o daemon is waiting
|
|
|
|
* queue the request, wake it up and wait for completion
|
|
|
|
* otherwise just do it ourselves.
|
|
|
|
*/
|
|
|
|
if ((bp->b_flags & B_ASYNC) == 0 ||
|
2006-07-08 15:36:51 +00:00
|
|
|
nfs_asyncio(VFSTONFS(ap->a_vp->v_mount), bp, NOCRED, curthread))
|
|
|
|
(void)nfs_doio(ap->a_vp, bp, cr, curthread);
|
2005-11-21 19:23:46 +00:00
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1995-06-27 11:07:30 +00:00
|
|
|
* fsync vnode op. Just call nfs_flush() with commit == 1.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_fsync(struct vop_fsync_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2008-08-28 15:23:18 +00:00
|
|
|
|
|
|
|
return (nfs_flush(ap->a_vp, ap->a_waitfor, 1));
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush all the blocks associated with a vnode.
|
|
|
|
* Walk through the buffer pool and push any dirty pages
|
|
|
|
* associated with the vnode.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2008-08-28 15:23:18 +00:00
|
|
|
nfs_flush(struct vnode *vp, int waitfor, int commit)
|
1995-06-27 11:07:30 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct nfsnode *np = VTONFS(vp);
|
|
|
|
struct buf *bp;
|
|
|
|
int i;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct buf *nbp;
|
1995-06-27 11:07:30 +00:00
|
|
|
struct nfsmount *nmp = VFSTONFS(vp->v_mount);
|
2008-03-22 09:15:16 +00:00
|
|
|
int error = 0, slptimeo = 0, slpflag = 0, retv, bvecpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
int passone = 1;
|
1997-06-03 10:03:40 +00:00
|
|
|
u_quad_t off, endoff, toff;
|
1995-06-28 17:33:39 +00:00
|
|
|
struct ucred* wcred = NULL;
|
1997-06-03 10:03:40 +00:00
|
|
|
struct buf **bvec = NULL;
|
2008-03-22 09:15:16 +00:00
|
|
|
struct bufobj *bo;
|
2008-08-28 15:23:18 +00:00
|
|
|
struct thread *td = curthread;
|
1995-06-27 11:07:30 +00:00
|
|
|
#ifndef NFS_COMMITBVECSIZ
|
|
|
|
#define NFS_COMMITBVECSIZ 20
|
|
|
|
#endif
|
1997-06-03 10:03:40 +00:00
|
|
|
struct buf *bvec_on_stack[NFS_COMMITBVECSIZ];
|
|
|
|
int bvecsize = 0, bveccount;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (nmp->nm_flag & NFSMNT_INT)
|
2013-03-13 21:06:03 +00:00
|
|
|
slpflag = PCATCH;
|
1995-06-27 11:07:30 +00:00
|
|
|
if (!commit)
|
|
|
|
passone = 0;
|
2008-03-22 09:15:16 +00:00
|
|
|
bo = &vp->v_bufobj;
|
1995-06-27 11:07:30 +00:00
|
|
|
/*
|
|
|
|
* A b_flags == (B_DELWRI | B_NEEDCOMMIT) block has been written to the
|
2005-12-28 10:03:48 +00:00
|
|
|
* server, but has not been committed to stable storage on the server
|
1995-06-27 11:07:30 +00:00
|
|
|
* yet. On the first pass, the byte range is worked out and the commit
|
|
|
|
* rpc is done. On the second pass, nfs_writebp() is called to do the
|
|
|
|
* job.
|
|
|
|
*/
|
|
|
|
again:
|
1997-06-03 10:03:40 +00:00
|
|
|
off = (u_quad_t)-1;
|
|
|
|
endoff = 0;
|
1995-06-27 11:07:30 +00:00
|
|
|
bvecpos = 0;
|
|
|
|
if (NFS_ISV3(vp) && commit) {
|
2002-12-23 06:20:41 +00:00
|
|
|
if (bvec != NULL && bvec != bvec_on_stack)
|
|
|
|
free(bvec, M_TEMP);
|
1997-06-03 10:03:40 +00:00
|
|
|
/*
|
|
|
|
* Count up how many buffers waiting for a commit.
|
|
|
|
*/
|
|
|
|
bveccount = 0;
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_LOCK(bo);
|
|
|
|
TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
|
2008-01-19 17:36:23 +00:00
|
|
|
if (!BUF_ISLOCKED(bp) &&
|
1999-06-26 02:47:16 +00:00
|
|
|
(bp->b_flags & (B_DELWRI | B_NEEDCOMMIT))
|
|
|
|
== (B_DELWRI | B_NEEDCOMMIT))
|
1997-06-03 10:03:40 +00:00
|
|
|
bveccount++;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Allocate space to remember the list of bufs to commit. It is
|
|
|
|
* important to use M_NOWAIT here to avoid a race with nfs_write.
|
|
|
|
* If we can't get memory (for whatever reason), we will end up
|
|
|
|
* committing the buffers one-by-one in the loop below.
|
|
|
|
*/
|
|
|
|
if (bveccount > NFS_COMMITBVECSIZ) {
|
2002-12-23 06:20:41 +00:00
|
|
|
/*
|
|
|
|
* Release the vnode interlock to avoid a lock
|
|
|
|
* order reversal.
|
|
|
|
*/
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_UNLOCK(bo);
|
1997-06-03 10:03:40 +00:00
|
|
|
bvec = (struct buf **)
|
|
|
|
malloc(bveccount * sizeof(struct buf *),
|
|
|
|
M_TEMP, M_NOWAIT);
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_LOCK(bo);
|
1997-06-03 10:03:40 +00:00
|
|
|
if (bvec == NULL) {
|
|
|
|
bvec = bvec_on_stack;
|
|
|
|
bvecsize = NFS_COMMITBVECSIZ;
|
|
|
|
} else
|
|
|
|
bvecsize = bveccount;
|
|
|
|
} else {
|
|
|
|
bvec = bvec_on_stack;
|
|
|
|
bvecsize = NFS_COMMITBVECSIZ;
|
|
|
|
}
|
2008-03-22 09:15:16 +00:00
|
|
|
TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
|
1997-06-03 10:03:40 +00:00
|
|
|
if (bvecpos >= bvecsize)
|
1995-06-27 11:07:30 +00:00
|
|
|
break;
|
2003-03-13 07:04:11 +00:00
|
|
|
if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) {
|
2004-10-21 15:53:54 +00:00
|
|
|
nbp = TAILQ_NEXT(bp, b_bobufs);
|
2003-02-26 00:24:19 +00:00
|
|
|
continue;
|
|
|
|
}
|
2003-03-13 07:04:11 +00:00
|
|
|
if ((bp->b_flags & (B_DELWRI | B_NEEDCOMMIT)) !=
|
|
|
|
(B_DELWRI | B_NEEDCOMMIT)) {
|
2003-03-14 05:13:19 +00:00
|
|
|
BUF_UNLOCK(bp);
|
2004-10-21 15:53:54 +00:00
|
|
|
nbp = TAILQ_NEXT(bp, b_bobufs);
|
1995-06-27 11:07:30 +00:00
|
|
|
continue;
|
2002-09-25 02:38:43 +00:00
|
|
|
}
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_UNLOCK(bo);
|
1995-06-27 11:07:30 +00:00
|
|
|
bremfree(bp);
|
1995-06-28 17:33:39 +00:00
|
|
|
/*
|
|
|
|
* Work out if all buffers are using the same cred
|
|
|
|
* so we can deal with them all with one commit.
|
1999-03-12 02:24:58 +00:00
|
|
|
*
|
|
|
|
* NOTE: we are not clearing B_DONE here, so we have
|
2001-09-18 23:32:09 +00:00
|
|
|
* to do it later on in this routine if we intend to
|
1999-03-12 02:24:58 +00:00
|
|
|
* initiate I/O on the bp.
|
2001-02-28 04:13:11 +00:00
|
|
|
*
|
|
|
|
* Note: to avoid loopback deadlocks, we do not
|
|
|
|
* assign b_runningbufspace.
|
1995-06-28 17:33:39 +00:00
|
|
|
*/
|
|
|
|
if (wcred == NULL)
|
|
|
|
wcred = bp->b_wcred;
|
|
|
|
else if (wcred != bp->b_wcred)
|
|
|
|
wcred = NOCRED;
|
1995-06-27 11:07:30 +00:00
|
|
|
vfs_busy_pages(bp, 1);
|
1999-03-12 02:24:58 +00:00
|
|
|
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_LOCK(bo);
|
1999-03-12 02:24:58 +00:00
|
|
|
/*
|
1999-06-26 02:47:16 +00:00
|
|
|
* bp is protected by being locked, but nbp is not
|
1999-03-12 02:24:58 +00:00
|
|
|
* and vfs_busy_pages() may sleep. We have to
|
|
|
|
* recalculate nbp.
|
|
|
|
*/
|
2004-10-21 15:53:54 +00:00
|
|
|
nbp = TAILQ_NEXT(bp, b_bobufs);
|
1999-03-12 02:24:58 +00:00
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
/*
|
|
|
|
* A list of these buffers is kept so that the
|
|
|
|
* second loop knows which buffers have actually
|
|
|
|
* been committed. This is necessary, since there
|
|
|
|
* may be a race between the commit rpc and new
|
|
|
|
* uncommitted writes on the file.
|
|
|
|
*/
|
|
|
|
bvec[bvecpos++] = bp;
|
|
|
|
toff = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +
|
|
|
|
bp->b_dirtyoff;
|
|
|
|
if (toff < off)
|
|
|
|
off = toff;
|
|
|
|
toff += (u_quad_t)(bp->b_dirtyend - bp->b_dirtyoff);
|
|
|
|
if (toff > endoff)
|
|
|
|
endoff = toff;
|
|
|
|
}
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_UNLOCK(bo);
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
|
|
|
if (bvecpos > 0) {
|
|
|
|
/*
|
|
|
|
* Commit data on the server, as required.
|
1995-06-28 17:33:39 +00:00
|
|
|
* If all bufs are using the same wcred, then use that with
|
|
|
|
* one call for all of them, otherwise commit each one
|
|
|
|
* separately.
|
1995-06-27 11:07:30 +00:00
|
|
|
*/
|
1995-06-28 17:33:39 +00:00
|
|
|
if (wcred != NOCRED)
|
|
|
|
retv = nfs_commit(vp, off, (int)(endoff - off),
|
2001-09-12 08:38:13 +00:00
|
|
|
wcred, td);
|
1995-06-28 17:33:39 +00:00
|
|
|
else {
|
|
|
|
retv = 0;
|
|
|
|
for (i = 0; i < bvecpos; i++) {
|
|
|
|
off_t off, size;
|
|
|
|
bp = bvec[i];
|
|
|
|
off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +
|
|
|
|
bp->b_dirtyoff;
|
|
|
|
size = (u_quad_t)(bp->b_dirtyend
|
|
|
|
- bp->b_dirtyoff);
|
|
|
|
retv = nfs_commit(vp, off, (int)size,
|
2001-09-12 08:38:13 +00:00
|
|
|
bp->b_wcred, td);
|
1995-06-28 17:33:39 +00:00
|
|
|
if (retv) break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
if (retv == NFSERR_STALEWRITEVERF)
|
|
|
|
nfs_clearcommit(vp->v_mount);
|
1999-03-12 02:24:58 +00:00
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
/*
|
|
|
|
* Now, either mark the blocks I/O done or mark the
|
|
|
|
* blocks dirty, depending on whether the commit
|
|
|
|
* succeeded.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < bvecpos; i++) {
|
|
|
|
bp = bvec[i];
|
2004-09-15 21:49:22 +00:00
|
|
|
bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (retv) {
|
1999-03-12 02:24:58 +00:00
|
|
|
/*
|
|
|
|
* Error, leave B_DELWRI intact
|
|
|
|
*/
|
|
|
|
vfs_unbusy_pages(bp);
|
|
|
|
brelse(bp);
|
1995-06-27 11:07:30 +00:00
|
|
|
} else {
|
1999-03-12 02:24:58 +00:00
|
|
|
/*
|
|
|
|
* Success, remove B_DELWRI ( bundirty() ).
|
|
|
|
*
|
2001-09-18 23:32:09 +00:00
|
|
|
* b_dirtyoff/b_dirtyend seem to be NFS
|
1999-03-12 02:24:58 +00:00
|
|
|
* specific. We should probably move that
|
|
|
|
* into bundirty(). XXX
|
|
|
|
*/
|
2008-03-22 09:15:16 +00:00
|
|
|
bufobj_wref(bo);
|
1999-03-12 02:24:58 +00:00
|
|
|
bp->b_flags |= B_ASYNC;
|
|
|
|
bundirty(bp);
|
2000-04-02 15:24:56 +00:00
|
|
|
bp->b_flags &= ~B_DONE;
|
|
|
|
bp->b_ioflags &= ~BIO_ERROR;
|
1999-03-12 02:24:58 +00:00
|
|
|
bp->b_dirtyoff = bp->b_dirtyend = 0;
|
2000-04-15 05:54:02 +00:00
|
|
|
bufdone(bp);
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start/do any write(s) that are required.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
loop:
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_LOCK(bo);
|
|
|
|
TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
|
2003-02-25 03:37:48 +00:00
|
|
|
if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) {
|
|
|
|
if (waitfor != MNT_WAIT || passone)
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
2003-02-25 03:37:48 +00:00
|
|
|
|
|
|
|
error = BUF_TIMELOCK(bp,
|
|
|
|
LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
|
2013-05-31 00:43:41 +00:00
|
|
|
BO_LOCKPTR(bo), "nfsfsync", slpflag, slptimeo);
|
2006-05-19 00:04:24 +00:00
|
|
|
if (error == 0) {
|
|
|
|
BUF_UNLOCK(bp);
|
|
|
|
goto loop;
|
|
|
|
}
|
2008-05-27 00:20:19 +00:00
|
|
|
if (error == ENOLCK) {
|
|
|
|
error = 0;
|
1999-06-26 02:47:16 +00:00
|
|
|
goto loop;
|
2008-05-27 00:20:19 +00:00
|
|
|
}
|
2009-06-30 19:10:17 +00:00
|
|
|
if (nfs_sigintr(nmp, td)) {
|
2004-12-07 21:16:32 +00:00
|
|
|
error = EINTR;
|
|
|
|
goto done;
|
|
|
|
}
|
2013-03-13 21:06:03 +00:00
|
|
|
if (slpflag == PCATCH) {
|
1994-05-24 10:09:53 +00:00
|
|
|
slpflag = 0;
|
|
|
|
slptimeo = 2 * hz;
|
|
|
|
}
|
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
if ((bp->b_flags & B_DELWRI) == 0)
|
|
|
|
panic("nfs_fsync: not dirty");
|
1999-06-26 02:47:16 +00:00
|
|
|
if ((passone || !commit) && (bp->b_flags & B_NEEDCOMMIT)) {
|
|
|
|
BUF_UNLOCK(bp);
|
1995-06-27 11:07:30 +00:00
|
|
|
continue;
|
1999-06-26 02:47:16 +00:00
|
|
|
}
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_UNLOCK(bo);
|
1994-05-24 10:09:53 +00:00
|
|
|
bremfree(bp);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (passone || !commit)
|
1999-06-26 02:47:16 +00:00
|
|
|
bp->b_flags |= B_ASYNC;
|
1995-06-27 11:07:30 +00:00
|
|
|
else
|
2004-09-15 21:49:22 +00:00
|
|
|
bp->b_flags |= B_ASYNC;
|
2004-03-11 18:02:36 +00:00
|
|
|
bwrite(bp);
|
2009-06-30 19:10:17 +00:00
|
|
|
if (nfs_sigintr(nmp, td)) {
|
2004-12-07 21:16:32 +00:00
|
|
|
error = EINTR;
|
|
|
|
goto done;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
goto loop;
|
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
if (passone) {
|
|
|
|
passone = 0;
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_UNLOCK(bo);
|
1995-06-27 11:07:30 +00:00
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
if (waitfor == MNT_WAIT) {
|
2008-03-22 09:15:16 +00:00
|
|
|
while (bo->bo_numoutput) {
|
|
|
|
error = bufobj_wwait(bo, slpflag, slptimeo);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error) {
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_UNLOCK(bo);
|
2009-06-30 19:10:17 +00:00
|
|
|
error = nfs_sigintr(nmp, td);
|
2004-07-06 09:12:03 +00:00
|
|
|
if (error)
|
1997-06-03 10:03:40 +00:00
|
|
|
goto done;
|
2013-03-13 21:06:03 +00:00
|
|
|
if (slpflag == PCATCH) {
|
1994-05-24 10:09:53 +00:00
|
|
|
slpflag = 0;
|
|
|
|
slptimeo = 2 * hz;
|
|
|
|
}
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_LOCK(bo);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
2008-03-22 09:15:16 +00:00
|
|
|
if (bo->bo_dirty.bv_cnt != 0 && commit) {
|
|
|
|
BO_UNLOCK(bo);
|
1994-05-24 10:09:53 +00:00
|
|
|
goto loop;
|
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
/*
|
|
|
|
* Wait for all the async IO requests to drain
|
2006-04-06 01:20:30 +00:00
|
|
|
*/
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_UNLOCK(bo);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
2006-04-06 01:20:30 +00:00
|
|
|
while (np->n_directio_asyncwr > 0) {
|
|
|
|
np->n_flag |= NFSYNCWAIT;
|
2006-05-19 00:04:24 +00:00
|
|
|
error = nfs_msleep(td, (caddr_t)&np->n_directio_asyncwr,
|
|
|
|
&np->n_mtx, slpflag | (PRIBIO + 1),
|
|
|
|
"nfsfsync", 0);
|
2006-04-06 01:20:30 +00:00
|
|
|
if (error) {
|
2009-06-30 19:10:17 +00:00
|
|
|
if (nfs_sigintr(nmp, td)) {
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
|
|
|
error = EINTR;
|
2006-04-06 01:20:30 +00:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
|
|
|
} else
|
2008-03-22 09:15:16 +00:00
|
|
|
BO_UNLOCK(bo);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (np->n_flag & NWRITEERR) {
|
|
|
|
error = np->n_error;
|
|
|
|
np->n_flag &= ~NWRITEERR;
|
|
|
|
}
|
2008-03-22 09:15:16 +00:00
|
|
|
if (commit && bo->bo_dirty.bv_cnt == 0 &&
|
|
|
|
bo->bo_numoutput == 0 && np->n_directio_asyncwr == 0)
|
2004-12-06 16:35:58 +00:00
|
|
|
np->n_flag &= ~NMODIFIED;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
1997-06-03 10:03:40 +00:00
|
|
|
done:
|
|
|
|
if (bvec != NULL && bvec != bvec_on_stack)
|
|
|
|
free(bvec, M_TEMP);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NFS advisory byte-level locks.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_advlock(struct vop_advlock_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
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 vnode *vp = ap->a_vp;
|
|
|
|
u_quad_t size;
|
2006-05-19 00:04:24 +00:00
|
|
|
int error;
|
2001-11-12 02:33:52 +00:00
|
|
|
|
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
|
|
|
error = vn_lock(vp, LK_SHARED);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
if ((VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NOLOCKD) != 0) {
|
|
|
|
size = VTONFS(vp)->n_size;
|
|
|
|
VOP_UNLOCK(vp, 0);
|
|
|
|
error = lf_advlock(ap, &(vp->v_lockf), size);
|
2008-06-26 10:21:54 +00:00
|
|
|
} else {
|
|
|
|
if (nfs_advlock_p)
|
|
|
|
error = nfs_advlock_p(ap);
|
|
|
|
else
|
|
|
|
error = ENOLCK;
|
|
|
|
}
|
|
|
|
|
2008-03-26 15:23:12 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NFS advisory byte-level locks.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
nfs_advlockasync(struct vop_advlockasync_args *ap)
|
|
|
|
{
|
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 vnode *vp = ap->a_vp;
|
|
|
|
u_quad_t size;
|
2008-03-26 15:23:12 +00:00
|
|
|
int error;
|
|
|
|
|
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
|
|
|
error = vn_lock(vp, LK_SHARED);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
if ((VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NOLOCKD) != 0) {
|
|
|
|
size = VTONFS(vp)->n_size;
|
|
|
|
VOP_UNLOCK(vp, 0);
|
|
|
|
error = lf_advlockasync(ap, &(vp->v_lockf), size);
|
|
|
|
} else {
|
|
|
|
VOP_UNLOCK(vp, 0);
|
|
|
|
error = EOPNOTSUPP;
|
2008-03-26 15:23:12 +00:00
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Print out the contents of an nfsnode.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_print(struct vop_print_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct nfsnode *np = VTONFS(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2006-05-19 00:04:24 +00:00
|
|
|
nfs_printf("\tfileid %ld fsid 0x%x",
|
2003-03-03 19:15:40 +00:00
|
|
|
np->n_vattr.va_fileid, np->n_vattr.va_fsid);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (vp->v_type == VFIFO)
|
|
|
|
fifo_printinfo(vp);
|
|
|
|
printf("\n");
|
1994-05-25 09:21:21 +00:00
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-06-27 11:07:30 +00:00
|
|
|
/*
|
2001-04-17 08:56:39 +00:00
|
|
|
* This is the "real" nfs::bwrite(struct buf*).
|
|
|
|
* We set B_CACHE if this is a VMIO buffer.
|
1995-06-27 11:07:30 +00:00
|
|
|
*/
|
|
|
|
int
|
2004-09-15 21:49:22 +00:00
|
|
|
nfs_writebp(struct buf *bp, int force __unused, struct thread *td)
|
1995-06-27 11:07:30 +00:00
|
|
|
{
|
1998-03-08 09:59:44 +00:00
|
|
|
int s;
|
1999-03-12 02:24:58 +00:00
|
|
|
int oldflags = bp->b_flags;
|
1999-09-17 05:57:57 +00:00
|
|
|
#if 0
|
1999-03-12 02:24:58 +00:00
|
|
|
int retv = 1;
|
1995-06-27 11:07:30 +00:00
|
|
|
off_t off;
|
1999-09-17 05:57:57 +00:00
|
|
|
#endif
|
1995-06-27 11:07:30 +00:00
|
|
|
|
2008-02-13 20:44:19 +00:00
|
|
|
BUF_ASSERT_HELD(bp);
|
1995-06-27 11:07:30 +00:00
|
|
|
|
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
|
|
|
if (bp->b_flags & B_INVAL) {
|
|
|
|
brelse(bp);
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
bp->b_flags |= B_CACHE;
|
This mega-commit is meant to fix numerous interrelated problems. There
has been some bitrot and incorrect assumptions in the vfs_bio code. These
problems have manifest themselves worse on NFS type filesystems, but can
still affect local filesystems under certain circumstances. Most of
the problems have involved mmap consistancy, and as a side-effect broke
the vfs.ioopt code. This code might have been committed seperately, but
almost everything is interrelated.
1) Allow (pmap_object_init_pt) prefaulting of buffer-busy pages that
are fully valid.
2) Rather than deactivating erroneously read initial (header) pages in
kern_exec, we now free them.
3) Fix the rundown of non-VMIO buffers that are in an inconsistent
(missing vp) state.
4) Fix the disassociation of pages from buffers in brelse. The previous
code had rotted and was faulty in a couple of important circumstances.
5) Remove a gratuitious buffer wakeup in vfs_vmio_release.
6) Remove a crufty and currently unused cluster mechanism for VBLK
files in vfs_bio_awrite. When the code is functional, I'll add back
a cleaner version.
7) The page busy count wakeups assocated with the buffer cache usage were
incorrectly cleaned up in a previous commit by me. Revert to the
original, correct version, but with a cleaner implementation.
8) The cluster read code now tries to keep data associated with buffers
more aggressively (without breaking the heuristics) when it is presumed
that the read data (buffers) will be soon needed.
9) Change to filesystem lockmgr locks so that they use LK_NOPAUSE. The
delay loop waiting is not useful for filesystem locks, due to the
length of the time intervals.
10) Correct and clean-up spec_getpages.
11) Implement a fully functional nfs_getpages, nfs_putpages.
12) Fix nfs_write so that modifications are coherent with the NFS data on
the server disk (at least as well as NFS seems to allow.)
13) Properly support MS_INVALIDATE on NFS.
14) Properly pass down MS_INVALIDATE to lower levels of the VM code from
vm_map_clean.
15) Better support the notion of pages being busy but valid, so that
fewer in-transit waits occur. (use p->busy more for pageouts instead
of PG_BUSY.) Since the page is fully valid, it is still usable for
reads.
16) It is possible (in error) for cached pages to be busy. Make the
page allocation code handle that case correctly. (It should probably
be a printf or panic, but I want the system to handle coding errors
robustly. I'll probably add a printf.)
17) Correct the design and usage of vm_page_sleep. It didn't handle
consistancy problems very well, so make the design a little less
lofty. After vm_page_sleep, if it ever blocked, it is still important
to relookup the page (if the object generation count changed), and
verify it's status (always.)
18) In vm_pageout.c, vm_pageout_clean had rotted, so clean that up.
19) Push the page busy for writes and VM_PROT_READ into vm_pageout_flush.
20) Fix vm_pager_put_pages and it's descendents to support an int flag
instead of a boolean, so that we can pass down the invalidate bit.
1998-03-07 21:37:31 +00:00
|
|
|
|
1999-03-12 02:24:58 +00:00
|
|
|
/*
|
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
|
|
|
* Undirty the bp. We will redirty it later if the I/O fails.
|
1999-03-12 02:24:58 +00:00
|
|
|
*/
|
1995-06-27 11:07:30 +00:00
|
|
|
|
1999-03-12 02:24:58 +00:00
|
|
|
s = splbio();
|
|
|
|
bundirty(bp);
|
2000-04-02 15:24:56 +00:00
|
|
|
bp->b_flags &= ~B_DONE;
|
|
|
|
bp->b_ioflags &= ~BIO_ERROR;
|
2000-03-20 10:44:49 +00:00
|
|
|
bp->b_iocmd = BIO_WRITE;
|
1995-06-27 11:07:30 +00:00
|
|
|
|
2004-10-22 08:47:20 +00:00
|
|
|
bufobj_wref(bp->b_bufobj);
|
2007-06-01 01:12:45 +00:00
|
|
|
curthread->td_ru.ru_oublock++;
|
1998-03-08 09:59:44 +00:00
|
|
|
splx(s);
|
1995-06-27 11:07:30 +00:00
|
|
|
|
2001-02-28 04:13:11 +00:00
|
|
|
/*
|
|
|
|
* Note: to avoid loopback deadlocks, we do not
|
|
|
|
* assign b_runningbufspace.
|
|
|
|
*/
|
1999-09-17 05:57:57 +00:00
|
|
|
vfs_busy_pages(bp, 1);
|
2001-02-28 04:13:11 +00:00
|
|
|
|
1999-09-17 05:57:57 +00:00
|
|
|
BUF_KERNPROC(bp);
|
2003-10-18 14:10:28 +00:00
|
|
|
bp->b_iooffset = dbtob(bp->b_blkno);
|
2004-10-24 20:03:41 +00:00
|
|
|
bstrategy(bp);
|
1995-06-27 11:07:30 +00:00
|
|
|
|
|
|
|
if( (oldflags & B_ASYNC) == 0) {
|
2000-04-29 16:25:22 +00:00
|
|
|
int rtval = bufwait(bp);
|
1995-06-27 11:07:30 +00:00
|
|
|
|
|
|
|
if (oldflags & B_DELWRI) {
|
1998-03-08 09:59:44 +00:00
|
|
|
s = splbio();
|
2004-07-25 21:24:23 +00:00
|
|
|
reassignbuf(bp);
|
1998-03-08 09:59:44 +00:00
|
|
|
splx(s);
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
|
|
|
brelse(bp);
|
|
|
|
return (rtval);
|
2001-09-18 23:32:09 +00:00
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* nfs special file access vnode op.
|
|
|
|
* Essentially just get vattr and then imitate iaccess() since the device is
|
|
|
|
* local to the client.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfsspec_access(struct vop_access_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vattr *vap;
|
|
|
|
struct ucred *cred = ap->a_cred;
|
1995-10-22 09:32:48 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
2008-10-28 13:44:11 +00:00
|
|
|
accmode_t accmode = ap->a_accmode;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
|
|
|
int error;
|
|
|
|
|
1995-10-22 09:32:48 +00:00
|
|
|
/*
|
|
|
|
* Disallow write attempts on filesystems mounted read-only;
|
|
|
|
* unless the file is a socket, fifo, or a block or character
|
|
|
|
* device resident on the filesystem.
|
|
|
|
*/
|
2008-10-28 13:44:11 +00:00
|
|
|
if ((accmode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
|
1995-10-22 09:32:48 +00:00
|
|
|
switch (vp->v_type) {
|
1998-05-31 17:27:58 +00:00
|
|
|
case VREG:
|
|
|
|
case VDIR:
|
|
|
|
case VLNK:
|
1995-10-22 09:32:48 +00:00
|
|
|
return (EROFS);
|
1998-05-31 17:27:58 +00:00
|
|
|
default:
|
|
|
|
break;
|
1995-10-22 09:32:48 +00:00
|
|
|
}
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
vap = &vattr;
|
2008-08-28 15:23:18 +00:00
|
|
|
error = VOP_GETATTR(vp, vap, cred);
|
1994-10-02 17:27:07 +00:00
|
|
|
if (error)
|
2006-05-19 00:04:24 +00:00
|
|
|
goto out;
|
|
|
|
error = vaccess(vp->v_type, vap->va_mode, vap->va_uid, vap->va_gid,
|
2008-10-28 13:44:11 +00:00
|
|
|
accmode, cred, NULL);
|
2006-05-19 00:04:24 +00:00
|
|
|
out:
|
|
|
|
return error;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read wrapper for fifos.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfsfifo_read(struct vop_read_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct nfsnode *np = VTONFS(ap->a_vp);
|
2006-05-19 00:04:24 +00:00
|
|
|
int error;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set access flag.
|
|
|
|
*/
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
np->n_flag |= NACC;
|
2013-01-18 18:43:38 +00:00
|
|
|
vfs_timestamp(&np->n_atim);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
|
|
|
error = fifo_specops.vop_read(ap);
|
|
|
|
return error;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write wrapper for fifos.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfsfifo_write(struct vop_write_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct nfsnode *np = VTONFS(ap->a_vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set update flag.
|
|
|
|
*/
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
np->n_flag |= NUPD;
|
2013-01-18 18:43:38 +00:00
|
|
|
vfs_timestamp(&np->n_mtim);
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
|
|
|
return(fifo_specops.vop_write(ap));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Close wrapper for fifos.
|
|
|
|
*
|
|
|
|
* Update the times on the nfsnode then do fifo close.
|
|
|
|
*/
|
1995-10-29 15:33:36 +00:00
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfsfifo_close(struct vop_close_args *ap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct vnode *vp = ap->a_vp;
|
|
|
|
struct nfsnode *np = VTONFS(vp);
|
1994-05-24 10:09:53 +00:00
|
|
|
struct vattr vattr;
|
1998-05-16 16:20:50 +00:00
|
|
|
struct timespec ts;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_lock(&np->n_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (np->n_flag & (NACC | NUPD)) {
|
2013-01-18 18:43:38 +00:00
|
|
|
vfs_timestamp(&ts);
|
1998-05-16 16:20:50 +00:00
|
|
|
if (np->n_flag & NACC)
|
|
|
|
np->n_atim = ts;
|
|
|
|
if (np->n_flag & NUPD)
|
|
|
|
np->n_mtim = ts;
|
1994-05-24 10:09:53 +00:00
|
|
|
np->n_flag |= NCHG;
|
2002-09-25 02:38:43 +00:00
|
|
|
if (vrefcnt(vp) == 1 &&
|
1994-05-24 10:09:53 +00:00
|
|
|
(vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
|
|
|
|
VATTR_NULL(&vattr);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (np->n_flag & NACC)
|
|
|
|
vattr.va_atime = np->n_atim;
|
|
|
|
if (np->n_flag & NUPD)
|
|
|
|
vattr.va_mtime = np->n_mtim;
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
2008-08-28 15:23:18 +00:00
|
|
|
(void)VOP_SETATTR(vp, &vattr, ap->a_cred);
|
2006-05-19 00:04:24 +00:00
|
|
|
goto out;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
2006-05-19 00:04:24 +00:00
|
|
|
mtx_unlock(&np->n_mtx);
|
|
|
|
out:
|
2004-12-11 21:36:29 +00:00
|
|
|
return (fifo_specops.vop_close(ap));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-12-14 01:16:57 +00:00
|
|
|
|
2004-10-24 20:03:41 +00:00
|
|
|
/*
|
|
|
|
* Just call nfs_writebp() with the force argument set to 1.
|
|
|
|
*
|
|
|
|
* NOTE: B_DONE may or may not be set in a_bp on call.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
nfs_bwrite(struct buf *bp)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (nfs_writebp(bp, 1, curthread));
|
|
|
|
}
|
|
|
|
|
|
|
|
struct buf_ops buf_ops_nfs = {
|
|
|
|
.bop_name = "buf_ops_nfs",
|
|
|
|
.bop_write = nfs_bwrite,
|
|
|
|
.bop_strategy = bufstrategy,
|
2005-01-11 10:43:08 +00:00
|
|
|
.bop_sync = bufsync,
|
Cylinder group bitmaps and blocks containing inode for a snapshot
file are after snaplock, while other ffs device buffers are before
snaplock in global lock order. By itself, this could cause deadlock
when bdwrite() tries to flush dirty buffers on snapshotted ffs. If,
during the flush, COW activity for snapshot needs to allocate block
and ffs_alloccg() selects the cylinder group that is being written
by bdwrite(), then kernel would panic due to recursive buffer lock
acquision.
Avoid dealing with buffers in bdwrite() that are from other side of
snaplock divisor in the lock order then the buffer being written. Add
new BOP, bop_bdwrite(), to do dirty buffer flushing for same vnode in
the bdwrite(). Default implementation, bufbdflush(), refactors the code
from bdwrite(). For ffs device buffers, specialized implementation is
used.
Reviewed by: tegge, jeff, Russell Cattelan (cattelan xfs org, xfs changes)
Tested by: Peter Holm
X-MFC after: 3 weeks (if ever: it changes ABI)
2007-01-23 10:01:19 +00:00
|
|
|
.bop_bdflush = bufbdflush,
|
2004-10-24 20:03:41 +00:00
|
|
|
};
|