/*

* Server-side procedures for NFSv4.

*

* Copyright (c) 2002 The Regents of the University of Michigan.

* All rights reserved.

*

* Kendrick Smith <kmsmith@umich.edu>

* Andy Adamson <andros@umich.edu>

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

*

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* 3. Neither the name of the University nor the names of its

* contributors may be used to endorse or promote products derived

* from this software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED

* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include <linux/fs_struct.h>

#include <linux/file.h>

#include <linux/falloc.h>

#include <linux/slab.h>

#include <linux/kthread.h>

#include <linux/namei.h>

#include <linux/sunrpc/addr.h>

#include <linux/nfs_ssc.h>

#include "idmap.h"

#include "cache.h"

#include "xdr4.h"

#include "vfs.h"

#include "current_stateid.h"

#include "netns.h"

#include "acl.h"

#include "pnfs.h"

#include "trace.h"

static bool inter_copy_offload_enable;

module_param(inter_copy_offload_enable, bool, 0644);

MODULE_PARM_DESC(inter_copy_offload_enable,

"Enable inter server to server copy offload. Default: false");

static void cleanup_async_copy(struct nfsd4_copy *copy);

#ifdef CONFIG_NFSD_V4_2_INTER_SSC

static int nfsd4_ssc_umount_timeout = 900000; /* default to 15 mins */

module_param(nfsd4_ssc_umount_timeout, int, 0644);

MODULE_PARM_DESC(nfsd4_ssc_umount_timeout,

"idle msecs before unmount export from source server");

#endif

#define NFSDDBG_FACILITY NFSDDBG_PROC

static u32 nfsd_attrmask[] = {

NFSD_WRITEABLE_ATTRS_WORD0,

NFSD_WRITEABLE_ATTRS_WORD1,

NFSD_WRITEABLE_ATTRS_WORD2

};

static u32 nfsd41_ex_attrmask[] = {

NFSD_SUPPATTR_EXCLCREAT_WORD0,

NFSD_SUPPATTR_EXCLCREAT_WORD1,

NFSD_SUPPATTR_EXCLCREAT_WORD2

};

static __be32

check_attr_support(struct nfsd4_compound_state *cstate, u32 *bmval,

u32 *writable)

{

struct dentry *dentry = cstate->current_fh.fh_dentry;

struct svc_export *exp = cstate->current_fh.fh_export;

if (!nfsd_attrs_supported(cstate->minorversion, bmval))

return nfserr_attrnotsupp;

if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry)))

return nfserr_attrnotsupp;

if ((bmval[2] & (FATTR4_WORD2_POSIX_DEFAULT_ACL |

FATTR4_WORD2_POSIX_ACCESS_ACL)) &&

!IS_POSIXACL(d_inode(dentry)))

return nfserr_attrnotsupp;

if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) &&

!(exp->ex_flags & NFSEXP_SECURITY_LABEL))

return nfserr_attrnotsupp;

if (writable && !bmval_is_subset(bmval, writable))

return nfserr_inval;

if (writable && (bmval[2] & FATTR4_WORD2_MODE_UMASK) &&

(bmval[1] & FATTR4_WORD1_MODE))

return nfserr_inval;

return nfs_ok;

}

static __be32

nfsd4_check_open_attributes(struct nfsd4_compound_state *cstate,

struct nfsd4_open *open)

{

__be32 status = nfs_ok;

if (open->op_create != NFS4_OPEN_CREATE)

return status;

switch (open->op_createmode) {

case NFS4_CREATE_UNCHECKED:

case NFS4_CREATE_GUARDED:

status = check_attr_support(cstate, open->op_bmval,

nfsd_attrmask);

break;

case NFS4_CREATE_EXCLUSIVE4_1:

status = check_attr_support(cstate, open->op_bmval,

nfsd41_ex_attrmask);

break;

}

return status;

}

static int

is_create_with_attrs(struct nfsd4_open *open)

{

return open->op_create == NFS4_OPEN_CREATE

&& (open->op_createmode == NFS4_CREATE_UNCHECKED

|| open->op_createmode == NFS4_CREATE_GUARDED

|| open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1);

}

static inline void

fh_dup2(struct svc_fh *dst, struct svc_fh *src)

{

fh_put(dst);

dget(src->fh_dentry);

if (src->fh_export)

exp_get(src->fh_export);

*dst = *src;

}

static __be32

do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode)

{

if (open->op_truncate &&

!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))

return nfserr_inval;

accmode |= NFSD_MAY_READ_IF_EXEC;

if (open->op_share_access & NFS4_SHARE_ACCESS_READ)

accmode |= NFSD_MAY_READ;

if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)

accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC);

if (open->op_share_deny & NFS4_SHARE_DENY_READ)

accmode |= NFSD_MAY_WRITE;

return fh_verify(rqstp, current_fh, S_IFREG, accmode);

}

static __be32 nfsd_check_obj_isreg(struct svc_fh *fh, u32 minor_version)

{

umode_t mode = d_inode(fh->fh_dentry)->i_mode;

if (S_ISREG(mode))

return nfs_ok;

if (S_ISDIR(mode))

return nfserr_isdir;

if (S_ISLNK(mode))

return nfserr_symlink;

/* RFC 7530 - 16.16.6 */

if (minor_version == 0)

return nfserr_symlink;

else

return nfserr_wrong_type;

}

static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh)

{

if (nfsd4_has_session(cstate))

return;

fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,

&resfh->fh_handle);

}

static inline bool nfsd4_create_is_exclusive(int createmode)

{

return createmode == NFS4_CREATE_EXCLUSIVE ||

createmode == NFS4_CREATE_EXCLUSIVE4_1;

}

static __be32

nfsd4_vfs_create(struct svc_fh *fhp, struct dentry **child,

struct nfsd4_open *open)

{

struct file *filp;

struct path path;

int oflags;

oflags = O_CREAT | O_LARGEFILE;

if (nfsd4_create_is_exclusive(open->op_createmode))

oflags |= O_EXCL;

switch (open->op_share_access & NFS4_SHARE_ACCESS_BOTH) {

case NFS4_SHARE_ACCESS_WRITE:

oflags |= O_WRONLY;

break;

case NFS4_SHARE_ACCESS_BOTH:

oflags |= O_RDWR;

break;

default:

oflags |= O_RDONLY;

}

path.mnt = fhp->fh_export->ex_path.mnt;

path.dentry = *child;

filp = dentry_create(&path, oflags, open->op_iattr.ia_mode,

current_cred());

*child = path.dentry;

if (IS_ERR(filp))

return nfserrno(PTR_ERR(filp));

open->op_filp = filp;

return nfs_ok;

}

/*

* Implement NFSv4's unchecked, guarded, and exclusive create

* semantics for regular files. Open state for this new file is

* subsequently fabricated in nfsd4_process_open2().

*

* Upon return, caller must release @fhp and @resfhp.

*/

static __be32

nfsd4_create_file(struct svc_rqst *rqstp, struct svc_fh *fhp,

struct svc_fh *resfhp, struct nfsd4_open *open)

{

struct iattr *iap = &open->op_iattr;

struct nfsd_attrs attrs = {

.na_iattr = iap,

.na_seclabel = &open->op_label,

};

struct dentry *parent, *child;

__u32 v_mtime, v_atime;

struct inode *inode;

__be32 status;

int host_err;

if (isdotent(open->op_fname, open->op_fnamelen))

return nfserr_exist;

if (!(iap->ia_valid & ATTR_MODE))

iap->ia_mode = 0;

status = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);

if (status != nfs_ok)

return status;

parent = fhp->fh_dentry;

inode = d_inode(parent);

host_err = fh_want_write(fhp);

if (host_err)

return nfserrno(host_err);

if (open->op_acl) {

if (open->op_dpacl || open->op_pacl) {

status = nfserr_inval;

goto out_write;

}

if (is_create_with_attrs(open))

nfsd4_acl_to_attr(NF4REG, open->op_acl, &attrs);

} else if (is_create_with_attrs(open)) {

/* The dpacl and pacl will get released by nfsd_attrs_free(). */

attrs.na_dpacl = open->op_dpacl;

attrs.na_pacl = open->op_pacl;

open->op_dpacl = NULL;

open->op_pacl = NULL;

}

child = start_creating(&nop_mnt_idmap, parent,

&QSTR_LEN(open->op_fname, open->op_fnamelen));

if (IS_ERR(child)) {

status = nfserrno(PTR_ERR(child));

goto out_write;

}

if (d_really_is_negative(child)) {

status = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);

if (status != nfs_ok)

goto out;

}

status = fh_compose(resfhp, fhp->fh_export, child, fhp);

if (status != nfs_ok)

goto out;

v_mtime = 0;

v_atime = 0;

if (nfsd4_create_is_exclusive(open->op_createmode)) {

u32 *verifier = (u32 *)open->op_verf.data;

/*

* Solaris 7 gets confused (bugid 4218508) if these have

* the high bit set, as do xfs filesystems without the

* "bigtime" feature. So just clear the high bits. If this

* is ever changed to use different attrs for storing the

* verifier, then do_open_lookup() will also need to be

* fixed accordingly.

*/

v_mtime = verifier[0] & 0x7fffffff;

v_atime = verifier[1] & 0x7fffffff;

}

if (d_really_is_positive(child)) {

/* NFSv4 protocol requires change attributes even though

* no change happened.

*/

status = fh_fill_both_attrs(fhp);

if (status != nfs_ok)

goto out;

switch (open->op_createmode) {

case NFS4_CREATE_UNCHECKED:

if (!d_is_reg(child))

break;

/*

* In NFSv4, we don't want to truncate the file

* now. This would be wrong if the OPEN fails for

* some other reason. Furthermore, if the size is

* nonzero, we should ignore it according to spec!

*/

open->op_truncate = (iap->ia_valid & ATTR_SIZE) &&

!iap->ia_size;

break;

case NFS4_CREATE_GUARDED:

status = nfserr_exist;

break;

case NFS4_CREATE_EXCLUSIVE:

if (inode_get_mtime_sec(d_inode(child)) == v_mtime &&

inode_get_atime_sec(d_inode(child)) == v_atime &&

d_inode(child)->i_size == 0) {

open->op_created = true;

break; /* subtle */

}

status = nfserr_exist;

break;

case NFS4_CREATE_EXCLUSIVE4_1:

if (inode_get_mtime_sec(d_inode(child)) == v_mtime &&

inode_get_atime_sec(d_inode(child)) == v_atime &&

d_inode(child)->i_size == 0) {

open->op_created = true;

goto set_attr; /* subtle */

}

status = nfserr_exist;

}

goto out;

}

if (!IS_POSIXACL(inode))

iap->ia_mode &= ~current_umask();

status = fh_fill_pre_attrs(fhp);

if (status != nfs_ok)

goto out;

status = nfsd4_vfs_create(fhp, &child, open);

if (status != nfs_ok)

goto out;

open->op_created = true;

fh_fill_post_attrs(fhp);

/* A newly created file already has a file size of zero. */

if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0))

iap->ia_valid &= ~ATTR_SIZE;

if (nfsd4_create_is_exclusive(open->op_createmode)) {

iap->ia_valid = ATTR_MTIME | ATTR_ATIME |

ATTR_MTIME_SET|ATTR_ATIME_SET;

iap->ia_mtime.tv_sec = v_mtime;

iap->ia_atime.tv_sec = v_atime;

iap->ia_mtime.tv_nsec = 0;

iap->ia_atime.tv_nsec = 0;

}

set_attr:

status = nfsd_create_setattr(rqstp, fhp, resfhp, &attrs);

if (attrs.na_labelerr)

open->op_bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;

if (attrs.na_paclerr || attrs.na_dpaclerr)

open->op_bmval[0] &= ~FATTR4_WORD0_ACL;

if (attrs.na_dpaclerr)

open->op_bmval[2] &= ~FATTR4_WORD2_POSIX_DEFAULT_ACL;

if (attrs.na_paclerr)

open->op_bmval[2] &= ~FATTR4_WORD2_POSIX_ACCESS_ACL;

out:

end_creating(child);

nfsd_attrs_free(&attrs);

out_write:

fh_drop_write(fhp);

return status;

}

/**

* set_change_info - set up the change_info4 for a reply

* @cinfo: pointer to nfsd4_change_info to be populated

* @fhp: pointer to svc_fh to use as source

*

* Many operations in NFSv4 require change_info4 in the reply. This function

* populates that from the info that we (should!) have already collected. In

* the event that we didn't get any pre-attrs, just zero out both.

*/

static void

set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp)

{

cinfo->atomic = (u32)(fhp->fh_pre_saved && fhp->fh_post_saved && !fhp->fh_no_atomic_attr);

cinfo->before_change = fhp->fh_pre_change;

cinfo->after_change = fhp->fh_post_change;

/*

* If fetching the pre-change attributes failed, then we should

* have already failed the whole operation. We could have still

* failed to fetch post-change attributes however.

*

* If we didn't get post-op attrs, just zero-out the after

* field since we don't know what it should be. If the pre_saved

* field isn't set for some reason, throw warning and just copy

* whatever is in the after field.

*/

if (WARN_ON_ONCE(!fhp->fh_pre_saved))

cinfo->before_change = 0;

if (!fhp->fh_post_saved)

cinfo->after_change = cinfo->before_change + 1;

}

static __be32

do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh **resfh)

{

struct svc_fh *current_fh = &cstate->current_fh;

int accmode;

__be32 status;

*resfh = kmalloc_obj(struct svc_fh);

if (!*resfh)

return nfserr_jukebox;

fh_init(*resfh, NFS4_FHSIZE);

open->op_truncate = false;

if (open->op_create) {

/* FIXME: check session persistence and pnfs flags.

* The nfsv4.1 spec requires the following semantics:

*

* Persistent | pNFS | Server REQUIRED | Client Allowed

* Reply Cache | server | |

* -------------+--------+-----------------+--------------------

* no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1

* | | | (SHOULD)

* | | and EXCLUSIVE4 | or EXCLUSIVE4

* | | | (SHOULD NOT)

* no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1

* yes | no | GUARDED4 | GUARDED4

* yes | yes | GUARDED4 | GUARDED4

*/

current->fs->umask = open->op_umask;

status = nfsd4_create_file(rqstp, current_fh, *resfh, open);

current->fs->umask = 0;

/*

* Following rfc 3530 14.2.16, and rfc 5661 18.16.4

* use the returned bitmask to indicate which attributes

* we used to store the verifier:

*/

if (nfsd4_create_is_exclusive(open->op_createmode) && status == 0)

open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS |

FATTR4_WORD1_TIME_MODIFY);

} else {

status = nfsd_lookup(rqstp, current_fh,

open->op_fname, open->op_fnamelen, *resfh);

if (status == nfs_ok)

/* NFSv4 protocol requires change attributes even though

* no change happened.

*/

status = fh_fill_both_attrs(current_fh);

}

if (status)

goto out;

status = nfsd_check_obj_isreg(*resfh, cstate->minorversion);

if (status)

goto out;

nfsd4_set_open_owner_reply_cache(cstate, open, *resfh);

accmode = NFSD_MAY_NOP;

if (open->op_created ||

open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)

accmode |= NFSD_MAY_OWNER_OVERRIDE;

status = do_open_permission(rqstp, *resfh, open, accmode);

set_change_info(&open->op_cinfo, current_fh);

out:

return status;

}

static __be32

do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open)

{

struct svc_fh *current_fh = &cstate->current_fh;

int accmode = 0;

/* We don't know the target directory, and therefore can not

* set the change info

*/

memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));

nfsd4_set_open_owner_reply_cache(cstate, open, current_fh);

open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&

(open->op_iattr.ia_size == 0);

/*

* In the delegation case, the client is telling us about an

* open that it *already* performed locally, some time ago. We

* should let it succeed now if possible.

*

* In the case of a CLAIM_FH open, on the other hand, the client

* may be counting on us to enforce permissions (the Linux 4.1

* client uses this for normal opens, for example).

*/

if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH)

accmode = NFSD_MAY_OWNER_OVERRIDE;

return do_open_permission(rqstp, current_fh, open, accmode);

}

static void

copy_clientid(clientid_t *clid, struct nfsd4_session *session)

{

struct nfsd4_sessionid *sid =

(struct nfsd4_sessionid *)session->se_sessionid.data;

clid->cl_boot = sid->clientid.cl_boot;

clid->cl_id = sid->clientid.cl_id;

}

static __be32

nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

struct nfsd4_open *open = &u->open;

__be32 status;

struct svc_fh *resfh = NULL;

struct net *net = SVC_NET(rqstp);

struct nfsd_net *nn = net_generic(net, nfsd_net_id);

bool reclaim = false;

dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",

(int)open->op_fnamelen, open->op_fname,

open->op_openowner);

open->op_filp = NULL;

open->op_rqstp = rqstp;

/* This check required by spec. */

if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL) {

status = nfserr_inval;

goto out_err;

}

open->op_created = false;

/*

* RFC5661 18.51.3

* Before RECLAIM_COMPLETE done, server should deny new lock

*/

if (nfsd4_has_session(cstate) &&

!test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &cstate->clp->cl_flags) &&

open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) {

status = nfserr_grace;

goto out_err;

}

if (nfsd4_has_session(cstate))

copy_clientid(&open->op_clientid, cstate->session);

/* check seqid for replay. set nfs4_owner */

status = nfsd4_process_open1(cstate, open, nn);

if (status == nfserr_replay_me) {

struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay;

fh_put(&cstate->current_fh);

fh_copy_shallow(&cstate->current_fh.fh_handle,

&rp->rp_openfh);

status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);

if (status)

dprintk("nfsd4_open: replay failed"

" restoring previous filehandle\n");

else

status = nfserr_replay_me;

}

if (status)

goto out;

if (open->op_xdr_error) {

status = open->op_xdr_error;

goto out;

}

status = nfsd4_check_open_attributes(cstate, open);

if (status)

goto out;

/* Openowner is now set, so sequence id will get bumped. Now we need

* these checks before we do any creates: */

status = nfserr_grace;

if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)

goto out;

status = nfserr_no_grace;

if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)

goto out;

switch (open->op_claim_type) {

case NFS4_OPEN_CLAIM_DELEGATE_CUR:

case NFS4_OPEN_CLAIM_NULL:

status = do_open_lookup(rqstp, cstate, open, &resfh);

if (status)

goto out;

break;

case NFS4_OPEN_CLAIM_PREVIOUS:

status = nfs4_check_open_reclaim(cstate->clp);

if (status)

goto out;

open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;

reclaim = true;

fallthrough;

case NFS4_OPEN_CLAIM_FH:

case NFS4_OPEN_CLAIM_DELEG_CUR_FH:

status = do_open_fhandle(rqstp, cstate, open);

if (status)

goto out;

resfh = &cstate->current_fh;

break;

case NFS4_OPEN_CLAIM_DELEG_PREV_FH:

case NFS4_OPEN_CLAIM_DELEGATE_PREV:

status = nfserr_notsupp;

goto out;

default:

status = nfserr_inval;

goto out;

}

status = nfsd4_process_open2(rqstp, resfh, open);

if (status && open->op_created)

pr_warn("nfsd4_process_open2 failed to open newly-created file: status=%u\n",

be32_to_cpu(status));

if (reclaim && !status)

nn->somebody_reclaimed = true;

out:

if (open->op_filp) {

fput(open->op_filp);

open->op_filp = NULL;

}

if (resfh && resfh != &cstate->current_fh) {

fh_dup2(&cstate->current_fh, resfh);

fh_put(resfh);

kfree(resfh);

}

nfsd4_cleanup_open_state(cstate, open);

nfsd4_bump_seqid(cstate, status);

out_err:

posix_acl_release(open->op_dpacl);

posix_acl_release(open->op_pacl);

return status;

}

/*

* OPEN is the only seqid-mutating operation whose decoding can fail

* with a seqid-mutating error (specifically, decoding of user names in

* the attributes). Therefore we have to do some processing to look up

* the stateowner so that we can bump the seqid.

*/

static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op)

{

struct nfsd4_open *open = &op->u.open;

if (!seqid_mutating_err(ntohl(op->status)))

return op->status;

if (nfsd4_has_session(cstate))

return op->status;

open->op_xdr_error = op->status;

return nfsd4_open(rqstp, cstate, &op->u);

}

/*

* filehandle-manipulating ops.

*/

static __be32

nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

u->getfh = &cstate->current_fh;

return nfs_ok;

}

static __be32

nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

struct nfsd4_putfh *putfh = &u->putfh;

__be32 ret;

fh_put(&cstate->current_fh);

cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;

memcpy(&cstate->current_fh.fh_handle.fh_raw, putfh->pf_fhval,

putfh->pf_fhlen);

ret = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);

#ifdef CONFIG_NFSD_V4_2_INTER_SSC

if (ret == nfserr_stale && putfh->no_verify) {

SET_FH_FLAG(&cstate->current_fh, NFSD4_FH_FOREIGN);

ret = 0;

}

#endif

return ret;

}

static __be32

nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

fh_put(&cstate->current_fh);

return exp_pseudoroot(rqstp, &cstate->current_fh);

}

static __be32

nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

if (!cstate->save_fh.fh_dentry)

return nfserr_restorefh;

fh_dup2(&cstate->current_fh, &cstate->save_fh);

if (HAS_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG)) {

memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));

SET_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);

}

return nfs_ok;

}

static __be32

nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

fh_dup2(&cstate->save_fh, &cstate->current_fh);

if (HAS_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG)) {

memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));

SET_CSTATE_FLAG(cstate, SAVED_STATE_ID_FLAG);

}

return nfs_ok;

}

/*

* misc nfsv4 ops

*/

static __be32

nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

struct nfsd4_access *access = &u->access;

u32 access_full;

access_full = NFS3_ACCESS_FULL;

if (cstate->minorversion >= 2)

access_full |= NFS4_ACCESS_XALIST | NFS4_ACCESS_XAREAD |

NFS4_ACCESS_XAWRITE;

if (access->ac_req_access & ~access_full)

return nfserr_inval;

access->ac_resp_access = access->ac_req_access;

return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access,

&access->ac_supported);

}

static __be32

nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

struct nfsd4_commit *commit = &u->commit;

struct nfsd_file *nf;

__be32 status;

status = nfsd_file_acquire(rqstp, &cstate->current_fh, NFSD_MAY_WRITE |

NFSD_MAY_NOT_BREAK_LEASE, &nf);

if (status != nfs_ok)

return status;

status = nfsd_commit(rqstp, &cstate->current_fh, nf, commit->co_offset,

commit->co_count,

(__be32 *)commit->co_verf.data);

nfsd_file_put(nf);

return status;

}

static __be32

nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

struct nfsd4_create *create = &u->create;

struct nfsd_attrs attrs = {

.na_iattr = &create->cr_iattr,

.na_seclabel = &create->cr_label,

.na_dpacl = create->cr_dpacl,

.na_pacl = create->cr_pacl,

};

struct svc_fh resfh;

__be32 status;

dev_t rdev;

create->cr_dpacl = NULL;

create->cr_pacl = NULL;

fh_init(&resfh, NFS4_FHSIZE);

status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP);

if (status)

goto out_aftermask;

status = check_attr_support(cstate, create->cr_bmval, nfsd_attrmask);

if (status)

goto out_aftermask;

if (create->cr_acl) {

if (create->cr_dpacl || create->cr_pacl) {

status = nfserr_inval;

goto out_aftermask;

}

status = nfsd4_acl_to_attr(create->cr_type, create->cr_acl,

&attrs);

}

current->fs->umask = create->cr_umask;

switch (create->cr_type) {

case NF4LNK:

status = nfsd_symlink(rqstp, &cstate->current_fh,

create->cr_name, create->cr_namelen,

create->cr_data, &attrs, &resfh);

break;

case NF4BLK:

status = nfserr_inval;

rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);

if (MAJOR(rdev) != create->cr_specdata1 ||

MINOR(rdev) != create->cr_specdata2)

goto out_umask;

status = nfsd_create(rqstp, &cstate->current_fh,

create->cr_name, create->cr_namelen,

&attrs, S_IFBLK, rdev, &resfh);

break;

case NF4CHR:

status = nfserr_inval;

rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);

if (MAJOR(rdev) != create->cr_specdata1 ||

MINOR(rdev) != create->cr_specdata2)

goto out_umask;

status = nfsd_create(rqstp, &cstate->current_fh,

create->cr_name, create->cr_namelen,

&attrs, S_IFCHR, rdev, &resfh);

break;

case NF4SOCK:

status = nfsd_create(rqstp, &cstate->current_fh,

create->cr_name, create->cr_namelen,

&attrs, S_IFSOCK, 0, &resfh);

break;

case NF4FIFO:

status = nfsd_create(rqstp, &cstate->current_fh,

create->cr_name, create->cr_namelen,

&attrs, S_IFIFO, 0, &resfh);

break;

case NF4DIR:

create->cr_iattr.ia_valid &= ~ATTR_SIZE;

status = nfsd_create(rqstp, &cstate->current_fh,

create->cr_name, create->cr_namelen,

&attrs, S_IFDIR, 0, &resfh);

break;

default:

status = nfserr_badtype;

}

if (status)

goto out;

if (attrs.na_labelerr)

create->cr_bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;

if (attrs.na_paclerr || attrs.na_dpaclerr)

create->cr_bmval[0] &= ~FATTR4_WORD0_ACL;

if (attrs.na_dpaclerr)

create->cr_bmval[2] &= ~FATTR4_WORD2_POSIX_DEFAULT_ACL;

if (attrs.na_paclerr)

create->cr_bmval[2] &= ~FATTR4_WORD2_POSIX_ACCESS_ACL;

set_change_info(&create->cr_cinfo, &cstate->current_fh);

fh_dup2(&cstate->current_fh, &resfh);

out:

fh_put(&resfh);

out_umask:

current->fs->umask = 0;

out_aftermask:

nfsd_attrs_free(&attrs);

return status;

}

static __be32

nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

struct nfsd4_getattr *getattr = &u->getattr;

__be32 status;

trace_nfsd_vfs_getattr(rqstp, &cstate->current_fh);

status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);

if (status)

return status;

if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)

return nfserr_inval;

getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];

getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];

getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];

getattr->ga_fhp = &cstate->current_fh;

return nfs_ok;

}

static __be32

nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

struct nfsd4_link *link = &u->link;

__be32 status;

status = nfsd_link(rqstp, &cstate->current_fh,

link->li_name, link->li_namelen, &cstate->save_fh);

if (!status)

set_change_info(&link->li_cinfo, &cstate->current_fh);

return status;

}

static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh)

{

struct svc_fh tmp_fh;

__be32 ret;

fh_init(&tmp_fh, NFS4_FHSIZE);

ret = exp_pseudoroot(rqstp, &tmp_fh);

if (ret)

return ret;

if (tmp_fh.fh_dentry == fh->fh_dentry) {

fh_put(&tmp_fh);

return nfserr_noent;

}

fh_put(&tmp_fh);

return nfsd_lookup(rqstp, fh, "..", 2, fh);

}

static __be32

nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

return nfsd4_do_lookupp(rqstp, &cstate->current_fh);

}

static __be32

nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

return nfsd_lookup(rqstp, &cstate->current_fh,

u->lookup.lo_name, u->lookup.lo_len,

&cstate->current_fh);

}

static __be32

nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,

union nfsd4_op_u *u)

{

struct nfsd4_read *read = &u->read;

__be32 status;

read->rd_nf = NULL;