2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Process version 3 NFS requests.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1996, 1997, 1998 Olaf Kirch <okir@monad.swb.de>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/ext2_fs.h>
|
2009-01-11 12:13:53 -07:00
|
|
|
#include <linux/magic.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-12-03 11:30:56 -07:00
|
|
|
#include "cache.h"
|
|
|
|
#include "xdr3.h"
|
2009-11-04 16:12:35 -07:00
|
|
|
#include "vfs.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define NFSDDBG_FACILITY NFSDDBG_PROC
|
|
|
|
|
|
|
|
#define RETURN_STATUS(st) { resp->status = (st); return (st); }
|
|
|
|
|
|
|
|
static int nfs3_ftypes[] = {
|
|
|
|
0, /* NF3NON */
|
|
|
|
S_IFREG, /* NF3REG */
|
|
|
|
S_IFDIR, /* NF3DIR */
|
|
|
|
S_IFBLK, /* NF3BLK */
|
|
|
|
S_IFCHR, /* NF3CHR */
|
|
|
|
S_IFLNK, /* NF3LNK */
|
|
|
|
S_IFSOCK, /* NF3SOCK */
|
|
|
|
S_IFIFO, /* NF3FIFO */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NULL call.
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
|
|
|
|
{
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get a file's attributes
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle *argp,
|
|
|
|
struct nfsd3_attrstat *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: GETATTR(3) %s\n",
|
2006-01-06 01:19:58 -07:00
|
|
|
SVCFH_fmt(&argp->fh));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
fh_copy(&resp->fh, &argp->fh);
|
2008-08-07 11:00:20 -06:00
|
|
|
nfserr = fh_verify(rqstp, &resp->fh, 0,
|
|
|
|
NFSD_MAY_NOP | NFSD_MAY_BYPASS_GSS_ON_ROOT);
|
2006-01-06 01:19:58 -07:00
|
|
|
if (nfserr)
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
|
2013-01-24 00:18:08 -07:00
|
|
|
nfserr = fh_getattr(&resp->fh, &resp->stat);
|
2006-01-06 01:19:58 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set a file's attributes
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_setattr(struct svc_rqst *rqstp, struct nfsd3_sattrargs *argp,
|
|
|
|
struct nfsd3_attrstat *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: SETATTR(3) %s\n",
|
|
|
|
SVCFH_fmt(&argp->fh));
|
|
|
|
|
|
|
|
fh_copy(&resp->fh, &argp->fh);
|
|
|
|
nfserr = nfsd_setattr(rqstp, &resp->fh, &argp->attrs,
|
|
|
|
argp->check_guard, argp->guardtime);
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Look up a path name component
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_lookup(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
|
|
|
|
struct nfsd3_diropres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: LOOKUP(3) %s %.*s\n",
|
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
argp->len,
|
|
|
|
argp->name);
|
|
|
|
|
|
|
|
fh_copy(&resp->dirfh, &argp->fh);
|
|
|
|
fh_init(&resp->fh, NFS3_FHSIZE);
|
|
|
|
|
|
|
|
nfserr = nfsd_lookup(rqstp, &resp->dirfh,
|
|
|
|
argp->name,
|
|
|
|
argp->len,
|
|
|
|
&resp->fh);
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check file access
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_access(struct svc_rqst *rqstp, struct nfsd3_accessargs *argp,
|
|
|
|
struct nfsd3_accessres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: ACCESS(3) %s 0x%x\n",
|
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
argp->access);
|
|
|
|
|
|
|
|
fh_copy(&resp->fh, &argp->fh);
|
|
|
|
resp->access = argp->access;
|
|
|
|
nfserr = nfsd_access(rqstp, &resp->fh, &resp->access, NULL);
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read a symlink.
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_readlink(struct svc_rqst *rqstp, struct nfsd3_readlinkargs *argp,
|
|
|
|
struct nfsd3_readlinkres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: READLINK(3) %s\n", SVCFH_fmt(&argp->fh));
|
|
|
|
|
|
|
|
/* Read the symlink. */
|
|
|
|
fh_copy(&resp->fh, &argp->fh);
|
|
|
|
resp->len = NFS3_MAXPATHLEN;
|
|
|
|
nfserr = nfsd_readlink(rqstp, &resp->fh, argp->buffer, &resp->len);
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read a portion of a file.
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_read(struct svc_rqst *rqstp, struct nfsd3_readargs *argp,
|
|
|
|
struct nfsd3_readres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2006-10-04 03:15:47 -06:00
|
|
|
u32 max_blocksize = svc_max_payload(rqstp);
|
2016-03-22 08:28:36 -06:00
|
|
|
unsigned long cnt = min(argp->count, max_blocksize);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-11-29 13:28:10 -07:00
|
|
|
dprintk("nfsd: READ(3) %s %lu bytes at %Lu\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
(unsigned long) argp->count,
|
2010-11-29 13:28:10 -07:00
|
|
|
(unsigned long long) argp->offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Obtain buffer pointer for payload.
|
|
|
|
* 1 (status) + 22 (post_op_attr) + 1 (count) + 1 (eof)
|
|
|
|
* + 1 (xdr opaque byte count) = 26
|
|
|
|
*/
|
2016-03-22 08:28:36 -06:00
|
|
|
resp->count = cnt;
|
2007-05-09 03:34:50 -06:00
|
|
|
svc_reserve_auth(rqstp, ((1 + NFS3_POST_OP_ATTR_WORDS + 3)<<2) + resp->count +4);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
fh_copy(&resp->fh, &argp->fh);
|
2010-07-30 09:33:32 -06:00
|
|
|
nfserr = nfsd_read(rqstp, &resp->fh,
|
2005-04-16 16:20:36 -06:00
|
|
|
argp->offset,
|
2006-10-04 03:15:47 -06:00
|
|
|
rqstp->rq_vec, argp->vlen,
|
2005-04-16 16:20:36 -06:00
|
|
|
&resp->count);
|
|
|
|
if (nfserr == 0) {
|
2015-03-17 16:25:59 -06:00
|
|
|
struct inode *inode = d_inode(resp->fh.fh_dentry);
|
2016-03-22 08:28:36 -06:00
|
|
|
resp->eof = nfsd_eof_on_read(cnt, resp->count, argp->offset,
|
|
|
|
inode->i_size);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write data to a file
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_write(struct svc_rqst *rqstp, struct nfsd3_writeargs *argp,
|
|
|
|
struct nfsd3_writeres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2009-03-05 18:16:14 -07:00
|
|
|
unsigned long cnt = argp->len;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-11-29 13:28:10 -07:00
|
|
|
dprintk("nfsd: WRITE(3) %s %d bytes at %Lu%s\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
argp->len,
|
2010-11-29 13:28:10 -07:00
|
|
|
(unsigned long long) argp->offset,
|
2005-04-16 16:20:36 -06:00
|
|
|
argp->stable? " stable" : "");
|
|
|
|
|
|
|
|
fh_copy(&resp->fh, &argp->fh);
|
|
|
|
resp->committed = argp->stable;
|
2016-12-31 06:00:13 -07:00
|
|
|
nfserr = nfsd_write(rqstp, &resp->fh, argp->offset,
|
|
|
|
rqstp->rq_vec, argp->vlen,
|
|
|
|
&cnt, resp->committed);
|
2009-03-05 18:16:14 -07:00
|
|
|
resp->count = cnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* With NFSv3, CREATE processing is a lot easier than with NFSv2.
|
|
|
|
* At least in theory; we'll see how it fares in practice when the
|
|
|
|
* first reports about SunOS compatibility problems start to pour in...
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_create(struct svc_rqst *rqstp, struct nfsd3_createargs *argp,
|
|
|
|
struct nfsd3_diropres *resp)
|
|
|
|
{
|
|
|
|
svc_fh *dirfhp, *newfhp = NULL;
|
|
|
|
struct iattr *attr;
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: CREATE(3) %s %.*s\n",
|
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
argp->len,
|
|
|
|
argp->name);
|
|
|
|
|
|
|
|
dirfhp = fh_copy(&resp->dirfh, &argp->fh);
|
|
|
|
newfhp = fh_init(&resp->fh, NFS3_FHSIZE);
|
|
|
|
attr = &argp->attrs;
|
|
|
|
|
|
|
|
/* Unfudge the mode bits */
|
|
|
|
attr->ia_mode &= ~S_IFMT;
|
|
|
|
if (!(attr->ia_valid & ATTR_MODE)) {
|
|
|
|
attr->ia_valid |= ATTR_MODE;
|
|
|
|
attr->ia_mode = S_IFREG;
|
|
|
|
} else {
|
|
|
|
attr->ia_mode = (attr->ia_mode & ~S_IFMT) | S_IFREG;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now create the file and set attributes */
|
2011-04-20 03:06:25 -06:00
|
|
|
nfserr = do_nfsd_create(rqstp, dirfhp, argp->name, argp->len,
|
2005-04-16 16:20:36 -06:00
|
|
|
attr, newfhp,
|
2012-07-27 13:50:11 -06:00
|
|
|
argp->createmode, (u32 *)argp->verf, NULL, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make directory. This operation is not idempotent.
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_mkdir(struct svc_rqst *rqstp, struct nfsd3_createargs *argp,
|
|
|
|
struct nfsd3_diropres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: MKDIR(3) %s %.*s\n",
|
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
argp->len,
|
|
|
|
argp->name);
|
|
|
|
|
|
|
|
argp->attrs.ia_valid &= ~ATTR_SIZE;
|
|
|
|
fh_copy(&resp->dirfh, &argp->fh);
|
|
|
|
fh_init(&resp->fh, NFS3_FHSIZE);
|
|
|
|
nfserr = nfsd_create(rqstp, &resp->dirfh, argp->name, argp->len,
|
|
|
|
&argp->attrs, S_IFDIR, 0, &resp->fh);
|
NFSD: Fill in WCC data for REMOVE, RMDIR, MKNOD, and MKDIR
Some well-known NFSv3 clients drop their directory entry caches when
they receive replies with no WCC data. Without this data, they
employ extra READ, LOOKUP, and GETATTR requests to ensure their
directory entry caches are up to date, causing performance to suffer
needlessly.
In order to return WCC data, our server has to have both the pre-op
and the post-op attribute data on hand when a reply is XDR encoded.
The pre-op data is filled in when the incoming fh is locked, and the
post-op data is filled in when the fh is unlocked.
Unfortunately, for REMOVE, RMDIR, MKNOD, and MKDIR, the directory fh
is not unlocked until well after the reply has been XDR encoded. This
means that encode_wcc_data() does not have wcc_data for the parent
directory, so none is returned to the client after these operations
complete.
By unlocking the parent directory fh immediately after the internal
operations for each NFS procedure is complete, the post-op data is
filled in before XDR encoding starts, so it can be returned to the
client properly.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
2010-07-06 14:53:34 -06:00
|
|
|
fh_unlock(&resp->dirfh);
|
2005-04-16 16:20:36 -06:00
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_symlink(struct svc_rqst *rqstp, struct nfsd3_symlinkargs *argp,
|
|
|
|
struct nfsd3_diropres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: SYMLINK(3) %s %.*s -> %.*s\n",
|
|
|
|
SVCFH_fmt(&argp->ffh),
|
|
|
|
argp->flen, argp->fname,
|
|
|
|
argp->tlen, argp->tname);
|
|
|
|
|
|
|
|
fh_copy(&resp->dirfh, &argp->ffh);
|
|
|
|
fh_init(&resp->fh, NFS3_FHSIZE);
|
|
|
|
nfserr = nfsd_symlink(rqstp, &resp->dirfh, argp->fname, argp->flen,
|
2014-07-01 03:48:02 -06:00
|
|
|
argp->tname, &resp->fh);
|
2005-04-16 16:20:36 -06:00
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make socket/fifo/device.
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_mknod(struct svc_rqst *rqstp, struct nfsd3_mknodargs *argp,
|
|
|
|
struct nfsd3_diropres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
|
|
|
int type;
|
2005-04-16 16:20:36 -06:00
|
|
|
dev_t rdev = 0;
|
|
|
|
|
|
|
|
dprintk("nfsd: MKNOD(3) %s %.*s\n",
|
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
argp->len,
|
|
|
|
argp->name);
|
|
|
|
|
|
|
|
fh_copy(&resp->dirfh, &argp->fh);
|
|
|
|
fh_init(&resp->fh, NFS3_FHSIZE);
|
|
|
|
|
|
|
|
if (argp->ftype == 0 || argp->ftype >= NF3BAD)
|
|
|
|
RETURN_STATUS(nfserr_inval);
|
|
|
|
if (argp->ftype == NF3CHR || argp->ftype == NF3BLK) {
|
|
|
|
rdev = MKDEV(argp->major, argp->minor);
|
|
|
|
if (MAJOR(rdev) != argp->major ||
|
|
|
|
MINOR(rdev) != argp->minor)
|
|
|
|
RETURN_STATUS(nfserr_inval);
|
|
|
|
} else
|
|
|
|
if (argp->ftype != NF3SOCK && argp->ftype != NF3FIFO)
|
|
|
|
RETURN_STATUS(nfserr_inval);
|
|
|
|
|
|
|
|
type = nfs3_ftypes[argp->ftype];
|
|
|
|
nfserr = nfsd_create(rqstp, &resp->dirfh, argp->name, argp->len,
|
|
|
|
&argp->attrs, type, rdev, &resp->fh);
|
NFSD: Fill in WCC data for REMOVE, RMDIR, MKNOD, and MKDIR
Some well-known NFSv3 clients drop their directory entry caches when
they receive replies with no WCC data. Without this data, they
employ extra READ, LOOKUP, and GETATTR requests to ensure their
directory entry caches are up to date, causing performance to suffer
needlessly.
In order to return WCC data, our server has to have both the pre-op
and the post-op attribute data on hand when a reply is XDR encoded.
The pre-op data is filled in when the incoming fh is locked, and the
post-op data is filled in when the fh is unlocked.
Unfortunately, for REMOVE, RMDIR, MKNOD, and MKDIR, the directory fh
is not unlocked until well after the reply has been XDR encoded. This
means that encode_wcc_data() does not have wcc_data for the parent
directory, so none is returned to the client after these operations
complete.
By unlocking the parent directory fh immediately after the internal
operations for each NFS procedure is complete, the post-op data is
filled in before XDR encoding starts, so it can be returned to the
client properly.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
2010-07-06 14:53:34 -06:00
|
|
|
fh_unlock(&resp->dirfh);
|
2005-04-16 16:20:36 -06:00
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove file/fifo/socket etc.
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_remove(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
|
|
|
|
struct nfsd3_attrstat *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: REMOVE(3) %s %.*s\n",
|
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
argp->len,
|
|
|
|
argp->name);
|
|
|
|
|
|
|
|
/* Unlink. -S_IFDIR means file must not be a directory */
|
|
|
|
fh_copy(&resp->fh, &argp->fh);
|
|
|
|
nfserr = nfsd_unlink(rqstp, &resp->fh, -S_IFDIR, argp->name, argp->len);
|
NFSD: Fill in WCC data for REMOVE, RMDIR, MKNOD, and MKDIR
Some well-known NFSv3 clients drop their directory entry caches when
they receive replies with no WCC data. Without this data, they
employ extra READ, LOOKUP, and GETATTR requests to ensure their
directory entry caches are up to date, causing performance to suffer
needlessly.
In order to return WCC data, our server has to have both the pre-op
and the post-op attribute data on hand when a reply is XDR encoded.
The pre-op data is filled in when the incoming fh is locked, and the
post-op data is filled in when the fh is unlocked.
Unfortunately, for REMOVE, RMDIR, MKNOD, and MKDIR, the directory fh
is not unlocked until well after the reply has been XDR encoded. This
means that encode_wcc_data() does not have wcc_data for the parent
directory, so none is returned to the client after these operations
complete.
By unlocking the parent directory fh immediately after the internal
operations for each NFS procedure is complete, the post-op data is
filled in before XDR encoding starts, so it can be returned to the
client properly.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
2010-07-06 14:53:34 -06:00
|
|
|
fh_unlock(&resp->fh);
|
2005-04-16 16:20:36 -06:00
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove a directory
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_rmdir(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
|
|
|
|
struct nfsd3_attrstat *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: RMDIR(3) %s %.*s\n",
|
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
argp->len,
|
|
|
|
argp->name);
|
|
|
|
|
|
|
|
fh_copy(&resp->fh, &argp->fh);
|
|
|
|
nfserr = nfsd_unlink(rqstp, &resp->fh, S_IFDIR, argp->name, argp->len);
|
NFSD: Fill in WCC data for REMOVE, RMDIR, MKNOD, and MKDIR
Some well-known NFSv3 clients drop their directory entry caches when
they receive replies with no WCC data. Without this data, they
employ extra READ, LOOKUP, and GETATTR requests to ensure their
directory entry caches are up to date, causing performance to suffer
needlessly.
In order to return WCC data, our server has to have both the pre-op
and the post-op attribute data on hand when a reply is XDR encoded.
The pre-op data is filled in when the incoming fh is locked, and the
post-op data is filled in when the fh is unlocked.
Unfortunately, for REMOVE, RMDIR, MKNOD, and MKDIR, the directory fh
is not unlocked until well after the reply has been XDR encoded. This
means that encode_wcc_data() does not have wcc_data for the parent
directory, so none is returned to the client after these operations
complete.
By unlocking the parent directory fh immediately after the internal
operations for each NFS procedure is complete, the post-op data is
filled in before XDR encoding starts, so it can be returned to the
client properly.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
2010-07-06 14:53:34 -06:00
|
|
|
fh_unlock(&resp->fh);
|
2005-04-16 16:20:36 -06:00
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_rename(struct svc_rqst *rqstp, struct nfsd3_renameargs *argp,
|
|
|
|
struct nfsd3_renameres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: RENAME(3) %s %.*s ->\n",
|
|
|
|
SVCFH_fmt(&argp->ffh),
|
|
|
|
argp->flen,
|
|
|
|
argp->fname);
|
|
|
|
dprintk("nfsd: -> %s %.*s\n",
|
|
|
|
SVCFH_fmt(&argp->tfh),
|
|
|
|
argp->tlen,
|
|
|
|
argp->tname);
|
|
|
|
|
|
|
|
fh_copy(&resp->ffh, &argp->ffh);
|
|
|
|
fh_copy(&resp->tfh, &argp->tfh);
|
|
|
|
nfserr = nfsd_rename(rqstp, &resp->ffh, argp->fname, argp->flen,
|
|
|
|
&resp->tfh, argp->tname, argp->tlen);
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_link(struct svc_rqst *rqstp, struct nfsd3_linkargs *argp,
|
|
|
|
struct nfsd3_linkres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: LINK(3) %s ->\n",
|
|
|
|
SVCFH_fmt(&argp->ffh));
|
|
|
|
dprintk("nfsd: -> %s %.*s\n",
|
|
|
|
SVCFH_fmt(&argp->tfh),
|
|
|
|
argp->tlen,
|
|
|
|
argp->tname);
|
|
|
|
|
|
|
|
fh_copy(&resp->fh, &argp->ffh);
|
|
|
|
fh_copy(&resp->tfh, &argp->tfh);
|
|
|
|
nfserr = nfsd_link(rqstp, &resp->tfh, argp->tname, argp->tlen,
|
|
|
|
&resp->fh);
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read a portion of a directory.
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_readdir(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
|
|
|
|
struct nfsd3_readdirres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
|
|
|
int count;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: READDIR(3) %s %d bytes at %d\n",
|
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
argp->count, (u32) argp->cookie);
|
|
|
|
|
|
|
|
/* Make sure we've room for the NULL ptr & eof flag, and shrink to
|
|
|
|
* client read size */
|
|
|
|
count = (argp->count >> 2) - 2;
|
|
|
|
|
|
|
|
/* Read directory and encode entries on the fly */
|
|
|
|
fh_copy(&resp->fh, &argp->fh);
|
|
|
|
|
|
|
|
resp->buflen = count;
|
|
|
|
resp->common.err = nfs_ok;
|
|
|
|
resp->buffer = argp->buffer;
|
|
|
|
resp->rqstp = rqstp;
|
|
|
|
nfserr = nfsd_readdir(rqstp, &resp->fh, (loff_t*) &argp->cookie,
|
|
|
|
&resp->common, nfs3svc_encode_entry);
|
|
|
|
memcpy(resp->verf, argp->verf, 8);
|
|
|
|
resp->count = resp->buffer - argp->buffer;
|
|
|
|
if (resp->offset)
|
|
|
|
xdr_encode_hyper(resp->offset, argp->cookie);
|
|
|
|
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read a portion of a directory, including file handles and attrs.
|
|
|
|
* For now, we choose to ignore the dircount parameter.
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_readdirplus(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
|
|
|
|
struct nfsd3_readdirres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
|
|
|
int count = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
loff_t offset;
|
2012-12-10 16:01:37 -07:00
|
|
|
struct page **p;
|
2005-04-16 16:20:36 -06:00
|
|
|
caddr_t page_addr = NULL;
|
|
|
|
|
|
|
|
dprintk("nfsd: READDIR+(3) %s %d bytes at %d\n",
|
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
argp->count, (u32) argp->cookie);
|
|
|
|
|
|
|
|
/* Convert byte count to number of words (i.e. >> 2),
|
|
|
|
* and reserve room for the NULL ptr & eof flag (-2 words) */
|
|
|
|
resp->count = (argp->count >> 2) - 2;
|
|
|
|
|
|
|
|
/* Read directory and encode entries on the fly */
|
|
|
|
fh_copy(&resp->fh, &argp->fh);
|
|
|
|
|
|
|
|
resp->common.err = nfs_ok;
|
|
|
|
resp->buffer = argp->buffer;
|
|
|
|
resp->buflen = resp->count;
|
|
|
|
resp->rqstp = rqstp;
|
|
|
|
offset = argp->cookie;
|
nfsd: allow turning off nfsv3 readdir_plus
One of our customer's application only needs file names, not file
attributes. With directories having 10K+ inodes (assuming buffer cache
has directory blocks cached having file names, but inode cache is
limited and hence need eviction of older cached inodes), older inodes
are evicted periodically. So if they keep on doing readdir(2) from NSF
client on multiple directories, some directory's files are periodically
removed from inode cache and hence new readdir(2) on same directory
requires disk access to bring back inodes again to inode cache.
As READDIRPLUS request fetches attributes also, doing getattr on each
file on server, it causes unnecessary disk accesses. If READDIRPLUS on
NFS client is returned with -ENOTSUPP, NFS client uses READDIR request
which just gets the names of the files in a directory, not attributes,
hence avoiding disk accesses on server.
There's already a corresponding client-side mount option, but an export
option reduces the need for configuration across multiple clients.
This flag affects NFSv3 only. If it turns out it's needed for NFSv4 as
well then we may have to figure out how to extend the behavior to NFSv4,
but it's not currently obvious how to do that.
Signed-off-by: Rajesh Ghanekar <rajesh_ghanekar@symantec.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-08-01 20:17:30 -06:00
|
|
|
|
|
|
|
nfserr = fh_verify(rqstp, &resp->fh, S_IFDIR, NFSD_MAY_NOP);
|
|
|
|
if (nfserr)
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
|
|
|
|
if (resp->fh.fh_export->ex_flags & NFSEXP_NOREADDIRPLUS)
|
|
|
|
RETURN_STATUS(nfserr_notsupp);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
nfserr = nfsd_readdir(rqstp, &resp->fh,
|
|
|
|
&offset,
|
|
|
|
&resp->common,
|
|
|
|
nfs3svc_encode_entry_plus);
|
|
|
|
memcpy(resp->verf, argp->verf, 8);
|
2012-12-10 16:01:37 -07:00
|
|
|
for (p = rqstp->rq_respages + 1; p < rqstp->rq_next_page; p++) {
|
|
|
|
page_addr = page_address(*p);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (((caddr_t)resp->buffer >= page_addr) &&
|
|
|
|
((caddr_t)resp->buffer < page_addr + PAGE_SIZE)) {
|
|
|
|
count += (caddr_t)resp->buffer - page_addr;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
count += PAGE_SIZE;
|
|
|
|
}
|
|
|
|
resp->count = count >> 2;
|
|
|
|
if (resp->offset) {
|
|
|
|
if (unlikely(resp->offset1)) {
|
|
|
|
/* we ended up with offset on a page boundary */
|
|
|
|
*resp->offset = htonl(offset >> 32);
|
|
|
|
*resp->offset1 = htonl(offset & 0xffffffff);
|
|
|
|
resp->offset1 = NULL;
|
|
|
|
} else {
|
|
|
|
xdr_encode_hyper(resp->offset, offset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get file system stats
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_fsstat(struct svc_rqst * rqstp, struct nfsd_fhandle *argp,
|
|
|
|
struct nfsd3_fsstatres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: FSSTAT(3) %s\n",
|
|
|
|
SVCFH_fmt(&argp->fh));
|
|
|
|
|
2008-08-07 11:00:20 -06:00
|
|
|
nfserr = nfsd_statfs(rqstp, &argp->fh, &resp->stats, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
fh_put(&argp->fh);
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get file system info
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_fsinfo(struct svc_rqst * rqstp, struct nfsd_fhandle *argp,
|
|
|
|
struct nfsd3_fsinfores *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2006-10-04 03:15:47 -06:00
|
|
|
u32 max_blocksize = svc_max_payload(rqstp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: FSINFO(3) %s\n",
|
|
|
|
SVCFH_fmt(&argp->fh));
|
|
|
|
|
2006-10-04 03:15:47 -06:00
|
|
|
resp->f_rtmax = max_blocksize;
|
|
|
|
resp->f_rtpref = max_blocksize;
|
2005-04-16 16:20:36 -06:00
|
|
|
resp->f_rtmult = PAGE_SIZE;
|
2006-10-04 03:15:47 -06:00
|
|
|
resp->f_wtmax = max_blocksize;
|
|
|
|
resp->f_wtpref = max_blocksize;
|
2005-04-16 16:20:36 -06:00
|
|
|
resp->f_wtmult = PAGE_SIZE;
|
|
|
|
resp->f_dtpref = PAGE_SIZE;
|
|
|
|
resp->f_maxfilesize = ~(u32) 0;
|
|
|
|
resp->f_properties = NFS3_FSF_DEFAULT;
|
|
|
|
|
2008-08-07 11:00:20 -06:00
|
|
|
nfserr = fh_verify(rqstp, &argp->fh, 0,
|
|
|
|
NFSD_MAY_NOP | NFSD_MAY_BYPASS_GSS_ON_ROOT);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Check special features of the file system. May request
|
|
|
|
* different read/write sizes for file systems known to have
|
|
|
|
* problems with large blocks */
|
|
|
|
if (nfserr == 0) {
|
2016-04-09 23:33:30 -06:00
|
|
|
struct super_block *sb = argp->fh.fh_dentry->d_sb;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Note that we don't care for remote fs's here */
|
2009-01-11 12:13:53 -07:00
|
|
|
if (sb->s_magic == MSDOS_SUPER_MAGIC) {
|
2005-04-16 16:20:36 -06:00
|
|
|
resp->f_properties = NFS3_FSF_BILLYBOY;
|
|
|
|
}
|
|
|
|
resp->f_maxfilesize = sb->s_maxbytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
fh_put(&argp->fh);
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get pathconf info for the specified file
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_pathconf(struct svc_rqst * rqstp, struct nfsd_fhandle *argp,
|
|
|
|
struct nfsd3_pathconfres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: PATHCONF(3) %s\n",
|
|
|
|
SVCFH_fmt(&argp->fh));
|
|
|
|
|
|
|
|
/* Set default pathconf */
|
|
|
|
resp->p_link_max = 255; /* at least */
|
|
|
|
resp->p_name_max = 255; /* at least */
|
|
|
|
resp->p_no_trunc = 0;
|
|
|
|
resp->p_chown_restricted = 1;
|
|
|
|
resp->p_case_insensitive = 0;
|
|
|
|
resp->p_case_preserving = 1;
|
|
|
|
|
2008-06-16 05:20:29 -06:00
|
|
|
nfserr = fh_verify(rqstp, &argp->fh, 0, NFSD_MAY_NOP);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (nfserr == 0) {
|
2016-04-09 23:33:30 -06:00
|
|
|
struct super_block *sb = argp->fh.fh_dentry->d_sb;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Note that we don't care for remote fs's here */
|
|
|
|
switch (sb->s_magic) {
|
|
|
|
case EXT2_SUPER_MAGIC:
|
|
|
|
resp->p_link_max = EXT2_LINK_MAX;
|
|
|
|
resp->p_name_max = EXT2_NAME_LEN;
|
|
|
|
break;
|
2009-01-11 12:13:53 -07:00
|
|
|
case MSDOS_SUPER_MAGIC:
|
2005-04-16 16:20:36 -06:00
|
|
|
resp->p_case_insensitive = 1;
|
|
|
|
resp->p_case_preserving = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fh_put(&argp->fh);
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Commit a file (range) to stable storage.
|
|
|
|
*/
|
2006-10-20 00:28:45 -06:00
|
|
|
static __be32
|
2005-04-16 16:20:36 -06:00
|
|
|
nfsd3_proc_commit(struct svc_rqst * rqstp, struct nfsd3_commitargs *argp,
|
|
|
|
struct nfsd3_commitres *resp)
|
|
|
|
{
|
2006-10-20 00:29:00 -06:00
|
|
|
__be32 nfserr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dprintk("nfsd: COMMIT(3) %s %u@%Lu\n",
|
|
|
|
SVCFH_fmt(&argp->fh),
|
|
|
|
argp->count,
|
|
|
|
(unsigned long long) argp->offset);
|
|
|
|
|
|
|
|
if (argp->offset > NFS_OFFSET_MAX)
|
|
|
|
RETURN_STATUS(nfserr_inval);
|
|
|
|
|
|
|
|
fh_copy(&resp->fh, &argp->fh);
|
|
|
|
nfserr = nfsd_commit(rqstp, &resp->fh, argp->offset, argp->count);
|
|
|
|
|
|
|
|
RETURN_STATUS(nfserr);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NFSv3 Server procedures.
|
|
|
|
* Only the results of non-idempotent operations are cached.
|
|
|
|
*/
|
|
|
|
#define nfs3svc_decode_fhandleargs nfs3svc_decode_fhandle
|
|
|
|
#define nfs3svc_encode_attrstatres nfs3svc_encode_attrstat
|
|
|
|
#define nfs3svc_encode_wccstatres nfs3svc_encode_wccstat
|
|
|
|
#define nfsd3_mkdirargs nfsd3_createargs
|
|
|
|
#define nfsd3_readdirplusargs nfsd3_readdirargs
|
|
|
|
#define nfsd3_fhandleargs nfsd_fhandle
|
|
|
|
#define nfsd3_fhandleres nfsd3_attrstat
|
|
|
|
#define nfsd3_attrstatres nfsd3_attrstat
|
|
|
|
#define nfsd3_wccstatres nfsd3_attrstat
|
|
|
|
#define nfsd3_createres nfsd3_diropres
|
|
|
|
#define nfsd3_voidres nfsd3_voidargs
|
|
|
|
struct nfsd3_voidargs { int dummy; };
|
|
|
|
|
|
|
|
#define PROC(name, argt, rest, relt, cache, respsize) \
|
|
|
|
{ (svc_procfunc) nfsd3_proc_##name, \
|
|
|
|
(kxdrproc_t) nfs3svc_decode_##argt##args, \
|
|
|
|
(kxdrproc_t) nfs3svc_encode_##rest##res, \
|
|
|
|
(kxdrproc_t) nfs3svc_release_##relt, \
|
|
|
|
sizeof(struct nfsd3_##argt##args), \
|
|
|
|
sizeof(struct nfsd3_##rest##res), \
|
|
|
|
0, \
|
|
|
|
cache, \
|
|
|
|
respsize, \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ST 1 /* status*/
|
|
|
|
#define FH 17 /* filehandle with length */
|
|
|
|
#define AT 21 /* attributes */
|
|
|
|
#define pAT (1+AT) /* post attributes - conditional */
|
|
|
|
#define WC (7+pAT) /* WCC attributes */
|
|
|
|
|
|
|
|
static struct svc_procedure nfsd_procedures3[22] = {
|
2009-06-09 03:33:34 -06:00
|
|
|
[NFS3PROC_NULL] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_null,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_voidres,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_voidargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_voidres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = ST,
|
|
|
|
},
|
|
|
|
[NFS3PROC_GETATTR] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_getattr,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_attrstatres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_fhandleargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_attrstatres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = ST+AT,
|
|
|
|
},
|
|
|
|
[NFS3PROC_SETATTR] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_setattr,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_sattrargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_wccstatres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_sattrargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_wccstatres),
|
|
|
|
.pc_cachetype = RC_REPLBUFF,
|
|
|
|
.pc_xdrressize = ST+WC,
|
|
|
|
},
|
|
|
|
[NFS3PROC_LOOKUP] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_lookup,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_diropargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_diropres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_diropargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_diropres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = ST+FH+pAT+pAT,
|
|
|
|
},
|
|
|
|
[NFS3PROC_ACCESS] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_access,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_accessargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_accessres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_accessargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_accessres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = ST+pAT+1,
|
|
|
|
},
|
|
|
|
[NFS3PROC_READLINK] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_readlink,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_readlinkargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_readlinkres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_readlinkargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_readlinkres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = ST+pAT+1+NFS3_MAXPATHLEN/4,
|
|
|
|
},
|
|
|
|
[NFS3PROC_READ] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_read,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_readargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_readres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_readargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_readres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = ST+pAT+4+NFSSVC_MAXBLKSIZE/4,
|
|
|
|
},
|
|
|
|
[NFS3PROC_WRITE] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_write,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_writeargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_writeres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_writeargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_writeres),
|
|
|
|
.pc_cachetype = RC_REPLBUFF,
|
|
|
|
.pc_xdrressize = ST+WC+4,
|
|
|
|
},
|
|
|
|
[NFS3PROC_CREATE] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_create,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_createargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_createargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_createres),
|
|
|
|
.pc_cachetype = RC_REPLBUFF,
|
|
|
|
.pc_xdrressize = ST+(1+FH+pAT)+WC,
|
|
|
|
},
|
|
|
|
[NFS3PROC_MKDIR] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_mkdir,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_mkdirargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_mkdirargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_createres),
|
|
|
|
.pc_cachetype = RC_REPLBUFF,
|
|
|
|
.pc_xdrressize = ST+(1+FH+pAT)+WC,
|
|
|
|
},
|
|
|
|
[NFS3PROC_SYMLINK] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_symlink,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_symlinkargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_symlinkargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_createres),
|
|
|
|
.pc_cachetype = RC_REPLBUFF,
|
|
|
|
.pc_xdrressize = ST+(1+FH+pAT)+WC,
|
|
|
|
},
|
|
|
|
[NFS3PROC_MKNOD] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_mknod,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_mknodargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_mknodargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_createres),
|
|
|
|
.pc_cachetype = RC_REPLBUFF,
|
|
|
|
.pc_xdrressize = ST+(1+FH+pAT)+WC,
|
|
|
|
},
|
|
|
|
[NFS3PROC_REMOVE] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_remove,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_diropargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_wccstatres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_diropargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_wccstatres),
|
|
|
|
.pc_cachetype = RC_REPLBUFF,
|
|
|
|
.pc_xdrressize = ST+WC,
|
|
|
|
},
|
|
|
|
[NFS3PROC_RMDIR] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_rmdir,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_diropargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_wccstatres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_diropargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_wccstatres),
|
|
|
|
.pc_cachetype = RC_REPLBUFF,
|
|
|
|
.pc_xdrressize = ST+WC,
|
|
|
|
},
|
|
|
|
[NFS3PROC_RENAME] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_rename,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_renameargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_renameres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_renameargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_renameres),
|
|
|
|
.pc_cachetype = RC_REPLBUFF,
|
|
|
|
.pc_xdrressize = ST+WC+WC,
|
|
|
|
},
|
|
|
|
[NFS3PROC_LINK] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_link,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_linkargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_linkres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_linkargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_linkres),
|
|
|
|
.pc_cachetype = RC_REPLBUFF,
|
|
|
|
.pc_xdrressize = ST+pAT+WC,
|
|
|
|
},
|
|
|
|
[NFS3PROC_READDIR] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_readdir,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_readdirargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_readdirres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_readdirargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_readdirres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
},
|
|
|
|
[NFS3PROC_READDIRPLUS] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_readdirplus,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_readdirplusargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_readdirres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_readdirplusargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_readdirres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
},
|
|
|
|
[NFS3PROC_FSSTAT] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_fsstat,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_fsstatres,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_fhandleargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_fsstatres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = ST+pAT+2*6+1,
|
|
|
|
},
|
|
|
|
[NFS3PROC_FSINFO] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_fsinfo,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_fsinfores,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_fhandleargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_fsinfores),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = ST+pAT+12,
|
|
|
|
},
|
|
|
|
[NFS3PROC_PATHCONF] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_pathconf,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_pathconfres,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_fhandleargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_pathconfres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = ST+pAT+6,
|
|
|
|
},
|
|
|
|
[NFS3PROC_COMMIT] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd3_proc_commit,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs3svc_decode_commitargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs3svc_encode_commitres,
|
|
|
|
.pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
|
|
|
|
.pc_argsize = sizeof(struct nfsd3_commitargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd3_commitres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = ST+WC+2,
|
|
|
|
},
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct svc_version nfsd_version3 = {
|
|
|
|
.vs_vers = 3,
|
|
|
|
.vs_nproc = 22,
|
|
|
|
.vs_proc = nfsd_procedures3,
|
|
|
|
.vs_dispatch = nfsd_dispatch,
|
|
|
|
.vs_xdrsize = NFS3_SVC_XDRSIZE,
|
|
|
|
};
|