SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/nfsd/nfs4proc.c

   1 /*
   2  *  fs/nfsd/nfs4proc.c
   3  *
   4  *  Server-side procedures for NFSv4.
   5  *
   6  *  Copyright (c) 2002 The Regents of the University of Michigan.
   7  *  All rights reserved.
   8  *
   9  *  Kendrick Smith <kmsmith@umich.edu>
  10  *  Andy Adamson   <andros@umich.edu>
  11  *
  12  *  Redistribution and use in source and binary forms, with or without
  13  *  modification, are permitted provided that the following conditions
  14  *  are met:
  15  *
  16  *  1. Redistributions of source code must retain the above copyright
  17  *     notice, this list of conditions and the following disclaimer.
  18  *  2. Redistributions in binary form must reproduce the above copyright
  19  *     notice, this list of conditions and the following disclaimer in the
  20  *     documentation and/or other materials provided with the distribution.
  21  *  3. Neither the name of the University nor the names of its
  22  *     contributors may be used to endorse or promote products derived
  23  *     from this software without specific prior written permission.
  24  *
  25  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  26  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  27  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  28  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  32  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  34  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  35  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37 #include <linux/file.h>
  38
  39 #include "cache.h"
  40 #include "xdr4.h"
  41 #include "vfs.h"
  42
  43 #define NFSDDBG_FACILITY                NFSDDBG_PROC
  44
  45 static u32 nfsd_attrmask[] = {
  46         NFSD_WRITEABLE_ATTRS_WORD0,
  47         NFSD_WRITEABLE_ATTRS_WORD1,
  48         NFSD_WRITEABLE_ATTRS_WORD2
  49 };
  50
  51 static u32 nfsd41_ex_attrmask[] = {
  52         NFSD_SUPPATTR_EXCLCREAT_WORD0,
  53         NFSD_SUPPATTR_EXCLCREAT_WORD1,
  54         NFSD_SUPPATTR_EXCLCREAT_WORD2
  55 };
  56
  57 static __be32
  58 check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  59                    u32 *bmval, u32 *writable)
  60 {
  61         struct dentry *dentry = cstate->current_fh.fh_dentry;
  62
  63         /*
  64          * Check about attributes are supported by the NFSv4 server or not.
  65          * According to spec, unsupported attributes return ERR_ATTRNOTSUPP.
  66          */
  67         if ((bmval[0] & ~nfsd_suppattrs0(cstate->minorversion)) ||
  68             (bmval[1] & ~nfsd_suppattrs1(cstate->minorversion)) ||
  69             (bmval[2] & ~nfsd_suppattrs2(cstate->minorversion)))
  70                 return nfserr_attrnotsupp;
  71
  72         /*
  73          * Check FATTR4_WORD0_ACL can be supported
  74          * in current environment or not.
  75          */
  76         if (bmval[0] & FATTR4_WORD0_ACL) {
  77                 if (!IS_POSIXACL(dentry->d_inode))
  78                         return nfserr_attrnotsupp;
  79         }
  80
  81         /*
  82          * According to spec, read-only attributes return ERR_INVAL.
  83          */
  84         if (writable) {
  85                 if ((bmval[0] & ~writable[0]) || (bmval[1] & ~writable[1]) ||
  86                     (bmval[2] & ~writable[2]))
  87                         return nfserr_inval;
  88         }
  89
  90         return nfs_ok;
  91 }
  92
  93 static __be32
  94 nfsd4_check_open_attributes(struct svc_rqst *rqstp,
  95         struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
  96 {
  97         __be32 status = nfs_ok;
  98
  99         if (open->op_create == NFS4_OPEN_CREATE) {
 100                 if (open->op_createmode == NFS4_CREATE_UNCHECKED
 101                     || open->op_createmode == NFS4_CREATE_GUARDED)
 102                         status = check_attr_support(rqstp, cstate,
 103                                         open->op_bmval, nfsd_attrmask);
 104                 else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1)
 105                         status = check_attr_support(rqstp, cstate,
 106                                         open->op_bmval, nfsd41_ex_attrmask);
 107         }
 108
 109         return status;
 110 }
 111
 112 static int
 113 is_create_with_attrs(struct nfsd4_open *open)
 114 {
 115         return open->op_create == NFS4_OPEN_CREATE
 116                 && (open->op_createmode == NFS4_CREATE_UNCHECKED
 117                     || open->op_createmode == NFS4_CREATE_GUARDED
 118                     || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1);
 119 }
 120
 121 /*
 122  * if error occurs when setting the acl, just clear the acl bit
 123  * in the returned attr bitmap.
 124  */
 125 static void
 126 do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
 127                 struct nfs4_acl *acl, u32 *bmval)
 128 {
 129         __be32 status;
 130
 131         status = nfsd4_set_nfs4_acl(rqstp, fhp, acl);
 132         if (status)
 133                 /*
 134                  * We should probably fail the whole open at this point,
 135                  * but we've already created the file, so it's too late;
 136                  * So this seems the least of evils:
 137                  */
 138                 bmval[0] &= ~FATTR4_WORD0_ACL;
 139 }
 140
 141 static inline void
 142 fh_dup2(struct svc_fh *dst, struct svc_fh *src)
 143 {
 144         fh_put(dst);
 145         dget(src->fh_dentry);
 146         if (src->fh_export)
 147                 cache_get(&src->fh_export->h);
 148         *dst = *src;
 149 }
 150
 151 static __be32
 152 do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode)
 153 {
 154         __be32 status;
 155
 156         if (open->op_truncate &&
 157                 !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
 158                 return nfserr_inval;
 159
 160         if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
 161                 accmode |= NFSD_MAY_READ;
 162         if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
 163                 accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC);
 164         if (open->op_share_deny & NFS4_SHARE_DENY_READ)
 165                 accmode |= NFSD_MAY_WRITE;
 166
 167         status = fh_verify(rqstp, current_fh, S_IFREG, accmode);
 168
 169         return status;
 170 }
 171
 172 static __be32
 173 do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
 174 {
 175         struct svc_fh resfh;
 176         __be32 status;
 177         int created = 0;
 178
 179         fh_init(&resfh, NFS4_FHSIZE);
 180         open->op_truncate = 0;
 181
 182         if (open->op_create) {
 183                 /* FIXME: check session persistence and pnfs flags.
 184                  * The nfsv4.1 spec requires the following semantics:
 185                  *
 186                  * Persistent   | pNFS   | Server REQUIRED | Client Allowed
 187                  * Reply Cache  | server |                 |
 188                  * -------------+--------+-----------------+--------------------
 189                  * no           | no     | EXCLUSIVE4_1    | EXCLUSIVE4_1
 190                  *              |        |                 | (SHOULD)
 191                  *              |        | and EXCLUSIVE4  | or EXCLUSIVE4
 192                  *              |        |                 | (SHOULD NOT)
 193                  * no           | yes    | EXCLUSIVE4_1    | EXCLUSIVE4_1
 194                  * yes          | no     | GUARDED4        | GUARDED4
 195                  * yes          | yes    | GUARDED4        | GUARDED4
 196                  */
 197
 198                 /*
 199                  * Note: create modes (UNCHECKED,GUARDED...) are the same
 200                  * in NFSv4 as in v3.
 201                  */
 202                 status = nfsd_create_v3(rqstp, current_fh, open->op_fname.data,
 203                                         open->op_fname.len, &open->op_iattr,
 204                                         &resfh, open->op_createmode,
 205                                         (u32 *)open->op_verf.data,
 206                                         &open->op_truncate, &created);
 207
 208                 /*
 209                  * Following rfc 3530 14.2.16, use the returned bitmask
 210                  * to indicate which attributes we used to store the
 211                  * verifier:
 212                  */
 213                 if (open->op_createmode == NFS4_CREATE_EXCLUSIVE && status == 0)
 214                         open->op_bmval[1] = (FATTR4_WORD1_TIME_ACCESS |
 215                                                 FATTR4_WORD1_TIME_MODIFY);
 216         } else {
 217                 status = nfsd_lookup(rqstp, current_fh,
 218                                      open->op_fname.data, open->op_fname.len, &resfh);
 219                 fh_unlock(current_fh);
 220         }
 221         if (status)
 222                 goto out;
 223
 224         if (is_create_with_attrs(open) && open->op_acl != NULL)
 225                 do_set_nfs4_acl(rqstp, &resfh, open->op_acl, open->op_bmval);
 226
 227         set_change_info(&open->op_cinfo, current_fh);
 228         fh_dup2(current_fh, &resfh);
 229
 230         /* set reply cache */
 231         fh_copy_shallow(&open->op_stateowner->so_replay.rp_openfh,
 232                         &resfh.fh_handle);
 233         if (!created)
 234                 status = do_open_permission(rqstp, current_fh, open,
 235                                             NFSD_MAY_NOP);
 236
 237 out:
 238         fh_put(&resfh);
 239         return status;
 240 }
 241
 242 static __be32
 243 do_open_fhandle(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
 244 {
 245         __be32 status;
 246
 247         /* Only reclaims from previously confirmed clients are valid */
 248         if ((status = nfs4_check_open_reclaim(&open->op_clientid)))
 249                 return status;
 250
 251         /* We don't know the target directory, and therefore can not
 252         * set the change info
 253         */
 254
 255         memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));
 256
 257         /* set replay cache */
 258         fh_copy_shallow(&open->op_stateowner->so_replay.rp_openfh,
 259                         &current_fh->fh_handle);
 260
 261         open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
 262                 (open->op_iattr.ia_size == 0);
 263
 264         status = do_open_permission(rqstp, current_fh, open,
 265                                     NFSD_MAY_OWNER_OVERRIDE);
 266
 267         return status;
 268 }
 269
 270 static void
 271 copy_clientid(clientid_t *clid, struct nfsd4_session *session)
 272 {
 273         struct nfsd4_sessionid *sid =
 274                         (struct nfsd4_sessionid *)session->se_sessionid.data;
 275
 276         clid->cl_boot = sid->clientid.cl_boot;
 277         clid->cl_id = sid->clientid.cl_id;
 278 }
 279
 280 static __be32
 281 nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 282            struct nfsd4_open *open)
 283 {
 284         __be32 status;
 285         struct nfsd4_compoundres *resp;
 286
 287         dprintk("NFSD: nfsd4_open filename %.*s op_stateowner %p\n",
 288                 (int)open->op_fname.len, open->op_fname.data,
 289                 open->op_stateowner);
 290
 291         /* This check required by spec. */
 292         if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
 293                 return nfserr_inval;
 294
 295         if (nfsd4_has_session(cstate))
 296                 copy_clientid(&open->op_clientid, cstate->session);
 297
 298         nfs4_lock_state();
 299
 300         /* check seqid for replay. set nfs4_owner */
 301         resp = rqstp->rq_resp;
 302         status = nfsd4_process_open1(&resp->cstate, open);
 303         if (status == nfserr_replay_me) {
 304                 struct nfs4_replay *rp = &open->op_stateowner->so_replay;
 305                 fh_put(&cstate->current_fh);
 306                 fh_copy_shallow(&cstate->current_fh.fh_handle,
 307                                 &rp->rp_openfh);
 308                 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
 309                 if (status)
 310                         dprintk("nfsd4_open: replay failed"
 311                                 " restoring previous filehandle\n");
 312                 else
 313                         status = nfserr_replay_me;
 314         }
 315         if (status)
 316                 goto out;
 317
 318         status = nfsd4_check_open_attributes(rqstp, cstate, open);
 319         if (status)
 320                 goto out;
 321
 322         /* Openowner is now set, so sequence id will get bumped.  Now we need
 323          * these checks before we do any creates: */
 324         status = nfserr_grace;
 325         if (locks_in_grace() && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
 326                 goto out;
 327         status = nfserr_no_grace;
 328         if (!locks_in_grace() && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
 329                 goto out;
 330
 331         switch (open->op_claim_type) {
 332                 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
 333                 case NFS4_OPEN_CLAIM_NULL:
 334                         /*
 335                          * (1) set CURRENT_FH to the file being opened,
 336                          * creating it if necessary, (2) set open->op_cinfo,
 337                          * (3) set open->op_truncate if the file is to be
 338                          * truncated after opening, (4) do permission checking.
 339                          */
 340                         status = do_open_lookup(rqstp, &cstate->current_fh,
 341                                                 open);
 342                         if (status)
 343                                 goto out;
 344                         break;
 345                 case NFS4_OPEN_CLAIM_PREVIOUS:
 346                         open->op_stateowner->so_confirmed = 1;
 347                         /*
 348                          * The CURRENT_FH is already set to the file being
 349                          * opened.  (1) set open->op_cinfo, (2) set
 350                          * open->op_truncate if the file is to be truncated
 351                          * after opening, (3) do permission checking.
 352                         */
 353                         status = do_open_fhandle(rqstp, &cstate->current_fh,
 354                                                  open);
 355                         if (status)
 356                                 goto out;
 357                         break;
 358                 case NFS4_OPEN_CLAIM_DELEGATE_PREV:
 359                         open->op_stateowner->so_confirmed = 1;
 360                         dprintk("NFSD: unsupported OPEN claim type %d\n",
 361                                 open->op_claim_type);
 362                         status = nfserr_notsupp;
 363                         goto out;
 364                 default:
 365                         dprintk("NFSD: Invalid OPEN claim type %d\n",
 366                                 open->op_claim_type);
 367                         status = nfserr_inval;
 368                         goto out;
 369         }
 370         /*
 371          * nfsd4_process_open2() does the actual opening of the file.  If
 372          * successful, it (1) truncates the file if open->op_truncate was
 373          * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
 374          */
 375         status = nfsd4_process_open2(rqstp, &cstate->current_fh, open);
 376 out:
 377         if (open->op_stateowner) {
 378                 nfs4_get_stateowner(open->op_stateowner);
 379                 cstate->replay_owner = open->op_stateowner;
 380         }
 381         nfs4_unlock_state();
 382         return status;
 383 }
 384
 385 /*
 386  * filehandle-manipulating ops.
 387  */
 388 static __be32
 389 nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 390             struct svc_fh **getfh)
 391 {
 392         if (!cstate->current_fh.fh_dentry)
 393                 return nfserr_nofilehandle;
 394
 395         *getfh = &cstate->current_fh;
 396         return nfs_ok;
 397 }
 398
 399 static __be32
 400 nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 401             struct nfsd4_putfh *putfh)
 402 {
 403         fh_put(&cstate->current_fh);
 404         cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
 405         memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
 406                putfh->pf_fhlen);
 407         return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
 408 }
 409
 410 static __be32
 411 nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 412                 void *arg)
 413 {
 414         __be32 status;
 415
 416         fh_put(&cstate->current_fh);
 417         status = exp_pseudoroot(rqstp, &cstate->current_fh);
 418         return status;
 419 }
 420
 421 static __be32
 422 nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 423                 void *arg)
 424 {
 425         if (!cstate->save_fh.fh_dentry)
 426                 return nfserr_restorefh;
 427
 428         fh_dup2(&cstate->current_fh, &cstate->save_fh);
 429         return nfs_ok;
 430 }
 431
 432 static __be32
 433 nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 434              void *arg)
 435 {
 436         if (!cstate->current_fh.fh_dentry)
 437                 return nfserr_nofilehandle;
 438
 439         fh_dup2(&cstate->save_fh, &cstate->current_fh);
 440         return nfs_ok;
 441 }
 442
 443 /*
 444  * misc nfsv4 ops
 445  */
 446 static __be32
 447 nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 448              struct nfsd4_access *access)
 449 {
 450         if (access->ac_req_access & ~NFS3_ACCESS_FULL)
 451                 return nfserr_inval;
 452
 453         access->ac_resp_access = access->ac_req_access;
 454         return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access,
 455                            &access->ac_supported);
 456 }
 457
 458 static __be32
 459 nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 460              struct nfsd4_commit *commit)
 461 {
 462         __be32 status;
 463
 464         u32 *p = (u32 *)commit->co_verf.data;
 465         *p++ = nfssvc_boot.tv_sec;
 466         *p++ = nfssvc_boot.tv_usec;
 467
 468         status = nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
 469                              commit->co_count);
 470         if (status == nfserr_symlink)
 471                 status = nfserr_inval;
 472         return status;
 473 }
 474
 475 static __be32
 476 nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 477              struct nfsd4_create *create)
 478 {
 479         struct svc_fh resfh;
 480         __be32 status;
 481         dev_t rdev;
 482
 483         fh_init(&resfh, NFS4_FHSIZE);
 484
 485         status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR,
 486                            NFSD_MAY_CREATE);
 487         if (status == nfserr_symlink)
 488                 status = nfserr_notdir;
 489         if (status)
 490                 return status;
 491
 492         status = check_attr_support(rqstp, cstate, create->cr_bmval,
 493                                     nfsd_attrmask);
 494         if (status)
 495                 return status;
 496
 497         switch (create->cr_type) {
 498         case NF4LNK:
 499                 /* ugh! we have to null-terminate the linktext, or
 500                  * vfs_symlink() will choke.  it is always safe to
 501                  * null-terminate by brute force, since at worst we
 502                  * will overwrite the first byte of the create namelen
 503                  * in the XDR buffer, which has already been extracted
 504                  * during XDR decode.
 505                  */
 506                 create->cr_linkname[create->cr_linklen] = 0;
 507
 508                 status = nfsd_symlink(rqstp, &cstate->current_fh,
 509                                       create->cr_name, create->cr_namelen,
 510                                       create->cr_linkname, create->cr_linklen,
 511                                       &resfh, &create->cr_iattr);
 512                 break;
 513
 514         case NF4BLK:
 515                 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
 516                 if (MAJOR(rdev) != create->cr_specdata1 ||
 517                     MINOR(rdev) != create->cr_specdata2)
 518                         return nfserr_inval;
 519                 status = nfsd_create(rqstp, &cstate->current_fh,
 520                                      create->cr_name, create->cr_namelen,
 521                                      &create->cr_iattr, S_IFBLK, rdev, &resfh);
 522                 break;
 523
 524         case NF4CHR:
 525                 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
 526                 if (MAJOR(rdev) != create->cr_specdata1 ||
 527                     MINOR(rdev) != create->cr_specdata2)
 528                         return nfserr_inval;
 529                 status = nfsd_create(rqstp, &cstate->current_fh,
 530                                      create->cr_name, create->cr_namelen,
 531                                      &create->cr_iattr,S_IFCHR, rdev, &resfh);
 532                 break;
 533
 534         case NF4SOCK:
 535                 status = nfsd_create(rqstp, &cstate->current_fh,
 536                                      create->cr_name, create->cr_namelen,
 537                                      &create->cr_iattr, S_IFSOCK, 0, &resfh);
 538                 break;
 539
 540         case NF4FIFO:
 541                 status = nfsd_create(rqstp, &cstate->current_fh,
 542                                      create->cr_name, create->cr_namelen,
 543                                      &create->cr_iattr, S_IFIFO, 0, &resfh);
 544                 break;
 545
 546         case NF4DIR:
 547                 create->cr_iattr.ia_valid &= ~ATTR_SIZE;
 548                 status = nfsd_create(rqstp, &cstate->current_fh,
 549                                      create->cr_name, create->cr_namelen,
 550                                      &create->cr_iattr, S_IFDIR, 0, &resfh);
 551                 break;
 552
 553         default:
 554                 status = nfserr_badtype;
 555         }
 556
 557         if (status)
 558                 goto out;
 559
 560         if (create->cr_acl != NULL)
 561                 do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
 562                                 create->cr_bmval);
 563
 564         fh_unlock(&cstate->current_fh);
 565         set_change_info(&create->cr_cinfo, &cstate->current_fh);
 566         fh_dup2(&cstate->current_fh, &resfh);
 567 out:
 568         fh_put(&resfh);
 569         return status;
 570 }
 571
 572 static __be32
 573 nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 574               struct nfsd4_getattr *getattr)
 575 {
 576         __be32 status;
 577
 578         status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
 579         if (status)
 580                 return status;
 581
 582         if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
 583                 return nfserr_inval;
 584
 585         getattr->ga_bmval[0] &= nfsd_suppattrs0(cstate->minorversion);
 586         getattr->ga_bmval[1] &= nfsd_suppattrs1(cstate->minorversion);
 587         getattr->ga_bmval[2] &= nfsd_suppattrs2(cstate->minorversion);
 588
 589         getattr->ga_fhp = &cstate->current_fh;
 590         return nfs_ok;
 591 }
 592
 593 static __be32
 594 nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 595            struct nfsd4_link *link)
 596 {
 597         __be32 status = nfserr_nofilehandle;
 598
 599         if (!cstate->save_fh.fh_dentry)
 600                 return status;
 601         status = nfsd_link(rqstp, &cstate->current_fh,
 602                            link->li_name, link->li_namelen, &cstate->save_fh);
 603         if (!status)
 604                 set_change_info(&link->li_cinfo, &cstate->current_fh);
 605         return status;
 606 }
 607
 608 static __be32
 609 nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 610               void *arg)
 611 {
 612         struct svc_fh tmp_fh;
 613         __be32 ret;
 614
 615         fh_init(&tmp_fh, NFS4_FHSIZE);
 616         ret = exp_pseudoroot(rqstp, &tmp_fh);
 617         if (ret)
 618                 return ret;
 619         if (tmp_fh.fh_dentry == cstate->current_fh.fh_dentry) {
 620                 fh_put(&tmp_fh);
 621                 return nfserr_noent;
 622         }
 623         fh_put(&tmp_fh);
 624         return nfsd_lookup(rqstp, &cstate->current_fh,
 625                            "..", 2, &cstate->current_fh);
 626 }
 627
 628 static __be32
 629 nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 630              struct nfsd4_lookup *lookup)
 631 {
 632         return nfsd_lookup(rqstp, &cstate->current_fh,
 633                            lookup->lo_name, lookup->lo_len,
 634                            &cstate->current_fh);
 635 }
 636
 637 static __be32
 638 nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 639            struct nfsd4_read *read)
 640 {
 641         __be32 status;
 642
 643         /* no need to check permission - this will be done in nfsd_read() */
 644
 645         read->rd_filp = NULL;
 646         if (read->rd_offset >= OFFSET_MAX)
 647                 return nfserr_inval;
 648
 649         nfs4_lock_state();
 650         /* check stateid */
 651         if ((status = nfs4_preprocess_stateid_op(cstate, &read->rd_stateid,
 652                                                  RD_STATE, &read->rd_filp))) {
 653                 dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
 654                 goto out;
 655         }
 656         if (read->rd_filp)
 657                 get_file(read->rd_filp);
 658         status = nfs_ok;
 659 out:
 660         nfs4_unlock_state();
 661         read->rd_rqstp = rqstp;
 662         read->rd_fhp = &cstate->current_fh;
 663         return status;
 664 }
 665
 666 static __be32
 667 nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 668               struct nfsd4_readdir *readdir)
 669 {
 670         u64 cookie = readdir->rd_cookie;
 671         static const nfs4_verifier zeroverf;
 672
 673         /* no need to check permission - this will be done in nfsd_readdir() */
 674
 675         if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
 676                 return nfserr_inval;
 677
 678         readdir->rd_bmval[0] &= nfsd_suppattrs0(cstate->minorversion);
 679         readdir->rd_bmval[1] &= nfsd_suppattrs1(cstate->minorversion);
 680         readdir->rd_bmval[2] &= nfsd_suppattrs2(cstate->minorversion);
 681
 682         if ((cookie > ~(u32)0) || (cookie == 1) || (cookie == 2) ||
 683             (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE)))
 684                 return nfserr_bad_cookie;
 685
 686         readdir->rd_rqstp = rqstp;
 687         readdir->rd_fhp = &cstate->current_fh;
 688         return nfs_ok;
 689 }
 690
 691 static __be32
 692 nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 693                struct nfsd4_readlink *readlink)
 694 {
 695         readlink->rl_rqstp = rqstp;
 696         readlink->rl_fhp = &cstate->current_fh;
 697         return nfs_ok;
 698 }
 699
 700 static __be32
 701 nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 702              struct nfsd4_remove *remove)
 703 {
 704         __be32 status;
 705
 706         if (locks_in_grace())
 707                 return nfserr_grace;
 708         status = nfsd_unlink(rqstp, &cstate->current_fh, 0,
 709                              remove->rm_name, remove->rm_namelen);
 710         if (status == nfserr_symlink)
 711                 return nfserr_notdir;
 712         if (!status) {
 713                 fh_unlock(&cstate->current_fh);
 714                 set_change_info(&remove->rm_cinfo, &cstate->current_fh);
 715         }
 716         return status;
 717 }
 718
 719 static __be32
 720 nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 721              struct nfsd4_rename *rename)
 722 {
 723         __be32 status = nfserr_nofilehandle;
 724
 725         if (!cstate->save_fh.fh_dentry)
 726                 return status;
 727         if (locks_in_grace() && !(cstate->save_fh.fh_export->ex_flags
 728                                         & NFSEXP_NOSUBTREECHECK))
 729                 return nfserr_grace;
 730         status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname,
 731                              rename->rn_snamelen, &cstate->current_fh,
 732                              rename->rn_tname, rename->rn_tnamelen);
 733
 734         /* the underlying filesystem returns different error's than required
 735          * by NFSv4. both save_fh and current_fh have been verified.. */
 736         if (status == nfserr_isdir)
 737                 status = nfserr_exist;
 738         else if ((status == nfserr_notdir) &&
 739                   (S_ISDIR(cstate->save_fh.fh_dentry->d_inode->i_mode) &&
 740                    S_ISDIR(cstate->current_fh.fh_dentry->d_inode->i_mode)))
 741                 status = nfserr_exist;
 742         else if (status == nfserr_symlink)
 743                 status = nfserr_notdir;
 744
 745         if (!status) {
 746                 set_change_info(&rename->rn_sinfo, &cstate->current_fh);
 747                 set_change_info(&rename->rn_tinfo, &cstate->save_fh);
 748         }
 749         return status;
 750 }
 751
 752 static __be32
 753 nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 754               struct nfsd4_secinfo *secinfo)
 755 {
 756         struct svc_fh resfh;
 757         struct svc_export *exp;
 758         struct dentry *dentry;
 759         __be32 err;
 760
 761         fh_init(&resfh, NFS4_FHSIZE);
 762         err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
 763                                     secinfo->si_name, secinfo->si_namelen,
 764                                     &exp, &dentry);
 765         if (err)
 766                 return err;
 767         if (dentry->d_inode == NULL) {
 768                 exp_put(exp);
 769                 err = nfserr_noent;
 770         } else
 771                 secinfo->si_exp = exp;
 772         dput(dentry);
 773         return err;
 774 }
 775
 776 static __be32
 777 nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 778               struct nfsd4_setattr *setattr)
 779 {
 780         __be32 status = nfs_ok;
 781
 782         if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
 783                 nfs4_lock_state();
 784                 status = nfs4_preprocess_stateid_op(cstate,
 785                         &setattr->sa_stateid, WR_STATE, NULL);
 786                 nfs4_unlock_state();
 787                 if (status) {
 788                         dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
 789                         return status;
 790                 }
 791         }
 792         status = mnt_want_write(cstate->current_fh.fh_export->ex_path.mnt);
 793         if (status)
 794                 return status;
 795         status = nfs_ok;
 796
 797         status = check_attr_support(rqstp, cstate, setattr->sa_bmval,
 798                                     nfsd_attrmask);
 799         if (status)
 800                 goto out;
 801
 802         if (setattr->sa_acl != NULL)
 803                 status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh,
 804                                             setattr->sa_acl);
 805         if (status)
 806                 goto out;
 807         status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
 808                                 0, (time_t)0);
 809 out:
 810         mnt_drop_write(cstate->current_fh.fh_export->ex_path.mnt);
 811         return status;
 812 }
 813
 814 static __be32
 815 nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 816             struct nfsd4_write *write)
 817 {
 818         stateid_t *stateid = &write->wr_stateid;
 819         struct file *filp = NULL;
 820         u32 *p;
 821         __be32 status = nfs_ok;
 822         unsigned long cnt;
 823
 824         /* no need to check permission - this will be done in nfsd_write() */
 825
 826         if (write->wr_offset >= OFFSET_MAX)
 827                 return nfserr_inval;
 828
 829         nfs4_lock_state();
 830         status = nfs4_preprocess_stateid_op(cstate, stateid, WR_STATE, &filp);
 831         if (filp)
 832                 get_file(filp);
 833         nfs4_unlock_state();
 834
 835         if (status) {
 836                 dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
 837                 return status;
 838         }
 839
 840         cnt = write->wr_buflen;
 841         write->wr_how_written = write->wr_stable_how;
 842         p = (u32 *)write->wr_verifier.data;
 843         *p++ = nfssvc_boot.tv_sec;
 844         *p++ = nfssvc_boot.tv_usec;
 845
 846         status =  nfsd_write(rqstp, &cstate->current_fh, filp,
 847                              write->wr_offset, rqstp->rq_vec, write->wr_vlen,
 848                              &cnt, &write->wr_how_written);
 849         if (filp)
 850                 fput(filp);
 851
 852         write->wr_bytes_written = cnt;
 853
 854         if (status == nfserr_symlink)
 855                 status = nfserr_inval;
 856         return status;
 857 }
 858
 859 /* This routine never returns NFS_OK!  If there are no other errors, it
 860  * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
 861  * attributes matched.  VERIFY is implemented by mapping NFSERR_SAME
 862  * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
 863  */
 864 static __be32
 865 _nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 866              struct nfsd4_verify *verify)
 867 {
 868         __be32 *buf, *p;
 869         int count;
 870         __be32 status;
 871
 872         status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
 873         if (status)
 874                 return status;
 875
 876         status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL);
 877         if (status)
 878                 return status;
 879
 880         if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)
 881             || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1))
 882                 return nfserr_inval;
 883         if (verify->ve_attrlen & 3)
 884                 return nfserr_inval;
 885
 886         /* count in words:
 887          *   bitmap_len(1) + bitmap(2) + attr_len(1) = 4
 888          */
 889         count = 4 + (verify->ve_attrlen >> 2);
 890         buf = kmalloc(count << 2, GFP_KERNEL);
 891         if (!buf)
 892                 return nfserr_resource;
 893
 894         status = nfsd4_encode_fattr(&cstate->current_fh,
 895                                     cstate->current_fh.fh_export,
 896                                     cstate->current_fh.fh_dentry, buf,
 897                                     &count, verify->ve_bmval,
 898                                     rqstp, 0);
 899
 900         /* this means that nfsd4_encode_fattr() ran out of space */
 901         if (status == nfserr_resource && count == 0)
 902                 status = nfserr_not_same;
 903         if (status)
 904                 goto out_kfree;
 905
 906         /* skip bitmap */
 907         p = buf + 1 + ntohl(buf[0]);
 908         status = nfserr_not_same;
 909         if (ntohl(*p++) != verify->ve_attrlen)
 910                 goto out_kfree;
 911         if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen))
 912                 status = nfserr_same;
 913
 914 out_kfree:
 915         kfree(buf);
 916         return status;
 917 }
 918
 919 static __be32
 920 nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 921               struct nfsd4_verify *verify)
 922 {
 923         __be32 status;
 924
 925         status = _nfsd4_verify(rqstp, cstate, verify);
 926         return status == nfserr_not_same ? nfs_ok : status;
 927 }
 928
 929 static __be32
 930 nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 931              struct nfsd4_verify *verify)
 932 {
 933         __be32 status;
 934
 935         status = _nfsd4_verify(rqstp, cstate, verify);
 936         return status == nfserr_same ? nfs_ok : status;
 937 }
 938
 939 /*
 940  * NULL call.
 941  */
 942 static __be32
 943 nfsd4_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
 944 {
 945         return nfs_ok;
 946 }
 947
 948 static inline void nfsd4_increment_op_stats(u32 opnum)
 949 {
 950         if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP)
 951                 nfsdstats.nfs4_opcount[opnum]++;
 952 }
 953
 954 typedef __be32(*nfsd4op_func)(struct svc_rqst *, struct nfsd4_compound_state *,
 955                               void *);
 956 enum nfsd4_op_flags {
 957         ALLOWED_WITHOUT_FH = 1 << 0,    /* No current filehandle required */
 958         ALLOWED_ON_ABSENT_FS = 2 << 0,  /* ops processed on absent fs */
 959         ALLOWED_AS_FIRST_OP = 3 << 0,   /* ops reqired first in compound */
 960 };
 961
 962 struct nfsd4_operation {
 963         nfsd4op_func op_func;
 964         u32 op_flags;
 965         char *op_name;
 966 };
 967
 968 static struct nfsd4_operation nfsd4_ops[];
 969
 970 static const char *nfsd4_op_name(unsigned opnum);
 971
 972 /*
 973  * Enforce NFSv4.1 COMPOUND ordering rules.
 974  *
 975  * TODO:
 976  * - enforce NFS4ERR_NOT_ONLY_OP,
 977  * - DESTROY_SESSION MUST be the final operation in the COMPOUND request.
 978  */
 979 static bool nfs41_op_ordering_ok(struct nfsd4_compoundargs *args)
 980 {
 981         if (args->minorversion && args->opcnt > 0) {
 982                 struct nfsd4_op *op = &args->ops[0];
 983                 return (op->status == nfserr_op_illegal) ||
 984                        (nfsd4_ops[op->opnum].op_flags & ALLOWED_AS_FIRST_OP);
 985         }
 986         return true;
 987 }
 988
 989 /*
 990  * COMPOUND call.
 991  */
 992 static __be32
 993 nfsd4_proc_compound(struct svc_rqst *rqstp,
 994                     struct nfsd4_compoundargs *args,
 995                     struct nfsd4_compoundres *resp)
 996 {
 997         struct nfsd4_op *op;
 998         struct nfsd4_operation *opdesc;
 999         struct nfsd4_compound_state *cstate = &resp->cstate;
1000         int             slack_bytes;
1001         __be32          status;
1002
1003         resp->xbuf = &rqstp->rq_res;
1004         resp->p = rqstp->rq_res.head[0].iov_base +
1005                                                 rqstp->rq_res.head[0].iov_len;
1006         resp->tagp = resp->p;
1007         /* reserve space for: taglen, tag, and opcnt */
1008         resp->p += 2 + XDR_QUADLEN(args->taglen);
1009         resp->end = rqstp->rq_res.head[0].iov_base + PAGE_SIZE;
1010         resp->taglen = args->taglen;
1011         resp->tag = args->tag;
1012         resp->opcnt = 0;
1013         resp->rqstp = rqstp;
1014         resp->cstate.minorversion = args->minorversion;
1015         resp->cstate.replay_owner = NULL;
1016         fh_init(&resp->cstate.current_fh, NFS4_FHSIZE);
1017         fh_init(&resp->cstate.save_fh, NFS4_FHSIZE);
1018         /* Use the deferral mechanism only for NFSv4.0 compounds */
1019         rqstp->rq_usedeferral = (args->minorversion == 0);
1020
1021         /*
1022          * According to RFC3010, this takes precedence over all other errors.
1023          */
1024         status = nfserr_minor_vers_mismatch;
1025         if (args->minorversion > nfsd_supported_minorversion)
1026                 goto out;
1027
1028         if (!nfs41_op_ordering_ok(args)) {
1029                 op = &args->ops[0];
1030                 op->status = nfserr_sequence_pos;
1031                 goto encode_op;
1032         }
1033
1034         status = nfs_ok;
1035         while (!status && resp->opcnt < args->opcnt) {
1036                 op = &args->ops[resp->opcnt++];
1037
1038                 dprintk("nfsv4 compound op #%d/%d: %d (%s)\n",
1039                         resp->opcnt, args->opcnt, op->opnum,
1040                         nfsd4_op_name(op->opnum));
1041                 /*
1042                  * The XDR decode routines may have pre-set op->status;
1043                  * for example, if there is a miscellaneous XDR error
1044                  * it will be set to nfserr_bad_xdr.
1045                  */
1046                 if (op->status)
1047                         goto encode_op;
1048
1049                 /* We must be able to encode a successful response to
1050                  * this operation, with enough room left over to encode a
1051                  * failed response to the next operation.  If we don't
1052                  * have enough room, fail with ERR_RESOURCE.
1053                  */
1054                 slack_bytes = (char *)resp->end - (char *)resp->p;
1055                 if (slack_bytes < COMPOUND_SLACK_SPACE
1056                                 + COMPOUND_ERR_SLACK_SPACE) {
1057                         BUG_ON(slack_bytes < COMPOUND_ERR_SLACK_SPACE);
1058                         op->status = nfserr_resource;
1059                         goto encode_op;
1060                 }
1061
1062                 opdesc = &nfsd4_ops[op->opnum];
1063
1064                 if (!cstate->current_fh.fh_dentry) {
1065                         if (!(opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
1066                                 op->status = nfserr_nofilehandle;
1067                                 goto encode_op;
1068                         }
1069                 } else if (cstate->current_fh.fh_export->ex_fslocs.migrated &&
1070                           !(opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {
1071                         op->status = nfserr_moved;
1072                         goto encode_op;
1073                 }
1074
1075                 if (opdesc->op_func)
1076                         op->status = opdesc->op_func(rqstp, cstate, &op->u);
1077                 else
1078                         BUG_ON(op->status == nfs_ok);
1079
1080 encode_op:
1081                 /* Only from SEQUENCE */
1082                 if (resp->cstate.status == nfserr_replay_cache) {
1083                         dprintk("%s NFS4.1 replay from cache\n", __func__);
1084                         status = op->status;
1085                         goto out;
1086                 }
1087                 if (op->status == nfserr_replay_me) {
1088                         op->replay = &cstate->replay_owner->so_replay;
1089                         nfsd4_encode_replay(resp, op);
1090                         status = op->status = op->replay->rp_status;
1091                 } else {
1092                         nfsd4_encode_operation(resp, op);
1093                         status = op->status;
1094                 }
1095
1096                 dprintk("nfsv4 compound op %p opcnt %d #%d: %d: status %d\n",
1097                         args->ops, args->opcnt, resp->opcnt, op->opnum,
1098                         be32_to_cpu(status));
1099
1100                 if (cstate->replay_owner) {
1101                         nfs4_put_stateowner(cstate->replay_owner);
1102                         cstate->replay_owner = NULL;
1103                 }
1104                 /* XXX Ugh, we need to get rid of this kind of special case: */
1105                 if (op->opnum == OP_READ && op->u.read.rd_filp)
1106                         fput(op->u.read.rd_filp);
1107
1108                 nfsd4_increment_op_stats(op->opnum);
1109         }
1110         if (!rqstp->rq_usedeferral && status == nfserr_dropit) {
1111                 dprintk("%s Dropit - send NFS4ERR_DELAY\n", __func__);
1112                 status = nfserr_jukebox;
1113         }
1114
1115         resp->cstate.status = status;
1116         fh_put(&resp->cstate.current_fh);
1117         fh_put(&resp->cstate.save_fh);
1118         BUG_ON(resp->cstate.replay_owner);
1119 out:
1120         nfsd4_release_compoundargs(args);
1121         /* Reset deferral mechanism for RPC deferrals */
1122         rqstp->rq_usedeferral = 1;
1123         dprintk("nfsv4 compound returned %d\n", ntohl(status));
1124         return status;
1125 }
1126
1127 static struct nfsd4_operation nfsd4_ops[] = {
1128         [OP_ACCESS] = {
1129                 .op_func = (nfsd4op_func)nfsd4_access,
1130                 .op_name = "OP_ACCESS",
1131         },
1132         [OP_CLOSE] = {
1133                 .op_func = (nfsd4op_func)nfsd4_close,
1134                 .op_name = "OP_CLOSE",
1135         },
1136         [OP_COMMIT] = {
1137                 .op_func = (nfsd4op_func)nfsd4_commit,
1138                 .op_name = "OP_COMMIT",
1139         },
1140         [OP_CREATE] = {
1141                 .op_func = (nfsd4op_func)nfsd4_create,
1142                 .op_name = "OP_CREATE",
1143         },
1144         [OP_DELEGRETURN] = {
1145                 .op_func = (nfsd4op_func)nfsd4_delegreturn,
1146                 .op_name = "OP_DELEGRETURN",
1147         },
1148         [OP_GETATTR] = {
1149                 .op_func = (nfsd4op_func)nfsd4_getattr,
1150                 .op_flags = ALLOWED_ON_ABSENT_FS,
1151                 .op_name = "OP_GETATTR",
1152         },
1153         [OP_GETFH] = {
1154                 .op_func = (nfsd4op_func)nfsd4_getfh,
1155                 .op_name = "OP_GETFH",
1156         },
1157         [OP_LINK] = {
1158                 .op_func = (nfsd4op_func)nfsd4_link,
1159                 .op_name = "OP_LINK",
1160         },
1161         [OP_LOCK] = {
1162                 .op_func = (nfsd4op_func)nfsd4_lock,
1163                 .op_name = "OP_LOCK",
1164         },
1165         [OP_LOCKT] = {
1166                 .op_func = (nfsd4op_func)nfsd4_lockt,
1167                 .op_name = "OP_LOCKT",
1168         },
1169         [OP_LOCKU] = {
1170                 .op_func = (nfsd4op_func)nfsd4_locku,
1171                 .op_name = "OP_LOCKU",
1172         },
1173         [OP_LOOKUP] = {
1174                 .op_func = (nfsd4op_func)nfsd4_lookup,
1175                 .op_name = "OP_LOOKUP",
1176         },
1177         [OP_LOOKUPP] = {
1178                 .op_func = (nfsd4op_func)nfsd4_lookupp,
1179                 .op_name = "OP_LOOKUPP",
1180         },
1181         [OP_NVERIFY] = {
1182                 .op_func = (nfsd4op_func)nfsd4_nverify,
1183                 .op_name = "OP_NVERIFY",
1184         },
1185         [OP_OPEN] = {
1186                 .op_func = (nfsd4op_func)nfsd4_open,
1187                 .op_name = "OP_OPEN",
1188         },
1189         [OP_OPEN_CONFIRM] = {
1190                 .op_func = (nfsd4op_func)nfsd4_open_confirm,
1191                 .op_name = "OP_OPEN_CONFIRM",
1192         },
1193         [OP_OPEN_DOWNGRADE] = {
1194                 .op_func = (nfsd4op_func)nfsd4_open_downgrade,
1195                 .op_name = "OP_OPEN_DOWNGRADE",
1196         },
1197         [OP_PUTFH] = {
1198                 .op_func = (nfsd4op_func)nfsd4_putfh,
1199                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
1200                 .op_name = "OP_PUTFH",
1201         },
1202         [OP_PUTPUBFH] = {
1203                 .op_func = (nfsd4op_func)nfsd4_putrootfh,
1204                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
1205                 .op_name = "OP_PUTPUBFH",
1206         },
1207         [OP_PUTROOTFH] = {
1208                 .op_func = (nfsd4op_func)nfsd4_putrootfh,
1209                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
1210                 .op_name = "OP_PUTROOTFH",
1211         },
1212         [OP_READ] = {
1213                 .op_func = (nfsd4op_func)nfsd4_read,
1214                 .op_name = "OP_READ",
1215         },
1216         [OP_READDIR] = {
1217                 .op_func = (nfsd4op_func)nfsd4_readdir,
1218                 .op_name = "OP_READDIR",
1219         },
1220         [OP_READLINK] = {
1221                 .op_func = (nfsd4op_func)nfsd4_readlink,
1222                 .op_name = "OP_READLINK",
1223         },
1224         [OP_REMOVE] = {
1225                 .op_func = (nfsd4op_func)nfsd4_remove,
1226                 .op_name = "OP_REMOVE",
1227         },
1228         [OP_RENAME] = {
1229                 .op_name = "OP_RENAME",
1230                 .op_func = (nfsd4op_func)nfsd4_rename,
1231         },
1232         [OP_RENEW] = {
1233                 .op_func = (nfsd4op_func)nfsd4_renew,
1234                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
1235                 .op_name = "OP_RENEW",
1236         },
1237         [OP_RESTOREFH] = {
1238                 .op_func = (nfsd4op_func)nfsd4_restorefh,
1239                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
1240                 .op_name = "OP_RESTOREFH",
1241         },
1242         [OP_SAVEFH] = {
1243                 .op_func = (nfsd4op_func)nfsd4_savefh,
1244                 .op_name = "OP_SAVEFH",
1245         },
1246         [OP_SECINFO] = {
1247                 .op_func = (nfsd4op_func)nfsd4_secinfo,
1248                 .op_name = "OP_SECINFO",
1249         },
1250         [OP_SETATTR] = {
1251                 .op_func = (nfsd4op_func)nfsd4_setattr,
1252                 .op_name = "OP_SETATTR",
1253         },
1254         [OP_SETCLIENTID] = {
1255                 .op_func = (nfsd4op_func)nfsd4_setclientid,
1256                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
1257                 .op_name = "OP_SETCLIENTID",
1258         },
1259         [OP_SETCLIENTID_CONFIRM] = {
1260                 .op_func = (nfsd4op_func)nfsd4_setclientid_confirm,
1261                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
1262                 .op_name = "OP_SETCLIENTID_CONFIRM",
1263         },
1264         [OP_VERIFY] = {
1265                 .op_func = (nfsd4op_func)nfsd4_verify,
1266                 .op_name = "OP_VERIFY",
1267         },
1268         [OP_WRITE] = {
1269                 .op_func = (nfsd4op_func)nfsd4_write,
1270                 .op_name = "OP_WRITE",
1271         },
1272         [OP_RELEASE_LOCKOWNER] = {
1273                 .op_func = (nfsd4op_func)nfsd4_release_lockowner,
1274                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
1275                 .op_name = "OP_RELEASE_LOCKOWNER",
1276         },
1277
1278         /* NFSv4.1 operations */
1279         [OP_EXCHANGE_ID] = {
1280                 .op_func = (nfsd4op_func)nfsd4_exchange_id,
1281                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
1282                 .op_name = "OP_EXCHANGE_ID",
1283         },
1284         [OP_CREATE_SESSION] = {
1285                 .op_func = (nfsd4op_func)nfsd4_create_session,
1286                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
1287                 .op_name = "OP_CREATE_SESSION",
1288         },
1289         [OP_DESTROY_SESSION] = {
1290                 .op_func = (nfsd4op_func)nfsd4_destroy_session,
1291                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
1292                 .op_name = "OP_DESTROY_SESSION",
1293         },
1294         [OP_SEQUENCE] = {
1295                 .op_func = (nfsd4op_func)nfsd4_sequence,
1296                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
1297                 .op_name = "OP_SEQUENCE",
1298         },
1299 };
1300
1301 static const char *nfsd4_op_name(unsigned opnum)
1302 {
1303         if (opnum < ARRAY_SIZE(nfsd4_ops))
1304                 return nfsd4_ops[opnum].op_name;
1305         return "unknown_operation";
1306 }
1307
1308 #define nfsd4_voidres                   nfsd4_voidargs
1309 struct nfsd4_voidargs { int dummy; };
1310
1311 /*
1312  * TODO: At the present time, the NFSv4 server does not do XID caching
1313  * of requests.  Implementing XID caching would not be a serious problem,
1314  * although it would require a mild change in interfaces since one
1315  * doesn't know whether an NFSv4 request is idempotent until after the
1316  * XDR decode.  However, XID caching totally confuses pynfs (Peter
1317  * Astrand's regression testsuite for NFSv4 servers), which reuses
1318  * XID's liberally, so I've left it unimplemented until pynfs generates
1319  * better XID's.
1320  */
1321 static struct svc_procedure             nfsd_procedures4[2] = {
1322         [NFSPROC4_NULL] = {
1323                 .pc_func = (svc_procfunc) nfsd4_proc_null,
1324                 .pc_encode = (kxdrproc_t) nfs4svc_encode_voidres,
1325                 .pc_argsize = sizeof(struct nfsd4_voidargs),
1326                 .pc_ressize = sizeof(struct nfsd4_voidres),
1327                 .pc_cachetype = RC_NOCACHE,
1328                 .pc_xdrressize = 1,
1329         },
1330         [NFSPROC4_COMPOUND] = {
1331                 .pc_func = (svc_procfunc) nfsd4_proc_compound,
1332                 .pc_decode = (kxdrproc_t) nfs4svc_decode_compoundargs,
1333                 .pc_encode = (kxdrproc_t) nfs4svc_encode_compoundres,
1334                 .pc_argsize = sizeof(struct nfsd4_compoundargs),
1335                 .pc_ressize = sizeof(struct nfsd4_compoundres),
1336                 .pc_cachetype = RC_NOCACHE,
1337                 .pc_xdrressize = NFSD_BUFSIZE/4,
1338         },
1339 };
1340
1341 struct svc_version      nfsd_version4 = {
1342                 .vs_vers        = 4,
1343                 .vs_nproc       = 2,
1344                 .vs_proc        = nfsd_procedures4,
1345                 .vs_dispatch    = nfsd_dispatch,
1346                 .vs_xdrsize     = NFS4_SVC_XDRSIZE,
1347 };
1348
1349 /*
1350  * Local variables:
1351  *  c-basic-offset: 8
1352  * End:
1353  */