2005-04-16 22:20:36 +00: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.
|
|
|
|
*
|
|
|
|
* TODO: Neil Brown made the following observation: We currently
|
|
|
|
* initially reserve NFSD_BUFSIZE space on the transmit queue and
|
|
|
|
* never release any of that until the request is complete.
|
|
|
|
* It would be good to calculate a new maximum response size while
|
|
|
|
* decoding the COMPOUND, and call svc_reserve with this number
|
|
|
|
* at the end of nfs4svc_decode_compoundargs.
|
|
|
|
*/
|
|
|
|
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/namei.h>
|
2009-12-03 18:29:12 +00:00
|
|
|
#include <linux/statfs.h>
|
2009-04-03 05:28:01 +00:00
|
|
|
#include <linux/utsname.h>
|
2011-07-13 14:50:48 +00:00
|
|
|
#include <linux/pagemap.h>
|
2007-07-17 11:04:51 +00:00
|
|
|
#include <linux/sunrpc/svcauth_gss.h>
|
2009-12-03 18:30:56 +00:00
|
|
|
|
2011-01-04 22:37:15 +00:00
|
|
|
#include "idmap.h"
|
|
|
|
#include "acl.h"
|
2009-12-03 18:30:56 +00:00
|
|
|
#include "xdr4.h"
|
2009-11-04 23:12:35 +00:00
|
|
|
#include "vfs.h"
|
2011-07-13 14:50:48 +00:00
|
|
|
#include "state.h"
|
2011-01-24 17:11:02 +00:00
|
|
|
#include "cache.h"
|
2012-11-27 11:11:44 +00:00
|
|
|
#include "netns.h"
|
2011-01-04 22:37:15 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define NFSDDBG_FACILITY NFSDDBG_XDR
|
|
|
|
|
2006-10-04 09:16:20 +00: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 06:28:59 +00:00
|
|
|
static __be32
|
2012-11-25 21:31:00 +00:00
|
|
|
check_filename(char *str, int len)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (len == 0)
|
|
|
|
return nfserr_inval;
|
|
|
|
if (isdotent(str, len))
|
2012-11-25 21:31:00 +00:00
|
|
|
return nfserr_badname;
|
2005-04-16 22:20:36 +00:00
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
if (str[i] == '/')
|
2012-11-25 21:31:00 +00:00
|
|
|
return nfserr_badname;
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define DECODE_HEAD \
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *p; \
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status
|
2005-04-16 22:20:36 +00:00
|
|
|
#define DECODE_TAIL \
|
|
|
|
status = 0; \
|
|
|
|
out: \
|
|
|
|
return status; \
|
|
|
|
xdr_error: \
|
2007-09-11 22:01:20 +00:00
|
|
|
dprintk("NFSD: xdr error (%s:%d)\n", \
|
|
|
|
__FILE__, __LINE__); \
|
2005-04-16 22:20:36 +00:00
|
|
|
status = nfserr_bad_xdr; \
|
|
|
|
goto out
|
|
|
|
|
|
|
|
#define READ32(x) (x) = ntohl(*p++)
|
|
|
|
#define READ64(x) do { \
|
|
|
|
(x) = (u64)ntohl(*p++) << 32; \
|
|
|
|
(x) |= ntohl(*p++); \
|
|
|
|
} while (0)
|
|
|
|
#define READTIME(x) do { \
|
|
|
|
p++; \
|
|
|
|
(x) = ntohl(*p++); \
|
|
|
|
p++; \
|
|
|
|
} while (0)
|
|
|
|
#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-11 22:01:20 +00:00
|
|
|
dprintk("NFSD: xdr error (%s:%d)\n", \
|
|
|
|
__FILE__, __LINE__); \
|
2005-04-16 22:20:36 +00: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-11 22:01:20 +00:00
|
|
|
dprintk("NFSD: xdr error (%s:%d)\n", \
|
|
|
|
__FILE__, __LINE__); \
|
2005-04-16 22:20:36 +00:00
|
|
|
goto xdr_error; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2007-11-11 20:43:12 +00:00
|
|
|
static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
/* We want more bytes than seem to be available.
|
|
|
|
* Maybe we need a new page, maybe we have just run out
|
|
|
|
*/
|
2007-11-11 20:43:12 +00:00
|
|
|
unsigned int avail = (char *)argp->end - (char *)argp->p;
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00: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 09:01:34 +00:00
|
|
|
kfree(argp->tmpp);
|
2005-04-16 22:20:36 +00:00
|
|
|
p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL);
|
|
|
|
if (!p)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
}
|
2007-11-11 20:43:12 +00: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-16 22:20:36 +00:00
|
|
|
memcpy(p, argp->p, avail);
|
|
|
|
/* step to next page */
|
|
|
|
argp->p = page_address(argp->pagelist[0]);
|
|
|
|
argp->pagelist++;
|
|
|
|
if (argp->pagelen < PAGE_SIZE) {
|
2010-04-20 02:16:52 +00:00
|
|
|
argp->end = argp->p + (argp->pagelen>>2);
|
2005-04-16 22:20:36 +00:00
|
|
|
argp->pagelen = 0;
|
|
|
|
} else {
|
2010-04-20 02:16:52 +00:00
|
|
|
argp->end = argp->p + (PAGE_SIZE>>2);
|
2005-04-16 22:20:36 +00:00
|
|
|
argp->pagelen -= PAGE_SIZE;
|
|
|
|
}
|
|
|
|
memcpy(((char*)p)+avail, argp->p, (nbytes - avail));
|
|
|
|
argp->p += XDR_QUADLEN(nbytes - avail);
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2009-04-03 05:28:50 +00:00
|
|
|
static int zero_clientid(clientid_t *clid)
|
|
|
|
{
|
|
|
|
return (clid->cl_boot == 0) && (clid->cl_id == 0);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int
|
|
|
|
defer_free(struct nfsd4_compoundargs *argp,
|
|
|
|
void (*release)(const void *), void *p)
|
|
|
|
{
|
|
|
|
struct tmpbuf *tb;
|
|
|
|
|
|
|
|
tb = kmalloc(sizeof(*tb), GFP_KERNEL);
|
|
|
|
if (!tb)
|
|
|
|
return -ENOMEM;
|
|
|
|
tb->buf = p;
|
|
|
|
tb->release = release;
|
|
|
|
tb->next = argp->to_free;
|
|
|
|
argp->to_free = tb;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:58 +00:00
|
|
|
static char *savemem(struct nfsd4_compoundargs *argp, __be32 *p, int nbytes)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
if (p == argp->tmp) {
|
2011-11-17 22:43:40 +00:00
|
|
|
p = kmemdup(argp->tmp, nbytes, GFP_KERNEL);
|
2007-02-16 09:28:30 +00:00
|
|
|
if (!p)
|
|
|
|
return NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2006-10-03 21:37:14 +00:00
|
|
|
BUG_ON(p != argp->tmpp);
|
2005-04-16 22:20:36 +00:00
|
|
|
argp->tmpp = NULL;
|
|
|
|
}
|
|
|
|
if (defer_free(argp, kfree, p)) {
|
2007-02-16 09:28:30 +00:00
|
|
|
kfree(p);
|
2005-04-16 22:20:36 +00:00
|
|
|
return NULL;
|
|
|
|
} else
|
|
|
|
return (char *)p;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)
|
|
|
|
{
|
|
|
|
u32 bmlen;
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
bmval[0] = 0;
|
|
|
|
bmval[1] = 0;
|
2009-04-03 05:29:11 +00:00
|
|
|
bmval[2] = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(bmlen);
|
|
|
|
if (bmlen > 1000)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
READ_BUF(bmlen << 2);
|
|
|
|
if (bmlen > 0)
|
|
|
|
READ32(bmval[0]);
|
|
|
|
if (bmlen > 1)
|
|
|
|
READ32(bmval[1]);
|
2009-04-03 05:29:11 +00:00
|
|
|
if (bmlen > 2)
|
|
|
|
READ32(bmval[2]);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2009-05-16 08:22:31 +00:00
|
|
|
nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
|
2009-04-03 05:29:05 +00:00
|
|
|
struct iattr *iattr, struct nfs4_acl **acl)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int expected_len, len = 0;
|
|
|
|
u32 dummy32;
|
|
|
|
char *buf;
|
2006-10-20 06:29:01 +00:00
|
|
|
int host_err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
DECODE_HEAD;
|
|
|
|
iattr->ia_valid = 0;
|
|
|
|
if ((status = nfsd4_decode_bitmap(argp, bmval)))
|
|
|
|
return status;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(expected_len);
|
|
|
|
|
|
|
|
if (bmval[0] & FATTR4_WORD0_SIZE) {
|
|
|
|
READ_BUF(8);
|
|
|
|
len += 8;
|
|
|
|
READ64(iattr->ia_size);
|
|
|
|
iattr->ia_valid |= ATTR_SIZE;
|
|
|
|
}
|
|
|
|
if (bmval[0] & FATTR4_WORD0_ACL) {
|
2007-02-16 09:28:30 +00:00
|
|
|
int nace;
|
|
|
|
struct nfs4_ace *ace;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
READ_BUF(4); len += 4;
|
|
|
|
READ32(nace);
|
|
|
|
|
2007-02-16 09:28:30 +00:00
|
|
|
if (nace > NFS4_ACL_MAX)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
*acl = nfs4_acl_new(nace);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (*acl == NULL) {
|
2006-10-20 06:29:01 +00:00
|
|
|
host_err = -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_nfserr;
|
|
|
|
}
|
2007-02-16 09:28:30 +00:00
|
|
|
defer_free(argp, kfree, *acl);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-16 09:28:30 +00:00
|
|
|
(*acl)->naces = nace;
|
|
|
|
for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
READ_BUF(16); len += 16;
|
2007-02-16 09:28:30 +00:00
|
|
|
READ32(ace->type);
|
|
|
|
READ32(ace->flag);
|
|
|
|
READ32(ace->access_mask);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(dummy32);
|
|
|
|
READ_BUF(dummy32);
|
|
|
|
len += XDR_QUADLEN(dummy32) << 2;
|
|
|
|
READMEM(buf, dummy32);
|
2007-02-16 09:28:30 +00:00
|
|
|
ace->whotype = nfs4_acl_get_whotype(buf, dummy32);
|
2011-01-04 22:53:52 +00:00
|
|
|
status = nfs_ok;
|
2007-02-16 09:28:30 +00:00
|
|
|
if (ace->whotype != NFS4_ACL_WHO_NAMED)
|
|
|
|
ace->who = 0;
|
|
|
|
else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
|
2011-01-04 22:53:52 +00:00
|
|
|
status = nfsd_map_name_to_gid(argp->rqstp,
|
2007-02-16 09:28:30 +00:00
|
|
|
buf, dummy32, &ace->who);
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2011-01-04 22:53:52 +00:00
|
|
|
status = nfsd_map_name_to_uid(argp->rqstp,
|
2007-02-16 09:28:30 +00:00
|
|
|
buf, dummy32, &ace->who);
|
2011-01-04 22:53:52 +00:00
|
|
|
if (status)
|
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
*acl = NULL;
|
|
|
|
if (bmval[1] & FATTR4_WORD1_MODE) {
|
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
|
|
|
READ32(iattr->ia_mode);
|
|
|
|
iattr->ia_mode &= (S_IFMT | S_IALLUGO);
|
|
|
|
iattr->ia_valid |= ATTR_MODE;
|
|
|
|
}
|
|
|
|
if (bmval[1] & FATTR4_WORD1_OWNER) {
|
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
|
|
|
READ32(dummy32);
|
|
|
|
READ_BUF(dummy32);
|
|
|
|
len += (XDR_QUADLEN(dummy32) << 2);
|
|
|
|
READMEM(buf, dummy32);
|
2011-02-16 02:08:35 +00:00
|
|
|
if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid)))
|
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
iattr->ia_valid |= ATTR_UID;
|
|
|
|
}
|
|
|
|
if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) {
|
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
|
|
|
READ32(dummy32);
|
|
|
|
READ_BUF(dummy32);
|
|
|
|
len += (XDR_QUADLEN(dummy32) << 2);
|
|
|
|
READMEM(buf, dummy32);
|
2011-02-16 02:08:35 +00:00
|
|
|
if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid)))
|
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
iattr->ia_valid |= ATTR_GID;
|
|
|
|
}
|
|
|
|
if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
|
|
|
|
READ_BUF(4);
|
|
|
|
len += 4;
|
|
|
|
READ32(dummy32);
|
|
|
|
switch (dummy32) {
|
|
|
|
case NFS4_SET_TO_CLIENT_TIME:
|
|
|
|
/* We require the high 32 bits of 'seconds' to be 0, and we ignore
|
|
|
|
all 32 bits of 'nseconds'. */
|
|
|
|
READ_BUF(12);
|
|
|
|
len += 12;
|
|
|
|
READ32(dummy32);
|
|
|
|
if (dummy32)
|
|
|
|
return nfserr_inval;
|
|
|
|
READ32(iattr->ia_atime.tv_sec);
|
|
|
|
READ32(iattr->ia_atime.tv_nsec);
|
|
|
|
if (iattr->ia_atime.tv_nsec >= (u32)1000000000)
|
|
|
|
return nfserr_inval;
|
|
|
|
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;
|
|
|
|
READ32(dummy32);
|
|
|
|
switch (dummy32) {
|
|
|
|
case NFS4_SET_TO_CLIENT_TIME:
|
|
|
|
/* We require the high 32 bits of 'seconds' to be 0, and we ignore
|
|
|
|
all 32 bits of 'nseconds'. */
|
|
|
|
READ_BUF(12);
|
|
|
|
len += 12;
|
|
|
|
READ32(dummy32);
|
|
|
|
if (dummy32)
|
|
|
|
return nfserr_inval;
|
|
|
|
READ32(iattr->ia_mtime.tv_sec);
|
|
|
|
READ32(iattr->ia_mtime.tv_nsec);
|
|
|
|
if (iattr->ia_mtime.tv_nsec >= (u32)1000000000)
|
|
|
|
return nfserr_inval;
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2009-05-16 08:22:31 +00:00
|
|
|
if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
|
|
|
|
|| bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
|
|
|
|
|| bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2)
|
|
|
|
READ_BUF(expected_len - len);
|
|
|
|
else if (len != expected_len)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
|
|
|
|
out_nfserr:
|
2006-10-20 06:29:01 +00:00
|
|
|
status = nfserrno(host_err);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-08-12 17:46:18 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_stateid(struct nfsd4_compoundargs *argp, stateid_t *sid)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(sizeof(stateid_t));
|
|
|
|
READ32(sid->si_generation);
|
|
|
|
COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t));
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(access->ac_req_access);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2012-03-27 18:50:26 +00:00
|
|
|
static __be32 nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
2012-11-05 21:01:48 +00:00
|
|
|
u32 dummy, uid, gid;
|
2012-03-27 18:50:26 +00:00
|
|
|
char *machine_name;
|
|
|
|
int i;
|
|
|
|
int nr_secflavs;
|
|
|
|
|
|
|
|
/* callback_sec_params4 */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(nr_secflavs);
|
2012-11-05 21:01:48 +00:00
|
|
|
cbs->flavor = (u32)(-1);
|
2012-03-27 18:50:26 +00:00
|
|
|
for (i = 0; i < nr_secflavs; ++i) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(dummy);
|
|
|
|
switch (dummy) {
|
|
|
|
case RPC_AUTH_NULL:
|
|
|
|
/* Nothing to read */
|
2012-11-05 21:01:48 +00:00
|
|
|
if (cbs->flavor == (u32)(-1))
|
|
|
|
cbs->flavor = RPC_AUTH_NULL;
|
2012-03-27 18:50:26 +00:00
|
|
|
break;
|
|
|
|
case RPC_AUTH_UNIX:
|
|
|
|
READ_BUF(8);
|
|
|
|
/* stamp */
|
|
|
|
READ32(dummy);
|
|
|
|
|
|
|
|
/* machine name */
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy);
|
|
|
|
SAVEMEM(machine_name, dummy);
|
|
|
|
|
|
|
|
/* uid, gid */
|
|
|
|
READ_BUF(8);
|
2012-11-05 21:01:48 +00:00
|
|
|
READ32(uid);
|
|
|
|
READ32(gid);
|
2012-03-27 18:50:26 +00:00
|
|
|
|
|
|
|
/* more gids */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy * 4);
|
2012-11-05 21:01:48 +00:00
|
|
|
if (cbs->flavor == (u32)(-1)) {
|
|
|
|
cbs->uid = uid;
|
|
|
|
cbs->gid = gid;
|
|
|
|
cbs->flavor = RPC_AUTH_UNIX;
|
|
|
|
}
|
2012-03-27 18:50:26 +00:00
|
|
|
break;
|
|
|
|
case RPC_AUTH_GSS:
|
|
|
|
dprintk("RPC_AUTH_GSS callback secflavor "
|
|
|
|
"not supported!\n");
|
|
|
|
READ_BUF(8);
|
|
|
|
/* gcbp_service */
|
|
|
|
READ32(dummy);
|
|
|
|
/* gcbp_handle_from_server */
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy);
|
|
|
|
p += XDR_QUADLEN(dummy);
|
|
|
|
/* gcbp_handle_from_client */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dprintk("Illegal callback secflavor\n");
|
|
|
|
return nfserr_inval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2012-11-01 22:09:48 +00:00
|
|
|
static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, struct nfsd4_backchannel_ctl *bc)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(bc->bc_cb_program);
|
|
|
|
nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2010-10-05 03:12:59 +00: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);
|
|
|
|
READ32(bcts->dir);
|
2011-04-27 19:47:16 +00: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 03:12:59 +00:00
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2008-08-12 17:46:18 +00:00
|
|
|
READ_BUF(4);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(close->cl_seqid);
|
2008-08-12 17:46:18 +00:00
|
|
|
return nfsd4_decode_stateid(argp, &close->cl_stateid);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(12);
|
|
|
|
READ64(commit->co_offset);
|
|
|
|
READ32(commit->co_count);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(create->cr_type);
|
|
|
|
switch (create->cr_type) {
|
|
|
|
case NF4LNK:
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(create->cr_linklen);
|
|
|
|
READ_BUF(create->cr_linklen);
|
|
|
|
SAVEMEM(create->cr_linkname, create->cr_linklen);
|
|
|
|
break;
|
|
|
|
case NF4BLK:
|
|
|
|
case NF4CHR:
|
|
|
|
READ_BUF(8);
|
|
|
|
READ32(create->cr_specdata1);
|
|
|
|
READ32(create->cr_specdata2);
|
|
|
|
break;
|
|
|
|
case NF4SOCK:
|
|
|
|
case NF4FIFO:
|
|
|
|
case NF4DIR:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(create->cr_namelen);
|
|
|
|
READ_BUF(create->cr_namelen);
|
|
|
|
SAVEMEM(create->cr_name, create->cr_namelen);
|
2012-11-25 21:31:00 +00:00
|
|
|
if ((status = check_filename(create->cr_name, create->cr_namelen)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
|
2009-05-16 08:22:31 +00:00
|
|
|
status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr,
|
|
|
|
&create->cr_acl);
|
2009-04-03 05:29:05 +00:00
|
|
|
if (status)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static inline __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr)
|
|
|
|
{
|
2008-08-12 17:46:18 +00:00
|
|
|
return nfsd4_decode_stateid(argp, &dr->dr_stateid);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static inline __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr)
|
|
|
|
{
|
|
|
|
return nfsd4_decode_bitmap(argp, getattr->ga_bmval);
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(link->li_namelen);
|
|
|
|
READ_BUF(link->li_namelen);
|
|
|
|
SAVEMEM(link->li_name, link->li_namelen);
|
2012-11-25 21:31:00 +00:00
|
|
|
if ((status = check_filename(link->li_name, link->li_namelen)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00: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);
|
|
|
|
READ32(lock->lk_type);
|
|
|
|
if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))
|
|
|
|
goto xdr_error;
|
|
|
|
READ32(lock->lk_reclaim);
|
|
|
|
READ64(lock->lk_offset);
|
|
|
|
READ64(lock->lk_length);
|
|
|
|
READ32(lock->lk_is_new);
|
|
|
|
|
|
|
|
if (lock->lk_is_new) {
|
2008-08-12 17:46:18 +00:00
|
|
|
READ_BUF(4);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(lock->lk_new_open_seqid);
|
2008-08-12 17:46:18 +00:00
|
|
|
status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(8 + sizeof(clientid_t));
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(lock->lk_new_lock_seqid);
|
|
|
|
COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t));
|
|
|
|
READ32(lock->lk_new_owner.len);
|
|
|
|
READ_BUF(lock->lk_new_owner.len);
|
|
|
|
READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len);
|
|
|
|
} else {
|
2008-08-12 17:46:18 +00:00
|
|
|
status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(4);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(lock->lk_old_lock_seqid);
|
|
|
|
}
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(32);
|
|
|
|
READ32(lockt->lt_type);
|
|
|
|
if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))
|
|
|
|
goto xdr_error;
|
|
|
|
READ64(lockt->lt_offset);
|
|
|
|
READ64(lockt->lt_length);
|
|
|
|
COPYMEM(&lockt->lt_clientid, 8);
|
|
|
|
READ32(lockt->lt_owner.len);
|
|
|
|
READ_BUF(lockt->lt_owner.len);
|
|
|
|
READMEM(lockt->lt_owner.data, lockt->lt_owner.len);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2008-08-12 17:46:18 +00:00
|
|
|
READ_BUF(8);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(locku->lu_type);
|
|
|
|
if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))
|
|
|
|
goto xdr_error;
|
|
|
|
READ32(locku->lu_seqid);
|
2008-08-12 17:46:18 +00:00
|
|
|
status = nfsd4_decode_stateid(argp, &locku->lu_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(16);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ64(locku->lu_offset);
|
|
|
|
READ64(locku->lu_length);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(lookup->lo_len);
|
|
|
|
READ_BUF(lookup->lo_len);
|
|
|
|
SAVEMEM(lookup->lo_name, lookup->lo_len);
|
2012-11-25 21:31:00 +00:00
|
|
|
if ((status = check_filename(lookup->lo_name, lookup->lo_len)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2012-02-16 18:57:09 +00:00
|
|
|
static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when)
|
2011-10-10 18:37:13 +00:00
|
|
|
{
|
|
|
|
__be32 *p;
|
|
|
|
u32 w;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(w);
|
2012-02-16 18:57:09 +00: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-10 18:37:13 +00: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-27 18:43:01 +00:00
|
|
|
w &= ~NFS4_SHARE_ACCESS_MASK;
|
2011-10-10 18:37:13 +00: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 02:13:29 +00:00
|
|
|
w &= ~NFS4_SHARE_WANT_MASK;
|
2011-10-10 18:37:13 +00:00
|
|
|
if (!w)
|
|
|
|
return nfs_ok;
|
2012-02-16 18:57:09 +00:00
|
|
|
|
|
|
|
if (!deleg_when) /* open_downgrade */
|
|
|
|
return nfserr_inval;
|
2011-10-10 18:37:13 +00:00
|
|
|
switch (w) {
|
|
|
|
case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL:
|
|
|
|
case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED:
|
2011-10-20 02:13:13 +00:00
|
|
|
case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL |
|
|
|
|
NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED):
|
2011-10-10 18:37:13 +00: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);
|
|
|
|
READ32(*x);
|
|
|
|
/* Note: unlinke access bits, deny bits may be zero. */
|
2011-10-17 07:41:17 +00:00
|
|
|
if (*x & ~NFS4_SHARE_DENY_BOTH)
|
2011-10-10 18:37:13 +00:00
|
|
|
return nfserr_bad_xdr;
|
|
|
|
return nfs_ok;
|
|
|
|
xdr_error:
|
|
|
|
return nfserr_bad_xdr;
|
|
|
|
}
|
|
|
|
|
2011-10-10 19:07:40 +00:00
|
|
|
static __be32 nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o)
|
|
|
|
{
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(o->len);
|
|
|
|
|
|
|
|
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 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
2012-02-16 18:57:09 +00:00
|
|
|
u32 dummy;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
memset(open->op_bmval, 0, sizeof(open->op_bmval));
|
|
|
|
open->op_iattr.ia_valid = 0;
|
2011-07-31 03:33:59 +00:00
|
|
|
open->op_openowner = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* seqid, share_access, share_deny, clientid, ownerlen */
|
2011-10-10 18:37:13 +00:00
|
|
|
READ_BUF(4);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(open->op_seqid);
|
2012-02-16 18:57:09 +00: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-10 18:37:13 +00:00
|
|
|
if (status)
|
|
|
|
goto xdr_error;
|
|
|
|
status = nfsd4_decode_share_deny(argp, &open->op_share_deny);
|
|
|
|
if (status)
|
|
|
|
goto xdr_error;
|
2011-10-10 19:07:40 +00:00
|
|
|
READ_BUF(sizeof(clientid_t));
|
2005-04-16 22:20:36 +00:00
|
|
|
COPYMEM(&open->op_clientid, sizeof(clientid_t));
|
2011-10-10 19:07:40 +00:00
|
|
|
status = nfsd4_decode_opaque(argp, &open->op_owner);
|
|
|
|
if (status)
|
|
|
|
goto xdr_error;
|
|
|
|
READ_BUF(4);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(open->op_create);
|
|
|
|
switch (open->op_create) {
|
|
|
|
case NFS4_OPEN_NOCREATE:
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CREATE:
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(open->op_createmode);
|
|
|
|
switch (open->op_createmode) {
|
|
|
|
case NFS4_CREATE_UNCHECKED:
|
|
|
|
case NFS4_CREATE_GUARDED:
|
2009-04-03 05:29:05 +00:00
|
|
|
status = nfsd4_decode_fattr(argp, open->op_bmval,
|
2009-05-16 08:22:31 +00:00
|
|
|
&open->op_iattr, &open->op_acl);
|
2009-04-03 05:29:05 +00:00
|
|
|
if (status)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
case NFS4_CREATE_EXCLUSIVE:
|
2012-03-02 22:13:50 +00:00
|
|
|
READ_BUF(NFS4_VERIFIER_SIZE);
|
|
|
|
COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2009-04-03 05:29:17 +00:00
|
|
|
case NFS4_CREATE_EXCLUSIVE4_1:
|
|
|
|
if (argp->minorversion < 1)
|
|
|
|
goto xdr_error;
|
2012-03-02 22:13:50 +00:00
|
|
|
READ_BUF(NFS4_VERIFIER_SIZE);
|
|
|
|
COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
|
2009-04-03 05:29:17 +00:00
|
|
|
status = nfsd4_decode_fattr(argp, open->op_bmval,
|
2009-05-16 08:22:31 +00:00
|
|
|
&open->op_iattr, &open->op_acl);
|
2009-04-03 05:29:17 +00:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
default:
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* open_claim */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(open->op_claim_type);
|
|
|
|
switch (open->op_claim_type) {
|
|
|
|
case NFS4_OPEN_CLAIM_NULL:
|
|
|
|
case NFS4_OPEN_CLAIM_DELEGATE_PREV:
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(open->op_fname.len);
|
|
|
|
READ_BUF(open->op_fname.len);
|
|
|
|
SAVEMEM(open->op_fname.data, open->op_fname.len);
|
2012-11-25 21:31:00 +00:00
|
|
|
if ((status = check_filename(open->op_fname.data, open->op_fname.len)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CLAIM_PREVIOUS:
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(open->op_delegate_type);
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CLAIM_DELEGATE_CUR:
|
2008-08-12 17:46:18 +00:00
|
|
|
status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(4);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(open->op_fname.len);
|
|
|
|
READ_BUF(open->op_fname.len);
|
|
|
|
SAVEMEM(open->op_fname.data, open->op_fname.len);
|
2012-11-25 21:31:00 +00:00
|
|
|
if ((status = check_filename(open->op_fname.data, open->op_fname.len)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
break;
|
2011-10-19 15:52:12 +00: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-16 22:20:36 +00:00
|
|
|
default:
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2008-08-12 17:46:18 +00:00
|
|
|
status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(4);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(open_conf->oc_seqid);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2008-08-12 17:46:18 +00:00
|
|
|
status = nfsd4_decode_stateid(argp, &open_down->od_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2011-10-10 18:37:13 +00:00
|
|
|
READ_BUF(4);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(open_down->od_seqid);
|
2012-02-16 18:57:09 +00:00
|
|
|
status = nfsd4_decode_share_access(argp, &open_down->od_share_access,
|
|
|
|
&open_down->od_deleg_want, NULL);
|
2011-10-10 18:37:13 +00:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
status = nfsd4_decode_share_deny(argp, &open_down->od_share_deny);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(putfh->pf_fhlen);
|
|
|
|
if (putfh->pf_fhlen > NFS4_FHSIZE)
|
|
|
|
goto xdr_error;
|
|
|
|
READ_BUF(putfh->pf_fhlen);
|
|
|
|
SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2008-08-12 17:46:18 +00:00
|
|
|
status = nfsd4_decode_stateid(argp, &read->rd_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(12);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ64(read->rd_offset);
|
|
|
|
READ32(read->rd_length);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(24);
|
|
|
|
READ64(readdir->rd_cookie);
|
|
|
|
COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data));
|
|
|
|
READ32(readdir->rd_dircount); /* just in case you needed a useless field... */
|
|
|
|
READ32(readdir->rd_maxcount);
|
|
|
|
if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval)))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(remove->rm_namelen);
|
|
|
|
READ_BUF(remove->rm_namelen);
|
|
|
|
SAVEMEM(remove->rm_name, remove->rm_namelen);
|
2012-11-25 21:31:00 +00:00
|
|
|
if ((status = check_filename(remove->rm_name, remove->rm_namelen)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(rename->rn_snamelen);
|
|
|
|
READ_BUF(rename->rn_snamelen + 4);
|
|
|
|
SAVEMEM(rename->rn_sname, rename->rn_snamelen);
|
|
|
|
READ32(rename->rn_tnamelen);
|
|
|
|
READ_BUF(rename->rn_tnamelen);
|
|
|
|
SAVEMEM(rename->rn_tname, rename->rn_tnamelen);
|
2012-11-25 21:31:00 +00:00
|
|
|
if ((status = check_filename(rename->rn_sname, rename->rn_snamelen)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
2012-11-25 21:31:00 +00:00
|
|
|
if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(sizeof(clientid_t));
|
|
|
|
COPYMEM(clientid, sizeof(clientid_t));
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2007-07-17 11:04:51 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_secinfo *secinfo)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(secinfo->si_namelen);
|
|
|
|
READ_BUF(secinfo->si_namelen);
|
|
|
|
SAVEMEM(secinfo->si_name, secinfo->si_namelen);
|
2012-11-25 21:31:00 +00:00
|
|
|
status = check_filename(secinfo->si_name, secinfo->si_namelen);
|
2007-07-17 11:04:51 +00:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2010-12-16 14:51:13 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_secinfo_no_name *sin)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(sin->sin_style);
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr)
|
|
|
|
{
|
2008-08-12 17:46:18 +00:00
|
|
|
__be32 status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-12 17:46:18 +00:00
|
|
|
status = nfsd4_decode_stateid(argp, &setattr->sa_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2009-05-16 08:22:31 +00:00
|
|
|
return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr,
|
|
|
|
&setattr->sa_acl);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2012-03-02 22:13:50 +00:00
|
|
|
READ_BUF(NFS4_VERIFIER_SIZE);
|
|
|
|
COPYMEM(setclientid->se_verf.data, NFS4_VERIFIER_SIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-10-10 19:07:40 +00:00
|
|
|
status = nfsd4_decode_opaque(argp, &setclientid->se_name);
|
|
|
|
if (status)
|
|
|
|
return nfserr_bad_xdr;
|
|
|
|
READ_BUF(8);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ32(setclientid->se_callback_prog);
|
|
|
|
READ32(setclientid->se_callback_netid_len);
|
|
|
|
|
|
|
|
READ_BUF(setclientid->se_callback_netid_len + 4);
|
|
|
|
SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len);
|
|
|
|
READ32(setclientid->se_callback_addr_len);
|
|
|
|
|
|
|
|
READ_BUF(setclientid->se_callback_addr_len + 4);
|
|
|
|
SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len);
|
|
|
|
READ32(setclientid->se_callback_ident);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2012-03-02 22:13:50 +00:00
|
|
|
READ_BUF(8 + NFS4_VERIFIER_SIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
COPYMEM(&scd_c->sc_clientid, 8);
|
2012-03-02 22:13:50 +00:00
|
|
|
COPYMEM(&scd_c->sc_confirm, NFS4_VERIFIER_SIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Also used for NVERIFY */
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00: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-11-30 22:24:18 +00:00
|
|
|
* nfsd4_proc_verify */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
READ_BUF(4);
|
|
|
|
READ32(verify->ve_attrlen);
|
|
|
|
READ_BUF(verify->ve_attrlen);
|
|
|
|
SAVEMEM(verify->ve_attrval, verify->ve_attrlen);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write)
|
|
|
|
{
|
|
|
|
int avail;
|
|
|
|
int len;
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
2008-08-12 17:46:18 +00:00
|
|
|
status = nfsd4_decode_stateid(argp, &write->wr_stateid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(16);
|
2005-04-16 22:20:36 +00:00
|
|
|
READ64(write->wr_offset);
|
|
|
|
READ32(write->wr_stable_how);
|
|
|
|
if (write->wr_stable_how > 2)
|
|
|
|
goto xdr_error;
|
|
|
|
READ32(write->wr_buflen);
|
|
|
|
|
|
|
|
/* 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 < write->wr_buflen) {
|
2007-09-11 22:01:20 +00:00
|
|
|
dprintk("NFSD: xdr error (%s:%d)\n",
|
|
|
|
__FILE__, __LINE__);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto xdr_error;
|
|
|
|
}
|
2012-11-16 19:16:46 +00:00
|
|
|
write->wr_head.iov_base = p;
|
|
|
|
write->wr_head.iov_len = avail;
|
2012-11-16 15:01:30 +00:00
|
|
|
WARN_ON(avail != (XDR_QUADLEN(avail) << 2));
|
2012-11-16 19:16:46 +00:00
|
|
|
write->wr_pagelist = argp->pagelist;
|
2012-11-16 15:01:30 +00:00
|
|
|
|
|
|
|
len = XDR_QUADLEN(write->wr_buflen) << 2;
|
|
|
|
if (len >= avail) {
|
|
|
|
int pages;
|
|
|
|
|
|
|
|
len -= avail;
|
|
|
|
|
|
|
|
pages = len >> PAGE_SHIFT;
|
|
|
|
argp->pagelist += pages;
|
|
|
|
argp->pagelen -= pages * PAGE_SIZE;
|
|
|
|
len -= pages * PAGE_SIZE;
|
|
|
|
|
|
|
|
argp->p = (__be32 *)page_address(argp->pagelist[0]);
|
|
|
|
argp->end = argp->p + XDR_QUADLEN(PAGE_SIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2012-11-16 15:01:30 +00:00
|
|
|
argp->p += XDR_QUADLEN(len);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(12);
|
|
|
|
COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t));
|
|
|
|
READ32(rlockowner->rl_owner.len);
|
|
|
|
READ_BUF(rlockowner->rl_owner.len);
|
|
|
|
READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len);
|
|
|
|
|
2009-04-03 05:28:50 +00:00
|
|
|
if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))
|
|
|
|
return nfserr_inval;
|
2005-04-16 22:20:36 +00:00
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2009-04-03 05:27:55 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp,
|
2009-04-03 05:28:01 +00:00
|
|
|
struct nfsd4_exchange_id *exid)
|
2009-04-03 05:27:55 +00:00
|
|
|
{
|
2010-11-09 01:39:23 +00:00
|
|
|
int dummy, tmp;
|
2009-04-03 05:28:01 +00:00
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(NFS4_VERIFIER_SIZE);
|
|
|
|
COPYMEM(exid->verifier.data, NFS4_VERIFIER_SIZE);
|
|
|
|
|
2011-10-10 19:07:40 +00:00
|
|
|
status = nfsd4_decode_opaque(argp, &exid->clname);
|
|
|
|
if (status)
|
|
|
|
return nfserr_bad_xdr;
|
2009-04-03 05:28:01 +00:00
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(exid->flags);
|
|
|
|
|
|
|
|
/* Ignore state_protect4_a */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(exid->spa_how);
|
|
|
|
switch (exid->spa_how) {
|
|
|
|
case SP4_NONE:
|
|
|
|
break;
|
|
|
|
case SP4_MACH_CRED:
|
|
|
|
/* spo_must_enforce */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy * 4);
|
|
|
|
p += dummy;
|
|
|
|
|
|
|
|
/* spo_must_allow */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy * 4);
|
|
|
|
p += dummy;
|
|
|
|
break;
|
|
|
|
case SP4_SSV:
|
|
|
|
/* ssp_ops */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy * 4);
|
|
|
|
p += dummy;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy * 4);
|
|
|
|
p += dummy;
|
|
|
|
|
|
|
|
/* ssp_hash_algs<> */
|
|
|
|
READ_BUF(4);
|
2010-11-09 01:39:23 +00:00
|
|
|
READ32(tmp);
|
|
|
|
while (tmp--) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy);
|
|
|
|
p += XDR_QUADLEN(dummy);
|
|
|
|
}
|
2009-04-03 05:28:01 +00:00
|
|
|
|
|
|
|
/* ssp_encr_algs<> */
|
|
|
|
READ_BUF(4);
|
2010-11-09 01:39:23 +00:00
|
|
|
READ32(tmp);
|
|
|
|
while (tmp--) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy);
|
|
|
|
p += XDR_QUADLEN(dummy);
|
|
|
|
}
|
2009-04-03 05:28:01 +00:00
|
|
|
|
|
|
|
/* ssp_window and ssp_num_gss_handles */
|
|
|
|
READ_BUF(8);
|
|
|
|
READ32(dummy);
|
|
|
|
READ32(dummy);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ignore Implementation ID */
|
|
|
|
READ_BUF(4); /* nfs_impl_id4 array length */
|
|
|
|
READ32(dummy);
|
|
|
|
|
|
|
|
if (dummy > 1)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
if (dummy == 1) {
|
|
|
|
/* nii_domain */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy);
|
|
|
|
p += XDR_QUADLEN(dummy);
|
|
|
|
|
|
|
|
/* nii_name */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(dummy);
|
|
|
|
READ_BUF(dummy);
|
|
|
|
p += XDR_QUADLEN(dummy);
|
|
|
|
|
|
|
|
/* nii_date */
|
|
|
|
READ_BUF(12);
|
|
|
|
p += 3;
|
|
|
|
}
|
|
|
|
DECODE_TAIL;
|
2009-04-03 05:27:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_create_session(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_create_session *sess)
|
|
|
|
{
|
2009-04-03 05:28:28 +00:00
|
|
|
DECODE_HEAD;
|
|
|
|
u32 dummy;
|
|
|
|
|
|
|
|
READ_BUF(16);
|
|
|
|
COPYMEM(&sess->clientid, 8);
|
|
|
|
READ32(sess->seqid);
|
|
|
|
READ32(sess->flags);
|
|
|
|
|
|
|
|
/* Fore channel attrs */
|
|
|
|
READ_BUF(28);
|
|
|
|
READ32(dummy); /* headerpadsz is always 0 */
|
|
|
|
READ32(sess->fore_channel.maxreq_sz);
|
|
|
|
READ32(sess->fore_channel.maxresp_sz);
|
|
|
|
READ32(sess->fore_channel.maxresp_cached);
|
|
|
|
READ32(sess->fore_channel.maxops);
|
|
|
|
READ32(sess->fore_channel.maxreqs);
|
|
|
|
READ32(sess->fore_channel.nr_rdma_attrs);
|
|
|
|
if (sess->fore_channel.nr_rdma_attrs == 1) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(sess->fore_channel.rdma_attrs);
|
|
|
|
} 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);
|
|
|
|
READ32(dummy); /* headerpadsz is always 0 */
|
|
|
|
READ32(sess->back_channel.maxreq_sz);
|
|
|
|
READ32(sess->back_channel.maxresp_sz);
|
|
|
|
READ32(sess->back_channel.maxresp_cached);
|
|
|
|
READ32(sess->back_channel.maxops);
|
|
|
|
READ32(sess->back_channel.maxreqs);
|
|
|
|
READ32(sess->back_channel.nr_rdma_attrs);
|
|
|
|
if (sess->back_channel.nr_rdma_attrs == 1) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(sess->back_channel.rdma_attrs);
|
|
|
|
} else if (sess->back_channel.nr_rdma_attrs > 1) {
|
|
|
|
dprintk("Too many back channel attr bitmaps!\n");
|
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
|
2012-03-27 18:50:26 +00:00
|
|
|
READ_BUF(4);
|
2009-04-03 05:28:28 +00:00
|
|
|
READ32(sess->callback_prog);
|
2012-03-27 18:50:26 +00:00
|
|
|
nfsd4_decode_cb_sec(argp, &sess->cb_sec);
|
2009-04-03 05:28:28 +00:00
|
|
|
DECODE_TAIL;
|
2009-04-03 05:27:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_destroy_session *destroy_session)
|
|
|
|
{
|
2009-04-03 05:28:38 +00:00
|
|
|
DECODE_HEAD;
|
|
|
|
READ_BUF(NFS4_MAX_SESSIONID_LEN);
|
|
|
|
COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
2009-04-03 05:27:55 +00:00
|
|
|
}
|
|
|
|
|
2011-07-13 15:04:21 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_free_stateid *free_stateid)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(sizeof(stateid_t));
|
|
|
|
READ32(free_stateid->fr_stateid.si_generation);
|
|
|
|
COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t));
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2009-04-03 05:27:55 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_sequence(struct nfsd4_compoundargs *argp,
|
|
|
|
struct nfsd4_sequence *seq)
|
|
|
|
{
|
2009-04-03 05:28:08 +00:00
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(NFS4_MAX_SESSIONID_LEN + 16);
|
|
|
|
COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);
|
|
|
|
READ32(seq->seqid);
|
|
|
|
READ32(seq->slotid);
|
|
|
|
READ32(seq->maxslots);
|
|
|
|
READ32(seq->cachethis);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
2009-04-03 05:27:55 +00:00
|
|
|
}
|
|
|
|
|
2011-07-13 14:50:48 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid)
|
|
|
|
{
|
|
|
|
int i;
|
2012-01-27 15:22:49 +00:00
|
|
|
__be32 *p, status;
|
|
|
|
struct nfsd4_test_stateid_id *stateid;
|
2011-07-13 14:50:48 +00:00
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
test_stateid->ts_num_ids = ntohl(*p++);
|
|
|
|
|
2012-01-27 15:22:49 +00:00
|
|
|
INIT_LIST_HEAD(&test_stateid->ts_stateid_list);
|
2011-07-13 14:50:48 +00:00
|
|
|
|
|
|
|
for (i = 0; i < test_stateid->ts_num_ids; i++) {
|
2012-01-27 15:22:49 +00:00
|
|
|
stateid = kmalloc(sizeof(struct nfsd4_test_stateid_id), GFP_KERNEL);
|
|
|
|
if (!stateid) {
|
2012-04-13 04:15:37 +00:00
|
|
|
status = nfserrno(-ENOMEM);
|
2012-01-27 15:22:49 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
defer_free(argp, kfree, stateid);
|
|
|
|
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 14:50:48 +00:00
|
|
|
if (status)
|
2012-01-27 15:22:49 +00:00
|
|
|
goto out;
|
2011-07-13 14:50:48 +00: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 09:51:39 +00: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-19 19:11:28 +00:00
|
|
|
static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, struct nfsd4_reclaim_complete *rc)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(rc->rca_one_fs);
|
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
2008-07-02 08:13:41 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p)
|
|
|
|
{
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2008-07-02 08:14:01 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p)
|
|
|
|
{
|
2009-03-04 21:06:06 +00:00
|
|
|
return nfserr_notsupp;
|
2008-07-02 08:14:01 +00:00
|
|
|
}
|
|
|
|
|
2008-07-02 08:13:41 +00:00
|
|
|
typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *);
|
|
|
|
|
|
|
|
static nfsd4_dec nfsd4_dec_ops[] = {
|
2008-07-18 19:04:16 +00: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,
|
2009-03-09 16:17:29 +00:00
|
|
|
[OP_PUTPUBFH] = (nfsd4_dec)nfsd4_decode_noop,
|
2008-07-18 19:04:16 +00: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,
|
2008-07-02 08:13:41 +00:00
|
|
|
};
|
|
|
|
|
2009-04-03 05:27:55 +00:00
|
|
|
static nfsd4_dec nfsd41_dec_ops[] = {
|
2009-04-28 23:48:25 +00: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_notsupp,
|
|
|
|
[OP_OPEN_DOWNGRADE] = (nfsd4_dec)nfsd4_decode_open_downgrade,
|
|
|
|
[OP_PUTFH] = (nfsd4_dec)nfsd4_decode_putfh,
|
|
|
|
[OP_PUTPUBFH] = (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[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_notsupp,
|
|
|
|
[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_notsupp,
|
|
|
|
[OP_SETCLIENTID_CONFIRM]= (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[OP_VERIFY] = (nfsd4_dec)nfsd4_decode_verify,
|
|
|
|
[OP_WRITE] = (nfsd4_dec)nfsd4_decode_write,
|
|
|
|
[OP_RELEASE_LOCKOWNER] = (nfsd4_dec)nfsd4_decode_notsupp,
|
2009-04-03 05:27:55 +00:00
|
|
|
|
|
|
|
/* new operations for NFSv4.1 */
|
2012-11-01 22:09:48 +00:00
|
|
|
[OP_BACKCHANNEL_CTL] = (nfsd4_dec)nfsd4_decode_backchannel_ctl,
|
2010-10-05 03:12:59 +00:00
|
|
|
[OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session,
|
2009-04-28 23:48:25 +00: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 15:04:21 +00:00
|
|
|
[OP_FREE_STATEID] = (nfsd4_dec)nfsd4_decode_free_stateid,
|
2009-04-28 23:48:25 +00:00
|
|
|
[OP_GET_DIR_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp,
|
|
|
|
[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,
|
2010-12-16 14:51:13 +00:00
|
|
|
[OP_SECINFO_NO_NAME] = (nfsd4_dec)nfsd4_decode_secinfo_no_name,
|
2009-04-28 23:48:25 +00:00
|
|
|
[OP_SEQUENCE] = (nfsd4_dec)nfsd4_decode_sequence,
|
|
|
|
[OP_SET_SSV] = (nfsd4_dec)nfsd4_decode_notsupp,
|
2011-07-13 14:50:48 +00:00
|
|
|
[OP_TEST_STATEID] = (nfsd4_dec)nfsd4_decode_test_stateid,
|
2009-04-28 23:48:25 +00:00
|
|
|
[OP_WANT_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp,
|
2011-10-20 09:51:39 +00:00
|
|
|
[OP_DESTROY_CLIENTID] = (nfsd4_dec)nfsd4_decode_destroy_clientid,
|
2010-04-19 19:11:28 +00:00
|
|
|
[OP_RECLAIM_COMPLETE] = (nfsd4_dec)nfsd4_decode_reclaim_complete,
|
2009-04-03 05:27:55 +00:00
|
|
|
};
|
|
|
|
|
2008-07-02 08:14:22 +00:00
|
|
|
struct nfsd4_minorversion_ops {
|
|
|
|
nfsd4_dec *decoders;
|
|
|
|
int nops;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct nfsd4_minorversion_ops nfsd4_minorversion[] = {
|
2008-07-18 19:04:16 +00:00
|
|
|
[0] = { nfsd4_dec_ops, ARRAY_SIZE(nfsd4_dec_ops) },
|
2009-04-03 05:27:55 +00:00
|
|
|
[1] = { nfsd41_dec_ops, ARRAY_SIZE(nfsd41_dec_ops) },
|
2008-07-02 08:14:22 +00:00
|
|
|
};
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
|
|
|
|
{
|
|
|
|
DECODE_HEAD;
|
|
|
|
struct nfsd4_op *op;
|
2008-07-02 08:14:22 +00:00
|
|
|
struct nfsd4_minorversion_ops *ops;
|
2011-01-24 17:11:02 +00:00
|
|
|
bool cachethis = false;
|
2005-04-16 22:20:36 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(argp->taglen);
|
|
|
|
READ_BUF(argp->taglen + 8);
|
|
|
|
SAVEMEM(argp->tag, argp->taglen);
|
|
|
|
READ32(argp->minorversion);
|
|
|
|
READ32(argp->opcnt);
|
|
|
|
|
|
|
|
if (argp->taglen > NFSD4_MAX_TAGLEN)
|
|
|
|
goto xdr_error;
|
|
|
|
if (argp->opcnt > 100)
|
|
|
|
goto xdr_error;
|
|
|
|
|
2006-03-24 11:15:34 +00:00
|
|
|
if (argp->opcnt > ARRAY_SIZE(argp->iops)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
argp->ops = kmalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);
|
|
|
|
if (!argp->ops) {
|
|
|
|
argp->ops = argp->iops;
|
2007-09-11 22:01:20 +00:00
|
|
|
dprintk("nfsd: couldn't allocate room for COMPOUND\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto xdr_error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-02 08:14:22 +00:00
|
|
|
if (argp->minorversion >= ARRAY_SIZE(nfsd4_minorversion))
|
2008-07-02 08:13:18 +00:00
|
|
|
argp->opcnt = 0;
|
|
|
|
|
2008-07-02 08:14:22 +00:00
|
|
|
ops = &nfsd4_minorversion[argp->minorversion];
|
2005-04-16 22:20:36 +00:00
|
|
|
for (i = 0; i < argp->opcnt; i++) {
|
|
|
|
op = &argp->ops[i];
|
|
|
|
op->replay = NULL;
|
|
|
|
|
2012-11-17 03:28:38 +00:00
|
|
|
READ_BUF(4);
|
|
|
|
READ32(op->opnum);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-12-12 04:03:27 +00:00
|
|
|
if (op->opnum >= FIRST_NFS4_OP && op->opnum <= LAST_NFS4_OP)
|
2008-07-02 08:14:22 +00:00
|
|
|
op->status = ops->decoders[op->opnum](argp, &op->u);
|
2008-07-02 08:13:41 +00:00
|
|
|
else {
|
2005-04-16 22:20:36 +00:00
|
|
|
op->opnum = OP_ILLEGAL;
|
|
|
|
op->status = nfserr_op_illegal;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (op->status) {
|
|
|
|
argp->opcnt = i+1;
|
|
|
|
break;
|
|
|
|
}
|
2011-01-24 17:11:02 +00: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);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2011-01-24 17:11:02 +00:00
|
|
|
/* Sessions make the DRC unnecessary: */
|
|
|
|
if (argp->minorversion)
|
|
|
|
cachethis = false;
|
|
|
|
argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
DECODE_TAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define WRITE32(n) *p++ = htonl(n)
|
|
|
|
#define WRITE64(n) do { \
|
|
|
|
*p++ = htonl((u32)((n) >> 32)); \
|
|
|
|
*p++ = htonl((u32)(n)); \
|
|
|
|
} while (0)
|
2008-07-18 04:33:04 +00:00
|
|
|
#define WRITEMEM(ptr,nbytes) do { if (nbytes > 0) { \
|
2005-04-16 22:20:36 +00:00
|
|
|
*(p + XDR_QUADLEN(nbytes) -1) = 0; \
|
|
|
|
memcpy(p, ptr, nbytes); \
|
|
|
|
p += XDR_QUADLEN(nbytes); \
|
2008-07-18 04:33:04 +00:00
|
|
|
}} while (0)
|
2009-04-16 21:33:25 +00:00
|
|
|
|
|
|
|
static void write32(__be32 **p, u32 n)
|
|
|
|
{
|
2012-04-25 22:11:04 +00:00
|
|
|
*(*p)++ = htonl(n);
|
2009-04-16 21:33:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void write64(__be32 **p, u64 n)
|
|
|
|
{
|
2012-04-25 22:11:04 +00:00
|
|
|
write32(p, (n >> 32));
|
2009-04-16 21:33:25 +00:00
|
|
|
write32(p, (u32)n);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void write_change(__be32 **p, struct kstat *stat, struct inode *inode)
|
|
|
|
{
|
|
|
|
if (IS_I_VERSION(inode)) {
|
|
|
|
write64(p, inode->i_version);
|
|
|
|
} else {
|
|
|
|
write32(p, stat->ctime.tv_sec);
|
|
|
|
write32(p, stat->ctime.tv_nsec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void write_cinfo(__be32 **p, struct nfsd4_change_info *c)
|
|
|
|
{
|
|
|
|
write32(p, c->atomic);
|
|
|
|
if (c->change_supported) {
|
|
|
|
write64(p, c->before_change);
|
|
|
|
write64(p, c->after_change);
|
|
|
|
} else {
|
|
|
|
write32(p, c->before_ctime_sec);
|
|
|
|
write32(p, c->before_ctime_nsec);
|
|
|
|
write32(p, c->after_ctime_sec);
|
|
|
|
write32(p, c->after_ctime_nsec);
|
|
|
|
}
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define RESERVE_SPACE(nbytes) do { \
|
|
|
|
p = resp->p; \
|
|
|
|
BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end); \
|
|
|
|
} while (0)
|
|
|
|
#define ADJUST_ARGS() resp->p = p
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Header routine to setup seqid operation replay cache
|
|
|
|
*/
|
|
|
|
#define ENCODE_SEQID_OP_HEAD \
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *save; \
|
2005-04-16 22:20:36 +00:00
|
|
|
\
|
|
|
|
save = resp->p;
|
|
|
|
|
|
|
|
/*
|
2005-07-08 00:59:20 +00:00
|
|
|
* Routine for encoding the result of a "seqid-mutating" NFSv4 operation. This
|
|
|
|
* is where sequence id's are incremented, and the replay cache is filled.
|
|
|
|
* Note that we increment sequence id's here, at the last moment, so we're sure
|
|
|
|
* we know whether the error to be returned is a sequence id mutating error.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
2011-08-24 16:27:31 +00:00
|
|
|
static void encode_seqid_op_tail(struct nfsd4_compoundres *resp, __be32 *save, __be32 nfserr)
|
|
|
|
{
|
|
|
|
struct nfs4_stateowner *stateowner = resp->cstate.replay_owner;
|
|
|
|
|
|
|
|
if (seqid_mutating_err(ntohl(nfserr)) && stateowner) {
|
|
|
|
stateowner->so_seqid++;
|
|
|
|
stateowner->so_replay.rp_status = nfserr;
|
|
|
|
stateowner->so_replay.rp_buflen =
|
|
|
|
(char *)resp->p - (char *)save;
|
|
|
|
memcpy(stateowner->so_replay.rp_buf, save,
|
|
|
|
stateowner->so_replay.rp_buflen);
|
2011-09-16 21:42:48 +00:00
|
|
|
nfsd4_purge_closed_stateid(stateowner);
|
2011-08-24 16:27:31 +00:00
|
|
|
}
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-04 09:16:19 +00:00
|
|
|
/* Encode as an array of strings the string given with components
|
2012-04-24 15:07:59 +00:00
|
|
|
* separated @sep, escaped with esc_enter and esc_exit.
|
2006-10-04 09:16:19 +00:00
|
|
|
*/
|
2012-04-24 15:07:59 +00:00
|
|
|
static __be32 nfsd4_encode_components_esc(char sep, char *components,
|
|
|
|
__be32 **pp, int *buflen,
|
|
|
|
char esc_enter, char esc_exit)
|
2006-10-04 09:16:19 +00:00
|
|
|
{
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *p = *pp;
|
|
|
|
__be32 *countp = p;
|
2006-10-04 09:16:19 +00:00
|
|
|
int strlen, count=0;
|
2012-04-24 15:07:59 +00:00
|
|
|
char *str, *end, *next;
|
2006-10-04 09:16:19 +00:00
|
|
|
|
|
|
|
dprintk("nfsd4_encode_components(%s)\n", components);
|
|
|
|
if ((*buflen -= 4) < 0)
|
|
|
|
return nfserr_resource;
|
|
|
|
WRITE32(0); /* We will fill this in with @count later */
|
|
|
|
end = str = components;
|
|
|
|
while (*end) {
|
2012-04-24 15:07:59 +00: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 09:16:19 +00:00
|
|
|
strlen = end - str;
|
|
|
|
if (strlen) {
|
|
|
|
if ((*buflen -= ((XDR_QUADLEN(strlen) << 2) + 4)) < 0)
|
|
|
|
return nfserr_resource;
|
|
|
|
WRITE32(strlen);
|
|
|
|
WRITEMEM(str, strlen);
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
end++;
|
|
|
|
str = end;
|
|
|
|
}
|
|
|
|
*pp = p;
|
|
|
|
p = countp;
|
|
|
|
WRITE32(count);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-24 15:07:59 +00:00
|
|
|
/* Encode as an array of strings the string given with components
|
|
|
|
* separated @sep.
|
|
|
|
*/
|
|
|
|
static __be32 nfsd4_encode_components(char sep, char *components,
|
|
|
|
__be32 **pp, int *buflen)
|
|
|
|
{
|
|
|
|
return nfsd4_encode_components_esc(sep, components, pp, buflen, 0, 0);
|
|
|
|
}
|
|
|
|
|
2006-10-04 09:16:19 +00:00
|
|
|
/*
|
|
|
|
* encode a location element of a fs_locations structure
|
|
|
|
*/
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32 nfsd4_encode_fs_location4(struct nfsd4_fs_location *location,
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 **pp, int *buflen)
|
2006-10-04 09:16:19 +00:00
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *p = *pp;
|
2006-10-04 09:16:19 +00:00
|
|
|
|
2012-04-24 15:07:59 +00:00
|
|
|
status = nfsd4_encode_components_esc(':', location->hosts, &p, buflen,
|
|
|
|
'[', ']');
|
2006-10-04 09:16:19 +00:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
status = nfsd4_encode_components('/', location->path, &p, buflen);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
*pp = p;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-09-12 23:37:06 +00:00
|
|
|
* Encode a path in RFC3530 'pathname4' format
|
2006-10-04 09:16:19 +00:00
|
|
|
*/
|
2011-09-12 23:37:06 +00:00
|
|
|
static __be32 nfsd4_encode_path(const struct path *root,
|
|
|
|
const struct path *path, __be32 **pp, int *buflen)
|
2006-10-04 09:16:19 +00:00
|
|
|
{
|
2011-09-12 23:37:06 +00:00
|
|
|
struct path cur = {
|
|
|
|
.mnt = path->mnt,
|
|
|
|
.dentry = path->dentry,
|
|
|
|
};
|
|
|
|
__be32 *p = *pp;
|
|
|
|
struct dentry **components = NULL;
|
|
|
|
unsigned int ncomponents = 0;
|
|
|
|
__be32 err = nfserr_jukebox;
|
2006-10-04 09:16:19 +00:00
|
|
|
|
2011-09-12 23:37:06 +00:00
|
|
|
dprintk("nfsd4_encode_components(");
|
2006-10-04 09:16:19 +00:00
|
|
|
|
2011-09-12 23:37:06 +00:00
|
|
|
path_get(&cur);
|
|
|
|
/* First walk the path up to the nfsd root, and store the
|
|
|
|
* dentries/path components in an array.
|
|
|
|
*/
|
|
|
|
for (;;) {
|
|
|
|
if (cur.dentry == root->dentry && cur.mnt == root->mnt)
|
|
|
|
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);
|
|
|
|
}
|
2006-10-04 09:16:19 +00:00
|
|
|
|
2011-09-12 23:37:06 +00:00
|
|
|
*buflen -= 4;
|
|
|
|
if (*buflen < 0)
|
|
|
|
goto out_free;
|
|
|
|
WRITE32(ncomponents);
|
|
|
|
|
|
|
|
while (ncomponents) {
|
|
|
|
struct dentry *dentry = components[ncomponents - 1];
|
|
|
|
unsigned int len = dentry->d_name.len;
|
|
|
|
|
|
|
|
*buflen -= 4 + (XDR_QUADLEN(len) << 2);
|
|
|
|
if (*buflen < 0)
|
|
|
|
goto out_free;
|
|
|
|
WRITE32(len);
|
|
|
|
WRITEMEM(dentry->d_name.name, len);
|
|
|
|
dprintk("/%s", dentry->d_name.name);
|
|
|
|
dput(dentry);
|
|
|
|
ncomponents--;
|
2006-10-04 09:16:19 +00:00
|
|
|
}
|
2011-09-12 23:37:06 +00:00
|
|
|
|
|
|
|
*pp = p;
|
|
|
|
err = 0;
|
|
|
|
out_free:
|
|
|
|
dprintk(")\n");
|
|
|
|
while (ncomponents)
|
|
|
|
dput(components[--ncomponents]);
|
|
|
|
kfree(components);
|
|
|
|
path_put(&cur);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32 nfsd4_encode_fsloc_fsroot(struct svc_rqst *rqstp,
|
|
|
|
const struct path *path, __be32 **pp, int *buflen)
|
|
|
|
{
|
|
|
|
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));
|
|
|
|
res = nfsd4_encode_path(&exp_ps->ex_path, path, pp, buflen);
|
|
|
|
exp_put(exp_ps);
|
|
|
|
return res;
|
2006-10-04 09:16:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* encode a fs_locations structure
|
|
|
|
*/
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32 nfsd4_encode_fs_locations(struct svc_rqst *rqstp,
|
2006-10-04 09:16:19 +00:00
|
|
|
struct svc_export *exp,
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 **pp, int *buflen)
|
2006-10-04 09:16:19 +00:00
|
|
|
{
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2006-10-20 06:28:44 +00:00
|
|
|
int i;
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *p = *pp;
|
2006-10-04 09:16:19 +00:00
|
|
|
struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;
|
|
|
|
|
2011-09-12 23:37:06 +00:00
|
|
|
status = nfsd4_encode_fsloc_fsroot(rqstp, &exp->ex_path, &p, buflen);
|
2006-10-04 09:16:19 +00:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
if ((*buflen -= 4) < 0)
|
|
|
|
return nfserr_resource;
|
|
|
|
WRITE32(fslocs->locations_count);
|
|
|
|
for (i=0; i<fslocs->locations_count; i++) {
|
|
|
|
status = nfsd4_encode_fs_location4(&fslocs->locations[i],
|
|
|
|
&p, buflen);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
*pp = p;
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-08-15 15:49:30 +00: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-16 22:20:36 +00:00
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_encode_name(struct svc_rqst *rqstp, int whotype, uid_t id, int group,
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 **p, int *buflen)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
|
|
|
if (*buflen < (XDR_QUADLEN(IDMAP_NAMESZ) << 2) + 4)
|
|
|
|
return nfserr_resource;
|
|
|
|
if (whotype != NFS4_ACL_WHO_NAMED)
|
|
|
|
status = nfs4_acl_write_who(whotype, (u8 *)(*p + 1));
|
|
|
|
else if (group)
|
|
|
|
status = nfsd_map_gid_to_name(rqstp, id, (u8 *)(*p + 1));
|
|
|
|
else
|
|
|
|
status = nfsd_map_uid_to_name(rqstp, id, (u8 *)(*p + 1));
|
|
|
|
if (status < 0)
|
|
|
|
return nfserrno(status);
|
|
|
|
*p = xdr_encode_opaque(*p, NULL, status);
|
|
|
|
*buflen -= (XDR_QUADLEN(status) << 2) + 4;
|
|
|
|
BUG_ON(*buflen < 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static inline __be32
|
2006-10-20 06:28:58 +00:00
|
|
|
nfsd4_encode_user(struct svc_rqst *rqstp, uid_t uid, __be32 **p, int *buflen)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
return nfsd4_encode_name(rqstp, NFS4_ACL_WHO_NAMED, uid, 0, p, buflen);
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static inline __be32
|
2006-10-20 06:28:58 +00:00
|
|
|
nfsd4_encode_group(struct svc_rqst *rqstp, uid_t gid, __be32 **p, int *buflen)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
return nfsd4_encode_name(rqstp, NFS4_ACL_WHO_NAMED, gid, 1, p, buflen);
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static inline __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_encode_aclname(struct svc_rqst *rqstp, int whotype, uid_t id, int group,
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 **p, int *buflen)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
return nfsd4_encode_name(rqstp, whotype, id, group, p, buflen);
|
|
|
|
}
|
|
|
|
|
2006-10-04 09:16:20 +00: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
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err)
|
2006-10-04 09:16:20 +00: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;
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-10-01 21:50:56 +00: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;
|
|
|
|
}
|
|
|
|
err = vfs_getattr(path.mnt, path.dentry, stat);
|
|
|
|
path_put(&path);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Note: @fhp can be NULL; in this case, we might have to compose the filehandle
|
|
|
|
* ourselves.
|
|
|
|
*
|
|
|
|
* @countp is the buffer size in _words_; upon successful return this becomes
|
|
|
|
* replaced with the number of words written.
|
|
|
|
*/
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
|
2006-10-20 06:28:58 +00:00
|
|
|
struct dentry *dentry, __be32 *buffer, int *countp, u32 *bmval,
|
2007-11-27 19:34:05 +00:00
|
|
|
struct svc_rqst *rqstp, int ignore_crossmnt)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
u32 bmval0 = bmval[0];
|
|
|
|
u32 bmval1 = bmval[1];
|
2009-04-03 05:29:11 +00:00
|
|
|
u32 bmval2 = bmval[2];
|
2005-04-16 22:20:36 +00:00
|
|
|
struct kstat stat;
|
|
|
|
struct svc_fh tempfh;
|
|
|
|
struct kstatfs statfs;
|
|
|
|
int buflen = *countp << 2;
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *attrlenp;
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 dummy;
|
|
|
|
u64 dummy64;
|
2006-10-04 09:16:20 +00:00
|
|
|
u32 rdattr_err = 0;
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *p = buffer;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 status;
|
2006-10-20 06:29:01 +00:00
|
|
|
int err;
|
2005-04-16 22:20:36 +00:00
|
|
|
int aclsupport = 0;
|
|
|
|
struct nfs4_acl *acl = NULL;
|
2009-04-03 05:29:11 +00:00
|
|
|
struct nfsd4_compoundres *resp = rqstp->rq_resp;
|
|
|
|
u32 minorversion = resp->cstate.minorversion;
|
2010-07-07 16:53:11 +00:00
|
|
|
struct path path = {
|
|
|
|
.mnt = exp->ex_path.mnt,
|
|
|
|
.dentry = dentry,
|
|
|
|
};
|
2012-11-27 11:11:44 +00:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1);
|
2009-04-03 05:29:11 +00:00
|
|
|
BUG_ON(bmval0 & ~nfsd_suppattrs0(minorversion));
|
|
|
|
BUG_ON(bmval1 & ~nfsd_suppattrs1(minorversion));
|
|
|
|
BUG_ON(bmval2 & ~nfsd_suppattrs2(minorversion));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-04 09:16:20 +00:00
|
|
|
if (exp->ex_fslocs.migrated) {
|
2009-04-03 05:29:11 +00:00
|
|
|
BUG_ON(bmval[2]);
|
2006-10-04 09:16:20 +00:00
|
|
|
status = fattr_handle_absent_fs(&bmval0, &bmval1, &rdattr_err);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-02-15 03:38:39 +00:00
|
|
|
err = vfs_getattr(exp->ex_path.mnt, dentry, &stat);
|
2006-10-20 06:29:01 +00:00
|
|
|
if (err)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_nfserr;
|
2007-09-28 20:45:51 +00:00
|
|
|
if ((bmval0 & (FATTR4_WORD0_FILES_FREE | FATTR4_WORD0_FILES_TOTAL |
|
|
|
|
FATTR4_WORD0_MAXNAME)) ||
|
2005-04-16 22:20:36 +00:00
|
|
|
(bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |
|
|
|
|
FATTR4_WORD1_SPACE_TOTAL))) {
|
2010-07-07 16:53:11 +00:00
|
|
|
err = vfs_statfs(&path, &statfs);
|
2006-10-20 06:29:01 +00:00
|
|
|
if (err)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_nfserr;
|
|
|
|
}
|
|
|
|
if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) {
|
|
|
|
fh_init(&tempfh, NFS4_FHSIZE);
|
|
|
|
status = fh_compose(&tempfh, exp, dentry, NULL);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
fhp = &tempfh;
|
|
|
|
}
|
|
|
|
if (bmval0 & (FATTR4_WORD0_ACL | FATTR4_WORD0_ACLSUPPORT
|
|
|
|
| FATTR4_WORD0_SUPPORTED_ATTRS)) {
|
2006-10-20 06:29:01 +00:00
|
|
|
err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl);
|
|
|
|
aclsupport = (err == 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (bmval0 & FATTR4_WORD0_ACL) {
|
2006-10-20 06:29:01 +00:00
|
|
|
if (err == -EOPNOTSUPP)
|
2005-04-16 22:20:36 +00:00
|
|
|
bmval0 &= ~FATTR4_WORD0_ACL;
|
2006-10-20 06:29:01 +00:00
|
|
|
else if (err == -EINVAL) {
|
2005-04-16 22:20:36 +00:00
|
|
|
status = nfserr_attrnotsupp;
|
|
|
|
goto out;
|
2006-10-20 06:29:01 +00:00
|
|
|
} else if (err != 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_nfserr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-30 18:47:46 +00:00
|
|
|
if (bmval2) {
|
|
|
|
if ((buflen -= 16) < 0)
|
|
|
|
goto out_resource;
|
2009-04-03 05:29:11 +00:00
|
|
|
WRITE32(3);
|
|
|
|
WRITE32(bmval0);
|
|
|
|
WRITE32(bmval1);
|
|
|
|
WRITE32(bmval2);
|
2010-09-30 18:47:46 +00:00
|
|
|
} else if (bmval1) {
|
|
|
|
if ((buflen -= 12) < 0)
|
|
|
|
goto out_resource;
|
2009-04-03 05:29:11 +00:00
|
|
|
WRITE32(2);
|
|
|
|
WRITE32(bmval0);
|
|
|
|
WRITE32(bmval1);
|
|
|
|
} else {
|
2010-09-30 18:47:46 +00:00
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
2009-04-03 05:29:11 +00:00
|
|
|
WRITE32(1);
|
|
|
|
WRITE32(bmval0);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
attrlenp = p++; /* to be backfilled later */
|
|
|
|
|
|
|
|
if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
|
2009-04-03 05:29:11 +00:00
|
|
|
u32 word0 = nfsd_suppattrs0(minorversion);
|
|
|
|
u32 word1 = nfsd_suppattrs1(minorversion);
|
|
|
|
u32 word2 = nfsd_suppattrs2(minorversion);
|
|
|
|
|
2006-10-04 09:16:20 +00:00
|
|
|
if (!aclsupport)
|
|
|
|
word0 &= ~FATTR4_WORD0_ACL;
|
2009-04-03 05:29:11 +00:00
|
|
|
if (!word2) {
|
2010-09-30 18:47:46 +00:00
|
|
|
if ((buflen -= 12) < 0)
|
|
|
|
goto out_resource;
|
2009-04-03 05:29:11 +00:00
|
|
|
WRITE32(2);
|
|
|
|
WRITE32(word0);
|
|
|
|
WRITE32(word1);
|
|
|
|
} else {
|
2010-09-30 18:47:46 +00:00
|
|
|
if ((buflen -= 16) < 0)
|
|
|
|
goto out_resource;
|
2009-04-03 05:29:11 +00:00
|
|
|
WRITE32(3);
|
|
|
|
WRITE32(word0);
|
|
|
|
WRITE32(word1);
|
|
|
|
WRITE32(word2);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_TYPE) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
2011-08-15 15:49:30 +00:00
|
|
|
dummy = nfs4_file_type(stat.mode);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (dummy == NF4BAD)
|
|
|
|
goto out_serverfault;
|
|
|
|
WRITE32(dummy);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
2005-06-24 05:02:58 +00:00
|
|
|
if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)
|
2005-07-08 00:59:30 +00:00
|
|
|
WRITE32(NFS4_FH_PERSISTENT);
|
2005-06-24 05:02:58 +00:00
|
|
|
else
|
2005-07-08 00:59:30 +00:00
|
|
|
WRITE32(NFS4_FH_PERSISTENT|NFS4_FH_VOL_RENAME);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_CHANGE) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
2009-04-16 21:33:25 +00:00
|
|
|
write_change(&p, &stat, dentry->d_inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_SIZE) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE64(stat.size);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(1);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(1);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_NAMED_ATTR) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(0);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FSID) {
|
|
|
|
if ((buflen -= 16) < 0)
|
|
|
|
goto out_resource;
|
2006-10-04 09:16:20 +00:00
|
|
|
if (exp->ex_fslocs.migrated) {
|
|
|
|
WRITE64(NFS4_REFERRAL_FSID_MAJOR);
|
|
|
|
WRITE64(NFS4_REFERRAL_FSID_MINOR);
|
2007-02-14 08:33:12 +00:00
|
|
|
} else switch(fsid_source(fhp)) {
|
|
|
|
case FSIDSOURCE_FSID:
|
2005-04-16 22:20:36 +00:00
|
|
|
WRITE64((u64)exp->ex_fsid);
|
|
|
|
WRITE64((u64)0);
|
2007-02-14 08:33:12 +00:00
|
|
|
break;
|
|
|
|
case FSIDSOURCE_DEV:
|
2005-04-16 22:20:36 +00:00
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(MAJOR(stat.dev));
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(MINOR(stat.dev));
|
2007-02-14 08:33:12 +00:00
|
|
|
break;
|
|
|
|
case FSIDSOURCE_UUID:
|
|
|
|
WRITEMEM(exp->ex_uuid, 16);
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(0);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_LEASE_TIME) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
2012-11-27 11:11:44 +00:00
|
|
|
WRITE32(nn->nfsd4_lease);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
2006-10-04 09:16:20 +00:00
|
|
|
WRITE32(rdattr_err);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_ACL) {
|
|
|
|
struct nfs4_ace *ace;
|
|
|
|
|
|
|
|
if (acl == NULL) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
|
|
|
|
WRITE32(0);
|
|
|
|
goto out_acl;
|
|
|
|
}
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(acl->naces);
|
|
|
|
|
2007-02-16 09:28:30 +00:00
|
|
|
for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((buflen -= 4*3) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(ace->type);
|
|
|
|
WRITE32(ace->flag);
|
|
|
|
WRITE32(ace->access_mask & NFS4_ACE_MASK_ALL);
|
|
|
|
status = nfsd4_encode_aclname(rqstp, ace->whotype,
|
|
|
|
ace->who, ace->flag & NFS4_ACE_IDENTIFIER_GROUP,
|
|
|
|
&p, &buflen);
|
|
|
|
if (status == nfserr_resource)
|
|
|
|
goto out_resource;
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out_acl:
|
|
|
|
if (bmval0 & FATTR4_WORD0_ACLSUPPORT) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(aclsupport ?
|
|
|
|
ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_CANSETTIME) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(1);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
2012-06-05 20:52:06 +00:00
|
|
|
WRITE32(0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(1);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(1);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FILEHANDLE) {
|
|
|
|
buflen -= (XDR_QUADLEN(fhp->fh_handle.fh_size) << 2) + 4;
|
|
|
|
if (buflen < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(fhp->fh_handle.fh_size);
|
|
|
|
WRITEMEM(&fhp->fh_handle.fh_base, fhp->fh_handle.fh_size);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FILEID) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
2007-08-16 16:10:07 +00:00
|
|
|
WRITE64(stat.ino);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FILES_AVAIL) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE64((u64) statfs.f_ffree);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FILES_FREE) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE64((u64) statfs.f_ffree);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_FILES_TOTAL) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE64((u64) statfs.f_files);
|
|
|
|
}
|
2006-10-04 09:16:19 +00:00
|
|
|
if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) {
|
|
|
|
status = nfsd4_encode_fs_locations(rqstp, exp, &p, &buflen);
|
|
|
|
if (status == nfserr_resource)
|
|
|
|
goto out_resource;
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(1);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_MAXFILESIZE) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE64(~(u64)0);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_MAXLINK) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(255);
|
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_MAXNAME) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
2007-09-28 20:45:51 +00:00
|
|
|
WRITE32(statfs.f_namelen);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_MAXREAD) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
2006-10-04 09:15:47 +00:00
|
|
|
WRITE64((u64) svc_max_payload(rqstp));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (bmval0 & FATTR4_WORD0_MAXWRITE) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
2006-10-04 09:15:47 +00:00
|
|
|
WRITE64((u64) svc_max_payload(rqstp));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_MODE) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(stat.mode & S_IALLUGO);
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_NO_TRUNC) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(1);
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_NUMLINKS) {
|
|
|
|
if ((buflen -= 4) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(stat.nlink);
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_OWNER) {
|
|
|
|
status = nfsd4_encode_user(rqstp, stat.uid, &p, &buflen);
|
|
|
|
if (status == nfserr_resource)
|
|
|
|
goto out_resource;
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_OWNER_GROUP) {
|
|
|
|
status = nfsd4_encode_group(rqstp, stat.gid, &p, &buflen);
|
|
|
|
if (status == nfserr_resource)
|
|
|
|
goto out_resource;
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_RAWDEV) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32((u32) MAJOR(stat.rdev));
|
|
|
|
WRITE32((u32) MINOR(stat.rdev));
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize;
|
|
|
|
WRITE64(dummy64);
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_SPACE_FREE) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize;
|
|
|
|
WRITE64(dummy64);
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize;
|
|
|
|
WRITE64(dummy64);
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_SPACE_USED) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
dummy64 = (u64)stat.blocks << 9;
|
|
|
|
WRITE64(dummy64);
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_TIME_ACCESS) {
|
|
|
|
if ((buflen -= 12) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(stat.atime.tv_sec);
|
|
|
|
WRITE32(stat.atime.tv_nsec);
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_TIME_DELTA) {
|
|
|
|
if ((buflen -= 12) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(1);
|
|
|
|
WRITE32(0);
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_TIME_METADATA) {
|
|
|
|
if ((buflen -= 12) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(stat.ctime.tv_sec);
|
|
|
|
WRITE32(stat.ctime.tv_nsec);
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_TIME_MODIFY) {
|
|
|
|
if ((buflen -= 12) < 0)
|
|
|
|
goto out_resource;
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(stat.mtime.tv_sec);
|
|
|
|
WRITE32(stat.mtime.tv_nsec);
|
|
|
|
}
|
|
|
|
if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) {
|
|
|
|
if ((buflen -= 8) < 0)
|
|
|
|
goto out_resource;
|
2007-11-27 19:34:05 +00:00
|
|
|
/*
|
|
|
|
* Get parent's attributes if not ignoring crossmount
|
|
|
|
* and this is the root of a cross-mounted filesystem.
|
|
|
|
*/
|
|
|
|
if (ignore_crossmnt == 0 &&
|
2012-10-01 21:50:56 +00:00
|
|
|
dentry == exp->ex_path.mnt->mnt_root)
|
|
|
|
get_parent_attributes(exp, &stat);
|
2007-08-16 16:10:07 +00:00
|
|
|
WRITE64(stat.ino);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-04-03 05:29:14 +00:00
|
|
|
if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
|
|
|
|
WRITE32(3);
|
|
|
|
WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0);
|
|
|
|
WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD1);
|
|
|
|
WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD2);
|
|
|
|
}
|
2009-04-03 05:29:11 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
*attrlenp = htonl((char *)p - (char *)attrlenp - 4);
|
|
|
|
*countp = p - buffer;
|
|
|
|
status = nfs_ok;
|
|
|
|
|
|
|
|
out:
|
2007-02-16 09:28:30 +00:00
|
|
|
kfree(acl);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (fhp == &tempfh)
|
|
|
|
fh_put(&tempfh);
|
|
|
|
return status;
|
|
|
|
out_nfserr:
|
2006-10-20 06:29:01 +00:00
|
|
|
status = nfserrno(err);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
out_resource:
|
|
|
|
*countp = 0;
|
|
|
|
status = nfserr_resource;
|
|
|
|
goto out;
|
|
|
|
out_serverfault:
|
|
|
|
status = nfserr_serverfault;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-02-11 20:48:47 +00: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 06:28:59 +00:00
|
|
|
static __be32
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_encode_dirent_fattr(struct nfsd4_readdir *cd,
|
2006-10-20 06:28:58 +00:00
|
|
|
const char *name, int namlen, __be32 *p, int *buflen)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct svc_export *exp = cd->rd_fhp->fh_export;
|
|
|
|
struct dentry *dentry;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 nfserr;
|
2007-11-27 19:34:05 +00:00
|
|
|
int ignore_crossmnt = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
dentry = lookup_one_len(name, cd->rd_fhp->fh_dentry, namlen);
|
|
|
|
if (IS_ERR(dentry))
|
|
|
|
return nfserrno(PTR_ERR(dentry));
|
2009-05-05 23:04:29 +00:00
|
|
|
if (!dentry->d_inode) {
|
|
|
|
/*
|
|
|
|
* nfsd_buffered_readdir drops the i_mutex between
|
|
|
|
* readdir and calling this callback, leaving a window
|
|
|
|
* where this directory entry could have gone away.
|
|
|
|
*/
|
|
|
|
dput(dentry);
|
|
|
|
return nfserr_noent;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
exp_get(exp);
|
2007-11-27 19:34:05 +00: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 01:43:01 +00:00
|
|
|
if (nfsd_mountpoint(dentry, exp)) {
|
2006-12-13 08:35:24 +00:00
|
|
|
int err;
|
|
|
|
|
2009-10-26 01:43:01 +00:00
|
|
|
if (!(exp->ex_flags & NFSEXP_V4ROOT)
|
|
|
|
&& !attributes_need_mount(cd->rd_bmval)) {
|
|
|
|
ignore_crossmnt = 1;
|
|
|
|
goto out_encode;
|
|
|
|
}
|
2007-07-17 11:04:51 +00: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 08:35:24 +00:00
|
|
|
err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);
|
|
|
|
if (err) {
|
|
|
|
nfserr = nfserrno(err);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_put;
|
|
|
|
}
|
2007-07-17 11:04:51 +00:00
|
|
|
nfserr = check_nfsd_access(exp, cd->rd_rqstp);
|
|
|
|
if (nfserr)
|
|
|
|
goto out_put;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
}
|
2009-10-26 01:43:01 +00:00
|
|
|
out_encode:
|
2005-04-16 22:20:36 +00:00
|
|
|
nfserr = nfsd4_encode_fattr(NULL, exp, dentry, p, buflen, cd->rd_bmval,
|
2007-11-27 19:34:05 +00:00
|
|
|
cd->rd_rqstp, ignore_crossmnt);
|
2005-04-16 22:20:36 +00:00
|
|
|
out_put:
|
|
|
|
dput(dentry);
|
|
|
|
exp_put(exp);
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:58 +00:00
|
|
|
static __be32 *
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_rdattr_error(__be32 *p, int buflen, __be32 nfserr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *attrlenp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (buflen < 6)
|
|
|
|
return NULL;
|
|
|
|
*p++ = htonl(2);
|
|
|
|
*p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */
|
|
|
|
*p++ = htonl(0); /* bmval1 */
|
|
|
|
|
|
|
|
attrlenp = p++;
|
|
|
|
*p++ = nfserr; /* no htonl */
|
|
|
|
*attrlenp = htonl((char *)p - (char *)attrlenp - 4);
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-01-26 08:57:10 +00:00
|
|
|
nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,
|
|
|
|
loff_t offset, u64 ino, unsigned int d_type)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-01-26 08:57:10 +00:00
|
|
|
struct readdir_cd *ccd = ccdv;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);
|
|
|
|
int buflen;
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *p = cd->buffer;
|
2009-05-05 23:04:29 +00:00
|
|
|
__be32 *cookiep;
|
2006-10-20 06:28:59 +00:00
|
|
|
__be32 nfserr = nfserr_toosmall;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* In nfsv4, "." and ".." never make it onto the wire.. */
|
|
|
|
if (name && isdotent(name, namlen)) {
|
|
|
|
cd->common.err = nfs_ok;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cd->offset)
|
|
|
|
xdr_encode_hyper(cd->offset, (u64) offset);
|
|
|
|
|
|
|
|
buflen = cd->buflen - 4 - XDR_QUADLEN(namlen);
|
|
|
|
if (buflen < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
*p++ = xdr_one; /* mark entry present */
|
2009-05-05 23:04:29 +00:00
|
|
|
cookiep = p;
|
2005-04-16 22:20:36 +00:00
|
|
|
p = xdr_encode_hyper(p, NFS_OFFSET_MAX); /* offset of next entry */
|
|
|
|
p = xdr_encode_array(p, name, namlen); /* name length & name */
|
|
|
|
|
|
|
|
nfserr = nfsd4_encode_dirent_fattr(cd, name, namlen, p, &buflen);
|
|
|
|
switch (nfserr) {
|
|
|
|
case nfs_ok:
|
|
|
|
p += buflen;
|
|
|
|
break;
|
|
|
|
case nfserr_resource:
|
|
|
|
nfserr = nfserr_toosmall;
|
|
|
|
goto fail;
|
2009-05-05 23:04:29 +00:00
|
|
|
case nfserr_noent:
|
|
|
|
goto skip_entry;
|
2005-04-16 22:20:36 +00: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;
|
|
|
|
p = nfsd4_encode_rdattr_error(p, buflen, nfserr);
|
2006-01-19 01:43:40 +00:00
|
|
|
if (p == NULL) {
|
|
|
|
nfserr = nfserr_toosmall;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto fail;
|
2006-01-19 01:43:40 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
cd->buflen -= (p - cd->buffer);
|
|
|
|
cd->buffer = p;
|
2009-05-05 23:04:29 +00:00
|
|
|
cd->offset = cookiep;
|
|
|
|
skip_entry:
|
2005-04-16 22:20:36 +00:00
|
|
|
cd->common.err = nfs_ok;
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
|
|
cd->common.err = nfserr;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-08-12 17:45:07 +00:00
|
|
|
static void
|
|
|
|
nfsd4_encode_stateid(struct nfsd4_compoundres *resp, stateid_t *sid)
|
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2008-08-12 17:45:07 +00:00
|
|
|
|
|
|
|
RESERVE_SPACE(sizeof(stateid_t));
|
|
|
|
WRITE32(sid->si_generation);
|
|
|
|
WRITEMEM(&sid->si_opaque, sizeof(stateid_opaque_t));
|
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!nfserr) {
|
|
|
|
RESERVE_SPACE(8);
|
|
|
|
WRITE32(access->ac_supported);
|
|
|
|
WRITE32(access->ac_resp_access);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-10-05 03:12:59 +00:00
|
|
|
static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)
|
|
|
|
{
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
if (!nfserr) {
|
|
|
|
RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 8);
|
|
|
|
WRITEMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);
|
|
|
|
WRITE32(bcts->dir);
|
2012-09-13 13:49:43 +00:00
|
|
|
/* Sorry, we do not yet support RDMA over 4.1: */
|
2010-10-05 03:12:59 +00:00
|
|
|
WRITE32(0);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
ENCODE_SEQID_OP_HEAD;
|
|
|
|
|
2008-08-12 17:45:07 +00:00
|
|
|
if (!nfserr)
|
|
|
|
nfsd4_encode_stateid(resp, &close->cl_stateid);
|
|
|
|
|
2011-08-24 16:27:31 +00:00
|
|
|
encode_seqid_op_tail(resp, save, nfserr);
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!nfserr) {
|
2012-03-02 22:13:50 +00:00
|
|
|
RESERVE_SPACE(NFS4_VERIFIER_SIZE);
|
|
|
|
WRITEMEM(commit->co_verf.data, NFS4_VERIFIER_SIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!nfserr) {
|
|
|
|
RESERVE_SPACE(32);
|
2009-04-16 21:33:25 +00:00
|
|
|
write_cinfo(&p, &create->cr_cinfo);
|
2005-04-16 22:20:36 +00:00
|
|
|
WRITE32(2);
|
|
|
|
WRITE32(create->cr_bmval[0]);
|
|
|
|
WRITE32(create->cr_bmval[1]);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct svc_fh *fhp = getattr->ga_fhp;
|
|
|
|
int buflen;
|
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
|
|
|
|
buflen = resp->end - resp->p - (COMPOUND_ERR_SLACK_SPACE >> 2);
|
|
|
|
nfserr = nfsd4_encode_fattr(fhp, fhp->fh_export, fhp->fh_dentry,
|
|
|
|
resp->p, &buflen, getattr->ga_bmval,
|
2007-11-27 19:34:05 +00:00
|
|
|
resp->rqstp, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!nfserr)
|
|
|
|
resp->p += buflen;
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-04 11:38:33 +00:00
|
|
|
struct svc_fh *fhp = *fhpp;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int len;
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!nfserr) {
|
|
|
|
len = fhp->fh_handle.fh_size;
|
|
|
|
RESERVE_SPACE(len + 4);
|
|
|
|
WRITE32(len);
|
|
|
|
WRITEMEM(&fhp->fh_handle.fh_base, len);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Including all fields other than the name, a LOCK4denied structure requires
|
|
|
|
* 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
nfsd4_encode_lock_denied(struct nfsd4_compoundres *resp, struct nfsd4_lock_denied *ld)
|
|
|
|
{
|
2011-08-31 02:15:47 +00:00
|
|
|
struct xdr_netobj *conf = &ld->ld_owner;
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-08-31 02:15:47 +00:00
|
|
|
RESERVE_SPACE(32 + XDR_LEN(conf->len));
|
2005-04-16 22:20:36 +00:00
|
|
|
WRITE64(ld->ld_start);
|
|
|
|
WRITE64(ld->ld_length);
|
|
|
|
WRITE32(ld->ld_type);
|
2011-08-31 02:15:47 +00:00
|
|
|
if (conf->len) {
|
2005-04-16 22:20:36 +00:00
|
|
|
WRITEMEM(&ld->ld_clientid, 8);
|
2011-08-31 02:15:47 +00:00
|
|
|
WRITE32(conf->len);
|
|
|
|
WRITEMEM(conf->data, conf->len);
|
|
|
|
kfree(conf->data);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else { /* non - nfsv4 lock in conflict, no clientid nor owner */
|
|
|
|
WRITE64((u64)0); /* clientid */
|
|
|
|
WRITE32(0); /* length of owner name */
|
|
|
|
}
|
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
ENCODE_SEQID_OP_HEAD;
|
|
|
|
|
2008-08-12 17:45:07 +00:00
|
|
|
if (!nfserr)
|
|
|
|
nfsd4_encode_stateid(resp, &lock->lk_resp_stateid);
|
|
|
|
else if (nfserr == nfserr_denied)
|
2005-04-16 22:20:36 +00:00
|
|
|
nfsd4_encode_lock_denied(resp, &lock->lk_denied);
|
|
|
|
|
2011-08-24 16:27:31 +00:00
|
|
|
encode_seqid_op_tail(resp, save, nfserr);
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
if (nfserr == nfserr_denied)
|
|
|
|
nfsd4_encode_lock_denied(resp, &lockt->lt_denied);
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
ENCODE_SEQID_OP_HEAD;
|
|
|
|
|
2008-08-12 17:45:07 +00:00
|
|
|
if (!nfserr)
|
|
|
|
nfsd4_encode_stateid(resp, &locku->lu_stateid);
|
|
|
|
|
2011-08-24 16:27:31 +00:00
|
|
|
encode_seqid_op_tail(resp, save, nfserr);
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!nfserr) {
|
|
|
|
RESERVE_SPACE(20);
|
2009-04-16 21:33:25 +00:00
|
|
|
write_cinfo(&p, &link->li_cinfo);
|
2005-04-16 22:20:36 +00:00
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
ENCODE_SEQID_OP_HEAD;
|
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
goto out;
|
|
|
|
|
2008-08-12 17:45:07 +00:00
|
|
|
nfsd4_encode_stateid(resp, &open->op_stateid);
|
|
|
|
RESERVE_SPACE(40);
|
2009-04-16 21:33:25 +00:00
|
|
|
write_cinfo(&p, &open->op_cinfo);
|
2005-04-16 22:20:36 +00:00
|
|
|
WRITE32(open->op_rflags);
|
|
|
|
WRITE32(2);
|
|
|
|
WRITE32(open->op_bmval[0]);
|
|
|
|
WRITE32(open->op_bmval[1]);
|
|
|
|
WRITE32(open->op_delegate_type);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
|
|
|
|
switch (open->op_delegate_type) {
|
|
|
|
case NFS4_OPEN_DELEGATE_NONE:
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_DELEGATE_READ:
|
2008-08-12 17:45:07 +00:00
|
|
|
nfsd4_encode_stateid(resp, &open->op_delegate_stateid);
|
|
|
|
RESERVE_SPACE(20);
|
2005-06-24 05:03:23 +00:00
|
|
|
WRITE32(open->op_recall);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: ACE's in delegations
|
|
|
|
*/
|
|
|
|
WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(0); /* XXX: is NULL principal ok? */
|
|
|
|
ADJUST_ARGS();
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_DELEGATE_WRITE:
|
2008-08-12 17:45:07 +00:00
|
|
|
nfsd4_encode_stateid(resp, &open->op_delegate_stateid);
|
|
|
|
RESERVE_SPACE(32);
|
2005-04-16 22:20:36 +00:00
|
|
|
WRITE32(0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: space_limit's in delegations
|
|
|
|
*/
|
|
|
|
WRITE32(NFS4_LIMIT_SIZE);
|
|
|
|
WRITE32(~(u32)0);
|
|
|
|
WRITE32(~(u32)0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: ACE's in delegations
|
|
|
|
*/
|
|
|
|
WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(0); /* XXX: is NULL principal ok? */
|
|
|
|
ADJUST_ARGS();
|
|
|
|
break;
|
2012-02-16 18:57:17 +00:00
|
|
|
case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */
|
|
|
|
switch (open->op_why_no_deleg) {
|
|
|
|
case WND4_CONTENTION:
|
|
|
|
case WND4_RESOURCE:
|
|
|
|
RESERVE_SPACE(8);
|
|
|
|
WRITE32(open->op_why_no_deleg);
|
|
|
|
WRITE32(0); /* deleg signaling not supported yet */
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(open->op_why_no_deleg);
|
|
|
|
}
|
|
|
|
ADJUST_ARGS();
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
/* XXX save filehandle here */
|
|
|
|
out:
|
2011-08-24 16:27:31 +00:00
|
|
|
encode_seqid_op_tail(resp, save, nfserr);
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
ENCODE_SEQID_OP_HEAD;
|
2008-08-12 17:45:07 +00:00
|
|
|
|
|
|
|
if (!nfserr)
|
|
|
|
nfsd4_encode_stateid(resp, &oc->oc_resp_stateid);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-08-24 16:27:31 +00:00
|
|
|
encode_seqid_op_tail(resp, save, nfserr);
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
ENCODE_SEQID_OP_HEAD;
|
2008-08-12 17:45:07 +00:00
|
|
|
|
|
|
|
if (!nfserr)
|
|
|
|
nfsd4_encode_stateid(resp, &od->od_stateid);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-08-24 16:27:31 +00:00
|
|
|
encode_seqid_op_tail(resp, save, nfserr);
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,
|
2006-10-04 09:15:46 +00:00
|
|
|
struct nfsd4_read *read)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
u32 eof;
|
|
|
|
int v, pn;
|
|
|
|
unsigned long maxcount;
|
|
|
|
long len;
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
if (resp->xbuf->page_len)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
|
|
|
RESERVE_SPACE(8); /* eof flag and byte count */
|
|
|
|
|
2006-10-04 09:15:47 +00:00
|
|
|
maxcount = svc_max_payload(resp->rqstp);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (maxcount > read->rd_length)
|
|
|
|
maxcount = read->rd_length;
|
|
|
|
|
|
|
|
len = maxcount;
|
|
|
|
v = 0;
|
|
|
|
while (len > 0) {
|
2012-12-04 23:25:10 +00:00
|
|
|
pn = resp->rqstp->rq_resused;
|
|
|
|
if (!resp->rqstp->rq_respages[pn]) { /* ran out of pages */
|
|
|
|
maxcount -= len;
|
|
|
|
break;
|
|
|
|
}
|
2006-10-04 09:15:47 +00:00
|
|
|
resp->rqstp->rq_vec[v].iov_base =
|
2006-10-04 09:15:46 +00:00
|
|
|
page_address(resp->rqstp->rq_respages[pn]);
|
2006-10-04 09:15:47 +00:00
|
|
|
resp->rqstp->rq_vec[v].iov_len =
|
2006-10-04 09:15:46 +00:00
|
|
|
len < PAGE_SIZE ? len : PAGE_SIZE;
|
2012-12-04 23:25:10 +00:00
|
|
|
resp->rqstp->rq_resused++;
|
2005-04-16 22:20:36 +00:00
|
|
|
v++;
|
|
|
|
len -= PAGE_SIZE;
|
|
|
|
}
|
|
|
|
read->rd_vlen = v;
|
|
|
|
|
2010-07-30 15:33:32 +00:00
|
|
|
nfserr = nfsd_read_file(read->rd_rqstp, read->rd_fhp, read->rd_filp,
|
2006-10-04 09:15:47 +00:00
|
|
|
read->rd_offset, resp->rqstp->rq_vec, read->rd_vlen,
|
2005-04-16 22:20:36 +00:00
|
|
|
&maxcount);
|
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
2006-10-04 09:15:46 +00:00
|
|
|
eof = (read->rd_offset + maxcount >=
|
|
|
|
read->rd_fhp->fh_dentry->d_inode->i_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
WRITE32(eof);
|
|
|
|
WRITE32(maxcount);
|
|
|
|
ADJUST_ARGS();
|
2006-04-11 05:55:32 +00:00
|
|
|
resp->xbuf->head[0].iov_len = (char*)p
|
|
|
|
- (char*)resp->xbuf->head[0].iov_base;
|
2005-04-16 22:20:36 +00:00
|
|
|
resp->xbuf->page_len = maxcount;
|
|
|
|
|
2006-04-11 05:55:32 +00:00
|
|
|
/* Use rest of head for padding and remaining ops: */
|
|
|
|
resp->xbuf->tail[0].iov_base = p;
|
2005-04-16 22:20:36 +00:00
|
|
|
resp->xbuf->tail[0].iov_len = 0;
|
|
|
|
if (maxcount&3) {
|
2006-04-11 05:55:32 +00:00
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(0);
|
2005-04-16 22:20:36 +00:00
|
|
|
resp->xbuf->tail[0].iov_base += maxcount&3;
|
|
|
|
resp->xbuf->tail[0].iov_len = 4 - (maxcount&3);
|
2006-04-11 05:55:32 +00:00
|
|
|
ADJUST_ARGS();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int maxcount;
|
|
|
|
char *page;
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
if (resp->xbuf->page_len)
|
|
|
|
return nfserr_resource;
|
2012-12-04 23:25:10 +00:00
|
|
|
if (!resp->rqstp->rq_respages[resp->rqstp->rq_resused])
|
|
|
|
return nfserr_resource;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-04 09:15:46 +00:00
|
|
|
page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused++]);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
maxcount = PAGE_SIZE;
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX: By default, the ->readlink() VFS op will truncate symlinks
|
|
|
|
* if they would overflow the buffer. Is this kosher in NFSv4? If
|
|
|
|
* not, one easy fix is: if ->readlink() precisely fills the buffer,
|
|
|
|
* assume that truncation occurred, and return NFS4ERR_RESOURCE.
|
|
|
|
*/
|
|
|
|
nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, page, &maxcount);
|
|
|
|
if (nfserr == nfserr_isdir)
|
|
|
|
return nfserr_inval;
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
|
|
|
|
WRITE32(maxcount);
|
|
|
|
ADJUST_ARGS();
|
2006-04-11 05:55:32 +00:00
|
|
|
resp->xbuf->head[0].iov_len = (char*)p
|
|
|
|
- (char*)resp->xbuf->head[0].iov_base;
|
|
|
|
resp->xbuf->page_len = maxcount;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-04-11 05:55:32 +00:00
|
|
|
/* Use rest of head for padding and remaining ops: */
|
|
|
|
resp->xbuf->tail[0].iov_base = p;
|
2005-04-16 22:20:36 +00:00
|
|
|
resp->xbuf->tail[0].iov_len = 0;
|
|
|
|
if (maxcount&3) {
|
2006-04-11 05:55:32 +00:00
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(0);
|
2005-04-16 22:20:36 +00:00
|
|
|
resp->xbuf->tail[0].iov_base += maxcount&3;
|
|
|
|
resp->xbuf->tail[0].iov_len = 4 - (maxcount&3);
|
2006-04-11 05:55:32 +00:00
|
|
|
ADJUST_ARGS();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-20 06:28:59 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int maxcount;
|
|
|
|
loff_t offset;
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *page, *savep, *tailbase;
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
if (resp->xbuf->page_len)
|
|
|
|
return nfserr_resource;
|
2012-12-04 23:25:10 +00:00
|
|
|
if (!resp->rqstp->rq_respages[resp->rqstp->rq_resused])
|
|
|
|
return nfserr_resource;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-03-02 22:13:50 +00:00
|
|
|
RESERVE_SPACE(NFS4_VERIFIER_SIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
savep = p;
|
|
|
|
|
|
|
|
/* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(0);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
resp->xbuf->head[0].iov_len = ((char*)resp->p) - (char*)resp->xbuf->head[0].iov_base;
|
2006-04-11 05:55:33 +00:00
|
|
|
tailbase = p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
maxcount = PAGE_SIZE;
|
|
|
|
if (maxcount > readdir->rd_maxcount)
|
|
|
|
maxcount = readdir->rd_maxcount;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert from bytes to words, account for the two words already
|
|
|
|
* written, make sure to leave two words at the end for the next
|
|
|
|
* pointer and eof field.
|
|
|
|
*/
|
|
|
|
maxcount = (maxcount >> 2) - 4;
|
|
|
|
if (maxcount < 0) {
|
|
|
|
nfserr = nfserr_toosmall;
|
|
|
|
goto err_no_verf;
|
|
|
|
}
|
|
|
|
|
2006-10-04 09:15:46 +00:00
|
|
|
page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused++]);
|
2005-04-16 22:20:36 +00:00
|
|
|
readdir->common.err = 0;
|
|
|
|
readdir->buflen = maxcount;
|
|
|
|
readdir->buffer = page;
|
|
|
|
readdir->offset = NULL;
|
|
|
|
|
|
|
|
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 &&
|
|
|
|
readdir->buffer == page)
|
|
|
|
nfserr = nfserr_toosmall;
|
|
|
|
if (nfserr)
|
|
|
|
goto err_no_verf;
|
|
|
|
|
|
|
|
if (readdir->offset)
|
|
|
|
xdr_encode_hyper(readdir->offset, offset);
|
|
|
|
|
|
|
|
p = readdir->buffer;
|
|
|
|
*p++ = 0; /* no more entries */
|
|
|
|
*p++ = htonl(readdir->common.err == nfserr_eof);
|
2006-10-04 09:15:46 +00:00
|
|
|
resp->xbuf->page_len = ((char*)p) - (char*)page_address(
|
|
|
|
resp->rqstp->rq_respages[resp->rqstp->rq_resused-1]);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-04-11 05:55:33 +00:00
|
|
|
/* Use rest of head for padding and remaining ops: */
|
|
|
|
resp->xbuf->tail[0].iov_base = tailbase;
|
2005-04-16 22:20:36 +00:00
|
|
|
resp->xbuf->tail[0].iov_len = 0;
|
|
|
|
resp->p = resp->xbuf->tail[0].iov_base;
|
2006-04-11 05:55:33 +00:00
|
|
|
resp->end = resp->p + (PAGE_SIZE - resp->xbuf->head[0].iov_len)/4;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
err_no_verf:
|
|
|
|
p = savep;
|
|
|
|
ADJUST_ARGS();
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!nfserr) {
|
|
|
|
RESERVE_SPACE(20);
|
2009-04-16 21:33:25 +00:00
|
|
|
write_cinfo(&p, &remove->rm_cinfo);
|
2005-04-16 22:20:36 +00:00
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!nfserr) {
|
|
|
|
RESERVE_SPACE(40);
|
2009-04-16 21:33:25 +00:00
|
|
|
write_cinfo(&p, &rename->rn_sinfo);
|
|
|
|
write_cinfo(&p, &rename->rn_tinfo);
|
2005-04-16 22:20:36 +00:00
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2010-12-27 06:29:57 +00:00
|
|
|
nfsd4_do_encode_secinfo(struct nfsd4_compoundres *resp,
|
|
|
|
__be32 nfserr,struct svc_export *exp)
|
2007-07-17 11:04:51 +00:00
|
|
|
{
|
|
|
|
int i = 0;
|
2007-07-17 11:04:51 +00:00
|
|
|
u32 nflavs;
|
|
|
|
struct exp_flavor_info *flavs;
|
|
|
|
struct exp_flavor_info def_flavs[2];
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2007-07-17 11:04:51 +00:00
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
goto out;
|
2007-07-17 11:04:51 +00: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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-17 11:04:51 +00:00
|
|
|
RESERVE_SPACE(4);
|
2007-07-17 11:04:51 +00:00
|
|
|
WRITE32(nflavs);
|
2007-07-17 11:04:51 +00:00
|
|
|
ADJUST_ARGS();
|
2007-07-17 11:04:51 +00:00
|
|
|
for (i = 0; i < nflavs; i++) {
|
|
|
|
u32 flav = flavs[i].pseudoflavor;
|
2007-07-17 11:04:51 +00:00
|
|
|
struct gss_api_mech *gm = gss_mech_get_by_pseudoflavor(flav);
|
|
|
|
|
|
|
|
if (gm) {
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(RPC_AUTH_GSS);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
RESERVE_SPACE(4 + gm->gm_oid.len);
|
|
|
|
WRITE32(gm->gm_oid.len);
|
|
|
|
WRITEMEM(gm->gm_oid.data, gm->gm_oid.len);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(0); /* qop */
|
|
|
|
ADJUST_ARGS();
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(gss_pseudoflavor_to_service(gm, flav));
|
|
|
|
ADJUST_ARGS();
|
|
|
|
gss_mech_put(gm);
|
|
|
|
} else {
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(flav);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
if (exp)
|
|
|
|
exp_put(exp);
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2007-07-17 11:04:51 +00:00
|
|
|
}
|
|
|
|
|
2010-12-27 06:29:57 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_secinfo *secinfo)
|
|
|
|
{
|
|
|
|
return nfsd4_do_encode_secinfo(resp, nfserr, secinfo->si_exp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,
|
|
|
|
struct nfsd4_secinfo_no_name *secinfo)
|
|
|
|
{
|
|
|
|
return nfsd4_do_encode_secinfo(resp, nfserr, secinfo->sin_exp);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The SETATTR encode routine is special -- it always encodes a bitmap,
|
|
|
|
* regardless of the error status.
|
|
|
|
*/
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
RESERVE_SPACE(12);
|
|
|
|
if (nfserr) {
|
|
|
|
WRITE32(2);
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(0);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
WRITE32(2);
|
|
|
|
WRITE32(setattr->sa_bmval[0]);
|
|
|
|
WRITE32(setattr->sa_bmval[1]);
|
|
|
|
}
|
|
|
|
ADJUST_ARGS();
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!nfserr) {
|
2012-03-02 22:13:50 +00:00
|
|
|
RESERVE_SPACE(8 + NFS4_VERIFIER_SIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
WRITEMEM(&scd->se_clientid, 8);
|
2012-03-02 22:13:50 +00:00
|
|
|
WRITEMEM(&scd->se_confirm, NFS4_VERIFIER_SIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
|
|
|
else if (nfserr == nfserr_clid_inuse) {
|
|
|
|
RESERVE_SPACE(8);
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(0);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
2006-10-20 06:28:59 +00:00
|
|
|
nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!nfserr) {
|
|
|
|
RESERVE_SPACE(16);
|
|
|
|
WRITE32(write->wr_bytes_written);
|
|
|
|
WRITE32(write->wr_how_written);
|
2012-03-02 22:13:50 +00:00
|
|
|
WRITEMEM(write->wr_verifier.data, NFS4_VERIFIER_SIZE);
|
2005-04-16 22:20:36 +00:00
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
2008-07-04 11:38:33 +00:00
|
|
|
return nfserr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-04-03 05:27:55 +00:00
|
|
|
static __be32
|
2012-04-25 21:58:50 +00:00
|
|
|
nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
|
2009-04-03 05:27:55 +00:00
|
|
|
struct nfsd4_exchange_id *exid)
|
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2009-04-03 05:28:01 +00:00
|
|
|
char *major_id;
|
|
|
|
char *server_scope;
|
|
|
|
int major_id_sz;
|
|
|
|
int server_scope_sz;
|
|
|
|
uint64_t minor_id = 0;
|
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
|
|
|
|
major_id = utsname()->nodename;
|
|
|
|
major_id_sz = strlen(major_id);
|
|
|
|
server_scope = utsname()->nodename;
|
|
|
|
server_scope_sz = strlen(server_scope);
|
|
|
|
|
|
|
|
RESERVE_SPACE(
|
|
|
|
8 /* eir_clientid */ +
|
|
|
|
4 /* eir_sequenceid */ +
|
|
|
|
4 /* eir_flags */ +
|
|
|
|
4 /* spr_how (SP4_NONE) */ +
|
|
|
|
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) */);
|
|
|
|
|
|
|
|
WRITEMEM(&exid->clientid, 8);
|
|
|
|
WRITE32(exid->seqid);
|
|
|
|
WRITE32(exid->flags);
|
|
|
|
|
|
|
|
/* state_protect4_r. Currently only support SP4_NONE */
|
|
|
|
BUG_ON(exid->spa_how != SP4_NONE);
|
|
|
|
WRITE32(exid->spa_how);
|
|
|
|
|
|
|
|
/* The server_owner struct */
|
|
|
|
WRITE64(minor_id); /* Minor id */
|
|
|
|
/* major id */
|
|
|
|
WRITE32(major_id_sz);
|
|
|
|
WRITEMEM(major_id, major_id_sz);
|
|
|
|
|
|
|
|
/* Server scope */
|
|
|
|
WRITE32(server_scope_sz);
|
|
|
|
WRITEMEM(server_scope, server_scope_sz);
|
|
|
|
|
|
|
|
/* Implementation id */
|
|
|
|
WRITE32(0); /* zero length nfs_impl_id4 array */
|
|
|
|
ADJUST_ARGS();
|
|
|
|
return 0;
|
2009-04-03 05:27:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
2012-04-25 21:58:50 +00:00
|
|
|
nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,
|
2009-04-03 05:27:55 +00:00
|
|
|
struct nfsd4_create_session *sess)
|
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2009-04-03 05:28:28 +00:00
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
|
|
|
|
RESERVE_SPACE(24);
|
|
|
|
WRITEMEM(sess->sessionid.data, NFS4_MAX_SESSIONID_LEN);
|
|
|
|
WRITE32(sess->seqid);
|
|
|
|
WRITE32(sess->flags);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
|
|
|
|
RESERVE_SPACE(28);
|
|
|
|
WRITE32(0); /* headerpadsz */
|
|
|
|
WRITE32(sess->fore_channel.maxreq_sz);
|
|
|
|
WRITE32(sess->fore_channel.maxresp_sz);
|
|
|
|
WRITE32(sess->fore_channel.maxresp_cached);
|
|
|
|
WRITE32(sess->fore_channel.maxops);
|
|
|
|
WRITE32(sess->fore_channel.maxreqs);
|
|
|
|
WRITE32(sess->fore_channel.nr_rdma_attrs);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
|
|
|
|
if (sess->fore_channel.nr_rdma_attrs) {
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(sess->fore_channel.rdma_attrs);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
|
|
|
|
|
|
|
RESERVE_SPACE(28);
|
|
|
|
WRITE32(0); /* headerpadsz */
|
|
|
|
WRITE32(sess->back_channel.maxreq_sz);
|
|
|
|
WRITE32(sess->back_channel.maxresp_sz);
|
|
|
|
WRITE32(sess->back_channel.maxresp_cached);
|
|
|
|
WRITE32(sess->back_channel.maxops);
|
|
|
|
WRITE32(sess->back_channel.maxreqs);
|
|
|
|
WRITE32(sess->back_channel.nr_rdma_attrs);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
|
|
|
|
if (sess->back_channel.nr_rdma_attrs) {
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(sess->back_channel.rdma_attrs);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
|
|
|
return 0;
|
2009-04-03 05:27:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
2012-04-25 21:58:50 +00:00
|
|
|
nfsd4_encode_destroy_session(struct nfsd4_compoundres *resp, __be32 nfserr,
|
2009-04-03 05:27:55 +00:00
|
|
|
struct nfsd4_destroy_session *destroy_session)
|
|
|
|
{
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2011-07-13 15:04:21 +00:00
|
|
|
static __be32
|
2012-04-25 22:04:54 +00:00
|
|
|
nfsd4_encode_free_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,
|
2011-07-13 15:04:21 +00:00
|
|
|
struct nfsd4_free_stateid *free_stateid)
|
|
|
|
{
|
|
|
|
__be32 *p;
|
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
2012-04-25 22:04:54 +00:00
|
|
|
*p++ = nfserr;
|
2011-07-13 15:04:21 +00:00
|
|
|
ADJUST_ARGS();
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2011-05-16 14:38:14 +00:00
|
|
|
static __be32
|
2012-04-25 21:58:50 +00:00
|
|
|
nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,
|
2009-04-03 05:27:55 +00:00
|
|
|
struct nfsd4_sequence *seq)
|
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2009-04-03 05:28:08 +00:00
|
|
|
|
|
|
|
if (nfserr)
|
|
|
|
return nfserr;
|
|
|
|
|
|
|
|
RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 20);
|
|
|
|
WRITEMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);
|
|
|
|
WRITE32(seq->seqid);
|
|
|
|
WRITE32(seq->slotid);
|
2011-08-31 19:39:30 +00:00
|
|
|
/* Note slotid's are numbered from zero: */
|
|
|
|
WRITE32(seq->maxslots - 1); /* sr_highest_slotid */
|
|
|
|
WRITE32(seq->maxslots - 1); /* sr_target_highest_slotid */
|
2010-11-18 13:30:33 +00:00
|
|
|
WRITE32(seq->status_flags);
|
2009-04-03 05:28:08 +00:00
|
|
|
|
|
|
|
ADJUST_ARGS();
|
2009-08-28 12:45:04 +00:00
|
|
|
resp->cstate.datap = p; /* DRC cache data pointer */
|
2009-04-03 05:28:08 +00:00
|
|
|
return 0;
|
2009-04-03 05:27:55 +00:00
|
|
|
}
|
|
|
|
|
2012-04-25 20:56:22 +00:00
|
|
|
static __be32
|
2012-04-25 21:58:50 +00:00
|
|
|
nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,
|
2011-07-13 14:50:48 +00:00
|
|
|
struct nfsd4_test_stateid *test_stateid)
|
|
|
|
{
|
2012-01-27 15:22:49 +00:00
|
|
|
struct nfsd4_test_stateid_id *stateid, *next;
|
2011-07-13 14:50:48 +00:00
|
|
|
__be32 *p;
|
|
|
|
|
2012-01-27 15:22:49 +00:00
|
|
|
RESERVE_SPACE(4 + (4 * test_stateid->ts_num_ids));
|
2011-07-13 14:50:48 +00:00
|
|
|
*p++ = htonl(test_stateid->ts_num_ids);
|
|
|
|
|
2012-01-27 15:22:49 +00:00
|
|
|
list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) {
|
2012-04-13 04:10:34 +00:00
|
|
|
*p++ = stateid->ts_id_status;
|
2011-07-13 14:50:48 +00:00
|
|
|
}
|
|
|
|
|
2012-01-27 15:22:49 +00:00
|
|
|
ADJUST_ARGS();
|
2011-07-13 14:50:48 +00:00
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
static __be32
|
|
|
|
nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p)
|
|
|
|
{
|
|
|
|
return nfserr;
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *);
|
|
|
|
|
2009-04-03 05:27:55 +00: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.
|
|
|
|
*/
|
2008-07-04 11:38:33 +00:00
|
|
|
static nfsd4_enc nfsd4_enc_ops[] = {
|
2008-07-18 19:04:16 +00: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-04 21:05:35 +00:00
|
|
|
[OP_OPENATTR] = (nfsd4_enc)nfsd4_encode_noop,
|
2008-07-18 19:04:16 +00: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 05:27:55 +00:00
|
|
|
|
|
|
|
/* NFSv4.1 operations */
|
|
|
|
[OP_BACKCHANNEL_CTL] = (nfsd4_enc)nfsd4_encode_noop,
|
2010-10-05 03:12:59 +00:00
|
|
|
[OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session,
|
2009-04-03 05:27:55 +00:00
|
|
|
[OP_EXCHANGE_ID] = (nfsd4_enc)nfsd4_encode_exchange_id,
|
|
|
|
[OP_CREATE_SESSION] = (nfsd4_enc)nfsd4_encode_create_session,
|
|
|
|
[OP_DESTROY_SESSION] = (nfsd4_enc)nfsd4_encode_destroy_session,
|
2011-07-13 15:04:21 +00:00
|
|
|
[OP_FREE_STATEID] = (nfsd4_enc)nfsd4_encode_free_stateid,
|
2009-04-03 05:27:55 +00:00
|
|
|
[OP_GET_DIR_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop,
|
|
|
|
[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,
|
2010-12-27 06:29:57 +00:00
|
|
|
[OP_SECINFO_NO_NAME] = (nfsd4_enc)nfsd4_encode_secinfo_no_name,
|
2009-04-03 05:27:55 +00:00
|
|
|
[OP_SEQUENCE] = (nfsd4_enc)nfsd4_encode_sequence,
|
|
|
|
[OP_SET_SSV] = (nfsd4_enc)nfsd4_encode_noop,
|
2011-07-13 14:50:48 +00:00
|
|
|
[OP_TEST_STATEID] = (nfsd4_enc)nfsd4_encode_test_stateid,
|
2009-04-03 05:27:55 +00: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,
|
2008-07-04 11:38:33 +00:00
|
|
|
};
|
|
|
|
|
2009-04-03 05:28:48 +00:00
|
|
|
/*
|
|
|
|
* Calculate the total amount of memory that the compound response has taken
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
* after encoding the current operation with pad.
|
2009-04-03 05:28:48 +00:00
|
|
|
*
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
* pad: if operation is non-idempotent, pad was calculate by op_rsize_bop()
|
|
|
|
* which was specified at nfsd4_operation, else pad is zero.
|
2009-04-03 05:28:48 +00:00
|
|
|
*
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
* Compare this length to the session se_fmaxresp_sz and se_fmaxresp_cached.
|
2009-04-03 05:28:48 +00:00
|
|
|
*
|
|
|
|
* Our se_fmaxresp_cached will always be a multiple of PAGE_SIZE, and so
|
|
|
|
* will be at least a page and will therefore hold the xdr_buf head.
|
|
|
|
*/
|
2012-04-25 21:58:50 +00:00
|
|
|
__be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 pad)
|
2009-04-03 05:28:48 +00:00
|
|
|
{
|
|
|
|
struct xdr_buf *xb = &resp->rqstp->rq_res;
|
|
|
|
struct nfsd4_session *session = NULL;
|
|
|
|
struct nfsd4_slot *slot = resp->cstate.slot;
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
u32 length, tlen = 0;
|
2009-04-03 05:28:48 +00:00
|
|
|
|
|
|
|
if (!nfsd4_has_session(&resp->cstate))
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
return 0;
|
2009-04-03 05:28:48 +00:00
|
|
|
|
|
|
|
session = resp->cstate.session;
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
if (session == NULL)
|
|
|
|
return 0;
|
2009-04-03 05:28:48 +00:00
|
|
|
|
|
|
|
if (xb->page_len == 0) {
|
|
|
|
length = (char *)resp->p - (char *)xb->head[0].iov_base + pad;
|
|
|
|
} else {
|
|
|
|
if (xb->tail[0].iov_base && xb->tail[0].iov_len > 0)
|
|
|
|
tlen = (char *)resp->p - (char *)xb->tail[0].iov_base;
|
|
|
|
|
|
|
|
length = xb->head[0].iov_len + xb->page_len + tlen + pad;
|
|
|
|
}
|
|
|
|
dprintk("%s length %u, xb->page_len %u tlen %u pad %u\n", __func__,
|
|
|
|
length, xb->page_len, tlen, pad);
|
|
|
|
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
if (length > session->se_fchannel.maxresp_sz)
|
|
|
|
return nfserr_rep_too_big;
|
|
|
|
|
2012-02-13 21:39:00 +00:00
|
|
|
if ((slot->sl_flags & NFSD4_SLOT_CACHETHIS) &&
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
length > session->se_fchannel.maxresp_cached)
|
2009-04-03 05:28:48 +00:00
|
|
|
return nfserr_rep_too_big_to_cache;
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
|
|
|
|
return 0;
|
2009-04-03 05:28:48 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
void
|
|
|
|
nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
|
|
|
|
{
|
2006-10-20 06:28:58 +00:00
|
|
|
__be32 *statp;
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
RESERVE_SPACE(8);
|
|
|
|
WRITE32(op->opnum);
|
|
|
|
statp = p++; /* to be backfilled at the end */
|
|
|
|
ADJUST_ARGS();
|
|
|
|
|
2008-07-04 11:38:33 +00:00
|
|
|
if (op->opnum == OP_ILLEGAL)
|
|
|
|
goto status;
|
|
|
|
BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||
|
|
|
|
!nfsd4_enc_ops[op->opnum]);
|
|
|
|
op->status = nfsd4_enc_ops[op->opnum](resp, op->status, &op->u);
|
2009-04-03 05:28:48 +00:00
|
|
|
/* nfsd4_check_drc_limit guarantees enough room for error status */
|
nfsd41: try to check reply size before operation
For checking the size of reply before calling a operation,
we need try to get maxsize of the operation's reply.
v3: using new method as Bruce said,
"we could handle operations in two different ways:
- For operations that actually change something (write, rename,
open, close, ...), do it the way we're doing it now: be
very careful to estimate the size of the response before even
processing the operation.
- For operations that don't change anything (read, getattr, ...)
just go ahead and do the operation. If you realize after the
fact that the response is too large, then return the error at
that point.
So we'd add another flag to op_flags: say, OP_MODIFIES_SOMETHING. And for
operations with OP_MODIFIES_SOMETHING set, we'd do the first thing. For
operations without it set, we'd do the second."
Signed-off-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
[bfields@redhat.com: crash, don't attempt to handle, undefined op_rsize_bop]
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2011-08-28 10:18:56 +00:00
|
|
|
if (!op->status)
|
|
|
|
op->status = nfsd4_check_resp_size(resp, 0);
|
2008-07-04 11:38:33 +00:00
|
|
|
status:
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Note: We write the status directly, instead of using WRITE32(),
|
|
|
|
* since it is already in network byte order.
|
|
|
|
*/
|
|
|
|
*statp = op->status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* called with nfs4_lock_state() held
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
nfsd4_encode_replay(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
|
|
|
|
{
|
2009-04-07 23:55:27 +00:00
|
|
|
__be32 *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct nfs4_replay *rp = op->replay;
|
|
|
|
|
|
|
|
BUG_ON(!rp);
|
|
|
|
|
|
|
|
RESERVE_SPACE(8);
|
|
|
|
WRITE32(op->opnum);
|
|
|
|
*p++ = rp->rp_status; /* already xdr'ed */
|
|
|
|
ADJUST_ARGS();
|
|
|
|
|
|
|
|
RESERVE_SPACE(rp->rp_buflen);
|
|
|
|
WRITEMEM(rp->rp_buf, rp->rp_buflen);
|
|
|
|
ADJUST_ARGS();
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2006-10-20 06:28:58 +00:00
|
|
|
nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
return xdr_ressize_check(rqstp, p);
|
|
|
|
}
|
|
|
|
|
2011-07-16 21:15:10 +00:00
|
|
|
int nfsd4_release_compoundargs(void *rq, __be32 *p, void *resp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-07-16 21:15:10 +00:00
|
|
|
struct svc_rqst *rqstp = rq;
|
|
|
|
struct nfsd4_compoundargs *args = rqstp->rq_argp;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (args->ops != args->iops) {
|
|
|
|
kfree(args->ops);
|
|
|
|
args->ops = args->iops;
|
|
|
|
}
|
2005-11-07 09:01:34 +00:00
|
|
|
kfree(args->tmpp);
|
|
|
|
args->tmpp = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
while (args->to_free) {
|
|
|
|
struct tmpbuf *tb = args->to_free;
|
|
|
|
args->to_free = tb->next;
|
|
|
|
tb->release(tb->buf);
|
|
|
|
kfree(tb);
|
|
|
|
}
|
2011-07-16 21:15:10 +00:00
|
|
|
return 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2006-10-20 06:28:58 +00:00
|
|
|
nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundargs *args)
|
2005-04-16 22:20:36 +00: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;
|
|
|
|
args->tmpp = NULL;
|
|
|
|
args->to_free = NULL;
|
|
|
|
args->ops = args->iops;
|
|
|
|
args->rqstp = rqstp;
|
|
|
|
|
2011-07-16 21:15:10 +00:00
|
|
|
return !nfsd4_decode_compound(args);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2006-10-20 06:28:58 +00:00
|
|
|
nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundres *resp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* All that remains is to write the tag and operation count...
|
|
|
|
*/
|
2009-08-28 12:45:04 +00:00
|
|
|
struct nfsd4_compound_state *cs = &resp->cstate;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct kvec *iov;
|
|
|
|
p = resp->tagp;
|
|
|
|
*p++ = htonl(resp->taglen);
|
|
|
|
memcpy(p, resp->tag, resp->taglen);
|
|
|
|
p += XDR_QUADLEN(resp->taglen);
|
|
|
|
*p++ = htonl(resp->opcnt);
|
|
|
|
|
|
|
|
if (rqstp->rq_res.page_len)
|
|
|
|
iov = &rqstp->rq_res.tail[0];
|
|
|
|
else
|
|
|
|
iov = &rqstp->rq_res.head[0];
|
|
|
|
iov->iov_len = ((char*)resp->p) - (char*)iov->iov_base;
|
|
|
|
BUG_ON(iov->iov_len > PAGE_SIZE);
|
2010-04-24 19:35:43 +00:00
|
|
|
if (nfsd4_has_session(cs)) {
|
|
|
|
if (cs->status != nfserr_replay_cache) {
|
|
|
|
nfsd4_store_cache_entry(resp);
|
2012-02-13 21:39:00 +00:00
|
|
|
cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE;
|
2010-04-24 19:35:43 +00:00
|
|
|
}
|
2010-05-11 21:13:54 +00:00
|
|
|
/* Renew the clientid on success and on replay */
|
|
|
|
release_session_client(cs->session);
|
2010-06-22 18:10:14 +00:00
|
|
|
nfsd4_put_session(cs->session);
|
2009-04-03 05:28:22 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Local variables:
|
|
|
|
* c-basic-offset: 8
|
|
|
|
* End:
|
|
|
|
*/
|