fs/nfsd/nfs4proc.c

   1 /*
   2  *  Server-side procedures for NFSv4.
   3  *
   4  *  Copyright (c) 2002 The Regents of the University of Michigan.
   5  *  All rights reserved.
   6  *
   7  *  Kendrick Smith <kmsmith@umich.edu>
   8  *  Andy Adamson   <andros@umich.edu>
   9  *
  10  *  Redistribution and use in source and binary forms, with or without
  11  *  modification, are permitted provided that the following conditions
  12  *  are met:
  13  *
  14  *  1. Redistributions of source code must retain the above copyright
  15  *     notice, this list of conditions and the following disclaimer.
  16  *  2. Redistributions in binary form must reproduce the above copyright
  17  *     notice, this list of conditions and the following disclaimer in the
  18  *     documentation and/or other materials provided with the distribution.
  19  *  3. Neither the name of the University nor the names of its
  20  *     contributors may be used to endorse or promote products derived
  21  *     from this software without specific prior written permission.
  22  *
  23  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  24  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  30  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35 #include <linux/fs_struct.h>
  36 #include <linux/file.h>
  37 #include <linux/falloc.h>
  38 #include <linux/slab.h>
  39 #include <linux/kthread.h>
  40
  41 #include "idmap.h"
  42 #include "cache.h"
  43 #include "xdr4.h"
  44 #include "vfs.h"
  45 #include "current_stateid.h"
  46 #include "netns.h"
  47 #include "acl.h"
  48 #include "pnfs.h"
  49 #include "trace.h"
  50
  51 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
  52 #include <linux/security.h>
  53
  54 static inline void
  55 nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
  56 {
  57         struct inode *inode = d_inode(resfh->fh_dentry);
  58         int status;
  59
  60         inode_lock(inode);
  61         status = security_inode_setsecctx(resfh->fh_dentry,
  62                 label->data, label->len);
  63         inode_unlock(inode);
  64
  65         if (status)
  66                 /*
  67                  * XXX: We should really fail the whole open, but we may
  68                  * already have created a new file, so it may be too
  69                  * late.  For now this seems the least of evils:
  70                  */
  71                 bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
  72
  73         return;
  74 }
  75 #else
  76 static inline void
  77 nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
  78 { }
  79 #endif
  80
  81 #define NFSDDBG_FACILITY                NFSDDBG_PROC
  82
  83 static u32 nfsd_attrmask[] = {
  84         NFSD_WRITEABLE_ATTRS_WORD0,
  85         NFSD_WRITEABLE_ATTRS_WORD1,
  86         NFSD_WRITEABLE_ATTRS_WORD2
  87 };
  88
  89 static u32 nfsd41_ex_attrmask[] = {
  90         NFSD_SUPPATTR_EXCLCREAT_WORD0,
  91         NFSD_SUPPATTR_EXCLCREAT_WORD1,
  92         NFSD_SUPPATTR_EXCLCREAT_WORD2
  93 };
  94
  95 static __be32
  96 check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  97                    u32 *bmval, u32 *writable)
  98 {
  99         struct dentry *dentry = cstate->current_fh.fh_dentry;
 100         struct svc_export *exp = cstate->current_fh.fh_export;
 101
 102         if (!nfsd_attrs_supported(cstate->minorversion, bmval))
 103                 return nfserr_attrnotsupp;
 104         if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry)))
 105                 return nfserr_attrnotsupp;
 106         if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) &&
 107                         !(exp->ex_flags & NFSEXP_SECURITY_LABEL))
 108                 return nfserr_attrnotsupp;
 109         if (writable && !bmval_is_subset(bmval, writable))
 110                 return nfserr_inval;
 111         if (writable && (bmval[2] & FATTR4_WORD2_MODE_UMASK) &&
 112                         (bmval[1] & FATTR4_WORD1_MODE))
 113                 return nfserr_inval;
 114         return nfs_ok;
 115 }
 116
 117 static __be32
 118 nfsd4_check_open_attributes(struct svc_rqst *rqstp,
 119         struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
 120 {
 121         __be32 status = nfs_ok;
 122
 123         if (open->op_create == NFS4_OPEN_CREATE) {
 124                 if (open->op_createmode == NFS4_CREATE_UNCHECKED
 125                     || open->op_createmode == NFS4_CREATE_GUARDED)
 126                         status = check_attr_support(rqstp, cstate,
 127                                         open->op_bmval, nfsd_attrmask);
 128                 else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1)
 129                         status = check_attr_support(rqstp, cstate,
 130                                         open->op_bmval, nfsd41_ex_attrmask);
 131         }
 132
 133         return status;
 134 }
 135
 136 static int
 137 is_create_with_attrs(struct nfsd4_open *open)
 138 {
 139         return open->op_create == NFS4_OPEN_CREATE
 140                 && (open->op_createmode == NFS4_CREATE_UNCHECKED
 141                     || open->op_createmode == NFS4_CREATE_GUARDED
 142                     || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1);
 143 }
 144
 145 /*
 146  * if error occurs when setting the acl, just clear the acl bit
 147  * in the returned attr bitmap.
 148  */
 149 static void
 150 do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
 151                 struct nfs4_acl *acl, u32 *bmval)
 152 {
 153         __be32 status;
 154
 155         status = nfsd4_set_nfs4_acl(rqstp, fhp, acl);
 156         if (status)
 157                 /*
 158                  * We should probably fail the whole open at this point,
 159                  * but we've already created the file, so it's too late;
 160                  * So this seems the least of evils:
 161                  */
 162                 bmval[0] &= ~FATTR4_WORD0_ACL;
 163 }
 164
 165 static inline void
 166 fh_dup2(struct svc_fh *dst, struct svc_fh *src)
 167 {
 168         fh_put(dst);
 169         dget(src->fh_dentry);
 170         if (src->fh_export)
 171                 exp_get(src->fh_export);
 172         *dst = *src;
 173 }
 174
 175 static __be32
 176 do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode)
 177 {
 178         __be32 status;
 179
 180         if (open->op_truncate &&
 181                 !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
 182                 return nfserr_inval;
 183
 184         accmode |= NFSD_MAY_READ_IF_EXEC;
 185
 186         if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
 187                 accmode |= NFSD_MAY_READ;
 188         if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
 189                 accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC);
 190         if (open->op_share_deny & NFS4_SHARE_DENY_READ)
 191                 accmode |= NFSD_MAY_WRITE;
 192
 193         status = fh_verify(rqstp, current_fh, S_IFREG, accmode);
 194
 195         return status;
 196 }
 197
 198 static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
 199 {
 200         umode_t mode = d_inode(fh->fh_dentry)->i_mode;
 201
 202         if (S_ISREG(mode))
 203                 return nfs_ok;
 204         if (S_ISDIR(mode))
 205                 return nfserr_isdir;
 206         /*
 207          * Using err_symlink as our catch-all case may look odd; but
 208          * there's no other obvious error for this case in 4.0, and we
 209          * happen to know that it will cause the linux v4 client to do
 210          * the right thing on attempts to open something other than a
 211          * regular file.
 212          */
 213         return nfserr_symlink;
 214 }
 215
 216 static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh)
 217 {
 218         if (nfsd4_has_session(cstate))
 219                 return;
 220         fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
 221                         &resfh->fh_handle);
 222 }
 223
 224 static __be32
 225 do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh **resfh)
 226 {
 227         struct svc_fh *current_fh = &cstate->current_fh;
 228         int accmode;
 229         __be32 status;
 230
 231         *resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
 232         if (!*resfh)
 233                 return nfserr_jukebox;
 234         fh_init(*resfh, NFS4_FHSIZE);
 235         open->op_truncate = 0;
 236
 237         if (open->op_create) {
 238                 /* FIXME: check session persistence and pnfs flags.
 239                  * The nfsv4.1 spec requires the following semantics:
 240                  *
 241                  * Persistent   | pNFS   | Server REQUIRED | Client Allowed
 242                  * Reply Cache  | server |                 |
 243                  * -------------+--------+-----------------+--------------------
 244                  * no           | no     | EXCLUSIVE4_1    | EXCLUSIVE4_1
 245                  *              |        |                 | (SHOULD)
 246                  *              |        | and EXCLUSIVE4  | or EXCLUSIVE4
 247                  *              |        |                 | (SHOULD NOT)
 248                  * no           | yes    | EXCLUSIVE4_1    | EXCLUSIVE4_1
 249                  * yes          | no     | GUARDED4        | GUARDED4
 250                  * yes          | yes    | GUARDED4        | GUARDED4
 251                  */
 252
 253                 /*
 254                  * Note: create modes (UNCHECKED,GUARDED...) are the same
 255                  * in NFSv4 as in v3 except EXCLUSIVE4_1.
 256                  */
 257                 current->fs->umask = open->op_umask;
 258                 status = do_nfsd_create(rqstp, current_fh, open->op_fname.data,
 259                                         open->op_fname.len, &open->op_iattr,
 260                                         *resfh, open->op_createmode,
 261                                         (u32 *)open->op_verf.data,
 262                                         &open->op_truncate, &open->op_created);
 263                 current->fs->umask = 0;
 264
 265                 if (!status && open->op_label.len)
 266                         nfsd4_security_inode_setsecctx(*resfh, &open->op_label, open->op_bmval);
 267
 268                 /*
 269                  * Following rfc 3530 14.2.16, and rfc 5661 18.16.4
 270                  * use the returned bitmask to indicate which attributes
 271                  * we used to store the verifier:
 272                  */
 273                 if (nfsd_create_is_exclusive(open->op_createmode) && status == 0)
 274                         open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS |
 275                                                 FATTR4_WORD1_TIME_MODIFY);
 276         } else
 277                 /*
 278                  * Note this may exit with the parent still locked.
 279                  * We will hold the lock until nfsd4_open's final
 280                  * lookup, to prevent renames or unlinks until we've had
 281                  * a chance to an acquire a delegation if appropriate.
 282                  */
 283                 status = nfsd_lookup(rqstp, current_fh,
 284                                      open->op_fname.data, open->op_fname.len, *resfh);
 285         if (status)
 286                 goto out;
 287         status = nfsd_check_obj_isreg(*resfh);
 288         if (status)
 289                 goto out;
 290
 291         if (is_create_with_attrs(open) && open->op_acl != NULL)
 292                 do_set_nfs4_acl(rqstp, *resfh, open->op_acl, open->op_bmval);
 293
 294         nfsd4_set_open_owner_reply_cache(cstate, open, *resfh);
 295         accmode = NFSD_MAY_NOP;
 296         if (open->op_created ||
 297                         open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
 298                 accmode |= NFSD_MAY_OWNER_OVERRIDE;
 299         status = do_open_permission(rqstp, *resfh, open, accmode);
 300         set_change_info(&open->op_cinfo, current_fh);
 301 out:
 302         return status;
 303 }
 304
 305 static __be32
 306 do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
 307 {
 308         struct svc_fh *current_fh = &cstate->current_fh;
 309         __be32 status;
 310         int accmode = 0;
 311
 312         /* We don't know the target directory, and therefore can not
 313         * set the change info
 314         */
 315
 316         memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));
 317
 318         nfsd4_set_open_owner_reply_cache(cstate, open, current_fh);
 319
 320         open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
 321                 (open->op_iattr.ia_size == 0);
 322         /*
 323          * In the delegation case, the client is telling us about an
 324          * open that it *already* performed locally, some time ago.  We
 325          * should let it succeed now if possible.
 326          *
 327          * In the case of a CLAIM_FH open, on the other hand, the client
 328          * may be counting on us to enforce permissions (the Linux 4.1
 329          * client uses this for normal opens, for example).
 330          */
 331         if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH)
 332                 accmode = NFSD_MAY_OWNER_OVERRIDE;
 333
 334         status = do_open_permission(rqstp, current_fh, open, accmode);
 335
 336         return status;
 337 }
 338
 339 static void
 340 copy_clientid(clientid_t *clid, struct nfsd4_session *session)
 341 {
 342         struct nfsd4_sessionid *sid =
 343                         (struct nfsd4_sessionid *)session->se_sessionid.data;
 344
 345         clid->cl_boot = sid->clientid.cl_boot;
 346         clid->cl_id = sid->clientid.cl_id;
 347 }
 348
 349 static __be32
 350 nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 351            union nfsd4_op_u *u)
 352 {
 353         struct nfsd4_open *open = &u->open;
 354         __be32 status;
 355         struct svc_fh *resfh = NULL;
 356         struct net *net = SVC_NET(rqstp);
 357         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 358         bool reclaim = false;
 359
 360         dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",
 361                 (int)open->op_fname.len, open->op_fname.data,
 362                 open->op_openowner);
 363
 364         /* This check required by spec. */
 365         if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
 366                 return nfserr_inval;
 367
 368         open->op_created = 0;
 369         /*
 370          * RFC5661 18.51.3
 371          * Before RECLAIM_COMPLETE done, server should deny new lock
 372          */
 373         if (nfsd4_has_session(cstate) &&
 374             !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
 375                       &cstate->session->se_client->cl_flags) &&
 376             open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
 377                 return nfserr_grace;
 378
 379         if (nfsd4_has_session(cstate))
 380                 copy_clientid(&open->op_clientid, cstate->session);
 381
 382         /* check seqid for replay. set nfs4_owner */
 383         status = nfsd4_process_open1(cstate, open, nn);
 384         if (status == nfserr_replay_me) {
 385                 struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay;
 386                 fh_put(&cstate->current_fh);
 387                 fh_copy_shallow(&cstate->current_fh.fh_handle,
 388                                 &rp->rp_openfh);
 389                 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
 390                 if (status)
 391                         dprintk("nfsd4_open: replay failed"
 392                                 " restoring previous filehandle\n");
 393                 else
 394                         status = nfserr_replay_me;
 395         }
 396         if (status)
 397                 goto out;
 398         if (open->op_xdr_error) {
 399                 status = open->op_xdr_error;
 400                 goto out;
 401         }
 402
 403         status = nfsd4_check_open_attributes(rqstp, cstate, open);
 404         if (status)
 405                 goto out;
 406
 407         /* Openowner is now set, so sequence id will get bumped.  Now we need
 408          * these checks before we do any creates: */
 409         status = nfserr_grace;
 410         if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
 411                 goto out;
 412         status = nfserr_no_grace;
 413         if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
 414                 goto out;
 415
 416         switch (open->op_claim_type) {
 417                 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
 418                 case NFS4_OPEN_CLAIM_NULL:
 419                         status = do_open_lookup(rqstp, cstate, open, &resfh);
 420                         if (status)
 421                                 goto out;
 422                         break;
 423                 case NFS4_OPEN_CLAIM_PREVIOUS:
 424                         status = nfs4_check_open_reclaim(&open->op_clientid,
 425                                                          cstate, nn);
 426                         if (status)
 427                                 goto out;
 428                         open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
 429                         reclaim = true;
 430                         /* fall through */
 431                 case NFS4_OPEN_CLAIM_FH:
 432                 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
 433                         status = do_open_fhandle(rqstp, cstate, open);
 434                         if (status)
 435                                 goto out;
 436                         resfh = &cstate->current_fh;
 437                         break;
 438                 case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
 439                 case NFS4_OPEN_CLAIM_DELEGATE_PREV:
 440                         dprintk("NFSD: unsupported OPEN claim type %d\n",
 441                                 open->op_claim_type);
 442                         status = nfserr_notsupp;
 443                         goto out;
 444                 default:
 445                         dprintk("NFSD: Invalid OPEN claim type %d\n",
 446                                 open->op_claim_type);
 447                         status = nfserr_inval;
 448                         goto out;
 449         }
 450         /*
 451          * nfsd4_process_open2() does the actual opening of the file.  If
 452          * successful, it (1) truncates the file if open->op_truncate was
 453          * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
 454          */
 455         status = nfsd4_process_open2(rqstp, resfh, open);
 456         WARN(status && open->op_created,
 457              "nfsd4_process_open2 failed to open newly-created file! status=%u\n",
 458              be32_to_cpu(status));
 459         if (reclaim && !status)
 460                 nn->somebody_reclaimed = true;
 461 out:
 462         if (resfh && resfh != &cstate->current_fh) {
 463                 fh_dup2(&cstate->current_fh, resfh);
 464                 fh_put(resfh);
 465                 kfree(resfh);
 466         }
 467         nfsd4_cleanup_open_state(cstate, open);
 468         nfsd4_bump_seqid(cstate, status);
 469         return status;
 470 }
 471
 472 /*
 473  * OPEN is the only seqid-mutating operation whose decoding can fail
 474  * with a seqid-mutating error (specifically, decoding of user names in
 475  * the attributes).  Therefore we have to do some processing to look up
 476  * the stateowner so that we can bump the seqid.
 477  */
 478 static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op)
 479 {
 480         struct nfsd4_open *open = &op->u.open;
 481
 482         if (!seqid_mutating_err(ntohl(op->status)))
 483                 return op->status;
 484         if (nfsd4_has_session(cstate))
 485                 return op->status;
 486         open->op_xdr_error = op->status;
 487         return nfsd4_open(rqstp, cstate, &op->u);
 488 }
 489
 490 /*
 491  * filehandle-manipulating ops.
 492  */
 493 static __be32
 494 nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 495             union nfsd4_op_u *u)
 496 {
 497         u->getfh = &cstate->current_fh;
 498         return nfs_ok;
 499 }
 500
 501 static __be32
 502 nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 503             union nfsd4_op_u *u)
 504 {
 505         struct nfsd4_putfh *putfh = &u->putfh;
 506
 507         fh_put(&cstate->current_fh);
 508         cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
 509         memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
 510                putfh->pf_fhlen);
 511         return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
 512 }
 513
 514 static __be32
 515 nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 516                 union nfsd4_op_u *u)
 517 {
 518         __be32 status;
 519
 520         fh_put(&cstate->current_fh);
 521         status = exp_pseudoroot(rqstp, &cstate->current_fh);
 522         return status;
 523 }
 524
 525 static __be32
 526 nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 527                 union nfsd4_op_u *u)
 528 {
 529         if (!cstate->save_fh.fh_dentry)
 530                 return nfserr_restorefh;
 531
 532         fh_dup2(&cstate->current_fh, &cstate->save_fh);
 533         if (HAS_STATE_ID(cstate, SAVED_STATE_ID_FLAG)) {
 534                 memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));
 535                 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
 536         }
 537         return nfs_ok;
 538 }
 539
 540 static __be32
 541 nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 542              union nfsd4_op_u *u)
 543 {
 544         fh_dup2(&cstate->save_fh, &cstate->current_fh);
 545         if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG)) {
 546                 memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));
 547                 SET_STATE_ID(cstate, SAVED_STATE_ID_FLAG);
 548         }
 549         return nfs_ok;
 550 }
 551
 552 /*
 553  * misc nfsv4 ops
 554  */
 555 static __be32
 556 nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 557              union nfsd4_op_u *u)
 558 {
 559         struct nfsd4_access *access = &u->access;
 560
 561         if (access->ac_req_access & ~NFS3_ACCESS_FULL)
 562                 return nfserr_inval;
 563
 564         access->ac_resp_access = access->ac_req_access;
 565         return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access,
 566                            &access->ac_supported);
 567 }
 568
 569 static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net)
 570 {
 571         __be32 *verf = (__be32 *)verifier->data;
 572
 573         BUILD_BUG_ON(2*sizeof(*verf) != sizeof(verifier->data));
 574
 575         nfsd_copy_boot_verifier(verf, net_generic(net, nfsd_net_id));
 576 }
 577
 578 static __be32
 579 nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 580              union nfsd4_op_u *u)
 581 {
 582         struct nfsd4_commit *commit = &u->commit;
 583
 584         gen_boot_verifier(&commit->co_verf, SVC_NET(rqstp));
 585         return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
 586                              commit->co_count);
 587 }
 588
 589 static __be32
 590 nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 591              union nfsd4_op_u *u)
 592 {
 593         struct nfsd4_create *create = &u->create;
 594         struct svc_fh resfh;
 595         __be32 status;
 596         dev_t rdev;
 597
 598         fh_init(&resfh, NFS4_FHSIZE);
 599
 600         status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP);
 601         if (status)
 602                 return status;
 603
 604         status = check_attr_support(rqstp, cstate, create->cr_bmval,
 605                                     nfsd_attrmask);
 606         if (status)
 607                 return status;
 608
 609         current->fs->umask = create->cr_umask;
 610         switch (create->cr_type) {
 611         case NF4LNK:
 612                 status = nfsd_symlink(rqstp, &cstate->current_fh,
 613                                       create->cr_name, create->cr_namelen,
 614                                       create->cr_data, &resfh);
 615                 break;
 616
 617         case NF4BLK:
 618                 status = nfserr_inval;
 619                 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
 620                 if (MAJOR(rdev) != create->cr_specdata1 ||
 621                     MINOR(rdev) != create->cr_specdata2)
 622                         goto out_umask;
 623                 status = nfsd_create(rqstp, &cstate->current_fh,
 624                                      create->cr_name, create->cr_namelen,
 625                                      &create->cr_iattr, S_IFBLK, rdev, &resfh);
 626                 break;
 627
 628         case NF4CHR:
 629                 status = nfserr_inval;
 630                 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
 631                 if (MAJOR(rdev) != create->cr_specdata1 ||
 632                     MINOR(rdev) != create->cr_specdata2)
 633                         goto out_umask;
 634                 status = nfsd_create(rqstp, &cstate->current_fh,
 635                                      create->cr_name, create->cr_namelen,
 636                                      &create->cr_iattr,S_IFCHR, rdev, &resfh);
 637                 break;
 638
 639         case NF4SOCK:
 640                 status = nfsd_create(rqstp, &cstate->current_fh,
 641                                      create->cr_name, create->cr_namelen,
 642                                      &create->cr_iattr, S_IFSOCK, 0, &resfh);
 643                 break;
 644
 645         case NF4FIFO:
 646                 status = nfsd_create(rqstp, &cstate->current_fh,
 647                                      create->cr_name, create->cr_namelen,
 648                                      &create->cr_iattr, S_IFIFO, 0, &resfh);
 649                 break;
 650
 651         case NF4DIR:
 652                 create->cr_iattr.ia_valid &= ~ATTR_SIZE;
 653                 status = nfsd_create(rqstp, &cstate->current_fh,
 654                                      create->cr_name, create->cr_namelen,
 655                                      &create->cr_iattr, S_IFDIR, 0, &resfh);
 656                 break;
 657
 658         default:
 659                 status = nfserr_badtype;
 660         }
 661
 662         if (status)
 663                 goto out;
 664
 665         if (create->cr_label.len)
 666                 nfsd4_security_inode_setsecctx(&resfh, &create->cr_label, create->cr_bmval);
 667
 668         if (create->cr_acl != NULL)
 669                 do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
 670                                 create->cr_bmval);
 671
 672         fh_unlock(&cstate->current_fh);
 673         set_change_info(&create->cr_cinfo, &cstate->current_fh);
 674         fh_dup2(&cstate->current_fh, &resfh);
 675 out:
 676         fh_put(&resfh);
 677 out_umask:
 678         current->fs->umask = 0;
 679         return status;
 680 }
 681
 682 static __be32
 683 nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 684               union nfsd4_op_u *u)
 685 {
 686         struct nfsd4_getattr *getattr = &u->getattr;
 687         __be32 status;
 688
 689         status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
 690         if (status)
 691                 return status;
 692
 693         if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
 694                 return nfserr_inval;
 695
 696         getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
 697         getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
 698         getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
 699
 700         getattr->ga_fhp = &cstate->current_fh;
 701         return nfs_ok;
 702 }
 703
 704 static __be32
 705 nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 706            union nfsd4_op_u *u)
 707 {
 708         struct nfsd4_link *link = &u->link;
 709         __be32 status;
 710
 711         status = nfsd_link(rqstp, &cstate->current_fh,
 712                            link->li_name, link->li_namelen, &cstate->save_fh);
 713         if (!status)
 714                 set_change_info(&link->li_cinfo, &cstate->current_fh);
 715         return status;
 716 }
 717
 718 static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh)
 719 {
 720         struct svc_fh tmp_fh;
 721         __be32 ret;
 722
 723         fh_init(&tmp_fh, NFS4_FHSIZE);
 724         ret = exp_pseudoroot(rqstp, &tmp_fh);
 725         if (ret)
 726                 return ret;
 727         if (tmp_fh.fh_dentry == fh->fh_dentry) {
 728                 fh_put(&tmp_fh);
 729                 return nfserr_noent;
 730         }
 731         fh_put(&tmp_fh);
 732         return nfsd_lookup(rqstp, fh, "..", 2, fh);
 733 }
 734
 735 static __be32
 736 nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 737               union nfsd4_op_u *u)
 738 {
 739         return nfsd4_do_lookupp(rqstp, &cstate->current_fh);
 740 }
 741
 742 static __be32
 743 nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 744              union nfsd4_op_u *u)
 745 {
 746         return nfsd_lookup(rqstp, &cstate->current_fh,
 747                            u->lookup.lo_name, u->lookup.lo_len,
 748                            &cstate->current_fh);
 749 }
 750
 751 static __be32
 752 nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 753            union nfsd4_op_u *u)
 754 {
 755         struct nfsd4_read *read = &u->read;
 756         __be32 status;
 757
 758         read->rd_nf = NULL;
 759         if (read->rd_offset >= OFFSET_MAX)
 760                 return nfserr_inval;
 761
 762         trace_nfsd_read_start(rqstp, &cstate->current_fh,
 763                               read->rd_offset, read->rd_length);
 764
 765         /*
 766          * If we do a zero copy read, then a client will see read data
 767          * that reflects the state of the file *after* performing the
 768          * following compound.
 769          *
 770          * To ensure proper ordering, we therefore turn off zero copy if
 771          * the client wants us to do more in this compound:
 772          */
 773         if (!nfsd4_last_compound_op(rqstp))
 774                 clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags);
 775
 776         /* check stateid */
 777         status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
 778                                         &read->rd_stateid, RD_STATE,
 779                                         &read->rd_nf);
 780         if (status) {
 781                 dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
 782                 goto out;
 783         }
 784         status = nfs_ok;
 785 out:
 786         read->rd_rqstp = rqstp;
 787         read->rd_fhp = &cstate->current_fh;
 788         return status;
 789 }
 790
 791
 792 static void
 793 nfsd4_read_release(union nfsd4_op_u *u)
 794 {
 795         if (u->read.rd_nf)
 796                 nfsd_file_put(u->read.rd_nf);
 797         trace_nfsd_read_done(u->read.rd_rqstp, u->read.rd_fhp,
 798                              u->read.rd_offset, u->read.rd_length);
 799 }
 800
 801 static __be32
 802 nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 803               union nfsd4_op_u *u)
 804 {
 805         struct nfsd4_readdir *readdir = &u->readdir;
 806         u64 cookie = readdir->rd_cookie;
 807         static const nfs4_verifier zeroverf;
 808
 809         /* no need to check permission - this will be done in nfsd_readdir() */
 810
 811         if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
 812                 return nfserr_inval;
 813
 814         readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
 815         readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
 816         readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
 817
 818         if ((cookie == 1) || (cookie == 2) ||
 819             (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE)))
 820                 return nfserr_bad_cookie;
 821
 822         readdir->rd_rqstp = rqstp;
 823         readdir->rd_fhp = &cstate->current_fh;
 824         return nfs_ok;
 825 }
 826
 827 static __be32
 828 nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 829                union nfsd4_op_u *u)
 830 {
 831         u->readlink.rl_rqstp = rqstp;
 832         u->readlink.rl_fhp = &cstate->current_fh;
 833         return nfs_ok;
 834 }
 835
 836 static __be32
 837 nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 838              union nfsd4_op_u *u)
 839 {
 840         struct nfsd4_remove *remove = &u->remove;
 841         __be32 status;
 842
 843         if (opens_in_grace(SVC_NET(rqstp)))
 844                 return nfserr_grace;
 845         status = nfsd_unlink(rqstp, &cstate->current_fh, 0,
 846                              remove->rm_name, remove->rm_namelen);
 847         if (!status) {
 848                 fh_unlock(&cstate->current_fh);
 849                 set_change_info(&remove->rm_cinfo, &cstate->current_fh);
 850         }
 851         return status;
 852 }
 853
 854 static __be32
 855 nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 856              union nfsd4_op_u *u)
 857 {
 858         struct nfsd4_rename *rename = &u->rename;
 859         __be32 status;
 860
 861         if (opens_in_grace(SVC_NET(rqstp)))
 862                 return nfserr_grace;
 863         status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname,
 864                              rename->rn_snamelen, &cstate->current_fh,
 865                              rename->rn_tname, rename->rn_tnamelen);
 866         if (status)
 867                 return status;
 868         set_change_info(&rename->rn_sinfo, &cstate->current_fh);
 869         set_change_info(&rename->rn_tinfo, &cstate->save_fh);
 870         return nfs_ok;
 871 }
 872
 873 static __be32
 874 nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 875               union nfsd4_op_u *u)
 876 {
 877         struct nfsd4_secinfo *secinfo = &u->secinfo;
 878         struct svc_export *exp;
 879         struct dentry *dentry;
 880         __be32 err;
 881
 882         err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC);
 883         if (err)
 884                 return err;
 885         err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
 886                                     secinfo->si_name, secinfo->si_namelen,
 887                                     &exp, &dentry);
 888         if (err)
 889                 return err;
 890         fh_unlock(&cstate->current_fh);
 891         if (d_really_is_negative(dentry)) {
 892                 exp_put(exp);
 893                 err = nfserr_noent;
 894         } else
 895                 secinfo->si_exp = exp;
 896         dput(dentry);
 897         if (cstate->minorversion)
 898                 /* See rfc 5661 section 2.6.3.1.1.8 */
 899                 fh_put(&cstate->current_fh);
 900         return err;
 901 }
 902
 903 static __be32
 904 nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 905                 union nfsd4_op_u *u)
 906 {
 907         __be32 err;
 908
 909         switch (u->secinfo_no_name.sin_style) {
 910         case NFS4_SECINFO_STYLE4_CURRENT_FH:
 911                 break;
 912         case NFS4_SECINFO_STYLE4_PARENT:
 913                 err = nfsd4_do_lookupp(rqstp, &cstate->current_fh);
 914                 if (err)
 915                         return err;
 916                 break;
 917         default:
 918                 return nfserr_inval;
 919         }
 920
 921         u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export);
 922         fh_put(&cstate->current_fh);
 923         return nfs_ok;
 924 }
 925
 926 static void
 927 nfsd4_secinfo_release(union nfsd4_op_u *u)
 928 {
 929         if (u->secinfo.si_exp)
 930                 exp_put(u->secinfo.si_exp);
 931 }
 932
 933 static void
 934 nfsd4_secinfo_no_name_release(union nfsd4_op_u *u)
 935 {
 936         if (u->secinfo_no_name.sin_exp)
 937                 exp_put(u->secinfo_no_name.sin_exp);
 938 }
 939
 940 static __be32
 941 nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 942               union nfsd4_op_u *u)
 943 {
 944         struct nfsd4_setattr *setattr = &u->setattr;
 945         __be32 status = nfs_ok;
 946         int err;
 947
 948         if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
 949                 status = nfs4_preprocess_stateid_op(rqstp, cstate,
 950                                 &cstate->current_fh, &setattr->sa_stateid,
 951                                 WR_STATE, NULL);
 952                 if (status) {
 953                         dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
 954                         return status;
 955                 }
 956         }
 957         err = fh_want_write(&cstate->current_fh);
 958         if (err)
 959                 return nfserrno(err);
 960         status = nfs_ok;
 961
 962         status = check_attr_support(rqstp, cstate, setattr->sa_bmval,
 963                                     nfsd_attrmask);
 964         if (status)
 965                 goto out;
 966
 967         if (setattr->sa_acl != NULL)
 968                 status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh,
 969                                             setattr->sa_acl);
 970         if (status)
 971                 goto out;
 972         if (setattr->sa_label.len)
 973                 status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh,
 974                                 &setattr->sa_label);
 975         if (status)
 976                 goto out;
 977         status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
 978                                 0, (time_t)0);
 979 out:
 980         fh_drop_write(&cstate->current_fh);
 981         return status;
 982 }
 983
 984 static __be32
 985 nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 986             union nfsd4_op_u *u)
 987 {
 988         struct nfsd4_write *write = &u->write;
 989         stateid_t *stateid = &write->wr_stateid;
 990         struct nfsd_file *nf = NULL;
 991         __be32 status = nfs_ok;
 992         unsigned long cnt;
 993         int nvecs;
 994
 995         if (write->wr_offset >= OFFSET_MAX)
 996                 return nfserr_inval;
 997
 998         cnt = write->wr_buflen;
 999         trace_nfsd_write_start(rqstp, &cstate->current_fh,
1000                                write->wr_offset, cnt);
1001         status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1002                                                 stateid, WR_STATE, &nf);
1003         if (status) {
1004                 dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
1005                 return status;
1006         }
1007
1008         write->wr_how_written = write->wr_stable_how;
1009         gen_boot_verifier(&write->wr_verifier, SVC_NET(rqstp));
1010
1011         nvecs = svc_fill_write_vector(rqstp, write->wr_pagelist,
1012                                       &write->wr_head, write->wr_buflen);
1013         WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec));
1014
1015         status = nfsd_vfs_write(rqstp, &cstate->current_fh, nf->nf_file,
1016                                 write->wr_offset, rqstp->rq_vec, nvecs, &cnt,
1017                                 write->wr_how_written);
1018         nfsd_file_put(nf);
1019
1020         write->wr_bytes_written = cnt;
1021         trace_nfsd_write_done(rqstp, &cstate->current_fh,
1022                               write->wr_offset, cnt);
1023         return status;
1024 }
1025
1026 static __be32
1027 nfsd4_verify_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1028                   stateid_t *src_stateid, struct nfsd_file **src,
1029                   stateid_t *dst_stateid, struct nfsd_file **dst)
1030 {
1031         __be32 status;
1032
1033         if (!cstate->save_fh.fh_dentry)
1034                 return nfserr_nofilehandle;
1035
1036         status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh,
1037                                             src_stateid, RD_STATE, src);
1038         if (status) {
1039                 dprintk("NFSD: %s: couldn't process src stateid!\n", __func__);
1040                 goto out;
1041         }
1042
1043         status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1044                                             dst_stateid, WR_STATE, dst);
1045         if (status) {
1046                 dprintk("NFSD: %s: couldn't process dst stateid!\n", __func__);
1047                 goto out_put_src;
1048         }
1049
1050         /* fix up for NFS-specific error code */
1051         if (!S_ISREG(file_inode((*src)->nf_file)->i_mode) ||
1052             !S_ISREG(file_inode((*dst)->nf_file)->i_mode)) {
1053                 status = nfserr_wrong_type;
1054                 goto out_put_dst;
1055         }
1056
1057 out:
1058         return status;
1059 out_put_dst:
1060         nfsd_file_put(*dst);
1061 out_put_src:
1062         nfsd_file_put(*src);
1063         goto out;
1064 }
1065
1066 static __be32
1067 nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1068                 union nfsd4_op_u *u)
1069 {
1070         struct nfsd4_clone *clone = &u->clone;
1071         struct nfsd_file *src, *dst;
1072         __be32 status;
1073
1074         status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src,
1075                                    &clone->cl_dst_stateid, &dst);
1076         if (status)
1077                 goto out;
1078
1079         status = nfsd4_clone_file_range(src->nf_file, clone->cl_src_pos,
1080                         dst->nf_file, clone->cl_dst_pos, clone->cl_count);
1081
1082         nfsd_file_put(dst);
1083         nfsd_file_put(src);
1084 out:
1085         return status;
1086 }
1087
1088 void nfs4_put_copy(struct nfsd4_copy *copy)
1089 {
1090         if (!refcount_dec_and_test(&copy->refcount))
1091                 return;
1092         kfree(copy);
1093 }
1094
1095 static bool
1096 check_and_set_stop_copy(struct nfsd4_copy *copy)
1097 {
1098         bool value;
1099
1100         spin_lock(&copy->cp_clp->async_lock);
1101         value = copy->stopped;
1102         if (!copy->stopped)
1103                 copy->stopped = true;
1104         spin_unlock(&copy->cp_clp->async_lock);
1105         return value;
1106 }
1107
1108 static void nfsd4_stop_copy(struct nfsd4_copy *copy)
1109 {
1110         /* only 1 thread should stop the copy */
1111         if (!check_and_set_stop_copy(copy))
1112                 kthread_stop(copy->copy_task);
1113         nfs4_put_copy(copy);
1114 }
1115
1116 static struct nfsd4_copy *nfsd4_get_copy(struct nfs4_client *clp)
1117 {
1118         struct nfsd4_copy *copy = NULL;
1119
1120         spin_lock(&clp->async_lock);
1121         if (!list_empty(&clp->async_copies)) {
1122                 copy = list_first_entry(&clp->async_copies, struct nfsd4_copy,
1123                                         copies);
1124                 refcount_inc(&copy->refcount);
1125         }
1126         spin_unlock(&clp->async_lock);
1127         return copy;
1128 }
1129
1130 void nfsd4_shutdown_copy(struct nfs4_client *clp)
1131 {
1132         struct nfsd4_copy *copy;
1133
1134         while ((copy = nfsd4_get_copy(clp)) != NULL)
1135                 nfsd4_stop_copy(copy);
1136 }
1137
1138 static void nfsd4_cb_offload_release(struct nfsd4_callback *cb)
1139 {
1140         struct nfsd4_copy *copy = container_of(cb, struct nfsd4_copy, cp_cb);
1141
1142         nfs4_put_copy(copy);
1143 }
1144
1145 static int nfsd4_cb_offload_done(struct nfsd4_callback *cb,
1146                                  struct rpc_task *task)
1147 {
1148         return 1;
1149 }
1150
1151 static const struct nfsd4_callback_ops nfsd4_cb_offload_ops = {
1152         .release = nfsd4_cb_offload_release,
1153         .done = nfsd4_cb_offload_done
1154 };
1155
1156 static void nfsd4_init_copy_res(struct nfsd4_copy *copy, bool sync)
1157 {
1158         copy->cp_res.wr_stable_how = NFS_UNSTABLE;
1159         copy->cp_synchronous = sync;
1160         gen_boot_verifier(&copy->cp_res.wr_verifier, copy->cp_clp->net);
1161 }
1162
1163 static ssize_t _nfsd_copy_file_range(struct nfsd4_copy *copy)
1164 {
1165         ssize_t bytes_copied = 0;
1166         size_t bytes_total = copy->cp_count;
1167         u64 src_pos = copy->cp_src_pos;
1168         u64 dst_pos = copy->cp_dst_pos;
1169
1170         do {
1171                 if (kthread_should_stop())
1172                         break;
1173                 bytes_copied = nfsd_copy_file_range(copy->nf_src->nf_file,
1174                                 src_pos, copy->nf_dst->nf_file, dst_pos,
1175                                 bytes_total);
1176                 if (bytes_copied <= 0)
1177                         break;
1178                 bytes_total -= bytes_copied;
1179                 copy->cp_res.wr_bytes_written += bytes_copied;
1180                 src_pos += bytes_copied;
1181                 dst_pos += bytes_copied;
1182         } while (bytes_total > 0 && !copy->cp_synchronous);
1183         return bytes_copied;
1184 }
1185
1186 static __be32 nfsd4_do_copy(struct nfsd4_copy *copy, bool sync)
1187 {
1188         __be32 status;
1189         ssize_t bytes;
1190
1191         bytes = _nfsd_copy_file_range(copy);
1192         /* for async copy, we ignore the error, client can always retry
1193          * to get the error
1194          */
1195         if (bytes < 0 && !copy->cp_res.wr_bytes_written)
1196                 status = nfserrno(bytes);
1197         else {
1198                 nfsd4_init_copy_res(copy, sync);
1199                 status = nfs_ok;
1200         }
1201
1202         nfsd_file_put(copy->nf_src);
1203         nfsd_file_put(copy->nf_dst);
1204         return status;
1205 }
1206
1207 static void dup_copy_fields(struct nfsd4_copy *src, struct nfsd4_copy *dst)
1208 {
1209         dst->cp_src_pos = src->cp_src_pos;
1210         dst->cp_dst_pos = src->cp_dst_pos;
1211         dst->cp_count = src->cp_count;
1212         dst->cp_synchronous = src->cp_synchronous;
1213         memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res));
1214         memcpy(&dst->fh, &src->fh, sizeof(src->fh));
1215         dst->cp_clp = src->cp_clp;
1216         dst->nf_dst = nfsd_file_get(src->nf_dst);
1217         dst->nf_src = nfsd_file_get(src->nf_src);
1218         memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid));
1219 }
1220
1221 static void cleanup_async_copy(struct nfsd4_copy *copy)
1222 {
1223         nfs4_free_cp_state(copy);
1224         nfsd_file_put(copy->nf_dst);
1225         nfsd_file_put(copy->nf_src);
1226         spin_lock(&copy->cp_clp->async_lock);
1227         list_del(&copy->copies);
1228         spin_unlock(&copy->cp_clp->async_lock);
1229         nfs4_put_copy(copy);
1230 }
1231
1232 static int nfsd4_do_async_copy(void *data)
1233 {
1234         struct nfsd4_copy *copy = (struct nfsd4_copy *)data;
1235         struct nfsd4_copy *cb_copy;
1236
1237         copy->nfserr = nfsd4_do_copy(copy, 0);
1238         cb_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL);
1239         if (!cb_copy)
1240                 goto out;
1241         memcpy(&cb_copy->cp_res, &copy->cp_res, sizeof(copy->cp_res));
1242         cb_copy->cp_clp = copy->cp_clp;
1243         cb_copy->nfserr = copy->nfserr;
1244         memcpy(&cb_copy->fh, &copy->fh, sizeof(copy->fh));
1245         nfsd4_init_cb(&cb_copy->cp_cb, cb_copy->cp_clp,
1246                         &nfsd4_cb_offload_ops, NFSPROC4_CLNT_CB_OFFLOAD);
1247         nfsd4_run_cb(&cb_copy->cp_cb);
1248 out:
1249         cleanup_async_copy(copy);
1250         return 0;
1251 }
1252
1253 static __be32
1254 nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1255                 union nfsd4_op_u *u)
1256 {
1257         struct nfsd4_copy *copy = &u->copy;
1258         __be32 status;
1259         struct nfsd4_copy *async_copy = NULL;
1260
1261         status = nfsd4_verify_copy(rqstp, cstate, &copy->cp_src_stateid,
1262                                    &copy->nf_src, &copy->cp_dst_stateid,
1263                                    &copy->nf_dst);
1264         if (status)
1265                 goto out;
1266
1267         copy->cp_clp = cstate->clp;
1268         memcpy(&copy->fh, &cstate->current_fh.fh_handle,
1269                 sizeof(struct knfsd_fh));
1270         if (!copy->cp_synchronous) {
1271                 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1272
1273                 status = nfserrno(-ENOMEM);
1274                 async_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL);
1275                 if (!async_copy)
1276                         goto out;
1277                 if (!nfs4_init_cp_state(nn, copy)) {
1278                         kfree(async_copy);
1279                         goto out;
1280                 }
1281                 refcount_set(&async_copy->refcount, 1);
1282                 memcpy(&copy->cp_res.cb_stateid, &copy->cp_stateid,
1283                         sizeof(copy->cp_stateid));
1284                 dup_copy_fields(copy, async_copy);
1285                 async_copy->copy_task = kthread_create(nfsd4_do_async_copy,
1286                                 async_copy, "%s", "copy thread");
1287                 if (IS_ERR(async_copy->copy_task))
1288                         goto out_err;
1289                 spin_lock(&async_copy->cp_clp->async_lock);
1290                 list_add(&async_copy->copies,
1291                                 &async_copy->cp_clp->async_copies);
1292                 spin_unlock(&async_copy->cp_clp->async_lock);
1293                 wake_up_process(async_copy->copy_task);
1294                 status = nfs_ok;
1295         } else
1296                 status = nfsd4_do_copy(copy, 1);
1297 out:
1298         return status;
1299 out_err:
1300         cleanup_async_copy(async_copy);
1301         goto out;
1302 }
1303
1304 struct nfsd4_copy *
1305 find_async_copy(struct nfs4_client *clp, stateid_t *stateid)
1306 {
1307         struct nfsd4_copy *copy;
1308
1309         spin_lock(&clp->async_lock);
1310         list_for_each_entry(copy, &clp->async_copies, copies) {
1311                 if (memcmp(&copy->cp_stateid, stateid, NFS4_STATEID_SIZE))
1312                         continue;
1313                 refcount_inc(&copy->refcount);
1314                 spin_unlock(&clp->async_lock);
1315                 return copy;
1316         }
1317         spin_unlock(&clp->async_lock);
1318         return NULL;
1319 }
1320
1321 static __be32
1322 nfsd4_offload_cancel(struct svc_rqst *rqstp,
1323                      struct nfsd4_compound_state *cstate,
1324                      union nfsd4_op_u *u)
1325 {
1326         struct nfsd4_offload_status *os = &u->offload_status;
1327         __be32 status = 0;
1328         struct nfsd4_copy *copy;
1329         struct nfs4_client *clp = cstate->clp;
1330
1331         copy = find_async_copy(clp, &os->stateid);
1332         if (copy)
1333                 nfsd4_stop_copy(copy);
1334         else
1335                 status = nfserr_bad_stateid;
1336
1337         return status;
1338 }
1339
1340 static __be32
1341 nfsd4_fallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1342                 struct nfsd4_fallocate *fallocate, int flags)
1343 {
1344         __be32 status;
1345         struct nfsd_file *nf;
1346
1347         status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1348                                             &fallocate->falloc_stateid,
1349                                             WR_STATE, &nf);
1350         if (status != nfs_ok) {
1351                 dprintk("NFSD: nfsd4_fallocate: couldn't process stateid!\n");
1352                 return status;
1353         }
1354
1355         status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, nf->nf_file,
1356                                      fallocate->falloc_offset,
1357                                      fallocate->falloc_length,
1358                                      flags);
1359         nfsd_file_put(nf);
1360         return status;
1361 }
1362 static __be32
1363 nfsd4_offload_status(struct svc_rqst *rqstp,
1364                      struct nfsd4_compound_state *cstate,
1365                      union nfsd4_op_u *u)
1366 {
1367         struct nfsd4_offload_status *os = &u->offload_status;
1368         __be32 status = 0;
1369         struct nfsd4_copy *copy;
1370         struct nfs4_client *clp = cstate->clp;
1371
1372         copy = find_async_copy(clp, &os->stateid);
1373         if (copy) {
1374                 os->count = copy->cp_res.wr_bytes_written;
1375                 nfs4_put_copy(copy);
1376         } else
1377                 status = nfserr_bad_stateid;
1378
1379         return status;
1380 }
1381
1382 static __be32
1383 nfsd4_allocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1384                union nfsd4_op_u *u)
1385 {
1386         return nfsd4_fallocate(rqstp, cstate, &u->allocate, 0);
1387 }
1388
1389 static __be32
1390 nfsd4_deallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1391                  union nfsd4_op_u *u)
1392 {
1393         return nfsd4_fallocate(rqstp, cstate, &u->deallocate,
1394                                FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE);
1395 }
1396
1397 static __be32
1398 nfsd4_seek(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1399            union nfsd4_op_u *u)
1400 {
1401         struct nfsd4_seek *seek = &u->seek;
1402         int whence;
1403         __be32 status;
1404         struct nfsd_file *nf;
1405
1406         status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1407                                             &seek->seek_stateid,
1408                                             RD_STATE, &nf);
1409         if (status) {
1410                 dprintk("NFSD: nfsd4_seek: couldn't process stateid!\n");
1411                 return status;
1412         }
1413
1414         switch (seek->seek_whence) {
1415         case NFS4_CONTENT_DATA:
1416                 whence = SEEK_DATA;
1417                 break;
1418         case NFS4_CONTENT_HOLE:
1419                 whence = SEEK_HOLE;
1420                 break;
1421         default:
1422                 status = nfserr_union_notsupp;
1423                 goto out;
1424         }
1425
1426         /*
1427          * Note:  This call does change file->f_pos, but nothing in NFSD
1428          *        should ever file->f_pos.
1429          */
1430         seek->seek_pos = vfs_llseek(nf->nf_file, seek->seek_offset, whence);
1431         if (seek->seek_pos < 0)
1432                 status = nfserrno(seek->seek_pos);
1433         else if (seek->seek_pos >= i_size_read(file_inode(nf->nf_file)))
1434                 seek->seek_eof = true;
1435
1436 out:
1437         nfsd_file_put(nf);
1438         return status;
1439 }
1440
1441 /* This routine never returns NFS_OK!  If there are no other errors, it
1442  * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
1443  * attributes matched.  VERIFY is implemented by mapping NFSERR_SAME
1444  * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
1445  */
1446 static __be32
1447 _nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1448              struct nfsd4_verify *verify)
1449 {
1450         __be32 *buf, *p;
1451         int count;
1452         __be32 status;
1453
1454         status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
1455         if (status)
1456                 return status;
1457
1458         status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL);
1459         if (status)
1460                 return status;
1461
1462         if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)
1463             || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1))
1464                 return nfserr_inval;
1465         if (verify->ve_attrlen & 3)
1466                 return nfserr_inval;
1467
1468         /* count in words:
1469          *   bitmap_len(1) + bitmap(2) + attr_len(1) = 4
1470          */
1471         count = 4 + (verify->ve_attrlen >> 2);
1472         buf = kmalloc(count << 2, GFP_KERNEL);
1473         if (!buf)
1474                 return nfserr_jukebox;
1475
1476         p = buf;
1477         status = nfsd4_encode_fattr_to_buf(&p, count, &cstate->current_fh,
1478                                     cstate->current_fh.fh_export,
1479                                     cstate->current_fh.fh_dentry,
1480                                     verify->ve_bmval,
1481                                     rqstp, 0);
1482         /*
1483          * If nfsd4_encode_fattr() ran out of space, assume that's because
1484          * the attributes are longer (hence different) than those given:
1485          */
1486         if (status == nfserr_resource)
1487                 status = nfserr_not_same;
1488         if (status)
1489                 goto out_kfree;
1490
1491         /* skip bitmap */
1492         p = buf + 1 + ntohl(buf[0]);
1493         status = nfserr_not_same;
1494         if (ntohl(*p++) != verify->ve_attrlen)
1495                 goto out_kfree;
1496         if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen))
1497                 status = nfserr_same;
1498
1499 out_kfree:
1500         kfree(buf);
1501         return status;
1502 }
1503
1504 static __be32
1505 nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1506               union nfsd4_op_u *u)
1507 {
1508         __be32 status;
1509
1510         status = _nfsd4_verify(rqstp, cstate, &u->verify);
1511         return status == nfserr_not_same ? nfs_ok : status;
1512 }
1513
1514 static __be32
1515 nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1516              union nfsd4_op_u *u)
1517 {
1518         __be32 status;
1519
1520         status = _nfsd4_verify(rqstp, cstate, &u->nverify);
1521         return status == nfserr_same ? nfs_ok : status;
1522 }
1523
1524 #ifdef CONFIG_NFSD_PNFS
1525 static const struct nfsd4_layout_ops *
1526 nfsd4_layout_verify(struct svc_export *exp, unsigned int layout_type)
1527 {
1528         if (!exp->ex_layout_types) {
1529                 dprintk("%s: export does not support pNFS\n", __func__);
1530                 return NULL;
1531         }
1532
1533         if (layout_type >= LAYOUT_TYPE_MAX ||
1534             !(exp->ex_layout_types & (1 << layout_type))) {
1535                 dprintk("%s: layout type %d not supported\n",
1536                         __func__, layout_type);
1537                 return NULL;
1538         }
1539
1540         return nfsd4_layout_ops[layout_type];
1541 }
1542
1543 static __be32
1544 nfsd4_getdeviceinfo(struct svc_rqst *rqstp,
1545                 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1546 {
1547         struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo;
1548         const struct nfsd4_layout_ops *ops;
1549         struct nfsd4_deviceid_map *map;
1550         struct svc_export *exp;
1551         __be32 nfserr;
1552
1553         dprintk("%s: layout_type %u dev_id [0x%llx:0x%x] maxcnt %u\n",
1554                __func__,
1555                gdp->gd_layout_type,
1556                gdp->gd_devid.fsid_idx, gdp->gd_devid.generation,
1557                gdp->gd_maxcount);
1558
1559         map = nfsd4_find_devid_map(gdp->gd_devid.fsid_idx);
1560         if (!map) {
1561                 dprintk("%s: couldn't find device ID to export mapping!\n",
1562                         __func__);
1563                 return nfserr_noent;
1564         }
1565
1566         exp = rqst_exp_find(rqstp, map->fsid_type, map->fsid);
1567         if (IS_ERR(exp)) {
1568                 dprintk("%s: could not find device id\n", __func__);
1569                 return nfserr_noent;
1570         }
1571
1572         nfserr = nfserr_layoutunavailable;
1573         ops = nfsd4_layout_verify(exp, gdp->gd_layout_type);
1574         if (!ops)
1575                 goto out;
1576
1577         nfserr = nfs_ok;
1578         if (gdp->gd_maxcount != 0) {
1579                 nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb,
1580                                 rqstp, cstate->session->se_client, gdp);
1581         }
1582
1583         gdp->gd_notify_types &= ops->notify_types;
1584 out:
1585         exp_put(exp);
1586         return nfserr;
1587 }
1588
1589 static void
1590 nfsd4_getdeviceinfo_release(union nfsd4_op_u *u)
1591 {
1592         kfree(u->getdeviceinfo.gd_device);
1593 }
1594
1595 static __be32
1596 nfsd4_layoutget(struct svc_rqst *rqstp,
1597                 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1598 {
1599         struct nfsd4_layoutget *lgp = &u->layoutget;
1600         struct svc_fh *current_fh = &cstate->current_fh;
1601         const struct nfsd4_layout_ops *ops;
1602         struct nfs4_layout_stateid *ls;
1603         __be32 nfserr;
1604         int accmode = NFSD_MAY_READ_IF_EXEC;
1605
1606         switch (lgp->lg_seg.iomode) {
1607         case IOMODE_READ:
1608                 accmode |= NFSD_MAY_READ;
1609                 break;
1610         case IOMODE_RW:
1611                 accmode |= NFSD_MAY_READ | NFSD_MAY_WRITE;
1612                 break;
1613         default:
1614                 dprintk("%s: invalid iomode %d\n",
1615                         __func__, lgp->lg_seg.iomode);
1616                 nfserr = nfserr_badiomode;
1617                 goto out;
1618         }
1619
1620         nfserr = fh_verify(rqstp, current_fh, 0, accmode);
1621         if (nfserr)
1622                 goto out;
1623
1624         nfserr = nfserr_layoutunavailable;
1625         ops = nfsd4_layout_verify(current_fh->fh_export, lgp->lg_layout_type);
1626         if (!ops)
1627                 goto out;
1628
1629         /*
1630          * Verify minlength and range as per RFC5661:
1631          *  o  If loga_length is less than loga_minlength,
1632          *     the metadata server MUST return NFS4ERR_INVAL.
1633          *  o  If the sum of loga_offset and loga_minlength exceeds
1634          *     NFS4_UINT64_MAX, and loga_minlength is not
1635          *     NFS4_UINT64_MAX, the error NFS4ERR_INVAL MUST result.
1636          *  o  If the sum of loga_offset and loga_length exceeds
1637          *     NFS4_UINT64_MAX, and loga_length is not NFS4_UINT64_MAX,
1638          *     the error NFS4ERR_INVAL MUST result.
1639          */
1640         nfserr = nfserr_inval;
1641         if (lgp->lg_seg.length < lgp->lg_minlength ||
1642             (lgp->lg_minlength != NFS4_MAX_UINT64 &&
1643              lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) ||
1644             (lgp->lg_seg.length != NFS4_MAX_UINT64 &&
1645              lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset))
1646                 goto out;
1647         if (lgp->lg_seg.length == 0)
1648                 goto out;
1649
1650         nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lgp->lg_sid,
1651                                                 true, lgp->lg_layout_type, &ls);
1652         if (nfserr) {
1653                 trace_nfsd_layout_get_lookup_fail(&lgp->lg_sid);
1654                 goto out;
1655         }
1656
1657         nfserr = nfserr_recallconflict;
1658         if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls))
1659                 goto out_put_stid;
1660
1661         nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry),
1662                                      current_fh, lgp);
1663         if (nfserr)
1664                 goto out_put_stid;
1665
1666         nfserr = nfsd4_insert_layout(lgp, ls);
1667
1668 out_put_stid:
1669         mutex_unlock(&ls->ls_mutex);
1670         nfs4_put_stid(&ls->ls_stid);
1671 out:
1672         return nfserr;
1673 }
1674
1675 static void
1676 nfsd4_layoutget_release(union nfsd4_op_u *u)
1677 {
1678         kfree(u->layoutget.lg_content);
1679 }
1680
1681 static __be32
1682 nfsd4_layoutcommit(struct svc_rqst *rqstp,
1683                 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1684 {
1685         struct nfsd4_layoutcommit *lcp = &u->layoutcommit;
1686         const struct nfsd4_layout_seg *seg = &lcp->lc_seg;
1687         struct svc_fh *current_fh = &cstate->current_fh;
1688         const struct nfsd4_layout_ops *ops;
1689         loff_t new_size = lcp->lc_last_wr + 1;
1690         struct inode *inode;
1691         struct nfs4_layout_stateid *ls;
1692         __be32 nfserr;
1693
1694         nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_WRITE);
1695         if (nfserr)
1696                 goto out;
1697
1698         nfserr = nfserr_layoutunavailable;
1699         ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type);
1700         if (!ops)
1701                 goto out;
1702         inode = d_inode(current_fh->fh_dentry);
1703
1704         nfserr = nfserr_inval;
1705         if (new_size <= seg->offset) {
1706                 dprintk("pnfsd: last write before layout segment\n");
1707                 goto out;
1708         }
1709         if (new_size > seg->offset + seg->length) {
1710                 dprintk("pnfsd: last write beyond layout segment\n");
1711                 goto out;
1712         }
1713         if (!lcp->lc_newoffset && new_size > i_size_read(inode)) {
1714                 dprintk("pnfsd: layoutcommit beyond EOF\n");
1715                 goto out;
1716         }
1717
1718         nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lcp->lc_sid,
1719                                                 false, lcp->lc_layout_type,
1720                                                 &ls);
1721         if (nfserr) {
1722                 trace_nfsd_layout_commit_lookup_fail(&lcp->lc_sid);
1723                 /* fixup error code as per RFC5661 */
1724                 if (nfserr == nfserr_bad_stateid)
1725                         nfserr = nfserr_badlayout;
1726                 goto out;
1727         }
1728
1729         /* LAYOUTCOMMIT does not require any serialization */
1730         mutex_unlock(&ls->ls_mutex);
1731
1732         if (new_size > i_size_read(inode)) {
1733                 lcp->lc_size_chg = 1;
1734                 lcp->lc_newsize = new_size;
1735         } else {
1736                 lcp->lc_size_chg = 0;
1737         }
1738
1739         nfserr = ops->proc_layoutcommit(inode, lcp);
1740         nfs4_put_stid(&ls->ls_stid);
1741 out:
1742         return nfserr;
1743 }
1744
1745 static __be32
1746 nfsd4_layoutreturn(struct svc_rqst *rqstp,
1747                 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1748 {
1749         struct nfsd4_layoutreturn *lrp = &u->layoutreturn;
1750         struct svc_fh *current_fh = &cstate->current_fh;
1751         __be32 nfserr;
1752
1753         nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_NOP);
1754         if (nfserr)
1755                 goto out;
1756
1757         nfserr = nfserr_layoutunavailable;
1758         if (!nfsd4_layout_verify(current_fh->fh_export, lrp->lr_layout_type))
1759                 goto out;
1760
1761         switch (lrp->lr_seg.iomode) {
1762         case IOMODE_READ:
1763         case IOMODE_RW:
1764         case IOMODE_ANY:
1765                 break;
1766         default:
1767                 dprintk("%s: invalid iomode %d\n", __func__,
1768                         lrp->lr_seg.iomode);
1769                 nfserr = nfserr_inval;
1770                 goto out;
1771         }
1772
1773         switch (lrp->lr_return_type) {
1774         case RETURN_FILE:
1775                 nfserr = nfsd4_return_file_layouts(rqstp, cstate, lrp);
1776                 break;
1777         case RETURN_FSID:
1778         case RETURN_ALL:
1779                 nfserr = nfsd4_return_client_layouts(rqstp, cstate, lrp);
1780                 break;
1781         default:
1782                 dprintk("%s: invalid return_type %d\n", __func__,
1783                         lrp->lr_return_type);
1784                 nfserr = nfserr_inval;
1785                 break;
1786         }
1787 out:
1788         return nfserr;
1789 }
1790 #endif /* CONFIG_NFSD_PNFS */
1791
1792 /*
1793  * NULL call.
1794  */
1795 static __be32
1796 nfsd4_proc_null(struct svc_rqst *rqstp)
1797 {
1798         return nfs_ok;
1799 }
1800
1801 static inline void nfsd4_increment_op_stats(u32 opnum)
1802 {
1803         if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP)
1804                 nfsdstats.nfs4_opcount[opnum]++;
1805 }
1806
1807 static const struct nfsd4_operation nfsd4_ops[];
1808
1809 static const char *nfsd4_op_name(unsigned opnum);
1810
1811 /*
1812  * Enforce NFSv4.1 COMPOUND ordering rules:
1813  *
1814  * Also note, enforced elsewhere:
1815  *      - SEQUENCE other than as first op results in
1816  *        NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().)
1817  *      - BIND_CONN_TO_SESSION must be the only op in its compound.
1818  *        (Enforced in nfsd4_bind_conn_to_session().)
1819  *      - DESTROY_SESSION must be the final operation in a compound, if
1820  *        sessionid's in SEQUENCE and DESTROY_SESSION are the same.
1821  *        (Enforced in nfsd4_destroy_session().)
1822  */
1823 static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args)
1824 {
1825         struct nfsd4_op *first_op = &args->ops[0];
1826
1827         /* These ordering requirements don't apply to NFSv4.0: */
1828         if (args->minorversion == 0)
1829                 return nfs_ok;
1830         /* This is weird, but OK, not our problem: */
1831         if (args->opcnt == 0)
1832                 return nfs_ok;
1833         if (first_op->status == nfserr_op_illegal)
1834                 return nfs_ok;
1835         if (!(nfsd4_ops[first_op->opnum].op_flags & ALLOWED_AS_FIRST_OP))
1836                 return nfserr_op_not_in_session;
1837         if (first_op->opnum == OP_SEQUENCE)
1838                 return nfs_ok;
1839         /*
1840          * So first_op is something allowed outside a session, like
1841          * EXCHANGE_ID; but then it has to be the only op in the
1842          * compound:
1843          */
1844         if (args->opcnt != 1)
1845                 return nfserr_not_only_op;
1846         return nfs_ok;
1847 }
1848
1849 const struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
1850 {
1851         return &nfsd4_ops[op->opnum];
1852 }
1853
1854 bool nfsd4_cache_this_op(struct nfsd4_op *op)
1855 {
1856         if (op->opnum == OP_ILLEGAL)
1857                 return false;
1858         return OPDESC(op)->op_flags & OP_CACHEME;
1859 }
1860
1861 static bool need_wrongsec_check(struct svc_rqst *rqstp)
1862 {
1863         struct nfsd4_compoundres *resp = rqstp->rq_resp;
1864         struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1865         struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
1866         struct nfsd4_op *next = &argp->ops[resp->opcnt];
1867         const struct nfsd4_operation *thisd = OPDESC(this);
1868         const struct nfsd4_operation *nextd;
1869
1870         /*
1871          * Most ops check wronsec on our own; only the putfh-like ops
1872          * have special rules.
1873          */
1874         if (!(thisd->op_flags & OP_IS_PUTFH_LIKE))
1875                 return false;
1876         /*
1877          * rfc 5661 2.6.3.1.1.6: don't bother erroring out a
1878          * put-filehandle operation if we're not going to use the
1879          * result:
1880          */
1881         if (argp->opcnt == resp->opcnt)
1882                 return false;
1883         if (next->opnum == OP_ILLEGAL)
1884                 return false;
1885         nextd = OPDESC(next);
1886         /*
1887          * Rest of 2.6.3.1.1: certain operations will return WRONGSEC
1888          * errors themselves as necessary; others should check for them
1889          * now:
1890          */
1891         return !(nextd->op_flags & OP_HANDLES_WRONGSEC);
1892 }
1893
1894 static void svcxdr_init_encode(struct svc_rqst *rqstp,
1895                                struct nfsd4_compoundres *resp)
1896 {
1897         struct xdr_stream *xdr = &resp->xdr;
1898         struct xdr_buf *buf = &rqstp->rq_res;
1899         struct kvec *head = buf->head;
1900
1901         xdr->buf = buf;
1902         xdr->iov = head;
1903         xdr->p   = head->iov_base + head->iov_len;
1904         xdr->end = head->iov_base + PAGE_SIZE - rqstp->rq_auth_slack;
1905         /* Tail and page_len should be zero at this point: */
1906         buf->len = buf->head[0].iov_len;
1907         xdr->scratch.iov_len = 0;
1908         xdr->page_ptr = buf->pages - 1;
1909         buf->buflen = PAGE_SIZE * (1 + rqstp->rq_page_end - buf->pages)
1910                 - rqstp->rq_auth_slack;
1911 }
1912
1913 /*
1914  * COMPOUND call.
1915  */
1916 static __be32
1917 nfsd4_proc_compound(struct svc_rqst *rqstp)
1918 {
1919         struct nfsd4_compoundargs *args = rqstp->rq_argp;
1920         struct nfsd4_compoundres *resp = rqstp->rq_resp;
1921         struct nfsd4_op *op;
1922         struct nfsd4_compound_state *cstate = &resp->cstate;
1923         struct svc_fh *current_fh = &cstate->current_fh;
1924         struct svc_fh *save_fh = &cstate->save_fh;
1925         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1926         __be32          status;
1927
1928         svcxdr_init_encode(rqstp, resp);
1929         resp->tagp = resp->xdr.p;
1930         /* reserve space for: taglen, tag, and opcnt */
1931         xdr_reserve_space(&resp->xdr, 8 + args->taglen);
1932         resp->taglen = args->taglen;
1933         resp->tag = args->tag;
1934         resp->rqstp = rqstp;
1935         cstate->minorversion = args->minorversion;
1936         fh_init(current_fh, NFS4_FHSIZE);
1937         fh_init(save_fh, NFS4_FHSIZE);
1938         /*
1939          * Don't use the deferral mechanism for NFSv4; compounds make it
1940          * too hard to avoid non-idempotency problems.
1941          */
1942         clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
1943
1944         /*
1945          * According to RFC3010, this takes precedence over all other errors.
1946          */
1947         status = nfserr_minor_vers_mismatch;
1948         if (nfsd_minorversion(nn, args->minorversion, NFSD_TEST) <= 0)
1949                 goto out;
1950         status = nfserr_resource;
1951         if (args->opcnt > NFSD_MAX_OPS_PER_COMPOUND)
1952                 goto out;
1953
1954         status = nfs41_check_op_ordering(args);
1955         if (status) {
1956                 op = &args->ops[0];
1957                 op->status = status;
1958                 resp->opcnt = 1;
1959                 goto encode_op;
1960         }
1961
1962         trace_nfsd_compound(rqstp, args->opcnt);
1963         while (!status && resp->opcnt < args->opcnt) {
1964                 op = &args->ops[resp->opcnt++];
1965
1966                 /*
1967                  * The XDR decode routines may have pre-set op->status;
1968                  * for example, if there is a miscellaneous XDR error
1969                  * it will be set to nfserr_bad_xdr.
1970                  */
1971                 if (op->status) {
1972                         if (op->opnum == OP_OPEN)
1973                                 op->status = nfsd4_open_omfg(rqstp, cstate, op);
1974                         goto encode_op;
1975                 }
1976
1977                 if (!current_fh->fh_dentry) {
1978                         if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
1979                                 op->status = nfserr_nofilehandle;
1980                                 goto encode_op;
1981                         }
1982                 } else if (current_fh->fh_export->ex_fslocs.migrated &&
1983                           !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {
1984                         op->status = nfserr_moved;
1985                         goto encode_op;
1986                 }
1987
1988                 fh_clear_wcc(current_fh);
1989
1990                 /* If op is non-idempotent */
1991                 if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) {
1992                         /*
1993                          * Don't execute this op if we couldn't encode a
1994                          * succesful reply:
1995                          */
1996                         u32 plen = op->opdesc->op_rsize_bop(rqstp, op);
1997                         /*
1998                          * Plus if there's another operation, make sure
1999                          * we'll have space to at least encode an error:
2000                          */
2001                         if (resp->opcnt < args->opcnt)
2002                                 plen += COMPOUND_ERR_SLACK_SPACE;
2003                         op->status = nfsd4_check_resp_size(resp, plen);
2004                 }
2005
2006                 if (op->status)
2007                         goto encode_op;
2008
2009                 if (op->opdesc->op_get_currentstateid)
2010                         op->opdesc->op_get_currentstateid(cstate, &op->u);
2011                 op->status = op->opdesc->op_func(rqstp, cstate, &op->u);
2012
2013                 /* Only from SEQUENCE */
2014                 if (cstate->status == nfserr_replay_cache) {
2015                         dprintk("%s NFS4.1 replay from cache\n", __func__);
2016                         status = op->status;
2017                         goto out;
2018                 }
2019                 if (!op->status) {
2020                         if (op->opdesc->op_set_currentstateid)
2021                                 op->opdesc->op_set_currentstateid(cstate, &op->u);
2022
2023                         if (op->opdesc->op_flags & OP_CLEAR_STATEID)
2024                                 clear_current_stateid(cstate);
2025
2026                         if (need_wrongsec_check(rqstp))
2027                                 op->status = check_nfsd_access(current_fh->fh_export, rqstp);
2028                 }
2029 encode_op:
2030                 if (op->status == nfserr_replay_me) {
2031                         op->replay = &cstate->replay_owner->so_replay;
2032                         nfsd4_encode_replay(&resp->xdr, op);
2033                         status = op->status = op->replay->rp_status;
2034                 } else {
2035                         nfsd4_encode_operation(resp, op);
2036                         status = op->status;
2037                 }
2038
2039                 trace_nfsd_compound_status(args->opcnt, resp->opcnt, status,
2040                                            nfsd4_op_name(op->opnum));
2041
2042                 nfsd4_cstate_clear_replay(cstate);
2043                 nfsd4_increment_op_stats(op->opnum);
2044         }
2045
2046         cstate->status = status;
2047         fh_put(current_fh);
2048         fh_put(save_fh);
2049         BUG_ON(cstate->replay_owner);
2050 out:
2051         /* Reset deferral mechanism for RPC deferrals */
2052         set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
2053         dprintk("nfsv4 compound returned %d\n", ntohl(status));
2054         return status;
2055 }
2056
2057 #define op_encode_hdr_size              (2)
2058 #define op_encode_stateid_maxsz         (XDR_QUADLEN(NFS4_STATEID_SIZE))
2059 #define op_encode_verifier_maxsz        (XDR_QUADLEN(NFS4_VERIFIER_SIZE))
2060 #define op_encode_change_info_maxsz     (5)
2061 #define nfs4_fattr_bitmap_maxsz         (4)
2062
2063 /* We'll fall back on returning no lockowner if run out of space: */
2064 #define op_encode_lockowner_maxsz       (0)
2065 #define op_encode_lock_denied_maxsz     (8 + op_encode_lockowner_maxsz)
2066
2067 #define nfs4_owner_maxsz                (1 + XDR_QUADLEN(IDMAP_NAMESZ))
2068
2069 #define op_encode_ace_maxsz             (3 + nfs4_owner_maxsz)
2070 #define op_encode_delegation_maxsz      (1 + op_encode_stateid_maxsz + 1 + \
2071                                          op_encode_ace_maxsz)
2072
2073 #define op_encode_channel_attrs_maxsz   (6 + 1 + 1)
2074
2075 static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2076 {
2077         return (op_encode_hdr_size) * sizeof(__be32);
2078 }
2079
2080 static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2081 {
2082         return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32);
2083 }
2084
2085 static inline u32 nfsd4_access_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2086 {
2087         /* ac_supported, ac_resp_access */
2088         return (op_encode_hdr_size + 2)* sizeof(__be32);
2089 }
2090
2091 static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2092 {
2093         return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
2094 }
2095
2096 static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2097 {
2098         return (op_encode_hdr_size + op_encode_change_info_maxsz
2099                 + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
2100 }
2101
2102 /*
2103  * Note since this is an idempotent operation we won't insist on failing
2104  * the op prematurely if the estimate is too large.  We may turn off splice
2105  * reads unnecessarily.
2106  */
2107 static inline u32 nfsd4_getattr_rsize(struct svc_rqst *rqstp,
2108                                       struct nfsd4_op *op)
2109 {
2110         u32 *bmap = op->u.getattr.ga_bmval;
2111         u32 bmap0 = bmap[0], bmap1 = bmap[1], bmap2 = bmap[2];
2112         u32 ret = 0;
2113
2114         if (bmap0 & FATTR4_WORD0_ACL)
2115                 return svc_max_payload(rqstp);
2116         if (bmap0 & FATTR4_WORD0_FS_LOCATIONS)
2117                 return svc_max_payload(rqstp);
2118
2119         if (bmap1 & FATTR4_WORD1_OWNER) {
2120                 ret += IDMAP_NAMESZ + 4;
2121                 bmap1 &= ~FATTR4_WORD1_OWNER;
2122         }
2123         if (bmap1 & FATTR4_WORD1_OWNER_GROUP) {
2124                 ret += IDMAP_NAMESZ + 4;
2125                 bmap1 &= ~FATTR4_WORD1_OWNER_GROUP;
2126         }
2127         if (bmap0 & FATTR4_WORD0_FILEHANDLE) {
2128                 ret += NFS4_FHSIZE + 4;
2129                 bmap0 &= ~FATTR4_WORD0_FILEHANDLE;
2130         }
2131         if (bmap2 & FATTR4_WORD2_SECURITY_LABEL) {
2132                 ret += NFS4_MAXLABELLEN + 12;
2133                 bmap2 &= ~FATTR4_WORD2_SECURITY_LABEL;
2134         }
2135         /*
2136          * Largest of remaining attributes are 16 bytes (e.g.,
2137          * supported_attributes)
2138          */
2139         ret += 16 * (hweight32(bmap0) + hweight32(bmap1) + hweight32(bmap2));
2140         /* bitmask, length */
2141         ret += 20;
2142         return ret;
2143 }
2144
2145 static inline u32 nfsd4_getfh_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2146 {
2147         return (op_encode_hdr_size + 1) * sizeof(__be32) + NFS4_FHSIZE;
2148 }
2149
2150 static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2151 {
2152         return (op_encode_hdr_size + op_encode_change_info_maxsz)
2153                 * sizeof(__be32);
2154 }
2155
2156 static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2157 {
2158         return (op_encode_hdr_size + op_encode_lock_denied_maxsz)
2159                 * sizeof(__be32);
2160 }
2161
2162 static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2163 {
2164         return (op_encode_hdr_size + op_encode_stateid_maxsz
2165                 + op_encode_change_info_maxsz + 1
2166                 + nfs4_fattr_bitmap_maxsz
2167                 + op_encode_delegation_maxsz) * sizeof(__be32);
2168 }
2169
2170 static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2171 {
2172         u32 maxcount = 0, rlen = 0;
2173
2174         maxcount = svc_max_payload(rqstp);
2175         rlen = min(op->u.read.rd_length, maxcount);
2176
2177         return (op_encode_hdr_size + 2 + XDR_QUADLEN(rlen)) * sizeof(__be32);
2178 }
2179
2180 static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2181 {
2182         u32 maxcount = 0, rlen = 0;
2183
2184         maxcount = svc_max_payload(rqstp);
2185         rlen = min(op->u.readdir.rd_maxcount, maxcount);
2186
2187         return (op_encode_hdr_size + op_encode_verifier_maxsz +
2188                 XDR_QUADLEN(rlen)) * sizeof(__be32);
2189 }
2190
2191 static inline u32 nfsd4_readlink_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2192 {
2193         return (op_encode_hdr_size + 1) * sizeof(__be32) + PAGE_SIZE;
2194 }
2195
2196 static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2197 {
2198         return (op_encode_hdr_size + op_encode_change_info_maxsz)
2199                 * sizeof(__be32);
2200 }
2201
2202 static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2203 {
2204         return (op_encode_hdr_size + op_encode_change_info_maxsz
2205                 + op_encode_change_info_maxsz) * sizeof(__be32);
2206 }
2207
2208 static inline u32 nfsd4_sequence_rsize(struct svc_rqst *rqstp,
2209                                        struct nfsd4_op *op)
2210 {
2211         return (op_encode_hdr_size
2212                 + XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5) * sizeof(__be32);
2213 }
2214
2215 static inline u32 nfsd4_test_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2216 {
2217         return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids)
2218                 * sizeof(__be32);
2219 }
2220
2221 static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2222 {
2223         return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
2224 }
2225
2226 static inline u32 nfsd4_secinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2227 {
2228         return (op_encode_hdr_size + RPC_AUTH_MAXFLAVOR *
2229                 (4 + XDR_QUADLEN(GSS_OID_MAX_LEN))) * sizeof(__be32);
2230 }
2231
2232 static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2233 {
2234         return (op_encode_hdr_size + 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE)) *
2235                                                                 sizeof(__be32);
2236 }
2237
2238 static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2239 {
2240         return (op_encode_hdr_size + 2 + op_encode_verifier_maxsz) * sizeof(__be32);
2241 }
2242
2243 static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2244 {
2245         return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\
2246                 1 + 1 + /* eir_flags, spr_how */\
2247                 4 + /* spo_must_enforce & _allow with bitmap */\
2248                 2 + /*eir_server_owner.so_minor_id */\
2249                 /* eir_server_owner.so_major_id<> */\
2250                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2251                 /* eir_server_scope<> */\
2252                 XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2253                 1 + /* eir_server_impl_id array length */\
2254                 0 /* ignored eir_server_impl_id contents */) * sizeof(__be32);
2255 }
2256
2257 static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2258 {
2259         return (op_encode_hdr_size + \
2260                 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\
2261                 2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32);
2262 }
2263
2264 static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2265 {
2266         return (op_encode_hdr_size + \
2267                 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\
2268                 2 + /* csr_sequence, csr_flags */\
2269                 op_encode_channel_attrs_maxsz + \
2270                 op_encode_channel_attrs_maxsz) * sizeof(__be32);
2271 }
2272
2273 static inline u32 nfsd4_copy_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2274 {
2275         return (op_encode_hdr_size +
2276                 1 /* wr_callback */ +
2277                 op_encode_stateid_maxsz /* wr_callback */ +
2278                 2 /* wr_count */ +
2279                 1 /* wr_committed */ +
2280                 op_encode_verifier_maxsz +
2281                 1 /* cr_consecutive */ +
2282                 1 /* cr_synchronous */) * sizeof(__be32);
2283 }
2284
2285 static inline u32 nfsd4_offload_status_rsize(struct svc_rqst *rqstp,
2286                                              struct nfsd4_op *op)
2287 {
2288         return (op_encode_hdr_size +
2289                 2 /* osr_count */ +
2290                 1 /* osr_complete<1> optional 0 for now */) * sizeof(__be32);
2291 }
2292
2293 #ifdef CONFIG_NFSD_PNFS
2294 static inline u32 nfsd4_getdeviceinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2295 {
2296         u32 maxcount = 0, rlen = 0;
2297
2298         maxcount = svc_max_payload(rqstp);
2299         rlen = min(op->u.getdeviceinfo.gd_maxcount, maxcount);
2300
2301         return (op_encode_hdr_size +
2302                 1 /* gd_layout_type*/ +
2303                 XDR_QUADLEN(rlen) +
2304                 2 /* gd_notify_types */) * sizeof(__be32);
2305 }
2306
2307 /*
2308  * At this stage we don't really know what layout driver will handle the request,
2309  * so we need to define an arbitrary upper bound here.
2310  */
2311 #define MAX_LAYOUT_SIZE         128
2312 static inline u32 nfsd4_layoutget_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2313 {
2314         return (op_encode_hdr_size +
2315                 1 /* logr_return_on_close */ +
2316                 op_encode_stateid_maxsz +
2317                 1 /* nr of layouts */ +
2318                 MAX_LAYOUT_SIZE) * sizeof(__be32);
2319 }
2320
2321 static inline u32 nfsd4_layoutcommit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2322 {
2323         return (op_encode_hdr_size +
2324                 1 /* locr_newsize */ +
2325                 2 /* ns_size */) * sizeof(__be32);
2326 }
2327
2328 static inline u32 nfsd4_layoutreturn_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2329 {
2330         return (op_encode_hdr_size +
2331                 1 /* lrs_stateid */ +
2332                 op_encode_stateid_maxsz) * sizeof(__be32);
2333 }
2334 #endif /* CONFIG_NFSD_PNFS */
2335
2336
2337 static inline u32 nfsd4_seek_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2338 {
2339         return (op_encode_hdr_size + 3) * sizeof(__be32);
2340 }
2341
2342 static const struct nfsd4_operation nfsd4_ops[] = {
2343         [OP_ACCESS] = {
2344                 .op_func = nfsd4_access,
2345                 .op_name = "OP_ACCESS",
2346                 .op_rsize_bop = nfsd4_access_rsize,
2347         },
2348         [OP_CLOSE] = {
2349                 .op_func = nfsd4_close,
2350                 .op_flags = OP_MODIFIES_SOMETHING,
2351                 .op_name = "OP_CLOSE",
2352                 .op_rsize_bop = nfsd4_status_stateid_rsize,
2353                 .op_get_currentstateid = nfsd4_get_closestateid,
2354                 .op_set_currentstateid = nfsd4_set_closestateid,
2355         },
2356         [OP_COMMIT] = {
2357                 .op_func = nfsd4_commit,
2358                 .op_flags = OP_MODIFIES_SOMETHING,
2359                 .op_name = "OP_COMMIT",
2360                 .op_rsize_bop = nfsd4_commit_rsize,
2361         },
2362         [OP_CREATE] = {
2363                 .op_func = nfsd4_create,
2364                 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID,
2365                 .op_name = "OP_CREATE",
2366                 .op_rsize_bop = nfsd4_create_rsize,
2367         },
2368         [OP_DELEGRETURN] = {
2369                 .op_func = nfsd4_delegreturn,
2370                 .op_flags = OP_MODIFIES_SOMETHING,
2371                 .op_name = "OP_DELEGRETURN",
2372                 .op_rsize_bop = nfsd4_only_status_rsize,
2373                 .op_get_currentstateid = nfsd4_get_delegreturnstateid,
2374         },
2375         [OP_GETATTR] = {
2376                 .op_func = nfsd4_getattr,
2377                 .op_flags = ALLOWED_ON_ABSENT_FS,
2378                 .op_rsize_bop = nfsd4_getattr_rsize,
2379                 .op_name = "OP_GETATTR",
2380         },
2381         [OP_GETFH] = {
2382                 .op_func = nfsd4_getfh,
2383                 .op_name = "OP_GETFH",
2384                 .op_rsize_bop = nfsd4_getfh_rsize,
2385         },
2386         [OP_LINK] = {
2387                 .op_func = nfsd4_link,
2388                 .op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING
2389                                 | OP_CACHEME,
2390                 .op_name = "OP_LINK",
2391                 .op_rsize_bop = nfsd4_link_rsize,
2392         },
2393         [OP_LOCK] = {
2394                 .op_func = nfsd4_lock,
2395                 .op_flags = OP_MODIFIES_SOMETHING |
2396                                 OP_NONTRIVIAL_ERROR_ENCODE,
2397                 .op_name = "OP_LOCK",
2398                 .op_rsize_bop = nfsd4_lock_rsize,
2399                 .op_set_currentstateid = nfsd4_set_lockstateid,
2400         },
2401         [OP_LOCKT] = {
2402                 .op_func = nfsd4_lockt,
2403                 .op_flags = OP_NONTRIVIAL_ERROR_ENCODE,
2404                 .op_name = "OP_LOCKT",
2405                 .op_rsize_bop = nfsd4_lock_rsize,
2406         },
2407         [OP_LOCKU] = {
2408                 .op_func = nfsd4_locku,
2409                 .op_flags = OP_MODIFIES_SOMETHING,
2410                 .op_name = "OP_LOCKU",
2411                 .op_rsize_bop = nfsd4_status_stateid_rsize,
2412                 .op_get_currentstateid = nfsd4_get_lockustateid,
2413         },
2414         [OP_LOOKUP] = {
2415                 .op_func = nfsd4_lookup,
2416                 .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
2417                 .op_name = "OP_LOOKUP",
2418                 .op_rsize_bop = nfsd4_only_status_rsize,
2419         },
2420         [OP_LOOKUPP] = {
2421                 .op_func = nfsd4_lookupp,
2422                 .op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
2423                 .op_name = "OP_LOOKUPP",
2424                 .op_rsize_bop = nfsd4_only_status_rsize,
2425         },
2426         [OP_NVERIFY] = {
2427                 .op_func = nfsd4_nverify,
2428                 .op_name = "OP_NVERIFY",
2429                 .op_rsize_bop = nfsd4_only_status_rsize,
2430         },
2431         [OP_OPEN] = {
2432                 .op_func = nfsd4_open,
2433                 .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
2434                 .op_name = "OP_OPEN",
2435                 .op_rsize_bop = nfsd4_open_rsize,
2436                 .op_set_currentstateid = nfsd4_set_openstateid,
2437         },
2438         [OP_OPEN_CONFIRM] = {
2439                 .op_func = nfsd4_open_confirm,
2440                 .op_flags = OP_MODIFIES_SOMETHING,
2441                 .op_name = "OP_OPEN_CONFIRM",
2442                 .op_rsize_bop = nfsd4_status_stateid_rsize,
2443         },
2444         [OP_OPEN_DOWNGRADE] = {
2445                 .op_func = nfsd4_open_downgrade,
2446                 .op_flags = OP_MODIFIES_SOMETHING,
2447                 .op_name = "OP_OPEN_DOWNGRADE",
2448                 .op_rsize_bop = nfsd4_status_stateid_rsize,
2449                 .op_get_currentstateid = nfsd4_get_opendowngradestateid,
2450                 .op_set_currentstateid = nfsd4_set_opendowngradestateid,
2451         },
2452         [OP_PUTFH] = {
2453                 .op_func = nfsd4_putfh,
2454                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2455                                 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2456                 .op_name = "OP_PUTFH",
2457                 .op_rsize_bop = nfsd4_only_status_rsize,
2458         },
2459         [OP_PUTPUBFH] = {
2460                 .op_func = nfsd4_putrootfh,
2461                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2462                                 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2463                 .op_name = "OP_PUTPUBFH",
2464                 .op_rsize_bop = nfsd4_only_status_rsize,
2465         },
2466         [OP_PUTROOTFH] = {
2467                 .op_func = nfsd4_putrootfh,
2468                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2469                                 | OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2470                 .op_name = "OP_PUTROOTFH",
2471                 .op_rsize_bop = nfsd4_only_status_rsize,
2472         },
2473         [OP_READ] = {
2474                 .op_func = nfsd4_read,
2475                 .op_release = nfsd4_read_release,
2476                 .op_name = "OP_READ",
2477                 .op_rsize_bop = nfsd4_read_rsize,
2478                 .op_get_currentstateid = nfsd4_get_readstateid,
2479         },
2480         [OP_READDIR] = {
2481                 .op_func = nfsd4_readdir,
2482                 .op_name = "OP_READDIR",
2483                 .op_rsize_bop = nfsd4_readdir_rsize,
2484         },
2485         [OP_READLINK] = {
2486                 .op_func = nfsd4_readlink,
2487                 .op_name = "OP_READLINK",
2488                 .op_rsize_bop = nfsd4_readlink_rsize,
2489         },
2490         [OP_REMOVE] = {
2491                 .op_func = nfsd4_remove,
2492                 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2493                 .op_name = "OP_REMOVE",
2494                 .op_rsize_bop = nfsd4_remove_rsize,
2495         },
2496         [OP_RENAME] = {
2497                 .op_func = nfsd4_rename,
2498                 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2499                 .op_name = "OP_RENAME",
2500                 .op_rsize_bop = nfsd4_rename_rsize,
2501         },
2502         [OP_RENEW] = {
2503                 .op_func = nfsd4_renew,
2504                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2505                                 | OP_MODIFIES_SOMETHING,
2506                 .op_name = "OP_RENEW",
2507                 .op_rsize_bop = nfsd4_only_status_rsize,
2508
2509         },
2510         [OP_RESTOREFH] = {
2511                 .op_func = nfsd4_restorefh,
2512                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2513                                 | OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING,
2514                 .op_name = "OP_RESTOREFH",
2515                 .op_rsize_bop = nfsd4_only_status_rsize,
2516         },
2517         [OP_SAVEFH] = {
2518                 .op_func = nfsd4_savefh,
2519                 .op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
2520                 .op_name = "OP_SAVEFH",
2521                 .op_rsize_bop = nfsd4_only_status_rsize,
2522         },
2523         [OP_SECINFO] = {
2524                 .op_func = nfsd4_secinfo,
2525                 .op_release = nfsd4_secinfo_release,
2526                 .op_flags = OP_HANDLES_WRONGSEC,
2527                 .op_name = "OP_SECINFO",
2528                 .op_rsize_bop = nfsd4_secinfo_rsize,
2529         },
2530         [OP_SETATTR] = {
2531                 .op_func = nfsd4_setattr,
2532                 .op_name = "OP_SETATTR",
2533                 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME
2534                                 | OP_NONTRIVIAL_ERROR_ENCODE,
2535                 .op_rsize_bop = nfsd4_setattr_rsize,
2536                 .op_get_currentstateid = nfsd4_get_setattrstateid,
2537         },
2538         [OP_SETCLIENTID] = {
2539                 .op_func = nfsd4_setclientid,
2540                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2541                                 | OP_MODIFIES_SOMETHING | OP_CACHEME
2542                                 | OP_NONTRIVIAL_ERROR_ENCODE,
2543                 .op_name = "OP_SETCLIENTID",
2544                 .op_rsize_bop = nfsd4_setclientid_rsize,
2545         },
2546         [OP_SETCLIENTID_CONFIRM] = {
2547                 .op_func = nfsd4_setclientid_confirm,
2548                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2549                                 | OP_MODIFIES_SOMETHING | OP_CACHEME,
2550                 .op_name = "OP_SETCLIENTID_CONFIRM",
2551                 .op_rsize_bop = nfsd4_only_status_rsize,
2552         },
2553         [OP_VERIFY] = {
2554                 .op_func = nfsd4_verify,
2555                 .op_name = "OP_VERIFY",
2556                 .op_rsize_bop = nfsd4_only_status_rsize,
2557         },
2558         [OP_WRITE] = {
2559                 .op_func = nfsd4_write,
2560                 .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2561                 .op_name = "OP_WRITE",
2562                 .op_rsize_bop = nfsd4_write_rsize,
2563                 .op_get_currentstateid = nfsd4_get_writestateid,
2564         },
2565         [OP_RELEASE_LOCKOWNER] = {
2566                 .op_func = nfsd4_release_lockowner,
2567                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2568                                 | OP_MODIFIES_SOMETHING,
2569                 .op_name = "OP_RELEASE_LOCKOWNER",
2570                 .op_rsize_bop = nfsd4_only_status_rsize,
2571         },
2572
2573         /* NFSv4.1 operations */
2574         [OP_EXCHANGE_ID] = {
2575                 .op_func = nfsd4_exchange_id,
2576                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2577                                 | OP_MODIFIES_SOMETHING,
2578                 .op_name = "OP_EXCHANGE_ID",
2579                 .op_rsize_bop = nfsd4_exchange_id_rsize,
2580         },
2581         [OP_BACKCHANNEL_CTL] = {
2582                 .op_func = nfsd4_backchannel_ctl,
2583                 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2584                 .op_name = "OP_BACKCHANNEL_CTL",
2585                 .op_rsize_bop = nfsd4_only_status_rsize,
2586         },
2587         [OP_BIND_CONN_TO_SESSION] = {
2588                 .op_func = nfsd4_bind_conn_to_session,
2589                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2590                                 | OP_MODIFIES_SOMETHING,
2591                 .op_name = "OP_BIND_CONN_TO_SESSION",
2592                 .op_rsize_bop = nfsd4_bind_conn_to_session_rsize,
2593         },
2594         [OP_CREATE_SESSION] = {
2595                 .op_func = nfsd4_create_session,
2596                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2597                                 | OP_MODIFIES_SOMETHING,
2598                 .op_name = "OP_CREATE_SESSION",
2599                 .op_rsize_bop = nfsd4_create_session_rsize,
2600         },
2601         [OP_DESTROY_SESSION] = {
2602                 .op_func = nfsd4_destroy_session,
2603                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2604                                 | OP_MODIFIES_SOMETHING,
2605                 .op_name = "OP_DESTROY_SESSION",
2606                 .op_rsize_bop = nfsd4_only_status_rsize,
2607         },
2608         [OP_SEQUENCE] = {
2609                 .op_func = nfsd4_sequence,
2610                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
2611                 .op_name = "OP_SEQUENCE",
2612                 .op_rsize_bop = nfsd4_sequence_rsize,
2613         },
2614         [OP_DESTROY_CLIENTID] = {
2615                 .op_func = nfsd4_destroy_clientid,
2616                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2617                                 | OP_MODIFIES_SOMETHING,
2618                 .op_name = "OP_DESTROY_CLIENTID",
2619                 .op_rsize_bop = nfsd4_only_status_rsize,
2620         },
2621         [OP_RECLAIM_COMPLETE] = {
2622                 .op_func = nfsd4_reclaim_complete,
2623                 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2624                 .op_name = "OP_RECLAIM_COMPLETE",
2625                 .op_rsize_bop = nfsd4_only_status_rsize,
2626         },
2627         [OP_SECINFO_NO_NAME] = {
2628                 .op_func = nfsd4_secinfo_no_name,
2629                 .op_release = nfsd4_secinfo_no_name_release,
2630                 .op_flags = OP_HANDLES_WRONGSEC,
2631                 .op_name = "OP_SECINFO_NO_NAME",
2632                 .op_rsize_bop = nfsd4_secinfo_rsize,
2633         },
2634         [OP_TEST_STATEID] = {
2635                 .op_func = nfsd4_test_stateid,
2636                 .op_flags = ALLOWED_WITHOUT_FH,
2637                 .op_name = "OP_TEST_STATEID",
2638                 .op_rsize_bop = nfsd4_test_stateid_rsize,
2639         },
2640         [OP_FREE_STATEID] = {
2641                 .op_func = nfsd4_free_stateid,
2642                 .op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2643                 .op_name = "OP_FREE_STATEID",
2644                 .op_get_currentstateid = nfsd4_get_freestateid,
2645                 .op_rsize_bop = nfsd4_only_status_rsize,
2646         },
2647 #ifdef CONFIG_NFSD_PNFS
2648         [OP_GETDEVICEINFO] = {
2649                 .op_func = nfsd4_getdeviceinfo,
2650                 .op_release = nfsd4_getdeviceinfo_release,
2651                 .op_flags = ALLOWED_WITHOUT_FH,
2652                 .op_name = "OP_GETDEVICEINFO",
2653                 .op_rsize_bop = nfsd4_getdeviceinfo_rsize,
2654         },
2655         [OP_LAYOUTGET] = {
2656                 .op_func = nfsd4_layoutget,
2657                 .op_release = nfsd4_layoutget_release,
2658                 .op_flags = OP_MODIFIES_SOMETHING,
2659                 .op_name = "OP_LAYOUTGET",
2660                 .op_rsize_bop = nfsd4_layoutget_rsize,
2661         },
2662         [OP_LAYOUTCOMMIT] = {
2663                 .op_func = nfsd4_layoutcommit,
2664                 .op_flags = OP_MODIFIES_SOMETHING,
2665                 .op_name = "OP_LAYOUTCOMMIT",
2666                 .op_rsize_bop = nfsd4_layoutcommit_rsize,
2667         },
2668         [OP_LAYOUTRETURN] = {
2669                 .op_func = nfsd4_layoutreturn,
2670                 .op_flags = OP_MODIFIES_SOMETHING,
2671                 .op_name = "OP_LAYOUTRETURN",
2672                 .op_rsize_bop = nfsd4_layoutreturn_rsize,
2673         },
2674 #endif /* CONFIG_NFSD_PNFS */
2675
2676         /* NFSv4.2 operations */
2677         [OP_ALLOCATE] = {
2678                 .op_func = nfsd4_allocate,
2679                 .op_flags = OP_MODIFIES_SOMETHING,
2680                 .op_name = "OP_ALLOCATE",
2681                 .op_rsize_bop = nfsd4_only_status_rsize,
2682         },
2683         [OP_DEALLOCATE] = {
2684                 .op_func = nfsd4_deallocate,
2685                 .op_flags = OP_MODIFIES_SOMETHING,
2686                 .op_name = "OP_DEALLOCATE",
2687                 .op_rsize_bop = nfsd4_only_status_rsize,
2688         },
2689         [OP_CLONE] = {
2690                 .op_func = nfsd4_clone,
2691                 .op_flags = OP_MODIFIES_SOMETHING,
2692                 .op_name = "OP_CLONE",
2693                 .op_rsize_bop = nfsd4_only_status_rsize,
2694         },
2695         [OP_COPY] = {
2696                 .op_func = nfsd4_copy,
2697                 .op_flags = OP_MODIFIES_SOMETHING,
2698                 .op_name = "OP_COPY",
2699                 .op_rsize_bop = nfsd4_copy_rsize,
2700         },
2701         [OP_SEEK] = {
2702                 .op_func = nfsd4_seek,
2703                 .op_name = "OP_SEEK",
2704                 .op_rsize_bop = nfsd4_seek_rsize,
2705         },
2706         [OP_OFFLOAD_STATUS] = {
2707                 .op_func = nfsd4_offload_status,
2708                 .op_name = "OP_OFFLOAD_STATUS",
2709                 .op_rsize_bop = nfsd4_offload_status_rsize,
2710         },
2711         [OP_OFFLOAD_CANCEL] = {
2712                 .op_func = nfsd4_offload_cancel,
2713                 .op_flags = OP_MODIFIES_SOMETHING,
2714                 .op_name = "OP_OFFLOAD_CANCEL",
2715                 .op_rsize_bop = nfsd4_only_status_rsize,
2716         },
2717 };
2718
2719 /**
2720  * nfsd4_spo_must_allow - Determine if the compound op contains an
2721  * operation that is allowed to be sent with machine credentials
2722  *
2723  * @rqstp: a pointer to the struct svc_rqst
2724  *
2725  * Checks to see if the compound contains a spo_must_allow op
2726  * and confirms that it was sent with the proper machine creds.
2727  */
2728
2729 bool nfsd4_spo_must_allow(struct svc_rqst *rqstp)
2730 {
2731         struct nfsd4_compoundres *resp = rqstp->rq_resp;
2732         struct nfsd4_compoundargs *argp = rqstp->rq_argp;
2733         struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
2734         struct nfsd4_compound_state *cstate = &resp->cstate;
2735         struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow;
2736         u32 opiter;
2737
2738         if (!cstate->minorversion)
2739                 return false;
2740
2741         if (cstate->spo_must_allowed == true)
2742                 return true;
2743
2744         opiter = resp->opcnt;
2745         while (opiter < argp->opcnt) {
2746                 this = &argp->ops[opiter++];
2747                 if (test_bit(this->opnum, allow->u.longs) &&
2748                         cstate->clp->cl_mach_cred &&
2749                         nfsd4_mach_creds_match(cstate->clp, rqstp)) {
2750                         cstate->spo_must_allowed = true;
2751                         return true;
2752                 }
2753         }
2754         cstate->spo_must_allowed = false;
2755         return false;
2756 }
2757
2758 int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op)
2759 {
2760         if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp)
2761                 return op_encode_hdr_size * sizeof(__be32);
2762
2763         BUG_ON(OPDESC(op)->op_rsize_bop == NULL);
2764         return OPDESC(op)->op_rsize_bop(rqstp, op);
2765 }
2766
2767 void warn_on_nonidempotent_op(struct nfsd4_op *op)
2768 {
2769         if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) {
2770                 pr_err("unable to encode reply to nonidempotent op %d (%s)\n",
2771                         op->opnum, nfsd4_op_name(op->opnum));
2772                 WARN_ON_ONCE(1);
2773         }
2774 }
2775
2776 static const char *nfsd4_op_name(unsigned opnum)
2777 {
2778         if (opnum < ARRAY_SIZE(nfsd4_ops))
2779                 return nfsd4_ops[opnum].op_name;
2780         return "unknown_operation";
2781 }
2782
2783 #define nfsd4_voidres                   nfsd4_voidargs
2784 struct nfsd4_voidargs { int dummy; };
2785
2786 static const struct svc_procedure nfsd_procedures4[2] = {
2787         [NFSPROC4_NULL] = {
2788                 .pc_func = nfsd4_proc_null,
2789                 .pc_encode = nfs4svc_encode_voidres,
2790                 .pc_argsize = sizeof(struct nfsd4_voidargs),
2791                 .pc_ressize = sizeof(struct nfsd4_voidres),
2792                 .pc_cachetype = RC_NOCACHE,
2793                 .pc_xdrressize = 1,
2794         },
2795         [NFSPROC4_COMPOUND] = {
2796                 .pc_func = nfsd4_proc_compound,
2797                 .pc_decode = nfs4svc_decode_compoundargs,
2798                 .pc_encode = nfs4svc_encode_compoundres,
2799                 .pc_argsize = sizeof(struct nfsd4_compoundargs),
2800                 .pc_ressize = sizeof(struct nfsd4_compoundres),
2801                 .pc_release = nfsd4_release_compoundargs,
2802                 .pc_cachetype = RC_NOCACHE,
2803                 .pc_xdrressize = NFSD_BUFSIZE/4,
2804         },
2805 };
2806
2807 static unsigned int nfsd_count3[ARRAY_SIZE(nfsd_procedures4)];
2808 const struct svc_version nfsd_version4 = {
2809         .vs_vers                = 4,
2810         .vs_nproc               = 2,
2811         .vs_proc                = nfsd_procedures4,
2812         .vs_count               = nfsd_count3,
2813         .vs_dispatch            = nfsd_dispatch,
2814         .vs_xdrsize             = NFS4_SVC_XDRSIZE,
2815         .vs_rpcb_optnl          = true,
2816         .vs_need_cong_ctrl      = true,
2817 };
2818
2819 /*
2820  * Local variables:
2821  *  c-basic-offset: 8
2822  * End:
2823  */