fs/nfsd/nfs4xdr.c

   1 /*
   2  *  Server-side XDR 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  * TODO: Neil Brown made the following observation:  We currently
  36  * initially reserve NFSD_BUFSIZE space on the transmit queue and
  37  * never release any of that until the request is complete.
  38  * It would be good to calculate a new maximum response size while
  39  * decoding the COMPOUND, and call svc_reserve with this number
  40  * at the end of nfs4svc_decode_compoundargs.
  41  */
  42
  43 #include <linux/slab.h>
  44 #include <linux/namei.h>
  45 #include <linux/statfs.h>
  46 #include <linux/utsname.h>
  47 #include <linux/pagemap.h>
  48 #include <linux/sunrpc/svcauth_gss.h>
  49
  50 #include "idmap.h"
  51 #include "acl.h"
  52 #include "xdr4.h"
  53 #include "vfs.h"
  54 #include "state.h"
  55 #include "cache.h"
  56
  57 #define NFSDDBG_FACILITY                NFSDDBG_XDR
  58
  59 /*
  60  * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
  61  * directory in order to indicate to the client that a filesystem boundary is present
  62  * We use a fixed fsid for a referral
  63  */
  64 #define NFS4_REFERRAL_FSID_MAJOR        0x8000000ULL
  65 #define NFS4_REFERRAL_FSID_MINOR        0x8000000ULL
  66
  67 static __be32
  68 check_filename(char *str, int len, __be32 err)
  69 {
  70         int i;
  71
  72         if (len == 0)
  73                 return nfserr_inval;
  74         if (isdotent(str, len))
  75                 return err;
  76         for (i = 0; i < len; i++)
  77                 if (str[i] == '/')
  78                         return err;
  79         return 0;
  80 }
  81
  82 #define DECODE_HEAD                             \
  83         __be32 *p;                              \
  84         __be32 status
  85 #define DECODE_TAIL                             \
  86         status = 0;                             \
  87 out:                                            \
  88         return status;                          \
  89 xdr_error:                                      \
  90         dprintk("NFSD: xdr error (%s:%d)\n",    \
  91                         __FILE__, __LINE__);    \
  92         status = nfserr_bad_xdr;                \
  93         goto out
  94
  95 #define READ32(x)         (x) = ntohl(*p++)
  96 #define READ64(x)         do {                  \
  97         (x) = (u64)ntohl(*p++) << 32;           \
  98         (x) |= ntohl(*p++);                     \
  99 } while (0)
 100 #define READTIME(x)       do {                  \
 101         p++;                                    \
 102         (x) = ntohl(*p++);                      \
 103         p++;                                    \
 104 } while (0)
 105 #define READMEM(x,nbytes) do {                  \
 106         x = (char *)p;                          \
 107         p += XDR_QUADLEN(nbytes);               \
 108 } while (0)
 109 #define SAVEMEM(x,nbytes) do {                  \
 110         if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
 111                 savemem(argp, p, nbytes) :      \
 112                 (char *)p)) {                   \
 113                 dprintk("NFSD: xdr error (%s:%d)\n", \
 114                                 __FILE__, __LINE__); \
 115                 goto xdr_error;                 \
 116                 }                               \
 117         p += XDR_QUADLEN(nbytes);               \
 118 } while (0)
 119 #define COPYMEM(x,nbytes) do {                  \
 120         memcpy((x), p, nbytes);                 \
 121         p += XDR_QUADLEN(nbytes);               \
 122 } while (0)
 123
 124 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */
 125 #define READ_BUF(nbytes)  do {                  \
 126         if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) {     \
 127                 p = argp->p;                    \
 128                 argp->p += XDR_QUADLEN(nbytes); \
 129         } else if (!(p = read_buf(argp, nbytes))) { \
 130                 dprintk("NFSD: xdr error (%s:%d)\n", \
 131                                 __FILE__, __LINE__); \
 132                 goto xdr_error;                 \
 133         }                                       \
 134 } while (0)
 135
 136 static void save_buf(struct nfsd4_compoundargs *argp, struct nfsd4_saved_compoundargs *savep)
 137 {
 138         savep->p        = argp->p;
 139         savep->end      = argp->end;
 140         savep->pagelen  = argp->pagelen;
 141         savep->pagelist = argp->pagelist;
 142 }
 143
 144 static void restore_buf(struct nfsd4_compoundargs *argp, struct nfsd4_saved_compoundargs *savep)
 145 {
 146         argp->p        = savep->p;
 147         argp->end      = savep->end;
 148         argp->pagelen  = savep->pagelen;
 149         argp->pagelist = savep->pagelist;
 150 }
 151
 152 static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes)
 153 {
 154         /* We want more bytes than seem to be available.
 155          * Maybe we need a new page, maybe we have just run out
 156          */
 157         unsigned int avail = (char *)argp->end - (char *)argp->p;
 158         __be32 *p;
 159         if (avail + argp->pagelen < nbytes)
 160                 return NULL;
 161         if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */
 162                 return NULL;
 163         /* ok, we can do it with the current plus the next page */
 164         if (nbytes <= sizeof(argp->tmp))
 165                 p = argp->tmp;
 166         else {
 167                 kfree(argp->tmpp);
 168                 p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL);
 169                 if (!p)
 170                         return NULL;
 171
 172         }
 173         /*
 174          * The following memcpy is safe because read_buf is always
 175          * called with nbytes > avail, and the two cases above both
 176          * guarantee p points to at least nbytes bytes.
 177          */
 178         memcpy(p, argp->p, avail);
 179         /* step to next page */
 180         argp->p = page_address(argp->pagelist[0]);
 181         argp->pagelist++;
 182         if (argp->pagelen < PAGE_SIZE) {
 183                 argp->end = argp->p + (argp->pagelen>>2);
 184                 argp->pagelen = 0;
 185         } else {
 186                 argp->end = argp->p + (PAGE_SIZE>>2);
 187                 argp->pagelen -= PAGE_SIZE;
 188         }
 189         memcpy(((char*)p)+avail, argp->p, (nbytes - avail));
 190         argp->p += XDR_QUADLEN(nbytes - avail);
 191         return p;
 192 }
 193
 194 static int zero_clientid(clientid_t *clid)
 195 {
 196         return (clid->cl_boot == 0) && (clid->cl_id == 0);
 197 }
 198
 199 static int
 200 defer_free(struct nfsd4_compoundargs *argp,
 201                 void (*release)(const void *), void *p)
 202 {
 203         struct tmpbuf *tb;
 204
 205         tb = kmalloc(sizeof(*tb), GFP_KERNEL);
 206         if (!tb)
 207                 return -ENOMEM;
 208         tb->buf = p;
 209         tb->release = release;
 210         tb->next = argp->to_free;
 211         argp->to_free = tb;
 212         return 0;
 213 }
 214
 215 static char *savemem(struct nfsd4_compoundargs *argp, __be32 *p, int nbytes)
 216 {
 217         if (p == argp->tmp) {
 218                 p = kmalloc(nbytes, GFP_KERNEL);
 219                 if (!p)
 220                         return NULL;
 221                 memcpy(p, argp->tmp, nbytes);
 222         } else {
 223                 BUG_ON(p != argp->tmpp);
 224                 argp->tmpp = NULL;
 225         }
 226         if (defer_free(argp, kfree, p)) {
 227                 kfree(p);
 228                 return NULL;
 229         } else
 230                 return (char *)p;
 231 }
 232
 233 static __be32
 234 nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)
 235 {
 236         u32 bmlen;
 237         DECODE_HEAD;
 238
 239         bmval[0] = 0;
 240         bmval[1] = 0;
 241         bmval[2] = 0;
 242
 243         READ_BUF(4);
 244         READ32(bmlen);
 245         if (bmlen > 1000)
 246                 goto xdr_error;
 247
 248         READ_BUF(bmlen << 2);
 249         if (bmlen > 0)
 250                 READ32(bmval[0]);
 251         if (bmlen > 1)
 252                 READ32(bmval[1]);
 253         if (bmlen > 2)
 254                 READ32(bmval[2]);
 255
 256         DECODE_TAIL;
 257 }
 258
 259 static __be32
 260 nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
 261                    struct iattr *iattr, struct nfs4_acl **acl)
 262 {
 263         int expected_len, len = 0;
 264         u32 dummy32;
 265         char *buf;
 266         int host_err;
 267
 268         DECODE_HEAD;
 269         iattr->ia_valid = 0;
 270         if ((status = nfsd4_decode_bitmap(argp, bmval)))
 271                 return status;
 272
 273         READ_BUF(4);
 274         READ32(expected_len);
 275
 276         if (bmval[0] & FATTR4_WORD0_SIZE) {
 277                 READ_BUF(8);
 278                 len += 8;
 279                 READ64(iattr->ia_size);
 280                 iattr->ia_valid |= ATTR_SIZE;
 281         }
 282         if (bmval[0] & FATTR4_WORD0_ACL) {
 283                 int nace;
 284                 struct nfs4_ace *ace;
 285
 286                 READ_BUF(4); len += 4;
 287                 READ32(nace);
 288
 289                 if (nace > NFS4_ACL_MAX)
 290                         return nfserr_resource;
 291
 292                 *acl = nfs4_acl_new(nace);
 293                 if (*acl == NULL) {
 294                         host_err = -ENOMEM;
 295                         goto out_nfserr;
 296                 }
 297                 defer_free(argp, kfree, *acl);
 298
 299                 (*acl)->naces = nace;
 300                 for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) {
 301                         READ_BUF(16); len += 16;
 302                         READ32(ace->type);
 303                         READ32(ace->flag);
 304                         READ32(ace->access_mask);
 305                         READ32(dummy32);
 306                         READ_BUF(dummy32);
 307                         len += XDR_QUADLEN(dummy32) << 2;
 308                         READMEM(buf, dummy32);
 309                         ace->whotype = nfs4_acl_get_whotype(buf, dummy32);
 310                         status = nfs_ok;
 311                         if (ace->whotype != NFS4_ACL_WHO_NAMED)
 312                                 ace->who = 0;
 313                         else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
 314                                 status = nfsd_map_name_to_gid(argp->rqstp,
 315                                                 buf, dummy32, &ace->who);
 316                         else
 317                                 status = nfsd_map_name_to_uid(argp->rqstp,
 318                                                 buf, dummy32, &ace->who);
 319                         if (status)
 320                                 return status;
 321                 }
 322         } else
 323                 *acl = NULL;
 324         if (bmval[1] & FATTR4_WORD1_MODE) {
 325                 READ_BUF(4);
 326                 len += 4;
 327                 READ32(iattr->ia_mode);
 328                 iattr->ia_mode &= (S_IFMT | S_IALLUGO);
 329                 iattr->ia_valid |= ATTR_MODE;
 330         }
 331         if (bmval[1] & FATTR4_WORD1_OWNER) {
 332                 READ_BUF(4);
 333                 len += 4;
 334                 READ32(dummy32);
 335                 READ_BUF(dummy32);
 336                 len += (XDR_QUADLEN(dummy32) << 2);
 337                 READMEM(buf, dummy32);
 338                 if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid)))
 339                         return status;
 340                 iattr->ia_valid |= ATTR_UID;
 341         }
 342         if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) {
 343                 READ_BUF(4);
 344                 len += 4;
 345                 READ32(dummy32);
 346                 READ_BUF(dummy32);
 347                 len += (XDR_QUADLEN(dummy32) << 2);
 348                 READMEM(buf, dummy32);
 349                 if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid)))
 350                         return status;
 351                 iattr->ia_valid |= ATTR_GID;
 352         }
 353         if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
 354                 READ_BUF(4);
 355                 len += 4;
 356                 READ32(dummy32);
 357                 switch (dummy32) {
 358                 case NFS4_SET_TO_CLIENT_TIME:
 359                         /* We require the high 32 bits of 'seconds' to be 0, and we ignore
 360                            all 32 bits of 'nseconds'. */
 361                         READ_BUF(12);
 362                         len += 12;
 363                         READ32(dummy32);
 364                         if (dummy32)
 365                                 return nfserr_inval;
 366                         READ32(iattr->ia_atime.tv_sec);
 367                         READ32(iattr->ia_atime.tv_nsec);
 368                         if (iattr->ia_atime.tv_nsec >= (u32)1000000000)
 369                                 return nfserr_inval;
 370                         iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET);
 371                         break;
 372                 case NFS4_SET_TO_SERVER_TIME:
 373                         iattr->ia_valid |= ATTR_ATIME;
 374                         break;
 375                 default:
 376                         goto xdr_error;
 377                 }
 378         }
 379         if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
 380                 READ_BUF(4);
 381                 len += 4;
 382                 READ32(dummy32);
 383                 switch (dummy32) {
 384                 case NFS4_SET_TO_CLIENT_TIME:
 385                         /* We require the high 32 bits of 'seconds' to be 0, and we ignore
 386                            all 32 bits of 'nseconds'. */
 387                         READ_BUF(12);
 388                         len += 12;
 389                         READ32(dummy32);
 390                         if (dummy32)
 391                                 return nfserr_inval;
 392                         READ32(iattr->ia_mtime.tv_sec);
 393                         READ32(iattr->ia_mtime.tv_nsec);
 394                         if (iattr->ia_mtime.tv_nsec >= (u32)1000000000)
 395                                 return nfserr_inval;
 396                         iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET);
 397                         break;
 398                 case NFS4_SET_TO_SERVER_TIME:
 399                         iattr->ia_valid |= ATTR_MTIME;
 400                         break;
 401                 default:
 402                         goto xdr_error;
 403                 }
 404         }
 405         if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
 406             || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
 407             || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2)
 408                 READ_BUF(expected_len - len);
 409         else if (len != expected_len)
 410                 goto xdr_error;
 411
 412         DECODE_TAIL;
 413
 414 out_nfserr:
 415         status = nfserrno(host_err);
 416         goto out;
 417 }
 418
 419 static __be32
 420 nfsd4_decode_stateid(struct nfsd4_compoundargs *argp, stateid_t *sid)
 421 {
 422         DECODE_HEAD;
 423
 424         READ_BUF(sizeof(stateid_t));
 425         READ32(sid->si_generation);
 426         COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t));
 427
 428         DECODE_TAIL;
 429 }
 430
 431 static __be32
 432 nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access)
 433 {
 434         DECODE_HEAD;
 435
 436         READ_BUF(4);
 437         READ32(access->ac_req_access);
 438
 439         DECODE_TAIL;
 440 }
 441
 442 static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, struct nfsd4_bind_conn_to_session *bcts)
 443 {
 444         DECODE_HEAD;
 445
 446         READ_BUF(NFS4_MAX_SESSIONID_LEN + 8);
 447         COPYMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);
 448         READ32(bcts->dir);
 449         /* XXX: skipping ctsa_use_conn_in_rdma_mode.  Perhaps Tom Tucker
 450          * could help us figure out we should be using it. */
 451         DECODE_TAIL;
 452 }
 453
 454 static __be32
 455 nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close)
 456 {
 457         DECODE_HEAD;
 458
 459         READ_BUF(4);
 460         READ32(close->cl_seqid);
 461         return nfsd4_decode_stateid(argp, &close->cl_stateid);
 462
 463         DECODE_TAIL;
 464 }
 465
 466
 467 static __be32
 468 nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit)
 469 {
 470         DECODE_HEAD;
 471
 472         READ_BUF(12);
 473         READ64(commit->co_offset);
 474         READ32(commit->co_count);
 475
 476         DECODE_TAIL;
 477 }
 478
 479 static __be32
 480 nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create)
 481 {
 482         DECODE_HEAD;
 483
 484         READ_BUF(4);
 485         READ32(create->cr_type);
 486         switch (create->cr_type) {
 487         case NF4LNK:
 488                 READ_BUF(4);
 489                 READ32(create->cr_linklen);
 490                 READ_BUF(create->cr_linklen);
 491                 SAVEMEM(create->cr_linkname, create->cr_linklen);
 492                 break;
 493         case NF4BLK:
 494         case NF4CHR:
 495                 READ_BUF(8);
 496                 READ32(create->cr_specdata1);
 497                 READ32(create->cr_specdata2);
 498                 break;
 499         case NF4SOCK:
 500         case NF4FIFO:
 501         case NF4DIR:
 502         default:
 503                 break;
 504         }
 505
 506         READ_BUF(4);
 507         READ32(create->cr_namelen);
 508         READ_BUF(create->cr_namelen);
 509         SAVEMEM(create->cr_name, create->cr_namelen);
 510         if ((status = check_filename(create->cr_name, create->cr_namelen, nfserr_inval)))
 511                 return status;
 512
 513         status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr,
 514                                     &create->cr_acl);
 515         if (status)
 516                 goto out;
 517
 518         DECODE_TAIL;
 519 }
 520
 521 static inline __be32
 522 nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr)
 523 {
 524         return nfsd4_decode_stateid(argp, &dr->dr_stateid);
 525 }
 526
 527 static inline __be32
 528 nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr)
 529 {
 530         return nfsd4_decode_bitmap(argp, getattr->ga_bmval);
 531 }
 532
 533 static __be32
 534 nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link)
 535 {
 536         DECODE_HEAD;
 537
 538         READ_BUF(4);
 539         READ32(link->li_namelen);
 540         READ_BUF(link->li_namelen);
 541         SAVEMEM(link->li_name, link->li_namelen);
 542         if ((status = check_filename(link->li_name, link->li_namelen, nfserr_inval)))
 543                 return status;
 544
 545         DECODE_TAIL;
 546 }
 547
 548 static __be32
 549 nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock)
 550 {
 551         DECODE_HEAD;
 552
 553         /*
 554         * type, reclaim(boolean), offset, length, new_lock_owner(boolean)
 555         */
 556         READ_BUF(28);
 557         READ32(lock->lk_type);
 558         if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))
 559                 goto xdr_error;
 560         READ32(lock->lk_reclaim);
 561         READ64(lock->lk_offset);
 562         READ64(lock->lk_length);
 563         READ32(lock->lk_is_new);
 564
 565         if (lock->lk_is_new) {
 566                 READ_BUF(4);
 567                 READ32(lock->lk_new_open_seqid);
 568                 status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid);
 569                 if (status)
 570                         return status;
 571                 READ_BUF(8 + sizeof(clientid_t));
 572                 READ32(lock->lk_new_lock_seqid);
 573                 COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t));
 574                 READ32(lock->lk_new_owner.len);
 575                 READ_BUF(lock->lk_new_owner.len);
 576                 READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len);
 577         } else {
 578                 status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid);
 579                 if (status)
 580                         return status;
 581                 READ_BUF(4);
 582                 READ32(lock->lk_old_lock_seqid);
 583         }
 584
 585         DECODE_TAIL;
 586 }
 587
 588 static __be32
 589 nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt)
 590 {
 591         DECODE_HEAD;
 592
 593         READ_BUF(32);
 594         READ32(lockt->lt_type);
 595         if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))
 596                 goto xdr_error;
 597         READ64(lockt->lt_offset);
 598         READ64(lockt->lt_length);
 599         COPYMEM(&lockt->lt_clientid, 8);
 600         READ32(lockt->lt_owner.len);
 601         READ_BUF(lockt->lt_owner.len);
 602         READMEM(lockt->lt_owner.data, lockt->lt_owner.len);
 603
 604         DECODE_TAIL;
 605 }
 606
 607 static __be32
 608 nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku)
 609 {
 610         DECODE_HEAD;
 611
 612         READ_BUF(8);
 613         READ32(locku->lu_type);
 614         if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))
 615                 goto xdr_error;
 616         READ32(locku->lu_seqid);
 617         status = nfsd4_decode_stateid(argp, &locku->lu_stateid);
 618         if (status)
 619                 return status;
 620         READ_BUF(16);
 621         READ64(locku->lu_offset);
 622         READ64(locku->lu_length);
 623
 624         DECODE_TAIL;
 625 }
 626
 627 static __be32
 628 nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup)
 629 {
 630         DECODE_HEAD;
 631
 632         READ_BUF(4);
 633         READ32(lookup->lo_len);
 634         READ_BUF(lookup->lo_len);
 635         SAVEMEM(lookup->lo_name, lookup->lo_len);
 636         if ((status = check_filename(lookup->lo_name, lookup->lo_len, nfserr_noent)))
 637                 return status;
 638
 639         DECODE_TAIL;
 640 }
 641
 642 static __be32
 643 nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
 644 {
 645         DECODE_HEAD;
 646
 647         memset(open->op_bmval, 0, sizeof(open->op_bmval));
 648         open->op_iattr.ia_valid = 0;
 649         open->op_openowner = NULL;
 650
 651         /* seqid, share_access, share_deny, clientid, ownerlen */
 652         READ_BUF(16 + sizeof(clientid_t));
 653         READ32(open->op_seqid);
 654         READ32(open->op_share_access);
 655         READ32(open->op_share_deny);
 656         COPYMEM(&open->op_clientid, sizeof(clientid_t));
 657         READ32(open->op_owner.len);
 658
 659         /* owner, open_flag */
 660         READ_BUF(open->op_owner.len + 4);
 661         SAVEMEM(open->op_owner.data, open->op_owner.len);
 662         READ32(open->op_create);
 663         switch (open->op_create) {
 664         case NFS4_OPEN_NOCREATE:
 665                 break;
 666         case NFS4_OPEN_CREATE:
 667                 READ_BUF(4);
 668                 READ32(open->op_createmode);
 669                 switch (open->op_createmode) {
 670                 case NFS4_CREATE_UNCHECKED:
 671                 case NFS4_CREATE_GUARDED:
 672                         status = nfsd4_decode_fattr(argp, open->op_bmval,
 673                                 &open->op_iattr, &open->op_acl);
 674                         if (status)
 675                                 goto out;
 676                         break;
 677                 case NFS4_CREATE_EXCLUSIVE:
 678                         READ_BUF(8);
 679                         COPYMEM(open->op_verf.data, 8);
 680                         break;
 681                 case NFS4_CREATE_EXCLUSIVE4_1:
 682                         if (argp->minorversion < 1)
 683                                 goto xdr_error;
 684                         READ_BUF(8);
 685                         COPYMEM(open->op_verf.data, 8);
 686                         status = nfsd4_decode_fattr(argp, open->op_bmval,
 687                                 &open->op_iattr, &open->op_acl);
 688                         if (status)
 689                                 goto out;
 690                         break;
 691                 default:
 692                         goto xdr_error;
 693                 }
 694                 break;
 695         default:
 696                 goto xdr_error;
 697         }
 698
 699         /* open_claim */
 700         READ_BUF(4);
 701         READ32(open->op_claim_type);
 702         switch (open->op_claim_type) {
 703         case NFS4_OPEN_CLAIM_NULL:
 704         case NFS4_OPEN_CLAIM_DELEGATE_PREV:
 705                 READ_BUF(4);
 706                 READ32(open->op_fname.len);
 707                 READ_BUF(open->op_fname.len);
 708                 SAVEMEM(open->op_fname.data, open->op_fname.len);
 709                 if ((status = check_filename(open->op_fname.data, open->op_fname.len, nfserr_inval)))
 710                         return status;
 711                 break;
 712         case NFS4_OPEN_CLAIM_PREVIOUS:
 713                 READ_BUF(4);
 714                 READ32(open->op_delegate_type);
 715                 break;
 716         case NFS4_OPEN_CLAIM_DELEGATE_CUR:
 717                 status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);
 718                 if (status)
 719                         return status;
 720                 READ_BUF(4);
 721                 READ32(open->op_fname.len);
 722                 READ_BUF(open->op_fname.len);
 723                 SAVEMEM(open->op_fname.data, open->op_fname.len);
 724                 if ((status = check_filename(open->op_fname.data, open->op_fname.len, nfserr_inval)))
 725                         return status;
 726                 break;
 727         default:
 728                 goto xdr_error;
 729         }
 730
 731         DECODE_TAIL;
 732 }
 733
 734 static __be32
 735 nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf)
 736 {
 737         DECODE_HEAD;
 738
 739         status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid);
 740         if (status)
 741                 return status;
 742         READ_BUF(4);
 743         READ32(open_conf->oc_seqid);
 744
 745         DECODE_TAIL;
 746 }
 747
 748 static __be32
 749 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down)
 750 {
 751         DECODE_HEAD;
 752
 753         status = nfsd4_decode_stateid(argp, &open_down->od_stateid);
 754         if (status)
 755                 return status;
 756         READ_BUF(12);
 757         READ32(open_down->od_seqid);
 758         READ32(open_down->od_share_access);
 759         READ32(open_down->od_share_deny);
 760
 761         DECODE_TAIL;
 762 }
 763
 764 static __be32
 765 nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh)
 766 {
 767         DECODE_HEAD;
 768
 769         READ_BUF(4);
 770         READ32(putfh->pf_fhlen);
 771         if (putfh->pf_fhlen > NFS4_FHSIZE)
 772                 goto xdr_error;
 773         READ_BUF(putfh->pf_fhlen);
 774         SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen);
 775
 776         DECODE_TAIL;
 777 }
 778
 779 static __be32
 780 nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read)
 781 {
 782         DECODE_HEAD;
 783
 784         status = nfsd4_decode_stateid(argp, &read->rd_stateid);
 785         if (status)
 786                 return status;
 787         READ_BUF(12);
 788         READ64(read->rd_offset);
 789         READ32(read->rd_length);
 790
 791         DECODE_TAIL;
 792 }
 793
 794 static __be32
 795 nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir)
 796 {
 797         DECODE_HEAD;
 798
 799         READ_BUF(24);
 800         READ64(readdir->rd_cookie);
 801         COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data));
 802         READ32(readdir->rd_dircount);    /* just in case you needed a useless field... */
 803         READ32(readdir->rd_maxcount);
 804         if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval)))
 805                 goto out;
 806
 807         DECODE_TAIL;
 808 }
 809
 810 static __be32
 811 nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove)
 812 {
 813         DECODE_HEAD;
 814
 815         READ_BUF(4);
 816         READ32(remove->rm_namelen);
 817         READ_BUF(remove->rm_namelen);
 818         SAVEMEM(remove->rm_name, remove->rm_namelen);
 819         if ((status = check_filename(remove->rm_name, remove->rm_namelen, nfserr_noent)))
 820                 return status;
 821
 822         DECODE_TAIL;
 823 }
 824
 825 static __be32
 826 nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename)
 827 {
 828         DECODE_HEAD;
 829
 830         READ_BUF(4);
 831         READ32(rename->rn_snamelen);
 832         READ_BUF(rename->rn_snamelen + 4);
 833         SAVEMEM(rename->rn_sname, rename->rn_snamelen);
 834         READ32(rename->rn_tnamelen);
 835         READ_BUF(rename->rn_tnamelen);
 836         SAVEMEM(rename->rn_tname, rename->rn_tnamelen);
 837         if ((status = check_filename(rename->rn_sname, rename->rn_snamelen, nfserr_noent)))
 838                 return status;
 839         if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen, nfserr_inval)))
 840                 return status;
 841
 842         DECODE_TAIL;
 843 }
 844
 845 static __be32
 846 nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid)
 847 {
 848         DECODE_HEAD;
 849
 850         READ_BUF(sizeof(clientid_t));
 851         COPYMEM(clientid, sizeof(clientid_t));
 852
 853         DECODE_TAIL;
 854 }
 855
 856 static __be32
 857 nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp,
 858                      struct nfsd4_secinfo *secinfo)
 859 {
 860         DECODE_HEAD;
 861
 862         READ_BUF(4);
 863         READ32(secinfo->si_namelen);
 864         READ_BUF(secinfo->si_namelen);
 865         SAVEMEM(secinfo->si_name, secinfo->si_namelen);
 866         status = check_filename(secinfo->si_name, secinfo->si_namelen,
 867                                                                 nfserr_noent);
 868         if (status)
 869                 return status;
 870         DECODE_TAIL;
 871 }
 872
 873 static __be32
 874 nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp,
 875                      struct nfsd4_secinfo_no_name *sin)
 876 {
 877         DECODE_HEAD;
 878
 879         READ_BUF(4);
 880         READ32(sin->sin_style);
 881         DECODE_TAIL;
 882 }
 883
 884 static __be32
 885 nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr)
 886 {
 887         __be32 status;
 888
 889         status = nfsd4_decode_stateid(argp, &setattr->sa_stateid);
 890         if (status)
 891                 return status;
 892         return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr,
 893                                   &setattr->sa_acl);
 894 }
 895
 896 static __be32
 897 nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid)
 898 {
 899         DECODE_HEAD;
 900
 901         READ_BUF(12);
 902         COPYMEM(setclientid->se_verf.data, 8);
 903         READ32(setclientid->se_namelen);
 904
 905         READ_BUF(setclientid->se_namelen + 8);
 906         SAVEMEM(setclientid->se_name, setclientid->se_namelen);
 907         READ32(setclientid->se_callback_prog);
 908         READ32(setclientid->se_callback_netid_len);
 909
 910         READ_BUF(setclientid->se_callback_netid_len + 4);
 911         SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len);
 912         READ32(setclientid->se_callback_addr_len);
 913
 914         READ_BUF(setclientid->se_callback_addr_len + 4);
 915         SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len);
 916         READ32(setclientid->se_callback_ident);
 917
 918         DECODE_TAIL;
 919 }
 920
 921 static __be32
 922 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c)
 923 {
 924         DECODE_HEAD;
 925
 926         READ_BUF(8 + sizeof(nfs4_verifier));
 927         COPYMEM(&scd_c->sc_clientid, 8);
 928         COPYMEM(&scd_c->sc_confirm, sizeof(nfs4_verifier));
 929
 930         DECODE_TAIL;
 931 }
 932
 933 /* Also used for NVERIFY */
 934 static __be32
 935 nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verify)
 936 {
 937 #if 0
 938         struct nfsd4_compoundargs save = {
 939                 .p = argp->p,
 940                 .end = argp->end,
 941                 .rqstp = argp->rqstp,
 942         };
 943         u32             ve_bmval[2];
 944         struct iattr    ve_iattr;           /* request */
 945         struct nfs4_acl *ve_acl;            /* request */
 946 #endif
 947         DECODE_HEAD;
 948
 949         if ((status = nfsd4_decode_bitmap(argp, verify->ve_bmval)))
 950                 goto out;
 951
 952         /* For convenience's sake, we compare raw xdr'd attributes in
 953          * nfsd4_proc_verify; however we still decode here just to return
 954          * correct error in case of bad xdr. */
 955 #if 0
 956         status = nfsd4_decode_fattr(ve_bmval, &ve_iattr, &ve_acl);
 957         if (status == nfserr_inval) {
 958                 status = nfserrno(status);
 959                 goto out;
 960         }
 961 #endif
 962         READ_BUF(4);
 963         READ32(verify->ve_attrlen);
 964         READ_BUF(verify->ve_attrlen);
 965         SAVEMEM(verify->ve_attrval, verify->ve_attrlen);
 966
 967         DECODE_TAIL;
 968 }
 969
 970 static __be32
 971 nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write)
 972 {
 973         int avail;
 974         int v;
 975         int len;
 976         DECODE_HEAD;
 977
 978         status = nfsd4_decode_stateid(argp, &write->wr_stateid);
 979         if (status)
 980                 return status;
 981         READ_BUF(16);
 982         READ64(write->wr_offset);
 983         READ32(write->wr_stable_how);
 984         if (write->wr_stable_how > 2)
 985                 goto xdr_error;
 986         READ32(write->wr_buflen);
 987
 988         /* Sorry .. no magic macros for this.. *
 989          * READ_BUF(write->wr_buflen);
 990          * SAVEMEM(write->wr_buf, write->wr_buflen);
 991          */
 992         avail = (char*)argp->end - (char*)argp->p;
 993         if (avail + argp->pagelen < write->wr_buflen) {
 994                 dprintk("NFSD: xdr error (%s:%d)\n",
 995                                 __FILE__, __LINE__);
 996                 goto xdr_error;
 997         }
 998         argp->rqstp->rq_vec[0].iov_base = p;
 999         argp->rqstp->rq_vec[0].iov_len = avail;
1000         v = 0;
1001         len = write->wr_buflen;
1002         while (len > argp->rqstp->rq_vec[v].iov_len) {
1003                 len -= argp->rqstp->rq_vec[v].iov_len;
1004                 v++;
1005                 argp->rqstp->rq_vec[v].iov_base = page_address(argp->pagelist[0]);
1006                 argp->pagelist++;
1007                 if (argp->pagelen >= PAGE_SIZE) {
1008                         argp->rqstp->rq_vec[v].iov_len = PAGE_SIZE;
1009                         argp->pagelen -= PAGE_SIZE;
1010                 } else {
1011                         argp->rqstp->rq_vec[v].iov_len = argp->pagelen;
1012                         argp->pagelen -= len;
1013                 }
1014         }
1015         argp->end = (__be32*) (argp->rqstp->rq_vec[v].iov_base + argp->rqstp->rq_vec[v].iov_len);
1016         argp->p = (__be32*)  (argp->rqstp->rq_vec[v].iov_base + (XDR_QUADLEN(len) << 2));
1017         argp->rqstp->rq_vec[v].iov_len = len;
1018         write->wr_vlen = v+1;
1019
1020         DECODE_TAIL;
1021 }
1022
1023 static __be32
1024 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner)
1025 {
1026         DECODE_HEAD;
1027
1028         READ_BUF(12);
1029         COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t));
1030         READ32(rlockowner->rl_owner.len);
1031         READ_BUF(rlockowner->rl_owner.len);
1032         READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len);
1033
1034         if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))
1035                 return nfserr_inval;
1036         DECODE_TAIL;
1037 }
1038
1039 static __be32
1040 nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp,
1041                          struct nfsd4_exchange_id *exid)
1042 {
1043         int dummy, tmp;
1044         DECODE_HEAD;
1045
1046         READ_BUF(NFS4_VERIFIER_SIZE);
1047         COPYMEM(exid->verifier.data, NFS4_VERIFIER_SIZE);
1048
1049         READ_BUF(4);
1050         READ32(exid->clname.len);
1051
1052         READ_BUF(exid->clname.len);
1053         SAVEMEM(exid->clname.data, exid->clname.len);
1054
1055         READ_BUF(4);
1056         READ32(exid->flags);
1057
1058         /* Ignore state_protect4_a */
1059         READ_BUF(4);
1060         READ32(exid->spa_how);
1061         switch (exid->spa_how) {
1062         case SP4_NONE:
1063                 break;
1064         case SP4_MACH_CRED:
1065                 /* spo_must_enforce */
1066                 READ_BUF(4);
1067                 READ32(dummy);
1068                 READ_BUF(dummy * 4);
1069                 p += dummy;
1070
1071                 /* spo_must_allow */
1072                 READ_BUF(4);
1073                 READ32(dummy);
1074                 READ_BUF(dummy * 4);
1075                 p += dummy;
1076                 break;
1077         case SP4_SSV:
1078                 /* ssp_ops */
1079                 READ_BUF(4);
1080                 READ32(dummy);
1081                 READ_BUF(dummy * 4);
1082                 p += dummy;
1083
1084                 READ_BUF(4);
1085                 READ32(dummy);
1086                 READ_BUF(dummy * 4);
1087                 p += dummy;
1088
1089                 /* ssp_hash_algs<> */
1090                 READ_BUF(4);
1091                 READ32(tmp);
1092                 while (tmp--) {
1093                         READ_BUF(4);
1094                         READ32(dummy);
1095                         READ_BUF(dummy);
1096                         p += XDR_QUADLEN(dummy);
1097                 }
1098
1099                 /* ssp_encr_algs<> */
1100                 READ_BUF(4);
1101                 READ32(tmp);
1102                 while (tmp--) {
1103                         READ_BUF(4);
1104                         READ32(dummy);
1105                         READ_BUF(dummy);
1106                         p += XDR_QUADLEN(dummy);
1107                 }
1108
1109                 /* ssp_window and ssp_num_gss_handles */
1110                 READ_BUF(8);
1111                 READ32(dummy);
1112                 READ32(dummy);
1113                 break;
1114         default:
1115                 goto xdr_error;
1116         }
1117
1118         /* Ignore Implementation ID */
1119         READ_BUF(4);    /* nfs_impl_id4 array length */
1120         READ32(dummy);
1121
1122         if (dummy > 1)
1123                 goto xdr_error;
1124
1125         if (dummy == 1) {
1126                 /* nii_domain */
1127                 READ_BUF(4);
1128                 READ32(dummy);
1129                 READ_BUF(dummy);
1130                 p += XDR_QUADLEN(dummy);
1131
1132                 /* nii_name */
1133                 READ_BUF(4);
1134                 READ32(dummy);
1135                 READ_BUF(dummy);
1136                 p += XDR_QUADLEN(dummy);
1137
1138                 /* nii_date */
1139                 READ_BUF(12);
1140                 p += 3;
1141         }
1142         DECODE_TAIL;
1143 }
1144
1145 static __be32
1146 nfsd4_decode_create_session(struct nfsd4_compoundargs *argp,
1147                             struct nfsd4_create_session *sess)
1148 {
1149         DECODE_HEAD;
1150
1151         u32 dummy;
1152         char *machine_name;
1153         int i;
1154         int nr_secflavs;
1155
1156         READ_BUF(16);
1157         COPYMEM(&sess->clientid, 8);
1158         READ32(sess->seqid);
1159         READ32(sess->flags);
1160
1161         /* Fore channel attrs */
1162         READ_BUF(28);
1163         READ32(dummy); /* headerpadsz is always 0 */
1164         READ32(sess->fore_channel.maxreq_sz);
1165         READ32(sess->fore_channel.maxresp_sz);
1166         READ32(sess->fore_channel.maxresp_cached);
1167         READ32(sess->fore_channel.maxops);
1168         READ32(sess->fore_channel.maxreqs);
1169         READ32(sess->fore_channel.nr_rdma_attrs);
1170         if (sess->fore_channel.nr_rdma_attrs == 1) {
1171                 READ_BUF(4);
1172                 READ32(sess->fore_channel.rdma_attrs);
1173         } else if (sess->fore_channel.nr_rdma_attrs > 1) {
1174                 dprintk("Too many fore channel attr bitmaps!\n");
1175                 goto xdr_error;
1176         }
1177
1178         /* Back channel attrs */
1179         READ_BUF(28);
1180         READ32(dummy); /* headerpadsz is always 0 */
1181         READ32(sess->back_channel.maxreq_sz);
1182         READ32(sess->back_channel.maxresp_sz);
1183         READ32(sess->back_channel.maxresp_cached);
1184         READ32(sess->back_channel.maxops);
1185         READ32(sess->back_channel.maxreqs);
1186         READ32(sess->back_channel.nr_rdma_attrs);
1187         if (sess->back_channel.nr_rdma_attrs == 1) {
1188                 READ_BUF(4);
1189                 READ32(sess->back_channel.rdma_attrs);
1190         } else if (sess->back_channel.nr_rdma_attrs > 1) {
1191                 dprintk("Too many back channel attr bitmaps!\n");
1192                 goto xdr_error;
1193         }
1194
1195         READ_BUF(8);
1196         READ32(sess->callback_prog);
1197
1198         /* callback_sec_params4 */
1199         READ32(nr_secflavs);
1200         for (i = 0; i < nr_secflavs; ++i) {
1201                 READ_BUF(4);
1202                 READ32(dummy);
1203                 switch (dummy) {
1204                 case RPC_AUTH_NULL:
1205                         /* Nothing to read */
1206                         break;
1207                 case RPC_AUTH_UNIX:
1208                         READ_BUF(8);
1209                         /* stamp */
1210                         READ32(dummy);
1211
1212                         /* machine name */
1213                         READ32(dummy);
1214                         READ_BUF(dummy);
1215                         SAVEMEM(machine_name, dummy);
1216
1217                         /* uid, gid */
1218                         READ_BUF(8);
1219                         READ32(sess->uid);
1220                         READ32(sess->gid);
1221
1222                         /* more gids */
1223                         READ_BUF(4);
1224                         READ32(dummy);
1225                         READ_BUF(dummy * 4);
1226                         break;
1227                 case RPC_AUTH_GSS:
1228                         dprintk("RPC_AUTH_GSS callback secflavor "
1229                                 "not supported!\n");
1230                         READ_BUF(8);
1231                         /* gcbp_service */
1232                         READ32(dummy);
1233                         /* gcbp_handle_from_server */
1234                         READ32(dummy);
1235                         READ_BUF(dummy);
1236                         p += XDR_QUADLEN(dummy);
1237                         /* gcbp_handle_from_client */
1238                         READ_BUF(4);
1239                         READ32(dummy);
1240                         READ_BUF(dummy);
1241                         break;
1242                 default:
1243                         dprintk("Illegal callback secflavor\n");
1244                         return nfserr_inval;
1245                 }
1246         }
1247         DECODE_TAIL;
1248 }
1249
1250 static __be32
1251 nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp,
1252                              struct nfsd4_destroy_session *destroy_session)
1253 {
1254         DECODE_HEAD;
1255         READ_BUF(NFS4_MAX_SESSIONID_LEN);
1256         COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN);
1257
1258         DECODE_TAIL;
1259 }
1260
1261 static __be32
1262 nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp,
1263                           struct nfsd4_free_stateid *free_stateid)
1264 {
1265         DECODE_HEAD;
1266
1267         READ_BUF(sizeof(stateid_t));
1268         READ32(free_stateid->fr_stateid.si_generation);
1269         COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t));
1270
1271         DECODE_TAIL;
1272 }
1273
1274 static __be32
1275 nfsd4_decode_sequence(struct nfsd4_compoundargs *argp,
1276                       struct nfsd4_sequence *seq)
1277 {
1278         DECODE_HEAD;
1279
1280         READ_BUF(NFS4_MAX_SESSIONID_LEN + 16);
1281         COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);
1282         READ32(seq->seqid);
1283         READ32(seq->slotid);
1284         READ32(seq->maxslots);
1285         READ32(seq->cachethis);
1286
1287         DECODE_TAIL;
1288 }
1289
1290 static __be32
1291 nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid)
1292 {
1293         unsigned int nbytes;
1294         stateid_t si;
1295         int i;
1296         __be32 *p;
1297         __be32 status;
1298
1299         READ_BUF(4);
1300         test_stateid->ts_num_ids = ntohl(*p++);
1301
1302         nbytes = test_stateid->ts_num_ids * sizeof(stateid_t);
1303         if (nbytes > (u32)((char *)argp->end - (char *)argp->p))
1304                 goto xdr_error;
1305
1306         test_stateid->ts_saved_args = argp;
1307         save_buf(argp, &test_stateid->ts_savedp);
1308
1309         for (i = 0; i < test_stateid->ts_num_ids; i++) {
1310                 status = nfsd4_decode_stateid(argp, &si);
1311                 if (status)
1312                         return status;
1313         }
1314
1315         status = 0;
1316 out:
1317         return status;
1318 xdr_error:
1319         dprintk("NFSD: xdr error (%s:%d)\n", __FILE__, __LINE__);
1320         status = nfserr_bad_xdr;
1321         goto out;
1322 }
1323
1324 static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, struct nfsd4_reclaim_complete *rc)
1325 {
1326         DECODE_HEAD;
1327
1328         READ_BUF(4);
1329         READ32(rc->rca_one_fs);
1330
1331         DECODE_TAIL;
1332 }
1333
1334 static __be32
1335 nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p)
1336 {
1337         return nfs_ok;
1338 }
1339
1340 static __be32
1341 nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p)
1342 {
1343         return nfserr_notsupp;
1344 }
1345
1346 typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *);
1347
1348 static nfsd4_dec nfsd4_dec_ops[] = {
1349         [OP_ACCESS]             = (nfsd4_dec)nfsd4_decode_access,
1350         [OP_CLOSE]              = (nfsd4_dec)nfsd4_decode_close,
1351         [OP_COMMIT]             = (nfsd4_dec)nfsd4_decode_commit,
1352         [OP_CREATE]             = (nfsd4_dec)nfsd4_decode_create,
1353         [OP_DELEGPURGE]         = (nfsd4_dec)nfsd4_decode_notsupp,
1354         [OP_DELEGRETURN]        = (nfsd4_dec)nfsd4_decode_delegreturn,
1355         [OP_GETATTR]            = (nfsd4_dec)nfsd4_decode_getattr,
1356         [OP_GETFH]              = (nfsd4_dec)nfsd4_decode_noop,
1357         [OP_LINK]               = (nfsd4_dec)nfsd4_decode_link,
1358         [OP_LOCK]               = (nfsd4_dec)nfsd4_decode_lock,
1359         [OP_LOCKT]              = (nfsd4_dec)nfsd4_decode_lockt,
1360         [OP_LOCKU]              = (nfsd4_dec)nfsd4_decode_locku,
1361         [OP_LOOKUP]             = (nfsd4_dec)nfsd4_decode_lookup,
1362         [OP_LOOKUPP]            = (nfsd4_dec)nfsd4_decode_noop,
1363         [OP_NVERIFY]            = (nfsd4_dec)nfsd4_decode_verify,
1364         [OP_OPEN]               = (nfsd4_dec)nfsd4_decode_open,
1365         [OP_OPENATTR]           = (nfsd4_dec)nfsd4_decode_notsupp,
1366         [OP_OPEN_CONFIRM]       = (nfsd4_dec)nfsd4_decode_open_confirm,
1367         [OP_OPEN_DOWNGRADE]     = (nfsd4_dec)nfsd4_decode_open_downgrade,
1368         [OP_PUTFH]              = (nfsd4_dec)nfsd4_decode_putfh,
1369         [OP_PUTPUBFH]           = (nfsd4_dec)nfsd4_decode_noop,
1370         [OP_PUTROOTFH]          = (nfsd4_dec)nfsd4_decode_noop,
1371         [OP_READ]               = (nfsd4_dec)nfsd4_decode_read,
1372         [OP_READDIR]            = (nfsd4_dec)nfsd4_decode_readdir,
1373         [OP_READLINK]           = (nfsd4_dec)nfsd4_decode_noop,
1374         [OP_REMOVE]             = (nfsd4_dec)nfsd4_decode_remove,
1375         [OP_RENAME]             = (nfsd4_dec)nfsd4_decode_rename,
1376         [OP_RENEW]              = (nfsd4_dec)nfsd4_decode_renew,
1377         [OP_RESTOREFH]          = (nfsd4_dec)nfsd4_decode_noop,
1378         [OP_SAVEFH]             = (nfsd4_dec)nfsd4_decode_noop,
1379         [OP_SECINFO]            = (nfsd4_dec)nfsd4_decode_secinfo,
1380         [OP_SETATTR]            = (nfsd4_dec)nfsd4_decode_setattr,
1381         [OP_SETCLIENTID]        = (nfsd4_dec)nfsd4_decode_setclientid,
1382         [OP_SETCLIENTID_CONFIRM] = (nfsd4_dec)nfsd4_decode_setclientid_confirm,
1383         [OP_VERIFY]             = (nfsd4_dec)nfsd4_decode_verify,
1384         [OP_WRITE]              = (nfsd4_dec)nfsd4_decode_write,
1385         [OP_RELEASE_LOCKOWNER]  = (nfsd4_dec)nfsd4_decode_release_lockowner,
1386 };
1387
1388 static nfsd4_dec nfsd41_dec_ops[] = {
1389         [OP_ACCESS]             = (nfsd4_dec)nfsd4_decode_access,
1390         [OP_CLOSE]              = (nfsd4_dec)nfsd4_decode_close,
1391         [OP_COMMIT]             = (nfsd4_dec)nfsd4_decode_commit,
1392         [OP_CREATE]             = (nfsd4_dec)nfsd4_decode_create,
1393         [OP_DELEGPURGE]         = (nfsd4_dec)nfsd4_decode_notsupp,
1394         [OP_DELEGRETURN]        = (nfsd4_dec)nfsd4_decode_delegreturn,
1395         [OP_GETATTR]            = (nfsd4_dec)nfsd4_decode_getattr,
1396         [OP_GETFH]              = (nfsd4_dec)nfsd4_decode_noop,
1397         [OP_LINK]               = (nfsd4_dec)nfsd4_decode_link,
1398         [OP_LOCK]               = (nfsd4_dec)nfsd4_decode_lock,
1399         [OP_LOCKT]              = (nfsd4_dec)nfsd4_decode_lockt,
1400         [OP_LOCKU]              = (nfsd4_dec)nfsd4_decode_locku,
1401         [OP_LOOKUP]             = (nfsd4_dec)nfsd4_decode_lookup,
1402         [OP_LOOKUPP]            = (nfsd4_dec)nfsd4_decode_noop,
1403         [OP_NVERIFY]            = (nfsd4_dec)nfsd4_decode_verify,
1404         [OP_OPEN]               = (nfsd4_dec)nfsd4_decode_open,
1405         [OP_OPENATTR]           = (nfsd4_dec)nfsd4_decode_notsupp,
1406         [OP_OPEN_CONFIRM]       = (nfsd4_dec)nfsd4_decode_notsupp,
1407         [OP_OPEN_DOWNGRADE]     = (nfsd4_dec)nfsd4_decode_open_downgrade,
1408         [OP_PUTFH]              = (nfsd4_dec)nfsd4_decode_putfh,
1409         [OP_PUTPUBFH]           = (nfsd4_dec)nfsd4_decode_notsupp,
1410         [OP_PUTROOTFH]          = (nfsd4_dec)nfsd4_decode_noop,
1411         [OP_READ]               = (nfsd4_dec)nfsd4_decode_read,
1412         [OP_READDIR]            = (nfsd4_dec)nfsd4_decode_readdir,
1413         [OP_READLINK]           = (nfsd4_dec)nfsd4_decode_noop,
1414         [OP_REMOVE]             = (nfsd4_dec)nfsd4_decode_remove,
1415         [OP_RENAME]             = (nfsd4_dec)nfsd4_decode_rename,
1416         [OP_RENEW]              = (nfsd4_dec)nfsd4_decode_notsupp,
1417         [OP_RESTOREFH]          = (nfsd4_dec)nfsd4_decode_noop,
1418         [OP_SAVEFH]             = (nfsd4_dec)nfsd4_decode_noop,
1419         [OP_SECINFO]            = (nfsd4_dec)nfsd4_decode_secinfo,
1420         [OP_SETATTR]            = (nfsd4_dec)nfsd4_decode_setattr,
1421         [OP_SETCLIENTID]        = (nfsd4_dec)nfsd4_decode_notsupp,
1422         [OP_SETCLIENTID_CONFIRM]= (nfsd4_dec)nfsd4_decode_notsupp,
1423         [OP_VERIFY]             = (nfsd4_dec)nfsd4_decode_verify,
1424         [OP_WRITE]              = (nfsd4_dec)nfsd4_decode_write,
1425         [OP_RELEASE_LOCKOWNER]  = (nfsd4_dec)nfsd4_decode_notsupp,
1426
1427         /* new operations for NFSv4.1 */
1428         [OP_BACKCHANNEL_CTL]    = (nfsd4_dec)nfsd4_decode_notsupp,
1429         [OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session,
1430         [OP_EXCHANGE_ID]        = (nfsd4_dec)nfsd4_decode_exchange_id,
1431         [OP_CREATE_SESSION]     = (nfsd4_dec)nfsd4_decode_create_session,
1432         [OP_DESTROY_SESSION]    = (nfsd4_dec)nfsd4_decode_destroy_session,
1433         [OP_FREE_STATEID]       = (nfsd4_dec)nfsd4_decode_free_stateid,
1434         [OP_GET_DIR_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp,
1435         [OP_GETDEVICEINFO]      = (nfsd4_dec)nfsd4_decode_notsupp,
1436         [OP_GETDEVICELIST]      = (nfsd4_dec)nfsd4_decode_notsupp,
1437         [OP_LAYOUTCOMMIT]       = (nfsd4_dec)nfsd4_decode_notsupp,
1438         [OP_LAYOUTGET]          = (nfsd4_dec)nfsd4_decode_notsupp,
1439         [OP_LAYOUTRETURN]       = (nfsd4_dec)nfsd4_decode_notsupp,
1440         [OP_SECINFO_NO_NAME]    = (nfsd4_dec)nfsd4_decode_secinfo_no_name,
1441         [OP_SEQUENCE]           = (nfsd4_dec)nfsd4_decode_sequence,
1442         [OP_SET_SSV]            = (nfsd4_dec)nfsd4_decode_notsupp,
1443         [OP_TEST_STATEID]       = (nfsd4_dec)nfsd4_decode_test_stateid,
1444         [OP_WANT_DELEGATION]    = (nfsd4_dec)nfsd4_decode_notsupp,
1445         [OP_DESTROY_CLIENTID]   = (nfsd4_dec)nfsd4_decode_notsupp,
1446         [OP_RECLAIM_COMPLETE]   = (nfsd4_dec)nfsd4_decode_reclaim_complete,
1447 };
1448
1449 struct nfsd4_minorversion_ops {
1450         nfsd4_dec *decoders;
1451         int nops;
1452 };
1453
1454 static struct nfsd4_minorversion_ops nfsd4_minorversion[] = {
1455         [0] = { nfsd4_dec_ops, ARRAY_SIZE(nfsd4_dec_ops) },
1456         [1] = { nfsd41_dec_ops, ARRAY_SIZE(nfsd41_dec_ops) },
1457 };
1458
1459 static __be32
1460 nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
1461 {
1462         DECODE_HEAD;
1463         struct nfsd4_op *op;
1464         struct nfsd4_minorversion_ops *ops;
1465         bool cachethis = false;
1466         int i;
1467
1468         /*
1469          * XXX: According to spec, we should check the tag
1470          * for UTF-8 compliance.  I'm postponing this for
1471          * now because it seems that some clients do use
1472          * binary tags.
1473          */
1474         READ_BUF(4);
1475         READ32(argp->taglen);
1476         READ_BUF(argp->taglen + 8);
1477         SAVEMEM(argp->tag, argp->taglen);
1478         READ32(argp->minorversion);
1479         READ32(argp->opcnt);
1480
1481         if (argp->taglen > NFSD4_MAX_TAGLEN)
1482                 goto xdr_error;
1483         if (argp->opcnt > 100)
1484                 goto xdr_error;
1485
1486         if (argp->opcnt > ARRAY_SIZE(argp->iops)) {
1487                 argp->ops = kmalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);
1488                 if (!argp->ops) {
1489                         argp->ops = argp->iops;
1490                         dprintk("nfsd: couldn't allocate room for COMPOUND\n");
1491                         goto xdr_error;
1492                 }
1493         }
1494
1495         if (argp->minorversion >= ARRAY_SIZE(nfsd4_minorversion))
1496                 argp->opcnt = 0;
1497
1498         ops = &nfsd4_minorversion[argp->minorversion];
1499         for (i = 0; i < argp->opcnt; i++) {
1500                 op = &argp->ops[i];
1501                 op->replay = NULL;
1502
1503                 /*
1504                  * We can't use READ_BUF() here because we need to handle
1505                  * a missing opcode as an OP_WRITE + 1. So we need to check
1506                  * to see if we're truly at the end of our buffer or if there
1507                  * is another page we need to flip to.
1508                  */
1509
1510                 if (argp->p == argp->end) {
1511                         if (argp->pagelen < 4) {
1512                                 /* There isn't an opcode still on the wire */
1513                                 op->opnum = OP_WRITE + 1;
1514                                 op->status = nfserr_bad_xdr;
1515                                 argp->opcnt = i+1;
1516                                 break;
1517                         }
1518
1519                         /*
1520                          * False alarm. We just hit a page boundary, but there
1521                          * is still data available.  Move pointer across page
1522                          * boundary.  *snip from READ_BUF*
1523                          */
1524                         argp->p = page_address(argp->pagelist[0]);
1525                         argp->pagelist++;
1526                         if (argp->pagelen < PAGE_SIZE) {
1527                                 argp->end = argp->p + (argp->pagelen>>2);
1528                                 argp->pagelen = 0;
1529                         } else {
1530                                 argp->end = argp->p + (PAGE_SIZE>>2);
1531                                 argp->pagelen -= PAGE_SIZE;
1532                         }
1533                 }
1534                 op->opnum = ntohl(*argp->p++);
1535
1536                 if (op->opnum >= FIRST_NFS4_OP && op->opnum <= LAST_NFS4_OP)
1537                         op->status = ops->decoders[op->opnum](argp, &op->u);
1538                 else {
1539                         op->opnum = OP_ILLEGAL;
1540                         op->status = nfserr_op_illegal;
1541                 }
1542
1543                 if (op->status) {
1544                         argp->opcnt = i+1;
1545                         break;
1546                 }
1547                 /*
1548                  * We'll try to cache the result in the DRC if any one
1549                  * op in the compound wants to be cached:
1550                  */
1551                 cachethis |= nfsd4_cache_this_op(op);
1552         }
1553         /* Sessions make the DRC unnecessary: */
1554         if (argp->minorversion)
1555                 cachethis = false;
1556         argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;
1557
1558         DECODE_TAIL;
1559 }
1560
1561 #define WRITE32(n)               *p++ = htonl(n)
1562 #define WRITE64(n)               do {                           \
1563         *p++ = htonl((u32)((n) >> 32));                         \
1564         *p++ = htonl((u32)(n));                                 \
1565 } while (0)
1566 #define WRITEMEM(ptr,nbytes)     do { if (nbytes > 0) {         \
1567         *(p + XDR_QUADLEN(nbytes) -1) = 0;                      \
1568         memcpy(p, ptr, nbytes);                                 \
1569         p += XDR_QUADLEN(nbytes);                               \
1570 }} while (0)
1571
1572 static void write32(__be32 **p, u32 n)
1573 {
1574         *(*p)++ = n;
1575 }
1576
1577 static void write64(__be32 **p, u64 n)
1578 {
1579         write32(p, (u32)(n >> 32));
1580         write32(p, (u32)n);
1581 }
1582
1583 static void write_change(__be32 **p, struct kstat *stat, struct inode *inode)
1584 {
1585         if (IS_I_VERSION(inode)) {
1586                 write64(p, inode->i_version);
1587         } else {
1588                 write32(p, stat->ctime.tv_sec);
1589                 write32(p, stat->ctime.tv_nsec);
1590         }
1591 }
1592
1593 static void write_cinfo(__be32 **p, struct nfsd4_change_info *c)
1594 {
1595         write32(p, c->atomic);
1596         if (c->change_supported) {
1597                 write64(p, c->before_change);
1598                 write64(p, c->after_change);
1599         } else {
1600                 write32(p, c->before_ctime_sec);
1601                 write32(p, c->before_ctime_nsec);
1602                 write32(p, c->after_ctime_sec);
1603                 write32(p, c->after_ctime_nsec);
1604         }
1605 }
1606
1607 #define RESERVE_SPACE(nbytes)   do {                            \
1608         p = resp->p;                                            \
1609         BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end);            \
1610 } while (0)
1611 #define ADJUST_ARGS()           resp->p = p
1612
1613 /*
1614  * Header routine to setup seqid operation replay cache
1615  */
1616 #define ENCODE_SEQID_OP_HEAD                                    \
1617         __be32 *save;                                           \
1618                                                                 \
1619         save = resp->p;
1620
1621 /*
1622  * Routine for encoding the result of a "seqid-mutating" NFSv4 operation.  This
1623  * is where sequence id's are incremented, and the replay cache is filled.
1624  * Note that we increment sequence id's here, at the last moment, so we're sure
1625  * we know whether the error to be returned is a sequence id mutating error.
1626  */
1627
1628 static void encode_seqid_op_tail(struct nfsd4_compoundres *resp, __be32 *save, __be32 nfserr)
1629 {
1630         struct nfs4_stateowner *stateowner = resp->cstate.replay_owner;
1631
1632         if (seqid_mutating_err(ntohl(nfserr)) && stateowner) {
1633                 stateowner->so_seqid++;
1634                 stateowner->so_replay.rp_status = nfserr;
1635                 stateowner->so_replay.rp_buflen =
1636                           (char *)resp->p - (char *)save;
1637                 memcpy(stateowner->so_replay.rp_buf, save,
1638                         stateowner->so_replay.rp_buflen);
1639                 nfsd4_purge_closed_stateid(stateowner);
1640         }
1641 }
1642
1643 /* Encode as an array of strings the string given with components
1644  * separated @sep.
1645  */
1646 static __be32 nfsd4_encode_components(char sep, char *components,
1647                                    __be32 **pp, int *buflen)
1648 {
1649         __be32 *p = *pp;
1650         __be32 *countp = p;
1651         int strlen, count=0;
1652         char *str, *end;
1653
1654         dprintk("nfsd4_encode_components(%s)\n", components);
1655         if ((*buflen -= 4) < 0)
1656                 return nfserr_resource;
1657         WRITE32(0); /* We will fill this in with @count later */
1658         end = str = components;
1659         while (*end) {
1660                 for (; *end && (*end != sep); end++)
1661                         ; /* Point to end of component */
1662                 strlen = end - str;
1663                 if (strlen) {
1664                         if ((*buflen -= ((XDR_QUADLEN(strlen) << 2) + 4)) < 0)
1665                                 return nfserr_resource;
1666                         WRITE32(strlen);
1667                         WRITEMEM(str, strlen);
1668                         count++;
1669                 }
1670                 else
1671                         end++;
1672                 str = end;
1673         }
1674         *pp = p;
1675         p = countp;
1676         WRITE32(count);
1677         return 0;
1678 }
1679
1680 /*
1681  * encode a location element of a fs_locations structure
1682  */
1683 static __be32 nfsd4_encode_fs_location4(struct nfsd4_fs_location *location,
1684                                     __be32 **pp, int *buflen)
1685 {
1686         __be32 status;
1687         __be32 *p = *pp;
1688
1689         status = nfsd4_encode_components(':', location->hosts, &p, buflen);
1690         if (status)
1691                 return status;
1692         status = nfsd4_encode_components('/', location->path, &p, buflen);
1693         if (status)
1694                 return status;
1695         *pp = p;
1696         return 0;
1697 }
1698
1699 /*
1700  * Encode a path in RFC3530 'pathname4' format
1701  */
1702 static __be32 nfsd4_encode_path(const struct path *root,
1703                 const struct path *path, __be32 **pp, int *buflen)
1704 {
1705         struct path cur = {
1706                 .mnt = path->mnt,
1707                 .dentry = path->dentry,
1708         };
1709         __be32 *p = *pp;
1710         struct dentry **components = NULL;
1711         unsigned int ncomponents = 0;
1712         __be32 err = nfserr_jukebox;
1713
1714         dprintk("nfsd4_encode_components(");
1715
1716         path_get(&cur);
1717         /* First walk the path up to the nfsd root, and store the
1718          * dentries/path components in an array.
1719          */
1720         for (;;) {
1721                 if (cur.dentry == root->dentry && cur.mnt == root->mnt)
1722                         break;
1723                 if (cur.dentry == cur.mnt->mnt_root) {
1724                         if (follow_up(&cur))
1725                                 continue;
1726                         goto out_free;
1727                 }
1728                 if ((ncomponents & 15) == 0) {
1729                         struct dentry **new;
1730                         new = krealloc(components,
1731                                         sizeof(*new) * (ncomponents + 16),
1732                                         GFP_KERNEL);
1733                         if (!new)
1734                                 goto out_free;
1735                         components = new;
1736                 }
1737                 components[ncomponents++] = cur.dentry;
1738                 cur.dentry = dget_parent(cur.dentry);
1739         }
1740
1741         *buflen -= 4;
1742         if (*buflen < 0)
1743                 goto out_free;
1744         WRITE32(ncomponents);
1745
1746         while (ncomponents) {
1747                 struct dentry *dentry = components[ncomponents - 1];
1748                 unsigned int len = dentry->d_name.len;
1749
1750                 *buflen -= 4 + (XDR_QUADLEN(len) << 2);
1751                 if (*buflen < 0)
1752                         goto out_free;
1753                 WRITE32(len);
1754                 WRITEMEM(dentry->d_name.name, len);
1755                 dprintk("/%s", dentry->d_name.name);
1756                 dput(dentry);
1757                 ncomponents--;
1758         }
1759
1760         *pp = p;
1761         err = 0;
1762 out_free:
1763         dprintk(")\n");
1764         while (ncomponents)
1765                 dput(components[--ncomponents]);
1766         kfree(components);
1767         path_put(&cur);
1768         return err;
1769 }
1770
1771 static __be32 nfsd4_encode_fsloc_fsroot(struct svc_rqst *rqstp,
1772                 const struct path *path, __be32 **pp, int *buflen)
1773 {
1774         struct svc_export *exp_ps;
1775         __be32 res;
1776
1777         exp_ps = rqst_find_fsidzero_export(rqstp);
1778         if (IS_ERR(exp_ps))
1779                 return nfserrno(PTR_ERR(exp_ps));
1780         res = nfsd4_encode_path(&exp_ps->ex_path, path, pp, buflen);
1781         exp_put(exp_ps);
1782         return res;
1783 }
1784
1785 /*
1786  *  encode a fs_locations structure
1787  */
1788 static __be32 nfsd4_encode_fs_locations(struct svc_rqst *rqstp,
1789                                      struct svc_export *exp,
1790                                      __be32 **pp, int *buflen)
1791 {
1792         __be32 status;
1793         int i;
1794         __be32 *p = *pp;
1795         struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;
1796
1797         status = nfsd4_encode_fsloc_fsroot(rqstp, &exp->ex_path, &p, buflen);
1798         if (status)
1799                 return status;
1800         if ((*buflen -= 4) < 0)
1801                 return nfserr_resource;
1802         WRITE32(fslocs->locations_count);
1803         for (i=0; i<fslocs->locations_count; i++) {
1804                 status = nfsd4_encode_fs_location4(&fslocs->locations[i],
1805                                                    &p, buflen);
1806                 if (status)
1807                         return status;
1808         }
1809         *pp = p;
1810         return 0;
1811 }
1812
1813 static u32 nfs4_file_type(umode_t mode)
1814 {
1815         switch (mode & S_IFMT) {
1816         case S_IFIFO:   return NF4FIFO;
1817         case S_IFCHR:   return NF4CHR;
1818         case S_IFDIR:   return NF4DIR;
1819         case S_IFBLK:   return NF4BLK;
1820         case S_IFLNK:   return NF4LNK;
1821         case S_IFREG:   return NF4REG;
1822         case S_IFSOCK:  return NF4SOCK;
1823         default:        return NF4BAD;
1824         };
1825 }
1826
1827 static __be32
1828 nfsd4_encode_name(struct svc_rqst *rqstp, int whotype, uid_t id, int group,
1829                         __be32 **p, int *buflen)
1830 {
1831         int status;
1832
1833         if (*buflen < (XDR_QUADLEN(IDMAP_NAMESZ) << 2) + 4)
1834                 return nfserr_resource;
1835         if (whotype != NFS4_ACL_WHO_NAMED)
1836                 status = nfs4_acl_write_who(whotype, (u8 *)(*p + 1));
1837         else if (group)
1838                 status = nfsd_map_gid_to_name(rqstp, id, (u8 *)(*p + 1));
1839         else
1840                 status = nfsd_map_uid_to_name(rqstp, id, (u8 *)(*p + 1));
1841         if (status < 0)
1842                 return nfserrno(status);
1843         *p = xdr_encode_opaque(*p, NULL, status);
1844         *buflen -= (XDR_QUADLEN(status) << 2) + 4;
1845         BUG_ON(*buflen < 0);
1846         return 0;
1847 }
1848
1849 static inline __be32
1850 nfsd4_encode_user(struct svc_rqst *rqstp, uid_t uid, __be32 **p, int *buflen)
1851 {
1852         return nfsd4_encode_name(rqstp, NFS4_ACL_WHO_NAMED, uid, 0, p, buflen);
1853 }
1854
1855 static inline __be32
1856 nfsd4_encode_group(struct svc_rqst *rqstp, uid_t gid, __be32 **p, int *buflen)
1857 {
1858         return nfsd4_encode_name(rqstp, NFS4_ACL_WHO_NAMED, gid, 1, p, buflen);
1859 }
1860
1861 static inline __be32
1862 nfsd4_encode_aclname(struct svc_rqst *rqstp, int whotype, uid_t id, int group,
1863                 __be32 **p, int *buflen)
1864 {
1865         return nfsd4_encode_name(rqstp, whotype, id, group, p, buflen);
1866 }
1867
1868 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
1869                               FATTR4_WORD0_RDATTR_ERROR)
1870 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
1871
1872 static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err)
1873 {
1874         /* As per referral draft:  */
1875         if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS ||
1876             *bmval1 & ~WORD1_ABSENT_FS_ATTRS) {
1877                 if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR ||
1878                     *bmval0 & FATTR4_WORD0_FS_LOCATIONS)
1879                         *rdattr_err = NFSERR_MOVED;
1880                 else
1881                         return nfserr_moved;
1882         }
1883         *bmval0 &= WORD0_ABSENT_FS_ATTRS;
1884         *bmval1 &= WORD1_ABSENT_FS_ATTRS;
1885         return 0;
1886 }
1887
1888 /*
1889  * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
1890  * ourselves.
1891  *
1892  * @countp is the buffer size in _words_; upon successful return this becomes
1893  * replaced with the number of words written.
1894  */
1895 __be32
1896 nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
1897                 struct dentry *dentry, __be32 *buffer, int *countp, u32 *bmval,
1898                 struct svc_rqst *rqstp, int ignore_crossmnt)
1899 {
1900         u32 bmval0 = bmval[0];
1901         u32 bmval1 = bmval[1];
1902         u32 bmval2 = bmval[2];
1903         struct kstat stat;
1904         struct svc_fh tempfh;
1905         struct kstatfs statfs;
1906         int buflen = *countp << 2;
1907         __be32 *attrlenp;
1908         u32 dummy;
1909         u64 dummy64;
1910         u32 rdattr_err = 0;
1911         __be32 *p = buffer;
1912         __be32 status;
1913         int err;
1914         int aclsupport = 0;
1915         struct nfs4_acl *acl = NULL;
1916         struct nfsd4_compoundres *resp = rqstp->rq_resp;
1917         u32 minorversion = resp->cstate.minorversion;
1918         struct path path = {
1919                 .mnt    = exp->ex_path.mnt,
1920                 .dentry = dentry,
1921         };
1922
1923         BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1);
1924         BUG_ON(bmval0 & ~nfsd_suppattrs0(minorversion));
1925         BUG_ON(bmval1 & ~nfsd_suppattrs1(minorversion));
1926         BUG_ON(bmval2 & ~nfsd_suppattrs2(minorversion));
1927
1928         if (exp->ex_fslocs.migrated) {
1929                 BUG_ON(bmval[2]);
1930                 status = fattr_handle_absent_fs(&bmval0, &bmval1, &rdattr_err);
1931                 if (status)
1932                         goto out;
1933         }
1934
1935         err = vfs_getattr(exp->ex_path.mnt, dentry, &stat);
1936         if (err)
1937                 goto out_nfserr;
1938         if ((bmval0 & (FATTR4_WORD0_FILES_FREE | FATTR4_WORD0_FILES_TOTAL |
1939                         FATTR4_WORD0_MAXNAME)) ||
1940             (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |
1941                        FATTR4_WORD1_SPACE_TOTAL))) {
1942                 err = vfs_statfs(&path, &statfs);
1943                 if (err)
1944                         goto out_nfserr;
1945         }
1946         if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) {
1947                 fh_init(&tempfh, NFS4_FHSIZE);
1948                 status = fh_compose(&tempfh, exp, dentry, NULL);
1949                 if (status)
1950                         goto out;
1951                 fhp = &tempfh;
1952         }
1953         if (bmval0 & (FATTR4_WORD0_ACL | FATTR4_WORD0_ACLSUPPORT
1954                         | FATTR4_WORD0_SUPPORTED_ATTRS)) {
1955                 err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl);
1956                 aclsupport = (err == 0);
1957                 if (bmval0 & FATTR4_WORD0_ACL) {
1958                         if (err == -EOPNOTSUPP)
1959                                 bmval0 &= ~FATTR4_WORD0_ACL;
1960                         else if (err == -EINVAL) {
1961                                 status = nfserr_attrnotsupp;
1962                                 goto out;
1963                         } else if (err != 0)
1964                                 goto out_nfserr;
1965                 }
1966         }
1967
1968         if (bmval2) {
1969                 if ((buflen -= 16) < 0)
1970                         goto out_resource;
1971                 WRITE32(3);
1972                 WRITE32(bmval0);
1973                 WRITE32(bmval1);
1974                 WRITE32(bmval2);
1975         } else if (bmval1) {
1976                 if ((buflen -= 12) < 0)
1977                         goto out_resource;
1978                 WRITE32(2);
1979                 WRITE32(bmval0);
1980                 WRITE32(bmval1);
1981         } else {
1982                 if ((buflen -= 8) < 0)
1983                         goto out_resource;
1984                 WRITE32(1);
1985                 WRITE32(bmval0);
1986         }
1987         attrlenp = p++;                /* to be backfilled later */
1988
1989         if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
1990                 u32 word0 = nfsd_suppattrs0(minorversion);
1991                 u32 word1 = nfsd_suppattrs1(minorversion);
1992                 u32 word2 = nfsd_suppattrs2(minorversion);
1993
1994                 if (!aclsupport)
1995                         word0 &= ~FATTR4_WORD0_ACL;
1996                 if (!word2) {
1997                         if ((buflen -= 12) < 0)
1998                                 goto out_resource;
1999                         WRITE32(2);
2000                         WRITE32(word0);
2001                         WRITE32(word1);
2002                 } else {
2003                         if ((buflen -= 16) < 0)
2004                                 goto out_resource;
2005                         WRITE32(3);
2006                         WRITE32(word0);
2007                         WRITE32(word1);
2008                         WRITE32(word2);
2009                 }
2010         }
2011         if (bmval0 & FATTR4_WORD0_TYPE) {
2012                 if ((buflen -= 4) < 0)
2013                         goto out_resource;
2014                 dummy = nfs4_file_type(stat.mode);
2015                 if (dummy == NF4BAD)
2016                         goto out_serverfault;
2017                 WRITE32(dummy);
2018         }
2019         if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) {
2020                 if ((buflen -= 4) < 0)
2021                         goto out_resource;
2022                 if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)
2023                         WRITE32(NFS4_FH_PERSISTENT);
2024                 else
2025                         WRITE32(NFS4_FH_PERSISTENT|NFS4_FH_VOL_RENAME);
2026         }
2027         if (bmval0 & FATTR4_WORD0_CHANGE) {
2028                 if ((buflen -= 8) < 0)
2029                         goto out_resource;
2030                 write_change(&p, &stat, dentry->d_inode);
2031         }
2032         if (bmval0 & FATTR4_WORD0_SIZE) {
2033                 if ((buflen -= 8) < 0)
2034                         goto out_resource;
2035                 WRITE64(stat.size);
2036         }
2037         if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) {
2038                 if ((buflen -= 4) < 0)
2039                         goto out_resource;
2040                 WRITE32(1);
2041         }
2042         if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) {
2043                 if ((buflen -= 4) < 0)
2044                         goto out_resource;
2045                 WRITE32(1);
2046         }
2047         if (bmval0 & FATTR4_WORD0_NAMED_ATTR) {
2048                 if ((buflen -= 4) < 0)
2049                         goto out_resource;
2050                 WRITE32(0);
2051         }
2052         if (bmval0 & FATTR4_WORD0_FSID) {
2053                 if ((buflen -= 16) < 0)
2054                         goto out_resource;
2055                 if (exp->ex_fslocs.migrated) {
2056                         WRITE64(NFS4_REFERRAL_FSID_MAJOR);
2057                         WRITE64(NFS4_REFERRAL_FSID_MINOR);
2058                 } else switch(fsid_source(fhp)) {
2059                 case FSIDSOURCE_FSID:
2060                         WRITE64((u64)exp->ex_fsid);
2061                         WRITE64((u64)0);
2062                         break;
2063                 case FSIDSOURCE_DEV:
2064                         WRITE32(0);
2065                         WRITE32(MAJOR(stat.dev));
2066                         WRITE32(0);
2067                         WRITE32(MINOR(stat.dev));
2068                         break;
2069                 case FSIDSOURCE_UUID:
2070                         WRITEMEM(exp->ex_uuid, 16);
2071                         break;
2072                 }
2073         }
2074         if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) {
2075                 if ((buflen -= 4) < 0)
2076                         goto out_resource;
2077                 WRITE32(0);
2078         }
2079         if (bmval0 & FATTR4_WORD0_LEASE_TIME) {
2080                 if ((buflen -= 4) < 0)
2081                         goto out_resource;
2082                 WRITE32(nfsd4_lease);
2083         }
2084         if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) {
2085                 if ((buflen -= 4) < 0)
2086                         goto out_resource;
2087                 WRITE32(rdattr_err);
2088         }
2089         if (bmval0 & FATTR4_WORD0_ACL) {
2090                 struct nfs4_ace *ace;
2091
2092                 if (acl == NULL) {
2093                         if ((buflen -= 4) < 0)
2094                                 goto out_resource;
2095
2096                         WRITE32(0);
2097                         goto out_acl;
2098                 }
2099                 if ((buflen -= 4) < 0)
2100                         goto out_resource;
2101                 WRITE32(acl->naces);
2102
2103                 for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {
2104                         if ((buflen -= 4*3) < 0)
2105                                 goto out_resource;
2106                         WRITE32(ace->type);
2107                         WRITE32(ace->flag);
2108                         WRITE32(ace->access_mask & NFS4_ACE_MASK_ALL);
2109                         status = nfsd4_encode_aclname(rqstp, ace->whotype,
2110                                 ace->who, ace->flag & NFS4_ACE_IDENTIFIER_GROUP,
2111                                 &p, &buflen);
2112                         if (status == nfserr_resource)
2113                                 goto out_resource;
2114                         if (status)
2115                                 goto out;
2116                 }
2117         }
2118 out_acl:
2119         if (bmval0 & FATTR4_WORD0_ACLSUPPORT) {
2120                 if ((buflen -= 4) < 0)
2121                         goto out_resource;
2122                 WRITE32(aclsupport ?
2123                         ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0);
2124         }
2125         if (bmval0 & FATTR4_WORD0_CANSETTIME) {
2126                 if ((buflen -= 4) < 0)
2127                         goto out_resource;
2128                 WRITE32(1);
2129         }
2130         if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) {
2131                 if ((buflen -= 4) < 0)
2132                         goto out_resource;
2133                 WRITE32(1);
2134         }
2135         if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) {
2136                 if ((buflen -= 4) < 0)
2137                         goto out_resource;
2138                 WRITE32(1);
2139         }
2140         if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) {
2141                 if ((buflen -= 4) < 0)
2142                         goto out_resource;
2143                 WRITE32(1);
2144         }
2145         if (bmval0 & FATTR4_WORD0_FILEHANDLE) {
2146                 buflen -= (XDR_QUADLEN(fhp->fh_handle.fh_size) << 2) + 4;
2147                 if (buflen < 0)
2148                         goto out_resource;
2149                 WRITE32(fhp->fh_handle.fh_size);
2150                 WRITEMEM(&fhp->fh_handle.fh_base, fhp->fh_handle.fh_size);
2151         }
2152         if (bmval0 & FATTR4_WORD0_FILEID) {
2153                 if ((buflen -= 8) < 0)
2154                         goto out_resource;
2155                 WRITE64(stat.ino);
2156         }
2157         if (bmval0 & FATTR4_WORD0_FILES_AVAIL) {
2158                 if ((buflen -= 8) < 0)
2159                         goto out_resource;
2160                 WRITE64((u64) statfs.f_ffree);
2161         }
2162         if (bmval0 & FATTR4_WORD0_FILES_FREE) {
2163                 if ((buflen -= 8) < 0)
2164                         goto out_resource;
2165                 WRITE64((u64) statfs.f_ffree);
2166         }
2167         if (bmval0 & FATTR4_WORD0_FILES_TOTAL) {
2168                 if ((buflen -= 8) < 0)
2169                         goto out_resource;
2170                 WRITE64((u64) statfs.f_files);
2171         }
2172         if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) {
2173                 status = nfsd4_encode_fs_locations(rqstp, exp, &p, &buflen);
2174                 if (status == nfserr_resource)
2175                         goto out_resource;
2176                 if (status)
2177                         goto out;
2178         }
2179         if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) {
2180                 if ((buflen -= 4) < 0)
2181                         goto out_resource;
2182                 WRITE32(1);
2183         }
2184         if (bmval0 & FATTR4_WORD0_MAXFILESIZE) {
2185                 if ((buflen -= 8) < 0)
2186                         goto out_resource;
2187                 WRITE64(~(u64)0);
2188         }
2189         if (bmval0 & FATTR4_WORD0_MAXLINK) {
2190                 if ((buflen -= 4) < 0)
2191                         goto out_resource;
2192                 WRITE32(255);
2193         }
2194         if (bmval0 & FATTR4_WORD0_MAXNAME) {
2195                 if ((buflen -= 4) < 0)
2196                         goto out_resource;
2197                 WRITE32(statfs.f_namelen);
2198         }
2199         if (bmval0 & FATTR4_WORD0_MAXREAD) {
2200                 if ((buflen -= 8) < 0)
2201                         goto out_resource;
2202                 WRITE64((u64) svc_max_payload(rqstp));
2203         }
2204         if (bmval0 & FATTR4_WORD0_MAXWRITE) {
2205                 if ((buflen -= 8) < 0)
2206                         goto out_resource;
2207                 WRITE64((u64) svc_max_payload(rqstp));
2208         }
2209         if (bmval1 & FATTR4_WORD1_MODE) {
2210                 if ((buflen -= 4) < 0)
2211                         goto out_resource;
2212                 WRITE32(stat.mode & S_IALLUGO);
2213         }
2214         if (bmval1 & FATTR4_WORD1_NO_TRUNC) {
2215                 if ((buflen -= 4) < 0)
2216                         goto out_resource;
2217                 WRITE32(1);
2218         }
2219         if (bmval1 & FATTR4_WORD1_NUMLINKS) {
2220                 if ((buflen -= 4) < 0)
2221                         goto out_resource;
2222                 WRITE32(stat.nlink);
2223         }
2224         if (bmval1 & FATTR4_WORD1_OWNER) {
2225                 status = nfsd4_encode_user(rqstp, stat.uid, &p, &buflen);
2226                 if (status == nfserr_resource)
2227                         goto out_resource;
2228                 if (status)
2229                         goto out;
2230         }
2231         if (bmval1 & FATTR4_WORD1_OWNER_GROUP) {
2232                 status = nfsd4_encode_group(rqstp, stat.gid, &p, &buflen);
2233                 if (status == nfserr_resource)
2234                         goto out_resource;
2235                 if (status)
2236                         goto out;
2237         }
2238         if (bmval1 & FATTR4_WORD1_RAWDEV) {
2239                 if ((buflen -= 8) < 0)
2240                         goto out_resource;
2241                 WRITE32((u32) MAJOR(stat.rdev));
2242                 WRITE32((u32) MINOR(stat.rdev));
2243         }
2244         if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) {
2245                 if ((buflen -= 8) < 0)
2246                         goto out_resource;
2247                 dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize;
2248                 WRITE64(dummy64);
2249         }
2250         if (bmval1 & FATTR4_WORD1_SPACE_FREE) {
2251                 if ((buflen -= 8) < 0)
2252                         goto out_resource;
2253                 dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize;
2254                 WRITE64(dummy64);
2255         }
2256         if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) {
2257                 if ((buflen -= 8) < 0)
2258                         goto out_resource;
2259                 dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize;
2260                 WRITE64(dummy64);
2261         }
2262         if (bmval1 & FATTR4_WORD1_SPACE_USED) {
2263                 if ((buflen -= 8) < 0)
2264                         goto out_resource;
2265                 dummy64 = (u64)stat.blocks << 9;
2266                 WRITE64(dummy64);
2267         }
2268         if (bmval1 & FATTR4_WORD1_TIME_ACCESS) {
2269                 if ((buflen -= 12) < 0)
2270                         goto out_resource;
2271                 WRITE32(0);
2272                 WRITE32(stat.atime.tv_sec);
2273                 WRITE32(stat.atime.tv_nsec);
2274         }
2275         if (bmval1 & FATTR4_WORD1_TIME_DELTA) {
2276                 if ((buflen -= 12) < 0)
2277                         goto out_resource;
2278                 WRITE32(0);
2279                 WRITE32(1);
2280                 WRITE32(0);
2281         }
2282         if (bmval1 & FATTR4_WORD1_TIME_METADATA) {
2283                 if ((buflen -= 12) < 0)
2284                         goto out_resource;
2285                 WRITE32(0);
2286                 WRITE32(stat.ctime.tv_sec);
2287                 WRITE32(stat.ctime.tv_nsec);
2288         }
2289         if (bmval1 & FATTR4_WORD1_TIME_MODIFY) {
2290                 if ((buflen -= 12) < 0)
2291                         goto out_resource;
2292                 WRITE32(0);
2293                 WRITE32(stat.mtime.tv_sec);
2294                 WRITE32(stat.mtime.tv_nsec);
2295         }
2296         if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) {
2297                 if ((buflen -= 8) < 0)
2298                         goto out_resource;
2299                 /*
2300                  * Get parent's attributes if not ignoring crossmount
2301                  * and this is the root of a cross-mounted filesystem.
2302                  */
2303                 if (ignore_crossmnt == 0 &&
2304                     dentry == exp->ex_path.mnt->mnt_root) {
2305                         struct path path = exp->ex_path;
2306                         path_get(&path);
2307                         while (follow_up(&path)) {
2308                                 if (path.dentry != path.mnt->mnt_root)
2309                                         break;
2310                         }
2311                         err = vfs_getattr(path.mnt, path.dentry, &stat);
2312                         path_put(&path);
2313                         if (err)
2314                                 goto out_nfserr;
2315                 }
2316                 WRITE64(stat.ino);
2317         }
2318         if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
2319                 WRITE32(3);
2320                 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0);
2321                 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD1);
2322                 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD2);
2323         }
2324
2325         *attrlenp = htonl((char *)p - (char *)attrlenp - 4);
2326         *countp = p - buffer;
2327         status = nfs_ok;
2328
2329 out:
2330         kfree(acl);
2331         if (fhp == &tempfh)
2332                 fh_put(&tempfh);
2333         return status;
2334 out_nfserr:
2335         status = nfserrno(err);
2336         goto out;
2337 out_resource:
2338         *countp = 0;
2339         status = nfserr_resource;
2340         goto out;
2341 out_serverfault:
2342         status = nfserr_serverfault;
2343         goto out;
2344 }
2345
2346 static inline int attributes_need_mount(u32 *bmval)
2347 {
2348         if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME))
2349                 return 1;
2350         if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID)
2351                 return 1;
2352         return 0;
2353 }
2354
2355 static __be32
2356 nfsd4_encode_dirent_fattr(struct nfsd4_readdir *cd,
2357                 const char *name, int namlen, __be32 *p, int *buflen)
2358 {
2359         struct svc_export *exp = cd->rd_fhp->fh_export;
2360         struct dentry *dentry;
2361         __be32 nfserr;
2362         int ignore_crossmnt = 0;
2363
2364         dentry = lookup_one_len(name, cd->rd_fhp->fh_dentry, namlen);
2365         if (IS_ERR(dentry))
2366                 return nfserrno(PTR_ERR(dentry));
2367         if (!dentry->d_inode) {
2368                 /*
2369                  * nfsd_buffered_readdir drops the i_mutex between
2370                  * readdir and calling this callback, leaving a window
2371                  * where this directory entry could have gone away.
2372                  */
2373                 dput(dentry);
2374                 return nfserr_noent;
2375         }
2376
2377         exp_get(exp);
2378         /*
2379          * In the case of a mountpoint, the client may be asking for
2380          * attributes that are only properties of the underlying filesystem
2381          * as opposed to the cross-mounted file system. In such a case,
2382          * we will not follow the cross mount and will fill the attribtutes
2383          * directly from the mountpoint dentry.
2384          */
2385         if (nfsd_mountpoint(dentry, exp)) {
2386                 int err;
2387
2388                 if (!(exp->ex_flags & NFSEXP_V4ROOT)
2389                                 && !attributes_need_mount(cd->rd_bmval)) {
2390                         ignore_crossmnt = 1;
2391                         goto out_encode;
2392                 }
2393                 /*
2394                  * Why the heck aren't we just using nfsd_lookup??
2395                  * Different "."/".." handling?  Something else?
2396                  * At least, add a comment here to explain....
2397                  */
2398                 err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);
2399                 if (err) {
2400                         nfserr = nfserrno(err);
2401                         goto out_put;
2402                 }
2403                 nfserr = check_nfsd_access(exp, cd->rd_rqstp);
2404                 if (nfserr)
2405                         goto out_put;
2406
2407         }
2408 out_encode:
2409         nfserr = nfsd4_encode_fattr(NULL, exp, dentry, p, buflen, cd->rd_bmval,
2410                                         cd->rd_rqstp, ignore_crossmnt);
2411 out_put:
2412         dput(dentry);
2413         exp_put(exp);
2414         return nfserr;
2415 }
2416
2417 static __be32 *
2418 nfsd4_encode_rdattr_error(__be32 *p, int buflen, __be32 nfserr)
2419 {
2420         __be32 *attrlenp;
2421
2422         if (buflen < 6)
2423                 return NULL;
2424         *p++ = htonl(2);
2425         *p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */
2426         *p++ = htonl(0);                         /* bmval1 */
2427
2428         attrlenp = p++;
2429         *p++ = nfserr;       /* no htonl */
2430         *attrlenp = htonl((char *)p - (char *)attrlenp - 4);
2431         return p;
2432 }
2433
2434 static int
2435 nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,
2436                     loff_t offset, u64 ino, unsigned int d_type)
2437 {
2438         struct readdir_cd *ccd = ccdv;
2439         struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);
2440         int buflen;
2441         __be32 *p = cd->buffer;
2442         __be32 *cookiep;
2443         __be32 nfserr = nfserr_toosmall;
2444
2445         /* In nfsv4, "." and ".." never make it onto the wire.. */
2446         if (name && isdotent(name, namlen)) {
2447                 cd->common.err = nfs_ok;
2448                 return 0;
2449         }
2450
2451         if (cd->offset)
2452                 xdr_encode_hyper(cd->offset, (u64) offset);
2453
2454         buflen = cd->buflen - 4 - XDR_QUADLEN(namlen);
2455         if (buflen < 0)
2456                 goto fail;
2457
2458         *p++ = xdr_one;                             /* mark entry present */
2459         cookiep = p;
2460         p = xdr_encode_hyper(p, NFS_OFFSET_MAX);    /* offset of next entry */
2461         p = xdr_encode_array(p, name, namlen);      /* name length & name */
2462
2463         nfserr = nfsd4_encode_dirent_fattr(cd, name, namlen, p, &buflen);
2464         switch (nfserr) {
2465         case nfs_ok:
2466                 p += buflen;
2467                 break;
2468         case nfserr_resource:
2469                 nfserr = nfserr_toosmall;
2470                 goto fail;
2471         case nfserr_noent:
2472                 goto skip_entry;
2473         default:
2474                 /*
2475                  * If the client requested the RDATTR_ERROR attribute,
2476                  * we stuff the error code into this attribute
2477                  * and continue.  If this attribute was not requested,
2478                  * then in accordance with the spec, we fail the
2479                  * entire READDIR operation(!)
2480                  */
2481                 if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))
2482                         goto fail;
2483                 p = nfsd4_encode_rdattr_error(p, buflen, nfserr);
2484                 if (p == NULL) {
2485                         nfserr = nfserr_toosmall;
2486                         goto fail;
2487                 }
2488         }
2489         cd->buflen -= (p - cd->buffer);
2490         cd->buffer = p;
2491         cd->offset = cookiep;
2492 skip_entry:
2493         cd->common.err = nfs_ok;
2494         return 0;
2495 fail:
2496         cd->common.err = nfserr;
2497         return -EINVAL;
2498 }
2499
2500 static void
2501 nfsd4_encode_stateid(struct nfsd4_compoundres *resp, stateid_t *sid)
2502 {
2503         __be32 *p;
2504
2505         RESERVE_SPACE(sizeof(stateid_t));
2506         WRITE32(sid->si_generation);
2507         WRITEMEM(&sid->si_opaque, sizeof(stateid_opaque_t));
2508         ADJUST_ARGS();
2509 }
2510
2511 static __be32
2512 nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access)
2513 {
2514         __be32 *p;
2515
2516         if (!nfserr) {
2517                 RESERVE_SPACE(8);
2518                 WRITE32(access->ac_supported);
2519                 WRITE32(access->ac_resp_access);
2520                 ADJUST_ARGS();
2521         }
2522         return nfserr;
2523 }
2524
2525 static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)
2526 {
2527         __be32 *p;
2528
2529         if (!nfserr) {
2530                 RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 8);
2531                 WRITEMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);
2532                 WRITE32(bcts->dir);
2533                 /* XXX: ? */
2534                 WRITE32(0);
2535                 ADJUST_ARGS();
2536         }
2537         return nfserr;
2538 }
2539
2540 static __be32
2541 nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close)
2542 {
2543         ENCODE_SEQID_OP_HEAD;
2544
2545         if (!nfserr)
2546                 nfsd4_encode_stateid(resp, &close->cl_stateid);
2547
2548         encode_seqid_op_tail(resp, save, nfserr);
2549         return nfserr;
2550 }
2551
2552
2553 static __be32
2554 nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit)
2555 {
2556         __be32 *p;
2557
2558         if (!nfserr) {
2559                 RESERVE_SPACE(8);
2560                 WRITEMEM(commit->co_verf.data, 8);
2561                 ADJUST_ARGS();
2562         }
2563         return nfserr;
2564 }
2565
2566 static __be32
2567 nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create)
2568 {
2569         __be32 *p;
2570
2571         if (!nfserr) {
2572                 RESERVE_SPACE(32);
2573                 write_cinfo(&p, &create->cr_cinfo);
2574                 WRITE32(2);
2575                 WRITE32(create->cr_bmval[0]);
2576                 WRITE32(create->cr_bmval[1]);
2577                 ADJUST_ARGS();
2578         }
2579         return nfserr;
2580 }
2581
2582 static __be32
2583 nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr)
2584 {
2585         struct svc_fh *fhp = getattr->ga_fhp;
2586         int buflen;
2587
2588         if (nfserr)
2589                 return nfserr;
2590
2591         buflen = resp->end - resp->p - (COMPOUND_ERR_SLACK_SPACE >> 2);
2592         nfserr = nfsd4_encode_fattr(fhp, fhp->fh_export, fhp->fh_dentry,
2593                                     resp->p, &buflen, getattr->ga_bmval,
2594                                     resp->rqstp, 0);
2595         if (!nfserr)
2596                 resp->p += buflen;
2597         return nfserr;
2598 }
2599
2600 static __be32
2601 nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp)
2602 {
2603         struct svc_fh *fhp = *fhpp;
2604         unsigned int len;
2605         __be32 *p;
2606
2607         if (!nfserr) {
2608                 len = fhp->fh_handle.fh_size;
2609                 RESERVE_SPACE(len + 4);
2610                 WRITE32(len);
2611                 WRITEMEM(&fhp->fh_handle.fh_base, len);
2612                 ADJUST_ARGS();
2613         }
2614         return nfserr;
2615 }
2616
2617 /*
2618 * Including all fields other than the name, a LOCK4denied structure requires
2619 *   8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
2620 */
2621 static void
2622 nfsd4_encode_lock_denied(struct nfsd4_compoundres *resp, struct nfsd4_lock_denied *ld)
2623 {
2624         struct xdr_netobj *conf = &ld->ld_owner;
2625         __be32 *p;
2626
2627         RESERVE_SPACE(32 + XDR_LEN(conf->len));
2628         WRITE64(ld->ld_start);
2629         WRITE64(ld->ld_length);
2630         WRITE32(ld->ld_type);
2631         if (conf->len) {
2632                 WRITEMEM(&ld->ld_clientid, 8);
2633                 WRITE32(conf->len);
2634                 WRITEMEM(conf->data, conf->len);
2635                 kfree(conf->data);
2636         }  else {  /* non - nfsv4 lock in conflict, no clientid nor owner */
2637                 WRITE64((u64)0); /* clientid */
2638                 WRITE32(0); /* length of owner name */
2639         }
2640         ADJUST_ARGS();
2641 }
2642
2643 static __be32
2644 nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock)
2645 {
2646         ENCODE_SEQID_OP_HEAD;
2647
2648         if (!nfserr)
2649                 nfsd4_encode_stateid(resp, &lock->lk_resp_stateid);
2650         else if (nfserr == nfserr_denied)
2651                 nfsd4_encode_lock_denied(resp, &lock->lk_denied);
2652
2653         encode_seqid_op_tail(resp, save, nfserr);
2654         return nfserr;
2655 }
2656
2657 static __be32
2658 nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt)
2659 {
2660         if (nfserr == nfserr_denied)
2661                 nfsd4_encode_lock_denied(resp, &lockt->lt_denied);
2662         return nfserr;
2663 }
2664
2665 static __be32
2666 nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku)
2667 {
2668         ENCODE_SEQID_OP_HEAD;
2669
2670         if (!nfserr)
2671                 nfsd4_encode_stateid(resp, &locku->lu_stateid);
2672
2673         encode_seqid_op_tail(resp, save, nfserr);
2674         return nfserr;
2675 }
2676
2677
2678 static __be32
2679 nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link)
2680 {
2681         __be32 *p;
2682
2683         if (!nfserr) {
2684                 RESERVE_SPACE(20);
2685                 write_cinfo(&p, &link->li_cinfo);
2686                 ADJUST_ARGS();
2687         }
2688         return nfserr;
2689 }
2690
2691
2692 static __be32
2693 nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open)
2694 {
2695         __be32 *p;
2696         ENCODE_SEQID_OP_HEAD;
2697
2698         if (nfserr)
2699                 goto out;
2700
2701         nfsd4_encode_stateid(resp, &open->op_stateid);
2702         RESERVE_SPACE(40);
2703         write_cinfo(&p, &open->op_cinfo);
2704         WRITE32(open->op_rflags);
2705         WRITE32(2);
2706         WRITE32(open->op_bmval[0]);
2707         WRITE32(open->op_bmval[1]);
2708         WRITE32(open->op_delegate_type);
2709         ADJUST_ARGS();
2710
2711         switch (open->op_delegate_type) {
2712         case NFS4_OPEN_DELEGATE_NONE:
2713                 break;
2714         case NFS4_OPEN_DELEGATE_READ:
2715                 nfsd4_encode_stateid(resp, &open->op_delegate_stateid);
2716                 RESERVE_SPACE(20);
2717                 WRITE32(open->op_recall);
2718
2719                 /*
2720                  * TODO: ACE's in delegations
2721                  */
2722                 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
2723                 WRITE32(0);
2724                 WRITE32(0);
2725                 WRITE32(0);   /* XXX: is NULL principal ok? */
2726                 ADJUST_ARGS();
2727                 break;
2728         case NFS4_OPEN_DELEGATE_WRITE:
2729                 nfsd4_encode_stateid(resp, &open->op_delegate_stateid);
2730                 RESERVE_SPACE(32);
2731                 WRITE32(0);
2732
2733                 /*
2734                  * TODO: space_limit's in delegations
2735                  */
2736                 WRITE32(NFS4_LIMIT_SIZE);
2737                 WRITE32(~(u32)0);
2738                 WRITE32(~(u32)0);
2739
2740                 /*
2741                  * TODO: ACE's in delegations
2742                  */
2743                 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
2744                 WRITE32(0);
2745                 WRITE32(0);
2746                 WRITE32(0);   /* XXX: is NULL principal ok? */
2747                 ADJUST_ARGS();
2748                 break;
2749         default:
2750                 BUG();
2751         }
2752         /* XXX save filehandle here */
2753 out:
2754         encode_seqid_op_tail(resp, save, nfserr);
2755         return nfserr;
2756 }
2757
2758 static __be32
2759 nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc)
2760 {
2761         ENCODE_SEQID_OP_HEAD;
2762
2763         if (!nfserr)
2764                 nfsd4_encode_stateid(resp, &oc->oc_resp_stateid);
2765
2766         encode_seqid_op_tail(resp, save, nfserr);
2767         return nfserr;
2768 }
2769
2770 static __be32
2771 nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od)
2772 {
2773         ENCODE_SEQID_OP_HEAD;
2774
2775         if (!nfserr)
2776                 nfsd4_encode_stateid(resp, &od->od_stateid);
2777
2778         encode_seqid_op_tail(resp, save, nfserr);
2779         return nfserr;
2780 }
2781
2782 static __be32
2783 nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,
2784                   struct nfsd4_read *read)
2785 {
2786         u32 eof;
2787         int v, pn;
2788         unsigned long maxcount;
2789         long len;
2790         __be32 *p;
2791
2792         if (nfserr)
2793                 return nfserr;
2794         if (resp->xbuf->page_len)
2795                 return nfserr_resource;
2796
2797         RESERVE_SPACE(8); /* eof flag and byte count */
2798
2799         maxcount = svc_max_payload(resp->rqstp);
2800         if (maxcount > read->rd_length)
2801                 maxcount = read->rd_length;
2802
2803         len = maxcount;
2804         v = 0;
2805         while (len > 0) {
2806                 pn = resp->rqstp->rq_resused++;
2807                 resp->rqstp->rq_vec[v].iov_base =
2808                         page_address(resp->rqstp->rq_respages[pn]);
2809                 resp->rqstp->rq_vec[v].iov_len =
2810                         len < PAGE_SIZE ? len : PAGE_SIZE;
2811                 v++;
2812                 len -= PAGE_SIZE;
2813         }
2814         read->rd_vlen = v;
2815
2816         nfserr = nfsd_read_file(read->rd_rqstp, read->rd_fhp, read->rd_filp,
2817                         read->rd_offset, resp->rqstp->rq_vec, read->rd_vlen,
2818                         &maxcount);
2819
2820         if (nfserr)
2821                 return nfserr;
2822         eof = (read->rd_offset + maxcount >=
2823                read->rd_fhp->fh_dentry->d_inode->i_size);
2824
2825         WRITE32(eof);
2826         WRITE32(maxcount);
2827         ADJUST_ARGS();
2828         resp->xbuf->head[0].iov_len = (char*)p
2829                                         - (char*)resp->xbuf->head[0].iov_base;
2830         resp->xbuf->page_len = maxcount;
2831
2832         /* Use rest of head for padding and remaining ops: */
2833         resp->xbuf->tail[0].iov_base = p;
2834         resp->xbuf->tail[0].iov_len = 0;
2835         if (maxcount&3) {
2836                 RESERVE_SPACE(4);
2837                 WRITE32(0);
2838                 resp->xbuf->tail[0].iov_base += maxcount&3;
2839                 resp->xbuf->tail[0].iov_len = 4 - (maxcount&3);
2840                 ADJUST_ARGS();
2841         }
2842         return 0;
2843 }
2844
2845 static __be32
2846 nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink)
2847 {
2848         int maxcount;
2849         char *page;
2850         __be32 *p;
2851
2852         if (nfserr)
2853                 return nfserr;
2854         if (resp->xbuf->page_len)
2855                 return nfserr_resource;
2856
2857         page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused++]);
2858
2859         maxcount = PAGE_SIZE;
2860         RESERVE_SPACE(4);
2861
2862         /*
2863          * XXX: By default, the ->readlink() VFS op will truncate symlinks
2864          * if they would overflow the buffer.  Is this kosher in NFSv4?  If
2865          * not, one easy fix is: if ->readlink() precisely fills the buffer,
2866          * assume that truncation occurred, and return NFS4ERR_RESOURCE.
2867          */
2868         nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, page, &maxcount);
2869         if (nfserr == nfserr_isdir)
2870                 return nfserr_inval;
2871         if (nfserr)
2872                 return nfserr;
2873
2874         WRITE32(maxcount);
2875         ADJUST_ARGS();
2876         resp->xbuf->head[0].iov_len = (char*)p
2877                                 - (char*)resp->xbuf->head[0].iov_base;
2878         resp->xbuf->page_len = maxcount;
2879
2880         /* Use rest of head for padding and remaining ops: */
2881         resp->xbuf->tail[0].iov_base = p;
2882         resp->xbuf->tail[0].iov_len = 0;
2883         if (maxcount&3) {
2884                 RESERVE_SPACE(4);
2885                 WRITE32(0);
2886                 resp->xbuf->tail[0].iov_base += maxcount&3;
2887                 resp->xbuf->tail[0].iov_len = 4 - (maxcount&3);
2888                 ADJUST_ARGS();
2889         }
2890         return 0;
2891 }
2892
2893 static __be32
2894 nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir)
2895 {
2896         int maxcount;
2897         loff_t offset;
2898         __be32 *page, *savep, *tailbase;
2899         __be32 *p;
2900
2901         if (nfserr)
2902                 return nfserr;
2903         if (resp->xbuf->page_len)
2904                 return nfserr_resource;
2905
2906         RESERVE_SPACE(8);  /* verifier */
2907         savep = p;
2908
2909         /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
2910         WRITE32(0);
2911         WRITE32(0);
2912         ADJUST_ARGS();
2913         resp->xbuf->head[0].iov_len = ((char*)resp->p) - (char*)resp->xbuf->head[0].iov_base;
2914         tailbase = p;
2915
2916         maxcount = PAGE_SIZE;
2917         if (maxcount > readdir->rd_maxcount)
2918                 maxcount = readdir->rd_maxcount;
2919
2920         /*
2921          * Convert from bytes to words, account for the two words already
2922          * written, make sure to leave two words at the end for the next
2923          * pointer and eof field.
2924          */
2925         maxcount = (maxcount >> 2) - 4;
2926         if (maxcount < 0) {
2927                 nfserr =  nfserr_toosmall;
2928                 goto err_no_verf;
2929         }
2930
2931         page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused++]);
2932         readdir->common.err = 0;
2933         readdir->buflen = maxcount;
2934         readdir->buffer = page;
2935         readdir->offset = NULL;
2936
2937         offset = readdir->rd_cookie;
2938         nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp,
2939                               &offset,
2940                               &readdir->common, nfsd4_encode_dirent);
2941         if (nfserr == nfs_ok &&
2942             readdir->common.err == nfserr_toosmall &&
2943             readdir->buffer == page)
2944                 nfserr = nfserr_toosmall;
2945         if (nfserr)
2946                 goto err_no_verf;
2947
2948         if (readdir->offset)
2949                 xdr_encode_hyper(readdir->offset, offset);
2950
2951         p = readdir->buffer;
2952         *p++ = 0;       /* no more entries */
2953         *p++ = htonl(readdir->common.err == nfserr_eof);
2954         resp->xbuf->page_len = ((char*)p) - (char*)page_address(
2955                 resp->rqstp->rq_respages[resp->rqstp->rq_resused-1]);
2956
2957         /* Use rest of head for padding and remaining ops: */
2958         resp->xbuf->tail[0].iov_base = tailbase;
2959         resp->xbuf->tail[0].iov_len = 0;
2960         resp->p = resp->xbuf->tail[0].iov_base;
2961         resp->end = resp->p + (PAGE_SIZE - resp->xbuf->head[0].iov_len)/4;
2962
2963         return 0;
2964 err_no_verf:
2965         p = savep;
2966         ADJUST_ARGS();
2967         return nfserr;
2968 }
2969
2970 static __be32
2971 nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove)
2972 {
2973         __be32 *p;
2974
2975         if (!nfserr) {
2976                 RESERVE_SPACE(20);
2977                 write_cinfo(&p, &remove->rm_cinfo);
2978                 ADJUST_ARGS();
2979         }
2980         return nfserr;
2981 }
2982
2983 static __be32
2984 nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename)
2985 {
2986         __be32 *p;
2987
2988         if (!nfserr) {
2989                 RESERVE_SPACE(40);
2990                 write_cinfo(&p, &rename->rn_sinfo);
2991                 write_cinfo(&p, &rename->rn_tinfo);
2992                 ADJUST_ARGS();
2993         }
2994         return nfserr;
2995 }
2996
2997 static __be32
2998 nfsd4_do_encode_secinfo(struct nfsd4_compoundres *resp,
2999                          __be32 nfserr,struct svc_export *exp)
3000 {
3001         int i = 0;
3002         u32 nflavs;
3003         struct exp_flavor_info *flavs;
3004         struct exp_flavor_info def_flavs[2];
3005         __be32 *p;
3006
3007         if (nfserr)
3008                 goto out;
3009         if (exp->ex_nflavors) {
3010                 flavs = exp->ex_flavors;
3011                 nflavs = exp->ex_nflavors;
3012         } else { /* Handling of some defaults in absence of real secinfo: */
3013                 flavs = def_flavs;
3014                 if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {
3015                         nflavs = 2;
3016                         flavs[0].pseudoflavor = RPC_AUTH_UNIX;
3017                         flavs[1].pseudoflavor = RPC_AUTH_NULL;
3018                 } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {
3019                         nflavs = 1;
3020                         flavs[0].pseudoflavor
3021                                         = svcauth_gss_flavor(exp->ex_client);
3022                 } else {
3023                         nflavs = 1;
3024                         flavs[0].pseudoflavor
3025                                         = exp->ex_client->flavour->flavour;
3026                 }
3027         }
3028
3029         RESERVE_SPACE(4);
3030         WRITE32(nflavs);
3031         ADJUST_ARGS();
3032         for (i = 0; i < nflavs; i++) {
3033                 u32 flav = flavs[i].pseudoflavor;
3034                 struct gss_api_mech *gm = gss_mech_get_by_pseudoflavor(flav);
3035
3036                 if (gm) {
3037                         RESERVE_SPACE(4);
3038                         WRITE32(RPC_AUTH_GSS);
3039                         ADJUST_ARGS();
3040                         RESERVE_SPACE(4 + gm->gm_oid.len);
3041                         WRITE32(gm->gm_oid.len);
3042                         WRITEMEM(gm->gm_oid.data, gm->gm_oid.len);
3043                         ADJUST_ARGS();
3044                         RESERVE_SPACE(4);
3045                         WRITE32(0); /* qop */
3046                         ADJUST_ARGS();
3047                         RESERVE_SPACE(4);
3048                         WRITE32(gss_pseudoflavor_to_service(gm, flav));
3049                         ADJUST_ARGS();
3050                         gss_mech_put(gm);
3051                 } else {
3052                         RESERVE_SPACE(4);
3053                         WRITE32(flav);
3054                         ADJUST_ARGS();
3055                 }
3056         }
3057 out:
3058         if (exp)
3059                 exp_put(exp);
3060         return nfserr;
3061 }
3062
3063 static __be32
3064 nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
3065                      struct nfsd4_secinfo *secinfo)
3066 {
3067         return nfsd4_do_encode_secinfo(resp, nfserr, secinfo->si_exp);
3068 }
3069
3070 static __be32
3071 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,
3072                      struct nfsd4_secinfo_no_name *secinfo)
3073 {
3074         return nfsd4_do_encode_secinfo(resp, nfserr, secinfo->sin_exp);
3075 }
3076
3077 /*
3078  * The SETATTR encode routine is special -- it always encodes a bitmap,
3079  * regardless of the error status.
3080  */
3081 static __be32
3082 nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr)
3083 {
3084         __be32 *p;
3085
3086         RESERVE_SPACE(12);
3087         if (nfserr) {
3088                 WRITE32(2);
3089                 WRITE32(0);
3090                 WRITE32(0);
3091         }
3092         else {
3093                 WRITE32(2);
3094                 WRITE32(setattr->sa_bmval[0]);
3095                 WRITE32(setattr->sa_bmval[1]);
3096         }
3097         ADJUST_ARGS();
3098         return nfserr;
3099 }
3100
3101 static __be32
3102 nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd)
3103 {
3104         __be32 *p;
3105
3106         if (!nfserr) {
3107                 RESERVE_SPACE(8 + sizeof(nfs4_verifier));
3108                 WRITEMEM(&scd->se_clientid, 8);
3109                 WRITEMEM(&scd->se_confirm, sizeof(nfs4_verifier));
3110                 ADJUST_ARGS();
3111         }
3112         else if (nfserr == nfserr_clid_inuse) {
3113                 RESERVE_SPACE(8);
3114                 WRITE32(0);
3115                 WRITE32(0);
3116                 ADJUST_ARGS();
3117         }
3118         return nfserr;
3119 }
3120
3121 static __be32
3122 nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write)
3123 {
3124         __be32 *p;
3125
3126         if (!nfserr) {
3127                 RESERVE_SPACE(16);
3128                 WRITE32(write->wr_bytes_written);
3129                 WRITE32(write->wr_how_written);
3130                 WRITEMEM(write->wr_verifier.data, 8);
3131                 ADJUST_ARGS();
3132         }
3133         return nfserr;
3134 }
3135
3136 static __be32
3137 nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, int nfserr,
3138                          struct nfsd4_exchange_id *exid)
3139 {
3140         __be32 *p;
3141         char *major_id;
3142         char *server_scope;
3143         int major_id_sz;
3144         int server_scope_sz;
3145         uint64_t minor_id = 0;
3146
3147         if (nfserr)
3148                 return nfserr;
3149
3150         major_id = utsname()->nodename;
3151         major_id_sz = strlen(major_id);
3152         server_scope = utsname()->nodename;
3153         server_scope_sz = strlen(server_scope);
3154
3155         RESERVE_SPACE(
3156                 8 /* eir_clientid */ +
3157                 4 /* eir_sequenceid */ +
3158                 4 /* eir_flags */ +
3159                 4 /* spr_how (SP4_NONE) */ +
3160                 8 /* so_minor_id */ +
3161                 4 /* so_major_id.len */ +
3162                 (XDR_QUADLEN(major_id_sz) * 4) +
3163                 4 /* eir_server_scope.len */ +
3164                 (XDR_QUADLEN(server_scope_sz) * 4) +
3165                 4 /* eir_server_impl_id.count (0) */);
3166
3167         WRITEMEM(&exid->clientid, 8);
3168         WRITE32(exid->seqid);
3169         WRITE32(exid->flags);
3170
3171         /* state_protect4_r. Currently only support SP4_NONE */
3172         BUG_ON(exid->spa_how != SP4_NONE);
3173         WRITE32(exid->spa_how);
3174
3175         /* The server_owner struct */
3176         WRITE64(minor_id);      /* Minor id */
3177         /* major id */
3178         WRITE32(major_id_sz);
3179         WRITEMEM(major_id, major_id_sz);
3180
3181         /* Server scope */
3182         WRITE32(server_scope_sz);
3183         WRITEMEM(server_scope, server_scope_sz);
3184
3185         /* Implementation id */
3186         WRITE32(0);     /* zero length nfs_impl_id4 array */
3187         ADJUST_ARGS();
3188         return 0;
3189 }
3190
3191 static __be32
3192 nfsd4_encode_create_session(struct nfsd4_compoundres *resp, int nfserr,
3193                             struct nfsd4_create_session *sess)
3194 {
3195         __be32 *p;
3196
3197         if (nfserr)
3198                 return nfserr;
3199
3200         RESERVE_SPACE(24);
3201         WRITEMEM(sess->sessionid.data, NFS4_MAX_SESSIONID_LEN);
3202         WRITE32(sess->seqid);
3203         WRITE32(sess->flags);
3204         ADJUST_ARGS();
3205
3206         RESERVE_SPACE(28);
3207         WRITE32(0); /* headerpadsz */
3208         WRITE32(sess->fore_channel.maxreq_sz);
3209         WRITE32(sess->fore_channel.maxresp_sz);
3210         WRITE32(sess->fore_channel.maxresp_cached);
3211         WRITE32(sess->fore_channel.maxops);
3212         WRITE32(sess->fore_channel.maxreqs);
3213         WRITE32(sess->fore_channel.nr_rdma_attrs);
3214         ADJUST_ARGS();
3215
3216         if (sess->fore_channel.nr_rdma_attrs) {
3217                 RESERVE_SPACE(4);
3218                 WRITE32(sess->fore_channel.rdma_attrs);
3219                 ADJUST_ARGS();
3220         }
3221
3222         RESERVE_SPACE(28);
3223         WRITE32(0); /* headerpadsz */
3224         WRITE32(sess->back_channel.maxreq_sz);
3225         WRITE32(sess->back_channel.maxresp_sz);
3226         WRITE32(sess->back_channel.maxresp_cached);
3227         WRITE32(sess->back_channel.maxops);
3228         WRITE32(sess->back_channel.maxreqs);
3229         WRITE32(sess->back_channel.nr_rdma_attrs);
3230         ADJUST_ARGS();
3231
3232         if (sess->back_channel.nr_rdma_attrs) {
3233                 RESERVE_SPACE(4);
3234                 WRITE32(sess->back_channel.rdma_attrs);
3235                 ADJUST_ARGS();
3236         }
3237         return 0;
3238 }
3239
3240 static __be32
3241 nfsd4_encode_destroy_session(struct nfsd4_compoundres *resp, int nfserr,
3242                              struct nfsd4_destroy_session *destroy_session)
3243 {
3244         return nfserr;
3245 }
3246
3247 static __be32
3248 nfsd4_encode_free_stateid(struct nfsd4_compoundres *resp, int nfserr,
3249                           struct nfsd4_free_stateid *free_stateid)
3250 {
3251         __be32 *p;
3252
3253         if (nfserr)
3254                 return nfserr;
3255
3256         RESERVE_SPACE(4);
3257         WRITE32(nfserr);
3258         ADJUST_ARGS();
3259         return nfserr;
3260 }
3261
3262 static __be32
3263 nfsd4_encode_sequence(struct nfsd4_compoundres *resp, int nfserr,
3264                       struct nfsd4_sequence *seq)
3265 {
3266         __be32 *p;
3267
3268         if (nfserr)
3269                 return nfserr;
3270
3271         RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 20);
3272         WRITEMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);
3273         WRITE32(seq->seqid);
3274         WRITE32(seq->slotid);
3275         /* Note slotid's are numbered from zero: */
3276         WRITE32(seq->maxslots - 1); /* sr_highest_slotid */
3277         WRITE32(seq->maxslots - 1); /* sr_target_highest_slotid */
3278         WRITE32(seq->status_flags);
3279
3280         ADJUST_ARGS();
3281         resp->cstate.datap = p; /* DRC cache data pointer */
3282         return 0;
3283 }
3284
3285 __be32
3286 nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, int nfserr,
3287                           struct nfsd4_test_stateid *test_stateid)
3288 {
3289         struct nfsd4_compoundargs *argp;
3290         stateid_t si;
3291         __be32 *p;
3292         int i;
3293         int valid;
3294
3295         restore_buf(test_stateid->ts_saved_args, &test_stateid->ts_savedp);
3296         argp = test_stateid->ts_saved_args;
3297
3298         RESERVE_SPACE(4);
3299         *p++ = htonl(test_stateid->ts_num_ids);
3300         resp->p = p;
3301
3302         nfs4_lock_state();
3303         for (i = 0; i < test_stateid->ts_num_ids; i++) {
3304                 nfsd4_decode_stateid(argp, &si);
3305                 valid = nfs4_validate_stateid(&si, test_stateid->ts_has_session);
3306                 RESERVE_SPACE(4);
3307                 *p++ = htonl(valid);
3308                 resp->p = p;
3309         }
3310         nfs4_unlock_state();
3311
3312         return nfserr;
3313 }
3314
3315 static __be32
3316 nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p)
3317 {
3318         return nfserr;
3319 }
3320
3321 typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *);
3322
3323 /*
3324  * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
3325  * since we don't need to filter out obsolete ops as this is
3326  * done in the decoding phase.
3327  */
3328 static nfsd4_enc nfsd4_enc_ops[] = {
3329         [OP_ACCESS]             = (nfsd4_enc)nfsd4_encode_access,
3330         [OP_CLOSE]              = (nfsd4_enc)nfsd4_encode_close,
3331         [OP_COMMIT]             = (nfsd4_enc)nfsd4_encode_commit,
3332         [OP_CREATE]             = (nfsd4_enc)nfsd4_encode_create,
3333         [OP_DELEGPURGE]         = (nfsd4_enc)nfsd4_encode_noop,
3334         [OP_DELEGRETURN]        = (nfsd4_enc)nfsd4_encode_noop,
3335         [OP_GETATTR]            = (nfsd4_enc)nfsd4_encode_getattr,
3336         [OP_GETFH]              = (nfsd4_enc)nfsd4_encode_getfh,
3337         [OP_LINK]               = (nfsd4_enc)nfsd4_encode_link,
3338         [OP_LOCK]               = (nfsd4_enc)nfsd4_encode_lock,
3339         [OP_LOCKT]              = (nfsd4_enc)nfsd4_encode_lockt,
3340         [OP_LOCKU]              = (nfsd4_enc)nfsd4_encode_locku,
3341         [OP_LOOKUP]             = (nfsd4_enc)nfsd4_encode_noop,
3342         [OP_LOOKUPP]            = (nfsd4_enc)nfsd4_encode_noop,
3343         [OP_NVERIFY]            = (nfsd4_enc)nfsd4_encode_noop,
3344         [OP_OPEN]               = (nfsd4_enc)nfsd4_encode_open,
3345         [OP_OPENATTR]           = (nfsd4_enc)nfsd4_encode_noop,
3346         [OP_OPEN_CONFIRM]       = (nfsd4_enc)nfsd4_encode_open_confirm,
3347         [OP_OPEN_DOWNGRADE]     = (nfsd4_enc)nfsd4_encode_open_downgrade,
3348         [OP_PUTFH]              = (nfsd4_enc)nfsd4_encode_noop,
3349         [OP_PUTPUBFH]           = (nfsd4_enc)nfsd4_encode_noop,
3350         [OP_PUTROOTFH]          = (nfsd4_enc)nfsd4_encode_noop,
3351         [OP_READ]               = (nfsd4_enc)nfsd4_encode_read,
3352         [OP_READDIR]            = (nfsd4_enc)nfsd4_encode_readdir,
3353         [OP_READLINK]           = (nfsd4_enc)nfsd4_encode_readlink,
3354         [OP_REMOVE]             = (nfsd4_enc)nfsd4_encode_remove,
3355         [OP_RENAME]             = (nfsd4_enc)nfsd4_encode_rename,
3356         [OP_RENEW]              = (nfsd4_enc)nfsd4_encode_noop,
3357         [OP_RESTOREFH]          = (nfsd4_enc)nfsd4_encode_noop,
3358         [OP_SAVEFH]             = (nfsd4_enc)nfsd4_encode_noop,
3359         [OP_SECINFO]            = (nfsd4_enc)nfsd4_encode_secinfo,
3360         [OP_SETATTR]            = (nfsd4_enc)nfsd4_encode_setattr,
3361         [OP_SETCLIENTID]        = (nfsd4_enc)nfsd4_encode_setclientid,
3362         [OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop,
3363         [OP_VERIFY]             = (nfsd4_enc)nfsd4_encode_noop,
3364         [OP_WRITE]              = (nfsd4_enc)nfsd4_encode_write,
3365         [OP_RELEASE_LOCKOWNER]  = (nfsd4_enc)nfsd4_encode_noop,
3366
3367         /* NFSv4.1 operations */
3368         [OP_BACKCHANNEL_CTL]    = (nfsd4_enc)nfsd4_encode_noop,
3369         [OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session,
3370         [OP_EXCHANGE_ID]        = (nfsd4_enc)nfsd4_encode_exchange_id,
3371         [OP_CREATE_SESSION]     = (nfsd4_enc)nfsd4_encode_create_session,
3372         [OP_DESTROY_SESSION]    = (nfsd4_enc)nfsd4_encode_destroy_session,
3373         [OP_FREE_STATEID]       = (nfsd4_enc)nfsd4_encode_free_stateid,
3374         [OP_GET_DIR_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop,
3375         [OP_GETDEVICEINFO]      = (nfsd4_enc)nfsd4_encode_noop,
3376         [OP_GETDEVICELIST]      = (nfsd4_enc)nfsd4_encode_noop,
3377         [OP_LAYOUTCOMMIT]       = (nfsd4_enc)nfsd4_encode_noop,
3378         [OP_LAYOUTGET]          = (nfsd4_enc)nfsd4_encode_noop,
3379         [OP_LAYOUTRETURN]       = (nfsd4_enc)nfsd4_encode_noop,
3380         [OP_SECINFO_NO_NAME]    = (nfsd4_enc)nfsd4_encode_secinfo_no_name,
3381         [OP_SEQUENCE]           = (nfsd4_enc)nfsd4_encode_sequence,
3382         [OP_SET_SSV]            = (nfsd4_enc)nfsd4_encode_noop,
3383         [OP_TEST_STATEID]       = (nfsd4_enc)nfsd4_encode_test_stateid,
3384         [OP_WANT_DELEGATION]    = (nfsd4_enc)nfsd4_encode_noop,
3385         [OP_DESTROY_CLIENTID]   = (nfsd4_enc)nfsd4_encode_noop,
3386         [OP_RECLAIM_COMPLETE]   = (nfsd4_enc)nfsd4_encode_noop,
3387 };
3388
3389 /*
3390  * Calculate the total amount of memory that the compound response has taken
3391  * after encoding the current operation with pad.
3392  *
3393  * pad: if operation is non-idempotent, pad was calculate by op_rsize_bop()
3394  *      which was specified at nfsd4_operation, else pad is zero.
3395  *
3396  * Compare this length to the session se_fmaxresp_sz and se_fmaxresp_cached.
3397  *
3398  * Our se_fmaxresp_cached will always be a multiple of PAGE_SIZE, and so
3399  * will be at least a page and will therefore hold the xdr_buf head.
3400  */
3401 int nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 pad)
3402 {
3403         struct xdr_buf *xb = &resp->rqstp->rq_res;
3404         struct nfsd4_session *session = NULL;
3405         struct nfsd4_slot *slot = resp->cstate.slot;
3406         u32 length, tlen = 0;
3407
3408         if (!nfsd4_has_session(&resp->cstate))
3409                 return 0;
3410
3411         session = resp->cstate.session;
3412         if (session == NULL)
3413                 return 0;
3414
3415         if (xb->page_len == 0) {
3416                 length = (char *)resp->p - (char *)xb->head[0].iov_base + pad;
3417         } else {
3418                 if (xb->tail[0].iov_base && xb->tail[0].iov_len > 0)
3419                         tlen = (char *)resp->p - (char *)xb->tail[0].iov_base;
3420
3421                 length = xb->head[0].iov_len + xb->page_len + tlen + pad;
3422         }
3423         dprintk("%s length %u, xb->page_len %u tlen %u pad %u\n", __func__,
3424                 length, xb->page_len, tlen, pad);
3425
3426         if (length > session->se_fchannel.maxresp_sz)
3427                 return nfserr_rep_too_big;
3428
3429         if (slot->sl_cachethis == 1 &&
3430             length > session->se_fchannel.maxresp_cached)
3431                 return nfserr_rep_too_big_to_cache;
3432
3433         return 0;
3434 }
3435
3436 void
3437 nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
3438 {
3439         __be32 *statp;
3440         __be32 *p;
3441
3442         RESERVE_SPACE(8);
3443         WRITE32(op->opnum);
3444         statp = p++;    /* to be backfilled at the end */
3445         ADJUST_ARGS();
3446
3447         if (op->opnum == OP_ILLEGAL)
3448                 goto status;
3449         BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||
3450                !nfsd4_enc_ops[op->opnum]);
3451         op->status = nfsd4_enc_ops[op->opnum](resp, op->status, &op->u);
3452         /* nfsd4_check_drc_limit guarantees enough room for error status */
3453         if (!op->status)
3454                 op->status = nfsd4_check_resp_size(resp, 0);
3455 status:
3456         /*
3457          * Note: We write the status directly, instead of using WRITE32(),
3458          * since it is already in network byte order.
3459          */
3460         *statp = op->status;
3461 }
3462
3463 /*
3464  * Encode the reply stored in the stateowner reply cache
3465  *
3466  * XDR note: do not encode rp->rp_buflen: the buffer contains the
3467  * previously sent already encoded operation.
3468  *
3469  * called with nfs4_lock_state() held
3470  */
3471 void
3472 nfsd4_encode_replay(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
3473 {
3474         __be32 *p;
3475         struct nfs4_replay *rp = op->replay;
3476
3477         BUG_ON(!rp);
3478
3479         RESERVE_SPACE(8);
3480         WRITE32(op->opnum);
3481         *p++ = rp->rp_status;  /* already xdr'ed */
3482         ADJUST_ARGS();
3483
3484         RESERVE_SPACE(rp->rp_buflen);
3485         WRITEMEM(rp->rp_buf, rp->rp_buflen);
3486         ADJUST_ARGS();
3487 }
3488
3489 int
3490 nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)
3491 {
3492         return xdr_ressize_check(rqstp, p);
3493 }
3494
3495 int nfsd4_release_compoundargs(void *rq, __be32 *p, void *resp)
3496 {
3497         struct svc_rqst *rqstp = rq;
3498         struct nfsd4_compoundargs *args = rqstp->rq_argp;
3499
3500         if (args->ops != args->iops) {
3501                 kfree(args->ops);
3502                 args->ops = args->iops;
3503         }
3504         kfree(args->tmpp);
3505         args->tmpp = NULL;
3506         while (args->to_free) {
3507                 struct tmpbuf *tb = args->to_free;
3508                 args->to_free = tb->next;
3509                 tb->release(tb->buf);
3510                 kfree(tb);
3511         }
3512         return 1;
3513 }
3514
3515 int
3516 nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundargs *args)
3517 {
3518         args->p = p;
3519         args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len;
3520         args->pagelist = rqstp->rq_arg.pages;
3521         args->pagelen = rqstp->rq_arg.page_len;
3522         args->tmpp = NULL;
3523         args->to_free = NULL;
3524         args->ops = args->iops;
3525         args->rqstp = rqstp;
3526
3527         return !nfsd4_decode_compound(args);
3528 }
3529
3530 int
3531 nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundres *resp)
3532 {
3533         /*
3534          * All that remains is to write the tag and operation count...
3535          */
3536         struct nfsd4_compound_state *cs = &resp->cstate;
3537         struct kvec *iov;
3538         p = resp->tagp;
3539         *p++ = htonl(resp->taglen);
3540         memcpy(p, resp->tag, resp->taglen);
3541         p += XDR_QUADLEN(resp->taglen);
3542         *p++ = htonl(resp->opcnt);
3543
3544         if (rqstp->rq_res.page_len)
3545                 iov = &rqstp->rq_res.tail[0];
3546         else
3547                 iov = &rqstp->rq_res.head[0];
3548         iov->iov_len = ((char*)resp->p) - (char*)iov->iov_base;
3549         BUG_ON(iov->iov_len > PAGE_SIZE);
3550         if (nfsd4_has_session(cs)) {
3551                 if (cs->status != nfserr_replay_cache) {
3552                         nfsd4_store_cache_entry(resp);
3553                         dprintk("%s: SET SLOT STATE TO AVAILABLE\n", __func__);
3554                         cs->slot->sl_inuse = false;
3555                 }
3556                 /* Renew the clientid on success and on replay */
3557                 release_session_client(cs->session);
3558                 nfsd4_put_session(cs->session);
3559         }
3560         return 1;
3561 }
3562
3563 /*
3564  * Local variables:
3565  *  c-basic-offset: 8
3566  * End:
3567  */