2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Server-side procedures for NFSv4.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2002 The Regents of the University of Michigan.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Kendrick Smith <kmsmith@umich.edu>
|
|
|
|
* Andy Adamson <andros@umich.edu>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
* 3. 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 ``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.
|
|
|
|
*/
|
2005-06-24 05:03:13 +00:00
|
|
|
#include <linux/file.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
#include "idmap.h"
|
2009-12-03 18:30:56 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "xdr4.h"
|
2009-11-04 23:12:35 +00:00
|
|
|
#include "vfs.h"
|
2012-02-13 21:55:24 +00:00
|
|
|
#include "current_stateid.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define NFSDDBG_FACILITY NFSDDBG_PROC
|
|
|
|
|
2009-05-16 08:22:31 +00:00
|
|
|
static u32 nfsd_attrmask[] = {
|
|
|
|
NFSD_WRITEABLE_ATTRS_WORD0,
|
|
|
|
NFSD_WRITEABLE_ATTRS_WORD1,
|
|
|
|
NFSD_WRITEABLE_ATTRS_WORD2
|
|
|
|
};
|
|
|
|
|
|
|
|
static u32 nfsd41_ex_attrmask[] = {
|
|
|
|
NFSD_SUPPATTR_EXCLCREAT_WORD0,
|
|
|
|
NFSD_SUPPATTR_EXCLCREAT_WORD1,
|
|
|
|
NFSD_SUPPATTR_EXCLCREAT_WORD2
|
|
|
|
};
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
u32 *bmval, u32 *writable)
|
|
|
|
{
|
|
|
|
struct dentry *dentry = cstate->current_fh.fh_dentry;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check about attributes are supported by the NFSv4 server or not.
|
|
|
|
* According to spec, unsupported attributes return ERR_ATTRNOTSUPP.
|
|
|
|
*/
|
|
|
|
if ((bmval[0] & ~nfsd_suppattrs0(cstate->minorversion)) ||
|
|
|
|
(bmval[1] & ~nfsd_suppattrs1(cstate->minorversion)) ||
|
|
|
|
(bmval[2] & ~nfsd_suppattrs2(cstate->minorversion)))
|
|
|
|
return nfserr_attrnotsupp;
|
|
|
|
|
|
|
|
/*
|
2009-08-31 19:16:11 +00:00
|
|
|
* Check FATTR4_WORD0_ACL can be supported
|
2009-05-16 08:22:31 +00:00
|
|
|
* in current environment or not.
|
|
|
|
*/
|
|
|
|
if (bmval[0] & FATTR4_WORD0_ACL) {
|
|
|
|
if (!IS_POSIXACL(dentry->d_inode))
|
|
|
|
return nfserr_attrnotsupp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* According to spec, read-only attributes return ERR_INVAL.
|
|
|
|
*/
|
|
|
|
if (writable) {
|
|
|
|
if ((bmval[0] & ~writable[0]) || (bmval[1] & ~writable[1]) ||
|
|
|
|
(bmval[2] & ~writable[2]))
|
|
|
|
return nfserr_inval;
|
|
|
|
}
|
|
|
|
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_check_open_attributes(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
|
|
|
|
{
|
|
|
|
__be32 status = nfs_ok;
|
|
|
|
|
|
|
|
if (open->op_create == NFS4_OPEN_CREATE) {
|
|
|
|
if (open->op_createmode == NFS4_CREATE_UNCHECKED
|
|
|
|
|| open->op_createmode == NFS4_CREATE_GUARDED)
|
|
|
|
status = check_attr_support(rqstp, cstate,
|
|
|
|
open->op_bmval, nfsd_attrmask);
|
|
|
|
else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1)
|
|
|
|
status = check_attr_support(rqstp, cstate,
|
|
|
|
open->op_bmval, nfsd41_ex_attrmask);
|
|
|
|
}
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2009-07-06 09:24:16 +00:00
|
|
|
static int
|
|
|
|
is_create_with_attrs(struct nfsd4_open *open)
|
|
|
|
{
|
|
|
|
return open->op_create == NFS4_OPEN_CREATE
|
|
|
|
&& (open->op_createmode == NFS4_CREATE_UNCHECKED
|
|
|
|
|| open->op_createmode == NFS4_CREATE_GUARDED
|
|
|
|
|| open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if error occurs when setting the acl, just clear the acl bit
|
|
|
|
* in the returned attr bitmap.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
|
|
|
|
struct nfs4_acl *acl, u32 *bmval)
|
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
|
|
|
|
status = nfsd4_set_nfs4_acl(rqstp, fhp, acl);
|
|
|
|
if (status)
|
|
|
|
/*
|
|
|
|
* We should probably fail the whole open at this point,
|
|
|
|
* but we've already created the file, so it's too late;
|
|
|
|
* So this seems the least of evils:
|
|
|
|
*/
|
|
|
|
bmval[0] &= ~FATTR4_WORD0_ACL;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static inline void
|
|
|
|
fh_dup2(struct svc_fh *dst, struct svc_fh *src)
|
|
|
|
{
|
|
|
|
fh_put(dst);
|
|
|
|
dget(src->fh_dentry);
|
|
|
|
if (src->fh_export)
|
|
|
|
cache_get(&src->fh_export->h);
|
|
|
|
*dst = *src;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2006-10-17 07:10:13 +00:00
|
|
|
do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (open->op_truncate &&
|
|
|
|
!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
|
|
|
|
return nfserr_inval;
|
|
|
|
|
2011-08-25 14:48:39 +00:00
|
|
|
accmode |= NFSD_MAY_READ_IF_EXEC;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
|
2008-06-16 11:20:29 +00:00
|
|
|
accmode |= NFSD_MAY_READ;
|
2006-10-17 07:10:14 +00:00
|
|
|
if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
|
2008-06-16 11:20:29 +00:00
|
|
|
accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC);
|
2009-12-02 00:42:57 +00:00
|
|
|
if (open->op_share_deny & NFS4_SHARE_DENY_READ)
|
2008-06-16 11:20:29 +00:00
|
|
|
accmode |= NFSD_MAY_WRITE;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
status = fh_verify(rqstp, current_fh, S_IFREG, accmode);
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-08-15 20:55:02 +00:00
|
|
|
static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
|
|
|
|
{
|
|
|
|
umode_t mode = fh->fh_dentry->d_inode->i_mode;
|
|
|
|
|
|
|
|
if (S_ISREG(mode))
|
|
|
|
return nfs_ok;
|
|
|
|
if (S_ISDIR(mode))
|
|
|
|
return nfserr_isdir;
|
|
|
|
/*
|
|
|
|
* Using err_symlink as our catch-all case may look odd; but
|
|
|
|
* there's no other obvious error for this case in 4.0, and we
|
|
|
|
* happen to know that it will cause the linux v4 client to do
|
|
|
|
* the right thing on attempts to open something other than a
|
|
|
|
* regular file.
|
|
|
|
*/
|
|
|
|
return nfserr_symlink;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
|
|
|
|
{
|
2012-01-27 21:49:55 +00:00
|
|
|
struct svc_fh *resfh;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-01-27 21:49:55 +00:00
|
|
|
resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
|
|
|
|
if (!resfh)
|
|
|
|
return nfserr_jukebox;
|
|
|
|
fh_init(resfh, NFS4_FHSIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
open->op_truncate = 0;
|
|
|
|
|
|
|
|
if (open->op_create) {
|
2009-04-03 05:29:17 +00:00
|
|
|
/* FIXME: check session persistence and pnfs flags.
|
|
|
|
* The nfsv4.1 spec requires the following semantics:
|
|
|
|
*
|
|
|
|
* Persistent | pNFS | Server REQUIRED | Client Allowed
|
|
|
|
* Reply Cache | server | |
|
|
|
|
* -------------+--------+-----------------+--------------------
|
|
|
|
* no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1
|
|
|
|
* | | | (SHOULD)
|
|
|
|
* | | and EXCLUSIVE4 | or EXCLUSIVE4
|
|
|
|
* | | | (SHOULD NOT)
|
|
|
|
* no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1
|
|
|
|
* yes | no | GUARDED4 | GUARDED4
|
|
|
|
* yes | yes | GUARDED4 | GUARDED4
|
|
|
|
*/
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Note: create modes (UNCHECKED,GUARDED...) are the same
|
2011-04-20 09:06:25 +00:00
|
|
|
* in NFSv4 as in v3 except EXCLUSIVE4_1.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2011-04-20 09:06:25 +00:00
|
|
|
status = do_nfsd_create(rqstp, current_fh, open->op_fname.data,
|
2005-04-16 22:20:36 +00:00
|
|
|
open->op_fname.len, &open->op_iattr,
|
2012-01-27 21:49:55 +00:00
|
|
|
resfh, open->op_createmode,
|
2007-07-31 07:37:51 +00:00
|
|
|
(u32 *)open->op_verf.data,
|
2011-10-13 15:37:11 +00:00
|
|
|
&open->op_truncate, &open->op_created);
|
2007-07-31 07:37:51 +00:00
|
|
|
|
2009-02-02 20:12:27 +00:00
|
|
|
/*
|
|
|
|
* Following rfc 3530 14.2.16, use the returned bitmask
|
|
|
|
* to indicate which attributes we used to store the
|
|
|
|
* verifier:
|
2007-07-31 07:37:51 +00:00
|
|
|
*/
|
|
|
|
if (open->op_createmode == NFS4_CREATE_EXCLUSIVE && status == 0)
|
2009-02-02 20:12:27 +00:00
|
|
|
open->op_bmval[1] = (FATTR4_WORD1_TIME_ACCESS |
|
2012-04-09 22:06:49 +00:00
|
|
|
FATTR4_WORD1_TIME_MODIFY);
|
2006-11-09 01:44:39 +00:00
|
|
|
} else {
|
2005-04-16 22:20:36 +00:00
|
|
|
status = nfsd_lookup(rqstp, current_fh,
|
2012-01-27 21:49:55 +00:00
|
|
|
open->op_fname.data, open->op_fname.len, resfh);
|
2005-04-16 22:20:36 +00:00
|
|
|
fh_unlock(current_fh);
|
|
|
|
}
|
2012-04-09 22:06:49 +00:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = nfsd_check_obj_isreg(resfh);
|
2006-11-09 01:44:39 +00:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-07-06 09:24:16 +00:00
|
|
|
if (is_create_with_attrs(open) && open->op_acl != NULL)
|
2012-01-27 21:49:55 +00:00
|
|
|
do_set_nfs4_acl(rqstp, resfh, open->op_acl, open->op_bmval);
|
2009-07-06 09:24:16 +00:00
|
|
|
|
2006-11-09 01:44:39 +00:00
|
|
|
/* set reply cache */
|
2011-07-31 03:33:59 +00:00
|
|
|
fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
|
2012-01-27 21:49:55 +00:00
|
|
|
&resfh->fh_handle);
|
2011-10-13 15:37:11 +00:00
|
|
|
if (!open->op_created)
|
2012-01-27 21:49:55 +00:00
|
|
|
status = do_open_permission(rqstp, resfh, open,
|
2008-06-16 11:20:29 +00:00
|
|
|
NFSD_MAY_NOP);
|
2012-01-27 21:26:02 +00:00
|
|
|
set_change_info(&open->op_cinfo, current_fh);
|
2012-01-27 21:49:55 +00:00
|
|
|
fh_dup2(current_fh, resfh);
|
2006-11-09 01:44:39 +00:00
|
|
|
out:
|
2012-01-27 21:49:55 +00:00
|
|
|
fh_put(resfh);
|
|
|
|
kfree(resfh);
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
do_open_fhandle(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
|
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* We don't know the target directory, and therefore can not
|
|
|
|
* set the change info
|
|
|
|
*/
|
|
|
|
|
|
|
|
memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));
|
|
|
|
|
|
|
|
/* set replay cache */
|
2011-07-31 03:33:59 +00:00
|
|
|
fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
|
2009-02-02 22:23:10 +00:00
|
|
|
¤t_fh->fh_handle);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
|
|
|
|
(open->op_iattr.ia_size == 0);
|
|
|
|
|
2008-06-16 11:20:29 +00:00
|
|
|
status = do_open_permission(rqstp, current_fh, open,
|
|
|
|
NFSD_MAY_OWNER_OVERRIDE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2009-04-03 05:28:50 +00:00
|
|
|
static void
|
|
|
|
copy_clientid(clientid_t *clid, struct nfsd4_session *session)
|
|
|
|
{
|
|
|
|
struct nfsd4_sessionid *sid =
|
|
|
|
(struct nfsd4_sessionid *)session->se_sessionid.data;
|
|
|
|
|
|
|
|
clid->cl_boot = sid->clientid.cl_boot;
|
|
|
|
clid->cl_id = sid->clientid.cl_id;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2006-12-13 08:35:28 +00:00
|
|
|
struct nfsd4_open *open)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2009-04-03 05:28:45 +00:00
|
|
|
struct nfsd4_compoundres *resp;
|
|
|
|
|
2011-07-31 03:33:59 +00:00
|
|
|
dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
(int)open->op_fname.len, open->op_fname.data,
|
2011-07-31 03:33:59 +00:00
|
|
|
open->op_openowner);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* This check required by spec. */
|
|
|
|
if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
|
|
|
|
return nfserr_inval;
|
|
|
|
|
2011-10-13 15:37:11 +00:00
|
|
|
open->op_created = 0;
|
2011-07-14 07:06:26 +00:00
|
|
|
/*
|
|
|
|
* RFC5661 18.51.3
|
|
|
|
* Before RECLAIM_COMPLETE done, server should deny new lock
|
|
|
|
*/
|
|
|
|
if (nfsd4_has_session(cstate) &&
|
2012-03-21 13:52:02 +00:00
|
|
|
!test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
|
|
|
|
&cstate->session->se_client->cl_flags) &&
|
2011-07-14 07:06:26 +00:00
|
|
|
open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
|
|
|
|
return nfserr_grace;
|
|
|
|
|
2009-04-03 05:28:50 +00:00
|
|
|
if (nfsd4_has_session(cstate))
|
|
|
|
copy_clientid(&open->op_clientid, cstate->session);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
nfs4_lock_state();
|
|
|
|
|
|
|
|
/* check seqid for replay. set nfs4_owner */
|
2009-04-03 05:28:45 +00:00
|
|
|
resp = rqstp->rq_resp;
|
|
|
|
status = nfsd4_process_open1(&resp->cstate, open);
|
2006-10-20 06:29:03 +00:00
|
|
|
if (status == nfserr_replay_me) {
|
2011-07-31 03:33:59 +00:00
|
|
|
struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay;
|
2006-12-13 08:35:27 +00:00
|
|
|
fh_put(&cstate->current_fh);
|
2009-02-02 22:23:10 +00:00
|
|
|
fh_copy_shallow(&cstate->current_fh.fh_handle,
|
|
|
|
&rp->rp_openfh);
|
2008-06-16 11:20:29 +00:00
|
|
|
status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (status)
|
|
|
|
dprintk("nfsd4_open: replay failed"
|
|
|
|
" restoring previous filehandle\n");
|
|
|
|
else
|
2006-10-20 06:29:03 +00:00
|
|
|
status = nfserr_replay_me;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (status)
|
|
|
|
goto out;
|
2006-01-19 01:43:36 +00:00
|
|
|
|
2009-05-16 08:22:31 +00:00
|
|
|
status = nfsd4_check_open_attributes(rqstp, cstate, open);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
|
2006-01-19 01:43:36 +00:00
|
|
|
/* Openowner is now set, so sequence id will get bumped. Now we need
|
|
|
|
* these checks before we do any creates: */
|
2006-02-07 20:58:32 +00:00
|
|
|
status = nfserr_grace;
|
2012-07-25 12:57:22 +00:00
|
|
|
if (locks_in_grace(SVC_NET(rqstp)) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
|
2006-02-07 20:58:32 +00:00
|
|
|
goto out;
|
|
|
|
status = nfserr_no_grace;
|
2012-07-25 12:57:22 +00:00
|
|
|
if (!locks_in_grace(SVC_NET(rqstp)) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
|
2006-02-07 20:58:32 +00:00
|
|
|
goto out;
|
2006-01-19 01:43:36 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (open->op_claim_type) {
|
2005-06-24 05:02:56 +00:00
|
|
|
case NFS4_OPEN_CLAIM_DELEGATE_CUR:
|
2005-04-16 22:20:36 +00:00
|
|
|
case NFS4_OPEN_CLAIM_NULL:
|
2006-12-13 08:35:27 +00:00
|
|
|
status = do_open_lookup(rqstp, &cstate->current_fh,
|
|
|
|
open);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CLAIM_PREVIOUS:
|
2011-09-12 16:24:13 +00:00
|
|
|
open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
|
2011-11-23 02:48:40 +00:00
|
|
|
status = nfs4_check_open_reclaim(&open->op_clientid);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
2011-10-19 15:52:12 +00:00
|
|
|
case NFS4_OPEN_CLAIM_FH:
|
|
|
|
case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
|
2006-12-13 08:35:27 +00:00
|
|
|
status = do_open_fhandle(rqstp, &cstate->current_fh,
|
|
|
|
open);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
break;
|
2011-10-19 15:52:12 +00:00
|
|
|
case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
|
2005-04-16 22:20:36 +00:00
|
|
|
case NFS4_OPEN_CLAIM_DELEGATE_PREV:
|
2011-09-12 16:24:13 +00:00
|
|
|
open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
|
2007-07-27 20:10:37 +00:00
|
|
|
dprintk("NFSD: unsupported OPEN claim type %d\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
open->op_claim_type);
|
|
|
|
status = nfserr_notsupp;
|
|
|
|
goto out;
|
|
|
|
default:
|
2007-07-27 20:10:37 +00:00
|
|
|
dprintk("NFSD: Invalid OPEN claim type %d\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
open->op_claim_type);
|
|
|
|
status = nfserr_inval;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* nfsd4_process_open2() does the actual opening of the file. If
|
|
|
|
* successful, it (1) truncates the file if open->op_truncate was
|
|
|
|
* set, (2) sets open->op_stateid, (3) sets open->op_delegation.
|
|
|
|
*/
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd4_process_open2(rqstp, &cstate->current_fh, open);
|
2011-10-13 15:37:11 +00:00
|
|
|
WARN_ON(status && open->op_created);
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
2011-10-13 19:12:59 +00:00
|
|
|
nfsd4_cleanup_open_state(open, status);
|
2011-07-31 03:33:59 +00:00
|
|
|
if (open->op_openowner)
|
|
|
|
cstate->replay_owner = &open->op_openowner->oo_owner;
|
2011-08-31 02:15:47 +00:00
|
|
|
else
|
2011-08-30 21:02:48 +00:00
|
|
|
nfs4_unlock_state();
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* filehandle-manipulating ops.
|
|
|
|
*/
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:38 +00:00
|
|
|
nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct svc_fh **getfh)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-12-13 08:35:27 +00:00
|
|
|
if (!cstate->current_fh.fh_dentry)
|
2005-04-16 22:20:36 +00:00
|
|
|
return nfserr_nofilehandle;
|
|
|
|
|
2006-12-13 08:35:27 +00:00
|
|
|
*getfh = &cstate->current_fh;
|
2005-04-16 22:20:36 +00:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_putfh *putfh)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-12-13 08:35:27 +00:00
|
|
|
fh_put(&cstate->current_fh);
|
|
|
|
cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
|
|
|
|
memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
|
|
|
|
putfh->pf_fhlen);
|
2011-04-08 21:00:50 +00:00
|
|
|
return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:38 +00:00
|
|
|
nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
void *arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-13 08:35:27 +00:00
|
|
|
fh_put(&cstate->current_fh);
|
2007-07-17 11:04:43 +00:00
|
|
|
status = exp_pseudoroot(rqstp, &cstate->current_fh);
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:38 +00:00
|
|
|
nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
void *arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-12-13 08:35:27 +00:00
|
|
|
if (!cstate->save_fh.fh_dentry)
|
2005-04-16 22:20:36 +00:00
|
|
|
return nfserr_restorefh;
|
|
|
|
|
2006-12-13 08:35:27 +00:00
|
|
|
fh_dup2(&cstate->current_fh, &cstate->save_fh);
|
2012-02-13 21:55:32 +00:00
|
|
|
if (HAS_STATE_ID(cstate, SAVED_STATE_ID_FLAG)) {
|
|
|
|
memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));
|
|
|
|
SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:38 +00:00
|
|
|
nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
void *arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-12-13 08:35:27 +00:00
|
|
|
if (!cstate->current_fh.fh_dentry)
|
2005-04-16 22:20:36 +00:00
|
|
|
return nfserr_nofilehandle;
|
|
|
|
|
2006-12-13 08:35:27 +00:00
|
|
|
fh_dup2(&cstate->save_fh, &cstate->current_fh);
|
2012-02-13 21:55:32 +00:00
|
|
|
if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG)) {
|
|
|
|
memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));
|
|
|
|
SET_STATE_ID(cstate, SAVED_STATE_ID_FLAG);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* misc nfsv4 ops
|
|
|
|
*/
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_access *access)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
if (access->ac_req_access & ~NFS3_ACCESS_FULL)
|
|
|
|
return nfserr_inval;
|
|
|
|
|
|
|
|
access->ac_resp_access = access->ac_req_access;
|
2006-12-13 08:35:27 +00:00
|
|
|
return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access,
|
|
|
|
&access->ac_supported);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2012-03-02 22:13:50 +00:00
|
|
|
static void gen_boot_verifier(nfs4_verifier *verifier)
|
|
|
|
{
|
|
|
|
__be32 verf[2];
|
|
|
|
|
|
|
|
verf[0] = (__be32)nfssvc_boot.tv_sec;
|
|
|
|
verf[1] = (__be32)nfssvc_boot.tv_usec;
|
|
|
|
memcpy(verifier->data, verf, sizeof(verifier->data));
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_commit *commit)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-03-02 22:13:50 +00:00
|
|
|
gen_boot_verifier(&commit->co_verf);
|
2011-08-15 22:39:32 +00:00
|
|
|
return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
|
2006-12-13 08:35:27 +00:00
|
|
|
commit->co_count);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_create *create)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct svc_fh resfh;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_t rdev;
|
|
|
|
|
|
|
|
fh_init(&resfh, NFS4_FHSIZE);
|
|
|
|
|
2008-06-16 11:20:29 +00:00
|
|
|
status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR,
|
|
|
|
NFSD_MAY_CREATE);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
2009-05-16 08:22:31 +00:00
|
|
|
status = check_attr_support(rqstp, cstate, create->cr_bmval,
|
|
|
|
nfsd_attrmask);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (create->cr_type) {
|
|
|
|
case NF4LNK:
|
|
|
|
/* ugh! we have to null-terminate the linktext, or
|
|
|
|
* vfs_symlink() will choke. it is always safe to
|
|
|
|
* null-terminate by brute force, since at worst we
|
|
|
|
* will overwrite the first byte of the create namelen
|
|
|
|
* in the XDR buffer, which has already been extracted
|
|
|
|
* during XDR decode.
|
|
|
|
*/
|
|
|
|
create->cr_linkname[create->cr_linklen] = 0;
|
|
|
|
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_symlink(rqstp, &cstate->current_fh,
|
|
|
|
create->cr_name, create->cr_namelen,
|
|
|
|
create->cr_linkname, create->cr_linklen,
|
|
|
|
&resfh, &create->cr_iattr);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NF4BLK:
|
|
|
|
rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
|
|
|
|
if (MAJOR(rdev) != create->cr_specdata1 ||
|
|
|
|
MINOR(rdev) != create->cr_specdata2)
|
|
|
|
return nfserr_inval;
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_create(rqstp, &cstate->current_fh,
|
|
|
|
create->cr_name, create->cr_namelen,
|
|
|
|
&create->cr_iattr, S_IFBLK, rdev, &resfh);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NF4CHR:
|
|
|
|
rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
|
|
|
|
if (MAJOR(rdev) != create->cr_specdata1 ||
|
|
|
|
MINOR(rdev) != create->cr_specdata2)
|
|
|
|
return nfserr_inval;
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_create(rqstp, &cstate->current_fh,
|
|
|
|
create->cr_name, create->cr_namelen,
|
|
|
|
&create->cr_iattr,S_IFCHR, rdev, &resfh);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NF4SOCK:
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_create(rqstp, &cstate->current_fh,
|
|
|
|
create->cr_name, create->cr_namelen,
|
|
|
|
&create->cr_iattr, S_IFSOCK, 0, &resfh);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NF4FIFO:
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_create(rqstp, &cstate->current_fh,
|
|
|
|
create->cr_name, create->cr_namelen,
|
|
|
|
&create->cr_iattr, S_IFIFO, 0, &resfh);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NF4DIR:
|
|
|
|
create->cr_iattr.ia_valid &= ~ATTR_SIZE;
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_create(rqstp, &cstate->current_fh,
|
|
|
|
create->cr_name, create->cr_namelen,
|
|
|
|
&create->cr_iattr, S_IFDIR, 0, &resfh);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
status = nfserr_badtype;
|
|
|
|
}
|
|
|
|
|
2009-07-06 09:24:16 +00:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-07-06 09:24:16 +00:00
|
|
|
if (create->cr_acl != NULL)
|
|
|
|
do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
|
|
|
|
create->cr_bmval);
|
|
|
|
|
|
|
|
fh_unlock(&cstate->current_fh);
|
|
|
|
set_change_info(&create->cr_cinfo, &cstate->current_fh);
|
|
|
|
fh_dup2(&cstate->current_fh, &resfh);
|
|
|
|
out:
|
2005-04-16 22:20:36 +00:00
|
|
|
fh_put(&resfh);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_getattr *getattr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-16 11:20:29 +00:00
|
|
|
status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
|
|
|
|
return nfserr_inval;
|
|
|
|
|
2009-04-03 05:29:11 +00:00
|
|
|
getattr->ga_bmval[0] &= nfsd_suppattrs0(cstate->minorversion);
|
|
|
|
getattr->ga_bmval[1] &= nfsd_suppattrs1(cstate->minorversion);
|
|
|
|
getattr->ga_bmval[2] &= nfsd_suppattrs2(cstate->minorversion);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-13 08:35:27 +00:00
|
|
|
getattr->ga_fhp = &cstate->current_fh;
|
2005-04-16 22:20:36 +00:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_link *link)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status = nfserr_nofilehandle;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-13 08:35:27 +00:00
|
|
|
if (!cstate->save_fh.fh_dentry)
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_link(rqstp, &cstate->current_fh,
|
|
|
|
link->li_name, link->li_namelen, &cstate->save_fh);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!status)
|
2006-12-13 08:35:27 +00:00
|
|
|
set_change_info(&link->li_cinfo, &cstate->current_fh);
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2010-12-16 15:06:27 +00:00
|
|
|
static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct svc_fh tmp_fh;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
fh_init(&tmp_fh, NFS4_FHSIZE);
|
2007-07-17 11:04:43 +00:00
|
|
|
ret = exp_pseudoroot(rqstp, &tmp_fh);
|
|
|
|
if (ret)
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
2010-12-16 15:06:27 +00:00
|
|
|
if (tmp_fh.fh_dentry == fh->fh_dentry) {
|
2005-04-16 22:20:36 +00:00
|
|
|
fh_put(&tmp_fh);
|
|
|
|
return nfserr_noent;
|
|
|
|
}
|
|
|
|
fh_put(&tmp_fh);
|
2010-12-16 15:06:27 +00:00
|
|
|
return nfsd_lookup(rqstp, fh, "..", 2, fh);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
void *arg)
|
|
|
|
{
|
|
|
|
return nfsd4_do_lookupp(rqstp, &cstate->current_fh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_lookup *lookup)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-12-13 08:35:27 +00:00
|
|
|
return nfsd_lookup(rqstp, &cstate->current_fh,
|
|
|
|
lookup->lo_name, lookup->lo_len,
|
|
|
|
&cstate->current_fh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_read *read)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* no need to check permission - this will be done in nfsd_read() */
|
|
|
|
|
2005-06-24 05:03:13 +00:00
|
|
|
read->rd_filp = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (read->rd_offset >= OFFSET_MAX)
|
|
|
|
return nfserr_inval;
|
|
|
|
|
|
|
|
nfs4_lock_state();
|
|
|
|
/* check stateid */
|
2012-07-25 12:57:22 +00:00
|
|
|
if ((status = nfs4_preprocess_stateid_op(SVC_NET(rqstp),
|
|
|
|
cstate, &read->rd_stateid,
|
2009-04-03 05:28:41 +00:00
|
|
|
RD_STATE, &read->rd_filp))) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
|
|
|
|
goto out;
|
|
|
|
}
|
2005-06-24 05:03:13 +00:00
|
|
|
if (read->rd_filp)
|
|
|
|
get_file(read->rd_filp);
|
2005-04-16 22:20:36 +00:00
|
|
|
status = nfs_ok;
|
|
|
|
out:
|
|
|
|
nfs4_unlock_state();
|
|
|
|
read->rd_rqstp = rqstp;
|
2006-12-13 08:35:27 +00:00
|
|
|
read->rd_fhp = &cstate->current_fh;
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_readdir *readdir)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
u64 cookie = readdir->rd_cookie;
|
|
|
|
static const nfs4_verifier zeroverf;
|
|
|
|
|
|
|
|
/* no need to check permission - this will be done in nfsd_readdir() */
|
|
|
|
|
|
|
|
if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
|
|
|
|
return nfserr_inval;
|
|
|
|
|
2009-04-03 05:29:11 +00:00
|
|
|
readdir->rd_bmval[0] &= nfsd_suppattrs0(cstate->minorversion);
|
|
|
|
readdir->rd_bmval[1] &= nfsd_suppattrs1(cstate->minorversion);
|
|
|
|
readdir->rd_bmval[2] &= nfsd_suppattrs2(cstate->minorversion);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-08-08 15:38:08 +00:00
|
|
|
if ((cookie == 1) || (cookie == 2) ||
|
2005-04-16 22:20:36 +00:00
|
|
|
(cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE)))
|
|
|
|
return nfserr_bad_cookie;
|
|
|
|
|
|
|
|
readdir->rd_rqstp = rqstp;
|
2006-12-13 08:35:27 +00:00
|
|
|
readdir->rd_fhp = &cstate->current_fh;
|
2005-04-16 22:20:36 +00:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_readlink *readlink)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
readlink->rl_rqstp = rqstp;
|
2006-12-13 08:35:27 +00:00
|
|
|
readlink->rl_fhp = &cstate->current_fh;
|
2005-04-16 22:20:36 +00:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_remove *remove)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-07-25 12:57:22 +00:00
|
|
|
if (locks_in_grace(SVC_NET(rqstp)))
|
2005-06-24 05:03:00 +00:00
|
|
|
return nfserr_grace;
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_unlink(rqstp, &cstate->current_fh, 0,
|
|
|
|
remove->rm_name, remove->rm_namelen);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!status) {
|
2006-12-13 08:35:27 +00:00
|
|
|
fh_unlock(&cstate->current_fh);
|
|
|
|
set_change_info(&remove->rm_cinfo, &cstate->current_fh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_rename *rename)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status = nfserr_nofilehandle;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-13 08:35:27 +00:00
|
|
|
if (!cstate->save_fh.fh_dentry)
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
2012-07-25 12:57:22 +00:00
|
|
|
if (locks_in_grace(SVC_NET(rqstp)) &&
|
|
|
|
!(cstate->save_fh.fh_export->ex_flags & NFSEXP_NOSUBTREECHECK))
|
2005-06-24 05:03:00 +00:00
|
|
|
return nfserr_grace;
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname,
|
|
|
|
rename->rn_snamelen, &cstate->current_fh,
|
2005-04-16 22:20:36 +00:00
|
|
|
rename->rn_tname, rename->rn_tnamelen);
|
|
|
|
|
|
|
|
/* the underlying filesystem returns different error's than required
|
|
|
|
* by NFSv4. both save_fh and current_fh have been verified.. */
|
|
|
|
if (status == nfserr_isdir)
|
|
|
|
status = nfserr_exist;
|
|
|
|
else if ((status == nfserr_notdir) &&
|
2006-12-13 08:35:27 +00:00
|
|
|
(S_ISDIR(cstate->save_fh.fh_dentry->d_inode->i_mode) &&
|
|
|
|
S_ISDIR(cstate->current_fh.fh_dentry->d_inode->i_mode)))
|
2005-04-16 22:20:36 +00:00
|
|
|
status = nfserr_exist;
|
|
|
|
|
|
|
|
if (!status) {
|
2006-12-13 08:35:27 +00:00
|
|
|
set_change_info(&rename->rn_sinfo, &cstate->current_fh);
|
|
|
|
set_change_info(&rename->rn_tinfo, &cstate->save_fh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2007-07-17 11:04:51 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_secinfo *secinfo)
|
|
|
|
{
|
|
|
|
struct svc_fh resfh;
|
|
|
|
struct svc_export *exp;
|
|
|
|
struct dentry *dentry;
|
|
|
|
__be32 err;
|
|
|
|
|
|
|
|
fh_init(&resfh, NFS4_FHSIZE);
|
2011-04-09 15:28:53 +00:00
|
|
|
err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2007-07-17 11:04:51 +00:00
|
|
|
err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
|
|
|
|
secinfo->si_name, secinfo->si_namelen,
|
|
|
|
&exp, &dentry);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
if (dentry->d_inode == NULL) {
|
|
|
|
exp_put(exp);
|
|
|
|
err = nfserr_noent;
|
|
|
|
} else
|
|
|
|
secinfo->si_exp = exp;
|
|
|
|
dput(dentry);
|
2010-12-16 14:57:15 +00:00
|
|
|
if (cstate->minorversion)
|
|
|
|
/* See rfc 5661 section 2.6.3.1.1.8 */
|
|
|
|
fh_put(&cstate->current_fh);
|
2007-07-17 11:04:51 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-12-16 14:51:13 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_secinfo_no_name *sin)
|
|
|
|
{
|
|
|
|
__be32 err;
|
|
|
|
|
|
|
|
switch (sin->sin_style) {
|
|
|
|
case NFS4_SECINFO_STYLE4_CURRENT_FH:
|
|
|
|
break;
|
|
|
|
case NFS4_SECINFO_STYLE4_PARENT:
|
|
|
|
err = nfsd4_do_lookupp(rqstp, &cstate->current_fh);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return nfserr_inval;
|
|
|
|
}
|
|
|
|
exp_get(cstate->current_fh.fh_export);
|
|
|
|
sin->sin_exp = cstate->current_fh.fh_export;
|
|
|
|
fh_put(&cstate->current_fh);
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_setattr *setattr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status = nfs_ok;
|
2012-04-13 03:47:00 +00:00
|
|
|
int err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
|
|
|
|
nfs4_lock_state();
|
2012-07-25 12:57:22 +00:00
|
|
|
status = nfs4_preprocess_stateid_op(SVC_NET(rqstp), cstate,
|
2009-02-21 21:36:16 +00:00
|
|
|
&setattr->sa_stateid, WR_STATE, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
nfs4_unlock_state();
|
2006-01-19 01:43:33 +00:00
|
|
|
if (status) {
|
2006-10-02 09:17:41 +00:00
|
|
|
dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
|
2006-01-19 01:43:33 +00:00
|
|
|
return status;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2012-04-13 03:47:00 +00:00
|
|
|
err = fh_want_write(&cstate->current_fh);
|
|
|
|
if (err)
|
|
|
|
return nfserrno(err);
|
2005-04-16 22:20:36 +00:00
|
|
|
status = nfs_ok;
|
2009-05-16 08:22:31 +00:00
|
|
|
|
|
|
|
status = check_attr_support(rqstp, cstate, setattr->sa_bmval,
|
|
|
|
nfsd_attrmask);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (setattr->sa_acl != NULL)
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh,
|
|
|
|
setattr->sa_acl);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (status)
|
2008-02-15 22:37:38 +00:00
|
|
|
goto out;
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
|
2005-04-16 22:20:36 +00:00
|
|
|
0, (time_t)0);
|
2008-02-15 22:37:38 +00:00
|
|
|
out:
|
2011-11-23 17:03:18 +00:00
|
|
|
fh_drop_write(&cstate->current_fh);
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:29 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:27 +00:00
|
|
|
nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_write *write)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
stateid_t *stateid = &write->wr_stateid;
|
|
|
|
struct file *filp = NULL;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status = nfs_ok;
|
2009-03-06 01:16:14 +00:00
|
|
|
unsigned long cnt;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* no need to check permission - this will be done in nfsd_write() */
|
|
|
|
|
|
|
|
if (write->wr_offset >= OFFSET_MAX)
|
|
|
|
return nfserr_inval;
|
|
|
|
|
|
|
|
nfs4_lock_state();
|
2012-07-25 12:57:22 +00:00
|
|
|
status = nfs4_preprocess_stateid_op(SVC_NET(rqstp),
|
|
|
|
cstate, stateid, WR_STATE, &filp);
|
2005-06-24 05:03:13 +00:00
|
|
|
if (filp)
|
|
|
|
get_file(filp);
|
2005-04-16 22:20:36 +00:00
|
|
|
nfs4_unlock_state();
|
|
|
|
|
2006-01-19 01:43:33 +00:00
|
|
|
if (status) {
|
|
|
|
dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2009-03-06 01:16:14 +00:00
|
|
|
cnt = write->wr_buflen;
|
2005-04-16 22:20:36 +00:00
|
|
|
write->wr_how_written = write->wr_stable_how;
|
2012-03-02 22:13:50 +00:00
|
|
|
gen_boot_verifier(&write->wr_verifier);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_write(rqstp, &cstate->current_fh, filp,
|
|
|
|
write->wr_offset, rqstp->rq_vec, write->wr_vlen,
|
2009-03-06 01:16:14 +00:00
|
|
|
&cnt, &write->wr_how_written);
|
2005-06-24 05:03:13 +00:00
|
|
|
if (filp)
|
|
|
|
fput(filp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-06 01:16:14 +00:00
|
|
|
write->wr_bytes_written = cnt;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This routine never returns NFS_OK! If there are no other errors, it
|
|
|
|
* will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
|
|
|
|
* attributes matched. VERIFY is implemented by mapping NFSERR_SAME
|
|
|
|
* to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
|
|
|
|
*/
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2006-12-13 08:35:31 +00:00
|
|
|
_nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2006-12-13 08:35:27 +00:00
|
|
|
struct nfsd4_verify *verify)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *buf, *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
int count;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-16 11:20:29 +00:00
|
|
|
status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
2009-05-16 08:22:31 +00:00
|
|
|
status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)
|
|
|
|
|| (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1))
|
|
|
|
return nfserr_inval;
|
|
|
|
if (verify->ve_attrlen & 3)
|
|
|
|
return nfserr_inval;
|
|
|
|
|
|
|
|
/* count in words:
|
|
|
|
* bitmap_len(1) + bitmap(2) + attr_len(1) = 4
|
|
|
|
*/
|
|
|
|
count = 4 + (verify->ve_attrlen >> 2);
|
|
|
|
buf = kmalloc(count << 2, GFP_KERNEL);
|
|
|
|
if (!buf)
|
2011-08-10 23:07:33 +00:00
|
|
|
return nfserr_jukebox;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd4_encode_fattr(&cstate->current_fh,
|
|
|
|
cstate->current_fh.fh_export,
|
|
|
|
cstate->current_fh.fh_dentry, buf,
|
2005-04-16 22:20:36 +00:00
|
|
|
&count, verify->ve_bmval,
|
2007-11-27 19:34:05 +00:00
|
|
|
rqstp, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* this means that nfsd4_encode_fattr() ran out of space */
|
|
|
|
if (status == nfserr_resource && count == 0)
|
|
|
|
status = nfserr_not_same;
|
|
|
|
if (status)
|
|
|
|
goto out_kfree;
|
|
|
|
|
2009-04-03 05:29:08 +00:00
|
|
|
/* skip bitmap */
|
|
|
|
p = buf + 1 + ntohl(buf[0]);
|
2005-04-16 22:20:36 +00:00
|
|
|
status = nfserr_not_same;
|
|
|
|
if (ntohl(*p++) != verify->ve_attrlen)
|
|
|
|
goto out_kfree;
|
|
|
|
if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen))
|
|
|
|
status = nfserr_same;
|
|
|
|
|
|
|
|
out_kfree:
|
|
|
|
kfree(buf);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:31 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_verify *verify)
|
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
|
|
|
|
status = _nfsd4_verify(rqstp, cstate, verify);
|
|
|
|
return status == nfserr_not_same ? nfs_ok : status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_verify *verify)
|
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
|
|
|
|
status = _nfsd4_verify(rqstp, cstate, verify);
|
|
|
|
return status == nfserr_same ? nfs_ok : status;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* NULL call.
|
|
|
|
*/
|
2006-10-20 06:28:45 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
|
|
|
|
{
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2006-07-10 11:45:44 +00:00
|
|
|
static inline void nfsd4_increment_op_stats(u32 opnum)
|
|
|
|
{
|
|
|
|
if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP)
|
|
|
|
nfsdstats.nfs4_opcount[opnum]++;
|
|
|
|
}
|
|
|
|
|
2006-12-13 08:35:38 +00:00
|
|
|
typedef __be32(*nfsd4op_func)(struct svc_rqst *, struct nfsd4_compound_state *,
|
|
|
|
void *);
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
typedef u32(*nfsd4op_rsize)(struct svc_rqst *, struct nfsd4_op *op);
|
2012-02-13 21:55:24 +00:00
|
|
|
typedef void(*stateid_setter)(struct nfsd4_compound_state *, void *);
|
|
|
|
typedef void(*stateid_getter)(struct nfsd4_compound_state *, void *);
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
|
2009-04-03 05:28:12 +00:00
|
|
|
enum nfsd4_op_flags {
|
|
|
|
ALLOWED_WITHOUT_FH = 1 << 0, /* No current filehandle required */
|
2011-02-18 01:08:31 +00:00
|
|
|
ALLOWED_ON_ABSENT_FS = 1 << 1, /* ops processed on absent fs */
|
|
|
|
ALLOWED_AS_FIRST_OP = 1 << 2, /* ops reqired first in compound */
|
2011-04-08 21:00:50 +00:00
|
|
|
/* For rfc 5661 section 2.6.3.1.1: */
|
|
|
|
OP_HANDLES_WRONGSEC = 1 << 3,
|
|
|
|
OP_IS_PUTFH_LIKE = 1 << 4,
|
2011-01-24 17:11:02 +00:00
|
|
|
/*
|
2011-09-20 12:49:51 +00:00
|
|
|
* These are the ops whose result size we estimate before
|
|
|
|
* encoding, to avoid performing an op then not being able to
|
|
|
|
* respond or cache a response. This includes writes and setattrs
|
|
|
|
* as well as the operations usually called "nonidempotent":
|
|
|
|
*/
|
|
|
|
OP_MODIFIES_SOMETHING = 1 << 5,
|
|
|
|
/*
|
|
|
|
* Cache compounds containing these ops in the xid-based drc:
|
2011-01-24 17:11:02 +00:00
|
|
|
* We use the DRC for compounds containing non-idempotent
|
|
|
|
* operations, *except* those that are 4.1-specific (since
|
|
|
|
* sessions provide their own EOS), and except for stateful
|
|
|
|
* operations other than setclientid and setclientid_confirm
|
|
|
|
* (since sequence numbers provide EOS for open, lock, etc in
|
|
|
|
* the v4.0 case).
|
|
|
|
*/
|
2011-09-20 12:49:51 +00:00
|
|
|
OP_CACHEME = 1 << 6,
|
2012-02-13 21:55:24 +00:00
|
|
|
/*
|
|
|
|
* These are ops which clear current state id.
|
|
|
|
*/
|
|
|
|
OP_CLEAR_STATEID = 1 << 7,
|
2011-09-20 12:49:51 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct nfsd4_operation {
|
|
|
|
nfsd4op_func op_func;
|
|
|
|
u32 op_flags;
|
|
|
|
char *op_name;
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
/* Try to get response size before operation */
|
|
|
|
nfsd4op_rsize op_rsize_bop;
|
2012-08-14 19:55:08 +00:00
|
|
|
stateid_getter op_get_currentstateid;
|
|
|
|
stateid_setter op_set_currentstateid;
|
2006-12-13 08:35:38 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct nfsd4_operation nfsd4_ops[];
|
|
|
|
|
2012-03-20 19:11:17 +00:00
|
|
|
#ifdef NFSD_DEBUG
|
2008-08-08 16:26:42 +00:00
|
|
|
static const char *nfsd4_op_name(unsigned opnum);
|
2012-03-20 19:11:17 +00:00
|
|
|
#endif
|
2008-07-02 08:15:03 +00:00
|
|
|
|
2009-04-03 05:28:12 +00:00
|
|
|
/*
|
2010-04-21 16:27:19 +00:00
|
|
|
* Enforce NFSv4.1 COMPOUND ordering rules:
|
2009-04-03 05:28:12 +00:00
|
|
|
*
|
2010-04-21 16:27:19 +00:00
|
|
|
* Also note, enforced elsewhere:
|
|
|
|
* - SEQUENCE other than as first op results in
|
|
|
|
* NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().)
|
2010-10-05 03:12:59 +00:00
|
|
|
* - BIND_CONN_TO_SESSION must be the only op in its compound.
|
|
|
|
* (Enforced in nfsd4_bind_conn_to_session().)
|
2010-04-21 16:27:19 +00:00
|
|
|
* - DESTROY_SESSION must be the final operation in a compound, if
|
|
|
|
* sessionid's in SEQUENCE and DESTROY_SESSION are the same.
|
|
|
|
* (Enforced in nfsd4_destroy_session().)
|
2009-04-03 05:28:12 +00:00
|
|
|
*/
|
2010-04-21 16:27:19 +00:00
|
|
|
static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args)
|
2009-04-03 05:28:12 +00:00
|
|
|
{
|
2010-04-21 16:27:19 +00:00
|
|
|
struct nfsd4_op *op = &args->ops[0];
|
|
|
|
|
|
|
|
/* These ordering requirements don't apply to NFSv4.0: */
|
|
|
|
if (args->minorversion == 0)
|
|
|
|
return nfs_ok;
|
|
|
|
/* This is weird, but OK, not our problem: */
|
|
|
|
if (args->opcnt == 0)
|
|
|
|
return nfs_ok;
|
|
|
|
if (op->status == nfserr_op_illegal)
|
|
|
|
return nfs_ok;
|
|
|
|
if (!(nfsd4_ops[op->opnum].op_flags & ALLOWED_AS_FIRST_OP))
|
|
|
|
return nfserr_op_not_in_session;
|
|
|
|
if (op->opnum == OP_SEQUENCE)
|
|
|
|
return nfs_ok;
|
|
|
|
if (args->opcnt != 1)
|
|
|
|
return nfserr_not_only_op;
|
|
|
|
return nfs_ok;
|
2009-04-03 05:28:12 +00:00
|
|
|
}
|
|
|
|
|
2011-04-09 15:23:24 +00:00
|
|
|
static inline struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return &nfsd4_ops[op->opnum];
|
|
|
|
}
|
|
|
|
|
2011-01-24 17:11:02 +00:00
|
|
|
bool nfsd4_cache_this_op(struct nfsd4_op *op)
|
|
|
|
{
|
2011-09-20 12:49:51 +00:00
|
|
|
return OPDESC(op)->op_flags & OP_CACHEME;
|
2011-01-24 17:11:02 +00:00
|
|
|
}
|
|
|
|
|
2011-04-08 21:00:50 +00:00
|
|
|
static bool need_wrongsec_check(struct svc_rqst *rqstp)
|
|
|
|
{
|
|
|
|
struct nfsd4_compoundres *resp = rqstp->rq_resp;
|
|
|
|
struct nfsd4_compoundargs *argp = rqstp->rq_argp;
|
|
|
|
struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
|
|
|
|
struct nfsd4_op *next = &argp->ops[resp->opcnt];
|
|
|
|
struct nfsd4_operation *thisd;
|
|
|
|
struct nfsd4_operation *nextd;
|
|
|
|
|
|
|
|
thisd = OPDESC(this);
|
|
|
|
/*
|
|
|
|
* Most ops check wronsec on our own; only the putfh-like ops
|
|
|
|
* have special rules.
|
|
|
|
*/
|
|
|
|
if (!(thisd->op_flags & OP_IS_PUTFH_LIKE))
|
|
|
|
return false;
|
|
|
|
/*
|
|
|
|
* rfc 5661 2.6.3.1.1.6: don't bother erroring out a
|
|
|
|
* put-filehandle operation if we're not going to use the
|
|
|
|
* result:
|
|
|
|
*/
|
|
|
|
if (argp->opcnt == resp->opcnt)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
nextd = OPDESC(next);
|
|
|
|
/*
|
|
|
|
* Rest of 2.6.3.1.1: certain operations will return WRONGSEC
|
|
|
|
* errors themselves as necessary; others should check for them
|
|
|
|
* now:
|
|
|
|
*/
|
|
|
|
return !(nextd->op_flags & OP_HANDLES_WRONGSEC);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* COMPOUND call.
|
|
|
|
*/
|
2006-10-20 06:28:45 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_proc_compound(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compoundargs *args,
|
|
|
|
struct nfsd4_compoundres *resp)
|
|
|
|
{
|
|
|
|
struct nfsd4_op *op;
|
2006-12-13 08:35:38 +00:00
|
|
|
struct nfsd4_operation *opdesc;
|
2009-03-28 08:30:52 +00:00
|
|
|
struct nfsd4_compound_state *cstate = &resp->cstate;
|
2006-12-13 08:35:20 +00:00
|
|
|
int slack_bytes;
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
u32 plen = 0;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
resp->xbuf = &rqstp->rq_res;
|
2009-03-28 08:30:52 +00:00
|
|
|
resp->p = rqstp->rq_res.head[0].iov_base +
|
|
|
|
rqstp->rq_res.head[0].iov_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
resp->tagp = resp->p;
|
|
|
|
/* reserve space for: taglen, tag, and opcnt */
|
|
|
|
resp->p += 2 + XDR_QUADLEN(args->taglen);
|
|
|
|
resp->end = rqstp->rq_res.head[0].iov_base + PAGE_SIZE;
|
|
|
|
resp->taglen = args->taglen;
|
|
|
|
resp->tag = args->tag;
|
|
|
|
resp->opcnt = 0;
|
|
|
|
resp->rqstp = rqstp;
|
2009-04-03 05:28:53 +00:00
|
|
|
resp->cstate.minorversion = args->minorversion;
|
2009-03-28 08:30:52 +00:00
|
|
|
resp->cstate.replay_owner = NULL;
|
2010-04-24 19:35:43 +00:00
|
|
|
resp->cstate.session = NULL;
|
2009-03-28 08:30:52 +00:00
|
|
|
fh_init(&resp->cstate.current_fh, NFS4_FHSIZE);
|
|
|
|
fh_init(&resp->cstate.save_fh, NFS4_FHSIZE);
|
2010-08-12 07:04:07 +00:00
|
|
|
/*
|
|
|
|
* Don't use the deferral mechanism for NFSv4; compounds make it
|
|
|
|
* too hard to avoid non-idempotency problems.
|
|
|
|
*/
|
|
|
|
rqstp->rq_usedeferral = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* According to RFC3010, this takes precedence over all other errors.
|
|
|
|
*/
|
|
|
|
status = nfserr_minor_vers_mismatch;
|
2009-04-03 05:28:59 +00:00
|
|
|
if (args->minorversion > nfsd_supported_minorversion)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
|
2010-04-21 16:27:19 +00:00
|
|
|
status = nfs41_check_op_ordering(args);
|
|
|
|
if (status) {
|
2009-04-03 05:28:12 +00:00
|
|
|
op = &args->ops[0];
|
2010-04-21 16:27:19 +00:00
|
|
|
op->status = status;
|
2009-04-03 05:28:12 +00:00
|
|
|
goto encode_op;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
while (!status && resp->opcnt < args->opcnt) {
|
|
|
|
op = &args->ops[resp->opcnt++];
|
|
|
|
|
2008-07-02 08:15:03 +00:00
|
|
|
dprintk("nfsv4 compound op #%d/%d: %d (%s)\n",
|
|
|
|
resp->opcnt, args->opcnt, op->opnum,
|
|
|
|
nfsd4_op_name(op->opnum));
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The XDR decode routines may have pre-set op->status;
|
|
|
|
* for example, if there is a miscellaneous XDR error
|
|
|
|
* it will be set to nfserr_bad_xdr.
|
|
|
|
*/
|
|
|
|
if (op->status)
|
|
|
|
goto encode_op;
|
|
|
|
|
|
|
|
/* We must be able to encode a successful response to
|
|
|
|
* this operation, with enough room left over to encode a
|
|
|
|
* failed response to the next operation. If we don't
|
|
|
|
* have enough room, fail with ERR_RESOURCE.
|
|
|
|
*/
|
2006-12-13 08:35:20 +00:00
|
|
|
slack_bytes = (char *)resp->end - (char *)resp->p;
|
|
|
|
if (slack_bytes < COMPOUND_SLACK_SPACE
|
|
|
|
+ COMPOUND_ERR_SLACK_SPACE) {
|
|
|
|
BUG_ON(slack_bytes < COMPOUND_ERR_SLACK_SPACE);
|
2005-04-16 22:20:36 +00:00
|
|
|
op->status = nfserr_resource;
|
|
|
|
goto encode_op;
|
|
|
|
}
|
|
|
|
|
2011-04-09 15:23:24 +00:00
|
|
|
opdesc = OPDESC(op);
|
2006-12-13 08:35:38 +00:00
|
|
|
|
2006-12-13 08:35:27 +00:00
|
|
|
if (!cstate->current_fh.fh_dentry) {
|
2006-12-13 08:35:43 +00:00
|
|
|
if (!(opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
|
2006-10-04 09:16:20 +00:00
|
|
|
op->status = nfserr_nofilehandle;
|
|
|
|
goto encode_op;
|
|
|
|
}
|
2006-12-13 08:35:39 +00:00
|
|
|
} else if (cstate->current_fh.fh_export->ex_fslocs.migrated &&
|
|
|
|
!(opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {
|
2006-10-04 09:16:20 +00:00
|
|
|
op->status = nfserr_moved;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto encode_op;
|
|
|
|
}
|
2006-12-13 08:35:38 +00:00
|
|
|
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
/* If op is non-idempotent */
|
|
|
|
if (opdesc->op_flags & OP_MODIFIES_SOMETHING) {
|
|
|
|
plen = opdesc->op_rsize_bop(rqstp, op);
|
|
|
|
op->status = nfsd4_check_resp_size(resp, plen);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (op->status)
|
|
|
|
goto encode_op;
|
|
|
|
|
2012-02-13 21:55:24 +00:00
|
|
|
if (opdesc->op_func) {
|
|
|
|
if (opdesc->op_get_currentstateid)
|
|
|
|
opdesc->op_get_currentstateid(cstate, &op->u);
|
2006-12-13 08:35:38 +00:00
|
|
|
op->status = opdesc->op_func(rqstp, cstate, &op->u);
|
2012-02-13 21:55:24 +00:00
|
|
|
} else
|
2005-04-16 22:20:36 +00:00
|
|
|
BUG_ON(op->status == nfs_ok);
|
|
|
|
|
2012-02-13 21:55:24 +00:00
|
|
|
if (!op->status) {
|
|
|
|
if (opdesc->op_set_currentstateid)
|
|
|
|
opdesc->op_set_currentstateid(cstate, &op->u);
|
|
|
|
|
|
|
|
if (opdesc->op_flags & OP_CLEAR_STATEID)
|
2012-02-13 21:55:32 +00:00
|
|
|
clear_current_stateid(cstate);
|
2012-02-13 21:55:24 +00:00
|
|
|
|
|
|
|
if (need_wrongsec_check(rqstp))
|
|
|
|
op->status = check_nfsd_access(cstate->current_fh.fh_export, rqstp);
|
|
|
|
}
|
2011-04-08 21:00:50 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
encode_op:
|
2009-07-23 23:02:16 +00:00
|
|
|
/* Only from SEQUENCE */
|
2009-04-03 05:28:22 +00:00
|
|
|
if (resp->cstate.status == nfserr_replay_cache) {
|
|
|
|
dprintk("%s NFS4.1 replay from cache\n", __func__);
|
2009-07-23 23:02:18 +00:00
|
|
|
status = op->status;
|
2009-04-03 05:28:22 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2006-10-20 06:29:03 +00:00
|
|
|
if (op->status == nfserr_replay_me) {
|
2006-12-13 08:35:28 +00:00
|
|
|
op->replay = &cstate->replay_owner->so_replay;
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_encode_replay(resp, op);
|
|
|
|
status = op->status = op->replay->rp_status;
|
|
|
|
} else {
|
|
|
|
nfsd4_encode_operation(resp, op);
|
|
|
|
status = op->status;
|
|
|
|
}
|
2008-12-15 17:40:49 +00:00
|
|
|
|
|
|
|
dprintk("nfsv4 compound op %p opcnt %d #%d: %d: status %d\n",
|
|
|
|
args->ops, args->opcnt, resp->opcnt, op->opnum,
|
|
|
|
be32_to_cpu(status));
|
|
|
|
|
2006-12-13 08:35:28 +00:00
|
|
|
if (cstate->replay_owner) {
|
2011-08-30 21:02:48 +00:00
|
|
|
nfs4_unlock_state();
|
2006-12-13 08:35:28 +00:00
|
|
|
cstate->replay_owner = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-06-24 05:03:13 +00:00
|
|
|
/* XXX Ugh, we need to get rid of this kind of special case: */
|
|
|
|
if (op->opnum == OP_READ && op->u.read.rd_filp)
|
|
|
|
fput(op->u.read.rd_filp);
|
2006-07-10 11:45:44 +00:00
|
|
|
|
|
|
|
nfsd4_increment_op_stats(op->opnum);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-04-03 05:28:22 +00:00
|
|
|
resp->cstate.status = status;
|
2009-03-28 08:30:52 +00:00
|
|
|
fh_put(&resp->cstate.current_fh);
|
|
|
|
fh_put(&resp->cstate.save_fh);
|
|
|
|
BUG_ON(resp->cstate.replay_owner);
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
2009-04-03 05:27:32 +00:00
|
|
|
/* Reset deferral mechanism for RPC deferrals */
|
|
|
|
rqstp->rq_usedeferral = 1;
|
2008-05-05 21:17:44 +00:00
|
|
|
dprintk("nfsv4 compound returned %d\n", ntohl(status));
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
#define op_encode_hdr_size (2)
|
|
|
|
#define op_encode_stateid_maxsz (XDR_QUADLEN(NFS4_STATEID_SIZE))
|
|
|
|
#define op_encode_verifier_maxsz (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
|
|
|
|
#define op_encode_change_info_maxsz (5)
|
|
|
|
#define nfs4_fattr_bitmap_maxsz (4)
|
|
|
|
|
|
|
|
#define op_encode_lockowner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
|
|
|
|
#define op_encode_lock_denied_maxsz (8 + op_encode_lockowner_maxsz)
|
|
|
|
|
|
|
|
#define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
|
|
|
|
|
|
|
|
#define op_encode_ace_maxsz (3 + nfs4_owner_maxsz)
|
|
|
|
#define op_encode_delegation_maxsz (1 + op_encode_stateid_maxsz + 1 + \
|
|
|
|
op_encode_ace_maxsz)
|
|
|
|
|
|
|
|
#define op_encode_channel_attrs_maxsz (6 + 1 + 1)
|
|
|
|
|
|
|
|
static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_change_info_maxsz
|
|
|
|
+ nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_change_info_maxsz)
|
|
|
|
* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_lock_denied_maxsz)
|
|
|
|
* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_stateid_maxsz
|
|
|
|
+ op_encode_change_info_maxsz + 1
|
|
|
|
+ nfs4_fattr_bitmap_maxsz
|
|
|
|
+ op_encode_delegation_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
u32 maxcount = 0, rlen = 0;
|
|
|
|
|
|
|
|
maxcount = svc_max_payload(rqstp);
|
|
|
|
rlen = op->u.read.rd_length;
|
|
|
|
|
|
|
|
if (rlen > maxcount)
|
|
|
|
rlen = maxcount;
|
|
|
|
|
|
|
|
return (op_encode_hdr_size + 2) * sizeof(__be32) + rlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
u32 rlen = op->u.readdir.rd_maxcount;
|
|
|
|
|
|
|
|
if (rlen > PAGE_SIZE)
|
|
|
|
rlen = PAGE_SIZE;
|
|
|
|
|
|
|
|
return (op_encode_hdr_size + op_encode_verifier_maxsz)
|
|
|
|
* sizeof(__be32) + rlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_change_info_maxsz)
|
|
|
|
* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_change_info_maxsz
|
|
|
|
+ op_encode_change_info_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + 2 + 1024) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\
|
|
|
|
1 + 1 + 0 + /* eir_flags, spr_how, SP4_NONE (for now) */\
|
|
|
|
2 + /*eir_server_owner.so_minor_id */\
|
|
|
|
/* eir_server_owner.so_major_id<> */\
|
|
|
|
XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
|
|
|
|
/* eir_server_scope<> */\
|
|
|
|
XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
|
|
|
|
1 + /* eir_server_impl_id array length */\
|
|
|
|
0 /* ignored eir_server_impl_id contents */) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + \
|
|
|
|
XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\
|
|
|
|
2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + \
|
|
|
|
XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\
|
|
|
|
2 + /* csr_sequence, csr_flags */\
|
|
|
|
op_encode_channel_attrs_maxsz + \
|
|
|
|
op_encode_channel_attrs_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2009-03-28 08:32:05 +00:00
|
|
|
static struct nfsd4_operation nfsd4_ops[] = {
|
2006-12-13 08:35:38 +00:00
|
|
|
[OP_ACCESS] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_access,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_ACCESS",
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_CLOSE] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_close,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_CLOSE",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
|
2012-02-13 21:55:24 +00:00
|
|
|
.op_get_currentstateid = (stateid_getter)nfsd4_get_closestateid,
|
|
|
|
.op_set_currentstateid = (stateid_setter)nfsd4_set_closestateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_COMMIT] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_commit,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_COMMIT",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_commit_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_CREATE] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_create,
|
2012-02-13 21:55:29 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_CREATE",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_create_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_DELEGRETURN] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_delegreturn,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_DELEGRETURN",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2012-02-13 21:55:31 +00:00
|
|
|
.op_get_currentstateid = (stateid_getter)nfsd4_get_delegreturnstateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_GETATTR] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_getattr,
|
2006-12-13 08:35:39 +00:00
|
|
|
.op_flags = ALLOWED_ON_ABSENT_FS,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_GETATTR",
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_GETFH] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_getfh,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_GETFH",
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LINK] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_link,
|
2011-09-20 12:49:51 +00:00
|
|
|
.op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING
|
|
|
|
| OP_CACHEME,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_LINK",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_link_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LOCK] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_lock,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_LOCK",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_lock_rsize,
|
2012-02-13 21:55:25 +00:00
|
|
|
.op_set_currentstateid = (stateid_setter)nfsd4_set_lockstateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LOCKT] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_lockt,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_LOCKT",
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LOCKU] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_locku,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_LOCKU",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
|
2012-02-13 21:55:25 +00:00
|
|
|
.op_get_currentstateid = (stateid_getter)nfsd4_get_lockustateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LOOKUP] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_lookup,
|
2012-02-13 21:55:29 +00:00
|
|
|
.op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_LOOKUP",
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LOOKUPP] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_lookupp,
|
2012-02-13 21:55:29 +00:00
|
|
|
.op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_LOOKUPP",
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_NVERIFY] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_nverify,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_NVERIFY",
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_OPEN] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_open,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_OPEN",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_open_rsize,
|
2012-02-13 21:55:24 +00:00
|
|
|
.op_set_currentstateid = (stateid_setter)nfsd4_set_openstateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_OPEN_CONFIRM] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_open_confirm,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_OPEN_CONFIRM",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_OPEN_DOWNGRADE] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_open_downgrade,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_OPEN_DOWNGRADE",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
|
2012-02-13 21:55:31 +00:00
|
|
|
.op_get_currentstateid = (stateid_getter)nfsd4_get_opendowngradestateid,
|
|
|
|
.op_set_currentstateid = (stateid_setter)nfsd4_set_opendowngradestateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_PUTFH] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_putfh,
|
2011-04-08 21:00:50 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
|
2012-02-13 21:55:27 +00:00
|
|
|
| OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING
|
|
|
|
| OP_CLEAR_STATEID,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_PUTFH",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
2006-12-13 08:35:39 +00:00
|
|
|
[OP_PUTPUBFH] = {
|
2009-03-09 16:17:29 +00:00
|
|
|
.op_func = (nfsd4op_func)nfsd4_putrootfh,
|
2011-04-08 21:00:50 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
|
2012-02-13 21:55:27 +00:00
|
|
|
| OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING
|
|
|
|
| OP_CLEAR_STATEID,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_PUTPUBFH",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
2006-12-13 08:35:39 +00:00
|
|
|
},
|
2006-12-13 08:35:38 +00:00
|
|
|
[OP_PUTROOTFH] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_putrootfh,
|
2011-04-08 21:00:50 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
|
2012-02-13 21:55:27 +00:00
|
|
|
| OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING
|
|
|
|
| OP_CLEAR_STATEID,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_PUTROOTFH",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_READ] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_read,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_READ",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_read_rsize,
|
2012-02-13 21:55:26 +00:00
|
|
|
.op_get_currentstateid = (stateid_getter)nfsd4_get_readstateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_READDIR] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_readdir,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_READDIR",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_readdir_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_READLINK] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_readlink,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_READLINK",
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_REMOVE] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_remove,
|
2011-09-20 12:49:51 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_REMOVE",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_remove_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_RENAME] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_rename,
|
2011-09-20 12:49:51 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_name = "OP_RENAME",
|
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_rename_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_RENEW] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_renew,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
|
|
|
|
| OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_RENEW",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
|
|
|
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_RESTOREFH] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_restorefh,
|
2011-04-08 21:00:50 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
| OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_RESTOREFH",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_SAVEFH] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_savefh,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_SAVEFH",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
2007-07-17 11:04:51 +00:00
|
|
|
[OP_SECINFO] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_secinfo,
|
2011-04-08 21:00:50 +00:00
|
|
|
.op_flags = OP_HANDLES_WRONGSEC,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_SECINFO",
|
2007-07-17 11:04:51 +00:00
|
|
|
},
|
2006-12-13 08:35:38 +00:00
|
|
|
[OP_SETATTR] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_setattr,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_SETATTR",
|
2011-09-20 12:49:51 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_setattr_rsize,
|
2012-02-13 21:55:30 +00:00
|
|
|
.op_get_currentstateid = (stateid_getter)nfsd4_get_setattrstateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_SETCLIENTID] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_setclientid,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
|
2011-09-20 12:49:51 +00:00
|
|
|
| OP_MODIFIES_SOMETHING | OP_CACHEME,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_SETCLIENTID",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_setclientid_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_SETCLIENTID_CONFIRM] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_setclientid_confirm,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
|
2011-09-20 12:49:51 +00:00
|
|
|
| OP_MODIFIES_SOMETHING | OP_CACHEME,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_SETCLIENTID_CONFIRM",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_VERIFY] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_verify,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_VERIFY",
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_WRITE] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_write,
|
2011-09-20 12:49:51 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_WRITE",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_write_rsize,
|
2012-02-13 21:55:26 +00:00
|
|
|
.op_get_currentstateid = (stateid_getter)nfsd4_get_writestateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_RELEASE_LOCKOWNER] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_release_lockowner,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
|
|
|
|
| OP_MODIFIES_SOMETHING,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_RELEASE_LOCKOWNER",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
2009-04-03 05:27:58 +00:00
|
|
|
|
|
|
|
/* NFSv4.1 operations */
|
|
|
|
[OP_EXCHANGE_ID] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_exchange_id,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
|
|
|
|
| OP_MODIFIES_SOMETHING,
|
2009-04-03 05:27:58 +00:00
|
|
|
.op_name = "OP_EXCHANGE_ID",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_exchange_id_rsize,
|
2009-04-03 05:27:58 +00:00
|
|
|
},
|
2010-10-05 03:12:59 +00:00
|
|
|
[OP_BIND_CONN_TO_SESSION] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_bind_conn_to_session,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
|
|
|
|
| OP_MODIFIES_SOMETHING,
|
2010-10-05 03:12:59 +00:00
|
|
|
.op_name = "OP_BIND_CONN_TO_SESSION",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_bind_conn_to_session_rsize,
|
2010-10-05 03:12:59 +00:00
|
|
|
},
|
2009-04-03 05:27:58 +00:00
|
|
|
[OP_CREATE_SESSION] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_create_session,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
|
|
|
|
| OP_MODIFIES_SOMETHING,
|
2009-04-03 05:27:58 +00:00
|
|
|
.op_name = "OP_CREATE_SESSION",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_create_session_rsize,
|
2009-04-03 05:27:58 +00:00
|
|
|
},
|
|
|
|
[OP_DESTROY_SESSION] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_destroy_session,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
|
|
|
|
| OP_MODIFIES_SOMETHING,
|
2009-04-03 05:27:58 +00:00
|
|
|
.op_name = "OP_DESTROY_SESSION",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
2009-04-03 05:27:58 +00:00
|
|
|
},
|
|
|
|
[OP_SEQUENCE] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_sequence,
|
2009-04-03 05:28:12 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
|
2009-04-03 05:27:58 +00:00
|
|
|
.op_name = "OP_SEQUENCE",
|
|
|
|
},
|
2011-06-16 15:39:10 +00:00
|
|
|
[OP_DESTROY_CLIENTID] = {
|
2011-10-20 09:51:39 +00:00
|
|
|
.op_func = (nfsd4op_func)nfsd4_destroy_clientid,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
|
|
|
|
| OP_MODIFIES_SOMETHING,
|
2011-06-16 15:39:10 +00:00
|
|
|
.op_name = "OP_DESTROY_CLIENTID",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
2011-06-16 15:39:10 +00:00
|
|
|
},
|
2010-04-19 19:11:28 +00:00
|
|
|
[OP_RECLAIM_COMPLETE] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_reclaim_complete,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
|
2010-04-19 19:11:28 +00:00
|
|
|
.op_name = "OP_RECLAIM_COMPLETE",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
2010-04-19 19:11:28 +00:00
|
|
|
},
|
2010-12-16 14:51:13 +00:00
|
|
|
[OP_SECINFO_NO_NAME] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_secinfo_no_name,
|
2011-04-08 21:00:50 +00:00
|
|
|
.op_flags = OP_HANDLES_WRONGSEC,
|
2010-12-16 14:51:13 +00:00
|
|
|
.op_name = "OP_SECINFO_NO_NAME",
|
|
|
|
},
|
2011-07-13 14:50:48 +00:00
|
|
|
[OP_TEST_STATEID] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_test_stateid,
|
|
|
|
.op_flags = ALLOWED_WITHOUT_FH,
|
|
|
|
.op_name = "OP_TEST_STATEID",
|
|
|
|
},
|
2011-07-13 15:04:21 +00:00
|
|
|
[OP_FREE_STATEID] = {
|
|
|
|
.op_func = (nfsd4op_func)nfsd4_free_stateid,
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
|
2011-07-13 15:04:21 +00:00
|
|
|
.op_name = "OP_FREE_STATEID",
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
.op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
|
2011-07-13 15:04:21 +00:00
|
|
|
},
|
2006-12-13 08:35:38 +00:00
|
|
|
};
|
|
|
|
|
2012-03-20 19:11:17 +00:00
|
|
|
#ifdef NFSD_DEBUG
|
2008-08-08 16:26:42 +00:00
|
|
|
static const char *nfsd4_op_name(unsigned opnum)
|
2008-07-02 08:15:03 +00:00
|
|
|
{
|
|
|
|
if (opnum < ARRAY_SIZE(nfsd4_ops))
|
|
|
|
return nfsd4_ops[opnum].op_name;
|
|
|
|
return "unknown_operation";
|
|
|
|
}
|
2012-03-20 19:11:17 +00:00
|
|
|
#endif
|
2008-07-02 08:15:03 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define nfsd4_voidres nfsd4_voidargs
|
|
|
|
struct nfsd4_voidargs { int dummy; };
|
|
|
|
|
|
|
|
static struct svc_procedure nfsd_procedures4[2] = {
|
2009-05-19 06:09:54 +00:00
|
|
|
[NFSPROC4_NULL] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd4_proc_null,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs4svc_encode_voidres,
|
|
|
|
.pc_argsize = sizeof(struct nfsd4_voidargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd4_voidres),
|
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = 1,
|
|
|
|
},
|
|
|
|
[NFSPROC4_COMPOUND] = {
|
|
|
|
.pc_func = (svc_procfunc) nfsd4_proc_compound,
|
|
|
|
.pc_decode = (kxdrproc_t) nfs4svc_decode_compoundargs,
|
|
|
|
.pc_encode = (kxdrproc_t) nfs4svc_encode_compoundres,
|
|
|
|
.pc_argsize = sizeof(struct nfsd4_compoundargs),
|
|
|
|
.pc_ressize = sizeof(struct nfsd4_compoundres),
|
2011-07-16 21:15:10 +00:00
|
|
|
.pc_release = nfsd4_release_compoundargs,
|
2009-05-19 06:09:54 +00:00
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = NFSD_BUFSIZE/4,
|
|
|
|
},
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct svc_version nfsd_version4 = {
|
|
|
|
.vs_vers = 4,
|
|
|
|
.vs_nproc = 2,
|
|
|
|
.vs_proc = nfsd_procedures4,
|
|
|
|
.vs_dispatch = nfsd_dispatch,
|
|
|
|
.vs_xdrsize = NFS4_SVC_XDRSIZE,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Local variables:
|
|
|
|
* c-basic-offset: 8
|
|
|
|
* End:
|
|
|
|
*/
|