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