2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Server-side XDR 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.
|
|
|
|
*/
|
|
|
|
|
2015-06-18 22:45:01 +08:00
|
|
|
#include <linux/file.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/namei.h>
|
2009-12-04 02:29:12 +08:00
|
|
|
#include <linux/statfs.h>
|
2009-04-03 13:28:01 +08:00
|
|
|
#include <linux/utsname.h>
|
2011-07-13 22:50:48 +08:00
|
|
|
#include <linux/pagemap.h>
|
2007-07-17 19:04:51 +08:00
|
|
|
#include <linux/sunrpc/svcauth_gss.h>
|
2019-09-14 02:00:57 +08:00
|
|
|
#include <linux/sunrpc/addr.h>
|
2020-06-24 06:39:26 +08:00
|
|
|
#include <linux/xattr.h>
|
|
|
|
#include <uapi/linux/xattr.h>
|
2009-12-04 02:30:56 +08:00
|
|
|
|
2011-01-05 06:37:15 +08:00
|
|
|
#include "idmap.h"
|
|
|
|
#include "acl.h"
|
2009-12-04 02:30:56 +08:00
|
|
|
#include "xdr4.h"
|
2009-11-05 07:12:35 +08:00
|
|
|
#include "vfs.h"
|
2011-07-13 22:50:48 +08:00
|
|
|
#include "state.h"
|
2011-01-25 01:11:02 +08:00
|
|
|
#include "cache.h"
|
2012-11-27 19:11:44 +08:00
|
|
|
#include "netns.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 19:11:59 +08:00
|
|
|
#include "pnfs.h"
|
2019-08-19 02:18:54 +08:00
|
|
|
#include "filecache.h"
|
2011-01-05 06:37:15 +08:00
|
|
|
|
2013-05-03 01:19:10 +08:00
|
|
|
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
|
|
|
|
#include <linux/security.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#define NFSDDBG_FACILITY NFSDDBG_XDR
|
|
|
|
|
2017-01-12 09:40:36 +08:00
|
|
|
const u32 nfsd_suppattrs[3][3] = {
|
2016-10-19 02:18:40 +08:00
|
|
|
{NFSD4_SUPPORTED_ATTRS_WORD0,
|
|
|
|
NFSD4_SUPPORTED_ATTRS_WORD1,
|
|
|
|
NFSD4_SUPPORTED_ATTRS_WORD2},
|
|
|
|
|
|
|
|
{NFSD4_1_SUPPORTED_ATTRS_WORD0,
|
|
|
|
NFSD4_1_SUPPORTED_ATTRS_WORD1,
|
|
|
|
NFSD4_1_SUPPORTED_ATTRS_WORD2},
|
|
|
|
|
|
|
|
{NFSD4_1_SUPPORTED_ATTRS_WORD0,
|
|
|
|
NFSD4_1_SUPPORTED_ATTRS_WORD1,
|
|
|
|
NFSD4_2_SUPPORTED_ATTRS_WORD2},
|
|
|
|
};
|
|
|
|
|
2006-10-04 17:16:20 +08:00
|
|
|
/*
|
|
|
|
* As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
|
|
|
|
* directory in order to indicate to the client that a filesystem boundary is present
|
|
|
|
* We use a fixed fsid for a referral
|
|
|
|
*/
|
|
|
|
#define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL
|
|
|
|
#define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2012-11-26 05:31:00 +08:00
|
|
|
check_filename(char *str, int len)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (len == 0)
|
|
|
|
return nfserr_inval;
|
|
|
|
if (isdotent(str, len))
|
2012-11-26 05:31:00 +08:00
|
|
|
return nfserr_badname;
|
2005-04-17 06:20:36 +08:00
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
if (str[i] == '/')
|
2012-11-26 05:31:00 +08:00
|
|
|
return nfserr_badname;
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define DECODE_HEAD \
|
2006-10-20 14:28:58 +08:00
|
|
|
__be32 *p; \
|
2006-10-20 14:28:59 +08:00
|
|
|
__be32 status
|
2005-04-17 06:20:36 +08:00
|
|
|
#define DECODE_TAIL \
|
|
|
|
status = 0; \
|
|
|
|
out: \
|
|
|
|
return status; \
|
|
|
|
xdr_error: \
|
2007-09-12 06:01:20 +08:00
|
|
|
dprintk("NFSD: xdr error (%s:%d)\n", \
|
|
|
|
__FILE__, __LINE__); \
|
2005-04-17 06:20:36 +08:00
|
|
|
status = nfserr_bad_xdr; \
|
|
|
|
goto out
|
|
|
|
|
|
|
|
#define READMEM(x,nbytes) do { \
|
|
|
|
x = (char *)p; \
|
|
|
|
p += XDR_QUADLEN(nbytes); \
|
|
|
|
} while (0)
|
|
|
|
#define SAVEMEM(x,nbytes) do { \
|
|
|
|
if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
|
|
|
|
savemem(argp, p, nbytes) : \
|
|
|
|
(char *)p)) { \
|
2007-09-12 06:01:20 +08:00
|
|
|
dprintk("NFSD: xdr error (%s:%d)\n", \
|
|
|
|
__FILE__, __LINE__); \
|
2005-04-17 06:20:36 +08:00
|
|
|
goto xdr_error; \
|
|
|
|
} \
|
|
|
|
p += XDR_QUADLEN(nbytes); \
|
|
|
|
} while (0)
|
|
|
|
#define COPYMEM(x,nbytes) do { \
|
|
|
|
memcpy((x), p, nbytes); \
|
|
|
|
p += XDR_QUADLEN(nbytes); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
/* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */
|
|
|
|
#define READ_BUF(nbytes) do { \
|
|
|
|
if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \
|
|
|
|
p = argp->p; \
|
|
|
|
argp->p += XDR_QUADLEN(nbytes); \
|
|
|
|
} else if (!(p = read_buf(argp, nbytes))) { \
|
2007-09-12 06:01:20 +08:00
|
|
|
dprintk("NFSD: xdr error (%s:%d)\n", \
|
|
|
|
__FILE__, __LINE__); \
|
2005-04-17 06:20:36 +08:00
|
|
|
goto xdr_error; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2013-06-22 05:06:29 +08:00
|
|
|
static void next_decode_page(struct nfsd4_compoundargs *argp)
|
|
|
|
{
|
|
|
|
argp->p = page_address(argp->pagelist[0]);
|
2013-11-20 06:32:43 +08:00
|
|
|
argp->pagelist++;
|
2013-06-22 05:06:29 +08:00
|
|
|
if (argp->pagelen < PAGE_SIZE) {
|
2017-08-18 23:12:19 +08:00
|
|
|
argp->end = argp->p + XDR_QUADLEN(argp->pagelen);
|
2013-06-22 05:06:29 +08:00
|
|
|
argp->pagelen = 0;
|
|
|
|
} else {
|
|
|
|
argp->end = argp->p + (PAGE_SIZE>>2);
|
|
|
|
argp->pagelen -= PAGE_SIZE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-11-12 04:43:12 +08:00
|
|
|
static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
/* We want more bytes than seem to be available.
|
|
|
|
* Maybe we need a new page, maybe we have just run out
|
|
|
|
*/
|
2007-11-12 04:43:12 +08:00
|
|
|
unsigned int avail = (char *)argp->end - (char *)argp->p;
|
2006-10-20 14:28:58 +08:00
|
|
|
__be32 *p;
|
2017-08-18 23:12:27 +08:00
|
|
|
|
|
|
|
if (argp->pagelen == 0) {
|
|
|
|
struct kvec *vec = &argp->rqstp->rq_arg.tail[0];
|
|
|
|
|
|
|
|
if (!argp->tail) {
|
|
|
|
argp->tail = true;
|
|
|
|
avail = vec->iov_len;
|
|
|
|
argp->p = vec->iov_base;
|
|
|
|
argp->end = vec->iov_base + avail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (avail < nbytes)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
p = argp->p;
|
|
|
|
argp->p += XDR_QUADLEN(nbytes);
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (avail + argp->pagelen < nbytes)
|
|
|
|
return NULL;
|
|
|
|
if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */
|
|
|
|
return NULL;
|
|
|
|
/* ok, we can do it with the current plus the next page */
|
|
|
|
if (nbytes <= sizeof(argp->tmp))
|
|
|
|
p = argp->tmp;
|
|
|
|
else {
|
2005-11-07 17:01:34 +08:00
|
|
|
kfree(argp->tmpp);
|
2005-04-17 06:20:36 +08:00
|
|
|
p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL);
|
|
|
|
if (!p)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
}
|
2007-11-12 04:43:12 +08:00
|
|
|
/*
|
|
|
|
* The following memcpy is safe because read_buf is always
|
|
|
|
* called with nbytes > avail, and the two cases above both
|
|
|
|
* guarantee p points to at least nbytes bytes.
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
memcpy(p, argp->p, avail);
|
2013-06-22 05:06:29 +08:00
|
|
|
next_decode_page(argp);
|
2005-04-17 06:20:36 +08:00
|
|
|
memcpy(((char*)p)+avail, argp->p, (nbytes - avail));
|
|
|
|
argp->p += XDR_QUADLEN(nbytes - avail);
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2019-08-29 09:13:45 +08:00
|
|
|
static unsigned int compoundargs_bytes_left(struct nfsd4_compoundargs *argp)
|
|
|
|
{
|
|
|
|
unsigned int this = (char *)argp->end - (char *)argp->p;
|
|
|
|
|
|
|
|
return this + argp->pagelen;
|
|
|
|
}
|
|
|
|
|
2009-04-03 13:28:50 +08:00
|
|
|
static int zero_clientid(clientid_t *clid)
|
|
|
|
{
|
|
|
|
return (clid->cl_boot == 0) && (clid->cl_id == 0);
|
|
|
|
}
|
|
|
|
|
2013-11-20 16:24:11 +08:00
|
|
|
/**
|
2014-06-25 05:43:45 +08:00
|
|
|
* svcxdr_tmpalloc - allocate memory to be freed after compound processing
|
2014-06-25 04:51:12 +08:00
|
|
|
* @argp: NFSv4 compound argument structure
|
2019-08-19 02:18:59 +08:00
|
|
|
* @len: length of buffer to allocate
|
2013-11-20 16:24:11 +08:00
|
|
|
*
|
2019-08-19 02:18:59 +08:00
|
|
|
* Allocates a buffer of size @len to be freed when processing the compound
|
|
|
|
* operation described in @argp finishes.
|
2013-11-20 16:24:11 +08:00
|
|
|
*/
|
2014-06-25 05:43:45 +08:00
|
|
|
static void *
|
|
|
|
svcxdr_tmpalloc(struct nfsd4_compoundargs *argp, u32 len)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-06-25 05:43:45 +08:00
|
|
|
struct svcxdr_tmpbuf *tb;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-06-25 05:43:45 +08:00
|
|
|
tb = kmalloc(sizeof(*tb) + len, GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!tb)
|
2014-06-25 05:43:45 +08:00
|
|
|
return NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
tb->next = argp->to_free;
|
|
|
|
argp->to_free = tb;
|
2014-06-25 05:43:45 +08:00
|
|
|
return tb->buf;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2014-06-25 05:06:51 +08:00
|
|
|
/*
|
|
|
|
* For xdr strings that need to be passed to other kernel api's
|
|
|
|
* as null-terminated strings.
|
|
|
|
*
|
|
|
|
* Note null-terminating in place usually isn't safe since the
|
|
|
|
* buffer might end on a page boundary.
|
|
|
|
*/
|
|
|
|
static char *
|
|
|
|
svcxdr_dupstr(struct nfsd4_compoundargs *argp, void *buf, u32 len)
|
|
|
|
{
|
2014-06-25 05:43:45 +08:00
|
|
|
char *p = svcxdr_tmpalloc(argp, len + 1);
|
2014-06-25 05:06:51 +08:00
|
|
|
|
|
|
|
if (!p)
|
|
|
|
return NULL;
|
|
|
|
memcpy(p, buf, len);
|
|
|
|
p[len] = '\0';
|
|
|
|
return p;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2020-06-24 06:39:21 +08:00
|
|
|
static __be32
|
|
|
|
svcxdr_construct_vector(struct nfsd4_compoundargs *argp, struct kvec *head,
|
|
|
|
struct page ***pagelist, u32 buflen)
|
|
|
|
{
|
|
|
|
int avail;
|
|
|
|
int len;
|
|
|
|
int pages;
|
|
|
|
|
|
|
|
/* Sorry .. no magic macros for this.. *
|
|
|
|
* READ_BUF(write->wr_buflen);
|
|
|
|
* SAVEMEM(write->wr_buf, write->wr_buflen);
|
|
|
|
*/
|
|
|
|
avail = (char *)argp->end - (char *)argp->p;
|
|
|
|
if (avail + argp->pagelen < buflen) {
|
|
|
|
dprintk("NFSD: xdr error (%s:%d)\n",
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
return nfserr_bad_xdr;
|
|
|
|
}
|
|
|
|
head->iov_base = argp->p;
|
|
|
|
head->iov_len = avail;
|
|
|
|
*pagelist = argp->pagelist;
|
|
|
|
|
|
|
|
len = XDR_QUADLEN(buflen) << 2;
|
|
|
|
if (len >= avail) {
|
|
|
|
len -= avail;
|
|
|
|
|
|
|
|
pages = len >> PAGE_SHIFT;
|
|
|
|
argp->pagelist += pages;
|
|
|
|
argp->pagelen -= pages * PAGE_SIZE;
|
|
|
|
len -= pages * PAGE_SIZE;
|
|
|
|
|
|
|
|
next_decode_page(argp);
|
|
|
|
}
|
|
|
|
argp->p += XDR_QUADLEN(len);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-20 16:24:11 +08:00
|
|
|
/**
|
|
|
|
* savemem - duplicate a chunk of memory for later processing
|
|
|
|
* @argp: NFSv4 compound argument structure to be freed with
|
|
|
|
* @p: pointer to be duplicated
|
|
|
|
* @nbytes: length to be duplicated
|
|
|
|
*
|
|
|
|
* Returns a pointer to a copy of @nbytes bytes of memory at @p
|
|
|
|
* that are preserved until processing of the NFSv4 compound
|
|
|
|
* operation described by @argp finishes.
|
|
|
|
*/
|
2006-10-20 14:28:58 +08:00
|
|
|
static char *savemem(struct nfsd4_compoundargs *argp, __be32 *p, int nbytes)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-06-25 05:43:45 +08:00
|
|
|
void *ret;
|
|
|
|
|
|
|
|
ret = svcxdr_tmpalloc(argp, nbytes);
|
|
|
|
if (!ret)
|
2005-04-17 06:20:36 +08:00
|
|
|
return NULL;
|
2014-06-25 05:43:45 +08:00
|
|
|
memcpy(ret, p, nbytes);
|
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2015-01-22 19:09:50 +08:00
|
|
|
static __be32
|
2019-06-06 02:17:42 +08:00
|
|
|
nfsd4_decode_time(struct nfsd4_compoundargs *argp, struct timespec64 *tv)
|
2015-01-22 19:09:50 +08:00
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(12);
|
2019-06-06 02:17:42 +08:00
|
|
|
p = xdr_decode_hyper(p, &tv->tv_sec);
|
2015-01-22 19:09:50 +08:00
|
|
|
tv->tv_nsec = be32_to_cpup(p++);
|
|
|
|
if (tv->tv_nsec >= (u32)1000000000)
|
|
|
|
return nfserr_inval;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)
|
|
|
|
{
|
|
|
|
u32 bmlen;
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
bmval[0] = 0;
|
|
|
|
bmval[1] = 0;
|
2009-04-03 13:29:11 +08:00
|
|
|
bmval[2] = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
bmlen = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (bmlen > 1000)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
READ_BUF(bmlen << 2);
|
|
|
|
if (bmlen > 0)
|
2014-06-03 00:32:51 +08:00
|
|
|
bmval[0] = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (bmlen > 1)
|
2014-06-03 00:32:51 +08:00
|
|
|
bmval[1] = be32_to_cpup(p++);
|
2009-04-03 13:29:11 +08:00
|
|
|
if (bmlen > 2)
|
2014-06-03 00:32:51 +08:00
|
|
|
bmval[2] = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2009-05-16 16:22:31 +08:00
|
|
|
nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
|
2013-05-03 01:19:10 +08:00
|
|
|
struct iattr *iattr, struct nfs4_acl **acl,
|
2016-01-13 03:24:14 +08:00
|
|
|
struct xdr_netobj *label, int *umask)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int expected_len, len = 0;
|
|
|
|
u32 dummy32;
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
DECODE_HEAD;
|
|
|
|
iattr->ia_valid = 0;
|
|
|
|
if ((status = nfsd4_decode_bitmap(argp, bmval)))
|
|
|
|
return status;
|
|
|
|
|
2016-06-11 04:56:05 +08:00
|
|
|
if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
|
|
|
|
|| bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
|
|
|
|
|| bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2) {
|
|
|
|
if (nfsd_attrs_supported(argp->minorversion, bmval))
|
|
|
|
return nfserr_inval;
|
|
|
|
return nfserr_attrnotsupp;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
expected_len = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (bmval[0] & FATTR4_WORD0_SIZE) {
|
|
|
|
READ_BUF(8);
|
|
|
|
len += 8;
|
2014-06-03 00:45:31 +08:00
|
|
|
p = xdr_decode_hyper(p, &iattr->ia_size);
|
2005-04-17 06:20:36 +08:00
|
|
|
iattr->ia_valid |= ATTR_SIZE;
|
|
|
|
}
|
|
|
|
if (bmval[0] & FATTR4_WORD0_ACL) {
|
2013-03-27 02:11:13 +08:00
|
|
|
u32 nace;
|
2007-02-16 17:28:30 +08:00
|
|
|
struct nfs4_ace *ace;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
READ_BUF(4); len += 4;
|
2014-06-03 00:32:51 +08:00
|
|
|
nace = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2019-08-29 09:13:45 +08:00
|
|
|
if (nace > compoundargs_bytes_left(argp)/20)
|
|
|
|
/*
|
|
|
|
* Even with 4-byte names there wouldn't be
|
|
|
|
* space for that many aces; something fishy is
|
|
|
|
* going on:
|
|
|
|
*/
|
2014-01-30 05:39:05 +08:00
|
|
|
return nfserr_fbig;
|
2007-02-16 17:28:30 +08:00
|
|
|
|
2014-06-25 05:43:45 +08:00
|
|
|
*acl = svcxdr_tmpalloc(argp, nfs4_acl_bytes(nace));
|
2013-12-09 18:23:46 +08:00
|
|
|
if (*acl == NULL)
|
|
|
|
return nfserr_jukebox;
|
|
|
|
|
2007-02-16 17:28:30 +08:00
|
|
|
(*acl)->naces = nace;
|
|
|
|
for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) {
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(16); len += 16;
|
2014-06-03 00:32:51 +08:00
|
|
|
ace->type = be32_to_cpup(p++);
|
|
|
|
ace->flag = be32_to_cpup(p++);
|
|
|
|
ace->access_mask = be32_to_cpup(p++);
|
|
|
|
dummy32 = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(dummy32);
|
|
|
|
len += XDR_QUADLEN(dummy32) << 2;
|
|
|
|
READMEM(buf, dummy32);
|
2007-02-16 17:28:30 +08:00
|
|
|
ace->whotype = nfs4_acl_get_whotype(buf, dummy32);
|
2011-01-05 06:53:52 +08:00
|
|
|
status = nfs_ok;
|
2007-02-16 17:28:30 +08:00
|
|
|
if (ace->whotype != NFS4_ACL_WHO_NAMED)
|
2013-02-02 21:18:08 +08:00
|
|
|
;
|
2007-02-16 17:28:30 +08:00
|
|
|
else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
|
2011-01-05 06:53:52 +08:00
|
|
|
status = nfsd_map_name_to_gid(argp->rqstp,
|
2013-02-02 21:18:08 +08:00
|
|
|
buf, dummy32, &ace->who_gid);
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
2011-01-05 06:53:52 +08:00
|
|
|
status = nfsd_map_name_to_uid(argp->rqstp,
|
2013-02-02 21:18:08 +08:00
|
|
|
buf, dummy32, &ace->who_uid);
|
2011-01-05 06:53:52 +08:00
|
|
|
if (status)
|
|
|
|
return status;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
*acl = NULL;
|
|
|
|
if (bmval[1] & FATTR4_WORD1_MODE) {
|
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
2014-06-03 00:32:51 +08:00
|
|
|
iattr->ia_mode = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
iattr->ia_mode &= (S_IFMT | S_IALLUGO);
|
|
|
|
iattr->ia_valid |= ATTR_MODE;
|
|
|
|
}
|
|
|
|
if (bmval[1] & FATTR4_WORD1_OWNER) {
|
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy32 = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(dummy32);
|
|
|
|
len += (XDR_QUADLEN(dummy32) << 2);
|
|
|
|
READMEM(buf, dummy32);
|
2011-02-16 10:08:35 +08:00
|
|
|
if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid)))
|
|
|
|
return status;
|
2005-04-17 06:20:36 +08:00
|
|
|
iattr->ia_valid |= ATTR_UID;
|
|
|
|
}
|
|
|
|
if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) {
|
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy32 = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(dummy32);
|
|
|
|
len += (XDR_QUADLEN(dummy32) << 2);
|
|
|
|
READMEM(buf, dummy32);
|
2011-02-16 10:08:35 +08:00
|
|
|
if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid)))
|
|
|
|
return status;
|
2005-04-17 06:20:36 +08:00
|
|
|
iattr->ia_valid |= ATTR_GID;
|
|
|
|
}
|
|
|
|
if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
|
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy32 = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (dummy32) {
|
|
|
|
case NFS4_SET_TO_CLIENT_TIME:
|
|
|
|
len += 12;
|
2019-06-06 02:17:42 +08:00
|
|
|
status = nfsd4_decode_time(argp, &iattr->ia_atime);
|
2015-01-22 19:09:50 +08:00
|
|
|
if (status)
|
|
|
|
return status;
|
2005-04-17 06:20:36 +08:00
|
|
|
iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET);
|
|
|
|
break;
|
|
|
|
case NFS4_SET_TO_SERVER_TIME:
|
|
|
|
iattr->ia_valid |= ATTR_ATIME;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
|
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy32 = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (dummy32) {
|
|
|
|
case NFS4_SET_TO_CLIENT_TIME:
|
|
|
|
len += 12;
|
2019-06-06 02:17:42 +08:00
|
|
|
status = nfsd4_decode_time(argp, &iattr->ia_mtime);
|
2015-01-22 19:09:50 +08:00
|
|
|
if (status)
|
|
|
|
return status;
|
2005-04-17 06:20:36 +08:00
|
|
|
iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET);
|
|
|
|
break;
|
|
|
|
case NFS4_SET_TO_SERVER_TIME:
|
|
|
|
iattr->ia_valid |= ATTR_MTIME;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
}
|
2013-05-03 01:19:10 +08:00
|
|
|
|
|
|
|
label->len = 0;
|
2018-01-23 05:09:12 +08:00
|
|
|
if (IS_ENABLED(CONFIG_NFSD_V4_SECURITY_LABEL) &&
|
|
|
|
bmval[2] & FATTR4_WORD2_SECURITY_LABEL) {
|
2013-05-03 01:19:10 +08:00
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy32 = be32_to_cpup(p++); /* lfs: we don't use it */
|
2013-05-03 01:19:10 +08:00
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy32 = be32_to_cpup(p++); /* pi: we don't use it either */
|
2013-05-03 01:19:10 +08:00
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy32 = be32_to_cpup(p++);
|
2013-05-03 01:19:10 +08:00
|
|
|
READ_BUF(dummy32);
|
2015-03-28 23:46:09 +08:00
|
|
|
if (dummy32 > NFS4_MAXLABELLEN)
|
2013-05-03 01:19:10 +08:00
|
|
|
return nfserr_badlabel;
|
|
|
|
len += (XDR_QUADLEN(dummy32) << 2);
|
|
|
|
READMEM(buf, dummy32);
|
2014-06-25 05:06:51 +08:00
|
|
|
label->len = dummy32;
|
|
|
|
label->data = svcxdr_dupstr(argp, buf, dummy32);
|
2013-05-03 01:19:10 +08:00
|
|
|
if (!label->data)
|
|
|
|
return nfserr_jukebox;
|
|
|
|
}
|
2016-01-13 03:24:14 +08:00
|
|
|
if (bmval[2] & FATTR4_WORD2_MODE_UMASK) {
|
|
|
|
if (!umask)
|
|
|
|
goto xdr_error;
|
|
|
|
READ_BUF(8);
|
|
|
|
len += 8;
|
|
|
|
dummy32 = be32_to_cpup(p++);
|
|
|
|
iattr->ia_mode = dummy32 & (S_IFMT | S_IALLUGO);
|
|
|
|
dummy32 = be32_to_cpup(p++);
|
|
|
|
*umask = dummy32 & S_IRWXUGO;
|
|
|
|
iattr->ia_valid |= ATTR_MODE;
|
|
|
|
}
|
2016-06-11 04:56:05 +08:00
|
|
|
if (len != expected_len)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2008-08-13 01:46:18 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_stateid(struct nfsd4_compoundargs *argp, stateid_t *sid)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(sizeof(stateid_t));
|
2014-06-03 00:32:51 +08:00
|
|
|
sid->si_generation = be32_to_cpup(p++);
|
2008-08-13 01:46:18 +08:00
|
|
|
COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t));
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
access->ac_req_access = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2012-03-28 02:50:26 +08:00
|
|
|
static __be32 nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
2019-04-10 00:13:42 +08:00
|
|
|
struct user_namespace *userns = nfsd_user_namespace(argp->rqstp);
|
2012-11-06 05:01:48 +08:00
|
|
|
u32 dummy, uid, gid;
|
2012-03-28 02:50:26 +08:00
|
|
|
char *machine_name;
|
|
|
|
int i;
|
|
|
|
int nr_secflavs;
|
|
|
|
|
|
|
|
/* callback_sec_params4 */
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
nr_secflavs = be32_to_cpup(p++);
|
2013-05-18 04:25:32 +08:00
|
|
|
if (nr_secflavs)
|
|
|
|
cbs->flavor = (u32)(-1);
|
|
|
|
else
|
|
|
|
/* Is this legal? Be generous, take it to mean AUTH_NONE: */
|
|
|
|
cbs->flavor = 0;
|
2012-03-28 02:50:26 +08:00
|
|
|
for (i = 0; i < nr_secflavs; ++i) {
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2012-03-28 02:50:26 +08:00
|
|
|
switch (dummy) {
|
|
|
|
case RPC_AUTH_NULL:
|
|
|
|
/* Nothing to read */
|
2012-11-06 05:01:48 +08:00
|
|
|
if (cbs->flavor == (u32)(-1))
|
|
|
|
cbs->flavor = RPC_AUTH_NULL;
|
2012-03-28 02:50:26 +08:00
|
|
|
break;
|
|
|
|
case RPC_AUTH_UNIX:
|
|
|
|
READ_BUF(8);
|
|
|
|
/* stamp */
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2012-03-28 02:50:26 +08:00
|
|
|
|
|
|
|
/* machine name */
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2012-03-28 02:50:26 +08:00
|
|
|
READ_BUF(dummy);
|
|
|
|
SAVEMEM(machine_name, dummy);
|
|
|
|
|
|
|
|
/* uid, gid */
|
|
|
|
READ_BUF(8);
|
2014-06-03 00:32:51 +08:00
|
|
|
uid = be32_to_cpup(p++);
|
|
|
|
gid = be32_to_cpup(p++);
|
2012-03-28 02:50:26 +08:00
|
|
|
|
|
|
|
/* more gids */
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2012-03-28 02:50:26 +08:00
|
|
|
READ_BUF(dummy * 4);
|
2012-11-06 05:01:48 +08:00
|
|
|
if (cbs->flavor == (u32)(-1)) {
|
2019-04-10 00:13:42 +08:00
|
|
|
kuid_t kuid = make_kuid(userns, uid);
|
|
|
|
kgid_t kgid = make_kgid(userns, gid);
|
2013-02-02 22:24:49 +08:00
|
|
|
if (uid_valid(kuid) && gid_valid(kgid)) {
|
|
|
|
cbs->uid = kuid;
|
|
|
|
cbs->gid = kgid;
|
|
|
|
cbs->flavor = RPC_AUTH_UNIX;
|
|
|
|
} else {
|
|
|
|
dprintk("RPC_AUTH_UNIX with invalid"
|
|
|
|
"uid or gid ignoring!\n");
|
|
|
|
}
|
2012-11-06 05:01:48 +08:00
|
|
|
}
|
2012-03-28 02:50:26 +08:00
|
|
|
break;
|
|
|
|
case RPC_AUTH_GSS:
|
|
|
|
dprintk("RPC_AUTH_GSS callback secflavor "
|
|
|
|
"not supported!\n");
|
|
|
|
READ_BUF(8);
|
|
|
|
/* gcbp_service */
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2012-03-28 02:50:26 +08:00
|
|
|
/* gcbp_handle_from_server */
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2012-03-28 02:50:26 +08:00
|
|
|
READ_BUF(dummy);
|
|
|
|
p += XDR_QUADLEN(dummy);
|
|
|
|
/* gcbp_handle_from_client */
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2012-03-28 02:50:26 +08:00
|
|
|
READ_BUF(dummy);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dprintk("Illegal callback secflavor\n");
|
|
|
|
return nfserr_inval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2012-11-02 06:09:48 +08:00
|
|
|
static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, struct nfsd4_backchannel_ctl *bc)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
bc->bc_cb_program = be32_to_cpup(p++);
|
2012-11-02 06:09:48 +08:00
|
|
|
nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2010-10-05 11:12:59 +08:00
|
|
|
static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, struct nfsd4_bind_conn_to_session *bcts)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(NFS4_MAX_SESSIONID_LEN + 8);
|
|
|
|
COPYMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);
|
2014-06-03 00:32:51 +08:00
|
|
|
bcts->dir = be32_to_cpup(p++);
|
2011-04-28 03:47:16 +08:00
|
|
|
/* XXX: skipping ctsa_use_conn_in_rdma_mode. Perhaps Tom Tucker
|
|
|
|
* could help us figure out we should be using it. */
|
2010-10-05 11:12:59 +08:00
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2008-08-13 01:46:18 +08:00
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
close->cl_seqid = be32_to_cpup(p++);
|
2008-08-13 01:46:18 +08:00
|
|
|
return nfsd4_decode_stateid(argp, &close->cl_stateid);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(12);
|
2014-06-03 00:45:31 +08:00
|
|
|
p = xdr_decode_hyper(p, &commit->co_offset);
|
2014-06-03 00:32:51 +08:00
|
|
|
commit->co_count = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
create->cr_type = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (create->cr_type) {
|
|
|
|
case NF4LNK:
|
|
|
|
READ_BUF(4);
|
2014-06-25 03:06:41 +08:00
|
|
|
create->cr_datalen = be32_to_cpup(p++);
|
|
|
|
READ_BUF(create->cr_datalen);
|
2014-06-25 05:06:51 +08:00
|
|
|
create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen);
|
2014-06-25 03:06:41 +08:00
|
|
|
if (!create->cr_data)
|
2014-06-20 04:44:48 +08:00
|
|
|
return nfserr_jukebox;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case NF4BLK:
|
|
|
|
case NF4CHR:
|
|
|
|
READ_BUF(8);
|
2014-06-03 00:32:51 +08:00
|
|
|
create->cr_specdata1 = be32_to_cpup(p++);
|
|
|
|
create->cr_specdata2 = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case NF4SOCK:
|
|
|
|
case NF4FIFO:
|
|
|
|
case NF4DIR:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
create->cr_namelen = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(create->cr_namelen);
|
|
|
|
SAVEMEM(create->cr_name, create->cr_namelen);
|
2012-11-26 05:31:00 +08:00
|
|
|
if ((status = check_filename(create->cr_name, create->cr_namelen)))
|
2005-04-17 06:20:36 +08:00
|
|
|
return status;
|
|
|
|
|
2009-05-16 16:22:31 +08:00
|
|
|
status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr,
|
2016-01-13 03:24:14 +08:00
|
|
|
&create->cr_acl, &create->cr_label,
|
2018-03-22 05:19:02 +08:00
|
|
|
&create->cr_umask);
|
2009-04-03 13:29:05 +08:00
|
|
|
if (status)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static inline __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr)
|
|
|
|
{
|
2008-08-13 01:46:18 +08:00
|
|
|
return nfsd4_decode_stateid(argp, &dr->dr_stateid);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static inline __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr)
|
|
|
|
{
|
|
|
|
return nfsd4_decode_bitmap(argp, getattr->ga_bmval);
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
link->li_namelen = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(link->li_namelen);
|
|
|
|
SAVEMEM(link->li_name, link->li_namelen);
|
2012-11-26 05:31:00 +08:00
|
|
|
if ((status = check_filename(link->li_name, link->li_namelen)))
|
2005-04-17 06:20:36 +08:00
|
|
|
return status;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* type, reclaim(boolean), offset, length, new_lock_owner(boolean)
|
|
|
|
*/
|
|
|
|
READ_BUF(28);
|
2014-06-03 00:32:51 +08:00
|
|
|
lock->lk_type = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))
|
|
|
|
goto xdr_error;
|
2014-06-03 00:32:51 +08:00
|
|
|
lock->lk_reclaim = be32_to_cpup(p++);
|
2014-06-03 00:45:31 +08:00
|
|
|
p = xdr_decode_hyper(p, &lock->lk_offset);
|
|
|
|
p = xdr_decode_hyper(p, &lock->lk_length);
|
2014-06-03 00:32:51 +08:00
|
|
|
lock->lk_is_new = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (lock->lk_is_new) {
|
2008-08-13 01:46:18 +08:00
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
lock->lk_new_open_seqid = be32_to_cpup(p++);
|
2008-08-13 01:46:18 +08:00
|
|
|
status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(8 + sizeof(clientid_t));
|
2014-06-03 00:32:51 +08:00
|
|
|
lock->lk_new_lock_seqid = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t));
|
2014-06-03 00:32:51 +08:00
|
|
|
lock->lk_new_owner.len = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(lock->lk_new_owner.len);
|
|
|
|
READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len);
|
|
|
|
} else {
|
2008-08-13 01:46:18 +08:00
|
|
|
status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
lock->lk_old_lock_seqid = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(32);
|
2014-06-03 00:32:51 +08:00
|
|
|
lockt->lt_type = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))
|
|
|
|
goto xdr_error;
|
2014-06-03 00:45:31 +08:00
|
|
|
p = xdr_decode_hyper(p, &lockt->lt_offset);
|
|
|
|
p = xdr_decode_hyper(p, &lockt->lt_length);
|
2005-04-17 06:20:36 +08:00
|
|
|
COPYMEM(&lockt->lt_clientid, 8);
|
2014-06-03 00:32:51 +08:00
|
|
|
lockt->lt_owner.len = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(lockt->lt_owner.len);
|
|
|
|
READMEM(lockt->lt_owner.data, lockt->lt_owner.len);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2008-08-13 01:46:18 +08:00
|
|
|
READ_BUF(8);
|
2014-06-03 00:32:51 +08:00
|
|
|
locku->lu_type = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))
|
|
|
|
goto xdr_error;
|
2014-06-03 00:32:51 +08:00
|
|
|
locku->lu_seqid = be32_to_cpup(p++);
|
2008-08-13 01:46:18 +08:00
|
|
|
status = nfsd4_decode_stateid(argp, &locku->lu_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(16);
|
2014-06-03 00:45:31 +08:00
|
|
|
p = xdr_decode_hyper(p, &locku->lu_offset);
|
|
|
|
p = xdr_decode_hyper(p, &locku->lu_length);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
lookup->lo_len = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(lookup->lo_len);
|
|
|
|
SAVEMEM(lookup->lo_name, lookup->lo_len);
|
2012-11-26 05:31:00 +08:00
|
|
|
if ((status = check_filename(lookup->lo_name, lookup->lo_len)))
|
2005-04-17 06:20:36 +08:00
|
|
|
return status;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2012-02-17 02:57:09 +08:00
|
|
|
static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when)
|
2011-10-11 02:37:13 +08:00
|
|
|
{
|
|
|
|
__be32 *p;
|
|
|
|
u32 w;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
w = be32_to_cpup(p++);
|
2012-02-17 02:57:09 +08:00
|
|
|
*share_access = w & NFS4_SHARE_ACCESS_MASK;
|
|
|
|
*deleg_want = w & NFS4_SHARE_WANT_MASK;
|
|
|
|
if (deleg_when)
|
|
|
|
*deleg_when = w & NFS4_SHARE_WHEN_MASK;
|
|
|
|
|
2011-10-11 02:37:13 +08:00
|
|
|
switch (w & NFS4_SHARE_ACCESS_MASK) {
|
|
|
|
case NFS4_SHARE_ACCESS_READ:
|
|
|
|
case NFS4_SHARE_ACCESS_WRITE:
|
|
|
|
case NFS4_SHARE_ACCESS_BOTH:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return nfserr_bad_xdr;
|
|
|
|
}
|
2011-10-28 02:43:01 +08:00
|
|
|
w &= ~NFS4_SHARE_ACCESS_MASK;
|
2011-10-11 02:37:13 +08:00
|
|
|
if (!w)
|
|
|
|
return nfs_ok;
|
|
|
|
if (!argp->minorversion)
|
|
|
|
return nfserr_bad_xdr;
|
|
|
|
switch (w & NFS4_SHARE_WANT_MASK) {
|
|
|
|
case NFS4_SHARE_WANT_NO_PREFERENCE:
|
|
|
|
case NFS4_SHARE_WANT_READ_DELEG:
|
|
|
|
case NFS4_SHARE_WANT_WRITE_DELEG:
|
|
|
|
case NFS4_SHARE_WANT_ANY_DELEG:
|
|
|
|
case NFS4_SHARE_WANT_NO_DELEG:
|
|
|
|
case NFS4_SHARE_WANT_CANCEL:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return nfserr_bad_xdr;
|
|
|
|
}
|
2011-10-20 10:13:29 +08:00
|
|
|
w &= ~NFS4_SHARE_WANT_MASK;
|
2011-10-11 02:37:13 +08:00
|
|
|
if (!w)
|
|
|
|
return nfs_ok;
|
2012-02-17 02:57:09 +08:00
|
|
|
|
|
|
|
if (!deleg_when) /* open_downgrade */
|
|
|
|
return nfserr_inval;
|
2011-10-11 02:37:13 +08:00
|
|
|
switch (w) {
|
|
|
|
case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL:
|
|
|
|
case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED:
|
2011-10-20 10:13:13 +08:00
|
|
|
case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL |
|
|
|
|
NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED):
|
2011-10-11 02:37:13 +08:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
xdr_error:
|
|
|
|
return nfserr_bad_xdr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32 nfsd4_decode_share_deny(struct nfsd4_compoundargs *argp, u32 *x)
|
|
|
|
{
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
*x = be32_to_cpup(p++);
|
2011-10-11 02:37:13 +08:00
|
|
|
/* Note: unlinke access bits, deny bits may be zero. */
|
2011-10-17 15:41:17 +08:00
|
|
|
if (*x & ~NFS4_SHARE_DENY_BOTH)
|
2011-10-11 02:37:13 +08:00
|
|
|
return nfserr_bad_xdr;
|
|
|
|
return nfs_ok;
|
|
|
|
xdr_error:
|
|
|
|
return nfserr_bad_xdr;
|
|
|
|
}
|
|
|
|
|
2011-10-11 03:07:40 +08:00
|
|
|
static __be32 nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o)
|
|
|
|
{
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
o->len = be32_to_cpup(p++);
|
2011-10-11 03:07:40 +08:00
|
|
|
|
|
|
|
if (o->len == 0 || o->len > NFS4_OPAQUE_LIMIT)
|
|
|
|
return nfserr_bad_xdr;
|
|
|
|
|
|
|
|
READ_BUF(o->len);
|
|
|
|
SAVEMEM(o->data, o->len);
|
|
|
|
return nfs_ok;
|
|
|
|
xdr_error:
|
|
|
|
return nfserr_bad_xdr;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
2012-02-17 02:57:09 +08:00
|
|
|
u32 dummy;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
memset(open->op_bmval, 0, sizeof(open->op_bmval));
|
|
|
|
open->op_iattr.ia_valid = 0;
|
2011-07-31 11:33:59 +08:00
|
|
|
open->op_openowner = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-03-01 04:51:49 +08:00
|
|
|
open->op_xdr_error = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
/* seqid, share_access, share_deny, clientid, ownerlen */
|
2011-10-11 02:37:13 +08:00
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
open->op_seqid = be32_to_cpup(p++);
|
2012-02-17 02:57:09 +08:00
|
|
|
/* decode, yet ignore deleg_when until supported */
|
|
|
|
status = nfsd4_decode_share_access(argp, &open->op_share_access,
|
|
|
|
&open->op_deleg_want, &dummy);
|
2011-10-11 02:37:13 +08:00
|
|
|
if (status)
|
|
|
|
goto xdr_error;
|
|
|
|
status = nfsd4_decode_share_deny(argp, &open->op_share_deny);
|
|
|
|
if (status)
|
|
|
|
goto xdr_error;
|
2011-10-11 03:07:40 +08:00
|
|
|
READ_BUF(sizeof(clientid_t));
|
2005-04-17 06:20:36 +08:00
|
|
|
COPYMEM(&open->op_clientid, sizeof(clientid_t));
|
2011-10-11 03:07:40 +08:00
|
|
|
status = nfsd4_decode_opaque(argp, &open->op_owner);
|
|
|
|
if (status)
|
|
|
|
goto xdr_error;
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
open->op_create = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (open->op_create) {
|
|
|
|
case NFS4_OPEN_NOCREATE:
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CREATE:
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
open->op_createmode = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (open->op_createmode) {
|
|
|
|
case NFS4_CREATE_UNCHECKED:
|
|
|
|
case NFS4_CREATE_GUARDED:
|
2009-04-03 13:29:05 +08:00
|
|
|
status = nfsd4_decode_fattr(argp, open->op_bmval,
|
2016-01-13 03:24:14 +08:00
|
|
|
&open->op_iattr, &open->op_acl, &open->op_label,
|
2018-03-22 05:19:02 +08:00
|
|
|
&open->op_umask);
|
2009-04-03 13:29:05 +08:00
|
|
|
if (status)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
case NFS4_CREATE_EXCLUSIVE:
|
2012-03-03 06:13:50 +08:00
|
|
|
READ_BUF(NFS4_VERIFIER_SIZE);
|
|
|
|
COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
2009-04-03 13:29:17 +08:00
|
|
|
case NFS4_CREATE_EXCLUSIVE4_1:
|
|
|
|
if (argp->minorversion < 1)
|
|
|
|
goto xdr_error;
|
2012-03-03 06:13:50 +08:00
|
|
|
READ_BUF(NFS4_VERIFIER_SIZE);
|
|
|
|
COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
|
2009-04-03 13:29:17 +08:00
|
|
|
status = nfsd4_decode_fattr(argp, open->op_bmval,
|
2016-01-13 03:24:14 +08:00
|
|
|
&open->op_iattr, &open->op_acl, &open->op_label,
|
2018-03-22 05:19:02 +08:00
|
|
|
&open->op_umask);
|
2009-04-03 13:29:17 +08:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
default:
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* open_claim */
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
open->op_claim_type = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (open->op_claim_type) {
|
|
|
|
case NFS4_OPEN_CLAIM_NULL:
|
|
|
|
case NFS4_OPEN_CLAIM_DELEGATE_PREV:
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
open->op_fname.len = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(open->op_fname.len);
|
|
|
|
SAVEMEM(open->op_fname.data, open->op_fname.len);
|
2012-11-26 05:31:00 +08:00
|
|
|
if ((status = check_filename(open->op_fname.data, open->op_fname.len)))
|
2005-04-17 06:20:36 +08:00
|
|
|
return status;
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CLAIM_PREVIOUS:
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
open->op_delegate_type = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CLAIM_DELEGATE_CUR:
|
2008-08-13 01:46:18 +08:00
|
|
|
status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
open->op_fname.len = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(open->op_fname.len);
|
|
|
|
SAVEMEM(open->op_fname.data, open->op_fname.len);
|
2012-11-26 05:31:00 +08:00
|
|
|
if ((status = check_filename(open->op_fname.data, open->op_fname.len)))
|
2005-04-17 06:20:36 +08:00
|
|
|
return status;
|
|
|
|
break;
|
2011-10-19 23:52:12 +08:00
|
|
|
case NFS4_OPEN_CLAIM_FH:
|
|
|
|
case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
|
|
|
|
if (argp->minorversion < 1)
|
|
|
|
goto xdr_error;
|
|
|
|
/* void */
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
|
|
|
|
if (argp->minorversion < 1)
|
|
|
|
goto xdr_error;
|
|
|
|
status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
default:
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
2013-10-30 22:00:20 +08:00
|
|
|
|
|
|
|
if (argp->minorversion >= 1)
|
|
|
|
return nfserr_notsupp;
|
|
|
|
|
2008-08-13 01:46:18 +08:00
|
|
|
status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
open_conf->oc_seqid = be32_to_cpup(p++);
|
2013-10-30 22:00:20 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2008-08-13 01:46:18 +08:00
|
|
|
status = nfsd4_decode_stateid(argp, &open_down->od_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2011-10-11 02:37:13 +08:00
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
open_down->od_seqid = be32_to_cpup(p++);
|
2012-02-17 02:57:09 +08:00
|
|
|
status = nfsd4_decode_share_access(argp, &open_down->od_share_access,
|
|
|
|
&open_down->od_deleg_want, NULL);
|
2011-10-11 02:37:13 +08:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
status = nfsd4_decode_share_deny(argp, &open_down->od_share_deny);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2005-04-17 06:20:36 +08:00
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
putfh->pf_fhlen = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (putfh->pf_fhlen > NFS4_FHSIZE)
|
|
|
|
goto xdr_error;
|
|
|
|
READ_BUF(putfh->pf_fhlen);
|
|
|
|
SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2013-10-30 22:00:20 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_putpubfh(struct nfsd4_compoundargs *argp, void *p)
|
|
|
|
{
|
|
|
|
if (argp->minorversion == 0)
|
|
|
|
return nfs_ok;
|
|
|
|
return nfserr_notsupp;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2008-08-13 01:46:18 +08:00
|
|
|
status = nfsd4_decode_stateid(argp, &read->rd_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(12);
|
2014-06-03 00:45:31 +08:00
|
|
|
p = xdr_decode_hyper(p, &read->rd_offset);
|
2014-06-03 00:32:51 +08:00
|
|
|
read->rd_length = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(24);
|
2014-06-03 00:45:31 +08:00
|
|
|
p = xdr_decode_hyper(p, &readdir->rd_cookie);
|
2005-04-17 06:20:36 +08:00
|
|
|
COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data));
|
2014-06-03 00:32:51 +08:00
|
|
|
readdir->rd_dircount = be32_to_cpup(p++);
|
|
|
|
readdir->rd_maxcount = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval)))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
remove->rm_namelen = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(remove->rm_namelen);
|
|
|
|
SAVEMEM(remove->rm_name, remove->rm_namelen);
|
2012-11-26 05:31:00 +08:00
|
|
|
if ((status = check_filename(remove->rm_name, remove->rm_namelen)))
|
2005-04-17 06:20:36 +08:00
|
|
|
return status;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
rename->rn_snamelen = be32_to_cpup(p++);
|
2016-03-01 09:21:21 +08:00
|
|
|
READ_BUF(rename->rn_snamelen);
|
2005-04-17 06:20:36 +08:00
|
|
|
SAVEMEM(rename->rn_sname, rename->rn_snamelen);
|
2016-03-01 09:21:21 +08:00
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
rename->rn_tnamelen = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(rename->rn_tnamelen);
|
|
|
|
SAVEMEM(rename->rn_tname, rename->rn_tnamelen);
|
2012-11-26 05:31:00 +08:00
|
|
|
if ((status = check_filename(rename->rn_sname, rename->rn_snamelen)))
|
2005-04-17 06:20:36 +08:00
|
|
|
return status;
|
2012-11-26 05:31:00 +08:00
|
|
|
if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen)))
|
2005-04-17 06:20:36 +08:00
|
|
|
return status;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2013-10-30 22:00:20 +08:00
|
|
|
if (argp->minorversion >= 1)
|
|
|
|
return nfserr_notsupp;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(sizeof(clientid_t));
|
|
|
|
COPYMEM(clientid, sizeof(clientid_t));
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2007-07-17 19:04:51 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_secinfo *secinfo)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
secinfo->si_namelen = be32_to_cpup(p++);
|
2007-07-17 19:04:51 +08:00
|
|
|
READ_BUF(secinfo->si_namelen);
|
|
|
|
SAVEMEM(secinfo->si_name, secinfo->si_namelen);
|
2012-11-26 05:31:00 +08:00
|
|
|
status = check_filename(secinfo->si_name, secinfo->si_namelen);
|
2007-07-17 19:04:51 +08:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2010-12-16 22:51:13 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_secinfo_no_name *sin)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
sin->sin_style = be32_to_cpup(p++);
|
2010-12-16 22:51:13 +08:00
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr)
|
|
|
|
{
|
2008-08-13 01:46:18 +08:00
|
|
|
__be32 status;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-08-13 01:46:18 +08:00
|
|
|
status = nfsd4_decode_stateid(argp, &setattr->sa_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2009-05-16 16:22:31 +08:00
|
|
|
return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr,
|
2016-01-13 03:24:14 +08:00
|
|
|
&setattr->sa_acl, &setattr->sa_label, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2013-10-30 22:00:20 +08:00
|
|
|
if (argp->minorversion >= 1)
|
|
|
|
return nfserr_notsupp;
|
|
|
|
|
2012-03-03 06:13:50 +08:00
|
|
|
READ_BUF(NFS4_VERIFIER_SIZE);
|
|
|
|
COPYMEM(setclientid->se_verf.data, NFS4_VERIFIER_SIZE);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-10-11 03:07:40 +08:00
|
|
|
status = nfsd4_decode_opaque(argp, &setclientid->se_name);
|
|
|
|
if (status)
|
|
|
|
return nfserr_bad_xdr;
|
|
|
|
READ_BUF(8);
|
2014-06-03 00:32:51 +08:00
|
|
|
setclientid->se_callback_prog = be32_to_cpup(p++);
|
|
|
|
setclientid->se_callback_netid_len = be32_to_cpup(p++);
|
2016-03-01 09:21:21 +08:00
|
|
|
READ_BUF(setclientid->se_callback_netid_len);
|
2005-04-17 06:20:36 +08:00
|
|
|
SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len);
|
2016-03-01 09:21:21 +08:00
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
setclientid->se_callback_addr_len = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-03-01 09:21:21 +08:00
|
|
|
READ_BUF(setclientid->se_callback_addr_len);
|
2005-04-17 06:20:36 +08:00
|
|
|
SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len);
|
2016-03-01 09:21:21 +08:00
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
setclientid->se_callback_ident = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2013-10-30 22:00:20 +08:00
|
|
|
if (argp->minorversion >= 1)
|
|
|
|
return nfserr_notsupp;
|
|
|
|
|
2012-03-03 06:13:50 +08:00
|
|
|
READ_BUF(8 + NFS4_VERIFIER_SIZE);
|
2005-04-17 06:20:36 +08:00
|
|
|
COPYMEM(&scd_c->sc_clientid, 8);
|
2012-03-03 06:13:50 +08:00
|
|
|
COPYMEM(&scd_c->sc_confirm, NFS4_VERIFIER_SIZE);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Also used for NVERIFY */
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verify)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
if ((status = nfsd4_decode_bitmap(argp, verify->ve_bmval)))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* For convenience's sake, we compare raw xdr'd attributes in
|
2012-12-01 06:24:18 +08:00
|
|
|
* nfsd4_proc_verify */
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
verify->ve_attrlen = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(verify->ve_attrlen);
|
|
|
|
SAVEMEM(verify->ve_attrval, verify->ve_attrlen);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2008-08-13 01:46:18 +08:00
|
|
|
status = nfsd4_decode_stateid(argp, &write->wr_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(16);
|
2014-06-03 00:45:31 +08:00
|
|
|
p = xdr_decode_hyper(p, &write->wr_offset);
|
2014-06-03 00:32:51 +08:00
|
|
|
write->wr_stable_how = be32_to_cpup(p++);
|
2016-12-31 20:59:53 +08:00
|
|
|
if (write->wr_stable_how > NFS_FILE_SYNC)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto xdr_error;
|
2014-06-03 00:32:51 +08:00
|
|
|
write->wr_buflen = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2020-06-24 06:39:21 +08:00
|
|
|
status = svcxdr_construct_vector(argp, &write->wr_head,
|
|
|
|
&write->wr_pagelist, write->wr_buflen);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2013-10-30 22:00:20 +08:00
|
|
|
if (argp->minorversion >= 1)
|
|
|
|
return nfserr_notsupp;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(12);
|
|
|
|
COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t));
|
2014-06-03 00:32:51 +08:00
|
|
|
rlockowner->rl_owner.len = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
READ_BUF(rlockowner->rl_owner.len);
|
|
|
|
READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len);
|
|
|
|
|
2009-04-03 13:28:50 +08:00
|
|
|
if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))
|
|
|
|
return nfserr_inval;
|
2005-04-17 06:20:36 +08:00
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2009-04-03 13:27:55 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp,
|
2009-04-03 13:28:01 +08:00
|
|
|
struct nfsd4_exchange_id *exid)
|
2009-04-03 13:27:55 +08:00
|
|
|
{
|
2010-11-09 09:39:23 +08:00
|
|
|
int dummy, tmp;
|
2009-04-03 13:28:01 +08:00
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(NFS4_VERIFIER_SIZE);
|
|
|
|
COPYMEM(exid->verifier.data, NFS4_VERIFIER_SIZE);
|
|
|
|
|
2011-10-11 03:07:40 +08:00
|
|
|
status = nfsd4_decode_opaque(argp, &exid->clname);
|
|
|
|
if (status)
|
|
|
|
return nfserr_bad_xdr;
|
2009-04-03 13:28:01 +08:00
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
exid->flags = be32_to_cpup(p++);
|
2009-04-03 13:28:01 +08:00
|
|
|
|
|
|
|
/* Ignore state_protect4_a */
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
exid->spa_how = be32_to_cpup(p++);
|
2009-04-03 13:28:01 +08:00
|
|
|
switch (exid->spa_how) {
|
|
|
|
case SP4_NONE:
|
|
|
|
break;
|
|
|
|
case SP4_MACH_CRED:
|
|
|
|
/* spo_must_enforce */
|
2016-06-16 00:52:09 +08:00
|
|
|
status = nfsd4_decode_bitmap(argp,
|
|
|
|
exid->spo_must_enforce);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
2009-04-03 13:28:01 +08:00
|
|
|
/* spo_must_allow */
|
2016-06-16 00:52:09 +08:00
|
|
|
status = nfsd4_decode_bitmap(argp, exid->spo_must_allow);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
2009-04-03 13:28:01 +08:00
|
|
|
break;
|
|
|
|
case SP4_SSV:
|
|
|
|
/* ssp_ops */
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2009-04-03 13:28:01 +08:00
|
|
|
READ_BUF(dummy * 4);
|
|
|
|
p += dummy;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2009-04-03 13:28:01 +08:00
|
|
|
READ_BUF(dummy * 4);
|
|
|
|
p += dummy;
|
|
|
|
|
|
|
|
/* ssp_hash_algs<> */
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
tmp = be32_to_cpup(p++);
|
2010-11-09 09:39:23 +08:00
|
|
|
while (tmp--) {
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2010-11-09 09:39:23 +08:00
|
|
|
READ_BUF(dummy);
|
|
|
|
p += XDR_QUADLEN(dummy);
|
|
|
|
}
|
2009-04-03 13:28:01 +08:00
|
|
|
|
|
|
|
/* ssp_encr_algs<> */
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
tmp = be32_to_cpup(p++);
|
2010-11-09 09:39:23 +08:00
|
|
|
while (tmp--) {
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2010-11-09 09:39:23 +08:00
|
|
|
READ_BUF(dummy);
|
|
|
|
p += XDR_QUADLEN(dummy);
|
|
|
|
}
|
2009-04-03 13:28:01 +08:00
|
|
|
|
2018-07-23 09:57:11 +08:00
|
|
|
/* ignore ssp_window and ssp_num_gss_handles: */
|
2009-04-03 13:28:01 +08:00
|
|
|
READ_BUF(8);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
READ_BUF(4); /* nfs_impl_id4 array length */
|
2014-06-03 00:32:51 +08:00
|
|
|
dummy = be32_to_cpup(p++);
|
2009-04-03 13:28:01 +08:00
|
|
|
|
|
|
|
if (dummy > 1)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
if (dummy == 1) {
|
2019-06-06 00:42:05 +08:00
|
|
|
status = nfsd4_decode_opaque(argp, &exid->nii_domain);
|
|
|
|
if (status)
|
|
|
|
goto xdr_error;
|
2009-04-03 13:28:01 +08:00
|
|
|
|
|
|
|
/* nii_name */
|
2019-06-06 00:42:05 +08:00
|
|
|
status = nfsd4_decode_opaque(argp, &exid->nii_name);
|
|
|
|
if (status)
|
|
|
|
goto xdr_error;
|
2009-04-03 13:28:01 +08:00
|
|
|
|
|
|
|
/* nii_date */
|
2019-06-06 00:42:05 +08:00
|
|
|
status = nfsd4_decode_time(argp, &exid->nii_time);
|
|
|
|
if (status)
|
|
|
|
goto xdr_error;
|
2009-04-03 13:28:01 +08:00
|
|
|
}
|
|
|
|
DECODE_TAIL;
|
2009-04-03 13:27:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_create_session(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_create_session *sess)
|
|
|
|
{
|
2009-04-03 13:28:28 +08:00
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(16);
|
|
|
|
COPYMEM(&sess->clientid, 8);
|
2014-06-03 00:32:51 +08:00
|
|
|
sess->seqid = be32_to_cpup(p++);
|
|
|
|
sess->flags = be32_to_cpup(p++);
|
2009-04-03 13:28:28 +08:00
|
|
|
|
|
|
|
/* Fore channel attrs */
|
|
|
|
READ_BUF(28);
|
2019-08-19 02:18:58 +08:00
|
|
|
p++; /* headerpadsz is always 0 */
|
2014-06-03 00:32:51 +08:00
|
|
|
sess->fore_channel.maxreq_sz = be32_to_cpup(p++);
|
|
|
|
sess->fore_channel.maxresp_sz = be32_to_cpup(p++);
|
|
|
|
sess->fore_channel.maxresp_cached = be32_to_cpup(p++);
|
|
|
|
sess->fore_channel.maxops = be32_to_cpup(p++);
|
|
|
|
sess->fore_channel.maxreqs = be32_to_cpup(p++);
|
|
|
|
sess->fore_channel.nr_rdma_attrs = be32_to_cpup(p++);
|
2009-04-03 13:28:28 +08:00
|
|
|
if (sess->fore_channel.nr_rdma_attrs == 1) {
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
sess->fore_channel.rdma_attrs = be32_to_cpup(p++);
|
2009-04-03 13:28:28 +08:00
|
|
|
} else if (sess->fore_channel.nr_rdma_attrs > 1) {
|
|
|
|
dprintk("Too many fore channel attr bitmaps!\n");
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Back channel attrs */
|
|
|
|
READ_BUF(28);
|
2019-08-19 02:18:58 +08:00
|
|
|
p++; /* headerpadsz is always 0 */
|
2014-06-03 00:32:51 +08:00
|
|
|
sess->back_channel.maxreq_sz = be32_to_cpup(p++);
|
|
|
|
sess->back_channel.maxresp_sz = be32_to_cpup(p++);
|
|
|
|
sess->back_channel.maxresp_cached = be32_to_cpup(p++);
|
|
|
|
sess->back_channel.maxops = be32_to_cpup(p++);
|
|
|
|
sess->back_channel.maxreqs = be32_to_cpup(p++);
|
|
|
|
sess->back_channel.nr_rdma_attrs = be32_to_cpup(p++);
|
2009-04-03 13:28:28 +08:00
|
|
|
if (sess->back_channel.nr_rdma_attrs == 1) {
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
sess->back_channel.rdma_attrs = be32_to_cpup(p++);
|
2009-04-03 13:28:28 +08:00
|
|
|
} else if (sess->back_channel.nr_rdma_attrs > 1) {
|
|
|
|
dprintk("Too many back channel attr bitmaps!\n");
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
|
2012-03-28 02:50:26 +08:00
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
sess->callback_prog = be32_to_cpup(p++);
|
2012-03-28 02:50:26 +08:00
|
|
|
nfsd4_decode_cb_sec(argp, &sess->cb_sec);
|
2009-04-03 13:28:28 +08:00
|
|
|
DECODE_TAIL;
|
2009-04-03 13:27:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_destroy_session *destroy_session)
|
|
|
|
{
|
2009-04-03 13:28:38 +08:00
|
|
|
DECODE_HEAD;
|
|
|
|
READ_BUF(NFS4_MAX_SESSIONID_LEN);
|
|
|
|
COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
2009-04-03 13:27:55 +08:00
|
|
|
}
|
|
|
|
|
2011-07-13 23:04:21 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_free_stateid *free_stateid)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(sizeof(stateid_t));
|
2014-06-03 00:32:51 +08:00
|
|
|
free_stateid->fr_stateid.si_generation = be32_to_cpup(p++);
|
2011-07-13 23:04:21 +08:00
|
|
|
COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t));
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2009-04-03 13:27:55 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_sequence(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_sequence *seq)
|
|
|
|
{
|
2009-04-03 13:28:08 +08:00
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(NFS4_MAX_SESSIONID_LEN + 16);
|
|
|
|
COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);
|
2014-06-03 00:32:51 +08:00
|
|
|
seq->seqid = be32_to_cpup(p++);
|
|
|
|
seq->slotid = be32_to_cpup(p++);
|
|
|
|
seq->maxslots = be32_to_cpup(p++);
|
|
|
|
seq->cachethis = be32_to_cpup(p++);
|
2009-04-03 13:28:08 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
2009-04-03 13:27:55 +08:00
|
|
|
}
|
|
|
|
|
2011-07-13 22:50:48 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid)
|
|
|
|
{
|
|
|
|
int i;
|
2012-01-27 23:22:49 +08:00
|
|
|
__be32 *p, status;
|
|
|
|
struct nfsd4_test_stateid_id *stateid;
|
2011-07-13 22:50:48 +08:00
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
test_stateid->ts_num_ids = ntohl(*p++);
|
|
|
|
|
2012-01-27 23:22:49 +08:00
|
|
|
INIT_LIST_HEAD(&test_stateid->ts_stateid_list);
|
2011-07-13 22:50:48 +08:00
|
|
|
|
|
|
|
for (i = 0; i < test_stateid->ts_num_ids; i++) {
|
2014-06-25 05:43:45 +08:00
|
|
|
stateid = svcxdr_tmpalloc(argp, sizeof(*stateid));
|
2012-01-27 23:22:49 +08:00
|
|
|
if (!stateid) {
|
2012-04-13 12:15:37 +08:00
|
|
|
status = nfserrno(-ENOMEM);
|
2012-01-27 23:22:49 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&stateid->ts_id_list);
|
|
|
|
list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list);
|
|
|
|
|
|
|
|
status = nfsd4_decode_stateid(argp, &stateid->ts_id_stateid);
|
2011-07-13 22:50:48 +08:00
|
|
|
if (status)
|
2012-01-27 23:22:49 +08:00
|
|
|
goto out;
|
2011-07-13 22:50:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
status = 0;
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
xdr_error:
|
|
|
|
dprintk("NFSD: xdr error (%s:%d)\n", __FILE__, __LINE__);
|
|
|
|
status = nfserr_bad_xdr;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-10-20 17:51:39 +08:00
|
|
|
static __be32 nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs *argp, struct nfsd4_destroy_clientid *dc)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(8);
|
|
|
|
COPYMEM(&dc->clientid, 8);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2010-04-20 03:11:28 +08:00
|
|
|
static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, struct nfsd4_reclaim_complete *rc)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
rc->rca_one_fs = be32_to_cpup(p++);
|
2010-04-20 03:11:28 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
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 19:11:59 +08:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_getdeviceinfo(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_getdeviceinfo *gdev)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
u32 num, i;
|
|
|
|
|
|
|
|
READ_BUF(sizeof(struct nfsd4_deviceid) + 3 * 4);
|
|
|
|
COPYMEM(&gdev->gd_devid, sizeof(struct nfsd4_deviceid));
|
|
|
|
gdev->gd_layout_type = be32_to_cpup(p++);
|
|
|
|
gdev->gd_maxcount = be32_to_cpup(p++);
|
|
|
|
num = be32_to_cpup(p++);
|
|
|
|
if (num) {
|
nfsd: fix potential use-after-free in nfsd4_decode_getdeviceinfo
When running a fuzz tester against a KASAN-enabled kernel, the following
splat periodically occurs.
The problem occurs when the test sends a GETDEVICEINFO request with a
malformed xdr array (size but no data) for gdia_notify_types and the
array size is > 0x3fffffff, which results in an overflow in the value of
nbytes which is passed to read_buf().
If the array size is 0x40000000, 0x80000000, or 0xc0000000, then after
the overflow occurs, the value of nbytes 0, and when that happens the
pointer returned by read_buf() points to the end of the xdr data (i.e.
argp->end) when really it should be returning NULL.
Fix this by returning NFS4ERR_BAD_XDR if the array size is > 1000 (this
value is arbitrary, but it's the same threshold used by
nfsd4_decode_bitmap()... in could really be any value >= 1 since it's
expected to get at most a single bitmap in gdia_notify_types).
[ 119.256854] ==================================================================
[ 119.257611] BUG: KASAN: use-after-free in nfsd4_decode_getdeviceinfo+0x5a4/0x5b0 [nfsd]
[ 119.258422] Read of size 4 at addr ffff880113ada000 by task nfsd/538
[ 119.259146] CPU: 0 PID: 538 Comm: nfsd Not tainted 4.17.0+ #1
[ 119.259662] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.9.3-1.fc25 04/01/2014
[ 119.261202] Call Trace:
[ 119.262265] dump_stack+0x71/0xab
[ 119.263371] print_address_description+0x6a/0x270
[ 119.264609] kasan_report+0x258/0x380
[ 119.265854] ? nfsd4_decode_getdeviceinfo+0x5a4/0x5b0 [nfsd]
[ 119.267291] nfsd4_decode_getdeviceinfo+0x5a4/0x5b0 [nfsd]
[ 119.268549] ? nfs4svc_decode_compoundargs+0xa5b/0x13c0 [nfsd]
[ 119.269873] ? nfsd4_decode_sequence+0x490/0x490 [nfsd]
[ 119.271095] nfs4svc_decode_compoundargs+0xa5b/0x13c0 [nfsd]
[ 119.272393] ? nfsd4_release_compoundargs+0x1b0/0x1b0 [nfsd]
[ 119.273658] nfsd_dispatch+0x183/0x850 [nfsd]
[ 119.274918] svc_process+0x161c/0x31a0 [sunrpc]
[ 119.276172] ? svc_printk+0x190/0x190 [sunrpc]
[ 119.277386] ? svc_xprt_release+0x451/0x680 [sunrpc]
[ 119.278622] nfsd+0x2b9/0x430 [nfsd]
[ 119.279771] ? nfsd_destroy+0x1c0/0x1c0 [nfsd]
[ 119.281157] kthread+0x2db/0x390
[ 119.282347] ? kthread_create_worker_on_cpu+0xc0/0xc0
[ 119.283756] ret_from_fork+0x35/0x40
[ 119.286041] Allocated by task 436:
[ 119.287525] kasan_kmalloc+0xa0/0xd0
[ 119.288685] kmem_cache_alloc+0xe9/0x1f0
[ 119.289900] get_empty_filp+0x7b/0x410
[ 119.291037] path_openat+0xca/0x4220
[ 119.292242] do_filp_open+0x182/0x280
[ 119.293411] do_sys_open+0x216/0x360
[ 119.294555] do_syscall_64+0xa0/0x2f0
[ 119.295721] entry_SYSCALL_64_after_hwframe+0x44/0xa9
[ 119.298068] Freed by task 436:
[ 119.299271] __kasan_slab_free+0x130/0x180
[ 119.300557] kmem_cache_free+0x78/0x210
[ 119.301823] rcu_process_callbacks+0x35b/0xbd0
[ 119.303162] __do_softirq+0x192/0x5ea
[ 119.305443] The buggy address belongs to the object at ffff880113ada000
which belongs to the cache filp of size 256
[ 119.308556] The buggy address is located 0 bytes inside of
256-byte region [ffff880113ada000, ffff880113ada100)
[ 119.311376] The buggy address belongs to the page:
[ 119.312728] page:ffffea00044eb680 count:1 mapcount:0 mapping:0000000000000000 index:0xffff880113ada780
[ 119.314428] flags: 0x17ffe000000100(slab)
[ 119.315740] raw: 0017ffe000000100 0000000000000000 ffff880113ada780 00000001000c0001
[ 119.317379] raw: ffffea0004553c60 ffffea00045c11e0 ffff88011b167e00 0000000000000000
[ 119.319050] page dumped because: kasan: bad access detected
[ 119.321652] Memory state around the buggy address:
[ 119.322993] ffff880113ad9f00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
[ 119.324515] ffff880113ad9f80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
[ 119.326087] >ffff880113ada000: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
[ 119.327547] ^
[ 119.328730] ffff880113ada080: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
[ 119.330218] ffff880113ada100: fc fc fc fc fc fc fc fc fb fb fb fb fb fb fb fb
[ 119.331740] ==================================================================
Signed-off-by: Scott Mayhew <smayhew@redhat.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2018-06-09 04:31:46 +08:00
|
|
|
if (num > 1000)
|
|
|
|
goto xdr_error;
|
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 19:11:59 +08:00
|
|
|
READ_BUF(4 * num);
|
|
|
|
gdev->gd_notify_types = be32_to_cpup(p++);
|
|
|
|
for (i = 1; i < num; i++) {
|
|
|
|
if (be32_to_cpup(p++)) {
|
|
|
|
status = nfserr_inval;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_layoutget(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_layoutget *lgp)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(36);
|
|
|
|
lgp->lg_signal = be32_to_cpup(p++);
|
|
|
|
lgp->lg_layout_type = be32_to_cpup(p++);
|
|
|
|
lgp->lg_seg.iomode = be32_to_cpup(p++);
|
|
|
|
p = xdr_decode_hyper(p, &lgp->lg_seg.offset);
|
|
|
|
p = xdr_decode_hyper(p, &lgp->lg_seg.length);
|
|
|
|
p = xdr_decode_hyper(p, &lgp->lg_minlength);
|
2015-03-19 19:04:41 +08:00
|
|
|
|
|
|
|
status = nfsd4_decode_stateid(argp, &lgp->lg_sid);
|
|
|
|
if (status)
|
|
|
|
return 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 19:11:59 +08:00
|
|
|
READ_BUF(4);
|
|
|
|
lgp->lg_maxcount = be32_to_cpup(p++);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_layoutcommit(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_layoutcommit *lcp)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
u32 timechange;
|
|
|
|
|
|
|
|
READ_BUF(20);
|
|
|
|
p = xdr_decode_hyper(p, &lcp->lc_seg.offset);
|
|
|
|
p = xdr_decode_hyper(p, &lcp->lc_seg.length);
|
|
|
|
lcp->lc_reclaim = be32_to_cpup(p++);
|
2015-03-19 19:04:41 +08:00
|
|
|
|
|
|
|
status = nfsd4_decode_stateid(argp, &lcp->lc_sid);
|
|
|
|
if (status)
|
|
|
|
return 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 19:11:59 +08:00
|
|
|
READ_BUF(4);
|
|
|
|
lcp->lc_newoffset = be32_to_cpup(p++);
|
|
|
|
if (lcp->lc_newoffset) {
|
|
|
|
READ_BUF(8);
|
|
|
|
p = xdr_decode_hyper(p, &lcp->lc_last_wr);
|
|
|
|
} else
|
|
|
|
lcp->lc_last_wr = 0;
|
|
|
|
READ_BUF(4);
|
|
|
|
timechange = be32_to_cpup(p++);
|
|
|
|
if (timechange) {
|
|
|
|
status = nfsd4_decode_time(argp, &lcp->lc_mtime);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
} else {
|
|
|
|
lcp->lc_mtime.tv_nsec = UTIME_NOW;
|
|
|
|
}
|
|
|
|
READ_BUF(8);
|
|
|
|
lcp->lc_layout_type = be32_to_cpup(p++);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Save the layout update in XDR format and let the layout driver deal
|
|
|
|
* with it later.
|
|
|
|
*/
|
|
|
|
lcp->lc_up_len = be32_to_cpup(p++);
|
|
|
|
if (lcp->lc_up_len > 0) {
|
|
|
|
READ_BUF(lcp->lc_up_len);
|
|
|
|
READMEM(lcp->lc_up_layout, lcp->lc_up_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_layoutreturn(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_layoutreturn *lrp)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(16);
|
|
|
|
lrp->lr_reclaim = be32_to_cpup(p++);
|
|
|
|
lrp->lr_layout_type = be32_to_cpup(p++);
|
|
|
|
lrp->lr_seg.iomode = be32_to_cpup(p++);
|
|
|
|
lrp->lr_return_type = be32_to_cpup(p++);
|
|
|
|
if (lrp->lr_return_type == RETURN_FILE) {
|
|
|
|
READ_BUF(16);
|
|
|
|
p = xdr_decode_hyper(p, &lrp->lr_seg.offset);
|
|
|
|
p = xdr_decode_hyper(p, &lrp->lr_seg.length);
|
2015-03-19 19:04:41 +08:00
|
|
|
|
|
|
|
status = nfsd4_decode_stateid(argp, &lrp->lr_sid);
|
|
|
|
if (status)
|
|
|
|
return 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 19:11:59 +08:00
|
|
|
READ_BUF(4);
|
|
|
|
lrp->lrf_body_len = be32_to_cpup(p++);
|
|
|
|
if (lrp->lrf_body_len > 0) {
|
|
|
|
READ_BUF(lrp->lrf_body_len);
|
|
|
|
READMEM(lrp->lrf_body, lrp->lrf_body_len);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
lrp->lr_seg.offset = 0;
|
|
|
|
lrp->lr_seg.length = NFS4_MAX_UINT64;
|
|
|
|
}
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NFSD_PNFS */
|
|
|
|
|
2014-11-08 03:44:26 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_fallocate(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_fallocate *fallocate)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
status = nfsd4_decode_stateid(argp, &fallocate->falloc_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
READ_BUF(16);
|
|
|
|
p = xdr_decode_hyper(p, &fallocate->falloc_offset);
|
|
|
|
xdr_decode_hyper(p, &fallocate->falloc_length);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2015-12-03 19:59:52 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_clone(struct nfsd4_compoundargs *argp, struct nfsd4_clone *clone)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
status = nfsd4_decode_stateid(argp, &clone->cl_src_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
status = nfsd4_decode_stateid(argp, &clone->cl_dst_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
READ_BUF(8 + 8 + 8);
|
|
|
|
p = xdr_decode_hyper(p, &clone->cl_src_pos);
|
|
|
|
p = xdr_decode_hyper(p, &clone->cl_dst_pos);
|
|
|
|
p = xdr_decode_hyper(p, &clone->cl_count);
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2019-09-14 02:00:57 +08:00
|
|
|
static __be32 nfsd4_decode_nl4_server(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nl4_server *ns)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
struct nfs42_netaddr *naddr;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
ns->nl4_type = be32_to_cpup(p++);
|
|
|
|
|
|
|
|
/* currently support for 1 inter-server source server */
|
|
|
|
switch (ns->nl4_type) {
|
|
|
|
case NL4_NETADDR:
|
|
|
|
naddr = &ns->u.nl4_addr;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
naddr->netid_len = be32_to_cpup(p++);
|
|
|
|
if (naddr->netid_len > RPCBIND_MAXNETIDLEN)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
READ_BUF(naddr->netid_len + 4); /* 4 for uaddr len */
|
|
|
|
COPYMEM(naddr->netid, naddr->netid_len);
|
|
|
|
|
|
|
|
naddr->addr_len = be32_to_cpup(p++);
|
|
|
|
if (naddr->addr_len > RPCBIND_MAXUADDRLEN)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
READ_BUF(naddr->addr_len);
|
|
|
|
COPYMEM(naddr->addr, naddr->addr_len);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2016-09-08 03:57:30 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_copy(struct nfsd4_compoundargs *argp, struct nfsd4_copy *copy)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
2019-09-14 02:00:57 +08:00
|
|
|
struct nl4_server *ns_dummy;
|
|
|
|
int i, count;
|
2016-09-08 03:57:30 +08:00
|
|
|
|
|
|
|
status = nfsd4_decode_stateid(argp, ©->cp_src_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
status = nfsd4_decode_stateid(argp, ©->cp_dst_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
READ_BUF(8 + 8 + 8 + 4 + 4 + 4);
|
|
|
|
p = xdr_decode_hyper(p, ©->cp_src_pos);
|
|
|
|
p = xdr_decode_hyper(p, ©->cp_dst_pos);
|
|
|
|
p = xdr_decode_hyper(p, ©->cp_count);
|
2018-03-08 04:37:35 +08:00
|
|
|
p++; /* ca_consecutive: we always do consecutive copies */
|
2016-09-08 03:57:30 +08:00
|
|
|
copy->cp_synchronous = be32_to_cpup(p++);
|
2019-09-14 02:00:57 +08:00
|
|
|
|
|
|
|
count = be32_to_cpup(p++);
|
|
|
|
|
|
|
|
copy->cp_intra = false;
|
|
|
|
if (count == 0) { /* intra-server copy */
|
|
|
|
copy->cp_intra = true;
|
|
|
|
goto intra;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* decode all the supplied server addresses but use first */
|
|
|
|
status = nfsd4_decode_nl4_server(argp, ©->cp_src);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
ns_dummy = kmalloc(sizeof(struct nl4_server), GFP_KERNEL);
|
|
|
|
if (ns_dummy == NULL)
|
|
|
|
return nfserrno(-ENOMEM);
|
|
|
|
for (i = 0; i < count - 1; i++) {
|
|
|
|
status = nfsd4_decode_nl4_server(argp, ns_dummy);
|
|
|
|
if (status) {
|
|
|
|
kfree(ns_dummy);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kfree(ns_dummy);
|
|
|
|
intra:
|
2016-09-08 03:57:30 +08:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2018-07-21 06:19:18 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_offload_status(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_offload_status *os)
|
|
|
|
{
|
|
|
|
return nfsd4_decode_stateid(argp, &os->stateid);
|
|
|
|
}
|
|
|
|
|
2019-08-08 23:14:59 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_copy_notify(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_copy_notify *cn)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = nfsd4_decode_stateid(argp, &cn->cpn_src_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
return nfsd4_decode_nl4_server(argp, &cn->cpn_dst);
|
|
|
|
}
|
|
|
|
|
2014-09-27 01:58:27 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_seek(struct nfsd4_compoundargs *argp, struct nfsd4_seek *seek)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
status = nfsd4_decode_stateid(argp, &seek->seek_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
READ_BUF(8 + 4);
|
|
|
|
p = xdr_decode_hyper(p, &seek->seek_offset);
|
|
|
|
seek->seek_whence = be32_to_cpup(p);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2020-06-24 06:39:26 +08:00
|
|
|
/*
|
|
|
|
* XDR data that is more than PAGE_SIZE in size is normally part of a
|
|
|
|
* read or write. However, the size of extended attributes is limited
|
|
|
|
* by the maximum request size, and then further limited by the underlying
|
|
|
|
* filesystem limits. This can exceed PAGE_SIZE (currently, XATTR_SIZE_MAX
|
|
|
|
* is 64k). Since there is no kvec- or page-based interface to xattrs,
|
|
|
|
* and we're not dealing with contiguous pages, we need to do some copying.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode data into buffer. Uses head and pages constructed by
|
|
|
|
* svcxdr_construct_vector.
|
|
|
|
*/
|
|
|
|
static __be32
|
|
|
|
nfsd4_vbuf_from_vector(struct nfsd4_compoundargs *argp, struct kvec *head,
|
|
|
|
struct page **pages, char **bufp, u32 buflen)
|
|
|
|
{
|
|
|
|
char *tmp, *dp;
|
|
|
|
u32 len;
|
|
|
|
|
|
|
|
if (buflen <= head->iov_len) {
|
|
|
|
/*
|
|
|
|
* We're in luck, the head has enough space. Just return
|
|
|
|
* the head, no need for copying.
|
|
|
|
*/
|
|
|
|
*bufp = head->iov_base;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = svcxdr_tmpalloc(argp, buflen);
|
|
|
|
if (tmp == NULL)
|
|
|
|
return nfserr_jukebox;
|
|
|
|
|
|
|
|
dp = tmp;
|
|
|
|
memcpy(dp, head->iov_base, head->iov_len);
|
|
|
|
buflen -= head->iov_len;
|
|
|
|
dp += head->iov_len;
|
|
|
|
|
|
|
|
while (buflen > 0) {
|
|
|
|
len = min_t(u32, buflen, PAGE_SIZE);
|
|
|
|
memcpy(dp, page_address(*pages), len);
|
|
|
|
|
|
|
|
buflen -= len;
|
|
|
|
dp += len;
|
|
|
|
pages++;
|
|
|
|
}
|
|
|
|
|
|
|
|
*bufp = tmp;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get a user extended attribute name from the XDR buffer.
|
|
|
|
* It will not have the "user." prefix, so prepend it.
|
|
|
|
* Lastly, check for nul characters in the name.
|
|
|
|
*/
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_xattr_name(struct nfsd4_compoundargs *argp, char **namep)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
char *name, *sp, *dp;
|
|
|
|
u32 namelen, cnt;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
namelen = be32_to_cpup(p++);
|
|
|
|
|
|
|
|
if (namelen > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN))
|
|
|
|
return nfserr_nametoolong;
|
|
|
|
|
|
|
|
if (namelen == 0)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
READ_BUF(namelen);
|
|
|
|
|
|
|
|
name = svcxdr_tmpalloc(argp, namelen + XATTR_USER_PREFIX_LEN + 1);
|
|
|
|
if (!name)
|
|
|
|
return nfserr_jukebox;
|
|
|
|
|
|
|
|
memcpy(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy the extended attribute name over while checking for 0
|
|
|
|
* characters.
|
|
|
|
*/
|
|
|
|
sp = (char *)p;
|
|
|
|
dp = name + XATTR_USER_PREFIX_LEN;
|
|
|
|
cnt = namelen;
|
|
|
|
|
|
|
|
while (cnt-- > 0) {
|
|
|
|
if (*sp == '\0')
|
|
|
|
goto xdr_error;
|
|
|
|
*dp++ = *sp++;
|
|
|
|
}
|
|
|
|
*dp = '\0';
|
|
|
|
|
|
|
|
*namep = name;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A GETXATTR op request comes without a length specifier. We just set the
|
|
|
|
* maximum length for the reply based on XATTR_SIZE_MAX and the maximum
|
|
|
|
* channel reply size. nfsd_getxattr will probe the length of the xattr,
|
|
|
|
* check it against getxa_len, and allocate + return the value.
|
|
|
|
*/
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_getxattr(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_getxattr *getxattr)
|
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
u32 maxcount;
|
|
|
|
|
|
|
|
status = nfsd4_decode_xattr_name(argp, &getxattr->getxa_name);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
maxcount = svc_max_payload(argp->rqstp);
|
|
|
|
maxcount = min_t(u32, XATTR_SIZE_MAX, maxcount);
|
|
|
|
|
|
|
|
getxattr->getxa_len = maxcount;
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_setxattr(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_setxattr *setxattr)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
u32 flags, maxcount, size;
|
|
|
|
struct kvec head;
|
|
|
|
struct page **pagelist;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
flags = be32_to_cpup(p++);
|
|
|
|
|
|
|
|
if (flags > SETXATTR4_REPLACE)
|
|
|
|
return nfserr_inval;
|
|
|
|
setxattr->setxa_flags = flags;
|
|
|
|
|
|
|
|
status = nfsd4_decode_xattr_name(argp, &setxattr->setxa_name);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
maxcount = svc_max_payload(argp->rqstp);
|
|
|
|
maxcount = min_t(u32, XATTR_SIZE_MAX, maxcount);
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
size = be32_to_cpup(p++);
|
|
|
|
if (size > maxcount)
|
|
|
|
return nfserr_xattr2big;
|
|
|
|
|
|
|
|
setxattr->setxa_len = size;
|
|
|
|
if (size > 0) {
|
|
|
|
status = svcxdr_construct_vector(argp, &head, &pagelist, size);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
status = nfsd4_vbuf_from_vector(argp, &head, pagelist,
|
|
|
|
&setxattr->setxa_buf, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_listxattrs(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_listxattrs *listxattrs)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
u32 maxcount;
|
|
|
|
|
|
|
|
READ_BUF(12);
|
|
|
|
p = xdr_decode_hyper(p, &listxattrs->lsxa_cookie);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the cookie is too large to have even one user.x attribute
|
|
|
|
* plus trailing '\0' left in a maximum size buffer, it's invalid.
|
|
|
|
*/
|
|
|
|
if (listxattrs->lsxa_cookie >=
|
|
|
|
(XATTR_LIST_MAX / (XATTR_USER_PREFIX_LEN + 2)))
|
|
|
|
return nfserr_badcookie;
|
|
|
|
|
|
|
|
maxcount = be32_to_cpup(p++);
|
|
|
|
if (maxcount < 8)
|
|
|
|
/* Always need at least 2 words (length and one character) */
|
|
|
|
return nfserr_inval;
|
|
|
|
|
|
|
|
maxcount = min(maxcount, svc_max_payload(argp->rqstp));
|
|
|
|
listxattrs->lsxa_maxcount = maxcount;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_removexattr(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_removexattr *removexattr)
|
|
|
|
{
|
|
|
|
return nfsd4_decode_xattr_name(argp, &removexattr->rmxa_name);
|
|
|
|
}
|
|
|
|
|
2008-07-02 16:13:41 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p)
|
|
|
|
{
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2008-07-02 16:14:01 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p)
|
|
|
|
{
|
2009-03-05 05:06:06 +08:00
|
|
|
return nfserr_notsupp;
|
2008-07-02 16:14:01 +08:00
|
|
|
}
|
|
|
|
|
2008-07-02 16:13:41 +08:00
|
|
|
typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *);
|
|
|
|
|
2017-08-01 23:59:58 +08:00
|
|
|
static const nfsd4_dec nfsd4_dec_ops[] = {
|
2008-07-19 03:04:16 +08:00
|
|
|
[OP_ACCESS] = (nfsd4_dec)nfsd4_decode_access,
|
|
|
|
[OP_CLOSE] = (nfsd4_dec)nfsd4_decode_close,
|
|
|
|
[OP_COMMIT] = (nfsd4_dec)nfsd4_decode_commit,
|
|
|
|
[OP_CREATE] = (nfsd4_dec)nfsd4_decode_create,
|
|
|
|
[OP_DELEGPURGE] = (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[OP_DELEGRETURN] = (nfsd4_dec)nfsd4_decode_delegreturn,
|
|
|
|
[OP_GETATTR] = (nfsd4_dec)nfsd4_decode_getattr,
|
|
|
|
[OP_GETFH] = (nfsd4_dec)nfsd4_decode_noop,
|
|
|
|
[OP_LINK] = (nfsd4_dec)nfsd4_decode_link,
|
|
|
|
[OP_LOCK] = (nfsd4_dec)nfsd4_decode_lock,
|
|
|
|
[OP_LOCKT] = (nfsd4_dec)nfsd4_decode_lockt,
|
|
|
|
[OP_LOCKU] = (nfsd4_dec)nfsd4_decode_locku,
|
|
|
|
[OP_LOOKUP] = (nfsd4_dec)nfsd4_decode_lookup,
|
|
|
|
[OP_LOOKUPP] = (nfsd4_dec)nfsd4_decode_noop,
|
|
|
|
[OP_NVERIFY] = (nfsd4_dec)nfsd4_decode_verify,
|
|
|
|
[OP_OPEN] = (nfsd4_dec)nfsd4_decode_open,
|
|
|
|
[OP_OPENATTR] = (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[OP_OPEN_CONFIRM] = (nfsd4_dec)nfsd4_decode_open_confirm,
|
|
|
|
[OP_OPEN_DOWNGRADE] = (nfsd4_dec)nfsd4_decode_open_downgrade,
|
|
|
|
[OP_PUTFH] = (nfsd4_dec)nfsd4_decode_putfh,
|
2013-10-30 22:00:20 +08:00
|
|
|
[OP_PUTPUBFH] = (nfsd4_dec)nfsd4_decode_putpubfh,
|
2008-07-19 03:04:16 +08:00
|
|
|
[OP_PUTROOTFH] = (nfsd4_dec)nfsd4_decode_noop,
|
|
|
|
[OP_READ] = (nfsd4_dec)nfsd4_decode_read,
|
|
|
|
[OP_READDIR] = (nfsd4_dec)nfsd4_decode_readdir,
|
|
|
|
[OP_READLINK] = (nfsd4_dec)nfsd4_decode_noop,
|
|
|
|
[OP_REMOVE] = (nfsd4_dec)nfsd4_decode_remove,
|
|
|
|
[OP_RENAME] = (nfsd4_dec)nfsd4_decode_rename,
|
|
|
|
[OP_RENEW] = (nfsd4_dec)nfsd4_decode_renew,
|
|
|
|
[OP_RESTOREFH] = (nfsd4_dec)nfsd4_decode_noop,
|
|
|
|
[OP_SAVEFH] = (nfsd4_dec)nfsd4_decode_noop,
|
|
|
|
[OP_SECINFO] = (nfsd4_dec)nfsd4_decode_secinfo,
|
|
|
|
[OP_SETATTR] = (nfsd4_dec)nfsd4_decode_setattr,
|
|
|
|
[OP_SETCLIENTID] = (nfsd4_dec)nfsd4_decode_setclientid,
|
|
|
|
[OP_SETCLIENTID_CONFIRM] = (nfsd4_dec)nfsd4_decode_setclientid_confirm,
|
|
|
|
[OP_VERIFY] = (nfsd4_dec)nfsd4_decode_verify,
|
|
|
|
[OP_WRITE] = (nfsd4_dec)nfsd4_decode_write,
|
|
|
|
[OP_RELEASE_LOCKOWNER] = (nfsd4_dec)nfsd4_decode_release_lockowner,
|
2009-04-03 13:27:55 +08:00
|
|
|
|
|
|
|
/* new operations for NFSv4.1 */
|
2012-11-02 06:09:48 +08:00
|
|
|
[OP_BACKCHANNEL_CTL] = (nfsd4_dec)nfsd4_decode_backchannel_ctl,
|
2010-10-05 11:12:59 +08:00
|
|
|
[OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session,
|
2009-04-29 07:48:25 +08:00
|
|
|
[OP_EXCHANGE_ID] = (nfsd4_dec)nfsd4_decode_exchange_id,
|
|
|
|
[OP_CREATE_SESSION] = (nfsd4_dec)nfsd4_decode_create_session,
|
|
|
|
[OP_DESTROY_SESSION] = (nfsd4_dec)nfsd4_decode_destroy_session,
|
2011-07-13 23:04:21 +08:00
|
|
|
[OP_FREE_STATEID] = (nfsd4_dec)nfsd4_decode_free_stateid,
|
2009-04-29 07:48:25 +08:00
|
|
|
[OP_GET_DIR_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp,
|
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 19:11:59 +08:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
|
|
|
[OP_GETDEVICEINFO] = (nfsd4_dec)nfsd4_decode_getdeviceinfo,
|
|
|
|
[OP_GETDEVICELIST] = (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[OP_LAYOUTCOMMIT] = (nfsd4_dec)nfsd4_decode_layoutcommit,
|
|
|
|
[OP_LAYOUTGET] = (nfsd4_dec)nfsd4_decode_layoutget,
|
|
|
|
[OP_LAYOUTRETURN] = (nfsd4_dec)nfsd4_decode_layoutreturn,
|
|
|
|
#else
|
2009-04-29 07:48:25 +08:00
|
|
|
[OP_GETDEVICEINFO] = (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[OP_GETDEVICELIST] = (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[OP_LAYOUTCOMMIT] = (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[OP_LAYOUTGET] = (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[OP_LAYOUTRETURN] = (nfsd4_dec)nfsd4_decode_notsupp,
|
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 19:11:59 +08:00
|
|
|
#endif
|
2010-12-16 22:51:13 +08:00
|
|
|
[OP_SECINFO_NO_NAME] = (nfsd4_dec)nfsd4_decode_secinfo_no_name,
|
2009-04-29 07:48:25 +08:00
|
|
|
[OP_SEQUENCE] = (nfsd4_dec)nfsd4_decode_sequence,
|
|
|
|
[OP_SET_SSV] = (nfsd4_dec)nfsd4_decode_notsupp,
|
2011-07-13 22:50:48 +08:00
|
|
|
[OP_TEST_STATEID] = (nfsd4_dec)nfsd4_decode_test_stateid,
|
2009-04-29 07:48:25 +08:00
|
|
|
[OP_WANT_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp,
|
2011-10-20 17:51:39 +08:00
|
|
|
[OP_DESTROY_CLIENTID] = (nfsd4_dec)nfsd4_decode_destroy_clientid,
|
2010-04-20 03:11:28 +08:00
|
|
|
[OP_RECLAIM_COMPLETE] = (nfsd4_dec)nfsd4_decode_reclaim_complete,
|
2014-09-27 01:58:26 +08:00
|
|
|
|
|
|
|
/* new operations for NFSv4.2 */
|
2014-11-08 03:44:26 +08:00
|
|
|
[OP_ALLOCATE] = (nfsd4_dec)nfsd4_decode_fallocate,
|
2016-09-08 03:57:30 +08:00
|
|
|
[OP_COPY] = (nfsd4_dec)nfsd4_decode_copy,
|
2019-08-08 23:14:59 +08:00
|
|
|
[OP_COPY_NOTIFY] = (nfsd4_dec)nfsd4_decode_copy_notify,
|
2014-11-08 03:44:27 +08:00
|
|
|
[OP_DEALLOCATE] = (nfsd4_dec)nfsd4_decode_fallocate,
|
2014-09-27 01:58:26 +08:00
|
|
|
[OP_IO_ADVISE] = (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[OP_LAYOUTERROR] = (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[OP_LAYOUTSTATS] = (nfsd4_dec)nfsd4_decode_notsupp,
|
2018-07-21 06:19:19 +08:00
|
|
|
[OP_OFFLOAD_CANCEL] = (nfsd4_dec)nfsd4_decode_offload_status,
|
2018-07-21 06:19:18 +08:00
|
|
|
[OP_OFFLOAD_STATUS] = (nfsd4_dec)nfsd4_decode_offload_status,
|
2014-09-27 01:58:26 +08:00
|
|
|
[OP_READ_PLUS] = (nfsd4_dec)nfsd4_decode_notsupp,
|
2014-09-27 01:58:27 +08:00
|
|
|
[OP_SEEK] = (nfsd4_dec)nfsd4_decode_seek,
|
2014-09-27 01:58:26 +08:00
|
|
|
[OP_WRITE_SAME] = (nfsd4_dec)nfsd4_decode_notsupp,
|
2015-12-03 19:59:52 +08:00
|
|
|
[OP_CLONE] = (nfsd4_dec)nfsd4_decode_clone,
|
2020-06-24 06:39:26 +08:00
|
|
|
/* RFC 8276 extended atributes operations */
|
|
|
|
[OP_GETXATTR] = (nfsd4_dec)nfsd4_decode_getxattr,
|
|
|
|
[OP_SETXATTR] = (nfsd4_dec)nfsd4_decode_setxattr,
|
|
|
|
[OP_LISTXATTRS] = (nfsd4_dec)nfsd4_decode_listxattrs,
|
|
|
|
[OP_REMOVEXATTR] = (nfsd4_dec)nfsd4_decode_removexattr,
|
2009-04-03 13:27:55 +08:00
|
|
|
};
|
|
|
|
|
2013-10-30 22:00:20 +08:00
|
|
|
static inline bool
|
|
|
|
nfsd4_opnum_in_range(struct nfsd4_compoundargs *argp, struct nfsd4_op *op)
|
|
|
|
{
|
2013-10-31 01:38:13 +08:00
|
|
|
if (op->opnum < FIRST_NFS4_OP)
|
2013-10-30 22:00:20 +08:00
|
|
|
return false;
|
2013-10-31 01:38:13 +08:00
|
|
|
else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP)
|
2013-10-30 22:00:20 +08:00
|
|
|
return false;
|
2013-10-31 01:38:13 +08:00
|
|
|
else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP)
|
|
|
|
return false;
|
|
|
|
else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP)
|
2013-10-30 22:00:20 +08:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
2008-07-02 16:14:22 +08:00
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2005-04-17 06:20:36 +08:00
|
|
|
nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
struct nfsd4_op *op;
|
2011-01-25 01:11:02 +08:00
|
|
|
bool cachethis = false;
|
2014-05-13 06:10:58 +08:00
|
|
|
int auth_slack= argp->rqstp->rq_auth_slack;
|
|
|
|
int max_reply = auth_slack + 8; /* opcnt, status */
|
2014-02-04 23:36:59 +08:00
|
|
|
int readcount = 0;
|
|
|
|
int readbytes = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
int i;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
argp->taglen = be32_to_cpup(p++);
|
2016-03-01 09:21:21 +08:00
|
|
|
READ_BUF(argp->taglen);
|
2005-04-17 06:20:36 +08:00
|
|
|
SAVEMEM(argp->tag, argp->taglen);
|
2016-03-01 09:21:21 +08:00
|
|
|
READ_BUF(8);
|
2014-06-03 00:32:51 +08:00
|
|
|
argp->minorversion = be32_to_cpup(p++);
|
|
|
|
argp->opcnt = be32_to_cpup(p++);
|
2014-03-12 03:39:13 +08:00
|
|
|
max_reply += 4 + (XDR_QUADLEN(argp->taglen) << 2);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (argp->taglen > NFSD4_MAX_TAGLEN)
|
|
|
|
goto xdr_error;
|
2017-11-16 01:30:27 +08:00
|
|
|
/*
|
|
|
|
* NFS4ERR_RESOURCE is a more helpful error than GARBAGE_ARGS
|
|
|
|
* here, so we return success at the xdr level so that
|
|
|
|
* nfsd4_proc can handle this is an NFS-level error.
|
|
|
|
*/
|
|
|
|
if (argp->opcnt > NFSD_MAX_OPS_PER_COMPOUND)
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-03-24 19:15:34 +08:00
|
|
|
if (argp->opcnt > ARRAY_SIZE(argp->iops)) {
|
2014-07-18 04:20:39 +08:00
|
|
|
argp->ops = kzalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!argp->ops) {
|
|
|
|
argp->ops = argp->iops;
|
2007-09-12 06:01:20 +08:00
|
|
|
dprintk("nfsd: couldn't allocate room for COMPOUND\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-30 22:00:20 +08:00
|
|
|
if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION)
|
2008-07-02 16:13:18 +08:00
|
|
|
argp->opcnt = 0;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
for (i = 0; i < argp->opcnt; i++) {
|
|
|
|
op = &argp->ops[i];
|
|
|
|
op->replay = NULL;
|
|
|
|
|
2012-11-17 11:28:38 +08:00
|
|
|
READ_BUF(4);
|
2014-06-03 00:32:51 +08:00
|
|
|
op->opnum = be32_to_cpup(p++);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-10-30 22:00:20 +08:00
|
|
|
if (nfsd4_opnum_in_range(argp, op))
|
|
|
|
op->status = nfsd4_dec_ops[op->opnum](argp, &op->u);
|
2008-07-02 16:13:41 +08:00
|
|
|
else {
|
2005-04-17 06:20:36 +08:00
|
|
|
op->opnum = OP_ILLEGAL;
|
|
|
|
op->status = nfserr_op_illegal;
|
|
|
|
}
|
2017-07-07 05:51:29 +08:00
|
|
|
op->opdesc = OPDESC(op);
|
2011-01-25 01:11:02 +08:00
|
|
|
/*
|
|
|
|
* We'll try to cache the result in the DRC if any one
|
|
|
|
* op in the compound wants to be cached:
|
|
|
|
*/
|
|
|
|
cachethis |= nfsd4_cache_this_op(op);
|
2013-11-06 04:07:16 +08:00
|
|
|
|
2014-02-04 23:36:59 +08:00
|
|
|
if (op->opnum == OP_READ) {
|
|
|
|
readcount++;
|
|
|
|
readbytes += nfsd4_max_reply(argp->rqstp, op);
|
|
|
|
} else
|
|
|
|
max_reply += nfsd4_max_reply(argp->rqstp, op);
|
2014-08-12 23:41:40 +08:00
|
|
|
/*
|
2017-02-03 22:51:46 +08:00
|
|
|
* OP_LOCK and OP_LOCKT may return a conflicting lock.
|
|
|
|
* (Special case because it will just skip encoding this
|
|
|
|
* if it runs out of xdr buffer space, and it is the only
|
|
|
|
* operation that behaves this way.)
|
2014-08-12 23:41:40 +08:00
|
|
|
*/
|
2017-02-03 22:51:46 +08:00
|
|
|
if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT)
|
2014-08-12 23:41:40 +08:00
|
|
|
max_reply += NFS4_OPAQUE_LIMIT;
|
2014-05-20 00:27:11 +08:00
|
|
|
|
|
|
|
if (op->status) {
|
|
|
|
argp->opcnt = i+1;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2011-01-25 01:11:02 +08:00
|
|
|
/* Sessions make the DRC unnecessary: */
|
|
|
|
if (argp->minorversion)
|
|
|
|
cachethis = false;
|
2014-02-04 23:36:59 +08:00
|
|
|
svc_reserve(argp->rqstp, max_reply + readbytes);
|
2011-01-25 01:11:02 +08:00
|
|
|
argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-05-13 06:10:58 +08:00
|
|
|
if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack)
|
2014-11-19 20:51:18 +08:00
|
|
|
clear_bit(RQ_SPLICE_OK, &argp->rqstp->rq_flags);
|
2014-02-04 23:36:59 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2017-01-30 14:17:00 +08:00
|
|
|
static __be32 *encode_change(__be32 *p, struct kstat *stat, struct inode *inode,
|
|
|
|
struct svc_export *exp)
|
2009-04-17 05:33:25 +08:00
|
|
|
{
|
2017-01-30 14:17:00 +08:00
|
|
|
if (exp->ex_flags & NFSEXP_V4ROOT) {
|
|
|
|
*p++ = cpu_to_be32(convert_to_wallclock(exp->cd->flush_time));
|
|
|
|
*p++ = 0;
|
|
|
|
} else if (IS_I_VERSION(inode)) {
|
2018-01-03 23:14:35 +08:00
|
|
|
p = xdr_encode_hyper(p, nfsd4_change_attribute(stat, inode));
|
2009-04-17 05:33:25 +08:00
|
|
|
} else {
|
2014-03-23 06:48:39 +08:00
|
|
|
*p++ = cpu_to_be32(stat->ctime.tv_sec);
|
|
|
|
*p++ = cpu_to_be32(stat->ctime.tv_nsec);
|
2009-04-17 05:33:25 +08:00
|
|
|
}
|
2014-03-23 06:48:39 +08:00
|
|
|
return p;
|
2009-04-17 05:33:25 +08:00
|
|
|
}
|
|
|
|
|
2018-04-26 02:34:11 +08:00
|
|
|
/*
|
|
|
|
* ctime (in NFSv4, time_metadata) is not writeable, and the client
|
|
|
|
* doesn't really care what resolution could theoretically be stored by
|
|
|
|
* the filesystem.
|
|
|
|
*
|
|
|
|
* The client cares how close together changes can be while still
|
|
|
|
* guaranteeing ctime changes. For most filesystems (which have
|
|
|
|
* timestamps with nanosecond fields) that is limited by the resolution
|
|
|
|
* of the time returned from current_time() (which I'm assuming to be
|
|
|
|
* 1/HZ).
|
|
|
|
*/
|
|
|
|
static __be32 *encode_time_delta(__be32 *p, struct inode *inode)
|
|
|
|
{
|
2019-10-31 22:14:03 +08:00
|
|
|
struct timespec64 ts;
|
2018-04-26 02:34:11 +08:00
|
|
|
u32 ns;
|
|
|
|
|
|
|
|
ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran);
|
2019-10-31 22:14:03 +08:00
|
|
|
ts = ns_to_timespec64(ns);
|
2018-04-26 02:34:11 +08:00
|
|
|
|
|
|
|
p = xdr_encode_hyper(p, ts.tv_sec);
|
|
|
|
*p++ = cpu_to_be32(ts.tv_nsec);
|
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2014-03-23 06:48:39 +08:00
|
|
|
static __be32 *encode_cinfo(__be32 *p, struct nfsd4_change_info *c)
|
2009-04-17 05:33:25 +08:00
|
|
|
{
|
2014-03-23 06:48:39 +08:00
|
|
|
*p++ = cpu_to_be32(c->atomic);
|
2009-04-17 05:33:25 +08:00
|
|
|
if (c->change_supported) {
|
2014-03-23 06:48:39 +08:00
|
|
|
p = xdr_encode_hyper(p, c->before_change);
|
|
|
|
p = xdr_encode_hyper(p, c->after_change);
|
2009-04-17 05:33:25 +08:00
|
|
|
} else {
|
2014-03-23 06:48:39 +08:00
|
|
|
*p++ = cpu_to_be32(c->before_ctime_sec);
|
|
|
|
*p++ = cpu_to_be32(c->before_ctime_nsec);
|
|
|
|
*p++ = cpu_to_be32(c->after_ctime_sec);
|
|
|
|
*p++ = cpu_to_be32(c->after_ctime_nsec);
|
2009-04-17 05:33:25 +08:00
|
|
|
}
|
2014-03-23 06:48:39 +08:00
|
|
|
return p;
|
2009-04-17 05:33:25 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-10-04 17:16:19 +08:00
|
|
|
/* Encode as an array of strings the string given with components
|
2012-04-24 23:07:59 +08:00
|
|
|
* separated @sep, escaped with esc_enter and esc_exit.
|
2006-10-04 17:16:19 +08:00
|
|
|
*/
|
2013-08-28 09:32:25 +08:00
|
|
|
static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep,
|
|
|
|
char *components, char esc_enter,
|
|
|
|
char esc_exit)
|
2006-10-04 17:16:19 +08:00
|
|
|
{
|
2013-08-28 09:32:25 +08:00
|
|
|
__be32 *p;
|
2013-08-30 03:42:52 +08:00
|
|
|
__be32 pathlen;
|
|
|
|
int pathlen_offset;
|
2006-10-04 17:16:19 +08:00
|
|
|
int strlen, count=0;
|
2012-04-24 23:07:59 +08:00
|
|
|
char *str, *end, *next;
|
2006-10-04 17:16:19 +08:00
|
|
|
|
|
|
|
dprintk("nfsd4_encode_components(%s)\n", components);
|
2013-08-30 03:42:52 +08:00
|
|
|
|
|
|
|
pathlen_offset = xdr->buf->len;
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2006-10-04 17:16:19 +08:00
|
|
|
return nfserr_resource;
|
2013-08-30 03:42:52 +08:00
|
|
|
p++; /* We will fill this in with @count later */
|
|
|
|
|
2006-10-04 17:16:19 +08:00
|
|
|
end = str = components;
|
|
|
|
while (*end) {
|
2012-04-24 23:07:59 +08:00
|
|
|
bool found_esc = false;
|
|
|
|
|
|
|
|
/* try to parse as esc_start, ..., esc_end, sep */
|
|
|
|
if (*str == esc_enter) {
|
|
|
|
for (; *end && (*end != esc_exit); end++)
|
|
|
|
/* find esc_exit or end of string */;
|
|
|
|
next = end + 1;
|
|
|
|
if (*end && (!*next || *next == sep)) {
|
|
|
|
str++;
|
|
|
|
found_esc = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!found_esc)
|
|
|
|
for (; *end && (*end != sep); end++)
|
|
|
|
/* find sep or end of string */;
|
|
|
|
|
2006-10-04 17:16:19 +08:00
|
|
|
strlen = end - str;
|
|
|
|
if (strlen) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, strlen + 4);
|
|
|
|
if (!p)
|
2006-10-04 17:16:19 +08:00
|
|
|
return nfserr_resource;
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque(p, str, strlen);
|
2006-10-04 17:16:19 +08:00
|
|
|
count++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
end++;
|
2014-12-08 05:05:47 +08:00
|
|
|
if (found_esc)
|
|
|
|
end = next;
|
|
|
|
|
2006-10-04 17:16:19 +08:00
|
|
|
str = end;
|
|
|
|
}
|
2014-12-08 05:05:48 +08:00
|
|
|
pathlen = htonl(count);
|
2013-08-30 03:42:52 +08:00
|
|
|
write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4);
|
2006-10-04 17:16:19 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-24 23:07:59 +08:00
|
|
|
/* Encode as an array of strings the string given with components
|
|
|
|
* separated @sep.
|
|
|
|
*/
|
2013-08-28 09:32:25 +08:00
|
|
|
static __be32 nfsd4_encode_components(struct xdr_stream *xdr, char sep,
|
|
|
|
char *components)
|
2012-04-24 23:07:59 +08:00
|
|
|
{
|
2013-08-28 09:32:25 +08:00
|
|
|
return nfsd4_encode_components_esc(xdr, sep, components, 0, 0);
|
2012-04-24 23:07:59 +08:00
|
|
|
}
|
|
|
|
|
2006-10-04 17:16:19 +08:00
|
|
|
/*
|
|
|
|
* encode a location element of a fs_locations structure
|
|
|
|
*/
|
2013-08-28 09:32:25 +08:00
|
|
|
static __be32 nfsd4_encode_fs_location4(struct xdr_stream *xdr,
|
|
|
|
struct nfsd4_fs_location *location)
|
2006-10-04 17:16:19 +08:00
|
|
|
{
|
2006-10-20 14:28:59 +08:00
|
|
|
__be32 status;
|
2006-10-04 17:16:19 +08:00
|
|
|
|
2013-08-28 09:32:25 +08:00
|
|
|
status = nfsd4_encode_components_esc(xdr, ':', location->hosts,
|
2012-04-24 23:07:59 +08:00
|
|
|
'[', ']');
|
2006-10-04 17:16:19 +08:00
|
|
|
if (status)
|
|
|
|
return status;
|
2013-08-28 09:32:25 +08:00
|
|
|
status = nfsd4_encode_components(xdr, '/', location->path);
|
2006-10-04 17:16:19 +08:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-09-13 07:37:06 +08:00
|
|
|
* Encode a path in RFC3530 'pathname4' format
|
2006-10-04 17:16:19 +08:00
|
|
|
*/
|
2013-08-28 09:32:25 +08:00
|
|
|
static __be32 nfsd4_encode_path(struct xdr_stream *xdr,
|
|
|
|
const struct path *root,
|
|
|
|
const struct path *path)
|
2006-10-04 17:16:19 +08:00
|
|
|
{
|
2013-09-02 04:06:39 +08:00
|
|
|
struct path cur = *path;
|
2013-08-28 09:32:25 +08:00
|
|
|
__be32 *p;
|
2011-09-13 07:37:06 +08:00
|
|
|
struct dentry **components = NULL;
|
|
|
|
unsigned int ncomponents = 0;
|
|
|
|
__be32 err = nfserr_jukebox;
|
2006-10-04 17:16:19 +08:00
|
|
|
|
2011-09-13 07:37:06 +08:00
|
|
|
dprintk("nfsd4_encode_components(");
|
2006-10-04 17:16:19 +08:00
|
|
|
|
2011-09-13 07:37:06 +08:00
|
|
|
path_get(&cur);
|
|
|
|
/* First walk the path up to the nfsd root, and store the
|
|
|
|
* dentries/path components in an array.
|
|
|
|
*/
|
|
|
|
for (;;) {
|
2015-03-15 23:13:32 +08:00
|
|
|
if (path_equal(&cur, root))
|
2011-09-13 07:37:06 +08:00
|
|
|
break;
|
|
|
|
if (cur.dentry == cur.mnt->mnt_root) {
|
|
|
|
if (follow_up(&cur))
|
|
|
|
continue;
|
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
if ((ncomponents & 15) == 0) {
|
|
|
|
struct dentry **new;
|
|
|
|
new = krealloc(components,
|
|
|
|
sizeof(*new) * (ncomponents + 16),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!new)
|
|
|
|
goto out_free;
|
|
|
|
components = new;
|
|
|
|
}
|
|
|
|
components[ncomponents++] = cur.dentry;
|
|
|
|
cur.dentry = dget_parent(cur.dentry);
|
|
|
|
}
|
2013-08-28 09:32:25 +08:00
|
|
|
err = nfserr_resource;
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2011-09-13 07:37:06 +08:00
|
|
|
goto out_free;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(ncomponents);
|
2011-09-13 07:37:06 +08:00
|
|
|
|
|
|
|
while (ncomponents) {
|
|
|
|
struct dentry *dentry = components[ncomponents - 1];
|
2013-09-02 04:06:39 +08:00
|
|
|
unsigned int len;
|
2011-09-13 07:37:06 +08:00
|
|
|
|
2013-09-02 04:06:39 +08:00
|
|
|
spin_lock(&dentry->d_lock);
|
|
|
|
len = dentry->d_name.len;
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, len + 4);
|
|
|
|
if (!p) {
|
2013-09-02 04:06:39 +08:00
|
|
|
spin_unlock(&dentry->d_lock);
|
2011-09-13 07:37:06 +08:00
|
|
|
goto out_free;
|
2013-09-02 04:06:39 +08:00
|
|
|
}
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque(p, dentry->d_name.name, len);
|
2014-10-22 08:11:25 +08:00
|
|
|
dprintk("/%pd", dentry);
|
2013-09-02 04:06:39 +08:00
|
|
|
spin_unlock(&dentry->d_lock);
|
2011-09-13 07:37:06 +08:00
|
|
|
dput(dentry);
|
|
|
|
ncomponents--;
|
2006-10-04 17:16:19 +08:00
|
|
|
}
|
2011-09-13 07:37:06 +08:00
|
|
|
|
|
|
|
err = 0;
|
|
|
|
out_free:
|
|
|
|
dprintk(")\n");
|
|
|
|
while (ncomponents)
|
|
|
|
dput(components[--ncomponents]);
|
|
|
|
kfree(components);
|
|
|
|
path_put(&cur);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-08-28 09:32:25 +08:00
|
|
|
static __be32 nfsd4_encode_fsloc_fsroot(struct xdr_stream *xdr,
|
|
|
|
struct svc_rqst *rqstp, const struct path *path)
|
2011-09-13 07:37:06 +08:00
|
|
|
{
|
|
|
|
struct svc_export *exp_ps;
|
|
|
|
__be32 res;
|
|
|
|
|
|
|
|
exp_ps = rqst_find_fsidzero_export(rqstp);
|
|
|
|
if (IS_ERR(exp_ps))
|
|
|
|
return nfserrno(PTR_ERR(exp_ps));
|
2013-08-28 09:32:25 +08:00
|
|
|
res = nfsd4_encode_path(xdr, &exp_ps->ex_path, path);
|
2011-09-13 07:37:06 +08:00
|
|
|
exp_put(exp_ps);
|
|
|
|
return res;
|
2006-10-04 17:16:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* encode a fs_locations structure
|
|
|
|
*/
|
2013-08-28 09:32:25 +08:00
|
|
|
static __be32 nfsd4_encode_fs_locations(struct xdr_stream *xdr,
|
|
|
|
struct svc_rqst *rqstp, struct svc_export *exp)
|
2006-10-04 17:16:19 +08:00
|
|
|
{
|
2006-10-20 14:28:59 +08:00
|
|
|
__be32 status;
|
2006-10-20 14:28:44 +08:00
|
|
|
int i;
|
2013-08-28 09:32:25 +08:00
|
|
|
__be32 *p;
|
2006-10-04 17:16:19 +08:00
|
|
|
struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;
|
|
|
|
|
2013-08-28 09:32:25 +08:00
|
|
|
status = nfsd4_encode_fsloc_fsroot(xdr, rqstp, &exp->ex_path);
|
2006-10-04 17:16:19 +08:00
|
|
|
if (status)
|
|
|
|
return status;
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2006-10-04 17:16:19 +08:00
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(fslocs->locations_count);
|
2006-10-04 17:16:19 +08:00
|
|
|
for (i=0; i<fslocs->locations_count; i++) {
|
2013-08-28 09:32:25 +08:00
|
|
|
status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]);
|
2006-10-04 17:16:19 +08:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-08-15 23:49:30 +08:00
|
|
|
static u32 nfs4_file_type(umode_t mode)
|
|
|
|
{
|
|
|
|
switch (mode & S_IFMT) {
|
|
|
|
case S_IFIFO: return NF4FIFO;
|
|
|
|
case S_IFCHR: return NF4CHR;
|
|
|
|
case S_IFDIR: return NF4DIR;
|
|
|
|
case S_IFBLK: return NF4BLK;
|
|
|
|
case S_IFLNK: return NF4LNK;
|
|
|
|
case S_IFREG: return NF4REG;
|
|
|
|
case S_IFSOCK: return NF4SOCK;
|
|
|
|
default: return NF4BAD;
|
|
|
|
};
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static inline __be32
|
2013-08-28 09:32:25 +08:00
|
|
|
nfsd4_encode_aclname(struct xdr_stream *xdr, struct svc_rqst *rqstp,
|
|
|
|
struct nfs4_ace *ace)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-08 22:49:01 +08:00
|
|
|
if (ace->whotype != NFS4_ACL_WHO_NAMED)
|
2013-08-28 09:32:25 +08:00
|
|
|
return nfs4_acl_write_who(xdr, ace->whotype);
|
2014-01-08 22:49:01 +08:00
|
|
|
else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
|
2013-08-28 09:32:25 +08:00
|
|
|
return nfsd4_encode_group(xdr, rqstp, ace->who_gid);
|
2014-01-08 22:49:01 +08:00
|
|
|
else
|
2013-08-28 09:32:25 +08:00
|
|
|
return nfsd4_encode_user(xdr, rqstp, ace->who_uid);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2015-07-30 21:52:44 +08:00
|
|
|
static inline __be32
|
2016-07-11 03:55:58 +08:00
|
|
|
nfsd4_encode_layout_types(struct xdr_stream *xdr, u32 layout_types)
|
2015-07-30 21:52:44 +08:00
|
|
|
{
|
2016-07-11 03:55:58 +08:00
|
|
|
__be32 *p;
|
|
|
|
unsigned long i = hweight_long(layout_types);
|
2015-07-30 21:52:44 +08:00
|
|
|
|
2016-07-11 03:55:58 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4 + 4 * i);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
*p++ = cpu_to_be32(i);
|
|
|
|
|
|
|
|
for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i)
|
|
|
|
if (layout_types & (1 << i))
|
|
|
|
*p++ = cpu_to_be32(i);
|
2015-07-30 21:52:44 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-04 17:16:20 +08:00
|
|
|
#define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
|
|
|
|
FATTR4_WORD0_RDATTR_ERROR)
|
|
|
|
#define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
|
2015-07-07 10:16:37 +08:00
|
|
|
#define WORD2_ABSENT_FS_ATTRS 0
|
2006-10-04 17:16:20 +08:00
|
|
|
|
2013-05-03 01:19:10 +08:00
|
|
|
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
|
|
|
|
static inline __be32
|
2013-08-28 09:32:25 +08:00
|
|
|
nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
|
|
|
|
void *context, int len)
|
2013-05-03 01:19:10 +08:00
|
|
|
{
|
2013-08-28 09:32:25 +08:00
|
|
|
__be32 *p;
|
2013-05-03 01:19:10 +08:00
|
|
|
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, len + 4 + 4 + 4);
|
|
|
|
if (!p)
|
2013-05-03 01:19:10 +08:00
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For now we use a 0 here to indicate the null translation; in
|
|
|
|
* the future we may place a call to translation code here.
|
|
|
|
*/
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0); /* lfs */
|
|
|
|
*p++ = cpu_to_be32(0); /* pi */
|
2013-05-03 01:19:10 +08:00
|
|
|
p = xdr_encode_opaque(p, context, len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline __be32
|
2013-08-28 09:32:25 +08:00
|
|
|
nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
|
|
|
|
void *context, int len)
|
2013-05-03 01:19:10 +08:00
|
|
|
{ return 0; }
|
|
|
|
#endif
|
|
|
|
|
2015-07-07 10:16:37 +08:00
|
|
|
static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *bmval2, u32 *rdattr_err)
|
2006-10-04 17:16:20 +08:00
|
|
|
{
|
|
|
|
/* As per referral draft: */
|
|
|
|
if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS ||
|
|
|
|
*bmval1 & ~WORD1_ABSENT_FS_ATTRS) {
|
|
|
|
if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR ||
|
|
|
|
*bmval0 & FATTR4_WORD0_FS_LOCATIONS)
|
|
|
|
*rdattr_err = NFSERR_MOVED;
|
|
|
|
else
|
|
|
|
return nfserr_moved;
|
|
|
|
}
|
|
|
|
*bmval0 &= WORD0_ABSENT_FS_ATTRS;
|
|
|
|
*bmval1 &= WORD1_ABSENT_FS_ATTRS;
|
2015-07-07 10:16:37 +08:00
|
|
|
*bmval2 &= WORD2_ABSENT_FS_ATTRS;
|
2006-10-04 17:16:20 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-10-02 05:50:56 +08:00
|
|
|
|
|
|
|
static int get_parent_attributes(struct svc_export *exp, struct kstat *stat)
|
|
|
|
{
|
|
|
|
struct path path = exp->ex_path;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
path_get(&path);
|
|
|
|
while (follow_up(&path)) {
|
|
|
|
if (path.dentry != path.mnt->mnt_root)
|
|
|
|
break;
|
|
|
|
}
|
statx: Add a system call to make enhanced file info available
Add a system call to make extended file information available, including
file creation and some attribute flags where available through the
underlying filesystem.
The getattr inode operation is altered to take two additional arguments: a
u32 request_mask and an unsigned int flags that indicate the
synchronisation mode. This change is propagated to the vfs_getattr*()
function.
Functions like vfs_stat() are now inline wrappers around new functions
vfs_statx() and vfs_statx_fd() to reduce stack usage.
========
OVERVIEW
========
The idea was initially proposed as a set of xattrs that could be retrieved
with getxattr(), but the general preference proved to be for a new syscall
with an extended stat structure.
A number of requests were gathered for features to be included. The
following have been included:
(1) Make the fields a consistent size on all arches and make them large.
(2) Spare space, request flags and information flags are provided for
future expansion.
(3) Better support for the y2038 problem [Arnd Bergmann] (tv_sec is an
__s64).
(4) Creation time: The SMB protocol carries the creation time, which could
be exported by Samba, which will in turn help CIFS make use of
FS-Cache as that can be used for coherency data (stx_btime).
This is also specified in NFSv4 as a recommended attribute and could
be exported by NFSD [Steve French].
(5) Lightweight stat: Ask for just those details of interest, and allow a
netfs (such as NFS) to approximate anything not of interest, possibly
without going to the server [Trond Myklebust, Ulrich Drepper, Andreas
Dilger] (AT_STATX_DONT_SYNC).
(6) Heavyweight stat: Force a netfs to go to the server, even if it thinks
its cached attributes are up to date [Trond Myklebust]
(AT_STATX_FORCE_SYNC).
And the following have been left out for future extension:
(7) Data version number: Could be used by userspace NFS servers [Aneesh
Kumar].
Can also be used to modify fill_post_wcc() in NFSD which retrieves
i_version directly, but has just called vfs_getattr(). It could get
it from the kstat struct if it used vfs_xgetattr() instead.
(There's disagreement on the exact semantics of a single field, since
not all filesystems do this the same way).
(8) BSD stat compatibility: Including more fields from the BSD stat such
as creation time (st_btime) and inode generation number (st_gen)
[Jeremy Allison, Bernd Schubert].
(9) Inode generation number: Useful for FUSE and userspace NFS servers
[Bernd Schubert].
(This was asked for but later deemed unnecessary with the
open-by-handle capability available and caused disagreement as to
whether it's a security hole or not).
(10) Extra coherency data may be useful in making backups [Andreas Dilger].
(No particular data were offered, but things like last backup
timestamp, the data version number and the DOS archive bit would come
into this category).
(11) Allow the filesystem to indicate what it can/cannot provide: A
filesystem can now say it doesn't support a standard stat feature if
that isn't available, so if, for instance, inode numbers or UIDs don't
exist or are fabricated locally...
(This requires a separate system call - I have an fsinfo() call idea
for this).
(12) Store a 16-byte volume ID in the superblock that can be returned in
struct xstat [Steve French].
(Deferred to fsinfo).
(13) Include granularity fields in the time data to indicate the
granularity of each of the times (NFSv4 time_delta) [Steve French].
(Deferred to fsinfo).
(14) FS_IOC_GETFLAGS value. These could be translated to BSD's st_flags.
Note that the Linux IOC flags are a mess and filesystems such as Ext4
define flags that aren't in linux/fs.h, so translation in the kernel
may be a necessity (or, possibly, we provide the filesystem type too).
(Some attributes are made available in stx_attributes, but the general
feeling was that the IOC flags were to ext[234]-specific and shouldn't
be exposed through statx this way).
(15) Mask of features available on file (eg: ACLs, seclabel) [Brad Boyer,
Michael Kerrisk].
(Deferred, probably to fsinfo. Finding out if there's an ACL or
seclabal might require extra filesystem operations).
(16) Femtosecond-resolution timestamps [Dave Chinner].
(A __reserved field has been left in the statx_timestamp struct for
this - if there proves to be a need).
(17) A set multiple attributes syscall to go with this.
===============
NEW SYSTEM CALL
===============
The new system call is:
int ret = statx(int dfd,
const char *filename,
unsigned int flags,
unsigned int mask,
struct statx *buffer);
The dfd, filename and flags parameters indicate the file to query, in a
similar way to fstatat(). There is no equivalent of lstat() as that can be
emulated with statx() by passing AT_SYMLINK_NOFOLLOW in flags. There is
also no equivalent of fstat() as that can be emulated by passing a NULL
filename to statx() with the fd of interest in dfd.
Whether or not statx() synchronises the attributes with the backing store
can be controlled by OR'ing a value into the flags argument (this typically
only affects network filesystems):
(1) AT_STATX_SYNC_AS_STAT tells statx() to behave as stat() does in this
respect.
(2) AT_STATX_FORCE_SYNC will require a network filesystem to synchronise
its attributes with the server - which might require data writeback to
occur to get the timestamps correct.
(3) AT_STATX_DONT_SYNC will suppress synchronisation with the server in a
network filesystem. The resulting values should be considered
approximate.
mask is a bitmask indicating the fields in struct statx that are of
interest to the caller. The user should set this to STATX_BASIC_STATS to
get the basic set returned by stat(). It should be noted that asking for
more information may entail extra I/O operations.
buffer points to the destination for the data. This must be 256 bytes in
size.
======================
MAIN ATTRIBUTES RECORD
======================
The following structures are defined in which to return the main attribute
set:
struct statx_timestamp {
__s64 tv_sec;
__s32 tv_nsec;
__s32 __reserved;
};
struct statx {
__u32 stx_mask;
__u32 stx_blksize;
__u64 stx_attributes;
__u32 stx_nlink;
__u32 stx_uid;
__u32 stx_gid;
__u16 stx_mode;
__u16 __spare0[1];
__u64 stx_ino;
__u64 stx_size;
__u64 stx_blocks;
__u64 __spare1[1];
struct statx_timestamp stx_atime;
struct statx_timestamp stx_btime;
struct statx_timestamp stx_ctime;
struct statx_timestamp stx_mtime;
__u32 stx_rdev_major;
__u32 stx_rdev_minor;
__u32 stx_dev_major;
__u32 stx_dev_minor;
__u64 __spare2[14];
};
The defined bits in request_mask and stx_mask are:
STATX_TYPE Want/got stx_mode & S_IFMT
STATX_MODE Want/got stx_mode & ~S_IFMT
STATX_NLINK Want/got stx_nlink
STATX_UID Want/got stx_uid
STATX_GID Want/got stx_gid
STATX_ATIME Want/got stx_atime{,_ns}
STATX_MTIME Want/got stx_mtime{,_ns}
STATX_CTIME Want/got stx_ctime{,_ns}
STATX_INO Want/got stx_ino
STATX_SIZE Want/got stx_size
STATX_BLOCKS Want/got stx_blocks
STATX_BASIC_STATS [The stuff in the normal stat struct]
STATX_BTIME Want/got stx_btime{,_ns}
STATX_ALL [All currently available stuff]
stx_btime is the file creation time, stx_mask is a bitmask indicating the
data provided and __spares*[] are where as-yet undefined fields can be
placed.
Time fields are structures with separate seconds and nanoseconds fields
plus a reserved field in case we want to add even finer resolution. Note
that times will be negative if before 1970; in such a case, the nanosecond
fields will also be negative if not zero.
The bits defined in the stx_attributes field convey information about a
file, how it is accessed, where it is and what it does. The following
attributes map to FS_*_FL flags and are the same numerical value:
STATX_ATTR_COMPRESSED File is compressed by the fs
STATX_ATTR_IMMUTABLE File is marked immutable
STATX_ATTR_APPEND File is append-only
STATX_ATTR_NODUMP File is not to be dumped
STATX_ATTR_ENCRYPTED File requires key to decrypt in fs
Within the kernel, the supported flags are listed by:
KSTAT_ATTR_FS_IOC_FLAGS
[Are any other IOC flags of sufficient general interest to be exposed
through this interface?]
New flags include:
STATX_ATTR_AUTOMOUNT Object is an automount trigger
These are for the use of GUI tools that might want to mark files specially,
depending on what they are.
Fields in struct statx come in a number of classes:
(0) stx_dev_*, stx_blksize.
These are local system information and are always available.
(1) stx_mode, stx_nlinks, stx_uid, stx_gid, stx_[amc]time, stx_ino,
stx_size, stx_blocks.
These will be returned whether the caller asks for them or not. The
corresponding bits in stx_mask will be set to indicate whether they
actually have valid values.
If the caller didn't ask for them, then they may be approximated. For
example, NFS won't waste any time updating them from the server,
unless as a byproduct of updating something requested.
If the values don't actually exist for the underlying object (such as
UID or GID on a DOS file), then the bit won't be set in the stx_mask,
even if the caller asked for the value. In such a case, the returned
value will be a fabrication.
Note that there are instances where the type might not be valid, for
instance Windows reparse points.
(2) stx_rdev_*.
This will be set only if stx_mode indicates we're looking at a
blockdev or a chardev, otherwise will be 0.
(3) stx_btime.
Similar to (1), except this will be set to 0 if it doesn't exist.
=======
TESTING
=======
The following test program can be used to test the statx system call:
samples/statx/test-statx.c
Just compile and run, passing it paths to the files you want to examine.
The file is built automatically if CONFIG_SAMPLES is enabled.
Here's some example output. Firstly, an NFS directory that crosses to
another FSID. Note that the AUTOMOUNT attribute is set because transiting
this directory will cause d_automount to be invoked by the VFS.
[root@andromeda ~]# /tmp/test-statx -A /warthog/data
statx(/warthog/data) = 0
results=7ff
Size: 4096 Blocks: 8 IO Block: 1048576 directory
Device: 00:26 Inode: 1703937 Links: 125
Access: (3777/drwxrwxrwx) Uid: 0 Gid: 4041
Access: 2016-11-24 09:02:12.219699527+0000
Modify: 2016-11-17 10:44:36.225653653+0000
Change: 2016-11-17 10:44:36.225653653+0000
Attributes: 0000000000001000 (-------- -------- -------- -------- -------- -------- ---m---- --------)
Secondly, the result of automounting on that directory.
[root@andromeda ~]# /tmp/test-statx /warthog/data
statx(/warthog/data) = 0
results=7ff
Size: 4096 Blocks: 8 IO Block: 1048576 directory
Device: 00:27 Inode: 2 Links: 125
Access: (3777/drwxrwxrwx) Uid: 0 Gid: 4041
Access: 2016-11-24 09:02:12.219699527+0000
Modify: 2016-11-17 10:44:36.225653653+0000
Change: 2016-11-17 10:44:36.225653653+0000
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2017-02-01 00:46:22 +08:00
|
|
|
err = vfs_getattr(&path, stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
|
2012-10-02 05:50:56 +08:00
|
|
|
path_put(&path);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2015-07-30 21:55:30 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_bitmap(struct xdr_stream *xdr, u32 bmval0, u32 bmval1, u32 bmval2)
|
|
|
|
{
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
if (bmval2) {
|
|
|
|
p = xdr_reserve_space(xdr, 16);
|
|
|
|
if (!p)
|
|
|
|
goto out_resource;
|
|
|
|
*p++ = cpu_to_be32(3);
|
|
|
|
*p++ = cpu_to_be32(bmval0);
|
|
|
|
*p++ = cpu_to_be32(bmval1);
|
|
|
|
*p++ = cpu_to_be32(bmval2);
|
|
|
|
} else if (bmval1) {
|
|
|
|
p = xdr_reserve_space(xdr, 12);
|
|
|
|
if (!p)
|
|
|
|
goto out_resource;
|
|
|
|
*p++ = cpu_to_be32(2);
|
|
|
|
*p++ = cpu_to_be32(bmval0);
|
|
|
|
*p++ = cpu_to_be32(bmval1);
|
|
|
|
} else {
|
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
|
|
|
goto out_resource;
|
|
|
|
*p++ = cpu_to_be32(1);
|
|
|
|
*p++ = cpu_to_be32(bmval0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
out_resource:
|
|
|
|
return nfserr_resource;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Note: @fhp can be NULL; in this case, we might have to compose the filehandle
|
|
|
|
* ourselves.
|
|
|
|
*/
|
2014-05-30 21:09:25 +08:00
|
|
|
static __be32
|
2013-08-27 04:04:46 +08:00
|
|
|
nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
|
|
|
|
struct svc_export *exp,
|
|
|
|
struct dentry *dentry, u32 *bmval,
|
2007-11-28 03:34:05 +08:00
|
|
|
struct svc_rqst *rqstp, int ignore_crossmnt)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
u32 bmval0 = bmval[0];
|
|
|
|
u32 bmval1 = bmval[1];
|
2009-04-03 13:29:11 +08:00
|
|
|
u32 bmval2 = bmval[2];
|
2005-04-17 06:20:36 +08:00
|
|
|
struct kstat stat;
|
2014-01-16 01:21:12 +08:00
|
|
|
struct svc_fh *tempfh = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct kstatfs statfs;
|
2013-08-28 09:32:25 +08:00
|
|
|
__be32 *p;
|
2014-02-27 09:17:02 +08:00
|
|
|
int starting_len = xdr->buf->len;
|
2013-08-30 03:42:52 +08:00
|
|
|
int attrlen_offset;
|
|
|
|
__be32 attrlen;
|
2005-04-17 06:20:36 +08:00
|
|
|
u32 dummy;
|
|
|
|
u64 dummy64;
|
2006-10-04 17:16:20 +08:00
|
|
|
u32 rdattr_err = 0;
|
2006-10-20 14:28:59 +08:00
|
|
|
__be32 status;
|
2006-10-20 14:29:01 +08:00
|
|
|
int err;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct nfs4_acl *acl = NULL;
|
2019-03-22 22:07:11 +08:00
|
|
|
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
|
2013-05-03 01:19:10 +08:00
|
|
|
void *context = NULL;
|
|
|
|
int contextlen;
|
2019-03-22 22:07:11 +08:00
|
|
|
#endif
|
2013-05-03 01:19:10 +08:00
|
|
|
bool contextsupport = false;
|
2009-04-03 13:29:11 +08:00
|
|
|
struct nfsd4_compoundres *resp = rqstp->rq_resp;
|
|
|
|
u32 minorversion = resp->cstate.minorversion;
|
2010-07-08 00:53:11 +08:00
|
|
|
struct path path = {
|
|
|
|
.mnt = exp->ex_path.mnt,
|
|
|
|
.dentry = dentry,
|
|
|
|
};
|
2012-11-27 19:11:44 +08:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1);
|
2016-10-19 02:18:40 +08:00
|
|
|
BUG_ON(!nfsd_attrs_supported(minorversion, bmval));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-10-04 17:16:20 +08:00
|
|
|
if (exp->ex_fslocs.migrated) {
|
2015-07-07 10:16:37 +08:00
|
|
|
status = fattr_handle_absent_fs(&bmval0, &bmval1, &bmval2, &rdattr_err);
|
2006-10-04 17:16:20 +08:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
statx: Add a system call to make enhanced file info available
Add a system call to make extended file information available, including
file creation and some attribute flags where available through the
underlying filesystem.
The getattr inode operation is altered to take two additional arguments: a
u32 request_mask and an unsigned int flags that indicate the
synchronisation mode. This change is propagated to the vfs_getattr*()
function.
Functions like vfs_stat() are now inline wrappers around new functions
vfs_statx() and vfs_statx_fd() to reduce stack usage.
========
OVERVIEW
========
The idea was initially proposed as a set of xattrs that could be retrieved
with getxattr(), but the general preference proved to be for a new syscall
with an extended stat structure.
A number of requests were gathered for features to be included. The
following have been included:
(1) Make the fields a consistent size on all arches and make them large.
(2) Spare space, request flags and information flags are provided for
future expansion.
(3) Better support for the y2038 problem [Arnd Bergmann] (tv_sec is an
__s64).
(4) Creation time: The SMB protocol carries the creation time, which could
be exported by Samba, which will in turn help CIFS make use of
FS-Cache as that can be used for coherency data (stx_btime).
This is also specified in NFSv4 as a recommended attribute and could
be exported by NFSD [Steve French].
(5) Lightweight stat: Ask for just those details of interest, and allow a
netfs (such as NFS) to approximate anything not of interest, possibly
without going to the server [Trond Myklebust, Ulrich Drepper, Andreas
Dilger] (AT_STATX_DONT_SYNC).
(6) Heavyweight stat: Force a netfs to go to the server, even if it thinks
its cached attributes are up to date [Trond Myklebust]
(AT_STATX_FORCE_SYNC).
And the following have been left out for future extension:
(7) Data version number: Could be used by userspace NFS servers [Aneesh
Kumar].
Can also be used to modify fill_post_wcc() in NFSD which retrieves
i_version directly, but has just called vfs_getattr(). It could get
it from the kstat struct if it used vfs_xgetattr() instead.
(There's disagreement on the exact semantics of a single field, since
not all filesystems do this the same way).
(8) BSD stat compatibility: Including more fields from the BSD stat such
as creation time (st_btime) and inode generation number (st_gen)
[Jeremy Allison, Bernd Schubert].
(9) Inode generation number: Useful for FUSE and userspace NFS servers
[Bernd Schubert].
(This was asked for but later deemed unnecessary with the
open-by-handle capability available and caused disagreement as to
whether it's a security hole or not).
(10) Extra coherency data may be useful in making backups [Andreas Dilger].
(No particular data were offered, but things like last backup
timestamp, the data version number and the DOS archive bit would come
into this category).
(11) Allow the filesystem to indicate what it can/cannot provide: A
filesystem can now say it doesn't support a standard stat feature if
that isn't available, so if, for instance, inode numbers or UIDs don't
exist or are fabricated locally...
(This requires a separate system call - I have an fsinfo() call idea
for this).
(12) Store a 16-byte volume ID in the superblock that can be returned in
struct xstat [Steve French].
(Deferred to fsinfo).
(13) Include granularity fields in the time data to indicate the
granularity of each of the times (NFSv4 time_delta) [Steve French].
(Deferred to fsinfo).
(14) FS_IOC_GETFLAGS value. These could be translated to BSD's st_flags.
Note that the Linux IOC flags are a mess and filesystems such as Ext4
define flags that aren't in linux/fs.h, so translation in the kernel
may be a necessity (or, possibly, we provide the filesystem type too).
(Some attributes are made available in stx_attributes, but the general
feeling was that the IOC flags were to ext[234]-specific and shouldn't
be exposed through statx this way).
(15) Mask of features available on file (eg: ACLs, seclabel) [Brad Boyer,
Michael Kerrisk].
(Deferred, probably to fsinfo. Finding out if there's an ACL or
seclabal might require extra filesystem operations).
(16) Femtosecond-resolution timestamps [Dave Chinner].
(A __reserved field has been left in the statx_timestamp struct for
this - if there proves to be a need).
(17) A set multiple attributes syscall to go with this.
===============
NEW SYSTEM CALL
===============
The new system call is:
int ret = statx(int dfd,
const char *filename,
unsigned int flags,
unsigned int mask,
struct statx *buffer);
The dfd, filename and flags parameters indicate the file to query, in a
similar way to fstatat(). There is no equivalent of lstat() as that can be
emulated with statx() by passing AT_SYMLINK_NOFOLLOW in flags. There is
also no equivalent of fstat() as that can be emulated by passing a NULL
filename to statx() with the fd of interest in dfd.
Whether or not statx() synchronises the attributes with the backing store
can be controlled by OR'ing a value into the flags argument (this typically
only affects network filesystems):
(1) AT_STATX_SYNC_AS_STAT tells statx() to behave as stat() does in this
respect.
(2) AT_STATX_FORCE_SYNC will require a network filesystem to synchronise
its attributes with the server - which might require data writeback to
occur to get the timestamps correct.
(3) AT_STATX_DONT_SYNC will suppress synchronisation with the server in a
network filesystem. The resulting values should be considered
approximate.
mask is a bitmask indicating the fields in struct statx that are of
interest to the caller. The user should set this to STATX_BASIC_STATS to
get the basic set returned by stat(). It should be noted that asking for
more information may entail extra I/O operations.
buffer points to the destination for the data. This must be 256 bytes in
size.
======================
MAIN ATTRIBUTES RECORD
======================
The following structures are defined in which to return the main attribute
set:
struct statx_timestamp {
__s64 tv_sec;
__s32 tv_nsec;
__s32 __reserved;
};
struct statx {
__u32 stx_mask;
__u32 stx_blksize;
__u64 stx_attributes;
__u32 stx_nlink;
__u32 stx_uid;
__u32 stx_gid;
__u16 stx_mode;
__u16 __spare0[1];
__u64 stx_ino;
__u64 stx_size;
__u64 stx_blocks;
__u64 __spare1[1];
struct statx_timestamp stx_atime;
struct statx_timestamp stx_btime;
struct statx_timestamp stx_ctime;
struct statx_timestamp stx_mtime;
__u32 stx_rdev_major;
__u32 stx_rdev_minor;
__u32 stx_dev_major;
__u32 stx_dev_minor;
__u64 __spare2[14];
};
The defined bits in request_mask and stx_mask are:
STATX_TYPE Want/got stx_mode & S_IFMT
STATX_MODE Want/got stx_mode & ~S_IFMT
STATX_NLINK Want/got stx_nlink
STATX_UID Want/got stx_uid
STATX_GID Want/got stx_gid
STATX_ATIME Want/got stx_atime{,_ns}
STATX_MTIME Want/got stx_mtime{,_ns}
STATX_CTIME Want/got stx_ctime{,_ns}
STATX_INO Want/got stx_ino
STATX_SIZE Want/got stx_size
STATX_BLOCKS Want/got stx_blocks
STATX_BASIC_STATS [The stuff in the normal stat struct]
STATX_BTIME Want/got stx_btime{,_ns}
STATX_ALL [All currently available stuff]
stx_btime is the file creation time, stx_mask is a bitmask indicating the
data provided and __spares*[] are where as-yet undefined fields can be
placed.
Time fields are structures with separate seconds and nanoseconds fields
plus a reserved field in case we want to add even finer resolution. Note
that times will be negative if before 1970; in such a case, the nanosecond
fields will also be negative if not zero.
The bits defined in the stx_attributes field convey information about a
file, how it is accessed, where it is and what it does. The following
attributes map to FS_*_FL flags and are the same numerical value:
STATX_ATTR_COMPRESSED File is compressed by the fs
STATX_ATTR_IMMUTABLE File is marked immutable
STATX_ATTR_APPEND File is append-only
STATX_ATTR_NODUMP File is not to be dumped
STATX_ATTR_ENCRYPTED File requires key to decrypt in fs
Within the kernel, the supported flags are listed by:
KSTAT_ATTR_FS_IOC_FLAGS
[Are any other IOC flags of sufficient general interest to be exposed
through this interface?]
New flags include:
STATX_ATTR_AUTOMOUNT Object is an automount trigger
These are for the use of GUI tools that might want to mark files specially,
depending on what they are.
Fields in struct statx come in a number of classes:
(0) stx_dev_*, stx_blksize.
These are local system information and are always available.
(1) stx_mode, stx_nlinks, stx_uid, stx_gid, stx_[amc]time, stx_ino,
stx_size, stx_blocks.
These will be returned whether the caller asks for them or not. The
corresponding bits in stx_mask will be set to indicate whether they
actually have valid values.
If the caller didn't ask for them, then they may be approximated. For
example, NFS won't waste any time updating them from the server,
unless as a byproduct of updating something requested.
If the values don't actually exist for the underlying object (such as
UID or GID on a DOS file), then the bit won't be set in the stx_mask,
even if the caller asked for the value. In such a case, the returned
value will be a fabrication.
Note that there are instances where the type might not be valid, for
instance Windows reparse points.
(2) stx_rdev_*.
This will be set only if stx_mode indicates we're looking at a
blockdev or a chardev, otherwise will be 0.
(3) stx_btime.
Similar to (1), except this will be set to 0 if it doesn't exist.
=======
TESTING
=======
The following test program can be used to test the statx system call:
samples/statx/test-statx.c
Just compile and run, passing it paths to the files you want to examine.
The file is built automatically if CONFIG_SAMPLES is enabled.
Here's some example output. Firstly, an NFS directory that crosses to
another FSID. Note that the AUTOMOUNT attribute is set because transiting
this directory will cause d_automount to be invoked by the VFS.
[root@andromeda ~]# /tmp/test-statx -A /warthog/data
statx(/warthog/data) = 0
results=7ff
Size: 4096 Blocks: 8 IO Block: 1048576 directory
Device: 00:26 Inode: 1703937 Links: 125
Access: (3777/drwxrwxrwx) Uid: 0 Gid: 4041
Access: 2016-11-24 09:02:12.219699527+0000
Modify: 2016-11-17 10:44:36.225653653+0000
Change: 2016-11-17 10:44:36.225653653+0000
Attributes: 0000000000001000 (-------- -------- -------- -------- -------- -------- ---m---- --------)
Secondly, the result of automounting on that directory.
[root@andromeda ~]# /tmp/test-statx /warthog/data
statx(/warthog/data) = 0
results=7ff
Size: 4096 Blocks: 8 IO Block: 1048576 directory
Device: 00:27 Inode: 2 Links: 125
Access: (3777/drwxrwxrwx) Uid: 0 Gid: 4041
Access: 2016-11-24 09:02:12.219699527+0000
Modify: 2016-11-17 10:44:36.225653653+0000
Change: 2016-11-17 10:44:36.225653653+0000
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2017-02-01 00:46:22 +08:00
|
|
|
err = vfs_getattr(&path, &stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
|
2006-10-20 14:29:01 +08:00
|
|
|
if (err)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_nfserr;
|
2014-05-28 16:46:13 +08:00
|
|
|
if ((bmval0 & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE |
|
|
|
|
FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) ||
|
2005-04-17 06:20:36 +08:00
|
|
|
(bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |
|
|
|
|
FATTR4_WORD1_SPACE_TOTAL))) {
|
2010-07-08 00:53:11 +08:00
|
|
|
err = vfs_statfs(&path, &statfs);
|
2006-10-20 14:29:01 +08:00
|
|
|
if (err)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_nfserr;
|
|
|
|
}
|
|
|
|
if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) {
|
2014-01-16 01:21:12 +08:00
|
|
|
tempfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
|
|
|
|
status = nfserr_jukebox;
|
|
|
|
if (!tempfh)
|
|
|
|
goto out;
|
|
|
|
fh_init(tempfh, NFS4_FHSIZE);
|
|
|
|
status = fh_compose(tempfh, exp, dentry, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2014-01-16 01:21:12 +08:00
|
|
|
fhp = tempfh;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2015-04-24 19:04:00 +08:00
|
|
|
if (bmval0 & FATTR4_WORD0_ACL) {
|
2006-10-20 14:29:01 +08:00
|
|
|
err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl);
|
2015-04-24 19:04:00 +08:00
|
|
|
if (err == -EOPNOTSUPP)
|
|
|
|
bmval0 &= ~FATTR4_WORD0_ACL;
|
|
|
|
else if (err == -EINVAL) {
|
|
|
|
status = nfserr_attrnotsupp;
|
|
|
|
goto out;
|
|
|
|
} else if (err != 0)
|
|
|
|
goto out_nfserr;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2013-05-03 01:19:10 +08:00
|
|
|
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
|
2015-07-07 10:16:37 +08:00
|
|
|
if ((bmval2 & FATTR4_WORD2_SECURITY_LABEL) ||
|
|
|
|
bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
|
2017-01-04 01:30:11 +08:00
|
|
|
if (exp->ex_flags & NFSEXP_SECURITY_LABEL)
|
|
|
|
err = security_inode_getsecctx(d_inode(dentry),
|
2013-05-03 01:19:10 +08:00
|
|
|
&context, &contextlen);
|
2017-01-04 01:30:11 +08:00
|
|
|
else
|
|
|
|
err = -EOPNOTSUPP;
|
2013-05-03 01:19:10 +08:00
|
|
|
contextsupport = (err == 0);
|
|
|
|
if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
|
|
|
|
if (err == -EOPNOTSUPP)
|
|
|
|
bmval2 &= ~FATTR4_WORD2_SECURITY_LABEL;
|
|
|
|
else if (err)
|
|
|
|
goto out_nfserr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
|
|
|
|
|
2015-07-30 21:55:30 +08:00
|
|
|
status = nfsd4_encode_bitmap(xdr, bmval0, bmval1, bmval2);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
2013-08-30 03:42:52 +08:00
|
|
|
|
|
|
|
attrlen_offset = xdr->buf->len;
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
goto out_resource;
|
2013-08-30 03:42:52 +08:00
|
|
|
p++; /* to be backfilled later */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
|
2017-01-12 09:34:50 +08:00
|
|
|
u32 supp[3];
|
|
|
|
|
|
|
|
memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp));
|
2009-04-03 13:29:11 +08:00
|
|
|
|
2015-04-24 19:04:00 +08:00
|
|
|
if (!IS_POSIXACL(dentry->d_inode))
|
2016-10-19 02:18:40 +08:00
|
|
|
supp[0] &= ~FATTR4_WORD0_ACL;
|
2013-05-03 01:19:10 +08:00
|
|
|
if (!contextsupport)
|
2016-10-19 02:18:40 +08:00
|
|
|
supp[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
|
|
|
|
if (!supp[2]) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 12);
|
|
|
|
if (!p)
|
2010-10-01 02:47:46 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(2);
|
2016-10-19 02:18:40 +08:00
|
|
|
*p++ = cpu_to_be32(supp[0]);
|
|
|
|
*p++ = cpu_to_be32(supp[1]);
|
2009-04-03 13:29:11 +08:00
|
|
|
} else {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 16);
|
|
|
|
if (!p)
|
2010-10-01 02:47:46 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(3);
|
2016-10-19 02:18:40 +08:00
|
|
|
*p++ = cpu_to_be32(supp[0]);
|
|
|
|
*p++ = cpu_to_be32(supp[1]);
|
|
|
|
*p++ = cpu_to_be32(supp[2]);
|
2009-04-03 13:29:11 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_TYPE) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2011-08-15 23:49:30 +08:00
|
|
|
dummy = nfs4_file_type(stat.mode);
|
2013-01-17 06:11:11 +08:00
|
|
|
if (dummy == NF4BAD) {
|
|
|
|
status = nfserr_serverfault;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(dummy);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2005-06-24 13:02:58 +08:00
|
|
|
if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(NFS4_FH_PERSISTENT);
|
2005-06-24 13:02:58 +08:00
|
|
|
else
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(NFS4_FH_PERSISTENT|
|
|
|
|
NFS4_FH_VOL_RENAME);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_CHANGE) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2017-01-30 14:17:00 +08:00
|
|
|
p = encode_change(p, &stat, d_inode(dentry), exp);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_SIZE) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, stat.size);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_NAMED_ATTR) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FSID) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 16);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2006-10-04 17:16:20 +08:00
|
|
|
if (exp->ex_fslocs.migrated) {
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MAJOR);
|
|
|
|
p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MINOR);
|
2007-02-14 16:33:12 +08:00
|
|
|
} else switch(fsid_source(fhp)) {
|
|
|
|
case FSIDSOURCE_FSID:
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, (u64)exp->ex_fsid);
|
|
|
|
p = xdr_encode_hyper(p, (u64)0);
|
2007-02-14 16:33:12 +08:00
|
|
|
break;
|
|
|
|
case FSIDSOURCE_DEV:
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
*p++ = cpu_to_be32(MAJOR(stat.dev));
|
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
*p++ = cpu_to_be32(MINOR(stat.dev));
|
2007-02-14 16:33:12 +08:00
|
|
|
break;
|
|
|
|
case FSIDSOURCE_UUID:
|
2014-05-23 20:00:19 +08:00
|
|
|
p = xdr_encode_opaque_fixed(p, exp->ex_uuid,
|
|
|
|
EX_UUID_LEN);
|
2007-02-14 16:33:12 +08:00
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_LEASE_TIME) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(nn->nfsd4_lease);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(rdattr_err);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_ACL) {
|
|
|
|
struct nfs4_ace *ace;
|
|
|
|
|
|
|
|
if (acl == NULL) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
|
|
|
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_acl;
|
|
|
|
}
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(acl->naces);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-02-16 17:28:30 +08:00
|
|
|
for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4*3);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(ace->type);
|
|
|
|
*p++ = cpu_to_be32(ace->flag);
|
|
|
|
*p++ = cpu_to_be32(ace->access_mask &
|
|
|
|
NFS4_ACE_MASK_ALL);
|
2013-08-28 09:32:25 +08:00
|
|
|
status = nfsd4_encode_aclname(xdr, rqstp, ace);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out_acl:
|
|
|
|
if (bmval0 & FATTR4_WORD0_ACLSUPPORT) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2015-04-24 19:04:00 +08:00
|
|
|
*p++ = cpu_to_be32(IS_POSIXACL(dentry->d_inode) ?
|
2005-04-17 06:20:36 +08:00
|
|
|
ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_CANSETTIME) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FILEHANDLE) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base,
|
|
|
|
fhp->fh_handle.fh_size);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FILEID) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, stat.ino);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FILES_AVAIL) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FILES_FREE) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FILES_TOTAL) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, (u64) statfs.f_files);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-10-04 17:16:19 +08:00
|
|
|
if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) {
|
2013-08-28 09:32:25 +08:00
|
|
|
status = nfsd4_encode_fs_locations(xdr, rqstp, exp);
|
2006-10-04 17:16:19 +08:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_MAXFILESIZE) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, exp->ex_path.mnt->mnt_sb->s_maxbytes);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_MAXLINK) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(255);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_MAXNAME) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(statfs.f_namelen);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_MAXREAD) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_MAXWRITE) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_MODE) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(stat.mode & S_IALLUGO);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_NO_TRUNC) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_NUMLINKS) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(stat.nlink);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_OWNER) {
|
2013-08-28 09:32:25 +08:00
|
|
|
status = nfsd4_encode_user(xdr, rqstp, stat.uid);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_OWNER_GROUP) {
|
2013-08-28 09:32:25 +08:00
|
|
|
status = nfsd4_encode_group(xdr, rqstp, stat.gid);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_RAWDEV) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32((u32) MAJOR(stat.rdev));
|
|
|
|
*p++ = cpu_to_be32((u32) MINOR(stat.rdev));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
|
|
|
dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, dummy64);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_SPACE_FREE) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
|
|
|
dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, dummy64);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
|
|
|
dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, dummy64);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_SPACE_USED) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
|
|
|
dummy64 = (u64)stat.blocks << 9;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, dummy64);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_TIME_ACCESS) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 12);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, (s64)stat.atime.tv_sec);
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(stat.atime.tv_nsec);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_TIME_DELTA) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 12);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2018-04-26 02:34:11 +08:00
|
|
|
p = encode_time_delta(p, d_inode(dentry));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_TIME_METADATA) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 12);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, (s64)stat.ctime.tv_sec);
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(stat.ctime.tv_nsec);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_TIME_MODIFY) {
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 12);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, (s64)stat.mtime.tv_sec);
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(stat.mtime.tv_nsec);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) {
|
2015-07-30 21:51:54 +08:00
|
|
|
struct kstat parent_stat;
|
|
|
|
u64 ino = stat.ino;
|
|
|
|
|
2013-08-28 09:32:25 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_resource;
|
2007-11-28 03:34:05 +08:00
|
|
|
/*
|
|
|
|
* Get parent's attributes if not ignoring crossmount
|
|
|
|
* and this is the root of a cross-mounted filesystem.
|
|
|
|
*/
|
|
|
|
if (ignore_crossmnt == 0 &&
|
2015-07-30 21:51:54 +08:00
|
|
|
dentry == exp->ex_path.mnt->mnt_root) {
|
|
|
|
err = get_parent_attributes(exp, &parent_stat);
|
|
|
|
if (err)
|
|
|
|
goto out_nfserr;
|
|
|
|
ino = parent_stat.ino;
|
|
|
|
}
|
|
|
|
p = xdr_encode_hyper(p, ino);
|
2005-04-17 06:20:36 +08: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 19:11:59 +08:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
2015-07-30 21:52:44 +08:00
|
|
|
if (bmval1 & FATTR4_WORD1_FS_LAYOUT_TYPES) {
|
2016-07-11 03:55:58 +08:00
|
|
|
status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types);
|
2015-07-30 21:52:44 +08:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bmval2 & FATTR4_WORD2_LAYOUT_TYPES) {
|
2016-07-11 03:55:58 +08:00
|
|
|
status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types);
|
2015-07-30 21:52:44 +08:00
|
|
|
if (status)
|
|
|
|
goto out;
|
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 19:11:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bmval2 & FATTR4_WORD2_LAYOUT_BLKSIZE) {
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
goto out_resource;
|
|
|
|
*p++ = cpu_to_be32(stat.blksize);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NFSD_PNFS */
|
2009-04-03 13:29:14 +08:00
|
|
|
if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
|
2017-05-10 04:24:59 +08:00
|
|
|
u32 supp[3];
|
|
|
|
|
|
|
|
memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp));
|
|
|
|
supp[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0;
|
|
|
|
supp[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1;
|
|
|
|
supp[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2;
|
|
|
|
|
|
|
|
status = nfsd4_encode_bitmap(xdr, supp[0], supp[1], supp[2]);
|
2015-07-30 21:55:30 +08:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2009-04-03 13:29:14 +08:00
|
|
|
}
|
2009-04-03 13:29:11 +08:00
|
|
|
|
2018-04-26 01:26:23 +08:00
|
|
|
if (bmval2 & FATTR4_WORD2_CHANGE_ATTR_TYPE) {
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
goto out_resource;
|
|
|
|
if (IS_I_VERSION(d_inode(dentry)))
|
|
|
|
*p++ = cpu_to_be32(NFS4_CHANGE_TYPE_IS_MONOTONIC_INCR);
|
|
|
|
else
|
|
|
|
*p++ = cpu_to_be32(NFS4_CHANGE_TYPE_IS_TIME_METADATA);
|
|
|
|
}
|
|
|
|
|
2019-03-22 22:07:11 +08:00
|
|
|
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
|
2015-07-30 21:54:26 +08:00
|
|
|
if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
|
|
|
|
status = nfsd4_encode_security_label(xdr, rqstp, context,
|
|
|
|
contextlen);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
2019-03-22 22:07:11 +08:00
|
|
|
#endif
|
2015-07-30 21:54:26 +08:00
|
|
|
|
2020-06-24 06:39:27 +08:00
|
|
|
if (bmval2 & FATTR4_WORD2_XATTR_SUPPORT) {
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
goto out_resource;
|
|
|
|
err = xattr_supported_namespace(d_inode(dentry),
|
|
|
|
XATTR_USER_PREFIX);
|
|
|
|
*p++ = cpu_to_be32(err == 0);
|
|
|
|
}
|
|
|
|
|
2013-08-30 03:42:52 +08:00
|
|
|
attrlen = htonl(xdr->buf->len - attrlen_offset - 4);
|
|
|
|
write_bytes_to_xdr_buf(xdr->buf, attrlen_offset, &attrlen, 4);
|
2005-04-17 06:20:36 +08:00
|
|
|
status = nfs_ok;
|
|
|
|
|
|
|
|
out:
|
2013-05-15 22:27:52 +08:00
|
|
|
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
|
2013-05-03 01:19:10 +08:00
|
|
|
if (context)
|
|
|
|
security_release_secctx(context, contextlen);
|
2013-05-15 22:27:52 +08:00
|
|
|
#endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
|
2007-02-16 17:28:30 +08:00
|
|
|
kfree(acl);
|
2014-03-10 12:52:07 +08:00
|
|
|
if (tempfh) {
|
2014-01-16 01:21:12 +08:00
|
|
|
fh_put(tempfh);
|
2014-03-10 12:52:07 +08:00
|
|
|
kfree(tempfh);
|
|
|
|
}
|
2014-02-27 09:17:02 +08:00
|
|
|
if (status)
|
|
|
|
xdr_truncate_encode(xdr, starting_len);
|
2005-04-17 06:20:36 +08:00
|
|
|
return status;
|
|
|
|
out_nfserr:
|
2006-10-20 14:29:01 +08:00
|
|
|
status = nfserrno(err);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
|
|
|
out_resource:
|
|
|
|
status = nfserr_resource;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-08-27 04:04:46 +08:00
|
|
|
static void svcxdr_init_encode_from_buffer(struct xdr_stream *xdr,
|
|
|
|
struct xdr_buf *buf, __be32 *p, int bytes)
|
|
|
|
{
|
|
|
|
xdr->scratch.iov_len = 0;
|
|
|
|
memset(buf, 0, sizeof(struct xdr_buf));
|
|
|
|
buf->head[0].iov_base = p;
|
|
|
|
buf->head[0].iov_len = 0;
|
|
|
|
buf->len = 0;
|
|
|
|
xdr->buf = buf;
|
|
|
|
xdr->iov = buf->head;
|
|
|
|
xdr->p = p;
|
|
|
|
xdr->end = (void *)p + bytes;
|
|
|
|
buf->buflen = bytes;
|
|
|
|
}
|
|
|
|
|
2013-08-27 04:04:46 +08:00
|
|
|
__be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words,
|
|
|
|
struct svc_fh *fhp, struct svc_export *exp,
|
|
|
|
struct dentry *dentry, u32 *bmval,
|
|
|
|
struct svc_rqst *rqstp, int ignore_crossmnt)
|
|
|
|
{
|
2013-08-27 04:04:46 +08:00
|
|
|
struct xdr_buf dummy;
|
2013-08-27 04:04:46 +08:00
|
|
|
struct xdr_stream xdr;
|
|
|
|
__be32 ret;
|
|
|
|
|
2013-08-27 04:04:46 +08:00
|
|
|
svcxdr_init_encode_from_buffer(&xdr, &dummy, *p, words << 2);
|
2013-08-27 04:04:46 +08:00
|
|
|
ret = nfsd4_encode_fattr(&xdr, fhp, exp, dentry, bmval, rqstp,
|
|
|
|
ignore_crossmnt);
|
|
|
|
*p = xdr.p;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-02-12 04:48:47 +08:00
|
|
|
static inline int attributes_need_mount(u32 *bmval)
|
|
|
|
{
|
|
|
|
if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME))
|
|
|
|
return 1;
|
|
|
|
if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
2014-01-21 05:37:11 +08:00
|
|
|
nfsd4_encode_dirent_fattr(struct xdr_stream *xdr, struct nfsd4_readdir *cd,
|
|
|
|
const char *name, int namlen)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct svc_export *exp = cd->rd_fhp->fh_export;
|
|
|
|
struct dentry *dentry;
|
2006-10-20 14:28:59 +08:00
|
|
|
__be32 nfserr;
|
2007-11-28 03:34:05 +08:00
|
|
|
int ignore_crossmnt = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2019-10-31 13:21:58 +08:00
|
|
|
dentry = lookup_positive_unlocked(name, cd->rd_fhp->fh_dentry, namlen);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (IS_ERR(dentry))
|
|
|
|
return nfserrno(PTR_ERR(dentry));
|
|
|
|
|
|
|
|
exp_get(exp);
|
2007-11-28 03:34:05 +08:00
|
|
|
/*
|
|
|
|
* In the case of a mountpoint, the client may be asking for
|
|
|
|
* attributes that are only properties of the underlying filesystem
|
|
|
|
* as opposed to the cross-mounted file system. In such a case,
|
|
|
|
* we will not follow the cross mount and will fill the attribtutes
|
|
|
|
* directly from the mountpoint dentry.
|
|
|
|
*/
|
2009-10-26 09:43:01 +08:00
|
|
|
if (nfsd_mountpoint(dentry, exp)) {
|
2006-12-13 16:35:24 +08:00
|
|
|
int err;
|
|
|
|
|
2009-10-26 09:43:01 +08:00
|
|
|
if (!(exp->ex_flags & NFSEXP_V4ROOT)
|
|
|
|
&& !attributes_need_mount(cd->rd_bmval)) {
|
|
|
|
ignore_crossmnt = 1;
|
|
|
|
goto out_encode;
|
|
|
|
}
|
2007-07-17 19:04:51 +08:00
|
|
|
/*
|
|
|
|
* Why the heck aren't we just using nfsd_lookup??
|
|
|
|
* Different "."/".." handling? Something else?
|
|
|
|
* At least, add a comment here to explain....
|
|
|
|
*/
|
2006-12-13 16:35:24 +08:00
|
|
|
err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);
|
|
|
|
if (err) {
|
|
|
|
nfserr = nfserrno(err);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_put;
|
|
|
|
}
|
2007-07-17 19:04:51 +08:00
|
|
|
nfserr = check_nfsd_access(exp, cd->rd_rqstp);
|
|
|
|
if (nfserr)
|
|
|
|
goto out_put;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
}
|
2009-10-26 09:43:01 +08:00
|
|
|
out_encode:
|
2014-01-21 05:37:11 +08:00
|
|
|
nfserr = nfsd4_encode_fattr(xdr, NULL, exp, dentry, cd->rd_bmval,
|
2007-11-28 03:34:05 +08:00
|
|
|
cd->rd_rqstp, ignore_crossmnt);
|
2005-04-17 06:20:36 +08:00
|
|
|
out_put:
|
|
|
|
dput(dentry);
|
|
|
|
exp_put(exp);
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:58 +08:00
|
|
|
static __be32 *
|
2014-01-21 05:37:11 +08:00
|
|
|
nfsd4_encode_rdattr_error(struct xdr_stream *xdr, __be32 nfserr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-21 05:37:11 +08:00
|
|
|
__be32 *p;
|
|
|
|
|
2014-07-06 11:34:43 +08:00
|
|
|
p = xdr_reserve_space(xdr, 20);
|
2014-01-21 05:37:11 +08:00
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
return NULL;
|
|
|
|
*p++ = htonl(2);
|
|
|
|
*p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */
|
|
|
|
*p++ = htonl(0); /* bmval1 */
|
|
|
|
|
2013-01-17 06:33:28 +08:00
|
|
|
*p++ = htonl(4); /* attribute length */
|
2005-04-17 06:20:36 +08:00
|
|
|
*p++ = nfserr; /* no htonl */
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-01-26 16:57:10 +08:00
|
|
|
nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,
|
|
|
|
loff_t offset, u64 ino, unsigned int d_type)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-01-26 16:57:10 +08:00
|
|
|
struct readdir_cd *ccd = ccdv;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);
|
2014-01-21 05:37:11 +08:00
|
|
|
struct xdr_stream *xdr = cd->xdr;
|
|
|
|
int start_offset = xdr->buf->len;
|
|
|
|
int cookie_offset;
|
2014-08-21 02:49:50 +08:00
|
|
|
u32 name_and_cookie;
|
2014-01-21 05:37:11 +08:00
|
|
|
int entry_bytes;
|
2006-10-20 14:28:59 +08:00
|
|
|
__be32 nfserr = nfserr_toosmall;
|
2014-01-21 05:37:11 +08:00
|
|
|
__be64 wire_offset;
|
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* In nfsv4, "." and ".." never make it onto the wire.. */
|
|
|
|
if (name && isdotent(name, namlen)) {
|
|
|
|
cd->common.err = nfs_ok;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-21 05:37:11 +08:00
|
|
|
if (cd->cookie_offset) {
|
|
|
|
wire_offset = cpu_to_be64(offset);
|
|
|
|
write_bytes_to_xdr_buf(xdr->buf, cd->cookie_offset,
|
|
|
|
&wire_offset, 8);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-01-21 05:37:11 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto fail;
|
|
|
|
*p++ = xdr_one; /* mark entry present */
|
2014-01-21 05:37:11 +08:00
|
|
|
cookie_offset = xdr->buf->len;
|
|
|
|
p = xdr_reserve_space(xdr, 3*4 + namlen);
|
|
|
|
if (!p)
|
|
|
|
goto fail;
|
2005-04-17 06:20:36 +08:00
|
|
|
p = xdr_encode_hyper(p, NFS_OFFSET_MAX); /* offset of next entry */
|
|
|
|
p = xdr_encode_array(p, name, namlen); /* name length & name */
|
|
|
|
|
2014-01-21 05:37:11 +08:00
|
|
|
nfserr = nfsd4_encode_dirent_fattr(xdr, cd, name, namlen);
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (nfserr) {
|
|
|
|
case nfs_ok:
|
|
|
|
break;
|
|
|
|
case nfserr_resource:
|
|
|
|
nfserr = nfserr_toosmall;
|
|
|
|
goto fail;
|
2009-05-06 07:04:29 +08:00
|
|
|
case nfserr_noent:
|
2014-06-13 17:32:42 +08:00
|
|
|
xdr_truncate_encode(xdr, start_offset);
|
2009-05-06 07:04:29 +08:00
|
|
|
goto skip_entry;
|
2005-04-17 06:20:36 +08:00
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* If the client requested the RDATTR_ERROR attribute,
|
|
|
|
* we stuff the error code into this attribute
|
|
|
|
* and continue. If this attribute was not requested,
|
|
|
|
* then in accordance with the spec, we fail the
|
|
|
|
* entire READDIR operation(!)
|
|
|
|
*/
|
|
|
|
if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))
|
|
|
|
goto fail;
|
2014-01-21 05:37:11 +08:00
|
|
|
p = nfsd4_encode_rdattr_error(xdr, nfserr);
|
2006-01-19 09:43:40 +08:00
|
|
|
if (p == NULL) {
|
|
|
|
nfserr = nfserr_toosmall;
|
2005-04-17 06:20:36 +08:00
|
|
|
goto fail;
|
2006-01-19 09:43:40 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2014-01-21 05:37:11 +08:00
|
|
|
nfserr = nfserr_toosmall;
|
|
|
|
entry_bytes = xdr->buf->len - start_offset;
|
|
|
|
if (entry_bytes > cd->rd_maxcount)
|
|
|
|
goto fail;
|
|
|
|
cd->rd_maxcount -= entry_bytes;
|
2014-08-21 02:49:50 +08:00
|
|
|
/*
|
|
|
|
* RFC 3530 14.2.24 describes rd_dircount as only a "hint", so
|
|
|
|
* let's always let through the first entry, at least:
|
|
|
|
*/
|
2014-12-20 07:01:35 +08:00
|
|
|
if (!cd->rd_dircount)
|
|
|
|
goto fail;
|
|
|
|
name_and_cookie = 4 + 4 * XDR_QUADLEN(namlen) + 8;
|
2014-08-21 02:49:50 +08:00
|
|
|
if (name_and_cookie > cd->rd_dircount && cd->cookie_offset)
|
|
|
|
goto fail;
|
|
|
|
cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie);
|
2014-12-20 07:01:35 +08:00
|
|
|
|
2014-01-21 05:37:11 +08:00
|
|
|
cd->cookie_offset = cookie_offset;
|
2009-05-06 07:04:29 +08:00
|
|
|
skip_entry:
|
2005-04-17 06:20:36 +08:00
|
|
|
cd->common.err = nfs_ok;
|
|
|
|
return 0;
|
|
|
|
fail:
|
2014-01-21 05:37:11 +08:00
|
|
|
xdr_truncate_encode(xdr, start_offset);
|
2005-04-17 06:20:36 +08:00
|
|
|
cd->common.err = nfserr;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_stateid(struct xdr_stream *xdr, stateid_t *sid)
|
2008-08-13 01:45:07 +08:00
|
|
|
{
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2008-08-13 01:45:07 +08:00
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, sizeof(stateid_t));
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(sid->si_generation);
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque_fixed(p, &sid->si_opaque,
|
|
|
|
sizeof(stateid_opaque_t));
|
2014-01-31 06:18:38 +08:00
|
|
|
return 0;
|
2008-08-13 01:45:07 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
*p++ = cpu_to_be32(access->ac_supported);
|
|
|
|
*p++ = cpu_to_be32(access->ac_resp_access);
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-10-05 11:12:59 +08:00
|
|
|
static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)
|
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2010-10-05 11:12:59 +08:00
|
|
|
__be32 *p;
|
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 8);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
p = xdr_encode_opaque_fixed(p, bcts->sessionid.data,
|
|
|
|
NFS4_MAX_SESSIONID_LEN);
|
|
|
|
*p++ = cpu_to_be32(bcts->dir);
|
|
|
|
/* Upshifting from TCP to RDMA is not supported */
|
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
return 0;
|
2010-10-05 11:12:59 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfsd4_encode_stateid(xdr, &close->cl_stateid);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
p = xdr_encode_opaque_fixed(p, commit->co_verf.data,
|
2014-03-23 06:43:16 +08:00
|
|
|
NFS4_VERIFIER_SIZE);
|
2017-05-06 23:12:04 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
p = xdr_reserve_space(xdr, 20);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
encode_cinfo(p, &create->cr_cinfo);
|
2019-08-19 02:18:58 +08:00
|
|
|
return nfsd4_encode_bitmap(xdr, create->cr_bmval[0],
|
2017-05-06 23:12:04 +08:00
|
|
|
create->cr_bmval[1], create->cr_bmval[2]);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct svc_fh *fhp = getattr->ga_fhp;
|
2013-08-27 04:04:46 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry,
|
|
|
|
getattr->ga_bmval, resp->rqstp, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2008-07-04 19:38:33 +08:00
|
|
|
struct svc_fh *fhp = *fhpp;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int len;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
len = fhp->fh_handle.fh_size;
|
|
|
|
p = xdr_reserve_space(xdr, len + 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, len);
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Including all fields other than the name, a LOCK4denied structure requires
|
|
|
|
* 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
|
|
|
|
*/
|
2014-01-31 06:18:38 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_lock_denied(struct xdr_stream *xdr, struct nfsd4_lock_denied *ld)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2011-08-31 10:15:47 +08:00
|
|
|
struct xdr_netobj *conf = &ld->ld_owner;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-03-11 00:19:10 +08:00
|
|
|
again:
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len));
|
2014-03-11 00:19:10 +08:00
|
|
|
if (!p) {
|
|
|
|
/*
|
|
|
|
* Don't fail to return the result just because we can't
|
|
|
|
* return the conflicting open:
|
|
|
|
*/
|
|
|
|
if (conf->len) {
|
2014-07-07 22:10:56 +08:00
|
|
|
kfree(conf->data);
|
2014-03-11 00:19:10 +08:00
|
|
|
conf->len = 0;
|
|
|
|
conf->data = NULL;
|
|
|
|
goto again;
|
|
|
|
}
|
2014-01-31 06:18:38 +08:00
|
|
|
return nfserr_resource;
|
2014-03-11 00:19:10 +08:00
|
|
|
}
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, ld->ld_start);
|
|
|
|
p = xdr_encode_hyper(p, ld->ld_length);
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(ld->ld_type);
|
2011-08-31 10:15:47 +08:00
|
|
|
if (conf->len) {
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8);
|
|
|
|
p = xdr_encode_opaque(p, conf->data, conf->len);
|
2014-07-07 22:10:56 +08:00
|
|
|
kfree(conf->data);
|
2005-04-17 06:20:36 +08:00
|
|
|
} else { /* non - nfsv4 lock in conflict, no clientid nor owner */
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, (u64)0); /* clientid */
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0); /* length of owner name */
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2014-01-31 06:18:38 +08:00
|
|
|
return nfserr_denied;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
|
2008-08-13 01:45:07 +08:00
|
|
|
if (!nfserr)
|
2014-01-31 06:18:38 +08:00
|
|
|
nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid);
|
2008-08-13 01:45:07 +08:00
|
|
|
else if (nfserr == nfserr_denied)
|
2014-01-31 06:18:38 +08:00
|
|
|
nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied);
|
2014-07-07 22:10:56 +08:00
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
return nfserr;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (nfserr == nfserr_denied)
|
2014-01-31 06:18:38 +08:00
|
|
|
nfsd4_encode_lock_denied(xdr, &lockt->lt_denied);
|
2008-07-04 19:38:33 +08:00
|
|
|
return nfserr;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfsd4_encode_stateid(xdr, &locku->lu_stateid);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
p = xdr_reserve_space(xdr, 20);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
p = encode_cinfo(p, &link->li_cinfo);
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid);
|
|
|
|
if (nfserr)
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr;
|
2015-07-30 21:55:30 +08:00
|
|
|
p = xdr_reserve_space(xdr, 24);
|
2014-01-31 06:18:38 +08:00
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 06:48:39 +08:00
|
|
|
p = encode_cinfo(p, &open->op_cinfo);
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(open->op_rflags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-07-30 21:55:30 +08:00
|
|
|
nfserr = nfsd4_encode_bitmap(xdr, open->op_bmval[0], open->op_bmval[1],
|
|
|
|
open->op_bmval[2]);
|
|
|
|
if (nfserr)
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr;
|
2015-07-30 21:55:30 +08:00
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
*p++ = cpu_to_be32(open->op_delegate_type);
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (open->op_delegate_type) {
|
|
|
|
case NFS4_OPEN_DELEGATE_NONE:
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_DELEGATE_READ:
|
2014-01-31 06:18:38 +08:00
|
|
|
nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
p = xdr_reserve_space(xdr, 20);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(open->op_recall);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: ACE's in delegations
|
|
|
|
*/
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
|
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
*p++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case NFS4_OPEN_DELEGATE_WRITE:
|
2014-01-31 06:18:38 +08:00
|
|
|
nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
p = xdr_reserve_space(xdr, 32);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: space_limit's in delegations
|
|
|
|
*/
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(NFS4_LIMIT_SIZE);
|
|
|
|
*p++ = cpu_to_be32(~(u32)0);
|
|
|
|
*p++ = cpu_to_be32(~(u32)0);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: ACE's in delegations
|
|
|
|
*/
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
|
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
*p++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
2012-02-17 02:57:17 +08:00
|
|
|
case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */
|
|
|
|
switch (open->op_why_no_deleg) {
|
|
|
|
case WND4_CONTENTION:
|
|
|
|
case WND4_RESOURCE:
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(open->op_why_no_deleg);
|
|
|
|
/* deleg signaling not supported yet: */
|
|
|
|
*p++ = cpu_to_be32(0);
|
2012-02-17 02:57:17 +08:00
|
|
|
break;
|
|
|
|
default:
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(open->op_why_no_deleg);
|
2012-02-17 02:57:17 +08:00
|
|
|
}
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
/* XXX save filehandle here */
|
2017-05-06 23:12:04 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfsd4_encode_stateid(xdr, &od->od_stateid);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2014-03-19 05:01:51 +08:00
|
|
|
static __be32 nfsd4_encode_splice_read(
|
|
|
|
struct nfsd4_compoundres *resp,
|
|
|
|
struct nfsd4_read *read,
|
|
|
|
struct file *file, unsigned long maxcount)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-08-28 09:32:25 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2014-05-14 04:32:04 +08:00
|
|
|
struct xdr_buf *buf = xdr->buf;
|
2014-03-19 05:01:51 +08:00
|
|
|
u32 eof;
|
2014-05-20 04:18:23 +08:00
|
|
|
int space_left;
|
2014-03-19 05:01:51 +08:00
|
|
|
__be32 nfserr;
|
2014-05-14 05:27:03 +08:00
|
|
|
__be32 *p = xdr->p - 2;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-07-09 21:51:27 +08:00
|
|
|
/* Make sure there will be room for padding if needed */
|
|
|
|
if (xdr->end - xdr->p < 1)
|
2014-01-31 06:18:38 +08:00
|
|
|
return nfserr_resource;
|
2014-03-19 05:01:51 +08:00
|
|
|
|
2018-03-29 01:29:11 +08:00
|
|
|
nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp,
|
2019-08-27 01:03:11 +08:00
|
|
|
file, read->rd_offset, &maxcount, &eof);
|
2018-03-29 01:29:11 +08:00
|
|
|
read->rd_length = maxcount;
|
2014-03-19 05:01:51 +08:00
|
|
|
if (nfserr) {
|
|
|
|
/*
|
|
|
|
* nfsd_splice_actor may have already messed with the
|
|
|
|
* page length; reset it so as not to confuse
|
|
|
|
* xdr_truncate_encode:
|
|
|
|
*/
|
2014-05-14 04:32:04 +08:00
|
|
|
buf->page_len = 0;
|
2014-03-19 05:01:51 +08:00
|
|
|
return nfserr;
|
2014-02-04 23:36:59 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-05-14 05:27:03 +08:00
|
|
|
*(p++) = htonl(eof);
|
|
|
|
*(p++) = htonl(maxcount);
|
2014-03-19 05:01:51 +08:00
|
|
|
|
2014-05-14 04:32:04 +08:00
|
|
|
buf->page_len = maxcount;
|
|
|
|
buf->len += maxcount;
|
2014-09-25 04:32:34 +08:00
|
|
|
xdr->page_ptr += (buf->page_base + maxcount + PAGE_SIZE - 1)
|
|
|
|
/ PAGE_SIZE;
|
2014-03-19 05:01:51 +08:00
|
|
|
|
|
|
|
/* Use rest of head for padding and remaining ops: */
|
2014-05-14 04:32:04 +08:00
|
|
|
buf->tail[0].iov_base = xdr->p;
|
|
|
|
buf->tail[0].iov_len = 0;
|
2014-05-14 05:27:03 +08:00
|
|
|
xdr->iov = buf->tail;
|
2014-03-19 05:01:51 +08:00
|
|
|
if (maxcount&3) {
|
2014-05-14 05:27:03 +08:00
|
|
|
int pad = 4 - (maxcount&3);
|
|
|
|
|
|
|
|
*(xdr->p++) = 0;
|
|
|
|
|
2014-05-14 04:32:04 +08:00
|
|
|
buf->tail[0].iov_base += maxcount&3;
|
2014-05-14 05:27:03 +08:00
|
|
|
buf->tail[0].iov_len = pad;
|
|
|
|
buf->len += pad;
|
2014-02-04 23:36:59 +08:00
|
|
|
}
|
2013-08-27 04:04:46 +08:00
|
|
|
|
2014-03-19 05:01:51 +08:00
|
|
|
space_left = min_t(int, (void *)xdr->end - (void *)xdr->p,
|
2014-05-14 04:32:04 +08:00
|
|
|
buf->buflen - buf->len);
|
|
|
|
buf->buflen = buf->len + space_left;
|
2014-03-19 05:01:51 +08:00
|
|
|
xdr->end = (__be32 *)((void *)xdr->end + space_left);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp,
|
|
|
|
struct nfsd4_read *read,
|
|
|
|
struct file *file, unsigned long maxcount)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
u32 eof;
|
|
|
|
int v;
|
|
|
|
int starting_len = xdr->buf->len - 8;
|
|
|
|
long len;
|
2014-03-19 05:44:10 +08:00
|
|
|
int thislen;
|
2014-03-19 05:01:51 +08:00
|
|
|
__be32 nfserr;
|
|
|
|
__be32 tmp;
|
|
|
|
__be32 *p;
|
2014-03-19 05:44:10 +08:00
|
|
|
int pad;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2020-03-03 03:45:53 +08:00
|
|
|
/*
|
|
|
|
* svcrdma requires every READ payload to start somewhere
|
|
|
|
* in xdr->pages.
|
|
|
|
*/
|
|
|
|
if (xdr->iov == xdr->buf->head) {
|
|
|
|
xdr->iov = NULL;
|
|
|
|
xdr->end = xdr->p;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
len = maxcount;
|
|
|
|
v = 0;
|
2014-03-19 05:44:10 +08:00
|
|
|
while (len) {
|
2014-03-12 04:51:23 +08:00
|
|
|
thislen = min_t(long, len, PAGE_SIZE);
|
2020-03-03 04:00:04 +08:00
|
|
|
p = xdr_reserve_space(xdr, thislen);
|
2014-03-19 05:44:10 +08:00
|
|
|
WARN_ON_ONCE(!p);
|
|
|
|
resp->rqstp->rq_vec[v].iov_base = p;
|
2014-03-12 04:51:23 +08:00
|
|
|
resp->rqstp->rq_vec[v].iov_len = thislen;
|
2005-04-17 06:20:36 +08:00
|
|
|
v++;
|
2014-03-12 04:51:23 +08:00
|
|
|
len -= thislen;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
read->rd_vlen = v;
|
|
|
|
|
2018-03-29 01:29:11 +08:00
|
|
|
nfserr = nfsd_readv(resp->rqstp, read->rd_fhp, file, read->rd_offset,
|
2019-08-27 01:03:11 +08:00
|
|
|
resp->rqstp->rq_vec, read->rd_vlen, &maxcount,
|
|
|
|
&eof);
|
2018-03-29 01:29:11 +08:00
|
|
|
read->rd_length = maxcount;
|
2014-03-19 05:01:51 +08:00
|
|
|
if (nfserr)
|
2005-04-17 06:20:36 +08:00
|
|
|
return nfserr;
|
2020-03-03 03:45:53 +08:00
|
|
|
if (svc_encode_read_payload(resp->rqstp, starting_len + 8, maxcount))
|
|
|
|
return nfserr_io;
|
2020-03-03 04:00:04 +08:00
|
|
|
xdr_truncate_encode(xdr, starting_len + 8 + xdr_align_size(maxcount));
|
2014-03-19 05:01:51 +08:00
|
|
|
|
|
|
|
tmp = htonl(eof);
|
|
|
|
write_bytes_to_xdr_buf(xdr->buf, starting_len , &tmp, 4);
|
|
|
|
tmp = htonl(maxcount);
|
|
|
|
write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4);
|
|
|
|
|
2020-03-03 04:00:04 +08:00
|
|
|
tmp = xdr_zero;
|
2014-03-19 05:44:10 +08:00
|
|
|
pad = (maxcount&3) ? 4 - (maxcount&3) : 0;
|
|
|
|
write_bytes_to_xdr_buf(xdr->buf, starting_len + 8 + maxcount,
|
2020-03-03 04:00:04 +08:00
|
|
|
&tmp, pad);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
2014-03-19 05:01:51 +08:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_read *read)
|
|
|
|
{
|
|
|
|
unsigned long maxcount;
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2019-08-19 02:18:54 +08:00
|
|
|
struct file *file;
|
2014-03-19 05:01:51 +08:00
|
|
|
int starting_len = xdr->buf->len;
|
|
|
|
__be32 *p;
|
|
|
|
|
2019-08-19 02:18:54 +08:00
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
file = read->rd_nf->nf_file;
|
|
|
|
|
2014-03-19 05:01:51 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8); /* eof flag and byte count */
|
|
|
|
if (!p) {
|
2014-11-19 20:51:18 +08:00
|
|
|
WARN_ON_ONCE(test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags));
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr_resource;
|
2014-03-19 05:01:51 +08:00
|
|
|
}
|
2015-06-18 22:45:02 +08:00
|
|
|
if (resp->xdr.buf->page_len &&
|
|
|
|
test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)) {
|
2014-03-19 05:44:10 +08:00
|
|
|
WARN_ON_ONCE(1);
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr_resource;
|
2014-03-19 05:01:51 +08:00
|
|
|
}
|
|
|
|
xdr_commit_encode(xdr);
|
|
|
|
|
|
|
|
maxcount = svc_max_payload(resp->rqstp);
|
2015-06-18 22:45:02 +08:00
|
|
|
maxcount = min_t(unsigned long, maxcount,
|
|
|
|
(xdr->buf->buflen - xdr->buf->len));
|
2014-06-10 18:08:19 +08:00
|
|
|
maxcount = min_t(unsigned long, maxcount, read->rd_length);
|
2014-03-19 05:01:51 +08:00
|
|
|
|
2015-06-18 22:45:02 +08:00
|
|
|
if (file->f_op->splice_read &&
|
|
|
|
test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags))
|
2015-06-18 22:45:01 +08:00
|
|
|
nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount);
|
2014-03-19 05:01:51 +08:00
|
|
|
else
|
2015-06-18 22:45:01 +08:00
|
|
|
nfserr = nfsd4_encode_readv(resp, read, file, maxcount);
|
2014-03-19 05:01:51 +08:00
|
|
|
|
2015-06-18 22:45:01 +08:00
|
|
|
if (nfserr)
|
2014-03-19 05:01:51 +08:00
|
|
|
xdr_truncate_encode(xdr, starting_len);
|
2015-06-18 22:45:01 +08:00
|
|
|
|
|
|
|
return nfserr;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int maxcount;
|
2014-01-21 06:08:27 +08:00
|
|
|
__be32 wire_count;
|
|
|
|
int zero = 0;
|
2013-08-28 09:32:25 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2014-02-27 09:17:02 +08:00
|
|
|
int length_offset = xdr->buf->len;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-27 04:04:46 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2005-04-17 06:20:36 +08:00
|
|
|
maxcount = PAGE_SIZE;
|
2014-01-31 06:18:38 +08:00
|
|
|
|
2014-01-21 06:08:27 +08:00
|
|
|
p = xdr_reserve_space(xdr, maxcount);
|
|
|
|
if (!p)
|
2014-03-23 03:15:11 +08:00
|
|
|
return nfserr_resource;
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2016-12-09 23:45:04 +08:00
|
|
|
* XXX: By default, vfs_readlink() will truncate symlinks if they
|
|
|
|
* would overflow the buffer. Is this kosher in NFSv4? If not, one
|
|
|
|
* easy fix is: if vfs_readlink() precisely fills the buffer, assume
|
|
|
|
* that truncation occurred, and return NFS4ERR_RESOURCE.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2014-01-21 06:08:27 +08:00
|
|
|
nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp,
|
|
|
|
(char *)p, &maxcount);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (nfserr == nfserr_isdir)
|
2014-02-27 06:00:38 +08:00
|
|
|
nfserr = nfserr_inval;
|
|
|
|
if (nfserr) {
|
2014-02-27 09:17:02 +08:00
|
|
|
xdr_truncate_encode(xdr, length_offset);
|
2005-04-17 06:20:36 +08:00
|
|
|
return nfserr;
|
2014-02-27 06:00:38 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-01-21 06:08:27 +08:00
|
|
|
wire_count = htonl(maxcount);
|
|
|
|
write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, 4);
|
2014-06-26 22:23:12 +08:00
|
|
|
xdr_truncate_encode(xdr, length_offset + 4 + ALIGN(maxcount, 4));
|
2014-01-21 06:08:27 +08:00
|
|
|
if (maxcount & 3)
|
|
|
|
write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount,
|
|
|
|
&zero, 4 - (maxcount&3));
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-20 14:28:59 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int maxcount;
|
2014-01-21 05:37:11 +08:00
|
|
|
int bytes_left;
|
2005-04-17 06:20:36 +08:00
|
|
|
loff_t offset;
|
2014-01-21 05:37:11 +08:00
|
|
|
__be64 wire_offset;
|
2013-08-28 09:32:25 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2014-02-27 09:17:02 +08:00
|
|
|
int starting_len = xdr->buf->len;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
*p++ = cpu_to_be32(0);
|
2014-01-16 04:17:58 +08:00
|
|
|
resp->xdr.buf->head[0].iov_len = ((char *)resp->xdr.p)
|
|
|
|
- (char *)resp->xdr.buf->head[0].iov_base;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
2014-01-21 05:37:11 +08:00
|
|
|
* Number of bytes left for directory entries allowing for the
|
|
|
|
* final 8 bytes of the readdir and a following failed op:
|
|
|
|
*/
|
|
|
|
bytes_left = xdr->buf->buflen - xdr->buf->len
|
|
|
|
- COMPOUND_ERR_SLACK_SPACE - 8;
|
|
|
|
if (bytes_left < 0) {
|
|
|
|
nfserr = nfserr_resource;
|
|
|
|
goto err_no_verf;
|
|
|
|
}
|
2018-05-07 21:01:08 +08:00
|
|
|
maxcount = svc_max_payload(resp->rqstp);
|
|
|
|
maxcount = min_t(u32, readdir->rd_maxcount, maxcount);
|
2014-01-21 05:37:11 +08:00
|
|
|
/*
|
|
|
|
* Note the rfc defines rd_maxcount as the size of the
|
|
|
|
* READDIR4resok structure, which includes the verifier above
|
|
|
|
* and the 8 bytes encoded at the end of this function:
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2014-01-21 05:37:11 +08:00
|
|
|
if (maxcount < 16) {
|
|
|
|
nfserr = nfserr_toosmall;
|
2005-04-17 06:20:36 +08:00
|
|
|
goto err_no_verf;
|
|
|
|
}
|
2014-01-21 05:37:11 +08:00
|
|
|
maxcount = min_t(int, maxcount-16, bytes_left);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-08-21 02:49:50 +08:00
|
|
|
/* RFC 3530 14.2.24 allows us to ignore dircount when it's 0: */
|
|
|
|
if (!readdir->rd_dircount)
|
2018-05-07 21:01:08 +08:00
|
|
|
readdir->rd_dircount = svc_max_payload(resp->rqstp);
|
2014-08-21 02:49:50 +08:00
|
|
|
|
2014-01-21 05:37:11 +08:00
|
|
|
readdir->xdr = xdr;
|
|
|
|
readdir->rd_maxcount = maxcount;
|
2005-04-17 06:20:36 +08:00
|
|
|
readdir->common.err = 0;
|
2014-01-21 05:37:11 +08:00
|
|
|
readdir->cookie_offset = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
offset = readdir->rd_cookie;
|
|
|
|
nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp,
|
|
|
|
&offset,
|
|
|
|
&readdir->common, nfsd4_encode_dirent);
|
|
|
|
if (nfserr == nfs_ok &&
|
|
|
|
readdir->common.err == nfserr_toosmall &&
|
2014-01-21 05:37:11 +08:00
|
|
|
xdr->buf->len == starting_len + 8) {
|
|
|
|
/* nothing encoded; which limit did we hit?: */
|
|
|
|
if (maxcount - 16 < bytes_left)
|
|
|
|
/* It was the fault of rd_maxcount: */
|
|
|
|
nfserr = nfserr_toosmall;
|
|
|
|
else
|
|
|
|
/* We ran out of buffer space: */
|
|
|
|
nfserr = nfserr_resource;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
if (nfserr)
|
|
|
|
goto err_no_verf;
|
|
|
|
|
2014-01-21 05:37:11 +08:00
|
|
|
if (readdir->cookie_offset) {
|
|
|
|
wire_offset = cpu_to_be64(offset);
|
|
|
|
write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset,
|
|
|
|
&wire_offset, 8);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-01-21 05:37:11 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p) {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
goto err_no_verf;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
*p++ = 0; /* no more entries */
|
|
|
|
*p++ = htonl(readdir->common.err == nfserr_eof);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err_no_verf:
|
2014-02-27 09:17:02 +08:00
|
|
|
xdr_truncate_encode(xdr, starting_len);
|
2005-04-17 06:20:36 +08:00
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
p = xdr_reserve_space(xdr, 20);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
p = encode_cinfo(p, &remove->rm_cinfo);
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
p = xdr_reserve_space(xdr, 40);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
p = encode_cinfo(p, &rename->rn_sinfo);
|
|
|
|
p = encode_cinfo(p, &rename->rn_tinfo);
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2017-05-06 23:12:04 +08:00
|
|
|
nfsd4_do_encode_secinfo(struct xdr_stream *xdr, struct svc_export *exp)
|
2007-07-17 19:04:51 +08:00
|
|
|
{
|
2013-05-01 06:48:54 +08:00
|
|
|
u32 i, nflavs, supported;
|
2007-07-17 19:04:51 +08:00
|
|
|
struct exp_flavor_info *flavs;
|
|
|
|
struct exp_flavor_info def_flavs[2];
|
2013-05-01 06:48:54 +08:00
|
|
|
__be32 *p, *flavorsp;
|
|
|
|
static bool report = true;
|
2007-07-17 19:04:51 +08:00
|
|
|
|
2007-07-17 19:04:51 +08:00
|
|
|
if (exp->ex_nflavors) {
|
|
|
|
flavs = exp->ex_flavors;
|
|
|
|
nflavs = exp->ex_nflavors;
|
|
|
|
} else { /* Handling of some defaults in absence of real secinfo: */
|
|
|
|
flavs = def_flavs;
|
|
|
|
if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {
|
|
|
|
nflavs = 2;
|
|
|
|
flavs[0].pseudoflavor = RPC_AUTH_UNIX;
|
|
|
|
flavs[1].pseudoflavor = RPC_AUTH_NULL;
|
|
|
|
} else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {
|
|
|
|
nflavs = 1;
|
|
|
|
flavs[0].pseudoflavor
|
|
|
|
= svcauth_gss_flavor(exp->ex_client);
|
|
|
|
} else {
|
|
|
|
nflavs = 1;
|
|
|
|
flavs[0].pseudoflavor
|
|
|
|
= exp->ex_client->flavour->flavour;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-01 06:48:54 +08:00
|
|
|
supported = 0;
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr_resource;
|
2013-05-01 06:48:54 +08:00
|
|
|
flavorsp = p++; /* to be backfilled later */
|
|
|
|
|
2007-07-17 19:04:51 +08:00
|
|
|
for (i = 0; i < nflavs; i++) {
|
2013-05-01 06:48:54 +08:00
|
|
|
rpc_authflavor_t pf = flavs[i].pseudoflavor;
|
2013-03-17 03:55:10 +08:00
|
|
|
struct rpcsec_gss_info info;
|
2007-07-17 19:04:51 +08:00
|
|
|
|
2013-05-01 06:48:54 +08:00
|
|
|
if (rpcauth_get_gssinfo(pf, &info) == 0) {
|
|
|
|
supported++;
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4 + 4 +
|
|
|
|
XDR_LEN(info.oid.len) + 4 + 4);
|
|
|
|
if (!p)
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(RPC_AUTH_GSS);
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque(p, info.oid.data, info.oid.len);
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(info.qop);
|
|
|
|
*p++ = cpu_to_be32(info.service);
|
2013-05-01 06:48:54 +08:00
|
|
|
} else if (pf < RPC_AUTH_MAXFLAVOR) {
|
|
|
|
supported++;
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(pf);
|
2013-05-01 06:48:54 +08:00
|
|
|
} else {
|
|
|
|
if (report)
|
|
|
|
pr_warn("NFS: SECINFO: security flavor %u "
|
|
|
|
"is not supported\n", pf);
|
2007-07-17 19:04:51 +08:00
|
|
|
}
|
|
|
|
}
|
2013-03-17 03:55:10 +08:00
|
|
|
|
2013-05-01 06:48:54 +08:00
|
|
|
if (nflavs != supported)
|
|
|
|
report = false;
|
|
|
|
*flavorsp = htonl(supported);
|
2017-05-06 23:12:04 +08:00
|
|
|
return 0;
|
2007-07-17 19:04:51 +08:00
|
|
|
}
|
|
|
|
|
2010-12-27 14:29:57 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_secinfo *secinfo)
|
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfsd4_do_encode_secinfo(xdr, secinfo->si_exp);
|
2010-12-27 14:29:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_secinfo_no_name *secinfo)
|
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfsd4_do_encode_secinfo(xdr, secinfo->sin_exp);
|
2010-12-27 14:29:57 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* The SETATTR encode routine is special -- it always encodes a bitmap,
|
|
|
|
* regardless of the error status.
|
|
|
|
*/
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 16);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (nfserr) {
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(3);
|
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
*p++ = cpu_to_be32(0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
else {
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(3);
|
|
|
|
*p++ = cpu_to_be32(setattr->sa_bmval[0]);
|
|
|
|
*p++ = cpu_to_be32(setattr->sa_bmval[1]);
|
|
|
|
*p++ = cpu_to_be32(setattr->sa_bmval[2]);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-07-04 19:38:33 +08:00
|
|
|
return nfserr;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!nfserr) {
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8 + NFS4_VERIFIER_SIZE);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque_fixed(p, &scd->se_clientid, 8);
|
|
|
|
p = xdr_encode_opaque_fixed(p, &scd->se_confirm,
|
|
|
|
NFS4_VERIFIER_SIZE);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
else if (nfserr == nfserr_clid_inuse) {
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
*p++ = cpu_to_be32(0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-07-04 19:38:33 +08:00
|
|
|
return nfserr;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
2006-10-20 14:28:59 +08:00
|
|
|
nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
p = xdr_reserve_space(xdr, 16);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
*p++ = cpu_to_be32(write->wr_bytes_written);
|
|
|
|
*p++ = cpu_to_be32(write->wr_how_written);
|
|
|
|
p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
|
|
|
|
NFS4_VERIFIER_SIZE);
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-04-03 13:27:55 +08:00
|
|
|
static __be32
|
2012-04-26 05:58:50 +08:00
|
|
|
nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
|
2009-04-03 13:27:55 +08:00
|
|
|
struct nfsd4_exchange_id *exid)
|
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2009-04-03 13:28:01 +08:00
|
|
|
char *major_id;
|
|
|
|
char *server_scope;
|
|
|
|
int major_id_sz;
|
|
|
|
int server_scope_sz;
|
|
|
|
uint64_t minor_id = 0;
|
2020-02-20 04:52:15 +08:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), nfsd_net_id);
|
2009-04-03 13:28:01 +08:00
|
|
|
|
2020-02-20 04:52:15 +08:00
|
|
|
major_id = nn->nfsd_name;
|
|
|
|
major_id_sz = strlen(nn->nfsd_name);
|
|
|
|
server_scope = nn->nfsd_name;
|
|
|
|
server_scope_sz = strlen(nn->nfsd_name);
|
2009-04-03 13:28:01 +08:00
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr,
|
2009-04-03 13:28:01 +08:00
|
|
|
8 /* eir_clientid */ +
|
|
|
|
4 /* eir_sequenceid */ +
|
|
|
|
4 /* eir_flags */ +
|
2013-12-10 15:24:36 +08:00
|
|
|
4 /* spr_how */);
|
2014-01-31 06:18:38 +08:00
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2009-04-03 13:28:01 +08:00
|
|
|
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque_fixed(p, &exid->clientid, 8);
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(exid->seqid);
|
|
|
|
*p++ = cpu_to_be32(exid->flags);
|
2009-04-03 13:28:01 +08:00
|
|
|
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(exid->spa_how);
|
2013-12-10 15:24:36 +08:00
|
|
|
|
2013-04-14 02:27:29 +08:00
|
|
|
switch (exid->spa_how) {
|
|
|
|
case SP4_NONE:
|
|
|
|
break;
|
|
|
|
case SP4_MACH_CRED:
|
|
|
|
/* spo_must_enforce bitmap: */
|
2017-05-06 23:12:04 +08:00
|
|
|
nfserr = nfsd4_encode_bitmap(xdr,
|
2016-06-16 00:52:09 +08:00
|
|
|
exid->spo_must_enforce[0],
|
|
|
|
exid->spo_must_enforce[1],
|
|
|
|
exid->spo_must_enforce[2]);
|
2017-05-06 23:12:04 +08:00
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
2016-06-16 00:52:09 +08:00
|
|
|
/* spo_must_allow bitmap: */
|
2017-05-06 23:12:04 +08:00
|
|
|
nfserr = nfsd4_encode_bitmap(xdr,
|
2016-06-16 00:52:09 +08:00
|
|
|
exid->spo_must_allow[0],
|
|
|
|
exid->spo_must_allow[1],
|
|
|
|
exid->spo_must_allow[2]);
|
2017-05-06 23:12:04 +08:00
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
2013-04-14 02:27:29 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
}
|
2009-04-03 13:28:01 +08:00
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr,
|
2013-12-10 15:24:36 +08:00
|
|
|
8 /* so_minor_id */ +
|
|
|
|
4 /* so_major_id.len */ +
|
|
|
|
(XDR_QUADLEN(major_id_sz) * 4) +
|
|
|
|
4 /* eir_server_scope.len */ +
|
|
|
|
(XDR_QUADLEN(server_scope_sz) * 4) +
|
|
|
|
4 /* eir_server_impl_id.count (0) */);
|
2014-01-31 06:18:38 +08:00
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2013-12-10 15:24:36 +08:00
|
|
|
|
2009-04-03 13:28:01 +08:00
|
|
|
/* The server_owner struct */
|
2014-03-23 05:11:35 +08:00
|
|
|
p = xdr_encode_hyper(p, minor_id); /* Minor id */
|
2009-04-03 13:28:01 +08:00
|
|
|
/* major id */
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque(p, major_id, major_id_sz);
|
2009-04-03 13:28:01 +08:00
|
|
|
|
|
|
|
/* Server scope */
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque(p, server_scope, server_scope_sz);
|
2009-04-03 13:28:01 +08:00
|
|
|
|
|
|
|
/* Implementation id */
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0); /* zero length nfs_impl_id4 array */
|
2009-04-03 13:28:01 +08:00
|
|
|
return 0;
|
2009-04-03 13:27:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
2012-04-26 05:58:50 +08:00
|
|
|
nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,
|
2009-04-03 13:27:55 +08:00
|
|
|
struct nfsd4_create_session *sess)
|
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2009-04-03 13:28:28 +08:00
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 24);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque_fixed(p, sess->sessionid.data,
|
|
|
|
NFS4_MAX_SESSIONID_LEN);
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(sess->seqid);
|
|
|
|
*p++ = cpu_to_be32(sess->flags);
|
2009-04-03 13:28:28 +08:00
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 28);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0); /* headerpadsz */
|
|
|
|
*p++ = cpu_to_be32(sess->fore_channel.maxreq_sz);
|
|
|
|
*p++ = cpu_to_be32(sess->fore_channel.maxresp_sz);
|
|
|
|
*p++ = cpu_to_be32(sess->fore_channel.maxresp_cached);
|
|
|
|
*p++ = cpu_to_be32(sess->fore_channel.maxops);
|
|
|
|
*p++ = cpu_to_be32(sess->fore_channel.maxreqs);
|
|
|
|
*p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs);
|
2009-04-03 13:28:28 +08:00
|
|
|
|
|
|
|
if (sess->fore_channel.nr_rdma_attrs) {
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(sess->fore_channel.rdma_attrs);
|
2009-04-03 13:28:28 +08:00
|
|
|
}
|
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 28);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(0); /* headerpadsz */
|
|
|
|
*p++ = cpu_to_be32(sess->back_channel.maxreq_sz);
|
|
|
|
*p++ = cpu_to_be32(sess->back_channel.maxresp_sz);
|
|
|
|
*p++ = cpu_to_be32(sess->back_channel.maxresp_cached);
|
|
|
|
*p++ = cpu_to_be32(sess->back_channel.maxops);
|
|
|
|
*p++ = cpu_to_be32(sess->back_channel.maxreqs);
|
|
|
|
*p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs);
|
2009-04-03 13:28:28 +08:00
|
|
|
|
|
|
|
if (sess->back_channel.nr_rdma_attrs) {
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(sess->back_channel.rdma_attrs);
|
2009-04-03 13:28:28 +08:00
|
|
|
}
|
|
|
|
return 0;
|
2009-04-03 13:27:55 +08:00
|
|
|
}
|
|
|
|
|
2011-05-16 22:38:14 +08:00
|
|
|
static __be32
|
2012-04-26 05:58:50 +08:00
|
|
|
nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,
|
2009-04-03 13:27:55 +08:00
|
|
|
struct nfsd4_sequence *seq)
|
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2009-04-03 13:28:08 +08:00
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 20);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque_fixed(p, seq->sessionid.data,
|
|
|
|
NFS4_MAX_SESSIONID_LEN);
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(seq->seqid);
|
|
|
|
*p++ = cpu_to_be32(seq->slotid);
|
2011-09-01 03:39:30 +08:00
|
|
|
/* Note slotid's are numbered from zero: */
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */
|
|
|
|
*p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */
|
|
|
|
*p++ = cpu_to_be32(seq->status_flags);
|
2009-04-03 13:28:08 +08:00
|
|
|
|
2014-03-22 05:57:57 +08:00
|
|
|
resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */
|
2009-04-03 13:28:08 +08:00
|
|
|
return 0;
|
2009-04-03 13:27:55 +08:00
|
|
|
}
|
|
|
|
|
2012-04-26 04:56:22 +08:00
|
|
|
static __be32
|
2012-04-26 05:58:50 +08:00
|
|
|
nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,
|
2011-07-13 22:50:48 +08:00
|
|
|
struct nfsd4_test_stateid *test_stateid)
|
|
|
|
{
|
2014-01-31 06:18:38 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2012-01-27 23:22:49 +08:00
|
|
|
struct nfsd4_test_stateid_id *stateid, *next;
|
2011-07-13 22:50:48 +08:00
|
|
|
__be32 *p;
|
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids));
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2011-07-13 22:50:48 +08:00
|
|
|
*p++ = htonl(test_stateid->ts_num_ids);
|
|
|
|
|
2012-01-27 23:22:49 +08:00
|
|
|
list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) {
|
2012-04-13 12:10:34 +08:00
|
|
|
*p++ = stateid->ts_id_status;
|
2011-07-13 22:50:48 +08:00
|
|
|
}
|
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
return 0;
|
2011-07-13 22:50:48 +08: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 19:11:59 +08:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
|
|
|
static __be32
|
|
|
|
nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_getdeviceinfo *gdev)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2017-05-06 04:17:57 +08:00
|
|
|
const struct nfsd4_layout_ops *ops;
|
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 19:11:59 +08:00
|
|
|
u32 starting_len = xdr->buf->len, needed_len;
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr_resource;
|
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 19:11:59 +08:00
|
|
|
|
|
|
|
*p++ = cpu_to_be32(gdev->gd_layout_type);
|
|
|
|
|
|
|
|
/* If maxcount is 0 then just update notifications */
|
|
|
|
if (gdev->gd_maxcount != 0) {
|
2017-05-06 04:17:57 +08:00
|
|
|
ops = nfsd4_layout_ops[gdev->gd_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 19:11:59 +08:00
|
|
|
nfserr = ops->encode_getdeviceinfo(xdr, gdev);
|
|
|
|
if (nfserr) {
|
|
|
|
/*
|
|
|
|
* We don't bother to burden the layout drivers with
|
|
|
|
* enforcing gd_maxcount, just tell the client to
|
|
|
|
* come back with a bigger buffer if it's not enough.
|
|
|
|
*/
|
|
|
|
if (xdr->buf->len + 4 > gdev->gd_maxcount)
|
|
|
|
goto toosmall;
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr;
|
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 19:11:59 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gdev->gd_notify_types) {
|
|
|
|
p = xdr_reserve_space(xdr, 4 + 4);
|
|
|
|
if (!p)
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr_resource;
|
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 19:11:59 +08:00
|
|
|
*p++ = cpu_to_be32(1); /* bitmap length */
|
|
|
|
*p++ = cpu_to_be32(gdev->gd_notify_types);
|
|
|
|
} else {
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr_resource;
|
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 19:11:59 +08:00
|
|
|
*p++ = 0;
|
|
|
|
}
|
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
return 0;
|
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 19:11:59 +08:00
|
|
|
toosmall:
|
|
|
|
dprintk("%s: maxcount too small\n", __func__);
|
|
|
|
needed_len = xdr->buf->len + 4 /* notifications */;
|
|
|
|
xdr_truncate_encode(xdr, starting_len);
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
2017-05-06 23:12:04 +08:00
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
*p++ = cpu_to_be32(needed_len);
|
|
|
|
return nfserr_toosmall;
|
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 19:11:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_encode_layoutget(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_layoutget *lgp)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2017-05-06 04:17:57 +08:00
|
|
|
const struct nfsd4_layout_ops *ops;
|
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 19:11:59 +08:00
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, 36 + sizeof(stateid_opaque_t));
|
|
|
|
if (!p)
|
2017-05-06 23:12:04 +08:00
|
|
|
return nfserr_resource;
|
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 19:11:59 +08:00
|
|
|
|
|
|
|
*p++ = cpu_to_be32(1); /* we always set return-on-close */
|
|
|
|
*p++ = cpu_to_be32(lgp->lg_sid.si_generation);
|
|
|
|
p = xdr_encode_opaque_fixed(p, &lgp->lg_sid.si_opaque,
|
|
|
|
sizeof(stateid_opaque_t));
|
|
|
|
|
|
|
|
*p++ = cpu_to_be32(1); /* we always return a single layout */
|
|
|
|
p = xdr_encode_hyper(p, lgp->lg_seg.offset);
|
|
|
|
p = xdr_encode_hyper(p, lgp->lg_seg.length);
|
|
|
|
*p++ = cpu_to_be32(lgp->lg_seg.iomode);
|
|
|
|
*p++ = cpu_to_be32(lgp->lg_layout_type);
|
|
|
|
|
2017-05-06 04:17:57 +08:00
|
|
|
ops = nfsd4_layout_ops[lgp->lg_layout_type];
|
2017-05-06 23:12:04 +08:00
|
|
|
return ops->encode_layoutget(xdr, lgp);
|
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 19:11:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_encode_layoutcommit(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_layoutcommit *lcp)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
*p++ = cpu_to_be32(lcp->lc_size_chg);
|
|
|
|
if (lcp->lc_size_chg) {
|
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
p = xdr_encode_hyper(p, lcp->lc_newsize);
|
|
|
|
}
|
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
return 0;
|
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 19:11:59 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_encode_layoutreturn(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_layoutreturn *lrp)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
*p++ = cpu_to_be32(lrp->lrs_present);
|
|
|
|
if (lrp->lrs_present)
|
2015-03-22 22:17:10 +08:00
|
|
|
return nfsd4_encode_stateid(xdr, &lrp->lr_sid);
|
2017-05-06 23:12:04 +08:00
|
|
|
return 0;
|
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 19:11:59 +08:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_NFSD_PNFS */
|
|
|
|
|
2016-09-08 03:57:30 +08:00
|
|
|
static __be32
|
2018-07-21 06:19:20 +08:00
|
|
|
nfsd42_encode_write_res(struct nfsd4_compoundres *resp,
|
|
|
|
struct nfsd42_write_res *write, bool sync)
|
2016-09-08 03:57:30 +08:00
|
|
|
{
|
|
|
|
__be32 *p;
|
2018-07-21 06:19:20 +08:00
|
|
|
p = xdr_reserve_space(&resp->xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
2016-09-08 03:57:30 +08:00
|
|
|
|
2018-07-21 06:19:20 +08:00
|
|
|
if (sync)
|
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
else {
|
|
|
|
__be32 nfserr;
|
|
|
|
*p++ = cpu_to_be32(1);
|
|
|
|
nfserr = nfsd4_encode_stateid(&resp->xdr, &write->cb_stateid);
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
p = xdr_reserve_space(&resp->xdr, 8 + 4 + NFS4_VERIFIER_SIZE);
|
2016-09-08 03:57:30 +08:00
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
p = xdr_encode_hyper(p, write->wr_bytes_written);
|
|
|
|
*p++ = cpu_to_be32(write->wr_stable_how);
|
|
|
|
p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
|
|
|
|
NFS4_VERIFIER_SIZE);
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2019-08-08 23:14:59 +08:00
|
|
|
static __be32
|
|
|
|
nfsd42_encode_nl4_server(struct nfsd4_compoundres *resp, struct nl4_server *ns)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
struct nfs42_netaddr *addr;
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
*p++ = cpu_to_be32(ns->nl4_type);
|
|
|
|
|
|
|
|
switch (ns->nl4_type) {
|
|
|
|
case NL4_NETADDR:
|
|
|
|
addr = &ns->u.nl4_addr;
|
|
|
|
|
|
|
|
/* netid_len, netid, uaddr_len, uaddr (port included
|
|
|
|
* in RPCBIND_MAXUADDRLEN)
|
|
|
|
*/
|
|
|
|
p = xdr_reserve_space(xdr,
|
|
|
|
4 /* netid len */ +
|
|
|
|
(XDR_QUADLEN(addr->netid_len) * 4) +
|
|
|
|
4 /* uaddr len */ +
|
|
|
|
(XDR_QUADLEN(addr->addr_len) * 4));
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
*p++ = cpu_to_be32(addr->netid_len);
|
|
|
|
p = xdr_encode_opaque_fixed(p, addr->netid,
|
|
|
|
addr->netid_len);
|
|
|
|
*p++ = cpu_to_be32(addr->addr_len);
|
|
|
|
p = xdr_encode_opaque_fixed(p, addr->addr,
|
|
|
|
addr->addr_len);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN_ON_ONCE(ns->nl4_type != NL4_NETADDR);
|
|
|
|
return nfserr_inval;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-09-08 03:57:30 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_copy *copy)
|
|
|
|
{
|
|
|
|
__be32 *p;
|
|
|
|
|
2018-07-21 06:19:20 +08:00
|
|
|
nfserr = nfsd42_encode_write_res(resp, ©->cp_res,
|
|
|
|
copy->cp_synchronous);
|
2017-05-06 23:12:04 +08:00
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
2016-09-08 03:57:30 +08:00
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
p = xdr_reserve_space(&resp->xdr, 4 + 4);
|
2018-03-08 04:37:35 +08:00
|
|
|
*p++ = xdr_one; /* cr_consecutive */
|
2017-05-06 23:12:04 +08:00
|
|
|
*p++ = cpu_to_be32(copy->cp_synchronous);
|
|
|
|
return 0;
|
2016-09-08 03:57:30 +08:00
|
|
|
}
|
|
|
|
|
2018-07-21 06:19:18 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_offload_status(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_offload_status *os)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, 8 + 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
p = xdr_encode_hyper(p, os->count);
|
|
|
|
*p++ = cpu_to_be32(0);
|
|
|
|
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2019-08-08 23:14:59 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_copy_notify(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_copy_notify *cn)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
|
|
|
|
/* 8 sec, 4 nsec */
|
|
|
|
p = xdr_reserve_space(xdr, 12);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
/* cnr_lease_time */
|
|
|
|
p = xdr_encode_hyper(p, cn->cpn_sec);
|
|
|
|
*p++ = cpu_to_be32(cn->cpn_nsec);
|
|
|
|
|
|
|
|
/* cnr_stateid */
|
|
|
|
nfserr = nfsd4_encode_stateid(xdr, &cn->cpn_cnr_stateid);
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
|
|
|
|
/* cnr_src.nl_nsvr */
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
*p++ = cpu_to_be32(1);
|
|
|
|
|
|
|
|
return nfsd42_encode_nl4_server(resp, &cn->cpn_src);
|
|
|
|
}
|
|
|
|
|
2014-09-27 01:58:27 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_seek(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_seek *seek)
|
|
|
|
{
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
p = xdr_reserve_space(&resp->xdr, 4 + 8);
|
|
|
|
*p++ = cpu_to_be32(seek->seek_eof);
|
|
|
|
p = xdr_encode_hyper(p, seek->seek_pos);
|
|
|
|
|
2017-05-06 23:12:04 +08:00
|
|
|
return 0;
|
2014-09-27 01:58:27 +08:00
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p)
|
|
|
|
{
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2020-06-24 06:39:26 +08:00
|
|
|
/*
|
|
|
|
* Encode kmalloc-ed buffer in to XDR stream.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
nfsd4_vbuf_to_stream(struct xdr_stream *xdr, char *buf, u32 buflen)
|
|
|
|
{
|
|
|
|
u32 cplen;
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
cplen = min_t(unsigned long, buflen,
|
|
|
|
((void *)xdr->end - (void *)xdr->p));
|
|
|
|
p = xdr_reserve_space(xdr, cplen);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
memcpy(p, buf, cplen);
|
|
|
|
buf += cplen;
|
|
|
|
buflen -= cplen;
|
|
|
|
|
|
|
|
while (buflen) {
|
|
|
|
cplen = min_t(u32, buflen, PAGE_SIZE);
|
|
|
|
p = xdr_reserve_space(xdr, cplen);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
memcpy(p, buf, cplen);
|
|
|
|
|
|
|
|
if (cplen < PAGE_SIZE) {
|
|
|
|
/*
|
|
|
|
* We're done, with a length that wasn't page
|
|
|
|
* aligned, so possibly not word aligned. Pad
|
|
|
|
* any trailing bytes with 0.
|
|
|
|
*/
|
|
|
|
xdr_encode_opaque_fixed(p, NULL, cplen);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
buflen -= PAGE_SIZE;
|
|
|
|
buf += PAGE_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_encode_getxattr(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_getxattr *getxattr)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
__be32 *p, err;
|
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
*p = cpu_to_be32(getxattr->getxa_len);
|
|
|
|
|
|
|
|
if (getxattr->getxa_len == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err = nfsd4_vbuf_to_stream(xdr, getxattr->getxa_buf,
|
|
|
|
getxattr->getxa_len);
|
|
|
|
|
|
|
|
kvfree(getxattr->getxa_buf);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_encode_setxattr(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_setxattr *setxattr)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, 20);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
encode_cinfo(p, &setxattr->setxa_cinfo);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if there are cookie values that can be rejected outright.
|
|
|
|
*/
|
|
|
|
static __be32
|
|
|
|
nfsd4_listxattr_validate_cookie(struct nfsd4_listxattrs *listxattrs,
|
|
|
|
u32 *offsetp)
|
|
|
|
{
|
|
|
|
u64 cookie = listxattrs->lsxa_cookie;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the cookie is larger than the maximum number we can fit
|
|
|
|
* in either the buffer we just got back from vfs_listxattr, or,
|
|
|
|
* XDR-encoded, in the return buffer, it's invalid.
|
|
|
|
*/
|
|
|
|
if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2))
|
|
|
|
return nfserr_badcookie;
|
|
|
|
|
|
|
|
if (cookie > (listxattrs->lsxa_maxcount /
|
|
|
|
(XDR_QUADLEN(XATTR_USER_PREFIX_LEN + 2) + 4)))
|
|
|
|
return nfserr_badcookie;
|
|
|
|
|
|
|
|
*offsetp = (u32)cookie;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_encode_listxattrs(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_listxattrs *listxattrs)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
u32 cookie_offset, count_offset, eof;
|
|
|
|
u32 left, xdrleft, slen, count;
|
|
|
|
u32 xdrlen, offset;
|
|
|
|
u64 cookie;
|
|
|
|
char *sp;
|
|
|
|
__be32 status;
|
|
|
|
__be32 *p;
|
|
|
|
u32 nuser;
|
|
|
|
|
|
|
|
eof = 1;
|
|
|
|
|
|
|
|
status = nfsd4_listxattr_validate_cookie(listxattrs, &offset);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reserve space for the cookie and the name array count. Record
|
|
|
|
* the offsets to save them later.
|
|
|
|
*/
|
|
|
|
cookie_offset = xdr->buf->len;
|
|
|
|
count_offset = cookie_offset + 8;
|
|
|
|
p = xdr_reserve_space(xdr, 12);
|
|
|
|
if (!p) {
|
|
|
|
status = nfserr_resource;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
left = listxattrs->lsxa_len;
|
|
|
|
sp = listxattrs->lsxa_buf;
|
|
|
|
nuser = 0;
|
|
|
|
|
|
|
|
xdrleft = listxattrs->lsxa_maxcount;
|
|
|
|
|
|
|
|
while (left > 0 && xdrleft > 0) {
|
|
|
|
slen = strlen(sp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if this a user. attribute, skip it if not.
|
|
|
|
*/
|
|
|
|
if (strncmp(sp, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN))
|
|
|
|
goto contloop;
|
|
|
|
|
|
|
|
slen -= XATTR_USER_PREFIX_LEN;
|
|
|
|
xdrlen = 4 + ((slen + 3) & ~3);
|
|
|
|
if (xdrlen > xdrleft) {
|
|
|
|
if (count == 0) {
|
|
|
|
/*
|
|
|
|
* Can't even fit the first attribute name.
|
|
|
|
*/
|
|
|
|
status = nfserr_toosmall;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
eof = 0;
|
|
|
|
goto wreof;
|
|
|
|
}
|
|
|
|
|
|
|
|
left -= XATTR_USER_PREFIX_LEN;
|
|
|
|
sp += XATTR_USER_PREFIX_LEN;
|
|
|
|
if (nuser++ < offset)
|
|
|
|
goto contloop;
|
|
|
|
|
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, xdrlen);
|
|
|
|
if (!p) {
|
|
|
|
status = nfserr_resource;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = xdr_encode_opaque(p, sp, slen);
|
|
|
|
|
|
|
|
xdrleft -= xdrlen;
|
|
|
|
count++;
|
|
|
|
contloop:
|
|
|
|
sp += slen + 1;
|
|
|
|
left -= slen + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there were user attributes to copy, but we didn't copy
|
|
|
|
* any, the offset was too large (e.g. the cookie was invalid).
|
|
|
|
*/
|
|
|
|
if (nuser > 0 && count == 0) {
|
|
|
|
status = nfserr_badcookie;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
wreof:
|
|
|
|
p = xdr_reserve_space(xdr, 4);
|
|
|
|
if (!p) {
|
|
|
|
status = nfserr_resource;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
*p = cpu_to_be32(eof);
|
|
|
|
|
|
|
|
cookie = offset + count;
|
|
|
|
|
|
|
|
write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &cookie, 8);
|
|
|
|
count = htonl(count);
|
|
|
|
write_bytes_to_xdr_buf(xdr->buf, count_offset, &count, 4);
|
|
|
|
out:
|
|
|
|
if (listxattrs->lsxa_len)
|
|
|
|
kvfree(listxattrs->lsxa_buf);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_encode_removexattr(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_removexattr *removexattr)
|
|
|
|
{
|
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, 20);
|
|
|
|
if (!p)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
p = encode_cinfo(p, &removexattr->rmxa_cinfo);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *);
|
|
|
|
|
2009-04-03 13:27:55 +08:00
|
|
|
/*
|
|
|
|
* Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
|
|
|
|
* since we don't need to filter out obsolete ops as this is
|
|
|
|
* done in the decoding phase.
|
|
|
|
*/
|
2017-08-01 23:59:58 +08:00
|
|
|
static const nfsd4_enc nfsd4_enc_ops[] = {
|
2008-07-19 03:04:16 +08:00
|
|
|
[OP_ACCESS] = (nfsd4_enc)nfsd4_encode_access,
|
|
|
|
[OP_CLOSE] = (nfsd4_enc)nfsd4_encode_close,
|
|
|
|
[OP_COMMIT] = (nfsd4_enc)nfsd4_encode_commit,
|
|
|
|
[OP_CREATE] = (nfsd4_enc)nfsd4_encode_create,
|
|
|
|
[OP_DELEGPURGE] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_DELEGRETURN] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_GETATTR] = (nfsd4_enc)nfsd4_encode_getattr,
|
|
|
|
[OP_GETFH] = (nfsd4_enc)nfsd4_encode_getfh,
|
|
|
|
[OP_LINK] = (nfsd4_enc)nfsd4_encode_link,
|
|
|
|
[OP_LOCK] = (nfsd4_enc)nfsd4_encode_lock,
|
|
|
|
[OP_LOCKT] = (nfsd4_enc)nfsd4_encode_lockt,
|
|
|
|
[OP_LOCKU] = (nfsd4_enc)nfsd4_encode_locku,
|
|
|
|
[OP_LOOKUP] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_LOOKUPP] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_NVERIFY] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_OPEN] = (nfsd4_enc)nfsd4_encode_open,
|
2009-03-05 05:05:35 +08:00
|
|
|
[OP_OPENATTR] = (nfsd4_enc)nfsd4_encode_noop,
|
2008-07-19 03:04:16 +08:00
|
|
|
[OP_OPEN_CONFIRM] = (nfsd4_enc)nfsd4_encode_open_confirm,
|
|
|
|
[OP_OPEN_DOWNGRADE] = (nfsd4_enc)nfsd4_encode_open_downgrade,
|
|
|
|
[OP_PUTFH] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_PUTPUBFH] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_PUTROOTFH] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_READ] = (nfsd4_enc)nfsd4_encode_read,
|
|
|
|
[OP_READDIR] = (nfsd4_enc)nfsd4_encode_readdir,
|
|
|
|
[OP_READLINK] = (nfsd4_enc)nfsd4_encode_readlink,
|
|
|
|
[OP_REMOVE] = (nfsd4_enc)nfsd4_encode_remove,
|
|
|
|
[OP_RENAME] = (nfsd4_enc)nfsd4_encode_rename,
|
|
|
|
[OP_RENEW] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_RESTOREFH] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_SAVEFH] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_SECINFO] = (nfsd4_enc)nfsd4_encode_secinfo,
|
|
|
|
[OP_SETATTR] = (nfsd4_enc)nfsd4_encode_setattr,
|
|
|
|
[OP_SETCLIENTID] = (nfsd4_enc)nfsd4_encode_setclientid,
|
|
|
|
[OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_VERIFY] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_WRITE] = (nfsd4_enc)nfsd4_encode_write,
|
|
|
|
[OP_RELEASE_LOCKOWNER] = (nfsd4_enc)nfsd4_encode_noop,
|
2009-04-03 13:27:55 +08:00
|
|
|
|
|
|
|
/* NFSv4.1 operations */
|
|
|
|
[OP_BACKCHANNEL_CTL] = (nfsd4_enc)nfsd4_encode_noop,
|
2010-10-05 11:12:59 +08:00
|
|
|
[OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session,
|
2009-04-03 13:27:55 +08:00
|
|
|
[OP_EXCHANGE_ID] = (nfsd4_enc)nfsd4_encode_exchange_id,
|
|
|
|
[OP_CREATE_SESSION] = (nfsd4_enc)nfsd4_encode_create_session,
|
2013-12-09 19:04:23 +08:00
|
|
|
[OP_DESTROY_SESSION] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_FREE_STATEID] = (nfsd4_enc)nfsd4_encode_noop,
|
2009-04-03 13:27:55 +08:00
|
|
|
[OP_GET_DIR_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop,
|
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 19:11:59 +08:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
|
|
|
[OP_GETDEVICEINFO] = (nfsd4_enc)nfsd4_encode_getdeviceinfo,
|
|
|
|
[OP_GETDEVICELIST] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_LAYOUTCOMMIT] = (nfsd4_enc)nfsd4_encode_layoutcommit,
|
|
|
|
[OP_LAYOUTGET] = (nfsd4_enc)nfsd4_encode_layoutget,
|
|
|
|
[OP_LAYOUTRETURN] = (nfsd4_enc)nfsd4_encode_layoutreturn,
|
|
|
|
#else
|
2009-04-03 13:27:55 +08:00
|
|
|
[OP_GETDEVICEINFO] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_GETDEVICELIST] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_LAYOUTCOMMIT] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_LAYOUTGET] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_LAYOUTRETURN] = (nfsd4_enc)nfsd4_encode_noop,
|
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 19:11:59 +08:00
|
|
|
#endif
|
2010-12-27 14:29:57 +08:00
|
|
|
[OP_SECINFO_NO_NAME] = (nfsd4_enc)nfsd4_encode_secinfo_no_name,
|
2009-04-03 13:27:55 +08:00
|
|
|
[OP_SEQUENCE] = (nfsd4_enc)nfsd4_encode_sequence,
|
|
|
|
[OP_SET_SSV] = (nfsd4_enc)nfsd4_encode_noop,
|
2011-07-13 22:50:48 +08:00
|
|
|
[OP_TEST_STATEID] = (nfsd4_enc)nfsd4_encode_test_stateid,
|
2009-04-03 13:27:55 +08:00
|
|
|
[OP_WANT_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_DESTROY_CLIENTID] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_RECLAIM_COMPLETE] = (nfsd4_enc)nfsd4_encode_noop,
|
2014-09-27 01:58:26 +08:00
|
|
|
|
|
|
|
/* NFSv4.2 operations */
|
|
|
|
[OP_ALLOCATE] = (nfsd4_enc)nfsd4_encode_noop,
|
2016-09-08 03:57:30 +08:00
|
|
|
[OP_COPY] = (nfsd4_enc)nfsd4_encode_copy,
|
2019-08-08 23:14:59 +08:00
|
|
|
[OP_COPY_NOTIFY] = (nfsd4_enc)nfsd4_encode_copy_notify,
|
2014-09-27 01:58:26 +08:00
|
|
|
[OP_DEALLOCATE] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_IO_ADVISE] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_LAYOUTERROR] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_LAYOUTSTATS] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[OP_OFFLOAD_CANCEL] = (nfsd4_enc)nfsd4_encode_noop,
|
2018-07-21 06:19:18 +08:00
|
|
|
[OP_OFFLOAD_STATUS] = (nfsd4_enc)nfsd4_encode_offload_status,
|
2014-09-27 01:58:26 +08:00
|
|
|
[OP_READ_PLUS] = (nfsd4_enc)nfsd4_encode_noop,
|
2014-09-27 01:58:27 +08:00
|
|
|
[OP_SEEK] = (nfsd4_enc)nfsd4_encode_seek,
|
2014-09-27 01:58:26 +08:00
|
|
|
[OP_WRITE_SAME] = (nfsd4_enc)nfsd4_encode_noop,
|
2015-12-03 19:59:52 +08:00
|
|
|
[OP_CLONE] = (nfsd4_enc)nfsd4_encode_noop,
|
2020-06-24 06:39:26 +08:00
|
|
|
|
|
|
|
/* RFC 8276 extended atributes operations */
|
|
|
|
[OP_GETXATTR] = (nfsd4_enc)nfsd4_encode_getxattr,
|
|
|
|
[OP_SETXATTR] = (nfsd4_enc)nfsd4_encode_setxattr,
|
|
|
|
[OP_LISTXATTRS] = (nfsd4_enc)nfsd4_encode_listxattrs,
|
|
|
|
[OP_REMOVEXATTR] = (nfsd4_enc)nfsd4_encode_removexattr,
|
2008-07-04 19:38:33 +08:00
|
|
|
};
|
|
|
|
|
2009-04-03 13:28:48 +08:00
|
|
|
/*
|
2014-03-12 05:54:34 +08:00
|
|
|
* Calculate whether we still have space to encode repsize bytes.
|
|
|
|
* There are two considerations:
|
|
|
|
* - For NFS versions >=4.1, the size of the reply must stay within
|
|
|
|
* session limits
|
|
|
|
* - For all NFS versions, we must stay within limited preallocated
|
|
|
|
* buffer space.
|
2009-04-03 13:28:48 +08:00
|
|
|
*
|
2014-03-12 05:54:34 +08:00
|
|
|
* This is called before the operation is processed, so can only provide
|
|
|
|
* an upper estimate. For some nonidempotent operations (such as
|
|
|
|
* getattr), it's not necessarily a problem if that estimate is wrong,
|
|
|
|
* as we can fail it after processing without significant side effects.
|
2009-04-03 13:28:48 +08:00
|
|
|
*/
|
2014-03-12 05:54:34 +08:00
|
|
|
__be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize)
|
2009-04-03 13:28:48 +08:00
|
|
|
{
|
2014-03-09 05:42:05 +08:00
|
|
|
struct xdr_buf *buf = &resp->rqstp->rq_res;
|
2014-03-13 09:39:35 +08:00
|
|
|
struct nfsd4_slot *slot = resp->cstate.slot;
|
2009-04-03 13:28:48 +08:00
|
|
|
|
2014-03-13 09:39:35 +08:00
|
|
|
if (buf->len + respsize <= buf->buflen)
|
|
|
|
return nfs_ok;
|
|
|
|
if (!nfsd4_has_session(&resp->cstate))
|
2014-03-09 06:19:55 +08:00
|
|
|
return nfserr_resource;
|
2014-03-13 09:39:35 +08:00
|
|
|
if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return nfserr_rep_too_big_to_cache;
|
2014-03-09 06:19:55 +08:00
|
|
|
}
|
2014-03-13 09:39:35 +08:00
|
|
|
return nfserr_rep_too_big;
|
2009-04-03 13:28:48 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
void
|
|
|
|
nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
|
|
|
|
{
|
2013-08-30 03:42:52 +08:00
|
|
|
struct xdr_stream *xdr = &resp->xdr;
|
2013-04-02 04:37:12 +08:00
|
|
|
struct nfs4_stateowner *so = resp->cstate.replay_owner;
|
2014-03-08 00:01:37 +08:00
|
|
|
struct svc_rqst *rqstp = resp->rqstp;
|
2017-05-06 05:09:37 +08:00
|
|
|
const struct nfsd4_operation *opdesc = op->opdesc;
|
2013-08-30 03:42:52 +08:00
|
|
|
int post_err_offset;
|
2014-03-07 09:39:29 +08:00
|
|
|
nfsd4_enc encoder;
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8);
|
|
|
|
if (!p) {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return;
|
|
|
|
}
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(op->opnum);
|
2013-08-30 03:42:52 +08:00
|
|
|
post_err_offset = xdr->buf->len;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-04 19:38:33 +08:00
|
|
|
if (op->opnum == OP_ILLEGAL)
|
|
|
|
goto status;
|
2017-05-06 22:49:21 +08:00
|
|
|
if (op->status && opdesc &&
|
|
|
|
!(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE))
|
|
|
|
goto status;
|
2008-07-04 19:38:33 +08:00
|
|
|
BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||
|
|
|
|
!nfsd4_enc_ops[op->opnum]);
|
2014-03-07 09:39:29 +08:00
|
|
|
encoder = nfsd4_enc_ops[op->opnum];
|
|
|
|
op->status = encoder(resp, op->status, &op->u);
|
2017-05-06 05:09:37 +08:00
|
|
|
if (opdesc && opdesc->op_release)
|
|
|
|
opdesc->op_release(&op->u);
|
2013-08-27 04:04:46 +08:00
|
|
|
xdr_commit_encode(xdr);
|
|
|
|
|
2014-03-22 05:26:44 +08:00
|
|
|
/* nfsd4_check_resp_size guarantees enough room for error status */
|
2014-03-08 00:01:37 +08:00
|
|
|
if (!op->status) {
|
|
|
|
int space_needed = 0;
|
|
|
|
if (!nfsd4_last_compound_op(rqstp))
|
|
|
|
space_needed = COMPOUND_ERR_SLACK_SPACE;
|
|
|
|
op->status = nfsd4_check_resp_size(resp, space_needed);
|
|
|
|
}
|
2014-05-09 05:38:18 +08:00
|
|
|
if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) {
|
|
|
|
struct nfsd4_slot *slot = resp->cstate.slot;
|
|
|
|
|
|
|
|
if (slot->sl_flags & NFSD4_SLOT_CACHETHIS)
|
|
|
|
op->status = nfserr_rep_too_big_to_cache;
|
|
|
|
else
|
|
|
|
op->status = nfserr_rep_too_big;
|
|
|
|
}
|
2014-03-07 09:39:29 +08:00
|
|
|
if (op->status == nfserr_resource ||
|
|
|
|
op->status == nfserr_rep_too_big ||
|
|
|
|
op->status == nfserr_rep_too_big_to_cache) {
|
|
|
|
/*
|
|
|
|
* The operation may have already been encoded or
|
|
|
|
* partially encoded. No op returns anything additional
|
|
|
|
* in the case of one of these three errors, so we can
|
|
|
|
* just truncate back to after the status. But it's a
|
|
|
|
* bug if we had to do this on a non-idempotent op:
|
|
|
|
*/
|
|
|
|
warn_on_nonidempotent_op(op);
|
2013-08-30 03:42:52 +08:00
|
|
|
xdr_truncate_encode(xdr, post_err_offset);
|
2014-03-07 09:39:29 +08:00
|
|
|
}
|
2013-04-02 04:37:12 +08:00
|
|
|
if (so) {
|
2013-08-30 03:42:52 +08:00
|
|
|
int len = xdr->buf->len - post_err_offset;
|
|
|
|
|
2013-04-02 04:37:12 +08:00
|
|
|
so->so_replay.rp_status = op->status;
|
2013-08-30 03:42:52 +08:00
|
|
|
so->so_replay.rp_buflen = len;
|
|
|
|
read_bytes_from_xdr_buf(xdr->buf, post_err_offset,
|
|
|
|
so->so_replay.rp_buf, len);
|
2013-04-02 04:37:12 +08:00
|
|
|
}
|
2008-07-04 19:38:33 +08:00
|
|
|
status:
|
2013-08-30 03:42:52 +08:00
|
|
|
/* Note that op->status is already in network byte order: */
|
|
|
|
write_bytes_to_xdr_buf(xdr->buf, post_err_offset - 4, &op->status, 4);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode the reply stored in the stateowner reply cache
|
|
|
|
*
|
|
|
|
* XDR note: do not encode rp->rp_buflen: the buffer contains the
|
|
|
|
* previously sent already encoded operation.
|
|
|
|
*/
|
|
|
|
void
|
2014-01-31 06:18:38 +08:00
|
|
|
nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-04-08 07:55:27 +08:00
|
|
|
__be32 *p;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct nfs4_replay *rp = op->replay;
|
|
|
|
|
2014-01-31 06:18:38 +08:00
|
|
|
p = xdr_reserve_space(xdr, 8 + rp->rp_buflen);
|
|
|
|
if (!p) {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return;
|
|
|
|
}
|
2014-03-23 05:09:18 +08:00
|
|
|
*p++ = cpu_to_be32(op->opnum);
|
2005-04-17 06:20:36 +08:00
|
|
|
*p++ = rp->rp_status; /* already xdr'ed */
|
|
|
|
|
2014-03-23 06:43:16 +08:00
|
|
|
p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2017-05-09 01:42:02 +08:00
|
|
|
nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
return xdr_ressize_check(rqstp, p);
|
|
|
|
}
|
|
|
|
|
2017-05-09 00:48:24 +08:00
|
|
|
void nfsd4_release_compoundargs(struct svc_rqst *rqstp)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2011-07-17 05:15:10 +08:00
|
|
|
struct nfsd4_compoundargs *args = rqstp->rq_argp;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (args->ops != args->iops) {
|
|
|
|
kfree(args->ops);
|
|
|
|
args->ops = args->iops;
|
|
|
|
}
|
2005-11-07 17:01:34 +08:00
|
|
|
kfree(args->tmpp);
|
|
|
|
args->tmpp = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
while (args->to_free) {
|
2014-06-25 05:43:45 +08:00
|
|
|
struct svcxdr_tmpbuf *tb = args->to_free;
|
2005-04-17 06:20:36 +08:00
|
|
|
args->to_free = tb->next;
|
|
|
|
kfree(tb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2017-05-09 01:01:48 +08:00
|
|
|
nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2017-05-09 01:01:48 +08:00
|
|
|
struct nfsd4_compoundargs *args = rqstp->rq_argp;
|
|
|
|
|
2014-03-10 23:34:55 +08:00
|
|
|
if (rqstp->rq_arg.head[0].iov_len % 4) {
|
|
|
|
/* client is nuts */
|
|
|
|
dprintk("%s: compound not properly padded! (peeraddr=%pISc xid=0x%x)",
|
|
|
|
__func__, svc_addr(rqstp), be32_to_cpu(rqstp->rq_xid));
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
args->p = p;
|
|
|
|
args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len;
|
|
|
|
args->pagelist = rqstp->rq_arg.pages;
|
|
|
|
args->pagelen = rqstp->rq_arg.page_len;
|
2017-08-18 23:12:27 +08:00
|
|
|
args->tail = false;
|
2005-04-17 06:20:36 +08:00
|
|
|
args->tmpp = NULL;
|
|
|
|
args->to_free = NULL;
|
|
|
|
args->ops = args->iops;
|
|
|
|
args->rqstp = rqstp;
|
|
|
|
|
2011-07-17 05:15:10 +08:00
|
|
|
return !nfsd4_decode_compound(args);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2017-05-09 01:42:02 +08:00
|
|
|
nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* All that remains is to write the tag and operation count...
|
|
|
|
*/
|
2017-05-09 01:42:02 +08:00
|
|
|
struct nfsd4_compoundres *resp = rqstp->rq_resp;
|
2014-02-27 06:39:35 +08:00
|
|
|
struct xdr_buf *buf = resp->xdr.buf;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(buf->len != buf->head[0].iov_len + buf->page_len +
|
|
|
|
buf->tail[0].iov_len);
|
2014-02-27 06:16:27 +08:00
|
|
|
|
2013-08-27 04:04:46 +08:00
|
|
|
rqstp->rq_next_page = resp->xdr.page_ptr + 1;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
p = resp->tagp;
|
|
|
|
*p++ = htonl(resp->taglen);
|
|
|
|
memcpy(p, resp->tag, resp->taglen);
|
|
|
|
p += XDR_QUADLEN(resp->taglen);
|
|
|
|
*p++ = htonl(resp->opcnt);
|
|
|
|
|
2014-06-30 23:48:35 +08:00
|
|
|
nfsd4_sequence_done(resp);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Local variables:
|
|
|
|
* c-basic-offset: 8
|
|
|
|
* End:
|
|
|
|
*/
|