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.
|
|
|
|
*/
|
2018-03-21 21:19:02 +00:00
|
|
|
#include <linux/fs_struct.h>
|
2005-06-24 05:03:13 +00:00
|
|
|
#include <linux/file.h>
|
2014-11-07 19:44:27 +00:00
|
|
|
#include <linux/falloc.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>
|
2018-07-20 22:19:20 +00:00
|
|
|
#include <linux/kthread.h>
|
2022-03-28 18:47:34 +00:00
|
|
|
#include <linux/namei.h>
|
|
|
|
|
2019-10-04 20:34:26 +00:00
|
|
|
#include <linux/sunrpc/addr.h>
|
2020-10-19 03:42:49 +00:00
|
|
|
#include <linux/nfs_ssc.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"
|
2012-11-14 15:22:07 +00:00
|
|
|
#include "netns.h"
|
2013-12-20 13:16:55 +00:00
|
|
|
#include "acl.h"
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
#include "pnfs.h"
|
2014-08-17 00:02:22 +00:00
|
|
|
#include "trace.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-12-18 17:28:23 +00:00
|
|
|
static bool inter_copy_offload_enable;
|
|
|
|
module_param(inter_copy_offload_enable, bool, 0644);
|
|
|
|
MODULE_PARM_DESC(inter_copy_offload_enable,
|
|
|
|
"Enable inter server to server copy offload. Default: false");
|
|
|
|
|
2021-05-21 19:09:37 +00:00
|
|
|
#ifdef CONFIG_NFSD_V4_2_INTER_SSC
|
|
|
|
static int nfsd4_ssc_umount_timeout = 900000; /* default to 15 mins */
|
|
|
|
module_param(nfsd4_ssc_umount_timeout, int, 0644);
|
|
|
|
MODULE_PARM_DESC(nfsd4_ssc_umount_timeout,
|
|
|
|
"idle msecs before unmount export from source server");
|
|
|
|
#endif
|
|
|
|
|
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;
|
2017-01-03 17:30:11 +00:00
|
|
|
struct svc_export *exp = cstate->current_fh.fh_export;
|
2009-05-16 08:22:31 +00:00
|
|
|
|
2016-10-18 18:18:40 +00:00
|
|
|
if (!nfsd_attrs_supported(cstate->minorversion, bmval))
|
2009-05-16 08:22:31 +00:00
|
|
|
return nfserr_attrnotsupp;
|
2016-10-18 18:18:40 +00:00
|
|
|
if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry)))
|
|
|
|
return nfserr_attrnotsupp;
|
2017-01-03 17:30:11 +00:00
|
|
|
if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) &&
|
|
|
|
!(exp->ex_flags & NFSEXP_SECURITY_LABEL))
|
|
|
|
return nfserr_attrnotsupp;
|
2016-10-18 18:18:40 +00:00
|
|
|
if (writable && !bmval_is_subset(bmval, writable))
|
|
|
|
return nfserr_inval;
|
2016-01-12 19:24:14 +00:00
|
|
|
if (writable && (bmval[2] & FATTR4_WORD2_MODE_UMASK) &&
|
|
|
|
(bmval[1] & FATTR4_WORD1_MODE))
|
|
|
|
return nfserr_inval;
|
2009-05-16 08:22:31 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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)
|
2014-06-10 14:06:44 +00:00
|
|
|
exp_get(src->fh_export);
|
2005-04-16 22:20:36 +00:00
|
|
|
*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
|
|
|
{
|
|
|
|
|
|
|
|
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
|
|
|
|
2022-08-31 14:20:02 +00:00
|
|
|
return fh_verify(rqstp, current_fh, S_IFREG, accmode);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-08-15 20:55:02 +00:00
|
|
|
static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
|
|
|
|
{
|
2015-03-17 22:25:59 +00:00
|
|
|
umode_t mode = d_inode(fh->fh_dentry)->i_mode;
|
2011-08-15 20:55:02 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-03-22 22:03:49 +00:00
|
|
|
static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh)
|
|
|
|
{
|
|
|
|
if (nfsd4_has_session(cstate))
|
|
|
|
return;
|
|
|
|
fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
|
|
|
|
&resfh->fh_handle);
|
|
|
|
}
|
|
|
|
|
2022-03-28 18:47:34 +00:00
|
|
|
static inline bool nfsd4_create_is_exclusive(int createmode)
|
|
|
|
{
|
|
|
|
return createmode == NFS4_CREATE_EXCLUSIVE ||
|
|
|
|
createmode == NFS4_CREATE_EXCLUSIVE4_1;
|
|
|
|
}
|
|
|
|
|
2022-03-30 14:30:54 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_vfs_create(struct svc_fh *fhp, struct dentry *child,
|
|
|
|
struct nfsd4_open *open)
|
|
|
|
{
|
|
|
|
struct file *filp;
|
|
|
|
struct path path;
|
|
|
|
int oflags;
|
|
|
|
|
|
|
|
oflags = O_CREAT | O_LARGEFILE;
|
|
|
|
switch (open->op_share_access & NFS4_SHARE_ACCESS_BOTH) {
|
|
|
|
case NFS4_SHARE_ACCESS_WRITE:
|
|
|
|
oflags |= O_WRONLY;
|
|
|
|
break;
|
|
|
|
case NFS4_SHARE_ACCESS_BOTH:
|
|
|
|
oflags |= O_RDWR;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
oflags |= O_RDONLY;
|
|
|
|
}
|
|
|
|
|
|
|
|
path.mnt = fhp->fh_export->ex_path.mnt;
|
|
|
|
path.dentry = child;
|
|
|
|
filp = dentry_create(&path, oflags, open->op_iattr.ia_mode,
|
|
|
|
current_cred());
|
|
|
|
if (IS_ERR(filp))
|
|
|
|
return nfserrno(PTR_ERR(filp));
|
|
|
|
|
|
|
|
open->op_filp = filp;
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2022-03-28 18:47:34 +00:00
|
|
|
/*
|
|
|
|
* Implement NFSv4's unchecked, guarded, and exclusive create
|
|
|
|
* semantics for regular files. Open state for this new file is
|
|
|
|
* subsequently fabricated in nfsd4_process_open2().
|
|
|
|
*
|
|
|
|
* Upon return, caller must release @fhp and @resfhp.
|
|
|
|
*/
|
|
|
|
static __be32
|
|
|
|
nfsd4_create_file(struct svc_rqst *rqstp, struct svc_fh *fhp,
|
|
|
|
struct svc_fh *resfhp, struct nfsd4_open *open)
|
|
|
|
{
|
|
|
|
struct iattr *iap = &open->op_iattr;
|
2022-07-26 06:45:30 +00:00
|
|
|
struct nfsd_attrs attrs = {
|
|
|
|
.na_iattr = iap,
|
2022-07-26 06:45:30 +00:00
|
|
|
.na_seclabel = &open->op_label,
|
2022-07-26 06:45:30 +00:00
|
|
|
};
|
2022-03-28 18:47:34 +00:00
|
|
|
struct dentry *parent, *child;
|
|
|
|
__u32 v_mtime, v_atime;
|
|
|
|
struct inode *inode;
|
|
|
|
__be32 status;
|
|
|
|
int host_err;
|
|
|
|
|
|
|
|
if (isdotent(open->op_fname, open->op_fnamelen))
|
|
|
|
return nfserr_exist;
|
|
|
|
if (!(iap->ia_valid & ATTR_MODE))
|
|
|
|
iap->ia_mode = 0;
|
|
|
|
|
|
|
|
status = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
|
|
|
|
if (status != nfs_ok)
|
|
|
|
return status;
|
|
|
|
parent = fhp->fh_dentry;
|
|
|
|
inode = d_inode(parent);
|
|
|
|
|
|
|
|
host_err = fh_want_write(fhp);
|
|
|
|
if (host_err)
|
|
|
|
return nfserrno(host_err);
|
|
|
|
|
2022-07-26 06:45:30 +00:00
|
|
|
if (is_create_with_attrs(open))
|
|
|
|
nfsd4_acl_to_attr(NF4REG, open->op_acl, &attrs);
|
|
|
|
|
2022-07-26 06:45:30 +00:00
|
|
|
inode_lock_nested(inode, I_MUTEX_PARENT);
|
2022-03-28 18:47:34 +00:00
|
|
|
|
|
|
|
child = lookup_one_len(open->op_fname, parent, open->op_fnamelen);
|
|
|
|
if (IS_ERR(child)) {
|
|
|
|
status = nfserrno(PTR_ERR(child));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (d_really_is_negative(child)) {
|
|
|
|
status = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
|
|
|
|
if (status != nfs_ok)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = fh_compose(resfhp, fhp->fh_export, child, fhp);
|
|
|
|
if (status != nfs_ok)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
v_mtime = 0;
|
|
|
|
v_atime = 0;
|
|
|
|
if (nfsd4_create_is_exclusive(open->op_createmode)) {
|
|
|
|
u32 *verifier = (u32 *)open->op_verf.data;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Solaris 7 gets confused (bugid 4218508) if these have
|
|
|
|
* the high bit set, as do xfs filesystems without the
|
|
|
|
* "bigtime" feature. So just clear the high bits. If this
|
|
|
|
* is ever changed to use different attrs for storing the
|
|
|
|
* verifier, then do_open_lookup() will also need to be
|
|
|
|
* fixed accordingly.
|
|
|
|
*/
|
|
|
|
v_mtime = verifier[0] & 0x7fffffff;
|
|
|
|
v_atime = verifier[1] & 0x7fffffff;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (d_really_is_positive(child)) {
|
2022-07-26 06:45:30 +00:00
|
|
|
/* NFSv4 protocol requires change attributes even though
|
|
|
|
* no change happened.
|
|
|
|
*/
|
2023-07-21 14:29:10 +00:00
|
|
|
status = fh_fill_both_attrs(fhp);
|
|
|
|
if (status != nfs_ok)
|
|
|
|
goto out;
|
2022-07-26 06:45:30 +00:00
|
|
|
|
2022-03-28 18:47:34 +00:00
|
|
|
switch (open->op_createmode) {
|
|
|
|
case NFS4_CREATE_UNCHECKED:
|
|
|
|
if (!d_is_reg(child))
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In NFSv4, we don't want to truncate the file
|
|
|
|
* now. This would be wrong if the OPEN fails for
|
|
|
|
* some other reason. Furthermore, if the size is
|
|
|
|
* nonzero, we should ignore it according to spec!
|
|
|
|
*/
|
|
|
|
open->op_truncate = (iap->ia_valid & ATTR_SIZE) &&
|
|
|
|
!iap->ia_size;
|
|
|
|
break;
|
|
|
|
case NFS4_CREATE_GUARDED:
|
|
|
|
status = nfserr_exist;
|
|
|
|
break;
|
|
|
|
case NFS4_CREATE_EXCLUSIVE:
|
|
|
|
if (d_inode(child)->i_mtime.tv_sec == v_mtime &&
|
|
|
|
d_inode(child)->i_atime.tv_sec == v_atime &&
|
|
|
|
d_inode(child)->i_size == 0) {
|
|
|
|
open->op_created = true;
|
|
|
|
break; /* subtle */
|
|
|
|
}
|
|
|
|
status = nfserr_exist;
|
|
|
|
break;
|
|
|
|
case NFS4_CREATE_EXCLUSIVE4_1:
|
|
|
|
if (d_inode(child)->i_mtime.tv_sec == v_mtime &&
|
|
|
|
d_inode(child)->i_atime.tv_sec == v_atime &&
|
|
|
|
d_inode(child)->i_size == 0) {
|
|
|
|
open->op_created = true;
|
|
|
|
goto set_attr; /* subtle */
|
|
|
|
}
|
|
|
|
status = nfserr_exist;
|
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!IS_POSIXACL(inode))
|
|
|
|
iap->ia_mode &= ~current_umask();
|
|
|
|
|
2023-07-21 14:29:10 +00:00
|
|
|
status = fh_fill_pre_attrs(fhp);
|
|
|
|
if (status != nfs_ok)
|
|
|
|
goto out;
|
2022-03-30 14:30:54 +00:00
|
|
|
status = nfsd4_vfs_create(fhp, child, open);
|
|
|
|
if (status != nfs_ok)
|
2022-03-28 18:47:34 +00:00
|
|
|
goto out;
|
|
|
|
open->op_created = true;
|
2022-07-26 06:45:30 +00:00
|
|
|
fh_fill_post_attrs(fhp);
|
2022-03-28 18:47:34 +00:00
|
|
|
|
|
|
|
/* A newly created file already has a file size of zero. */
|
|
|
|
if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0))
|
|
|
|
iap->ia_valid &= ~ATTR_SIZE;
|
|
|
|
if (nfsd4_create_is_exclusive(open->op_createmode)) {
|
|
|
|
iap->ia_valid = ATTR_MTIME | ATTR_ATIME |
|
|
|
|
ATTR_MTIME_SET|ATTR_ATIME_SET;
|
|
|
|
iap->ia_mtime.tv_sec = v_mtime;
|
|
|
|
iap->ia_atime.tv_sec = v_atime;
|
|
|
|
iap->ia_mtime.tv_nsec = 0;
|
|
|
|
iap->ia_atime.tv_nsec = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_attr:
|
2022-07-26 06:45:30 +00:00
|
|
|
status = nfsd_create_setattr(rqstp, fhp, resfhp, &attrs);
|
2022-03-28 18:47:34 +00:00
|
|
|
|
2022-07-26 06:45:30 +00:00
|
|
|
if (attrs.na_labelerr)
|
|
|
|
open->op_bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
|
2022-07-26 06:45:30 +00:00
|
|
|
if (attrs.na_aclerr)
|
|
|
|
open->op_bmval[0] &= ~FATTR4_WORD0_ACL;
|
2022-03-28 18:47:34 +00:00
|
|
|
out:
|
2022-07-26 06:45:30 +00:00
|
|
|
inode_unlock(inode);
|
2022-07-26 06:45:30 +00:00
|
|
|
nfsd_attrs_free(&attrs);
|
2022-03-28 18:47:34 +00:00
|
|
|
if (child && !IS_ERR(child))
|
|
|
|
dput(child);
|
|
|
|
fh_drop_write(fhp);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2023-07-21 14:29:11 +00:00
|
|
|
/**
|
|
|
|
* set_change_info - set up the change_info4 for a reply
|
|
|
|
* @cinfo: pointer to nfsd4_change_info to be populated
|
|
|
|
* @fhp: pointer to svc_fh to use as source
|
|
|
|
*
|
|
|
|
* Many operations in NFSv4 require change_info4 in the reply. This function
|
|
|
|
* populates that from the info that we (should!) have already collected. In
|
|
|
|
* the event that we didn't get any pre-attrs, just zero out both.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp)
|
|
|
|
{
|
|
|
|
cinfo->atomic = (u32)(fhp->fh_pre_saved && fhp->fh_post_saved && !fhp->fh_no_atomic_attr);
|
|
|
|
cinfo->before_change = fhp->fh_pre_change;
|
|
|
|
cinfo->after_change = fhp->fh_post_change;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If fetching the pre-change attributes failed, then we should
|
|
|
|
* have already failed the whole operation. We could have still
|
|
|
|
* failed to fetch post-change attributes however.
|
|
|
|
*
|
|
|
|
* If we didn't get post-op attrs, just zero-out the after
|
|
|
|
* field since we don't know what it should be. If the pre_saved
|
|
|
|
* field isn't set for some reason, throw warning and just copy
|
|
|
|
* whatever is in the after field.
|
|
|
|
*/
|
|
|
|
if (WARN_ON_ONCE(!fhp->fh_pre_saved))
|
|
|
|
cinfo->before_change = 0;
|
|
|
|
if (!fhp->fh_post_saved)
|
2023-07-24 14:53:39 +00:00
|
|
|
cinfo->after_change = cinfo->before_change + 1;
|
2023-07-21 14:29:11 +00:00
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2012-01-27 22:26:06 +00:00
|
|
|
do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh **resfh)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-03-22 22:03:49 +00:00
|
|
|
struct svc_fh *current_fh = &cstate->current_fh;
|
2012-12-07 20:40:55 +00:00
|
|
|
int accmode;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-01-27 22:26:06 +00:00
|
|
|
*resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
|
|
|
|
if (!*resfh)
|
2012-01-27 21:49:55 +00:00
|
|
|
return nfserr_jukebox;
|
2012-01-27 22:26:06 +00:00
|
|
|
fh_init(*resfh, NFS4_FHSIZE);
|
2019-12-25 03:19:35 +00:00
|
|
|
open->op_truncate = false;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
|
2018-03-21 21:19:02 +00:00
|
|
|
current->fs->umask = open->op_umask;
|
2022-03-28 18:47:34 +00:00
|
|
|
status = nfsd4_create_file(rqstp, current_fh, *resfh, open);
|
2018-03-21 21:19:02 +00:00
|
|
|
current->fs->umask = 0;
|
2007-07-31 07:37:51 +00:00
|
|
|
|
2009-02-02 20:12:27 +00:00
|
|
|
/*
|
2015-07-30 13:55:02 +00:00
|
|
|
* Following rfc 3530 14.2.16, and rfc 5661 18.16.4
|
|
|
|
* use the returned bitmask to indicate which attributes
|
|
|
|
* we used to store the verifier:
|
2007-07-31 07:37:51 +00:00
|
|
|
*/
|
2022-03-28 18:47:34 +00:00
|
|
|
if (nfsd4_create_is_exclusive(open->op_createmode) && status == 0)
|
2015-07-30 13:55:02 +00:00
|
|
|
open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS |
|
|
|
|
FATTR4_WORD1_TIME_MODIFY);
|
2022-07-26 06:45:30 +00:00
|
|
|
} else {
|
2005-04-16 22:20:36 +00:00
|
|
|
status = nfsd_lookup(rqstp, current_fh,
|
2020-11-16 22:45:04 +00:00
|
|
|
open->op_fname, open->op_fnamelen, *resfh);
|
2023-07-21 14:29:10 +00:00
|
|
|
if (status == nfs_ok)
|
2022-07-26 06:45:30 +00:00
|
|
|
/* NFSv4 protocol requires change attributes even though
|
|
|
|
* no change happened.
|
|
|
|
*/
|
2023-07-21 14:29:10 +00:00
|
|
|
status = fh_fill_both_attrs(current_fh);
|
2022-07-26 06:45:30 +00:00
|
|
|
}
|
2012-04-09 22:06:49 +00:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2012-01-27 22:26:06 +00:00
|
|
|
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
|
|
|
|
2012-01-27 22:26:06 +00:00
|
|
|
nfsd4_set_open_owner_reply_cache(cstate, open, *resfh);
|
2012-12-07 20:40:55 +00:00
|
|
|
accmode = NFSD_MAY_NOP;
|
2013-06-19 19:47:37 +00:00
|
|
|
if (open->op_created ||
|
|
|
|
open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
|
2012-12-07 20:40:55 +00:00
|
|
|
accmode |= NFSD_MAY_OWNER_OVERRIDE;
|
2012-01-27 22:26:06 +00:00
|
|
|
status = do_open_permission(rqstp, *resfh, open, accmode);
|
2012-01-27 21:26:02 +00:00
|
|
|
set_change_info(&open->op_cinfo, current_fh);
|
2006-11-09 01:44:39 +00:00
|
|
|
out:
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2013-03-22 22:03:49 +00:00
|
|
|
do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-03-22 22:03:49 +00:00
|
|
|
struct svc_fh *current_fh = &cstate->current_fh;
|
2013-05-03 20:09:09 +00:00
|
|
|
int accmode = 0;
|
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));
|
|
|
|
|
2013-03-22 22:03:49 +00:00
|
|
|
nfsd4_set_open_owner_reply_cache(cstate, open, current_fh);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
|
|
|
|
(open->op_iattr.ia_size == 0);
|
2013-05-03 20:09:09 +00:00
|
|
|
/*
|
|
|
|
* In the delegation case, the client is telling us about an
|
|
|
|
* open that it *already* performed locally, some time ago. We
|
|
|
|
* should let it succeed now if possible.
|
|
|
|
*
|
|
|
|
* In the case of a CLAIM_FH open, on the other hand, the client
|
|
|
|
* may be counting on us to enforce permissions (the Linux 4.1
|
|
|
|
* client uses this for normal opens, for example).
|
|
|
|
*/
|
|
|
|
if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH)
|
|
|
|
accmode = NFSD_MAY_OWNER_OVERRIDE;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2022-08-31 14:20:02 +00:00
|
|
|
return do_open_permission(rqstp, current_fh, open, accmode);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_open *open = &u->open;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2012-01-27 22:26:06 +00:00
|
|
|
struct svc_fh *resfh = NULL;
|
2012-11-14 15:22:07 +00:00
|
|
|
struct net *net = SVC_NET(rqstp);
|
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2018-06-08 16:28:47 +00:00
|
|
|
bool reclaim = false;
|
2009-04-03 05:28:45 +00:00
|
|
|
|
2011-07-31 03:33:59 +00:00
|
|
|
dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",
|
2020-11-16 22:45:04 +00:00
|
|
|
(int)open->op_fnamelen, open->op_fname,
|
2011-07-31 03:33:59 +00:00
|
|
|
open->op_openowner);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2022-03-30 14:30:54 +00:00
|
|
|
open->op_filp = NULL;
|
2022-07-26 06:45:30 +00:00
|
|
|
open->op_rqstp = rqstp;
|
2022-03-30 14:30:54 +00:00
|
|
|
|
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;
|
|
|
|
|
2019-12-25 03:19:35 +00:00
|
|
|
open->op_created = false;
|
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) &&
|
2021-01-21 22:57:45 +00:00
|
|
|
!test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &cstate->clp->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
|
|
|
/* check seqid for replay. set nfs4_owner */
|
2015-07-13 09:32:05 +00:00
|
|
|
status = nfsd4_process_open1(cstate, open, nn);
|
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;
|
2013-02-28 20:51:49 +00:00
|
|
|
if (open->op_xdr_error) {
|
|
|
|
status = open->op_xdr_error;
|
|
|
|
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;
|
2015-08-06 16:47:02 +00:00
|
|
|
if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
|
2006-02-07 20:58:32 +00:00
|
|
|
goto out;
|
|
|
|
status = nfserr_no_grace;
|
2015-08-06 16:47:02 +00:00
|
|
|
if (!opens_in_grace(net) && 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) {
|
2022-03-21 20:41:32 +00:00
|
|
|
case NFS4_OPEN_CLAIM_DELEGATE_CUR:
|
|
|
|
case NFS4_OPEN_CLAIM_NULL:
|
|
|
|
status = do_open_lookup(rqstp, cstate, open, &resfh);
|
|
|
|
if (status)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
2022-03-21 20:41:32 +00:00
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CLAIM_PREVIOUS:
|
|
|
|
status = nfs4_check_open_reclaim(cstate->clp);
|
|
|
|
if (status)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
2022-03-21 20:41:32 +00:00
|
|
|
open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
|
|
|
|
reclaim = true;
|
|
|
|
fallthrough;
|
|
|
|
case NFS4_OPEN_CLAIM_FH:
|
|
|
|
case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
|
|
|
|
status = do_open_fhandle(rqstp, cstate, open);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
resfh = &cstate->current_fh;
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
|
|
|
|
case NFS4_OPEN_CLAIM_DELEGATE_PREV:
|
|
|
|
status = nfserr_notsupp;
|
|
|
|
goto out;
|
|
|
|
default:
|
|
|
|
status = nfserr_inval;
|
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2022-03-23 17:55:37 +00:00
|
|
|
|
2012-01-27 22:26:06 +00:00
|
|
|
status = nfsd4_process_open2(rqstp, resfh, open);
|
2022-07-08 18:23:45 +00:00
|
|
|
if (status && open->op_created)
|
|
|
|
pr_warn("nfsd4_process_open2 failed to open newly-created file: status=%u\n",
|
|
|
|
be32_to_cpu(status));
|
2018-06-08 16:28:47 +00:00
|
|
|
if (reclaim && !status)
|
|
|
|
nn->somebody_reclaimed = true;
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
2022-03-30 14:30:54 +00:00
|
|
|
if (open->op_filp) {
|
|
|
|
fput(open->op_filp);
|
|
|
|
open->op_filp = NULL;
|
|
|
|
}
|
2012-01-27 22:26:06 +00:00
|
|
|
if (resfh && resfh != &cstate->current_fh) {
|
|
|
|
fh_dup2(&cstate->current_fh, resfh);
|
|
|
|
fh_put(resfh);
|
|
|
|
kfree(resfh);
|
|
|
|
}
|
2015-03-23 14:53:44 +00:00
|
|
|
nfsd4_cleanup_open_state(cstate, open);
|
2013-04-01 20:37:12 +00:00
|
|
|
nfsd4_bump_seqid(cstate, status);
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2013-02-28 20:51:49 +00:00
|
|
|
/*
|
|
|
|
* OPEN is the only seqid-mutating operation whose decoding can fail
|
|
|
|
* with a seqid-mutating error (specifically, decoding of user names in
|
|
|
|
* the attributes). Therefore we have to do some processing to look up
|
|
|
|
* the stateowner so that we can bump the seqid.
|
|
|
|
*/
|
|
|
|
static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op)
|
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_open *open = &op->u.open;
|
2013-02-28 20:51:49 +00:00
|
|
|
|
|
|
|
if (!seqid_mutating_err(ntohl(op->status)))
|
|
|
|
return op->status;
|
|
|
|
if (nfsd4_has_session(cstate))
|
|
|
|
return op->status;
|
|
|
|
open->op_xdr_error = op->status;
|
2017-05-08 18:58:35 +00:00
|
|
|
return nfsd4_open(rqstp, cstate, &op->u);
|
2013-02-28 20:51:49 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
u->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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_putfh *putfh = &u->putfh;
|
2019-10-07 14:56:48 +00:00
|
|
|
__be32 ret;
|
2017-05-08 18:58:35 +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;
|
2021-09-02 01:16:32 +00:00
|
|
|
memcpy(&cstate->current_fh.fh_handle.fh_raw, putfh->pf_fhval,
|
2006-12-13 08:35:27 +00:00
|
|
|
putfh->pf_fhlen);
|
2019-10-07 14:56:48 +00:00
|
|
|
ret = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
|
|
|
|
#ifdef CONFIG_NFSD_V4_2_INTER_SSC
|
|
|
|
if (ret == nfserr_stale && putfh->no_verify) {
|
|
|
|
SET_FH_FLAG(&cstate->current_fh, NFSD4_FH_FOREIGN);
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return ret;
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-12-13 08:35:27 +00:00
|
|
|
fh_put(&cstate->current_fh);
|
2022-08-31 14:20:02 +00:00
|
|
|
|
|
|
|
return exp_pseudoroot(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:38 +00:00
|
|
|
nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
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);
|
2018-09-13 17:58:24 +00:00
|
|
|
if (HAS_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG)) {
|
2012-02-13 21:55:32 +00:00
|
|
|
memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));
|
2018-09-13 17:58:24 +00:00
|
|
|
SET_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);
|
2012-02-13 21:55:32 +00:00
|
|
|
}
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-12-13 08:35:27 +00:00
|
|
|
fh_dup2(&cstate->save_fh, &cstate->current_fh);
|
2018-09-13 17:58:24 +00:00
|
|
|
if (HAS_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG)) {
|
2012-02-13 21:55:32 +00:00
|
|
|
memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));
|
2018-09-13 17:58:24 +00:00
|
|
|
SET_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG);
|
2012-02-13 21:55:32 +00:00
|
|
|
}
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_access *access = &u->access;
|
2020-06-23 22:39:24 +00:00
|
|
|
u32 access_full;
|
2017-05-08 18:58:35 +00:00
|
|
|
|
2020-06-23 22:39:24 +00:00
|
|
|
access_full = NFS3_ACCESS_FULL;
|
|
|
|
if (cstate->minorversion >= 2)
|
|
|
|
access_full |= NFS4_ACCESS_XALIST | NFS4_ACCESS_XAREAD |
|
|
|
|
NFS4_ACCESS_XAWRITE;
|
|
|
|
|
|
|
|
if (access->ac_req_access & ~access_full)
|
2005-04-16 22:20:36 +00:00
|
|
|
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-12-06 11:23:19 +00:00
|
|
|
static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net)
|
2012-03-02 22:13:50 +00:00
|
|
|
{
|
2019-09-02 17:02:56 +00:00
|
|
|
__be32 *verf = (__be32 *)verifier->data;
|
2012-03-02 22:13:50 +00:00
|
|
|
|
2019-09-02 17:02:56 +00:00
|
|
|
BUILD_BUG_ON(2*sizeof(*verf) != sizeof(verifier->data));
|
|
|
|
|
2021-12-30 15:22:05 +00:00
|
|
|
nfsd_copy_write_verifier(verf, net_generic(net, nfsd_net_id));
|
2012-03-02 22:13:50 +00:00
|
|
|
}
|
|
|
|
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_commit *commit = &u->commit;
|
2022-10-28 14:46:38 +00:00
|
|
|
struct nfsd_file *nf;
|
|
|
|
__be32 status;
|
2017-05-08 18:58:35 +00:00
|
|
|
|
2022-10-28 14:46:38 +00:00
|
|
|
status = nfsd_file_acquire(rqstp, &cstate->current_fh, NFSD_MAY_WRITE |
|
|
|
|
NFSD_MAY_NOT_BREAK_LEASE, &nf);
|
|
|
|
if (status != nfs_ok)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
status = nfsd_commit(rqstp, &cstate->current_fh, nf, commit->co_offset,
|
2020-01-06 18:40:36 +00:00
|
|
|
commit->co_count,
|
|
|
|
(__be32 *)commit->co_verf.data);
|
2022-10-28 14:46:38 +00:00
|
|
|
nfsd_file_put(nf);
|
|
|
|
return status;
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_create *create = &u->create;
|
2022-07-26 06:45:30 +00:00
|
|
|
struct nfsd_attrs attrs = {
|
|
|
|
.na_iattr = &create->cr_iattr,
|
2022-07-26 06:45:30 +00:00
|
|
|
.na_seclabel = &create->cr_label,
|
2022-07-26 06:45:30 +00:00
|
|
|
};
|
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);
|
|
|
|
|
2016-07-21 20:00:12 +00:00
|
|
|
status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, 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, create->cr_bmval,
|
|
|
|
nfsd_attrmask);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
2022-07-26 06:45:30 +00:00
|
|
|
status = nfsd4_acl_to_attr(create->cr_type, create->cr_acl, &attrs);
|
2018-03-21 21:19:02 +00:00
|
|
|
current->fs->umask = create->cr_umask;
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (create->cr_type) {
|
|
|
|
case NF4LNK:
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_symlink(rqstp, &cstate->current_fh,
|
|
|
|
create->cr_name, create->cr_namelen,
|
2022-07-26 06:45:30 +00:00
|
|
|
create->cr_data, &attrs, &resfh);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NF4BLK:
|
2018-03-21 21:19:02 +00:00
|
|
|
status = nfserr_inval;
|
2005-04-16 22:20:36 +00:00
|
|
|
rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
|
|
|
|
if (MAJOR(rdev) != create->cr_specdata1 ||
|
|
|
|
MINOR(rdev) != create->cr_specdata2)
|
2018-03-21 21:19:02 +00:00
|
|
|
goto out_umask;
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_create(rqstp, &cstate->current_fh,
|
|
|
|
create->cr_name, create->cr_namelen,
|
2022-07-26 06:45:30 +00:00
|
|
|
&attrs, S_IFBLK, rdev, &resfh);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NF4CHR:
|
2018-03-21 21:19:02 +00:00
|
|
|
status = nfserr_inval;
|
2005-04-16 22:20:36 +00:00
|
|
|
rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
|
|
|
|
if (MAJOR(rdev) != create->cr_specdata1 ||
|
|
|
|
MINOR(rdev) != create->cr_specdata2)
|
2018-03-21 21:19:02 +00:00
|
|
|
goto out_umask;
|
2006-12-13 08:35:27 +00:00
|
|
|
status = nfsd_create(rqstp, &cstate->current_fh,
|
|
|
|
create->cr_name, create->cr_namelen,
|
2022-07-26 06:45:30 +00:00
|
|
|
&attrs, 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,
|
2022-07-26 06:45:30 +00:00
|
|
|
&attrs, 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,
|
2022-07-26 06:45:30 +00:00
|
|
|
&attrs, 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,
|
2022-07-26 06:45:30 +00:00
|
|
|
&attrs, 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
|
|
|
|
2022-07-26 06:45:30 +00:00
|
|
|
if (attrs.na_labelerr)
|
|
|
|
create->cr_bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
|
2022-07-26 06:45:30 +00:00
|
|
|
if (attrs.na_aclerr)
|
|
|
|
create->cr_bmval[0] &= ~FATTR4_WORD0_ACL;
|
2009-07-06 09:24:16 +00:00
|
|
|
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);
|
2018-03-21 21:19:02 +00:00
|
|
|
out_umask:
|
|
|
|
current->fs->umask = 0;
|
2022-07-26 06:45:30 +00:00
|
|
|
nfsd_attrs_free(&attrs);
|
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_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_getattr *getattr = &u->getattr;
|
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;
|
|
|
|
|
2016-10-18 18:18:40 +00:00
|
|
|
getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
|
|
|
|
getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
|
|
|
|
getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_link *link = &u->link;
|
2017-09-15 20:02:52 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2010-12-16 15:06:27 +00:00
|
|
|
{
|
|
|
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-12-13 08:35:27 +00:00
|
|
|
return nfsd_lookup(rqstp, &cstate->current_fh,
|
2017-05-08 18:58:35 +00:00
|
|
|
u->lookup.lo_name, u->lookup.lo_len,
|
2006-12-13 08:35:27 +00:00
|
|
|
&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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_read *read = &u->read;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-08-18 18:18:54 +00:00
|
|
|
read->rd_nf = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-03-28 17:29:11 +00:00
|
|
|
trace_nfsd_read_start(rqstp, &cstate->current_fh,
|
|
|
|
read->rd_offset, read->rd_length);
|
|
|
|
|
2022-02-04 20:19:34 +00:00
|
|
|
read->rd_length = min_t(u32, read->rd_length, svc_max_payload(rqstp));
|
|
|
|
if (read->rd_offset > (u64)OFFSET_MAX)
|
|
|
|
read->rd_offset = (u64)OFFSET_MAX;
|
|
|
|
if (read->rd_offset + read->rd_length > (u64)OFFSET_MAX)
|
|
|
|
read->rd_length = (u64)OFFSET_MAX - read->rd_offset;
|
|
|
|
|
2012-12-04 23:03:46 +00:00
|
|
|
/*
|
|
|
|
* If we do a zero copy read, then a client will see read data
|
|
|
|
* that reflects the state of the file *after* performing the
|
|
|
|
* following compound.
|
|
|
|
*
|
|
|
|
* To ensure proper ordering, we therefore turn off zero copy if
|
|
|
|
* the client wants us to do more in this compound:
|
|
|
|
*/
|
|
|
|
if (!nfsd4_last_compound_op(rqstp))
|
2023-01-06 17:43:37 +00:00
|
|
|
clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags);
|
2012-12-04 23:03:46 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* check stateid */
|
2015-12-03 11:59:51 +00:00
|
|
|
status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
|
|
|
|
&read->rd_stateid, RD_STATE,
|
2019-10-04 20:34:26 +00:00
|
|
|
&read->rd_nf, NULL);
|
2022-10-28 14:46:57 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-05-05 21:09:37 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
nfsd4_read_release(union nfsd4_op_u *u)
|
|
|
|
{
|
2019-08-18 18:18:54 +00:00
|
|
|
if (u->read.rd_nf)
|
|
|
|
nfsd_file_put(u->read.rd_nf);
|
2018-03-28 17:29:11 +00:00
|
|
|
trace_nfsd_read_done(u->read.rd_rqstp, u->read.rd_fhp,
|
|
|
|
u->read.rd_offset, u->read.rd_length);
|
2017-05-05 21:09:37 +00:00
|
|
|
}
|
|
|
|
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_readdir *readdir = &u->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;
|
|
|
|
|
2016-10-18 18:18:40 +00:00
|
|
|
readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
|
|
|
|
readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
|
|
|
|
readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
u->readlink.rl_rqstp = rqstp;
|
|
|
|
u->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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_remove *remove = &u->remove;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-08-06 16:47:02 +00:00
|
|
|
if (opens_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);
|
2022-07-26 06:45:30 +00:00
|
|
|
if (!status)
|
2006-12-13 08:35:27 +00:00
|
|
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_rename *rename = &u->rename;
|
2017-09-15 20:02:52 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-11-06 16:47:20 +00:00
|
|
|
if (opens_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_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);
|
2013-04-30 19:28:51 +00:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
set_change_info(&rename->rn_sinfo, &cstate->current_fh);
|
|
|
|
set_change_info(&rename->rn_tinfo, &cstate->save_fh);
|
|
|
|
return nfs_ok;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-07-17 11:04:51 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2007-07-17 11:04:51 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_secinfo *secinfo = &u->secinfo;
|
2007-07-17 11:04:51 +00:00
|
|
|
struct svc_export *exp;
|
|
|
|
struct dentry *dentry;
|
|
|
|
__be32 err;
|
|
|
|
|
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;
|
2015-03-17 22:25:59 +00:00
|
|
|
if (d_really_is_negative(dentry)) {
|
2007-07-17 11:04:51 +00:00
|
|
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2010-12-16 14:51:13 +00:00
|
|
|
{
|
|
|
|
__be32 err;
|
|
|
|
|
2017-05-08 18:58:35 +00:00
|
|
|
switch (u->secinfo_no_name.sin_style) {
|
2010-12-16 14:51:13 +00:00
|
|
|
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;
|
|
|
|
}
|
2014-06-10 14:06:44 +00:00
|
|
|
|
2017-05-08 18:58:35 +00:00
|
|
|
u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export);
|
2010-12-16 14:51:13 +00:00
|
|
|
fh_put(&cstate->current_fh);
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2017-05-05 21:09:37 +00:00
|
|
|
static void
|
|
|
|
nfsd4_secinfo_release(union nfsd4_op_u *u)
|
|
|
|
{
|
|
|
|
if (u->secinfo.si_exp)
|
|
|
|
exp_put(u->secinfo.si_exp);
|
|
|
|
}
|
|
|
|
|
2017-09-29 07:01:10 +00:00
|
|
|
static void
|
|
|
|
nfsd4_secinfo_no_name_release(union nfsd4_op_u *u)
|
|
|
|
{
|
|
|
|
if (u->secinfo_no_name.sin_exp)
|
|
|
|
exp_put(u->secinfo_no_name.sin_exp);
|
|
|
|
}
|
|
|
|
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_setattr *setattr = &u->setattr;
|
2022-07-26 06:45:30 +00:00
|
|
|
struct nfsd_attrs attrs = {
|
|
|
|
.na_iattr = &setattr->sa_iattr,
|
2022-07-26 06:45:30 +00:00
|
|
|
.na_seclabel = &setattr->sa_label,
|
2022-07-26 06:45:30 +00:00
|
|
|
};
|
2022-07-26 06:45:30 +00:00
|
|
|
struct inode *inode;
|
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) {
|
2015-06-18 14:45:00 +00:00
|
|
|
status = nfs4_preprocess_stateid_op(rqstp, cstate,
|
2015-12-03 11:59:51 +00:00
|
|
|
&cstate->current_fh, &setattr->sa_stateid,
|
2019-10-04 20:34:26 +00:00
|
|
|
WR_STATE, NULL, NULL);
|
2022-10-28 14:46:57 +00:00
|
|
|
if (status)
|
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;
|
|
|
|
|
2022-07-26 06:45:30 +00:00
|
|
|
inode = cstate->current_fh.fh_dentry->d_inode;
|
|
|
|
status = nfsd4_acl_to_attr(S_ISDIR(inode->i_mode) ? NF4DIR : NF4REG,
|
|
|
|
setattr->sa_acl, &attrs);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (status)
|
2008-02-15 22:37:38 +00:00
|
|
|
goto out;
|
2022-07-26 06:45:30 +00:00
|
|
|
status = nfsd_setattr(rqstp, &cstate->current_fh, &attrs,
|
2019-11-03 16:50:18 +00:00
|
|
|
0, (time64_t)0);
|
2022-07-26 06:45:30 +00:00
|
|
|
if (!status)
|
|
|
|
status = nfserrno(attrs.na_labelerr);
|
2022-11-07 11:58:41 +00:00
|
|
|
if (!status)
|
|
|
|
status = nfserrno(attrs.na_aclerr);
|
2008-02-15 22:37:38 +00:00
|
|
|
out:
|
2022-07-26 06:45:30 +00:00
|
|
|
nfsd_attrs_free(&attrs);
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_write *write = &u->write;
|
2005-04-16 22:20:36 +00:00
|
|
|
stateid_t *stateid = &write->wr_stateid;
|
2019-08-18 18:18:54 +00:00
|
|
|
struct nfsd_file *nf = NULL;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status = nfs_ok;
|
2009-03-06 01:16:14 +00:00
|
|
|
unsigned long cnt;
|
2012-11-15 19:52:19 +00:00
|
|
|
int nvecs;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2022-01-25 21:36:22 +00:00
|
|
|
if (write->wr_offset > (u64)OFFSET_MAX ||
|
|
|
|
write->wr_offset + write->wr_buflen > (u64)OFFSET_MAX)
|
|
|
|
return nfserr_fbig;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-03-27 14:53:27 +00:00
|
|
|
cnt = write->wr_buflen;
|
|
|
|
trace_nfsd_write_start(rqstp, &cstate->current_fh,
|
|
|
|
write->wr_offset, cnt);
|
2015-12-03 11:59:51 +00:00
|
|
|
status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
|
2019-10-04 20:34:26 +00:00
|
|
|
stateid, WR_STATE, &nf, NULL);
|
2022-10-28 14:46:57 +00:00
|
|
|
if (status)
|
2006-01-19 01:43:33 +00:00
|
|
|
return status;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
write->wr_how_written = write->wr_stable_how;
|
|
|
|
|
2021-09-30 21:06:21 +00:00
|
|
|
nvecs = svc_fill_write_vector(rqstp, &write->wr_payload);
|
2012-11-15 19:52:19 +00:00
|
|
|
WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec));
|
|
|
|
|
2020-01-06 18:40:29 +00:00
|
|
|
status = nfsd_vfs_write(rqstp, &cstate->current_fh, nf,
|
2015-06-18 14:45:00 +00:00
|
|
|
write->wr_offset, rqstp->rq_vec, nvecs, &cnt,
|
2020-01-06 18:40:37 +00:00
|
|
|
write->wr_how_written,
|
|
|
|
(__be32 *)write->wr_verifier.data);
|
2019-08-18 18:18:54 +00:00
|
|
|
nfsd_file_put(nf);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-06 01:16:14 +00:00
|
|
|
write->wr_bytes_written = cnt;
|
2018-03-27 14:53:27 +00:00
|
|
|
trace_nfsd_write_done(rqstp, &cstate->current_fh,
|
|
|
|
write->wr_offset, cnt);
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2015-12-03 11:59:52 +00:00
|
|
|
static __be32
|
2016-09-07 19:57:30 +00:00
|
|
|
nfsd4_verify_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2019-08-18 18:18:54 +00:00
|
|
|
stateid_t *src_stateid, struct nfsd_file **src,
|
|
|
|
stateid_t *dst_stateid, struct nfsd_file **dst)
|
2015-12-03 11:59:52 +00:00
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
|
2018-11-08 16:11:36 +00:00
|
|
|
if (!cstate->save_fh.fh_dentry)
|
|
|
|
return nfserr_nofilehandle;
|
|
|
|
|
2015-12-03 11:59:52 +00:00
|
|
|
status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh,
|
2019-10-04 20:34:26 +00:00
|
|
|
src_stateid, RD_STATE, src, NULL);
|
2022-10-28 14:46:57 +00:00
|
|
|
if (status)
|
2015-12-03 11:59:52 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
|
2019-10-04 20:34:26 +00:00
|
|
|
dst_stateid, WR_STATE, dst, NULL);
|
2022-10-28 14:46:57 +00:00
|
|
|
if (status)
|
2015-12-03 11:59:52 +00:00
|
|
|
goto out_put_src;
|
|
|
|
|
|
|
|
/* fix up for NFS-specific error code */
|
2019-08-18 18:18:54 +00:00
|
|
|
if (!S_ISREG(file_inode((*src)->nf_file)->i_mode) ||
|
|
|
|
!S_ISREG(file_inode((*dst)->nf_file)->i_mode)) {
|
2015-12-03 11:59:52 +00:00
|
|
|
status = nfserr_wrong_type;
|
|
|
|
goto out_put_dst;
|
|
|
|
}
|
|
|
|
|
2016-09-07 19:57:30 +00:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
out_put_dst:
|
2019-08-18 18:18:54 +00:00
|
|
|
nfsd_file_put(*dst);
|
2023-01-17 19:38:30 +00:00
|
|
|
*dst = NULL;
|
2016-09-07 19:57:30 +00:00
|
|
|
out_put_src:
|
2019-08-18 18:18:54 +00:00
|
|
|
nfsd_file_put(*src);
|
2023-01-17 19:38:30 +00:00
|
|
|
*src = NULL;
|
2016-09-07 19:57:30 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2016-09-07 19:57:30 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_clone *clone = &u->clone;
|
2019-08-18 18:18:54 +00:00
|
|
|
struct nfsd_file *src, *dst;
|
2016-09-07 19:57:30 +00:00
|
|
|
__be32 status;
|
|
|
|
|
|
|
|
status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src,
|
|
|
|
&clone->cl_dst_stateid, &dst);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
|
2021-12-19 01:38:00 +00:00
|
|
|
status = nfsd4_clone_file_range(rqstp, src, clone->cl_src_pos,
|
2020-01-06 18:40:32 +00:00
|
|
|
dst, clone->cl_dst_pos, clone->cl_count,
|
2019-11-27 22:05:51 +00:00
|
|
|
EX_ISSYNC(cstate->current_fh.fh_export));
|
2015-12-03 11:59:52 +00:00
|
|
|
|
2019-08-18 18:18:54 +00:00
|
|
|
nfsd_file_put(dst);
|
|
|
|
nfsd_file_put(src);
|
2015-12-03 11:59:52 +00:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2022-07-27 18:40:35 +00:00
|
|
|
static void nfs4_put_copy(struct nfsd4_copy *copy)
|
2018-07-20 22:19:20 +00:00
|
|
|
{
|
|
|
|
if (!refcount_dec_and_test(©->refcount))
|
|
|
|
return;
|
2022-07-27 18:40:22 +00:00
|
|
|
kfree(copy->cp_src);
|
2018-07-20 22:19:20 +00:00
|
|
|
kfree(copy);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfsd4_stop_copy(struct nfsd4_copy *copy)
|
|
|
|
{
|
2022-07-27 18:40:41 +00:00
|
|
|
if (!test_and_set_bit(NFSD4_COPY_F_STOPPED, ©->cp_flags))
|
2018-07-20 22:19:20 +00:00
|
|
|
kthread_stop(copy->copy_task);
|
|
|
|
nfs4_put_copy(copy);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfsd4_copy *nfsd4_get_copy(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
struct nfsd4_copy *copy = NULL;
|
|
|
|
|
|
|
|
spin_lock(&clp->async_lock);
|
|
|
|
if (!list_empty(&clp->async_copies)) {
|
|
|
|
copy = list_first_entry(&clp->async_copies, struct nfsd4_copy,
|
|
|
|
copies);
|
|
|
|
refcount_inc(©->refcount);
|
|
|
|
}
|
|
|
|
spin_unlock(&clp->async_lock);
|
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
|
|
|
|
void nfsd4_shutdown_copy(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
struct nfsd4_copy *copy;
|
|
|
|
|
|
|
|
while ((copy = nfsd4_get_copy(clp)) != NULL)
|
|
|
|
nfsd4_stop_copy(copy);
|
|
|
|
}
|
2019-10-09 15:50:48 +00:00
|
|
|
#ifdef CONFIG_NFSD_V4_2_INTER_SSC
|
|
|
|
|
|
|
|
extern struct file *nfs42_ssc_open(struct vfsmount *ss_mnt,
|
|
|
|
struct nfs_fh *src_fh,
|
|
|
|
nfs4_stateid *stateid);
|
|
|
|
extern void nfs42_ssc_close(struct file *filep);
|
|
|
|
|
|
|
|
extern void nfs_sb_deactive(struct super_block *sb);
|
|
|
|
|
|
|
|
#define NFSD42_INTERSSC_MOUNTOPS "vers=4.2,addr=%s,sec=sys"
|
|
|
|
|
2021-05-21 19:09:37 +00:00
|
|
|
/*
|
|
|
|
* setup a work entry in the ssc delayed unmount list.
|
|
|
|
*/
|
2021-06-04 00:02:26 +00:00
|
|
|
static __be32 nfsd4_ssc_setup_dul(struct nfsd_net *nn, char *ipaddr,
|
2022-12-19 00:55:53 +00:00
|
|
|
struct nfsd4_ssc_umount_item **nsui)
|
2021-05-21 19:09:37 +00:00
|
|
|
{
|
2021-09-25 22:58:41 +00:00
|
|
|
struct nfsd4_ssc_umount_item *ni = NULL;
|
2021-05-21 19:09:37 +00:00
|
|
|
struct nfsd4_ssc_umount_item *work = NULL;
|
|
|
|
struct nfsd4_ssc_umount_item *tmp;
|
|
|
|
DEFINE_WAIT(wait);
|
2022-12-19 00:55:53 +00:00
|
|
|
__be32 status = 0;
|
2021-05-21 19:09:37 +00:00
|
|
|
|
2022-12-19 00:55:53 +00:00
|
|
|
*nsui = NULL;
|
2021-05-21 19:09:37 +00:00
|
|
|
work = kzalloc(sizeof(*work), GFP_KERNEL);
|
|
|
|
try_again:
|
|
|
|
spin_lock(&nn->nfsd_ssc_lock);
|
|
|
|
list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) {
|
|
|
|
if (strncmp(ni->nsui_ipaddr, ipaddr, sizeof(ni->nsui_ipaddr)))
|
|
|
|
continue;
|
|
|
|
/* found a match */
|
|
|
|
if (ni->nsui_busy) {
|
|
|
|
/* wait - and try again */
|
2023-07-18 06:38:08 +00:00
|
|
|
prepare_to_wait(&nn->nfsd_ssc_waitq, &wait, TASK_IDLE);
|
2021-05-21 19:09:37 +00:00
|
|
|
spin_unlock(&nn->nfsd_ssc_lock);
|
|
|
|
|
|
|
|
/* allow 20secs for mount/unmount for now - revisit */
|
2023-07-18 06:38:08 +00:00
|
|
|
if (kthread_should_stop() ||
|
2021-05-21 19:09:37 +00:00
|
|
|
(schedule_timeout(20*HZ) == 0)) {
|
2023-01-11 16:24:53 +00:00
|
|
|
finish_wait(&nn->nfsd_ssc_waitq, &wait);
|
2021-05-21 19:09:37 +00:00
|
|
|
kfree(work);
|
|
|
|
return nfserr_eagain;
|
|
|
|
}
|
|
|
|
finish_wait(&nn->nfsd_ssc_waitq, &wait);
|
|
|
|
goto try_again;
|
|
|
|
}
|
2022-12-19 00:55:53 +00:00
|
|
|
*nsui = ni;
|
2021-05-21 19:09:37 +00:00
|
|
|
refcount_inc(&ni->nsui_refcnt);
|
|
|
|
spin_unlock(&nn->nfsd_ssc_lock);
|
|
|
|
kfree(work);
|
|
|
|
|
2022-12-19 00:55:53 +00:00
|
|
|
/* return vfsmount in (*nsui)->nsui_vfsmount */
|
2021-05-21 19:09:37 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (work) {
|
2022-08-18 21:01:14 +00:00
|
|
|
strscpy(work->nsui_ipaddr, ipaddr, sizeof(work->nsui_ipaddr) - 1);
|
2021-05-21 19:09:37 +00:00
|
|
|
refcount_set(&work->nsui_refcnt, 2);
|
|
|
|
work->nsui_busy = true;
|
|
|
|
list_add_tail(&work->nsui_list, &nn->nfsd_ssc_mount_list);
|
2022-12-19 00:55:53 +00:00
|
|
|
*nsui = work;
|
|
|
|
} else
|
|
|
|
status = nfserr_resource;
|
2021-05-21 19:09:37 +00:00
|
|
|
spin_unlock(&nn->nfsd_ssc_lock);
|
2022-12-19 00:55:53 +00:00
|
|
|
return status;
|
2021-05-21 19:09:37 +00:00
|
|
|
}
|
|
|
|
|
2022-12-19 00:55:53 +00:00
|
|
|
static void nfsd4_ssc_update_dul(struct nfsd_net *nn,
|
|
|
|
struct nfsd4_ssc_umount_item *nsui,
|
|
|
|
struct vfsmount *ss_mnt)
|
2021-05-21 19:09:37 +00:00
|
|
|
{
|
|
|
|
spin_lock(&nn->nfsd_ssc_lock);
|
2022-12-19 00:55:53 +00:00
|
|
|
nsui->nsui_vfsmount = ss_mnt;
|
|
|
|
nsui->nsui_busy = false;
|
2021-05-21 19:09:37 +00:00
|
|
|
wake_up_all(&nn->nfsd_ssc_waitq);
|
|
|
|
spin_unlock(&nn->nfsd_ssc_lock);
|
|
|
|
}
|
|
|
|
|
2022-12-19 00:55:53 +00:00
|
|
|
static void nfsd4_ssc_cancel_dul(struct nfsd_net *nn,
|
|
|
|
struct nfsd4_ssc_umount_item *nsui)
|
2021-05-21 19:09:37 +00:00
|
|
|
{
|
|
|
|
spin_lock(&nn->nfsd_ssc_lock);
|
2022-12-19 00:55:53 +00:00
|
|
|
list_del(&nsui->nsui_list);
|
2021-05-21 19:09:37 +00:00
|
|
|
wake_up_all(&nn->nfsd_ssc_waitq);
|
|
|
|
spin_unlock(&nn->nfsd_ssc_lock);
|
2022-12-19 00:55:53 +00:00
|
|
|
kfree(nsui);
|
2021-05-21 19:09:37 +00:00
|
|
|
}
|
|
|
|
|
2020-04-06 20:01:42 +00:00
|
|
|
/*
|
2019-10-09 15:50:48 +00:00
|
|
|
* Support one copy source server for now.
|
|
|
|
*/
|
|
|
|
static __be32
|
|
|
|
nfsd4_interssc_connect(struct nl4_server *nss, struct svc_rqst *rqstp,
|
2022-12-19 00:55:53 +00:00
|
|
|
struct nfsd4_ssc_umount_item **nsui)
|
2019-10-09 15:50:48 +00:00
|
|
|
{
|
|
|
|
struct file_system_type *type;
|
|
|
|
struct vfsmount *ss_mnt;
|
|
|
|
struct nfs42_netaddr *naddr;
|
|
|
|
struct sockaddr_storage tmp_addr;
|
|
|
|
size_t tmp_addrlen, match_netid_len = 3;
|
|
|
|
char *startsep = "", *endsep = "", *match_netid = "tcp";
|
|
|
|
char *ipaddr, *dev_name, *raw_data;
|
2019-12-04 20:13:53 +00:00
|
|
|
int len, raw_len;
|
|
|
|
__be32 status = nfserr_inval;
|
2021-05-21 19:09:37 +00:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2019-10-09 15:50:48 +00:00
|
|
|
|
|
|
|
naddr = &nss->u.nl4_addr;
|
|
|
|
tmp_addrlen = rpc_uaddr2sockaddr(SVC_NET(rqstp), naddr->addr,
|
|
|
|
naddr->addr_len,
|
|
|
|
(struct sockaddr *)&tmp_addr,
|
|
|
|
sizeof(tmp_addr));
|
2022-12-19 00:55:53 +00:00
|
|
|
*nsui = NULL;
|
2019-10-09 15:50:48 +00:00
|
|
|
if (tmp_addrlen == 0)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
if (tmp_addr.ss_family == AF_INET6) {
|
|
|
|
startsep = "[";
|
|
|
|
endsep = "]";
|
|
|
|
match_netid = "tcp6";
|
|
|
|
match_netid_len = 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (naddr->netid_len != match_netid_len ||
|
|
|
|
strncmp(naddr->netid, match_netid, naddr->netid_len))
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
/* Construct the raw data for the vfs_kern_mount call */
|
|
|
|
len = RPC_MAX_ADDRBUFLEN + 1;
|
|
|
|
ipaddr = kzalloc(len, GFP_KERNEL);
|
|
|
|
if (!ipaddr)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
rpc_ntop((struct sockaddr *)&tmp_addr, ipaddr, len);
|
|
|
|
|
|
|
|
/* 2 for ipv6 endsep and startsep. 3 for ":/" and trailing '/0'*/
|
|
|
|
|
|
|
|
raw_len = strlen(NFSD42_INTERSSC_MOUNTOPS) + strlen(ipaddr);
|
|
|
|
raw_data = kzalloc(raw_len, GFP_KERNEL);
|
|
|
|
if (!raw_data)
|
|
|
|
goto out_free_ipaddr;
|
|
|
|
|
|
|
|
snprintf(raw_data, raw_len, NFSD42_INTERSSC_MOUNTOPS, ipaddr);
|
|
|
|
|
2019-12-04 20:13:53 +00:00
|
|
|
status = nfserr_nodev;
|
2019-10-09 15:50:48 +00:00
|
|
|
type = get_fs_type("nfs");
|
|
|
|
if (!type)
|
|
|
|
goto out_free_rawdata;
|
|
|
|
|
|
|
|
/* Set the server:<export> for the vfs_kern_mount call */
|
|
|
|
dev_name = kzalloc(len + 5, GFP_KERNEL);
|
|
|
|
if (!dev_name)
|
|
|
|
goto out_free_rawdata;
|
|
|
|
snprintf(dev_name, len + 5, "%s%s%s:/", startsep, ipaddr, endsep);
|
|
|
|
|
2022-12-19 00:55:53 +00:00
|
|
|
status = nfsd4_ssc_setup_dul(nn, ipaddr, nsui);
|
2021-05-21 19:09:37 +00:00
|
|
|
if (status)
|
|
|
|
goto out_free_devname;
|
2022-12-19 00:55:53 +00:00
|
|
|
if ((*nsui)->nsui_vfsmount)
|
2021-05-21 19:09:37 +00:00
|
|
|
goto out_done;
|
|
|
|
|
2019-10-09 15:50:48 +00:00
|
|
|
/* Use an 'internal' mount: SB_KERNMOUNT -> MNT_INTERNAL */
|
|
|
|
ss_mnt = vfs_kern_mount(type, SB_KERNMOUNT, dev_name, raw_data);
|
|
|
|
module_put(type->owner);
|
2021-05-21 19:09:37 +00:00
|
|
|
if (IS_ERR(ss_mnt)) {
|
2021-06-04 10:12:37 +00:00
|
|
|
status = nfserr_nodev;
|
2022-12-19 00:55:53 +00:00
|
|
|
nfsd4_ssc_cancel_dul(nn, *nsui);
|
2019-10-09 15:50:48 +00:00
|
|
|
goto out_free_devname;
|
2021-05-21 19:09:37 +00:00
|
|
|
}
|
2022-12-19 00:55:53 +00:00
|
|
|
nfsd4_ssc_update_dul(nn, *nsui, ss_mnt);
|
2021-05-21 19:09:37 +00:00
|
|
|
out_done:
|
2019-10-09 15:50:48 +00:00
|
|
|
status = 0;
|
|
|
|
|
|
|
|
out_free_devname:
|
|
|
|
kfree(dev_name);
|
|
|
|
out_free_rawdata:
|
|
|
|
kfree(raw_data);
|
|
|
|
out_free_ipaddr:
|
|
|
|
kfree(ipaddr);
|
|
|
|
out_err:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2020-04-06 20:01:42 +00:00
|
|
|
/*
|
2019-10-09 15:50:48 +00:00
|
|
|
* Verify COPY destination stateid.
|
2020-04-06 20:01:42 +00:00
|
|
|
*
|
2019-10-09 15:50:48 +00:00
|
|
|
* Connect to the source server with NFSv4.1.
|
|
|
|
* Create the source struct file for nfsd_copy_range.
|
|
|
|
* Called with COPY cstate:
|
|
|
|
* SAVED_FH: source filehandle
|
|
|
|
* CURRENT_FH: destination filehandle
|
|
|
|
*/
|
|
|
|
static __be32
|
|
|
|
nfsd4_setup_inter_ssc(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
2022-12-19 00:55:53 +00:00
|
|
|
struct nfsd4_copy *copy)
|
2019-10-09 15:50:48 +00:00
|
|
|
{
|
|
|
|
struct svc_fh *s_fh = NULL;
|
|
|
|
stateid_t *s_stid = ©->cp_src_stateid;
|
2019-12-04 20:13:53 +00:00
|
|
|
__be32 status = nfserr_inval;
|
2019-10-09 15:50:48 +00:00
|
|
|
|
|
|
|
/* Verify the destination stateid and set dst struct file*/
|
|
|
|
status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
|
|
|
|
©->cp_dst_stateid,
|
|
|
|
WR_STATE, ©->nf_dst, NULL);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
|
2022-12-19 00:55:53 +00:00
|
|
|
status = nfsd4_interssc_connect(copy->cp_src, rqstp, ©->ss_nsui);
|
2019-10-09 15:50:48 +00:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
s_fh = &cstate->save_fh;
|
|
|
|
|
|
|
|
copy->c_fh.size = s_fh->fh_handle.fh_size;
|
2021-09-02 01:16:32 +00:00
|
|
|
memcpy(copy->c_fh.data, &s_fh->fh_handle.fh_raw, copy->c_fh.size);
|
2019-12-04 20:13:53 +00:00
|
|
|
copy->stateid.seqid = cpu_to_be32(s_stid->si_generation);
|
2019-10-09 15:50:48 +00:00
|
|
|
memcpy(copy->stateid.other, (void *)&s_stid->si_opaque,
|
|
|
|
sizeof(stateid_opaque_t));
|
|
|
|
|
|
|
|
status = 0;
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2022-12-19 00:55:53 +00:00
|
|
|
nfsd4_cleanup_inter_ssc(struct nfsd4_ssc_umount_item *nsui, struct file *filp,
|
2019-10-09 15:50:48 +00:00
|
|
|
struct nfsd_file *dst)
|
|
|
|
{
|
2021-05-21 19:09:37 +00:00
|
|
|
struct nfsd_net *nn = net_generic(dst->nf_net, nfsd_net_id);
|
2022-12-19 00:55:53 +00:00
|
|
|
long timeout = msecs_to_jiffies(nfsd4_ssc_umount_timeout);
|
2021-05-21 19:09:37 +00:00
|
|
|
|
2022-07-27 18:40:47 +00:00
|
|
|
nfs42_ssc_close(filp);
|
|
|
|
fput(filp);
|
2021-05-21 19:09:37 +00:00
|
|
|
|
|
|
|
spin_lock(&nn->nfsd_ssc_lock);
|
2022-12-19 00:55:53 +00:00
|
|
|
list_del(&nsui->nsui_list);
|
|
|
|
/*
|
|
|
|
* vfsmount can be shared by multiple exports,
|
|
|
|
* decrement refcnt. If the count drops to 1 it
|
|
|
|
* will be unmounted when nsui_expire expires.
|
|
|
|
*/
|
|
|
|
refcount_dec(&nsui->nsui_refcnt);
|
|
|
|
nsui->nsui_expire = jiffies + timeout;
|
|
|
|
list_add_tail(&nsui->nsui_list, &nn->nfsd_ssc_mount_list);
|
2021-05-21 19:09:37 +00:00
|
|
|
spin_unlock(&nn->nfsd_ssc_lock);
|
2019-10-09 15:50:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#else /* CONFIG_NFSD_V4_2_INTER_SSC */
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_setup_inter_ssc(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
2022-12-19 00:55:53 +00:00
|
|
|
struct nfsd4_copy *copy)
|
2019-10-09 15:50:48 +00:00
|
|
|
{
|
2019-12-04 20:13:53 +00:00
|
|
|
return nfserr_inval;
|
2019-10-09 15:50:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2022-12-19 00:55:53 +00:00
|
|
|
nfsd4_cleanup_inter_ssc(struct nfsd4_ssc_umount_item *nsui, struct file *filp,
|
2019-10-09 15:50:48 +00:00
|
|
|
struct nfsd_file *dst)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct file *nfs42_ssc_open(struct vfsmount *ss_mnt,
|
|
|
|
struct nfs_fh *src_fh,
|
|
|
|
nfs4_stateid *stateid)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NFSD_V4_2_INTER_SSC */
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_setup_intra_ssc(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_copy *copy)
|
|
|
|
{
|
|
|
|
return nfsd4_verify_copy(rqstp, cstate, ©->cp_src_stateid,
|
|
|
|
©->nf_src, ©->cp_dst_stateid,
|
|
|
|
©->nf_dst);
|
|
|
|
}
|
|
|
|
|
2018-07-20 22:19:20 +00:00
|
|
|
static void nfsd4_cb_offload_release(struct nfsd4_callback *cb)
|
|
|
|
{
|
2022-07-27 18:41:18 +00:00
|
|
|
struct nfsd4_cb_offload *cbo =
|
|
|
|
container_of(cb, struct nfsd4_cb_offload, co_cb);
|
2018-07-20 22:19:20 +00:00
|
|
|
|
2022-07-27 18:41:18 +00:00
|
|
|
kfree(cbo);
|
2018-07-20 22:19:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int nfsd4_cb_offload_done(struct nfsd4_callback *cb,
|
|
|
|
struct rpc_task *task)
|
|
|
|
{
|
2022-09-08 22:13:54 +00:00
|
|
|
struct nfsd4_cb_offload *cbo =
|
|
|
|
container_of(cb, struct nfsd4_cb_offload, co_cb);
|
|
|
|
|
|
|
|
trace_nfsd_cb_offload_done(&cbo->co_res.cb_stateid, task);
|
2018-07-20 22:19:20 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct nfsd4_callback_ops nfsd4_cb_offload_ops = {
|
|
|
|
.release = nfsd4_cb_offload_release,
|
|
|
|
.done = nfsd4_cb_offload_done
|
|
|
|
};
|
|
|
|
|
|
|
|
static void nfsd4_init_copy_res(struct nfsd4_copy *copy, bool sync)
|
|
|
|
{
|
2021-05-19 18:48:27 +00:00
|
|
|
copy->cp_res.wr_stable_how =
|
2022-07-27 18:40:41 +00:00
|
|
|
test_bit(NFSD4_COPY_F_COMMITTED, ©->cp_flags) ?
|
|
|
|
NFS_FILE_SYNC : NFS_UNSTABLE;
|
|
|
|
nfsd4_copy_set_sync(copy, sync);
|
2018-07-20 22:19:20 +00:00
|
|
|
gen_boot_verifier(©->cp_res.wr_verifier, copy->cp_clp->net);
|
|
|
|
}
|
|
|
|
|
2022-07-27 18:40:59 +00:00
|
|
|
static ssize_t _nfsd_copy_file_range(struct nfsd4_copy *copy,
|
|
|
|
struct file *dst,
|
|
|
|
struct file *src)
|
2018-07-20 22:19:20 +00:00
|
|
|
{
|
2021-12-19 01:38:01 +00:00
|
|
|
errseq_t since;
|
2018-07-20 22:19:20 +00:00
|
|
|
ssize_t bytes_copied = 0;
|
2021-03-19 00:03:22 +00:00
|
|
|
u64 bytes_total = copy->cp_count;
|
2018-07-20 22:19:20 +00:00
|
|
|
u64 src_pos = copy->cp_src_pos;
|
|
|
|
u64 dst_pos = copy->cp_dst_pos;
|
2021-10-13 20:44:20 +00:00
|
|
|
int status;
|
2022-11-16 15:28:36 +00:00
|
|
|
loff_t end;
|
2018-07-20 22:19:20 +00:00
|
|
|
|
2021-03-19 00:03:23 +00:00
|
|
|
/* See RFC 7862 p.67: */
|
|
|
|
if (bytes_total == 0)
|
|
|
|
bytes_total = ULLONG_MAX;
|
2018-07-20 22:19:20 +00:00
|
|
|
do {
|
|
|
|
if (kthread_should_stop())
|
|
|
|
break;
|
2021-12-19 01:38:01 +00:00
|
|
|
bytes_copied = nfsd_copy_file_range(src, src_pos, dst, dst_pos,
|
|
|
|
bytes_total);
|
2018-07-20 22:19:20 +00:00
|
|
|
if (bytes_copied <= 0)
|
|
|
|
break;
|
|
|
|
bytes_total -= bytes_copied;
|
|
|
|
copy->cp_res.wr_bytes_written += bytes_copied;
|
|
|
|
src_pos += bytes_copied;
|
|
|
|
dst_pos += bytes_copied;
|
2022-07-27 18:40:41 +00:00
|
|
|
} while (bytes_total > 0 && nfsd4_copy_is_async(copy));
|
2021-05-19 18:48:27 +00:00
|
|
|
/* for a non-zero asynchronous copy do a commit of data */
|
2022-07-27 18:40:41 +00:00
|
|
|
if (nfsd4_copy_is_async(copy) && copy->cp_res.wr_bytes_written > 0) {
|
2021-12-19 01:38:01 +00:00
|
|
|
since = READ_ONCE(dst->f_wb_err);
|
2022-11-16 15:28:36 +00:00
|
|
|
end = copy->cp_dst_pos + copy->cp_res.wr_bytes_written - 1;
|
|
|
|
status = vfs_fsync_range(dst, copy->cp_dst_pos, end, 0);
|
2021-12-19 01:38:01 +00:00
|
|
|
if (!status)
|
|
|
|
status = filemap_check_wb_err(dst->f_mapping, since);
|
2021-05-19 18:48:27 +00:00
|
|
|
if (!status)
|
2022-07-27 18:40:41 +00:00
|
|
|
set_bit(NFSD4_COPY_F_COMMITTED, ©->cp_flags);
|
2021-05-19 18:48:27 +00:00
|
|
|
}
|
2018-07-20 22:19:20 +00:00
|
|
|
return bytes_copied;
|
|
|
|
}
|
|
|
|
|
2022-07-27 18:40:59 +00:00
|
|
|
static __be32 nfsd4_do_copy(struct nfsd4_copy *copy,
|
|
|
|
struct file *src, struct file *dst,
|
|
|
|
bool sync)
|
2018-07-20 22:19:20 +00:00
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
ssize_t bytes;
|
|
|
|
|
2022-07-27 18:40:59 +00:00
|
|
|
bytes = _nfsd_copy_file_range(copy, dst, src);
|
|
|
|
|
2018-07-20 22:19:20 +00:00
|
|
|
/* for async copy, we ignore the error, client can always retry
|
|
|
|
* to get the error
|
|
|
|
*/
|
|
|
|
if (bytes < 0 && !copy->cp_res.wr_bytes_written)
|
|
|
|
status = nfserrno(bytes);
|
|
|
|
else {
|
|
|
|
nfsd4_init_copy_res(copy, sync);
|
|
|
|
status = nfs_ok;
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2020-11-30 21:17:40 +00:00
|
|
|
static void dup_copy_fields(struct nfsd4_copy *src, struct nfsd4_copy *dst)
|
2018-07-20 22:19:20 +00:00
|
|
|
{
|
|
|
|
dst->cp_src_pos = src->cp_src_pos;
|
|
|
|
dst->cp_dst_pos = src->cp_dst_pos;
|
|
|
|
dst->cp_count = src->cp_count;
|
2022-07-27 18:40:41 +00:00
|
|
|
dst->cp_flags = src->cp_flags;
|
2018-07-20 22:19:20 +00:00
|
|
|
memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res));
|
|
|
|
memcpy(&dst->fh, &src->fh, sizeof(src->fh));
|
|
|
|
dst->cp_clp = src->cp_clp;
|
2019-08-18 18:18:54 +00:00
|
|
|
dst->nf_dst = nfsd_file_get(src->nf_dst);
|
2022-07-27 18:40:41 +00:00
|
|
|
/* for inter, nf_src doesn't exist yet */
|
|
|
|
if (!nfsd4_ssc_is_inter(src))
|
2019-10-09 15:50:48 +00:00
|
|
|
dst->nf_src = nfsd_file_get(src->nf_src);
|
|
|
|
|
2018-07-20 22:19:20 +00:00
|
|
|
memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid));
|
2022-07-27 18:40:22 +00:00
|
|
|
memcpy(dst->cp_src, src->cp_src, sizeof(struct nl4_server));
|
2019-10-09 15:50:48 +00:00
|
|
|
memcpy(&dst->stateid, &src->stateid, sizeof(src->stateid));
|
|
|
|
memcpy(&dst->c_fh, &src->c_fh, sizeof(src->c_fh));
|
2022-12-19 00:55:53 +00:00
|
|
|
dst->ss_nsui = src->ss_nsui;
|
2018-07-20 22:19:20 +00:00
|
|
|
}
|
|
|
|
|
2023-01-17 19:38:31 +00:00
|
|
|
static void release_copy_files(struct nfsd4_copy *copy)
|
|
|
|
{
|
|
|
|
if (copy->nf_src)
|
|
|
|
nfsd_file_put(copy->nf_src);
|
|
|
|
if (copy->nf_dst)
|
|
|
|
nfsd_file_put(copy->nf_dst);
|
|
|
|
}
|
|
|
|
|
2018-07-20 22:19:20 +00:00
|
|
|
static void cleanup_async_copy(struct nfsd4_copy *copy)
|
|
|
|
{
|
2019-10-04 20:34:26 +00:00
|
|
|
nfs4_free_copy_state(copy);
|
2023-01-17 19:38:31 +00:00
|
|
|
release_copy_files(copy);
|
2023-01-31 19:12:29 +00:00
|
|
|
if (copy->cp_clp) {
|
|
|
|
spin_lock(©->cp_clp->async_lock);
|
|
|
|
if (!list_empty(©->copies))
|
|
|
|
list_del_init(©->copies);
|
|
|
|
spin_unlock(©->cp_clp->async_lock);
|
|
|
|
}
|
2018-07-20 22:19:20 +00:00
|
|
|
nfs4_put_copy(copy);
|
|
|
|
}
|
|
|
|
|
2022-07-27 18:41:18 +00:00
|
|
|
static void nfsd4_send_cb_offload(struct nfsd4_copy *copy, __be32 nfserr)
|
2022-07-27 18:41:12 +00:00
|
|
|
{
|
2022-07-27 18:41:18 +00:00
|
|
|
struct nfsd4_cb_offload *cbo;
|
2022-07-27 18:41:12 +00:00
|
|
|
|
2022-07-27 18:41:18 +00:00
|
|
|
cbo = kzalloc(sizeof(*cbo), GFP_KERNEL);
|
|
|
|
if (!cbo)
|
2022-07-27 18:41:12 +00:00
|
|
|
return;
|
|
|
|
|
2022-07-27 18:41:18 +00:00
|
|
|
memcpy(&cbo->co_res, ©->cp_res, sizeof(copy->cp_res));
|
|
|
|
memcpy(&cbo->co_fh, ©->fh, sizeof(copy->fh));
|
|
|
|
cbo->co_nfserr = nfserr;
|
2022-07-27 18:41:12 +00:00
|
|
|
|
2022-07-27 18:41:18 +00:00
|
|
|
nfsd4_init_cb(&cbo->co_cb, copy->cp_clp, &nfsd4_cb_offload_ops,
|
|
|
|
NFSPROC4_CLNT_CB_OFFLOAD);
|
|
|
|
trace_nfsd_cb_offload(copy->cp_clp, &cbo->co_res.cb_stateid,
|
|
|
|
&cbo->co_fh, copy->cp_count, nfserr);
|
|
|
|
nfsd4_run_cb(&cbo->co_cb);
|
2022-07-27 18:41:12 +00:00
|
|
|
}
|
|
|
|
|
2022-07-27 18:41:06 +00:00
|
|
|
/**
|
|
|
|
* nfsd4_do_async_copy - kthread function for background server-side COPY
|
|
|
|
* @data: arguments for COPY operation
|
|
|
|
*
|
|
|
|
* Return values:
|
|
|
|
* %0: Copy operation is done.
|
|
|
|
*/
|
2018-07-20 22:19:20 +00:00
|
|
|
static int nfsd4_do_async_copy(void *data)
|
|
|
|
{
|
|
|
|
struct nfsd4_copy *copy = (struct nfsd4_copy *)data;
|
2022-07-27 18:41:18 +00:00
|
|
|
__be32 nfserr;
|
2018-07-20 22:19:20 +00:00
|
|
|
|
2022-07-27 18:40:41 +00:00
|
|
|
if (nfsd4_ssc_is_inter(copy)) {
|
2022-07-27 18:41:06 +00:00
|
|
|
struct file *filp;
|
|
|
|
|
2022-12-19 00:55:53 +00:00
|
|
|
filp = nfs42_ssc_open(copy->ss_nsui->nsui_vfsmount,
|
|
|
|
©->c_fh, ©->stateid);
|
2022-07-27 18:41:06 +00:00
|
|
|
if (IS_ERR(filp)) {
|
2022-08-19 19:16:36 +00:00
|
|
|
switch (PTR_ERR(filp)) {
|
|
|
|
case -EBADF:
|
|
|
|
nfserr = nfserr_wrong_type;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
nfserr = nfserr_offload_denied;
|
|
|
|
}
|
2022-12-12 22:50:11 +00:00
|
|
|
/* ss_mnt will be unmounted by the laundromat */
|
2019-10-09 15:50:48 +00:00
|
|
|
goto do_callback;
|
|
|
|
}
|
2022-07-27 18:41:18 +00:00
|
|
|
nfserr = nfsd4_do_copy(copy, filp, copy->nf_dst->nf_file,
|
|
|
|
false);
|
2022-12-19 00:55:53 +00:00
|
|
|
nfsd4_cleanup_inter_ssc(copy->ss_nsui, filp, copy->nf_dst);
|
2022-07-27 18:40:53 +00:00
|
|
|
} else {
|
2022-07-27 18:41:18 +00:00
|
|
|
nfserr = nfsd4_do_copy(copy, copy->nf_src->nf_file,
|
|
|
|
copy->nf_dst->nf_file, false);
|
2019-10-09 15:50:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
do_callback:
|
2022-07-27 18:41:18 +00:00
|
|
|
nfsd4_send_cb_offload(copy, nfserr);
|
2018-07-20 22:19:20 +00:00
|
|
|
cleanup_async_copy(copy);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-09-07 19:57:30 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2016-09-07 19:57:30 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_copy *copy = &u->copy;
|
2016-09-07 19:57:30 +00:00
|
|
|
__be32 status;
|
2018-07-20 22:19:20 +00:00
|
|
|
struct nfsd4_copy *async_copy = NULL;
|
2016-09-07 19:57:30 +00:00
|
|
|
|
2022-07-27 18:40:41 +00:00
|
|
|
if (nfsd4_ssc_is_inter(copy)) {
|
|
|
|
if (!inter_copy_offload_enable || nfsd4_copy_is_sync(copy)) {
|
2019-10-09 15:50:48 +00:00
|
|
|
status = nfserr_notsupp;
|
|
|
|
goto out;
|
|
|
|
}
|
2022-12-19 00:55:53 +00:00
|
|
|
status = nfsd4_setup_inter_ssc(rqstp, cstate, copy);
|
2019-10-09 15:50:48 +00:00
|
|
|
if (status)
|
|
|
|
return nfserr_offload_denied;
|
|
|
|
} else {
|
|
|
|
status = nfsd4_setup_intra_ssc(rqstp, cstate, copy);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
}
|
2016-09-07 19:57:30 +00:00
|
|
|
|
2018-07-20 22:19:20 +00:00
|
|
|
copy->cp_clp = cstate->clp;
|
|
|
|
memcpy(©->fh, &cstate->current_fh.fh_handle,
|
|
|
|
sizeof(struct knfsd_fh));
|
2022-07-27 18:40:41 +00:00
|
|
|
if (nfsd4_copy_is_async(copy)) {
|
2018-07-20 22:19:20 +00:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2016-09-07 19:57:30 +00:00
|
|
|
|
2018-07-20 22:19:20 +00:00
|
|
|
status = nfserrno(-ENOMEM);
|
|
|
|
async_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL);
|
|
|
|
if (!async_copy)
|
2019-10-09 15:50:48 +00:00
|
|
|
goto out_err;
|
2023-01-31 19:12:29 +00:00
|
|
|
INIT_LIST_HEAD(&async_copy->copies);
|
|
|
|
refcount_set(&async_copy->refcount, 1);
|
2022-07-27 18:40:22 +00:00
|
|
|
async_copy->cp_src = kmalloc(sizeof(*async_copy->cp_src), GFP_KERNEL);
|
|
|
|
if (!async_copy->cp_src)
|
|
|
|
goto out_err;
|
2019-10-09 15:50:48 +00:00
|
|
|
if (!nfs4_init_copy_state(nn, copy))
|
|
|
|
goto out_err;
|
2022-09-22 17:10:35 +00:00
|
|
|
memcpy(©->cp_res.cb_stateid, ©->cp_stateid.cs_stid,
|
2021-03-30 19:03:59 +00:00
|
|
|
sizeof(copy->cp_res.cb_stateid));
|
2020-11-30 21:17:40 +00:00
|
|
|
dup_copy_fields(copy, async_copy);
|
2018-07-20 22:19:20 +00:00
|
|
|
async_copy->copy_task = kthread_create(nfsd4_do_async_copy,
|
|
|
|
async_copy, "%s", "copy thread");
|
|
|
|
if (IS_ERR(async_copy->copy_task))
|
|
|
|
goto out_err;
|
|
|
|
spin_lock(&async_copy->cp_clp->async_lock);
|
|
|
|
list_add(&async_copy->copies,
|
|
|
|
&async_copy->cp_clp->async_copies);
|
|
|
|
spin_unlock(&async_copy->cp_clp->async_lock);
|
|
|
|
wake_up_process(async_copy->copy_task);
|
2016-09-07 19:57:30 +00:00
|
|
|
status = nfs_ok;
|
2019-10-09 15:50:48 +00:00
|
|
|
} else {
|
2022-07-27 18:40:59 +00:00
|
|
|
status = nfsd4_do_copy(copy, copy->nf_src->nf_file,
|
|
|
|
copy->nf_dst->nf_file, true);
|
2019-10-09 15:50:48 +00:00
|
|
|
}
|
2016-09-07 19:57:30 +00:00
|
|
|
out:
|
2023-01-17 19:38:31 +00:00
|
|
|
release_copy_files(copy);
|
2016-09-07 19:57:30 +00:00
|
|
|
return status;
|
2018-07-20 22:19:20 +00:00
|
|
|
out_err:
|
2023-01-24 05:34:13 +00:00
|
|
|
if (nfsd4_ssc_is_inter(copy)) {
|
|
|
|
/*
|
|
|
|
* Source's vfsmount of inter-copy will be unmounted
|
|
|
|
* by the laundromat. Use copy instead of async_copy
|
|
|
|
* since async_copy->ss_nsui might not be set yet.
|
|
|
|
*/
|
|
|
|
refcount_dec(©->ss_nsui->nsui_refcnt);
|
|
|
|
}
|
2019-12-04 20:13:54 +00:00
|
|
|
if (async_copy)
|
|
|
|
cleanup_async_copy(async_copy);
|
2019-10-09 15:50:48 +00:00
|
|
|
status = nfserrno(-ENOMEM);
|
2018-07-20 22:19:20 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2023-01-18 17:31:34 +00:00
|
|
|
static struct nfsd4_copy *
|
|
|
|
find_async_copy_locked(struct nfs4_client *clp, stateid_t *stateid)
|
2018-07-20 22:19:20 +00:00
|
|
|
{
|
|
|
|
struct nfsd4_copy *copy;
|
|
|
|
|
2023-01-18 17:31:34 +00:00
|
|
|
lockdep_assert_held(&clp->async_lock);
|
|
|
|
|
2018-07-20 22:19:20 +00:00
|
|
|
list_for_each_entry(copy, &clp->async_copies, copies) {
|
2022-09-22 17:10:35 +00:00
|
|
|
if (memcmp(©->cp_stateid.cs_stid, stateid, NFS4_STATEID_SIZE))
|
2018-07-20 22:19:20 +00:00
|
|
|
continue;
|
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
return NULL;
|
2016-09-07 19:57:30 +00:00
|
|
|
}
|
|
|
|
|
2023-01-18 17:31:34 +00:00
|
|
|
static struct nfsd4_copy *
|
|
|
|
find_async_copy(struct nfs4_client *clp, stateid_t *stateid)
|
|
|
|
{
|
|
|
|
struct nfsd4_copy *copy;
|
|
|
|
|
|
|
|
spin_lock(&clp->async_lock);
|
|
|
|
copy = find_async_copy_locked(clp, stateid);
|
|
|
|
if (copy)
|
|
|
|
refcount_inc(©->refcount);
|
|
|
|
spin_unlock(&clp->async_lock);
|
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
|
2018-07-20 22:19:19 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_offload_cancel(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
|
|
|
{
|
2018-07-20 22:19:20 +00:00
|
|
|
struct nfsd4_offload_status *os = &u->offload_status;
|
|
|
|
struct nfsd4_copy *copy;
|
|
|
|
struct nfs4_client *clp = cstate->clp;
|
|
|
|
|
|
|
|
copy = find_async_copy(clp, &os->stateid);
|
2019-10-09 15:50:48 +00:00
|
|
|
if (!copy) {
|
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
|
|
|
|
|
|
|
return manage_cpntf_state(nn, &os->stateid, clp, NULL);
|
|
|
|
} else
|
2018-07-20 22:19:20 +00:00
|
|
|
nfsd4_stop_copy(copy);
|
|
|
|
|
2019-10-09 15:50:48 +00:00
|
|
|
return nfs_ok;
|
2018-07-20 22:19:19 +00:00
|
|
|
}
|
|
|
|
|
2019-08-08 15:14:59 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_copy_notify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
|
|
|
{
|
2019-10-04 20:34:26 +00:00
|
|
|
struct nfsd4_copy_notify *cn = &u->copy_notify;
|
|
|
|
__be32 status;
|
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
|
|
|
struct nfs4_stid *stid;
|
|
|
|
struct nfs4_cpntf_state *cps;
|
|
|
|
struct nfs4_client *clp = cstate->clp;
|
|
|
|
|
|
|
|
status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
|
|
|
|
&cn->cpn_src_stateid, RD_STATE, NULL,
|
|
|
|
&stid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
cn->cpn_sec = nn->nfsd4_lease;
|
|
|
|
cn->cpn_nsec = 0;
|
|
|
|
|
|
|
|
status = nfserrno(-ENOMEM);
|
|
|
|
cps = nfs4_alloc_init_cpntf_state(nn, stid);
|
|
|
|
if (!cps)
|
|
|
|
goto out;
|
2022-09-22 17:10:35 +00:00
|
|
|
memcpy(&cn->cpn_cnr_stateid, &cps->cp_stateid.cs_stid, sizeof(stateid_t));
|
2019-10-04 20:34:26 +00:00
|
|
|
memcpy(&cps->cp_p_stateid, &stid->sc_stateid, sizeof(stateid_t));
|
|
|
|
memcpy(&cps->cp_p_clid, &clp->cl_clientid, sizeof(clientid_t));
|
|
|
|
|
|
|
|
/* For now, only return one server address in cpn_src, the
|
|
|
|
* address used by the client to connect to this server.
|
|
|
|
*/
|
2022-07-27 18:40:16 +00:00
|
|
|
cn->cpn_src->nl4_type = NL4_NETADDR;
|
2019-10-04 20:34:26 +00:00
|
|
|
status = nfsd4_set_netaddr((struct sockaddr *)&rqstp->rq_daddr,
|
2022-07-27 18:40:16 +00:00
|
|
|
&cn->cpn_src->u.nl4_addr);
|
2019-10-04 20:34:26 +00:00
|
|
|
WARN_ON_ONCE(status);
|
|
|
|
if (status) {
|
|
|
|
nfs4_put_cpntf_state(nn, cps);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
nfs4_put_stid(stid);
|
|
|
|
return status;
|
2019-08-08 15:14:59 +00:00
|
|
|
}
|
|
|
|
|
2014-11-07 19:44:26 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_fallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_fallocate *fallocate, int flags)
|
|
|
|
{
|
2018-11-06 22:44:03 +00:00
|
|
|
__be32 status;
|
2019-08-18 18:18:54 +00:00
|
|
|
struct nfsd_file *nf;
|
2014-11-07 19:44:26 +00:00
|
|
|
|
2015-12-03 11:59:51 +00:00
|
|
|
status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
|
2014-11-07 19:44:26 +00:00
|
|
|
&fallocate->falloc_stateid,
|
2019-10-04 20:34:26 +00:00
|
|
|
WR_STATE, &nf, NULL);
|
2022-10-28 14:46:57 +00:00
|
|
|
if (status != nfs_ok)
|
2014-11-07 19:44:26 +00:00
|
|
|
return status;
|
|
|
|
|
2019-08-18 18:18:54 +00:00
|
|
|
status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, nf->nf_file,
|
2014-11-07 19:44:26 +00:00
|
|
|
fallocate->falloc_offset,
|
|
|
|
fallocate->falloc_length,
|
|
|
|
flags);
|
2019-08-18 18:18:54 +00:00
|
|
|
nfsd_file_put(nf);
|
2014-11-07 19:44:26 +00:00
|
|
|
return status;
|
|
|
|
}
|
2023-01-18 17:31:34 +00:00
|
|
|
|
2018-07-20 22:19:18 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_offload_status(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
|
|
|
{
|
2018-07-20 22:19:20 +00:00
|
|
|
struct nfsd4_offload_status *os = &u->offload_status;
|
2023-01-18 17:31:34 +00:00
|
|
|
__be32 status = nfs_ok;
|
2018-07-20 22:19:20 +00:00
|
|
|
struct nfsd4_copy *copy;
|
|
|
|
struct nfs4_client *clp = cstate->clp;
|
|
|
|
|
2023-01-18 17:31:34 +00:00
|
|
|
spin_lock(&clp->async_lock);
|
|
|
|
copy = find_async_copy_locked(clp, &os->stateid);
|
|
|
|
if (copy)
|
2018-07-20 22:19:20 +00:00
|
|
|
os->count = copy->cp_res.wr_bytes_written;
|
2023-01-18 17:31:34 +00:00
|
|
|
else
|
2018-07-20 22:19:20 +00:00
|
|
|
status = nfserr_bad_stateid;
|
2023-01-18 17:31:34 +00:00
|
|
|
spin_unlock(&clp->async_lock);
|
2018-07-20 22:19:20 +00:00
|
|
|
|
|
|
|
return status;
|
2018-07-20 22:19:18 +00:00
|
|
|
}
|
2014-11-07 19:44:26 +00:00
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_allocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2014-11-07 19:44:26 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
return nfsd4_fallocate(rqstp, cstate, &u->allocate, 0);
|
2014-11-07 19:44:26 +00:00
|
|
|
}
|
|
|
|
|
2014-11-07 19:44:27 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_deallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2014-11-07 19:44:27 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
return nfsd4_fallocate(rqstp, cstate, &u->deallocate,
|
2014-11-07 19:44:27 +00:00
|
|
|
FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE);
|
|
|
|
}
|
|
|
|
|
2014-09-26 17:58:27 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_seek(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2014-09-26 17:58:27 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_seek *seek = &u->seek;
|
2014-09-26 17:58:27 +00:00
|
|
|
int whence;
|
|
|
|
__be32 status;
|
2019-08-18 18:18:54 +00:00
|
|
|
struct nfsd_file *nf;
|
2014-09-26 17:58:27 +00:00
|
|
|
|
2015-12-03 11:59:51 +00:00
|
|
|
status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
|
2014-09-26 17:58:27 +00:00
|
|
|
&seek->seek_stateid,
|
2019-10-04 20:34:26 +00:00
|
|
|
RD_STATE, &nf, NULL);
|
2022-10-28 14:46:57 +00:00
|
|
|
if (status)
|
2014-09-26 17:58:27 +00:00
|
|
|
return status;
|
|
|
|
|
|
|
|
switch (seek->seek_whence) {
|
|
|
|
case NFS4_CONTENT_DATA:
|
|
|
|
whence = SEEK_DATA;
|
|
|
|
break;
|
|
|
|
case NFS4_CONTENT_HOLE:
|
|
|
|
whence = SEEK_HOLE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
status = nfserr_union_notsupp;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: This call does change file->f_pos, but nothing in NFSD
|
|
|
|
* should ever file->f_pos.
|
|
|
|
*/
|
2019-08-18 18:18:54 +00:00
|
|
|
seek->seek_pos = vfs_llseek(nf->nf_file, seek->seek_offset, whence);
|
2014-09-26 17:58:27 +00:00
|
|
|
if (seek->seek_pos < 0)
|
|
|
|
status = nfserrno(seek->seek_pos);
|
2019-08-18 18:18:54 +00:00
|
|
|
else if (seek->seek_pos >= i_size_read(file_inode(nf->nf_file)))
|
2014-09-26 17:58:27 +00:00
|
|
|
seek->seek_eof = true;
|
|
|
|
|
|
|
|
out:
|
2019-08-18 18:18:54 +00:00
|
|
|
nfsd_file_put(nf);
|
2014-09-26 17:58:27 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* 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
|
|
|
|
2012-12-14 22:57:50 +00:00
|
|
|
p = buf;
|
2013-08-26 20:04:46 +00:00
|
|
|
status = nfsd4_encode_fattr_to_buf(&p, count, &cstate->current_fh,
|
2006-12-13 08:35:27 +00:00
|
|
|
cstate->current_fh.fh_export,
|
2013-08-26 20:04:46 +00:00
|
|
|
cstate->current_fh.fh_dentry,
|
|
|
|
verify->ve_bmval,
|
2007-11-27 19:34:05 +00:00
|
|
|
rqstp, 0);
|
2013-08-21 19:32:50 +00:00
|
|
|
/*
|
|
|
|
* If nfsd4_encode_fattr() ran out of space, assume that's because
|
|
|
|
* the attributes are longer (hence different) than those given:
|
|
|
|
*/
|
2012-12-14 22:57:50 +00:00
|
|
|
if (status == nfserr_resource)
|
2005-04-16 22:20:36 +00:00
|
|
|
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,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2006-12-13 08:35:31 +00:00
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
|
2017-05-08 18:58:35 +00:00
|
|
|
status = _nfsd4_verify(rqstp, cstate, &u->verify);
|
2006-12-13 08:35:31 +00:00
|
|
|
return status == nfserr_not_same ? nfs_ok : status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 18:58:35 +00:00
|
|
|
union nfsd4_op_u *u)
|
2006-12-13 08:35:31 +00:00
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
|
2017-05-08 18:58:35 +00:00
|
|
|
status = _nfsd4_verify(rqstp, cstate, &u->nverify);
|
2006-12-13 08:35:31 +00:00
|
|
|
return status == nfserr_same ? nfs_ok : status;
|
|
|
|
}
|
|
|
|
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
|
|
|
static const struct nfsd4_layout_ops *
|
|
|
|
nfsd4_layout_verify(struct svc_export *exp, unsigned int layout_type)
|
|
|
|
{
|
2016-07-10 19:55:58 +00:00
|
|
|
if (!exp->ex_layout_types) {
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
dprintk("%s: export does not support pNFS\n", __func__);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-05-05 20:07:55 +00:00
|
|
|
if (layout_type >= LAYOUT_TYPE_MAX ||
|
|
|
|
!(exp->ex_layout_types & (1 << layout_type))) {
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
dprintk("%s: layout type %d not supported\n",
|
|
|
|
__func__, layout_type);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return nfsd4_layout_ops[layout_type];
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_getdeviceinfo(struct svc_rqst *rqstp,
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo;
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
const struct nfsd4_layout_ops *ops;
|
|
|
|
struct nfsd4_deviceid_map *map;
|
|
|
|
struct svc_export *exp;
|
|
|
|
__be32 nfserr;
|
|
|
|
|
|
|
|
dprintk("%s: layout_type %u dev_id [0x%llx:0x%x] maxcnt %u\n",
|
|
|
|
__func__,
|
|
|
|
gdp->gd_layout_type,
|
|
|
|
gdp->gd_devid.fsid_idx, gdp->gd_devid.generation,
|
|
|
|
gdp->gd_maxcount);
|
|
|
|
|
|
|
|
map = nfsd4_find_devid_map(gdp->gd_devid.fsid_idx);
|
|
|
|
if (!map) {
|
|
|
|
dprintk("%s: couldn't find device ID to export mapping!\n",
|
|
|
|
__func__);
|
|
|
|
return nfserr_noent;
|
|
|
|
}
|
|
|
|
|
|
|
|
exp = rqst_exp_find(rqstp, map->fsid_type, map->fsid);
|
|
|
|
if (IS_ERR(exp)) {
|
|
|
|
dprintk("%s: could not find device id\n", __func__);
|
|
|
|
return nfserr_noent;
|
|
|
|
}
|
|
|
|
|
|
|
|
nfserr = nfserr_layoutunavailable;
|
|
|
|
ops = nfsd4_layout_verify(exp, gdp->gd_layout_type);
|
|
|
|
if (!ops)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
nfserr = nfs_ok;
|
2016-03-04 19:46:17 +00:00
|
|
|
if (gdp->gd_maxcount != 0) {
|
|
|
|
nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb,
|
2021-01-21 22:57:45 +00:00
|
|
|
rqstp, cstate->clp, gdp);
|
2016-03-04 19:46:17 +00:00
|
|
|
}
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
|
|
|
|
gdp->gd_notify_types &= ops->notify_types;
|
|
|
|
out:
|
2015-03-15 15:12:15 +00:00
|
|
|
exp_put(exp);
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2017-05-05 21:09:37 +00:00
|
|
|
static void
|
|
|
|
nfsd4_getdeviceinfo_release(union nfsd4_op_u *u)
|
|
|
|
{
|
|
|
|
kfree(u->getdeviceinfo.gd_device);
|
|
|
|
}
|
|
|
|
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_layoutget(struct svc_rqst *rqstp,
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_layoutget *lgp = &u->layoutget;
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
struct svc_fh *current_fh = &cstate->current_fh;
|
|
|
|
const struct nfsd4_layout_ops *ops;
|
|
|
|
struct nfs4_layout_stateid *ls;
|
|
|
|
__be32 nfserr;
|
2017-12-19 14:35:25 +00:00
|
|
|
int accmode = NFSD_MAY_READ_IF_EXEC;
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
|
|
|
|
switch (lgp->lg_seg.iomode) {
|
|
|
|
case IOMODE_READ:
|
2017-12-19 14:35:25 +00:00
|
|
|
accmode |= NFSD_MAY_READ;
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
break;
|
|
|
|
case IOMODE_RW:
|
2017-12-19 14:35:25 +00:00
|
|
|
accmode |= NFSD_MAY_READ | NFSD_MAY_WRITE;
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dprintk("%s: invalid iomode %d\n",
|
|
|
|
__func__, lgp->lg_seg.iomode);
|
|
|
|
nfserr = nfserr_badiomode;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
nfserr = fh_verify(rqstp, current_fh, 0, accmode);
|
|
|
|
if (nfserr)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
nfserr = nfserr_layoutunavailable;
|
|
|
|
ops = nfsd4_layout_verify(current_fh->fh_export, lgp->lg_layout_type);
|
|
|
|
if (!ops)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Verify minlength and range as per RFC5661:
|
|
|
|
* o If loga_length is less than loga_minlength,
|
|
|
|
* the metadata server MUST return NFS4ERR_INVAL.
|
|
|
|
* o If the sum of loga_offset and loga_minlength exceeds
|
|
|
|
* NFS4_UINT64_MAX, and loga_minlength is not
|
|
|
|
* NFS4_UINT64_MAX, the error NFS4ERR_INVAL MUST result.
|
|
|
|
* o If the sum of loga_offset and loga_length exceeds
|
|
|
|
* NFS4_UINT64_MAX, and loga_length is not NFS4_UINT64_MAX,
|
|
|
|
* the error NFS4ERR_INVAL MUST result.
|
|
|
|
*/
|
|
|
|
nfserr = nfserr_inval;
|
|
|
|
if (lgp->lg_seg.length < lgp->lg_minlength ||
|
|
|
|
(lgp->lg_minlength != NFS4_MAX_UINT64 &&
|
|
|
|
lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) ||
|
|
|
|
(lgp->lg_seg.length != NFS4_MAX_UINT64 &&
|
|
|
|
lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset))
|
|
|
|
goto out;
|
|
|
|
if (lgp->lg_seg.length == 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lgp->lg_sid,
|
|
|
|
true, lgp->lg_layout_type, &ls);
|
2014-08-17 00:02:22 +00:00
|
|
|
if (nfserr) {
|
2018-03-27 14:53:11 +00:00
|
|
|
trace_nfsd_layout_get_lookup_fail(&lgp->lg_sid);
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
goto out;
|
2014-08-17 00:02:22 +00:00
|
|
|
}
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
|
2014-09-23 10:38:48 +00:00
|
|
|
nfserr = nfserr_recallconflict;
|
|
|
|
if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls))
|
|
|
|
goto out_put_stid;
|
|
|
|
|
2015-03-17 22:25:59 +00:00
|
|
|
nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry),
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
current_fh, lgp);
|
|
|
|
if (nfserr)
|
|
|
|
goto out_put_stid;
|
|
|
|
|
|
|
|
nfserr = nfsd4_insert_layout(lgp, ls);
|
|
|
|
|
|
|
|
out_put_stid:
|
2015-09-17 11:58:24 +00:00
|
|
|
mutex_unlock(&ls->ls_mutex);
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
nfs4_put_stid(&ls->ls_stid);
|
|
|
|
out:
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2017-05-05 21:09:37 +00:00
|
|
|
static void
|
|
|
|
nfsd4_layoutget_release(union nfsd4_op_u *u)
|
|
|
|
{
|
|
|
|
kfree(u->layoutget.lg_content);
|
|
|
|
}
|
|
|
|
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_layoutcommit(struct svc_rqst *rqstp,
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_layoutcommit *lcp = &u->layoutcommit;
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
const struct nfsd4_layout_seg *seg = &lcp->lc_seg;
|
|
|
|
struct svc_fh *current_fh = &cstate->current_fh;
|
|
|
|
const struct nfsd4_layout_ops *ops;
|
|
|
|
loff_t new_size = lcp->lc_last_wr + 1;
|
|
|
|
struct inode *inode;
|
|
|
|
struct nfs4_layout_stateid *ls;
|
|
|
|
__be32 nfserr;
|
|
|
|
|
|
|
|
nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_WRITE);
|
|
|
|
if (nfserr)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
nfserr = nfserr_layoutunavailable;
|
|
|
|
ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type);
|
|
|
|
if (!ops)
|
|
|
|
goto out;
|
2015-03-17 22:25:59 +00:00
|
|
|
inode = d_inode(current_fh->fh_dentry);
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
|
|
|
|
nfserr = nfserr_inval;
|
|
|
|
if (new_size <= seg->offset) {
|
|
|
|
dprintk("pnfsd: last write before layout segment\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (new_size > seg->offset + seg->length) {
|
|
|
|
dprintk("pnfsd: last write beyond layout segment\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (!lcp->lc_newoffset && new_size > i_size_read(inode)) {
|
|
|
|
dprintk("pnfsd: layoutcommit beyond EOF\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lcp->lc_sid,
|
|
|
|
false, lcp->lc_layout_type,
|
|
|
|
&ls);
|
|
|
|
if (nfserr) {
|
2018-03-27 14:53:11 +00:00
|
|
|
trace_nfsd_layout_commit_lookup_fail(&lcp->lc_sid);
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
/* fixup error code as per RFC5661 */
|
|
|
|
if (nfserr == nfserr_bad_stateid)
|
|
|
|
nfserr = nfserr_badlayout;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-09-17 11:58:24 +00:00
|
|
|
/* LAYOUTCOMMIT does not require any serialization */
|
|
|
|
mutex_unlock(&ls->ls_mutex);
|
|
|
|
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
if (new_size > i_size_read(inode)) {
|
|
|
|
lcp->lc_size_chg = 1;
|
|
|
|
lcp->lc_newsize = new_size;
|
|
|
|
} else {
|
|
|
|
lcp->lc_size_chg = 0;
|
|
|
|
}
|
|
|
|
|
2015-07-07 02:12:03 +00:00
|
|
|
nfserr = ops->proc_layoutcommit(inode, lcp);
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
nfs4_put_stid(&ls->ls_stid);
|
|
|
|
out:
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_layoutreturn(struct svc_rqst *rqstp,
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
{
|
2017-05-08 18:58:35 +00:00
|
|
|
struct nfsd4_layoutreturn *lrp = &u->layoutreturn;
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
struct svc_fh *current_fh = &cstate->current_fh;
|
|
|
|
__be32 nfserr;
|
|
|
|
|
|
|
|
nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_NOP);
|
|
|
|
if (nfserr)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
nfserr = nfserr_layoutunavailable;
|
|
|
|
if (!nfsd4_layout_verify(current_fh->fh_export, lrp->lr_layout_type))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
switch (lrp->lr_seg.iomode) {
|
|
|
|
case IOMODE_READ:
|
|
|
|
case IOMODE_RW:
|
|
|
|
case IOMODE_ANY:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dprintk("%s: invalid iomode %d\n", __func__,
|
|
|
|
lrp->lr_seg.iomode);
|
|
|
|
nfserr = nfserr_inval;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (lrp->lr_return_type) {
|
|
|
|
case RETURN_FILE:
|
|
|
|
nfserr = nfsd4_return_file_layouts(rqstp, cstate, lrp);
|
|
|
|
break;
|
|
|
|
case RETURN_FSID:
|
|
|
|
case RETURN_ALL:
|
|
|
|
nfserr = nfsd4_return_client_layouts(rqstp, cstate, lrp);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dprintk("%s: invalid return_type %d\n", __func__,
|
|
|
|
lrp->lr_return_type);
|
|
|
|
nfserr = nfserr_inval;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NFSD_PNFS */
|
|
|
|
|
2020-06-23 22:39:26 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_getxattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
|
|
|
{
|
|
|
|
struct nfsd4_getxattr *getxattr = &u->getxattr;
|
|
|
|
|
|
|
|
return nfsd_getxattr(rqstp, &cstate->current_fh,
|
|
|
|
getxattr->getxa_name, &getxattr->getxa_buf,
|
|
|
|
&getxattr->getxa_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_setxattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
|
|
|
{
|
|
|
|
struct nfsd4_setxattr *setxattr = &u->setxattr;
|
|
|
|
__be32 ret;
|
|
|
|
|
|
|
|
if (opens_in_grace(SVC_NET(rqstp)))
|
|
|
|
return nfserr_grace;
|
|
|
|
|
|
|
|
ret = nfsd_setxattr(rqstp, &cstate->current_fh, setxattr->setxa_name,
|
|
|
|
setxattr->setxa_buf, setxattr->setxa_len,
|
|
|
|
setxattr->setxa_flags);
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
set_change_info(&setxattr->setxa_cinfo, &cstate->current_fh);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_listxattrs(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Get the entire list, then copy out only the user attributes
|
|
|
|
* in the encode function.
|
|
|
|
*/
|
|
|
|
return nfsd_listxattr(rqstp, &cstate->current_fh,
|
|
|
|
&u->listxattrs.lsxa_buf, &u->listxattrs.lsxa_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_removexattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
|
|
|
{
|
|
|
|
struct nfsd4_removexattr *removexattr = &u->removexattr;
|
|
|
|
__be32 ret;
|
|
|
|
|
|
|
|
if (opens_in_grace(SVC_NET(rqstp)))
|
|
|
|
return nfserr_grace;
|
|
|
|
|
|
|
|
ret = nfsd_removexattr(rqstp, &cstate->current_fh,
|
|
|
|
removexattr->rmxa_name);
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
set_change_info(&removexattr->rmxa_cinfo, &cstate->current_fh);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* NULL call.
|
|
|
|
*/
|
2006-10-20 06:28:45 +00:00
|
|
|
static __be32
|
2017-05-08 15:35:49 +00:00
|
|
|
nfsd4_proc_null(struct svc_rqst *rqstp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2020-10-02 19:52:44 +00:00
|
|
|
return rpc_success;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
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)
|
2021-01-06 07:52:35 +00:00
|
|
|
percpu_counter_inc(&nfsdstats.counter[NFSD_STATS_NFS4_OP(opnum)]);
|
2006-07-10 11:45:44 +00:00
|
|
|
}
|
|
|
|
|
2017-05-08 21:46:47 +00:00
|
|
|
static const struct nfsd4_operation nfsd4_ops[];
|
2006-12-13 08:35:38 +00:00
|
|
|
|
2008-08-08 16:26:42 +00:00
|
|
|
static const char *nfsd4_op_name(unsigned opnum);
|
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
|
|
|
{
|
2018-06-13 19:04:59 +00:00
|
|
|
struct nfsd4_op *first_op = &args->ops[0];
|
2010-04-21 16:27:19 +00:00
|
|
|
|
|
|
|
/* 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;
|
2018-06-13 19:04:59 +00:00
|
|
|
if (first_op->status == nfserr_op_illegal)
|
2010-04-21 16:27:19 +00:00
|
|
|
return nfs_ok;
|
2018-06-13 19:04:59 +00:00
|
|
|
if (!(nfsd4_ops[first_op->opnum].op_flags & ALLOWED_AS_FIRST_OP))
|
2010-04-21 16:27:19 +00:00
|
|
|
return nfserr_op_not_in_session;
|
2018-06-13 19:04:59 +00:00
|
|
|
if (first_op->opnum == OP_SEQUENCE)
|
2010-04-21 16:27:19 +00:00
|
|
|
return nfs_ok;
|
2018-06-13 19:04:59 +00:00
|
|
|
/*
|
|
|
|
* So first_op is something allowed outside a session, like
|
|
|
|
* EXCHANGE_ID; but then it has to be the only op in the
|
|
|
|
* compound:
|
|
|
|
*/
|
2010-04-21 16:27:19 +00:00
|
|
|
if (args->opcnt != 1)
|
|
|
|
return nfserr_not_only_op;
|
|
|
|
return nfs_ok;
|
2009-04-03 05:28:12 +00:00
|
|
|
}
|
|
|
|
|
2017-07-06 21:51:29 +00:00
|
|
|
const struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
|
2011-04-09 15:23:24 +00:00
|
|
|
{
|
|
|
|
return &nfsd4_ops[op->opnum];
|
|
|
|
}
|
|
|
|
|
2011-01-24 17:11:02 +00:00
|
|
|
bool nfsd4_cache_this_op(struct nfsd4_op *op)
|
|
|
|
{
|
2014-05-19 16:27:11 +00:00
|
|
|
if (op->opnum == OP_ILLEGAL)
|
|
|
|
return false;
|
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];
|
2017-05-08 21:46:47 +00:00
|
|
|
const struct nfsd4_operation *thisd = OPDESC(this);
|
|
|
|
const struct nfsd4_operation *nextd;
|
2011-04-08 21:00:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2014-10-22 18:46:29 +00:00
|
|
|
if (next->opnum == OP_ILLEGAL)
|
|
|
|
return false;
|
2011-04-08 21:00:50 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2019-10-07 14:56:48 +00:00
|
|
|
#ifdef CONFIG_NFSD_V4_2_INTER_SSC
|
|
|
|
static void
|
|
|
|
check_if_stalefh_allowed(struct nfsd4_compoundargs *args)
|
|
|
|
{
|
|
|
|
struct nfsd4_op *op, *current_op = NULL, *saved_op = NULL;
|
|
|
|
struct nfsd4_copy *copy;
|
|
|
|
struct nfsd4_putfh *putfh;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* traverse all operation and if it's a COPY compound, mark the
|
|
|
|
* source filehandle to skip verification
|
|
|
|
*/
|
|
|
|
for (i = 0; i < args->opcnt; i++) {
|
|
|
|
op = &args->ops[i];
|
|
|
|
if (op->opnum == OP_PUTFH)
|
|
|
|
current_op = op;
|
|
|
|
else if (op->opnum == OP_SAVEFH)
|
|
|
|
saved_op = current_op;
|
|
|
|
else if (op->opnum == OP_RESTOREFH)
|
|
|
|
current_op = saved_op;
|
|
|
|
else if (op->opnum == OP_COPY) {
|
|
|
|
copy = (struct nfsd4_copy *)&op->u;
|
|
|
|
if (!saved_op) {
|
|
|
|
op->status = nfserr_nofilehandle;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
putfh = (struct nfsd4_putfh *)&saved_op->u;
|
2022-07-27 18:40:41 +00:00
|
|
|
if (nfsd4_ssc_is_inter(copy))
|
2019-10-07 14:56:48 +00:00
|
|
|
putfh->no_verify = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void
|
|
|
|
check_if_stalefh_allowed(struct nfsd4_compoundargs *args)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* COMPOUND call.
|
|
|
|
*/
|
2006-10-20 06:28:45 +00:00
|
|
|
static __be32
|
2017-05-08 15:35:49 +00:00
|
|
|
nfsd4_proc_compound(struct svc_rqst *rqstp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-08 15:35:49 +00:00
|
|
|
struct nfsd4_compoundargs *args = rqstp->rq_argp;
|
|
|
|
struct nfsd4_compoundres *resp = rqstp->rq_resp;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct nfsd4_op *op;
|
2009-03-28 08:30:52 +00:00
|
|
|
struct nfsd4_compound_state *cstate = &resp->cstate;
|
2014-03-26 09:10:37 +00:00
|
|
|
struct svc_fh *current_fh = &cstate->current_fh;
|
|
|
|
struct svc_fh *save_fh = &cstate->save_fh;
|
2019-04-09 15:46:19 +00:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-10-27 19:53:42 +00:00
|
|
|
resp->xdr = &rqstp->rq_res_stream;
|
2021-10-13 14:40:59 +00:00
|
|
|
resp->statusp = resp->xdr->p;
|
2020-10-27 19:53:42 +00:00
|
|
|
|
|
|
|
/* reserve space for: NFS status code */
|
|
|
|
xdr_reserve_space(resp->xdr, XDR_UNIT);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* reserve space for: taglen, tag, and opcnt */
|
2020-10-27 19:53:42 +00:00
|
|
|
xdr_reserve_space(resp->xdr, XDR_UNIT * 2 + args->taglen);
|
2005-04-16 22:20:36 +00:00
|
|
|
resp->taglen = args->taglen;
|
|
|
|
resp->tag = args->tag;
|
|
|
|
resp->rqstp = rqstp;
|
2014-03-26 09:10:37 +00:00
|
|
|
cstate->minorversion = args->minorversion;
|
|
|
|
fh_init(current_fh, NFS4_FHSIZE);
|
|
|
|
fh_init(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.
|
|
|
|
*/
|
2023-01-06 17:43:37 +00:00
|
|
|
clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* According to RFC3010, this takes precedence over all other errors.
|
|
|
|
*/
|
|
|
|
status = nfserr_minor_vers_mismatch;
|
2019-04-09 15:46:19 +00:00
|
|
|
if (nfsd_minorversion(nn, args->minorversion, NFSD_TEST) <= 0)
|
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;
|
2018-06-13 19:21:35 +00:00
|
|
|
resp->opcnt = 1;
|
2009-04-03 05:28:12 +00:00
|
|
|
goto encode_op;
|
|
|
|
}
|
2019-10-07 14:56:48 +00:00
|
|
|
check_if_stalefh_allowed(args);
|
2009-04-03 05:28:12 +00:00
|
|
|
|
2017-07-28 20:35:15 +00:00
|
|
|
rqstp->rq_lease_breaker = (void **)&cstate->clp;
|
|
|
|
|
2022-09-08 22:13:48 +00:00
|
|
|
trace_nfsd_compound(rqstp, args->tag, args->taglen, args->client_opcnt);
|
2005-04-16 22:20:36 +00:00
|
|
|
while (!status && resp->opcnt < args->opcnt) {
|
|
|
|
op = &args->ops[resp->opcnt++];
|
|
|
|
|
2022-09-05 19:33:32 +00:00
|
|
|
if (unlikely(resp->opcnt == NFSD_MAX_OPS_PER_COMPOUND)) {
|
|
|
|
/* If there are still more operations to process,
|
|
|
|
* stop here and report NFS4ERR_RESOURCE. */
|
|
|
|
if (cstate->minorversion == 0 &&
|
|
|
|
args->client_opcnt > resp->opcnt) {
|
|
|
|
op->status = nfserr_resource;
|
|
|
|
goto encode_op;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
*/
|
2013-02-28 20:51:49 +00:00
|
|
|
if (op->status) {
|
|
|
|
if (op->opnum == OP_OPEN)
|
|
|
|
op->status = nfsd4_open_omfg(rqstp, cstate, op);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto encode_op;
|
2013-02-28 20:51:49 +00:00
|
|
|
}
|
2019-10-07 14:56:48 +00:00
|
|
|
if (!current_fh->fh_dentry &&
|
|
|
|
!HAS_FH_FLAG(current_fh, NFSD4_FH_FOREIGN)) {
|
2017-07-06 21:51:29 +00:00
|
|
|
if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
|
2006-10-04 09:16:20 +00:00
|
|
|
op->status = nfserr_nofilehandle;
|
|
|
|
goto encode_op;
|
|
|
|
}
|
2019-10-07 14:56:48 +00:00
|
|
|
} else if (current_fh->fh_export &&
|
|
|
|
current_fh->fh_export->ex_fslocs.migrated &&
|
2017-07-06 21:51:29 +00:00
|
|
|
!(op->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
|
|
|
|
2021-12-24 19:36:49 +00:00
|
|
|
fh_clear_pre_post_attrs(current_fh);
|
2014-03-29 02:23:47 +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 */
|
2017-07-06 21:51:29 +00:00
|
|
|
if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) {
|
2014-01-28 21:01:04 +00:00
|
|
|
/*
|
2014-03-11 21:54:34 +00:00
|
|
|
* Don't execute this op if we couldn't encode a
|
2022-06-23 08:20:05 +00:00
|
|
|
* successful reply:
|
2014-03-11 21:54:34 +00:00
|
|
|
*/
|
2017-07-06 21:51:29 +00:00
|
|
|
u32 plen = op->opdesc->op_rsize_bop(rqstp, op);
|
2014-03-11 21:54:34 +00:00
|
|
|
/*
|
|
|
|
* Plus if there's another operation, make sure
|
2014-01-28 21:01:04 +00:00
|
|
|
* we'll have space to at least encode an error:
|
|
|
|
*/
|
|
|
|
if (resp->opcnt < args->opcnt)
|
|
|
|
plen += COMPOUND_ERR_SLACK_SPACE;
|
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->status = nfsd4_check_resp_size(resp, plen);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (op->status)
|
|
|
|
goto encode_op;
|
|
|
|
|
2017-07-06 21:51:29 +00:00
|
|
|
if (op->opdesc->op_get_currentstateid)
|
|
|
|
op->opdesc->op_get_currentstateid(cstate, &op->u);
|
|
|
|
op->status = op->opdesc->op_func(rqstp, cstate, &op->u);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
nfsd4: fix null dereference on replay
if we receive a compound such that:
- the sessionid, slot, and sequence number in the SEQUENCE op
match a cached succesful reply with N ops, and
- the Nth operation of the compound is a PUTFH, PUTPUBFH,
PUTROOTFH, or RESTOREFH,
then nfsd4_sequence will return 0 and set cstate->status to
nfserr_replay_cache. The current filehandle will not be set. This will
cause us to call check_nfsd_access with first argument NULL.
To nfsd4_compound it looks like we just succesfully executed an
operation that set a filehandle, but the current filehandle is not set.
Fix this by moving the nfserr_replay_cache earlier. There was never any
reason to have it after the encode_op label, since the only case where
he hit that is when opdesc->op_func sets it.
Note that there are two ways we could hit this case:
- a client is resending a previously sent compound that ended
with one of the four PUTFH-like operations, or
- a client is sending a *new* compound that (incorrectly) shares
sessionid, slot, and sequence number with a previously sent
compound, and the length of the previously sent compound
happens to match the position of a PUTFH-like operation in the
new compound.
The second is obviously incorrect client behavior. The first is also
very strange--the only purpose of a PUTFH-like operation is to set the
current filehandle to be used by the following operation, so there's no
point in having it as the last in a compound.
So it's likely this requires a buggy or malicious client to reproduce.
Reported-by: Scott Mayhew <smayhew@redhat.com>
Cc: stable@kernel.vger.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-05-23 16:24:40 +00:00
|
|
|
/* Only from SEQUENCE */
|
|
|
|
if (cstate->status == nfserr_replay_cache) {
|
|
|
|
dprintk("%s NFS4.1 replay from cache\n", __func__);
|
|
|
|
status = op->status;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-02-13 21:55:24 +00:00
|
|
|
if (!op->status) {
|
2017-07-06 21:51:29 +00:00
|
|
|
if (op->opdesc->op_set_currentstateid)
|
|
|
|
op->opdesc->op_set_currentstateid(cstate, &op->u);
|
2012-02-13 21:55:24 +00:00
|
|
|
|
2017-07-06 21:51:29 +00:00
|
|
|
if (op->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
|
|
|
|
2019-12-06 21:07:32 +00:00
|
|
|
if (current_fh->fh_export &&
|
|
|
|
need_wrongsec_check(rqstp))
|
2014-03-26 09:10:37 +00:00
|
|
|
op->status = check_nfsd_access(current_fh->fh_export, rqstp);
|
2012-02-13 21:55:24 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
encode_op:
|
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;
|
2020-10-27 19:53:42 +00:00
|
|
|
nfsd4_encode_replay(resp->xdr, op);
|
2005-04-16 22:20:36 +00:00
|
|
|
status = op->status = op->replay->rp_status;
|
|
|
|
} else {
|
|
|
|
nfsd4_encode_operation(resp, op);
|
|
|
|
status = op->status;
|
|
|
|
}
|
2008-12-15 17:40:49 +00:00
|
|
|
|
2022-09-05 19:33:32 +00:00
|
|
|
trace_nfsd_compound_status(args->client_opcnt, resp->opcnt,
|
|
|
|
status, nfsd4_op_name(op->opnum));
|
2008-12-15 17:40:49 +00:00
|
|
|
|
2014-07-30 01:34:27 +00:00
|
|
|
nfsd4_cstate_clear_replay(cstate);
|
2006-07-10 11:45:44 +00:00
|
|
|
nfsd4_increment_op_stats(op->opnum);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-03-26 09:10:37 +00:00
|
|
|
fh_put(current_fh);
|
|
|
|
fh_put(save_fh);
|
|
|
|
BUG_ON(cstate->replay_owner);
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
2020-10-02 19:52:44 +00:00
|
|
|
cstate->status = status;
|
2009-04-03 05:27:32 +00:00
|
|
|
/* Reset deferral mechanism for RPC deferrals */
|
2023-01-06 17:43:37 +00:00
|
|
|
set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
|
2020-10-02 19:52:44 +00:00
|
|
|
return rpc_success;
|
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
|
|
|
#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)
|
|
|
|
|
2014-03-10 16:19:10 +00:00
|
|
|
/* We'll fall back on returning no lockowner if run out of space: */
|
|
|
|
#define op_encode_lockowner_maxsz (0)
|
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_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)
|
|
|
|
|
2022-09-01 19:29:55 +00:00
|
|
|
/*
|
|
|
|
* The _rsize() helpers are invoked by the NFSv4 COMPOUND decoder, which
|
|
|
|
* is called before sunrpc sets rq_res.buflen. Thus we have to compute
|
|
|
|
* the maximum payload size here, based on transport limits and the size
|
|
|
|
* of the remaining space in the rq_pages array.
|
|
|
|
*/
|
|
|
|
static u32 nfsd4_max_payload(const struct svc_rqst *rqstp)
|
|
|
|
{
|
|
|
|
u32 buflen;
|
|
|
|
|
|
|
|
buflen = (rqstp->rq_page_end - rqstp->rq_next_page) * PAGE_SIZE;
|
|
|
|
buflen -= rqstp->rq_auth_slack;
|
|
|
|
buflen -= rqstp->rq_res.head[0].iov_len;
|
|
|
|
return min_t(u32, buflen, svc_max_payload(rqstp));
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_only_status_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
return (op_encode_hdr_size) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_status_stateid_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_access_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2017-02-03 14:36:00 +00:00
|
|
|
{
|
|
|
|
/* ac_supported, ac_resp_access */
|
|
|
|
return (op_encode_hdr_size + 2)* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_commit_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_create_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_change_info_maxsz
|
|
|
|
+ nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2014-03-23 16:01:48 +00:00
|
|
|
/*
|
|
|
|
* Note since this is an idempotent operation we won't insist on failing
|
|
|
|
* the op prematurely if the estimate is too large. We may turn off splice
|
|
|
|
* reads unnecessarily.
|
|
|
|
*/
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_getattr_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2014-03-23 16:01:48 +00:00
|
|
|
{
|
2022-09-12 21:23:25 +00:00
|
|
|
const u32 *bmap = op->u.getattr.ga_bmval;
|
2014-03-23 16:01:48 +00:00
|
|
|
u32 bmap0 = bmap[0], bmap1 = bmap[1], bmap2 = bmap[2];
|
|
|
|
u32 ret = 0;
|
|
|
|
|
|
|
|
if (bmap0 & FATTR4_WORD0_ACL)
|
2022-09-01 19:29:55 +00:00
|
|
|
return nfsd4_max_payload(rqstp);
|
2014-03-23 16:01:48 +00:00
|
|
|
if (bmap0 & FATTR4_WORD0_FS_LOCATIONS)
|
2022-09-01 19:29:55 +00:00
|
|
|
return nfsd4_max_payload(rqstp);
|
2014-03-23 16:01:48 +00:00
|
|
|
|
|
|
|
if (bmap1 & FATTR4_WORD1_OWNER) {
|
|
|
|
ret += IDMAP_NAMESZ + 4;
|
|
|
|
bmap1 &= ~FATTR4_WORD1_OWNER;
|
|
|
|
}
|
|
|
|
if (bmap1 & FATTR4_WORD1_OWNER_GROUP) {
|
|
|
|
ret += IDMAP_NAMESZ + 4;
|
|
|
|
bmap1 &= ~FATTR4_WORD1_OWNER_GROUP;
|
|
|
|
}
|
|
|
|
if (bmap0 & FATTR4_WORD0_FILEHANDLE) {
|
|
|
|
ret += NFS4_FHSIZE + 4;
|
|
|
|
bmap0 &= ~FATTR4_WORD0_FILEHANDLE;
|
|
|
|
}
|
|
|
|
if (bmap2 & FATTR4_WORD2_SECURITY_LABEL) {
|
2015-03-28 15:46:09 +00:00
|
|
|
ret += NFS4_MAXLABELLEN + 12;
|
2014-03-23 16:01:48 +00:00
|
|
|
bmap2 &= ~FATTR4_WORD2_SECURITY_LABEL;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Largest of remaining attributes are 16 bytes (e.g.,
|
|
|
|
* supported_attributes)
|
|
|
|
*/
|
|
|
|
ret += 16 * (hweight32(bmap0) + hweight32(bmap1) + hweight32(bmap2));
|
|
|
|
/* bitmask, length */
|
|
|
|
ret += 20;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_getfh_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2017-02-03 14:36:00 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + 1) * sizeof(__be32) + NFS4_FHSIZE;
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_link_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_change_info_maxsz)
|
|
|
|
* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_lock_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_lock_denied_maxsz)
|
|
|
|
* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_open_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_read_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
2022-09-01 19:29:55 +00:00
|
|
|
u32 rlen = min(op->u.read.rd_length, nfsd4_max_payload(rqstp));
|
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
|
|
|
|
2014-05-16 18:38:20 +00:00
|
|
|
return (op_encode_hdr_size + 2 + XDR_QUADLEN(rlen)) * sizeof(__be32);
|
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
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_read_plus_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2020-09-28 17:08:58 +00:00
|
|
|
{
|
2022-09-01 19:29:55 +00:00
|
|
|
u32 rlen = min(op->u.read.rd_length, nfsd4_max_payload(rqstp));
|
2020-09-28 17:08:58 +00:00
|
|
|
/*
|
|
|
|
* If we detect that the file changed during hole encoding, then we
|
|
|
|
* recover by encoding the remaining reply as data. This means we need
|
|
|
|
* to set aside enough room to encode two data segments.
|
|
|
|
*/
|
|
|
|
u32 seg_len = 2 * (1 + 2 + 1);
|
|
|
|
|
|
|
|
return (op_encode_hdr_size + 2 + seg_len + XDR_QUADLEN(rlen)) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_readdir_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
2022-09-01 19:29:55 +00:00
|
|
|
u32 rlen = min(op->u.readdir.rd_maxcount, nfsd4_max_payload(rqstp));
|
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
|
|
|
|
2014-01-20 21:37:11 +00:00
|
|
|
return (op_encode_hdr_size + op_encode_verifier_maxsz +
|
|
|
|
XDR_QUADLEN(rlen)) * sizeof(__be32);
|
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
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_readlink_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2017-02-03 14:36:00 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + 1) * sizeof(__be32) + PAGE_SIZE;
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_remove_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_change_info_maxsz)
|
|
|
|
* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_rename_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_change_info_maxsz
|
|
|
|
+ op_encode_change_info_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_sequence_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2014-03-23 16:34:22 +00:00
|
|
|
{
|
2014-08-21 19:04:31 +00:00
|
|
|
return (op_encode_hdr_size
|
|
|
|
+ XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5) * sizeof(__be32);
|
2014-03-23 16:34:22 +00:00
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_test_stateid_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2017-02-03 14:36:00 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids)
|
|
|
|
* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_setattr_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_secinfo_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2017-02-03 14:36:00 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + RPC_AUTH_MAXFLAVOR *
|
|
|
|
(4 + XDR_QUADLEN(GSS_OID_MAX_LEN))) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_setclientid_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
2014-03-10 18:17:55 +00:00
|
|
|
return (op_encode_hdr_size + 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE)) *
|
|
|
|
sizeof(__be32);
|
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
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_write_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
2014-05-17 01:24:56 +00:00
|
|
|
return (op_encode_hdr_size + 2 + op_encode_verifier_maxsz) * sizeof(__be32);
|
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
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_exchange_id_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\
|
2013-12-10 07:24:36 +00:00
|
|
|
1 + 1 + /* eir_flags, spr_how */\
|
|
|
|
4 + /* spo_must_enforce & _allow with bitmap */\
|
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
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_bind_conn_to_session_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + \
|
|
|
|
XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\
|
|
|
|
2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_create_session_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
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
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_copy_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2016-09-07 19:57:30 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size +
|
|
|
|
1 /* wr_callback */ +
|
|
|
|
op_encode_stateid_maxsz /* wr_callback */ +
|
|
|
|
2 /* wr_count */ +
|
|
|
|
1 /* wr_committed */ +
|
|
|
|
op_encode_verifier_maxsz +
|
|
|
|
1 /* cr_consecutive */ +
|
|
|
|
1 /* cr_synchronous */) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_offload_status_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2018-07-20 22:19:18 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size +
|
|
|
|
2 /* osr_count */ +
|
|
|
|
1 /* osr_complete<1> optional 0 for now */) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_copy_notify_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2019-08-08 15:14:59 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size +
|
|
|
|
3 /* cnr_lease_time */ +
|
|
|
|
1 /* We support one cnr_source_server */ +
|
|
|
|
1 /* cnr_stateid seq */ +
|
|
|
|
op_encode_stateid_maxsz /* cnr_stateid */ +
|
|
|
|
1 /* num cnr_source_server*/ +
|
|
|
|
1 /* nl4_type */ +
|
|
|
|
1 /* nl4 size */ +
|
|
|
|
XDR_QUADLEN(NFS4_OPAQUE_LIMIT) /*nl4_loc + nl4_loc_sz */)
|
|
|
|
* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_getdeviceinfo_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2017-02-03 14:36:00 +00:00
|
|
|
{
|
2022-09-01 19:29:55 +00:00
|
|
|
u32 rlen = min(op->u.getdeviceinfo.gd_maxcount, nfsd4_max_payload(rqstp));
|
2017-02-03 14:36:00 +00:00
|
|
|
|
|
|
|
return (op_encode_hdr_size +
|
|
|
|
1 /* gd_layout_type*/ +
|
|
|
|
XDR_QUADLEN(rlen) +
|
|
|
|
2 /* gd_notify_types */) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
/*
|
|
|
|
* At this stage we don't really know what layout driver will handle the request,
|
|
|
|
* so we need to define an arbitrary upper bound here.
|
|
|
|
*/
|
|
|
|
#define MAX_LAYOUT_SIZE 128
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_layoutget_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size +
|
|
|
|
1 /* logr_return_on_close */ +
|
|
|
|
op_encode_stateid_maxsz +
|
|
|
|
1 /* nr of layouts */ +
|
|
|
|
MAX_LAYOUT_SIZE) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_layoutcommit_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size +
|
|
|
|
1 /* locr_newsize */ +
|
|
|
|
2 /* ns_size */) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_layoutreturn_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size +
|
|
|
|
1 /* lrs_stateid */ +
|
|
|
|
op_encode_stateid_maxsz) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NFSD_PNFS */
|
|
|
|
|
2017-02-03 14:36:00 +00:00
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_seek_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2017-02-03 14:36:00 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + 3) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_getxattr_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2020-06-23 22:39:26 +00:00
|
|
|
{
|
2022-09-01 19:29:55 +00:00
|
|
|
u32 rlen = min_t(u32, XATTR_SIZE_MAX, nfsd4_max_payload(rqstp));
|
2020-06-23 22:39:26 +00:00
|
|
|
|
|
|
|
return (op_encode_hdr_size + 1 + XDR_QUADLEN(rlen)) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_setxattr_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2020-06-23 22:39:26 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_change_info_maxsz)
|
|
|
|
* sizeof(__be32);
|
|
|
|
}
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_listxattrs_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2020-06-23 22:39:26 +00:00
|
|
|
{
|
2022-09-01 19:29:55 +00:00
|
|
|
u32 rlen = min(op->u.listxattrs.lsxa_maxcount, nfsd4_max_payload(rqstp));
|
2020-06-23 22:39:26 +00:00
|
|
|
|
|
|
|
return (op_encode_hdr_size + 4 + XDR_QUADLEN(rlen)) * sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
2022-09-12 21:23:25 +00:00
|
|
|
static u32 nfsd4_removexattr_rsize(const struct svc_rqst *rqstp,
|
|
|
|
const struct nfsd4_op *op)
|
2020-06-23 22:39:26 +00:00
|
|
|
{
|
|
|
|
return (op_encode_hdr_size + op_encode_change_info_maxsz)
|
|
|
|
* sizeof(__be32);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-05-08 21:46:47 +00:00
|
|
|
static const struct nfsd4_operation nfsd4_ops[] = {
|
2006-12-13 08:35:38 +00:00
|
|
|
[OP_ACCESS] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_access,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_ACCESS",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_access_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_CLOSE] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_status_stateid_rsize,
|
2017-05-08 18:37:33 +00:00
|
|
|
.op_get_currentstateid = nfsd4_get_closestateid,
|
2017-05-08 18:03:15 +00:00
|
|
|
.op_set_currentstateid = nfsd4_set_closestateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_COMMIT] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_commit_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_CREATE] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_create_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_DELEGRETURN] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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,
|
2017-05-08 18:37:33 +00:00
|
|
|
.op_get_currentstateid = nfsd4_get_delegreturnstateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_GETATTR] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_getattr,
|
2006-12-13 08:35:39 +00:00
|
|
|
.op_flags = ALLOWED_ON_ABSENT_FS,
|
2014-03-23 16:01:48 +00:00
|
|
|
.op_rsize_bop = nfsd4_getattr_rsize,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_GETATTR",
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_GETFH] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_getfh,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_GETFH",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_getfh_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LINK] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_link_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LOCK] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_lock,
|
2017-05-06 14:49:21 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING |
|
|
|
|
OP_NONTRIVIAL_ERROR_ENCODE,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_LOCK",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_lock_rsize,
|
2017-05-08 18:03:15 +00:00
|
|
|
.op_set_currentstateid = nfsd4_set_lockstateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LOCKT] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_lockt,
|
2017-05-06 14:49:21 +00:00
|
|
|
.op_flags = OP_NONTRIVIAL_ERROR_ENCODE,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_LOCKT",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_lock_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LOCKU] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_status_stateid_rsize,
|
2017-05-08 18:37:33 +00:00
|
|
|
.op_get_currentstateid = nfsd4_get_lockustateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LOOKUP] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_LOOKUPP] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_NVERIFY] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_nverify,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_NVERIFY",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_OPEN] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_open_rsize,
|
2017-05-08 18:03:15 +00:00
|
|
|
.op_set_currentstateid = nfsd4_set_openstateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_OPEN_CONFIRM] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_status_stateid_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_OPEN_DOWNGRADE] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_status_stateid_rsize,
|
2017-05-08 18:37:33 +00:00
|
|
|
.op_get_currentstateid = nfsd4_get_opendowngradestateid,
|
2017-05-08 18:03:15 +00:00
|
|
|
.op_set_currentstateid = nfsd4_set_opendowngradestateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_PUTFH] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_putfh,
|
2011-04-08 21:00:50 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
|
2014-03-07 16:43:58 +00:00
|
|
|
| OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_PUTFH",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
2006-12-13 08:35:39 +00:00
|
|
|
[OP_PUTPUBFH] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_putrootfh,
|
2011-04-08 21:00:50 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
|
2014-03-07 16:43:58 +00:00
|
|
|
| OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_PUTPUBFH",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2006-12-13 08:35:39 +00:00
|
|
|
},
|
2006-12-13 08:35:38 +00:00
|
|
|
[OP_PUTROOTFH] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_putrootfh,
|
2011-04-08 21:00:50 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
|
2014-03-07 16:43:58 +00:00
|
|
|
| OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_PUTROOTFH",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_READ] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_read,
|
2017-05-05 21:09:37 +00:00
|
|
|
.op_release = nfsd4_read_release,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_READ",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_read_rsize,
|
2017-05-08 18:37:33 +00:00
|
|
|
.op_get_currentstateid = nfsd4_get_readstateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_READDIR] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_readdir,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_READDIR",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_readdir_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_READLINK] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_readlink,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_READLINK",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_readlink_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_REMOVE] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_remove_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_RENAME] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_rename_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_RENEW] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
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
|
|
|
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_RESTOREFH] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_SAVEFH] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
2007-07-17 11:04:51 +00:00
|
|
|
[OP_SECINFO] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_secinfo,
|
2017-05-05 21:09:37 +00:00
|
|
|
.op_release = nfsd4_secinfo_release,
|
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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_secinfo_rsize,
|
2007-07-17 11:04:51 +00:00
|
|
|
},
|
2006-12-13 08:35:38 +00:00
|
|
|
[OP_SETATTR] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_setattr,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_SETATTR",
|
2017-05-06 14:49:21 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME
|
|
|
|
| OP_NONTRIVIAL_ERROR_ENCODE,
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_setattr_rsize,
|
2017-05-08 18:37:33 +00:00
|
|
|
.op_get_currentstateid = nfsd4_get_setattrstateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_SETCLIENTID] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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
|
2017-05-06 14:49:21 +00:00
|
|
|
| OP_MODIFIES_SOMETHING | OP_CACHEME
|
|
|
|
| OP_NONTRIVIAL_ERROR_ENCODE,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_SETCLIENTID",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_setclientid_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_SETCLIENTID_CONFIRM] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_VERIFY] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_verify,
|
2008-07-02 08:15:03 +00:00
|
|
|
.op_name = "OP_VERIFY",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_WRITE] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_write_rsize,
|
2017-05-08 18:37:33 +00:00
|
|
|
.op_get_currentstateid = nfsd4_get_writestateid,
|
2006-12-13 08:35:38 +00:00
|
|
|
},
|
|
|
|
[OP_RELEASE_LOCKOWNER] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = 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] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_exchange_id_rsize,
|
2009-04-03 05:27:58 +00:00
|
|
|
},
|
2012-11-01 22:09:48 +00:00
|
|
|
[OP_BACKCHANNEL_CTL] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_backchannel_ctl,
|
2012-11-01 22:09:48 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
|
|
|
|
.op_name = "OP_BACKCHANNEL_CTL",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2012-11-01 22:09:48 +00:00
|
|
|
},
|
2010-10-05 03:12:59 +00:00
|
|
|
[OP_BIND_CONN_TO_SESSION] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = 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] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_create_session_rsize,
|
2009-04-03 05:27:58 +00:00
|
|
|
},
|
|
|
|
[OP_DESTROY_SESSION] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2009-04-03 05:27:58 +00:00
|
|
|
},
|
|
|
|
[OP_SEQUENCE] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_sequence_rsize,
|
2009-04-03 05:27:58 +00:00
|
|
|
},
|
2011-06-16 15:39:10 +00:00
|
|
|
[OP_DESTROY_CLIENTID] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2011-06-16 15:39:10 +00:00
|
|
|
},
|
2010-04-19 19:11:28 +00:00
|
|
|
[OP_RECLAIM_COMPLETE] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2010-04-19 19:11:28 +00:00
|
|
|
},
|
2010-12-16 14:51:13 +00:00
|
|
|
[OP_SECINFO_NO_NAME] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_secinfo_no_name,
|
2017-09-29 07:01:10 +00:00
|
|
|
.op_release = nfsd4_secinfo_no_name_release,
|
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",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_secinfo_rsize,
|
2010-12-16 14:51:13 +00:00
|
|
|
},
|
2011-07-13 14:50:48 +00:00
|
|
|
[OP_TEST_STATEID] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_test_stateid,
|
2011-07-13 14:50:48 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH,
|
|
|
|
.op_name = "OP_TEST_STATEID",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_test_stateid_rsize,
|
2011-07-13 14:50:48 +00:00
|
|
|
},
|
2011-07-13 15:04:21 +00:00
|
|
|
[OP_FREE_STATEID] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_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",
|
2017-05-08 18:37:33 +00:00
|
|
|
.op_get_currentstateid = nfsd4_get_freestateid,
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2011-07-13 15:04:21 +00:00
|
|
|
},
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
|
|
|
[OP_GETDEVICEINFO] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_getdeviceinfo,
|
2017-05-05 21:09:37 +00:00
|
|
|
.op_release = nfsd4_getdeviceinfo_release,
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
.op_flags = ALLOWED_WITHOUT_FH,
|
|
|
|
.op_name = "OP_GETDEVICEINFO",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_getdeviceinfo_rsize,
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
},
|
|
|
|
[OP_LAYOUTGET] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_layoutget,
|
2017-05-05 21:09:37 +00:00
|
|
|
.op_release = nfsd4_layoutget_release,
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
|
|
|
.op_name = "OP_LAYOUTGET",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_layoutget_rsize,
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
},
|
|
|
|
[OP_LAYOUTCOMMIT] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_layoutcommit,
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
|
|
|
.op_name = "OP_LAYOUTCOMMIT",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_layoutcommit_rsize,
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
},
|
|
|
|
[OP_LAYOUTRETURN] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_layoutreturn,
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
|
|
|
.op_name = "OP_LAYOUTRETURN",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_layoutreturn_rsize,
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 11:11:59 +00:00
|
|
|
},
|
|
|
|
#endif /* CONFIG_NFSD_PNFS */
|
2014-09-26 17:58:27 +00:00
|
|
|
|
|
|
|
/* NFSv4.2 operations */
|
2014-11-07 19:44:26 +00:00
|
|
|
[OP_ALLOCATE] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_allocate,
|
2018-12-04 19:09:21 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2014-11-07 19:44:26 +00:00
|
|
|
.op_name = "OP_ALLOCATE",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2014-11-07 19:44:26 +00:00
|
|
|
},
|
2014-11-07 19:44:27 +00:00
|
|
|
[OP_DEALLOCATE] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_deallocate,
|
2018-12-04 19:09:21 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2014-11-07 19:44:27 +00:00
|
|
|
.op_name = "OP_DEALLOCATE",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2014-11-07 19:44:27 +00:00
|
|
|
},
|
2015-12-03 11:59:52 +00:00
|
|
|
[OP_CLONE] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_clone,
|
2018-12-04 19:09:21 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2015-12-03 11:59:52 +00:00
|
|
|
.op_name = "OP_CLONE",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
2015-12-03 11:59:52 +00:00
|
|
|
},
|
2016-09-07 19:57:30 +00:00
|
|
|
[OP_COPY] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_copy,
|
2018-12-04 19:09:21 +00:00
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
2016-09-07 19:57:30 +00:00
|
|
|
.op_name = "OP_COPY",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_copy_rsize,
|
2016-09-07 19:57:30 +00:00
|
|
|
},
|
2020-09-28 17:08:58 +00:00
|
|
|
[OP_READ_PLUS] = {
|
|
|
|
.op_func = nfsd4_read,
|
|
|
|
.op_release = nfsd4_read_release,
|
|
|
|
.op_name = "OP_READ_PLUS",
|
|
|
|
.op_rsize_bop = nfsd4_read_plus_rsize,
|
|
|
|
.op_get_currentstateid = nfsd4_get_readstateid,
|
|
|
|
},
|
2014-09-26 17:58:27 +00:00
|
|
|
[OP_SEEK] = {
|
2017-05-08 18:58:35 +00:00
|
|
|
.op_func = nfsd4_seek,
|
2014-09-26 17:58:27 +00:00
|
|
|
.op_name = "OP_SEEK",
|
2017-05-08 18:42:10 +00:00
|
|
|
.op_rsize_bop = nfsd4_seek_rsize,
|
2014-09-26 17:58:27 +00:00
|
|
|
},
|
2018-07-20 22:19:18 +00:00
|
|
|
[OP_OFFLOAD_STATUS] = {
|
|
|
|
.op_func = nfsd4_offload_status,
|
|
|
|
.op_name = "OP_OFFLOAD_STATUS",
|
|
|
|
.op_rsize_bop = nfsd4_offload_status_rsize,
|
|
|
|
},
|
2018-07-20 22:19:19 +00:00
|
|
|
[OP_OFFLOAD_CANCEL] = {
|
|
|
|
.op_func = nfsd4_offload_cancel,
|
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
|
|
|
.op_name = "OP_OFFLOAD_CANCEL",
|
|
|
|
.op_rsize_bop = nfsd4_only_status_rsize,
|
|
|
|
},
|
2019-08-08 15:14:59 +00:00
|
|
|
[OP_COPY_NOTIFY] = {
|
|
|
|
.op_func = nfsd4_copy_notify,
|
|
|
|
.op_flags = OP_MODIFIES_SOMETHING,
|
|
|
|
.op_name = "OP_COPY_NOTIFY",
|
|
|
|
.op_rsize_bop = nfsd4_copy_notify_rsize,
|
|
|
|
},
|
2020-06-23 22:39:26 +00:00
|
|
|
[OP_GETXATTR] = {
|
|
|
|
.op_func = nfsd4_getxattr,
|
|
|
|
.op_name = "OP_GETXATTR",
|
|
|
|
.op_rsize_bop = nfsd4_getxattr_rsize,
|
|
|
|
},
|
|
|
|
[OP_SETXATTR] = {
|
|
|
|
.op_func = nfsd4_setxattr,
|
|
|
|
.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
|
|
|
|
.op_name = "OP_SETXATTR",
|
|
|
|
.op_rsize_bop = nfsd4_setxattr_rsize,
|
|
|
|
},
|
|
|
|
[OP_LISTXATTRS] = {
|
|
|
|
.op_func = nfsd4_listxattrs,
|
|
|
|
.op_name = "OP_LISTXATTRS",
|
|
|
|
.op_rsize_bop = nfsd4_listxattrs_rsize,
|
|
|
|
},
|
|
|
|
[OP_REMOVEXATTR] = {
|
|
|
|
.op_func = nfsd4_removexattr,
|
|
|
|
.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
|
|
|
|
.op_name = "OP_REMOVEXATTR",
|
|
|
|
.op_rsize_bop = nfsd4_removexattr_rsize,
|
|
|
|
},
|
2006-12-13 08:35:38 +00:00
|
|
|
};
|
|
|
|
|
2016-06-15 16:52:09 +00:00
|
|
|
/**
|
|
|
|
* nfsd4_spo_must_allow - Determine if the compound op contains an
|
|
|
|
* operation that is allowed to be sent with machine credentials
|
|
|
|
*
|
|
|
|
* @rqstp: a pointer to the struct svc_rqst
|
|
|
|
*
|
|
|
|
* Checks to see if the compound contains a spo_must_allow op
|
|
|
|
* and confirms that it was sent with the proper machine creds.
|
|
|
|
*/
|
|
|
|
|
|
|
|
bool nfsd4_spo_must_allow(struct svc_rqst *rqstp)
|
|
|
|
{
|
|
|
|
struct nfsd4_compoundres *resp = rqstp->rq_resp;
|
|
|
|
struct nfsd4_compoundargs *argp = rqstp->rq_argp;
|
2021-05-13 15:16:39 +00:00
|
|
|
struct nfsd4_op *this;
|
2016-06-15 16:52:09 +00:00
|
|
|
struct nfsd4_compound_state *cstate = &resp->cstate;
|
|
|
|
struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow;
|
|
|
|
u32 opiter;
|
|
|
|
|
|
|
|
if (!cstate->minorversion)
|
|
|
|
return false;
|
|
|
|
|
2020-09-11 04:10:14 +00:00
|
|
|
if (cstate->spo_must_allowed)
|
2016-06-15 16:52:09 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
opiter = resp->opcnt;
|
|
|
|
while (opiter < argp->opcnt) {
|
|
|
|
this = &argp->ops[opiter++];
|
|
|
|
if (test_bit(this->opnum, allow->u.longs) &&
|
|
|
|
cstate->clp->cl_mach_cred &&
|
|
|
|
nfsd4_mach_creds_match(cstate->clp, rqstp)) {
|
|
|
|
cstate->spo_must_allowed = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
cstate->spo_must_allowed = false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-03-11 19:39:13 +00:00
|
|
|
int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op)
|
|
|
|
{
|
2017-03-23 18:36:20 +00:00
|
|
|
if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp)
|
2014-03-11 19:39:13 +00:00
|
|
|
return op_encode_hdr_size * sizeof(__be32);
|
2017-02-03 14:36:00 +00:00
|
|
|
|
|
|
|
BUG_ON(OPDESC(op)->op_rsize_bop == NULL);
|
|
|
|
return OPDESC(op)->op_rsize_bop(rqstp, op);
|
2014-03-11 19:39:13 +00:00
|
|
|
}
|
|
|
|
|
2014-03-07 01:39:29 +00:00
|
|
|
void warn_on_nonidempotent_op(struct nfsd4_op *op)
|
|
|
|
{
|
|
|
|
if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) {
|
2020-11-22 17:49:52 +00:00
|
|
|
pr_err("unable to encode reply to nonidempotent op %u (%s)\n",
|
2014-03-07 01:39:29 +00:00
|
|
|
op->opnum, nfsd4_op_name(op->opnum));
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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";
|
|
|
|
}
|
|
|
|
|
2017-05-12 14:11:49 +00:00
|
|
|
static const struct svc_procedure nfsd_procedures4[2] = {
|
2009-05-19 06:09:54 +00:00
|
|
|
[NFSPROC4_NULL] = {
|
2017-05-08 15:59:13 +00:00
|
|
|
.pc_func = nfsd4_proc_null,
|
2020-11-05 19:48:29 +00:00
|
|
|
.pc_decode = nfssvc_decode_voidarg,
|
|
|
|
.pc_encode = nfssvc_encode_voidres,
|
|
|
|
.pc_argsize = sizeof(struct nfsd_voidargs),
|
2022-09-12 21:22:38 +00:00
|
|
|
.pc_argzero = sizeof(struct nfsd_voidargs),
|
2020-11-05 19:48:29 +00:00
|
|
|
.pc_ressize = sizeof(struct nfsd_voidres),
|
2009-05-19 06:09:54 +00:00
|
|
|
.pc_cachetype = RC_NOCACHE,
|
|
|
|
.pc_xdrressize = 1,
|
2020-09-17 21:22:49 +00:00
|
|
|
.pc_name = "NULL",
|
2009-05-19 06:09:54 +00:00
|
|
|
},
|
|
|
|
[NFSPROC4_COMPOUND] = {
|
2017-05-08 15:59:13 +00:00
|
|
|
.pc_func = nfsd4_proc_compound,
|
2017-05-08 17:01:48 +00:00
|
|
|
.pc_decode = nfs4svc_decode_compoundargs,
|
2017-05-08 17:42:02 +00:00
|
|
|
.pc_encode = nfs4svc_encode_compoundres,
|
2009-05-19 06:09:54 +00:00
|
|
|
.pc_argsize = sizeof(struct nfsd4_compoundargs),
|
2022-09-12 21:22:44 +00:00
|
|
|
.pc_argzero = offsetof(struct nfsd4_compoundargs, iops),
|
2009-05-19 06:09:54 +00:00
|
|
|
.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,
|
2020-09-17 21:22:49 +00:00
|
|
|
.pc_name = "COMPOUND",
|
2009-05-19 06:09:54 +00:00
|
|
|
},
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2023-01-10 15:31:54 +00:00
|
|
|
static DEFINE_PER_CPU_ALIGNED(unsigned long,
|
|
|
|
nfsd_count4[ARRAY_SIZE(nfsd_procedures4)]);
|
2017-05-12 14:21:37 +00:00
|
|
|
const struct svc_version nfsd_version4 = {
|
2017-02-24 18:25:24 +00:00
|
|
|
.vs_vers = 4,
|
2023-01-10 15:31:54 +00:00
|
|
|
.vs_nproc = ARRAY_SIZE(nfsd_procedures4),
|
2017-02-24 18:25:24 +00:00
|
|
|
.vs_proc = nfsd_procedures4,
|
2023-01-10 15:31:54 +00:00
|
|
|
.vs_count = nfsd_count4,
|
2017-02-24 18:25:24 +00:00
|
|
|
.vs_dispatch = nfsd_dispatch,
|
|
|
|
.vs_xdrsize = NFS4_SVC_XDRSIZE,
|
|
|
|
.vs_rpcb_optnl = true,
|
|
|
|
.vs_need_cong_ctrl = true,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|