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
  36 #include <linux/file.h>
  37 #include <linux/slab.h>
  38 #include <linux/namei.h>
  39 #include <linux/statfs.h>
  40 #include <linux/utsname.h>
  41 #include <linux/pagemap.h>
  42 #include <linux/sunrpc/svcauth_gss.h>
  43
  44 #include "idmap.h"
  45 #include "acl.h"
  46 #include "xdr4.h"
  47 #include "vfs.h"
  48 #include "state.h"
  49 #include "cache.h"
  50 #include "netns.h"
  51 #include "pnfs.h"
  52
  53 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
  54 #include <linux/security.h>
  55 #endif
  56
  57
  58 #define NFSDDBG_FACILITY                NFSDDBG_XDR
  59
  60 const u32 nfsd_suppattrs[3][3] = {
  61         {NFSD4_SUPPORTED_ATTRS_WORD0,
  62          NFSD4_SUPPORTED_ATTRS_WORD1,
  63          NFSD4_SUPPORTED_ATTRS_WORD2},
  64
  65         {NFSD4_1_SUPPORTED_ATTRS_WORD0,
  66          NFSD4_1_SUPPORTED_ATTRS_WORD1,
  67          NFSD4_1_SUPPORTED_ATTRS_WORD2},
  68
  69         {NFSD4_1_SUPPORTED_ATTRS_WORD0,
  70          NFSD4_1_SUPPORTED_ATTRS_WORD1,
  71          NFSD4_2_SUPPORTED_ATTRS_WORD2},
  72 };
  73
  74 /*
  75  * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
  76  * directory in order to indicate to the client that a filesystem boundary is present
  77  * We use a fixed fsid for a referral
  78  */
  79 #define NFS4_REFERRAL_FSID_MAJOR        0x8000000ULL
  80 #define NFS4_REFERRAL_FSID_MINOR        0x8000000ULL
  81
  82 static __be32
  83 check_filename(char *str, int len)
  84 {
  85         int i;
  86
  87         if (len == 0)
  88                 return nfserr_inval;
  89         if (isdotent(str, len))
  90                 return nfserr_badname;
  91         for (i = 0; i < len; i++)
  92                 if (str[i] == '/')
  93                         return nfserr_badname;
  94         return 0;
  95 }
  96
  97 #define DECODE_HEAD                             \
  98         __be32 *p;                              \
  99         __be32 status
 100 #define DECODE_TAIL                             \
 101         status = 0;                             \
 102 out:                                            \
 103         return status;                          \
 104 xdr_error:                                      \
 105         dprintk("NFSD: xdr error (%s:%d)\n",    \
 106                         __FILE__, __LINE__);    \
 107         status = nfserr_bad_xdr;                \
 108         goto out
 109
 110 #define READMEM(x,nbytes) do {                  \
 111         x = (char *)p;                          \
 112         p += XDR_QUADLEN(nbytes);               \
 113 } while (0)
 114 #define SAVEMEM(x,nbytes) do {                  \
 115         if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
 116                 savemem(argp, p, nbytes) :      \
 117                 (char *)p)) {                   \
 118                 dprintk("NFSD: xdr error (%s:%d)\n", \
 119                                 __FILE__, __LINE__); \
 120                 goto xdr_error;                 \
 121                 }                               \
 122         p += XDR_QUADLEN(nbytes);               \
 123 } while (0)
 124 #define COPYMEM(x,nbytes) do {                  \
 125         memcpy((x), p, nbytes);                 \
 126         p += XDR_QUADLEN(nbytes);               \
 127 } while (0)
 128
 129 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */
 130 #define READ_BUF(nbytes)  do {                  \
 131         if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) {     \
 132                 p = argp->p;                    \
 133                 argp->p += XDR_QUADLEN(nbytes); \
 134         } else if (!(p = read_buf(argp, nbytes))) { \
 135                 dprintk("NFSD: xdr error (%s:%d)\n", \
 136                                 __FILE__, __LINE__); \
 137                 goto xdr_error;                 \
 138         }                                       \
 139 } while (0)
 140
 141 static void next_decode_page(struct nfsd4_compoundargs *argp)
 142 {
 143         argp->p = page_address(argp->pagelist[0]);
 144         argp->pagelist++;
 145         if (argp->pagelen < PAGE_SIZE) {
 146                 argp->end = argp->p + XDR_QUADLEN(argp->pagelen);
 147                 argp->pagelen = 0;
 148         } else {
 149                 argp->end = argp->p + (PAGE_SIZE>>2);
 150                 argp->pagelen -= PAGE_SIZE;
 151         }
 152 }
 153
 154 static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes)
 155 {
 156         /* We want more bytes than seem to be available.
 157          * Maybe we need a new page, maybe we have just run out
 158          */
 159         unsigned int avail = (char *)argp->end - (char *)argp->p;
 160         __be32 *p;
 161
 162         if (argp->pagelen == 0) {
 163                 struct kvec *vec = &argp->rqstp->rq_arg.tail[0];
 164
 165                 if (!argp->tail) {
 166                         argp->tail = true;
 167                         avail = vec->iov_len;
 168                         argp->p = vec->iov_base;
 169                         argp->end = vec->iov_base + avail;
 170                 }
 171
 172                 if (avail < nbytes)
 173                         return NULL;
 174
 175                 p = argp->p;
 176                 argp->p += XDR_QUADLEN(nbytes);
 177                 return p;
 178         }
 179
 180         if (avail + argp->pagelen < nbytes)
 181                 return NULL;
 182         if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */
 183                 return NULL;
 184         /* ok, we can do it with the current plus the next page */
 185         if (nbytes <= sizeof(argp->tmp))
 186                 p = argp->tmp;
 187         else {
 188                 kfree(argp->tmpp);
 189                 p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL);
 190                 if (!p)
 191                         return NULL;
 192
 193         }
 194         /*
 195          * The following memcpy is safe because read_buf is always
 196          * called with nbytes > avail, and the two cases above both
 197          * guarantee p points to at least nbytes bytes.
 198          */
 199         memcpy(p, argp->p, avail);
 200         next_decode_page(argp);
 201         memcpy(((char*)p)+avail, argp->p, (nbytes - avail));
 202         argp->p += XDR_QUADLEN(nbytes - avail);
 203         return p;
 204 }
 205
 206 static int zero_clientid(clientid_t *clid)
 207 {
 208         return (clid->cl_boot == 0) && (clid->cl_id == 0);
 209 }
 210
 211 /**
 212  * svcxdr_tmpalloc - allocate memory to be freed after compound processing
 213  * @argp: NFSv4 compound argument structure
 214  * @p: pointer to be freed (with kfree())
 215  *
 216  * Marks @p to be freed when processing the compound operation
 217  * described in @argp finishes.
 218  */
 219 static void *
 220 svcxdr_tmpalloc(struct nfsd4_compoundargs *argp, u32 len)
 221 {
 222         struct svcxdr_tmpbuf *tb;
 223
 224         tb = kmalloc(sizeof(*tb) + len, GFP_KERNEL);
 225         if (!tb)
 226                 return NULL;
 227         tb->next = argp->to_free;
 228         argp->to_free = tb;
 229         return tb->buf;
 230 }
 231
 232 /*
 233  * For xdr strings that need to be passed to other kernel api's
 234  * as null-terminated strings.
 235  *
 236  * Note null-terminating in place usually isn't safe since the
 237  * buffer might end on a page boundary.
 238  */
 239 static char *
 240 svcxdr_dupstr(struct nfsd4_compoundargs *argp, void *buf, u32 len)
 241 {
 242         char *p = svcxdr_tmpalloc(argp, len + 1);
 243
 244         if (!p)
 245                 return NULL;
 246         memcpy(p, buf, len);
 247         p[len] = '\0';
 248         return p;
 249 }
 250
 251 /**
 252  * savemem - duplicate a chunk of memory for later processing
 253  * @argp: NFSv4 compound argument structure to be freed with
 254  * @p: pointer to be duplicated
 255  * @nbytes: length to be duplicated
 256  *
 257  * Returns a pointer to a copy of @nbytes bytes of memory at @p
 258  * that are preserved until processing of the NFSv4 compound
 259  * operation described by @argp finishes.
 260  */
 261 static char *savemem(struct nfsd4_compoundargs *argp, __be32 *p, int nbytes)
 262 {
 263         void *ret;
 264
 265         ret = svcxdr_tmpalloc(argp, nbytes);
 266         if (!ret)
 267                 return NULL;
 268         memcpy(ret, p, nbytes);
 269         return ret;
 270 }
 271
 272 /*
 273  * We require the high 32 bits of 'seconds' to be 0, and
 274  * we ignore all 32 bits of 'nseconds'.
 275  */
 276 static __be32
 277 nfsd4_decode_time(struct nfsd4_compoundargs *argp, struct timespec *tv)
 278 {
 279         DECODE_HEAD;
 280         u64 sec;
 281
 282         READ_BUF(12);
 283         p = xdr_decode_hyper(p, &sec);
 284         tv->tv_sec = sec;
 285         tv->tv_nsec = be32_to_cpup(p++);
 286         if (tv->tv_nsec >= (u32)1000000000)
 287                 return nfserr_inval;
 288
 289         DECODE_TAIL;
 290 }
 291
 292 static __be32
 293 nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)
 294 {
 295         u32 bmlen;
 296         DECODE_HEAD;
 297
 298         bmval[0] = 0;
 299         bmval[1] = 0;
 300         bmval[2] = 0;
 301
 302         READ_BUF(4);
 303         bmlen = be32_to_cpup(p++);
 304         if (bmlen > 1000)
 305                 goto xdr_error;
 306
 307         READ_BUF(bmlen << 2);
 308         if (bmlen > 0)
 309                 bmval[0] = be32_to_cpup(p++);
 310         if (bmlen > 1)
 311                 bmval[1] = be32_to_cpup(p++);
 312         if (bmlen > 2)
 313                 bmval[2] = be32_to_cpup(p++);
 314
 315         DECODE_TAIL;
 316 }
 317
 318 static __be32
 319 nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
 320                    struct iattr *iattr, struct nfs4_acl **acl,
 321                    struct xdr_netobj *label, int *umask)
 322 {
 323         struct timespec ts;
 324         int expected_len, len = 0;
 325         u32 dummy32;
 326         char *buf;
 327
 328         DECODE_HEAD;
 329         iattr->ia_valid = 0;
 330         if ((status = nfsd4_decode_bitmap(argp, bmval)))
 331                 return status;
 332
 333         if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
 334             || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
 335             || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2) {
 336                 if (nfsd_attrs_supported(argp->minorversion, bmval))
 337                         return nfserr_inval;
 338                 return nfserr_attrnotsupp;
 339         }
 340
 341         READ_BUF(4);
 342         expected_len = be32_to_cpup(p++);
 343
 344         if (bmval[0] & FATTR4_WORD0_SIZE) {
 345                 READ_BUF(8);
 346                 len += 8;
 347                 p = xdr_decode_hyper(p, &iattr->ia_size);
 348                 iattr->ia_valid |= ATTR_SIZE;
 349         }
 350         if (bmval[0] & FATTR4_WORD0_ACL) {
 351                 u32 nace;
 352                 struct nfs4_ace *ace;
 353
 354                 READ_BUF(4); len += 4;
 355                 nace = be32_to_cpup(p++);
 356
 357                 if (nace > NFS4_ACL_MAX)
 358                         return nfserr_fbig;
 359
 360                 *acl = svcxdr_tmpalloc(argp, nfs4_acl_bytes(nace));
 361                 if (*acl == NULL)
 362                         return nfserr_jukebox;
 363
 364                 (*acl)->naces = nace;
 365                 for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) {
 366                         READ_BUF(16); len += 16;
 367                         ace->type = be32_to_cpup(p++);
 368                         ace->flag = be32_to_cpup(p++);
 369                         ace->access_mask = be32_to_cpup(p++);
 370                         dummy32 = be32_to_cpup(p++);
 371                         READ_BUF(dummy32);
 372                         len += XDR_QUADLEN(dummy32) << 2;
 373                         READMEM(buf, dummy32);
 374                         ace->whotype = nfs4_acl_get_whotype(buf, dummy32);
 375                         status = nfs_ok;
 376                         if (ace->whotype != NFS4_ACL_WHO_NAMED)
 377                                 ;
 378                         else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
 379                                 status = nfsd_map_name_to_gid(argp->rqstp,
 380                                                 buf, dummy32, &ace->who_gid);
 381                         else
 382                                 status = nfsd_map_name_to_uid(argp->rqstp,
 383                                                 buf, dummy32, &ace->who_uid);
 384                         if (status)
 385                                 return status;
 386                 }
 387         } else
 388                 *acl = NULL;
 389         if (bmval[1] & FATTR4_WORD1_MODE) {
 390                 READ_BUF(4);
 391                 len += 4;
 392                 iattr->ia_mode = be32_to_cpup(p++);
 393                 iattr->ia_mode &= (S_IFMT | S_IALLUGO);
 394                 iattr->ia_valid |= ATTR_MODE;
 395         }
 396         if (bmval[1] & FATTR4_WORD1_OWNER) {
 397                 READ_BUF(4);
 398                 len += 4;
 399                 dummy32 = be32_to_cpup(p++);
 400                 READ_BUF(dummy32);
 401                 len += (XDR_QUADLEN(dummy32) << 2);
 402                 READMEM(buf, dummy32);
 403                 if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid)))
 404                         return status;
 405                 iattr->ia_valid |= ATTR_UID;
 406         }
 407         if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) {
 408                 READ_BUF(4);
 409                 len += 4;
 410                 dummy32 = be32_to_cpup(p++);
 411                 READ_BUF(dummy32);
 412                 len += (XDR_QUADLEN(dummy32) << 2);
 413                 READMEM(buf, dummy32);
 414                 if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid)))
 415                         return status;
 416                 iattr->ia_valid |= ATTR_GID;
 417         }
 418         if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
 419                 READ_BUF(4);
 420                 len += 4;
 421                 dummy32 = be32_to_cpup(p++);
 422                 switch (dummy32) {
 423                 case NFS4_SET_TO_CLIENT_TIME:
 424                         len += 12;
 425                         status = nfsd4_decode_time(argp, &ts);
 426                         iattr->ia_atime = timespec_to_timespec64(ts);
 427                         if (status)
 428                                 return status;
 429                         iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET);
 430                         break;
 431                 case NFS4_SET_TO_SERVER_TIME:
 432                         iattr->ia_valid |= ATTR_ATIME;
 433                         break;
 434                 default:
 435                         goto xdr_error;
 436                 }
 437         }
 438         if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
 439                 READ_BUF(4);
 440                 len += 4;
 441                 dummy32 = be32_to_cpup(p++);
 442                 switch (dummy32) {
 443                 case NFS4_SET_TO_CLIENT_TIME:
 444                         len += 12;
 445                         status = nfsd4_decode_time(argp, &ts);
 446                         iattr->ia_mtime = timespec_to_timespec64(ts);
 447                         if (status)
 448                                 return status;
 449                         iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET);
 450                         break;
 451                 case NFS4_SET_TO_SERVER_TIME:
 452                         iattr->ia_valid |= ATTR_MTIME;
 453                         break;
 454                 default:
 455                         goto xdr_error;
 456                 }
 457         }
 458
 459         label->len = 0;
 460         if (IS_ENABLED(CONFIG_NFSD_V4_SECURITY_LABEL) &&
 461             bmval[2] & FATTR4_WORD2_SECURITY_LABEL) {
 462                 READ_BUF(4);
 463                 len += 4;
 464                 dummy32 = be32_to_cpup(p++); /* lfs: we don't use it */
 465                 READ_BUF(4);
 466                 len += 4;
 467                 dummy32 = be32_to_cpup(p++); /* pi: we don't use it either */
 468                 READ_BUF(4);
 469                 len += 4;
 470                 dummy32 = be32_to_cpup(p++);
 471                 READ_BUF(dummy32);
 472                 if (dummy32 > NFS4_MAXLABELLEN)
 473                         return nfserr_badlabel;
 474                 len += (XDR_QUADLEN(dummy32) << 2);
 475                 READMEM(buf, dummy32);
 476                 label->len = dummy32;
 477                 label->data = svcxdr_dupstr(argp, buf, dummy32);
 478                 if (!label->data)
 479                         return nfserr_jukebox;
 480         }
 481         if (bmval[2] & FATTR4_WORD2_MODE_UMASK) {
 482                 if (!umask)
 483                         goto xdr_error;
 484                 READ_BUF(8);
 485                 len += 8;
 486                 dummy32 = be32_to_cpup(p++);
 487                 iattr->ia_mode = dummy32 & (S_IFMT | S_IALLUGO);
 488                 dummy32 = be32_to_cpup(p++);
 489                 *umask = dummy32 & S_IRWXUGO;
 490                 iattr->ia_valid |= ATTR_MODE;
 491         }
 492         if (len != expected_len)
 493                 goto xdr_error;
 494
 495         DECODE_TAIL;
 496 }
 497
 498 static __be32
 499 nfsd4_decode_stateid(struct nfsd4_compoundargs *argp, stateid_t *sid)
 500 {
 501         DECODE_HEAD;
 502
 503         READ_BUF(sizeof(stateid_t));
 504         sid->si_generation = be32_to_cpup(p++);
 505         COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t));
 506
 507         DECODE_TAIL;
 508 }
 509
 510 static __be32
 511 nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access)
 512 {
 513         DECODE_HEAD;
 514
 515         READ_BUF(4);
 516         access->ac_req_access = be32_to_cpup(p++);
 517
 518         DECODE_TAIL;
 519 }
 520
 521 static __be32 nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs)
 522 {
 523         DECODE_HEAD;
 524         struct user_namespace *userns = nfsd_user_namespace(argp->rqstp);
 525         u32 dummy, uid, gid;
 526         char *machine_name;
 527         int i;
 528         int nr_secflavs;
 529
 530         /* callback_sec_params4 */
 531         READ_BUF(4);
 532         nr_secflavs = be32_to_cpup(p++);
 533         if (nr_secflavs)
 534                 cbs->flavor = (u32)(-1);
 535         else
 536                 /* Is this legal? Be generous, take it to mean AUTH_NONE: */
 537                 cbs->flavor = 0;
 538         for (i = 0; i < nr_secflavs; ++i) {
 539                 READ_BUF(4);
 540                 dummy = be32_to_cpup(p++);
 541                 switch (dummy) {
 542                 case RPC_AUTH_NULL:
 543                         /* Nothing to read */
 544                         if (cbs->flavor == (u32)(-1))
 545                                 cbs->flavor = RPC_AUTH_NULL;
 546                         break;
 547                 case RPC_AUTH_UNIX:
 548                         READ_BUF(8);
 549                         /* stamp */
 550                         dummy = be32_to_cpup(p++);
 551
 552                         /* machine name */
 553                         dummy = be32_to_cpup(p++);
 554                         READ_BUF(dummy);
 555                         SAVEMEM(machine_name, dummy);
 556
 557                         /* uid, gid */
 558                         READ_BUF(8);
 559                         uid = be32_to_cpup(p++);
 560                         gid = be32_to_cpup(p++);
 561
 562                         /* more gids */
 563                         READ_BUF(4);
 564                         dummy = be32_to_cpup(p++);
 565                         READ_BUF(dummy * 4);
 566                         if (cbs->flavor == (u32)(-1)) {
 567                                 kuid_t kuid = make_kuid(userns, uid);
 568                                 kgid_t kgid = make_kgid(userns, gid);
 569                                 if (uid_valid(kuid) && gid_valid(kgid)) {
 570                                         cbs->uid = kuid;
 571                                         cbs->gid = kgid;
 572                                         cbs->flavor = RPC_AUTH_UNIX;
 573                                 } else {
 574                                         dprintk("RPC_AUTH_UNIX with invalid"
 575                                                 "uid or gid ignoring!\n");
 576                                 }
 577                         }
 578                         break;
 579                 case RPC_AUTH_GSS:
 580                         dprintk("RPC_AUTH_GSS callback secflavor "
 581                                 "not supported!\n");
 582                         READ_BUF(8);
 583                         /* gcbp_service */
 584                         dummy = be32_to_cpup(p++);
 585                         /* gcbp_handle_from_server */
 586                         dummy = be32_to_cpup(p++);
 587                         READ_BUF(dummy);
 588                         p += XDR_QUADLEN(dummy);
 589                         /* gcbp_handle_from_client */
 590                         READ_BUF(4);
 591                         dummy = be32_to_cpup(p++);
 592                         READ_BUF(dummy);
 593                         break;
 594                 default:
 595                         dprintk("Illegal callback secflavor\n");
 596                         return nfserr_inval;
 597                 }
 598         }
 599         DECODE_TAIL;
 600 }
 601
 602 static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, struct nfsd4_backchannel_ctl *bc)
 603 {
 604         DECODE_HEAD;
 605
 606         READ_BUF(4);
 607         bc->bc_cb_program = be32_to_cpup(p++);
 608         nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);
 609
 610         DECODE_TAIL;
 611 }
 612
 613 static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, struct nfsd4_bind_conn_to_session *bcts)
 614 {
 615         DECODE_HEAD;
 616
 617         READ_BUF(NFS4_MAX_SESSIONID_LEN + 8);
 618         COPYMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);
 619         bcts->dir = be32_to_cpup(p++);
 620         /* XXX: skipping ctsa_use_conn_in_rdma_mode.  Perhaps Tom Tucker
 621          * could help us figure out we should be using it. */
 622         DECODE_TAIL;
 623 }
 624
 625 static __be32
 626 nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close)
 627 {
 628         DECODE_HEAD;
 629
 630         READ_BUF(4);
 631         close->cl_seqid = be32_to_cpup(p++);
 632         return nfsd4_decode_stateid(argp, &close->cl_stateid);
 633
 634         DECODE_TAIL;
 635 }
 636
 637
 638 static __be32
 639 nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit)
 640 {
 641         DECODE_HEAD;
 642
 643         READ_BUF(12);
 644         p = xdr_decode_hyper(p, &commit->co_offset);
 645         commit->co_count = be32_to_cpup(p++);
 646
 647         DECODE_TAIL;
 648 }
 649
 650 static __be32
 651 nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create)
 652 {
 653         DECODE_HEAD;
 654
 655         READ_BUF(4);
 656         create->cr_type = be32_to_cpup(p++);
 657         switch (create->cr_type) {
 658         case NF4LNK:
 659                 READ_BUF(4);
 660                 create->cr_datalen = be32_to_cpup(p++);
 661                 READ_BUF(create->cr_datalen);
 662                 create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen);
 663                 if (!create->cr_data)
 664                         return nfserr_jukebox;
 665                 break;
 666         case NF4BLK:
 667         case NF4CHR:
 668                 READ_BUF(8);
 669                 create->cr_specdata1 = be32_to_cpup(p++);
 670                 create->cr_specdata2 = be32_to_cpup(p++);
 671                 break;
 672         case NF4SOCK:
 673         case NF4FIFO:
 674         case NF4DIR:
 675         default:
 676                 break;
 677         }
 678
 679         READ_BUF(4);
 680         create->cr_namelen = be32_to_cpup(p++);
 681         READ_BUF(create->cr_namelen);
 682         SAVEMEM(create->cr_name, create->cr_namelen);
 683         if ((status = check_filename(create->cr_name, create->cr_namelen)))
 684                 return status;
 685
 686         status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr,
 687                                     &create->cr_acl, &create->cr_label,
 688                                     &create->cr_umask);
 689         if (status)
 690                 goto out;
 691
 692         DECODE_TAIL;
 693 }
 694
 695 static inline __be32
 696 nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr)
 697 {
 698         return nfsd4_decode_stateid(argp, &dr->dr_stateid);
 699 }
 700
 701 static inline __be32
 702 nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr)
 703 {
 704         return nfsd4_decode_bitmap(argp, getattr->ga_bmval);
 705 }
 706
 707 static __be32
 708 nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link)
 709 {
 710         DECODE_HEAD;
 711
 712         READ_BUF(4);
 713         link->li_namelen = be32_to_cpup(p++);
 714         READ_BUF(link->li_namelen);
 715         SAVEMEM(link->li_name, link->li_namelen);
 716         if ((status = check_filename(link->li_name, link->li_namelen)))
 717                 return status;
 718
 719         DECODE_TAIL;
 720 }
 721
 722 static __be32
 723 nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock)
 724 {
 725         DECODE_HEAD;
 726
 727         /*
 728         * type, reclaim(boolean), offset, length, new_lock_owner(boolean)
 729         */
 730         READ_BUF(28);
 731         lock->lk_type = be32_to_cpup(p++);
 732         if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))
 733                 goto xdr_error;
 734         lock->lk_reclaim = be32_to_cpup(p++);
 735         p = xdr_decode_hyper(p, &lock->lk_offset);
 736         p = xdr_decode_hyper(p, &lock->lk_length);
 737         lock->lk_is_new = be32_to_cpup(p++);
 738
 739         if (lock->lk_is_new) {
 740                 READ_BUF(4);
 741                 lock->lk_new_open_seqid = be32_to_cpup(p++);
 742                 status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid);
 743                 if (status)
 744                         return status;
 745                 READ_BUF(8 + sizeof(clientid_t));
 746                 lock->lk_new_lock_seqid = be32_to_cpup(p++);
 747                 COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t));
 748                 lock->lk_new_owner.len = be32_to_cpup(p++);
 749                 READ_BUF(lock->lk_new_owner.len);
 750                 READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len);
 751         } else {
 752                 status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid);
 753                 if (status)
 754                         return status;
 755                 READ_BUF(4);
 756                 lock->lk_old_lock_seqid = be32_to_cpup(p++);
 757         }
 758
 759         DECODE_TAIL;
 760 }
 761
 762 static __be32
 763 nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt)
 764 {
 765         DECODE_HEAD;
 766
 767         READ_BUF(32);
 768         lockt->lt_type = be32_to_cpup(p++);
 769         if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))
 770                 goto xdr_error;
 771         p = xdr_decode_hyper(p, &lockt->lt_offset);
 772         p = xdr_decode_hyper(p, &lockt->lt_length);
 773         COPYMEM(&lockt->lt_clientid, 8);
 774         lockt->lt_owner.len = be32_to_cpup(p++);
 775         READ_BUF(lockt->lt_owner.len);
 776         READMEM(lockt->lt_owner.data, lockt->lt_owner.len);
 777
 778         DECODE_TAIL;
 779 }
 780
 781 static __be32
 782 nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku)
 783 {
 784         DECODE_HEAD;
 785
 786         READ_BUF(8);
 787         locku->lu_type = be32_to_cpup(p++);
 788         if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))
 789                 goto xdr_error;
 790         locku->lu_seqid = be32_to_cpup(p++);
 791         status = nfsd4_decode_stateid(argp, &locku->lu_stateid);
 792         if (status)
 793                 return status;
 794         READ_BUF(16);
 795         p = xdr_decode_hyper(p, &locku->lu_offset);
 796         p = xdr_decode_hyper(p, &locku->lu_length);
 797
 798         DECODE_TAIL;
 799 }
 800
 801 static __be32
 802 nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup)
 803 {
 804         DECODE_HEAD;
 805
 806         READ_BUF(4);
 807         lookup->lo_len = be32_to_cpup(p++);
 808         READ_BUF(lookup->lo_len);
 809         SAVEMEM(lookup->lo_name, lookup->lo_len);
 810         if ((status = check_filename(lookup->lo_name, lookup->lo_len)))
 811                 return status;
 812
 813         DECODE_TAIL;
 814 }
 815
 816 static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when)
 817 {
 818         __be32 *p;
 819         u32 w;
 820
 821         READ_BUF(4);
 822         w = be32_to_cpup(p++);
 823         *share_access = w & NFS4_SHARE_ACCESS_MASK;
 824         *deleg_want = w & NFS4_SHARE_WANT_MASK;
 825         if (deleg_when)
 826                 *deleg_when = w & NFS4_SHARE_WHEN_MASK;
 827
 828         switch (w & NFS4_SHARE_ACCESS_MASK) {
 829         case NFS4_SHARE_ACCESS_READ:
 830         case NFS4_SHARE_ACCESS_WRITE:
 831         case NFS4_SHARE_ACCESS_BOTH:
 832                 break;
 833         default:
 834                 return nfserr_bad_xdr;
 835         }
 836         w &= ~NFS4_SHARE_ACCESS_MASK;
 837         if (!w)
 838                 return nfs_ok;
 839         if (!argp->minorversion)
 840                 return nfserr_bad_xdr;
 841         switch (w & NFS4_SHARE_WANT_MASK) {
 842         case NFS4_SHARE_WANT_NO_PREFERENCE:
 843         case NFS4_SHARE_WANT_READ_DELEG:
 844         case NFS4_SHARE_WANT_WRITE_DELEG:
 845         case NFS4_SHARE_WANT_ANY_DELEG:
 846         case NFS4_SHARE_WANT_NO_DELEG:
 847         case NFS4_SHARE_WANT_CANCEL:
 848                 break;
 849         default:
 850                 return nfserr_bad_xdr;
 851         }
 852         w &= ~NFS4_SHARE_WANT_MASK;
 853         if (!w)
 854                 return nfs_ok;
 855
 856         if (!deleg_when)        /* open_downgrade */
 857                 return nfserr_inval;
 858         switch (w) {
 859         case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL:
 860         case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED:
 861         case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL |
 862               NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED):
 863                 return nfs_ok;
 864         }
 865 xdr_error:
 866         return nfserr_bad_xdr;
 867 }
 868
 869 static __be32 nfsd4_decode_share_deny(struct nfsd4_compoundargs *argp, u32 *x)
 870 {
 871         __be32 *p;
 872
 873         READ_BUF(4);
 874         *x = be32_to_cpup(p++);
 875         /* Note: unlinke access bits, deny bits may be zero. */
 876         if (*x & ~NFS4_SHARE_DENY_BOTH)
 877                 return nfserr_bad_xdr;
 878         return nfs_ok;
 879 xdr_error:
 880         return nfserr_bad_xdr;
 881 }
 882
 883 static __be32 nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o)
 884 {
 885         __be32 *p;
 886
 887         READ_BUF(4);
 888         o->len = be32_to_cpup(p++);
 889
 890         if (o->len == 0 || o->len > NFS4_OPAQUE_LIMIT)
 891                 return nfserr_bad_xdr;
 892
 893         READ_BUF(o->len);
 894         SAVEMEM(o->data, o->len);
 895         return nfs_ok;
 896 xdr_error:
 897         return nfserr_bad_xdr;
 898 }
 899
 900 static __be32
 901 nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
 902 {
 903         DECODE_HEAD;
 904         u32 dummy;
 905
 906         memset(open->op_bmval, 0, sizeof(open->op_bmval));
 907         open->op_iattr.ia_valid = 0;
 908         open->op_openowner = NULL;
 909
 910         open->op_xdr_error = 0;
 911         /* seqid, share_access, share_deny, clientid, ownerlen */
 912         READ_BUF(4);
 913         open->op_seqid = be32_to_cpup(p++);
 914         /* decode, yet ignore deleg_when until supported */
 915         status = nfsd4_decode_share_access(argp, &open->op_share_access,
 916                                            &open->op_deleg_want, &dummy);
 917         if (status)
 918                 goto xdr_error;
 919         status = nfsd4_decode_share_deny(argp, &open->op_share_deny);
 920         if (status)
 921                 goto xdr_error;
 922         READ_BUF(sizeof(clientid_t));
 923         COPYMEM(&open->op_clientid, sizeof(clientid_t));
 924         status = nfsd4_decode_opaque(argp, &open->op_owner);
 925         if (status)
 926                 goto xdr_error;
 927         READ_BUF(4);
 928         open->op_create = be32_to_cpup(p++);
 929         switch (open->op_create) {
 930         case NFS4_OPEN_NOCREATE:
 931                 break;
 932         case NFS4_OPEN_CREATE:
 933                 READ_BUF(4);
 934                 open->op_createmode = be32_to_cpup(p++);
 935                 switch (open->op_createmode) {
 936                 case NFS4_CREATE_UNCHECKED:
 937                 case NFS4_CREATE_GUARDED:
 938                         status = nfsd4_decode_fattr(argp, open->op_bmval,
 939                                 &open->op_iattr, &open->op_acl, &open->op_label,
 940                                 &open->op_umask);
 941                         if (status)
 942                                 goto out;
 943                         break;
 944                 case NFS4_CREATE_EXCLUSIVE:
 945                         READ_BUF(NFS4_VERIFIER_SIZE);
 946                         COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
 947                         break;
 948                 case NFS4_CREATE_EXCLUSIVE4_1:
 949                         if (argp->minorversion < 1)
 950                                 goto xdr_error;
 951                         READ_BUF(NFS4_VERIFIER_SIZE);
 952                         COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
 953                         status = nfsd4_decode_fattr(argp, open->op_bmval,
 954                                 &open->op_iattr, &open->op_acl, &open->op_label,
 955                                 &open->op_umask);
 956                         if (status)
 957                                 goto out;
 958                         break;
 959                 default:
 960                         goto xdr_error;
 961                 }
 962                 break;
 963         default:
 964                 goto xdr_error;
 965         }
 966
 967         /* open_claim */
 968         READ_BUF(4);
 969         open->op_claim_type = be32_to_cpup(p++);
 970         switch (open->op_claim_type) {
 971         case NFS4_OPEN_CLAIM_NULL:
 972         case NFS4_OPEN_CLAIM_DELEGATE_PREV:
 973                 READ_BUF(4);
 974                 open->op_fname.len = be32_to_cpup(p++);
 975                 READ_BUF(open->op_fname.len);
 976                 SAVEMEM(open->op_fname.data, open->op_fname.len);
 977                 if ((status = check_filename(open->op_fname.data, open->op_fname.len)))
 978                         return status;
 979                 break;
 980         case NFS4_OPEN_CLAIM_PREVIOUS:
 981                 READ_BUF(4);
 982                 open->op_delegate_type = be32_to_cpup(p++);
 983                 break;
 984         case NFS4_OPEN_CLAIM_DELEGATE_CUR:
 985                 status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);
 986                 if (status)
 987                         return status;
 988                 READ_BUF(4);
 989                 open->op_fname.len = be32_to_cpup(p++);
 990                 READ_BUF(open->op_fname.len);
 991                 SAVEMEM(open->op_fname.data, open->op_fname.len);
 992                 if ((status = check_filename(open->op_fname.data, open->op_fname.len)))
 993                         return status;
 994                 break;
 995         case NFS4_OPEN_CLAIM_FH:
 996         case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
 997                 if (argp->minorversion < 1)
 998                         goto xdr_error;
 999                 /* void */
1000                 break;
1001         case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1002                 if (argp->minorversion < 1)
1003                         goto xdr_error;
1004                 status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);
1005                 if (status)
1006                         return status;
1007                 break;
1008         default:
1009                 goto xdr_error;
1010         }
1011
1012         DECODE_TAIL;
1013 }
1014
1015 static __be32
1016 nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf)
1017 {
1018         DECODE_HEAD;
1019
1020         if (argp->minorversion >= 1)
1021                 return nfserr_notsupp;
1022
1023         status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid);
1024         if (status)
1025                 return status;
1026         READ_BUF(4);
1027         open_conf->oc_seqid = be32_to_cpup(p++);
1028
1029         DECODE_TAIL;
1030 }
1031
1032 static __be32
1033 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down)
1034 {
1035         DECODE_HEAD;
1036
1037         status = nfsd4_decode_stateid(argp, &open_down->od_stateid);
1038         if (status)
1039                 return status;
1040         READ_BUF(4);
1041         open_down->od_seqid = be32_to_cpup(p++);
1042         status = nfsd4_decode_share_access(argp, &open_down->od_share_access,
1043                                            &open_down->od_deleg_want, NULL);
1044         if (status)
1045                 return status;
1046         status = nfsd4_decode_share_deny(argp, &open_down->od_share_deny);
1047         if (status)
1048                 return status;
1049         DECODE_TAIL;
1050 }
1051
1052 static __be32
1053 nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh)
1054 {
1055         DECODE_HEAD;
1056
1057         READ_BUF(4);
1058         putfh->pf_fhlen = be32_to_cpup(p++);
1059         if (putfh->pf_fhlen > NFS4_FHSIZE)
1060                 goto xdr_error;
1061         READ_BUF(putfh->pf_fhlen);
1062         SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen);
1063
1064         DECODE_TAIL;
1065 }
1066
1067 static __be32
1068 nfsd4_decode_putpubfh(struct nfsd4_compoundargs *argp, void *p)
1069 {
1070         if (argp->minorversion == 0)
1071                 return nfs_ok;
1072         return nfserr_notsupp;
1073 }
1074
1075 static __be32
1076 nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read)
1077 {
1078         DECODE_HEAD;
1079
1080         status = nfsd4_decode_stateid(argp, &read->rd_stateid);
1081         if (status)
1082                 return status;
1083         READ_BUF(12);
1084         p = xdr_decode_hyper(p, &read->rd_offset);
1085         read->rd_length = be32_to_cpup(p++);
1086
1087         DECODE_TAIL;
1088 }
1089
1090 static __be32
1091 nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir)
1092 {
1093         DECODE_HEAD;
1094
1095         READ_BUF(24);
1096         p = xdr_decode_hyper(p, &readdir->rd_cookie);
1097         COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data));
1098         readdir->rd_dircount = be32_to_cpup(p++);
1099         readdir->rd_maxcount = be32_to_cpup(p++);
1100         if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval)))
1101                 goto out;
1102
1103         DECODE_TAIL;
1104 }
1105
1106 static __be32
1107 nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove)
1108 {
1109         DECODE_HEAD;
1110
1111         READ_BUF(4);
1112         remove->rm_namelen = be32_to_cpup(p++);
1113         READ_BUF(remove->rm_namelen);
1114         SAVEMEM(remove->rm_name, remove->rm_namelen);
1115         if ((status = check_filename(remove->rm_name, remove->rm_namelen)))
1116                 return status;
1117
1118         DECODE_TAIL;
1119 }
1120
1121 static __be32
1122 nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename)
1123 {
1124         DECODE_HEAD;
1125
1126         READ_BUF(4);
1127         rename->rn_snamelen = be32_to_cpup(p++);
1128         READ_BUF(rename->rn_snamelen);
1129         SAVEMEM(rename->rn_sname, rename->rn_snamelen);
1130         READ_BUF(4);
1131         rename->rn_tnamelen = be32_to_cpup(p++);
1132         READ_BUF(rename->rn_tnamelen);
1133         SAVEMEM(rename->rn_tname, rename->rn_tnamelen);
1134         if ((status = check_filename(rename->rn_sname, rename->rn_snamelen)))
1135                 return status;
1136         if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen)))
1137                 return status;
1138
1139         DECODE_TAIL;
1140 }
1141
1142 static __be32
1143 nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid)
1144 {
1145         DECODE_HEAD;
1146
1147         if (argp->minorversion >= 1)
1148                 return nfserr_notsupp;
1149
1150         READ_BUF(sizeof(clientid_t));
1151         COPYMEM(clientid, sizeof(clientid_t));
1152
1153         DECODE_TAIL;
1154 }
1155
1156 static __be32
1157 nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp,
1158                      struct nfsd4_secinfo *secinfo)
1159 {
1160         DECODE_HEAD;
1161
1162         READ_BUF(4);
1163         secinfo->si_namelen = be32_to_cpup(p++);
1164         READ_BUF(secinfo->si_namelen);
1165         SAVEMEM(secinfo->si_name, secinfo->si_namelen);
1166         status = check_filename(secinfo->si_name, secinfo->si_namelen);
1167         if (status)
1168                 return status;
1169         DECODE_TAIL;
1170 }
1171
1172 static __be32
1173 nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp,
1174                      struct nfsd4_secinfo_no_name *sin)
1175 {
1176         DECODE_HEAD;
1177
1178         READ_BUF(4);
1179         sin->sin_style = be32_to_cpup(p++);
1180         DECODE_TAIL;
1181 }
1182
1183 static __be32
1184 nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr)
1185 {
1186         __be32 status;
1187
1188         status = nfsd4_decode_stateid(argp, &setattr->sa_stateid);
1189         if (status)
1190                 return status;
1191         return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr,
1192                                   &setattr->sa_acl, &setattr->sa_label, NULL);
1193 }
1194
1195 static __be32
1196 nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid)
1197 {
1198         DECODE_HEAD;
1199
1200         if (argp->minorversion >= 1)
1201                 return nfserr_notsupp;
1202
1203         READ_BUF(NFS4_VERIFIER_SIZE);
1204         COPYMEM(setclientid->se_verf.data, NFS4_VERIFIER_SIZE);
1205
1206         status = nfsd4_decode_opaque(argp, &setclientid->se_name);
1207         if (status)
1208                 return nfserr_bad_xdr;
1209         READ_BUF(8);
1210         setclientid->se_callback_prog = be32_to_cpup(p++);
1211         setclientid->se_callback_netid_len = be32_to_cpup(p++);
1212         READ_BUF(setclientid->se_callback_netid_len);
1213         SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len);
1214         READ_BUF(4);
1215         setclientid->se_callback_addr_len = be32_to_cpup(p++);
1216
1217         READ_BUF(setclientid->se_callback_addr_len);
1218         SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len);
1219         READ_BUF(4);
1220         setclientid->se_callback_ident = be32_to_cpup(p++);
1221
1222         DECODE_TAIL;
1223 }
1224
1225 static __be32
1226 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c)
1227 {
1228         DECODE_HEAD;
1229
1230         if (argp->minorversion >= 1)
1231                 return nfserr_notsupp;
1232
1233         READ_BUF(8 + NFS4_VERIFIER_SIZE);
1234         COPYMEM(&scd_c->sc_clientid, 8);
1235         COPYMEM(&scd_c->sc_confirm, NFS4_VERIFIER_SIZE);
1236
1237         DECODE_TAIL;
1238 }
1239
1240 /* Also used for NVERIFY */
1241 static __be32
1242 nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verify)
1243 {
1244         DECODE_HEAD;
1245
1246         if ((status = nfsd4_decode_bitmap(argp, verify->ve_bmval)))
1247                 goto out;
1248
1249         /* For convenience's sake, we compare raw xdr'd attributes in
1250          * nfsd4_proc_verify */
1251
1252         READ_BUF(4);
1253         verify->ve_attrlen = be32_to_cpup(p++);
1254         READ_BUF(verify->ve_attrlen);
1255         SAVEMEM(verify->ve_attrval, verify->ve_attrlen);
1256
1257         DECODE_TAIL;
1258 }
1259
1260 static __be32
1261 nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write)
1262 {
1263         int avail;
1264         int len;
1265         DECODE_HEAD;
1266
1267         status = nfsd4_decode_stateid(argp, &write->wr_stateid);
1268         if (status)
1269                 return status;
1270         READ_BUF(16);
1271         p = xdr_decode_hyper(p, &write->wr_offset);
1272         write->wr_stable_how = be32_to_cpup(p++);
1273         if (write->wr_stable_how > NFS_FILE_SYNC)
1274                 goto xdr_error;
1275         write->wr_buflen = be32_to_cpup(p++);
1276
1277         /* Sorry .. no magic macros for this.. *
1278          * READ_BUF(write->wr_buflen);
1279          * SAVEMEM(write->wr_buf, write->wr_buflen);
1280          */
1281         avail = (char*)argp->end - (char*)argp->p;
1282         if (avail + argp->pagelen < write->wr_buflen) {
1283                 dprintk("NFSD: xdr error (%s:%d)\n",
1284                                 __FILE__, __LINE__);
1285                 goto xdr_error;
1286         }
1287         write->wr_head.iov_base = p;
1288         write->wr_head.iov_len = avail;
1289         write->wr_pagelist = argp->pagelist;
1290
1291         len = XDR_QUADLEN(write->wr_buflen) << 2;
1292         if (len >= avail) {
1293                 int pages;
1294
1295                 len -= avail;
1296
1297                 pages = len >> PAGE_SHIFT;
1298                 argp->pagelist += pages;
1299                 argp->pagelen -= pages * PAGE_SIZE;
1300                 len -= pages * PAGE_SIZE;
1301
1302                 next_decode_page(argp);
1303         }
1304         argp->p += XDR_QUADLEN(len);
1305
1306         DECODE_TAIL;
1307 }
1308
1309 static __be32
1310 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner)
1311 {
1312         DECODE_HEAD;
1313
1314         if (argp->minorversion >= 1)
1315                 return nfserr_notsupp;
1316
1317         READ_BUF(12);
1318         COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t));
1319         rlockowner->rl_owner.len = be32_to_cpup(p++);
1320         READ_BUF(rlockowner->rl_owner.len);
1321         READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len);
1322
1323         if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))
1324                 return nfserr_inval;
1325         DECODE_TAIL;
1326 }
1327
1328 static __be32
1329 nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp,
1330                          struct nfsd4_exchange_id *exid)
1331 {
1332         int dummy, tmp;
1333         DECODE_HEAD;
1334
1335         READ_BUF(NFS4_VERIFIER_SIZE);
1336         COPYMEM(exid->verifier.data, NFS4_VERIFIER_SIZE);
1337
1338         status = nfsd4_decode_opaque(argp, &exid->clname);
1339         if (status)
1340                 return nfserr_bad_xdr;
1341
1342         READ_BUF(4);
1343         exid->flags = be32_to_cpup(p++);
1344
1345         /* Ignore state_protect4_a */
1346         READ_BUF(4);
1347         exid->spa_how = be32_to_cpup(p++);
1348         switch (exid->spa_how) {
1349         case SP4_NONE:
1350                 break;
1351         case SP4_MACH_CRED:
1352                 /* spo_must_enforce */
1353                 status = nfsd4_decode_bitmap(argp,
1354                                         exid->spo_must_enforce);
1355                 if (status)
1356                         goto out;
1357                 /* spo_must_allow */
1358                 status = nfsd4_decode_bitmap(argp, exid->spo_must_allow);
1359                 if (status)
1360                         goto out;
1361                 break;
1362         case SP4_SSV:
1363                 /* ssp_ops */
1364                 READ_BUF(4);
1365                 dummy = be32_to_cpup(p++);
1366                 READ_BUF(dummy * 4);
1367                 p += dummy;
1368
1369                 READ_BUF(4);
1370                 dummy = be32_to_cpup(p++);
1371                 READ_BUF(dummy * 4);
1372                 p += dummy;
1373
1374                 /* ssp_hash_algs<> */
1375                 READ_BUF(4);
1376                 tmp = be32_to_cpup(p++);
1377                 while (tmp--) {
1378                         READ_BUF(4);
1379                         dummy = be32_to_cpup(p++);
1380                         READ_BUF(dummy);
1381                         p += XDR_QUADLEN(dummy);
1382                 }
1383
1384                 /* ssp_encr_algs<> */
1385                 READ_BUF(4);
1386                 tmp = be32_to_cpup(p++);
1387                 while (tmp--) {
1388                         READ_BUF(4);
1389                         dummy = be32_to_cpup(p++);
1390                         READ_BUF(dummy);
1391                         p += XDR_QUADLEN(dummy);
1392                 }
1393
1394                 /* ignore ssp_window and ssp_num_gss_handles: */
1395                 READ_BUF(8);
1396                 break;
1397         default:
1398                 goto xdr_error;
1399         }
1400
1401         /* Ignore Implementation ID */
1402         READ_BUF(4);    /* nfs_impl_id4 array length */
1403         dummy = be32_to_cpup(p++);
1404
1405         if (dummy > 1)
1406                 goto xdr_error;
1407
1408         if (dummy == 1) {
1409                 /* nii_domain */
1410                 READ_BUF(4);
1411                 dummy = be32_to_cpup(p++);
1412                 READ_BUF(dummy);
1413                 p += XDR_QUADLEN(dummy);
1414
1415                 /* nii_name */
1416                 READ_BUF(4);
1417                 dummy = be32_to_cpup(p++);
1418                 READ_BUF(dummy);
1419                 p += XDR_QUADLEN(dummy);
1420
1421                 /* nii_date */
1422                 READ_BUF(12);
1423                 p += 3;
1424         }
1425         DECODE_TAIL;
1426 }
1427
1428 static __be32
1429 nfsd4_decode_create_session(struct nfsd4_compoundargs *argp,
1430                             struct nfsd4_create_session *sess)
1431 {
1432         DECODE_HEAD;
1433         u32 dummy;
1434
1435         READ_BUF(16);
1436         COPYMEM(&sess->clientid, 8);
1437         sess->seqid = be32_to_cpup(p++);
1438         sess->flags = be32_to_cpup(p++);
1439
1440         /* Fore channel attrs */
1441         READ_BUF(28);
1442         dummy = be32_to_cpup(p++); /* headerpadsz is always 0 */
1443         sess->fore_channel.maxreq_sz = be32_to_cpup(p++);
1444         sess->fore_channel.maxresp_sz = be32_to_cpup(p++);
1445         sess->fore_channel.maxresp_cached = be32_to_cpup(p++);
1446         sess->fore_channel.maxops = be32_to_cpup(p++);
1447         sess->fore_channel.maxreqs = be32_to_cpup(p++);
1448         sess->fore_channel.nr_rdma_attrs = be32_to_cpup(p++);
1449         if (sess->fore_channel.nr_rdma_attrs == 1) {
1450                 READ_BUF(4);
1451                 sess->fore_channel.rdma_attrs = be32_to_cpup(p++);
1452         } else if (sess->fore_channel.nr_rdma_attrs > 1) {
1453                 dprintk("Too many fore channel attr bitmaps!\n");
1454                 goto xdr_error;
1455         }
1456
1457         /* Back channel attrs */
1458         READ_BUF(28);
1459         dummy = be32_to_cpup(p++); /* headerpadsz is always 0 */
1460         sess->back_channel.maxreq_sz = be32_to_cpup(p++);
1461         sess->back_channel.maxresp_sz = be32_to_cpup(p++);
1462         sess->back_channel.maxresp_cached = be32_to_cpup(p++);
1463         sess->back_channel.maxops = be32_to_cpup(p++);
1464         sess->back_channel.maxreqs = be32_to_cpup(p++);
1465         sess->back_channel.nr_rdma_attrs = be32_to_cpup(p++);
1466         if (sess->back_channel.nr_rdma_attrs == 1) {
1467                 READ_BUF(4);
1468                 sess->back_channel.rdma_attrs = be32_to_cpup(p++);
1469         } else if (sess->back_channel.nr_rdma_attrs > 1) {
1470                 dprintk("Too many back channel attr bitmaps!\n");
1471                 goto xdr_error;
1472         }
1473
1474         READ_BUF(4);
1475         sess->callback_prog = be32_to_cpup(p++);
1476         nfsd4_decode_cb_sec(argp, &sess->cb_sec);
1477         DECODE_TAIL;
1478 }
1479
1480 static __be32
1481 nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp,
1482                              struct nfsd4_destroy_session *destroy_session)
1483 {
1484         DECODE_HEAD;
1485         READ_BUF(NFS4_MAX_SESSIONID_LEN);
1486         COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN);
1487
1488         DECODE_TAIL;
1489 }
1490
1491 static __be32
1492 nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp,
1493                           struct nfsd4_free_stateid *free_stateid)
1494 {
1495         DECODE_HEAD;
1496
1497         READ_BUF(sizeof(stateid_t));
1498         free_stateid->fr_stateid.si_generation = be32_to_cpup(p++);
1499         COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t));
1500
1501         DECODE_TAIL;
1502 }
1503
1504 static __be32
1505 nfsd4_decode_sequence(struct nfsd4_compoundargs *argp,
1506                       struct nfsd4_sequence *seq)
1507 {
1508         DECODE_HEAD;
1509
1510         READ_BUF(NFS4_MAX_SESSIONID_LEN + 16);
1511         COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);
1512         seq->seqid = be32_to_cpup(p++);
1513         seq->slotid = be32_to_cpup(p++);
1514         seq->maxslots = be32_to_cpup(p++);
1515         seq->cachethis = be32_to_cpup(p++);
1516
1517         DECODE_TAIL;
1518 }
1519
1520 static __be32
1521 nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid)
1522 {
1523         int i;
1524         __be32 *p, status;
1525         struct nfsd4_test_stateid_id *stateid;
1526
1527         READ_BUF(4);
1528         test_stateid->ts_num_ids = ntohl(*p++);
1529
1530         INIT_LIST_HEAD(&test_stateid->ts_stateid_list);
1531
1532         for (i = 0; i < test_stateid->ts_num_ids; i++) {
1533                 stateid = svcxdr_tmpalloc(argp, sizeof(*stateid));
1534                 if (!stateid) {
1535                         status = nfserrno(-ENOMEM);
1536                         goto out;
1537                 }
1538
1539                 INIT_LIST_HEAD(&stateid->ts_id_list);
1540                 list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list);
1541
1542                 status = nfsd4_decode_stateid(argp, &stateid->ts_id_stateid);
1543                 if (status)
1544                         goto out;
1545         }
1546
1547         status = 0;
1548 out:
1549         return status;
1550 xdr_error:
1551         dprintk("NFSD: xdr error (%s:%d)\n", __FILE__, __LINE__);
1552         status = nfserr_bad_xdr;
1553         goto out;
1554 }
1555
1556 static __be32 nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs *argp, struct nfsd4_destroy_clientid *dc)
1557 {
1558         DECODE_HEAD;
1559
1560         READ_BUF(8);
1561         COPYMEM(&dc->clientid, 8);
1562
1563         DECODE_TAIL;
1564 }
1565
1566 static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, struct nfsd4_reclaim_complete *rc)
1567 {
1568         DECODE_HEAD;
1569
1570         READ_BUF(4);
1571         rc->rca_one_fs = be32_to_cpup(p++);
1572
1573         DECODE_TAIL;
1574 }
1575
1576 #ifdef CONFIG_NFSD_PNFS
1577 static __be32
1578 nfsd4_decode_getdeviceinfo(struct nfsd4_compoundargs *argp,
1579                 struct nfsd4_getdeviceinfo *gdev)
1580 {
1581         DECODE_HEAD;
1582         u32 num, i;
1583
1584         READ_BUF(sizeof(struct nfsd4_deviceid) + 3 * 4);
1585         COPYMEM(&gdev->gd_devid, sizeof(struct nfsd4_deviceid));
1586         gdev->gd_layout_type = be32_to_cpup(p++);
1587         gdev->gd_maxcount = be32_to_cpup(p++);
1588         num = be32_to_cpup(p++);
1589         if (num) {
1590                 if (num > 1000)
1591                         goto xdr_error;
1592                 READ_BUF(4 * num);
1593                 gdev->gd_notify_types = be32_to_cpup(p++);
1594                 for (i = 1; i < num; i++) {
1595                         if (be32_to_cpup(p++)) {
1596                                 status = nfserr_inval;
1597                                 goto out;
1598                         }
1599                 }
1600         }
1601         DECODE_TAIL;
1602 }
1603
1604 static __be32
1605 nfsd4_decode_layoutget(struct nfsd4_compoundargs *argp,
1606                 struct nfsd4_layoutget *lgp)
1607 {
1608         DECODE_HEAD;
1609
1610         READ_BUF(36);
1611         lgp->lg_signal = be32_to_cpup(p++);
1612         lgp->lg_layout_type = be32_to_cpup(p++);
1613         lgp->lg_seg.iomode = be32_to_cpup(p++);
1614         p = xdr_decode_hyper(p, &lgp->lg_seg.offset);
1615         p = xdr_decode_hyper(p, &lgp->lg_seg.length);
1616         p = xdr_decode_hyper(p, &lgp->lg_minlength);
1617
1618         status = nfsd4_decode_stateid(argp, &lgp->lg_sid);
1619         if (status)
1620                 return status;
1621
1622         READ_BUF(4);
1623         lgp->lg_maxcount = be32_to_cpup(p++);
1624
1625         DECODE_TAIL;
1626 }
1627
1628 static __be32
1629 nfsd4_decode_layoutcommit(struct nfsd4_compoundargs *argp,
1630                 struct nfsd4_layoutcommit *lcp)
1631 {
1632         DECODE_HEAD;
1633         u32 timechange;
1634
1635         READ_BUF(20);
1636         p = xdr_decode_hyper(p, &lcp->lc_seg.offset);
1637         p = xdr_decode_hyper(p, &lcp->lc_seg.length);
1638         lcp->lc_reclaim = be32_to_cpup(p++);
1639
1640         status = nfsd4_decode_stateid(argp, &lcp->lc_sid);
1641         if (status)
1642                 return status;
1643
1644         READ_BUF(4);
1645         lcp->lc_newoffset = be32_to_cpup(p++);
1646         if (lcp->lc_newoffset) {
1647                 READ_BUF(8);
1648                 p = xdr_decode_hyper(p, &lcp->lc_last_wr);
1649         } else
1650                 lcp->lc_last_wr = 0;
1651         READ_BUF(4);
1652         timechange = be32_to_cpup(p++);
1653         if (timechange) {
1654                 status = nfsd4_decode_time(argp, &lcp->lc_mtime);
1655                 if (status)
1656                         return status;
1657         } else {
1658                 lcp->lc_mtime.tv_nsec = UTIME_NOW;
1659         }
1660         READ_BUF(8);
1661         lcp->lc_layout_type = be32_to_cpup(p++);
1662
1663         /*
1664          * Save the layout update in XDR format and let the layout driver deal
1665          * with it later.
1666          */
1667         lcp->lc_up_len = be32_to_cpup(p++);
1668         if (lcp->lc_up_len > 0) {
1669                 READ_BUF(lcp->lc_up_len);
1670                 READMEM(lcp->lc_up_layout, lcp->lc_up_len);
1671         }
1672
1673         DECODE_TAIL;
1674 }
1675
1676 static __be32
1677 nfsd4_decode_layoutreturn(struct nfsd4_compoundargs *argp,
1678                 struct nfsd4_layoutreturn *lrp)
1679 {
1680         DECODE_HEAD;
1681
1682         READ_BUF(16);
1683         lrp->lr_reclaim = be32_to_cpup(p++);
1684         lrp->lr_layout_type = be32_to_cpup(p++);
1685         lrp->lr_seg.iomode = be32_to_cpup(p++);
1686         lrp->lr_return_type = be32_to_cpup(p++);
1687         if (lrp->lr_return_type == RETURN_FILE) {
1688                 READ_BUF(16);
1689                 p = xdr_decode_hyper(p, &lrp->lr_seg.offset);
1690                 p = xdr_decode_hyper(p, &lrp->lr_seg.length);
1691
1692                 status = nfsd4_decode_stateid(argp, &lrp->lr_sid);
1693                 if (status)
1694                         return status;
1695
1696                 READ_BUF(4);
1697                 lrp->lrf_body_len = be32_to_cpup(p++);
1698                 if (lrp->lrf_body_len > 0) {
1699                         READ_BUF(lrp->lrf_body_len);
1700                         READMEM(lrp->lrf_body, lrp->lrf_body_len);
1701                 }
1702         } else {
1703                 lrp->lr_seg.offset = 0;
1704                 lrp->lr_seg.length = NFS4_MAX_UINT64;
1705         }
1706
1707         DECODE_TAIL;
1708 }
1709 #endif /* CONFIG_NFSD_PNFS */
1710
1711 static __be32
1712 nfsd4_decode_fallocate(struct nfsd4_compoundargs *argp,
1713                        struct nfsd4_fallocate *fallocate)
1714 {
1715         DECODE_HEAD;
1716
1717         status = nfsd4_decode_stateid(argp, &fallocate->falloc_stateid);
1718         if (status)
1719                 return status;
1720
1721         READ_BUF(16);
1722         p = xdr_decode_hyper(p, &fallocate->falloc_offset);
1723         xdr_decode_hyper(p, &fallocate->falloc_length);
1724
1725         DECODE_TAIL;
1726 }
1727
1728 static __be32
1729 nfsd4_decode_clone(struct nfsd4_compoundargs *argp, struct nfsd4_clone *clone)
1730 {
1731         DECODE_HEAD;
1732
1733         status = nfsd4_decode_stateid(argp, &clone->cl_src_stateid);
1734         if (status)
1735                 return status;
1736         status = nfsd4_decode_stateid(argp, &clone->cl_dst_stateid);
1737         if (status)
1738                 return status;
1739
1740         READ_BUF(8 + 8 + 8);
1741         p = xdr_decode_hyper(p, &clone->cl_src_pos);
1742         p = xdr_decode_hyper(p, &clone->cl_dst_pos);
1743         p = xdr_decode_hyper(p, &clone->cl_count);
1744         DECODE_TAIL;
1745 }
1746
1747 static __be32
1748 nfsd4_decode_copy(struct nfsd4_compoundargs *argp, struct nfsd4_copy *copy)
1749 {
1750         DECODE_HEAD;
1751         unsigned int tmp;
1752
1753         status = nfsd4_decode_stateid(argp, &copy->cp_src_stateid);
1754         if (status)
1755                 return status;
1756         status = nfsd4_decode_stateid(argp, &copy->cp_dst_stateid);
1757         if (status)
1758                 return status;
1759
1760         READ_BUF(8 + 8 + 8 + 4 + 4 + 4);
1761         p = xdr_decode_hyper(p, &copy->cp_src_pos);
1762         p = xdr_decode_hyper(p, &copy->cp_dst_pos);
1763         p = xdr_decode_hyper(p, &copy->cp_count);
1764         p++; /* ca_consecutive: we always do consecutive copies */
1765         copy->cp_synchronous = be32_to_cpup(p++);
1766         tmp = be32_to_cpup(p); /* Source server list not supported */
1767
1768         DECODE_TAIL;
1769 }
1770
1771 static __be32
1772 nfsd4_decode_offload_status(struct nfsd4_compoundargs *argp,
1773                             struct nfsd4_offload_status *os)
1774 {
1775         return nfsd4_decode_stateid(argp, &os->stateid);
1776 }
1777
1778 static __be32
1779 nfsd4_decode_seek(struct nfsd4_compoundargs *argp, struct nfsd4_seek *seek)
1780 {
1781         DECODE_HEAD;
1782
1783         status = nfsd4_decode_stateid(argp, &seek->seek_stateid);
1784         if (status)
1785                 return status;
1786
1787         READ_BUF(8 + 4);
1788         p = xdr_decode_hyper(p, &seek->seek_offset);
1789         seek->seek_whence = be32_to_cpup(p);
1790
1791         DECODE_TAIL;
1792 }
1793
1794 static __be32
1795 nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p)
1796 {
1797         return nfs_ok;
1798 }
1799
1800 static __be32
1801 nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p)
1802 {
1803         return nfserr_notsupp;
1804 }
1805
1806 typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *);
1807
1808 static const nfsd4_dec nfsd4_dec_ops[] = {
1809         [OP_ACCESS]             = (nfsd4_dec)nfsd4_decode_access,
1810         [OP_CLOSE]              = (nfsd4_dec)nfsd4_decode_close,
1811         [OP_COMMIT]             = (nfsd4_dec)nfsd4_decode_commit,
1812         [OP_CREATE]             = (nfsd4_dec)nfsd4_decode_create,
1813         [OP_DELEGPURGE]         = (nfsd4_dec)nfsd4_decode_notsupp,
1814         [OP_DELEGRETURN]        = (nfsd4_dec)nfsd4_decode_delegreturn,
1815         [OP_GETATTR]            = (nfsd4_dec)nfsd4_decode_getattr,
1816         [OP_GETFH]              = (nfsd4_dec)nfsd4_decode_noop,
1817         [OP_LINK]               = (nfsd4_dec)nfsd4_decode_link,
1818         [OP_LOCK]               = (nfsd4_dec)nfsd4_decode_lock,
1819         [OP_LOCKT]              = (nfsd4_dec)nfsd4_decode_lockt,
1820         [OP_LOCKU]              = (nfsd4_dec)nfsd4_decode_locku,
1821         [OP_LOOKUP]             = (nfsd4_dec)nfsd4_decode_lookup,
1822         [OP_LOOKUPP]            = (nfsd4_dec)nfsd4_decode_noop,
1823         [OP_NVERIFY]            = (nfsd4_dec)nfsd4_decode_verify,
1824         [OP_OPEN]               = (nfsd4_dec)nfsd4_decode_open,
1825         [OP_OPENATTR]           = (nfsd4_dec)nfsd4_decode_notsupp,
1826         [OP_OPEN_CONFIRM]       = (nfsd4_dec)nfsd4_decode_open_confirm,
1827         [OP_OPEN_DOWNGRADE]     = (nfsd4_dec)nfsd4_decode_open_downgrade,
1828         [OP_PUTFH]              = (nfsd4_dec)nfsd4_decode_putfh,
1829         [OP_PUTPUBFH]           = (nfsd4_dec)nfsd4_decode_putpubfh,
1830         [OP_PUTROOTFH]          = (nfsd4_dec)nfsd4_decode_noop,
1831         [OP_READ]               = (nfsd4_dec)nfsd4_decode_read,
1832         [OP_READDIR]            = (nfsd4_dec)nfsd4_decode_readdir,
1833         [OP_READLINK]           = (nfsd4_dec)nfsd4_decode_noop,
1834         [OP_REMOVE]             = (nfsd4_dec)nfsd4_decode_remove,
1835         [OP_RENAME]             = (nfsd4_dec)nfsd4_decode_rename,
1836         [OP_RENEW]              = (nfsd4_dec)nfsd4_decode_renew,
1837         [OP_RESTOREFH]          = (nfsd4_dec)nfsd4_decode_noop,
1838         [OP_SAVEFH]             = (nfsd4_dec)nfsd4_decode_noop,
1839         [OP_SECINFO]            = (nfsd4_dec)nfsd4_decode_secinfo,
1840         [OP_SETATTR]            = (nfsd4_dec)nfsd4_decode_setattr,
1841         [OP_SETCLIENTID]        = (nfsd4_dec)nfsd4_decode_setclientid,
1842         [OP_SETCLIENTID_CONFIRM] = (nfsd4_dec)nfsd4_decode_setclientid_confirm,
1843         [OP_VERIFY]             = (nfsd4_dec)nfsd4_decode_verify,
1844         [OP_WRITE]              = (nfsd4_dec)nfsd4_decode_write,
1845         [OP_RELEASE_LOCKOWNER]  = (nfsd4_dec)nfsd4_decode_release_lockowner,
1846
1847         /* new operations for NFSv4.1 */
1848         [OP_BACKCHANNEL_CTL]    = (nfsd4_dec)nfsd4_decode_backchannel_ctl,
1849         [OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session,
1850         [OP_EXCHANGE_ID]        = (nfsd4_dec)nfsd4_decode_exchange_id,
1851         [OP_CREATE_SESSION]     = (nfsd4_dec)nfsd4_decode_create_session,
1852         [OP_DESTROY_SESSION]    = (nfsd4_dec)nfsd4_decode_destroy_session,
1853         [OP_FREE_STATEID]       = (nfsd4_dec)nfsd4_decode_free_stateid,
1854         [OP_GET_DIR_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp,
1855 #ifdef CONFIG_NFSD_PNFS
1856         [OP_GETDEVICEINFO]      = (nfsd4_dec)nfsd4_decode_getdeviceinfo,
1857         [OP_GETDEVICELIST]      = (nfsd4_dec)nfsd4_decode_notsupp,
1858         [OP_LAYOUTCOMMIT]       = (nfsd4_dec)nfsd4_decode_layoutcommit,
1859         [OP_LAYOUTGET]          = (nfsd4_dec)nfsd4_decode_layoutget,
1860         [OP_LAYOUTRETURN]       = (nfsd4_dec)nfsd4_decode_layoutreturn,
1861 #else
1862         [OP_GETDEVICEINFO]      = (nfsd4_dec)nfsd4_decode_notsupp,
1863         [OP_GETDEVICELIST]      = (nfsd4_dec)nfsd4_decode_notsupp,
1864         [OP_LAYOUTCOMMIT]       = (nfsd4_dec)nfsd4_decode_notsupp,
1865         [OP_LAYOUTGET]          = (nfsd4_dec)nfsd4_decode_notsupp,
1866         [OP_LAYOUTRETURN]       = (nfsd4_dec)nfsd4_decode_notsupp,
1867 #endif
1868         [OP_SECINFO_NO_NAME]    = (nfsd4_dec)nfsd4_decode_secinfo_no_name,
1869         [OP_SEQUENCE]           = (nfsd4_dec)nfsd4_decode_sequence,
1870         [OP_SET_SSV]            = (nfsd4_dec)nfsd4_decode_notsupp,
1871         [OP_TEST_STATEID]       = (nfsd4_dec)nfsd4_decode_test_stateid,
1872         [OP_WANT_DELEGATION]    = (nfsd4_dec)nfsd4_decode_notsupp,
1873         [OP_DESTROY_CLIENTID]   = (nfsd4_dec)nfsd4_decode_destroy_clientid,
1874         [OP_RECLAIM_COMPLETE]   = (nfsd4_dec)nfsd4_decode_reclaim_complete,
1875
1876         /* new operations for NFSv4.2 */
1877         [OP_ALLOCATE]           = (nfsd4_dec)nfsd4_decode_fallocate,
1878         [OP_COPY]               = (nfsd4_dec)nfsd4_decode_copy,
1879         [OP_COPY_NOTIFY]        = (nfsd4_dec)nfsd4_decode_notsupp,
1880         [OP_DEALLOCATE]         = (nfsd4_dec)nfsd4_decode_fallocate,
1881         [OP_IO_ADVISE]          = (nfsd4_dec)nfsd4_decode_notsupp,
1882         [OP_LAYOUTERROR]        = (nfsd4_dec)nfsd4_decode_notsupp,
1883         [OP_LAYOUTSTATS]        = (nfsd4_dec)nfsd4_decode_notsupp,
1884         [OP_OFFLOAD_CANCEL]     = (nfsd4_dec)nfsd4_decode_offload_status,
1885         [OP_OFFLOAD_STATUS]     = (nfsd4_dec)nfsd4_decode_offload_status,
1886         [OP_READ_PLUS]          = (nfsd4_dec)nfsd4_decode_notsupp,
1887         [OP_SEEK]               = (nfsd4_dec)nfsd4_decode_seek,
1888         [OP_WRITE_SAME]         = (nfsd4_dec)nfsd4_decode_notsupp,
1889         [OP_CLONE]              = (nfsd4_dec)nfsd4_decode_clone,
1890 };
1891
1892 static inline bool
1893 nfsd4_opnum_in_range(struct nfsd4_compoundargs *argp, struct nfsd4_op *op)
1894 {
1895         if (op->opnum < FIRST_NFS4_OP)
1896                 return false;
1897         else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP)
1898                 return false;
1899         else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP)
1900                 return false;
1901         else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP)
1902                 return false;
1903         return true;
1904 }
1905
1906 static __be32
1907 nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
1908 {
1909         DECODE_HEAD;
1910         struct nfsd4_op *op;
1911         bool cachethis = false;
1912         int auth_slack= argp->rqstp->rq_auth_slack;
1913         int max_reply = auth_slack + 8; /* opcnt, status */
1914         int readcount = 0;
1915         int readbytes = 0;
1916         int i;
1917
1918         READ_BUF(4);
1919         argp->taglen = be32_to_cpup(p++);
1920         READ_BUF(argp->taglen);
1921         SAVEMEM(argp->tag, argp->taglen);
1922         READ_BUF(8);
1923         argp->minorversion = be32_to_cpup(p++);
1924         argp->opcnt = be32_to_cpup(p++);
1925         max_reply += 4 + (XDR_QUADLEN(argp->taglen) << 2);
1926
1927         if (argp->taglen > NFSD4_MAX_TAGLEN)
1928                 goto xdr_error;
1929         /*
1930          * NFS4ERR_RESOURCE is a more helpful error than GARBAGE_ARGS
1931          * here, so we return success at the xdr level so that
1932          * nfsd4_proc can handle this is an NFS-level error.
1933          */
1934         if (argp->opcnt > NFSD_MAX_OPS_PER_COMPOUND)
1935                 return 0;
1936
1937         if (argp->opcnt > ARRAY_SIZE(argp->iops)) {
1938                 argp->ops = kzalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);
1939                 if (!argp->ops) {
1940                         argp->ops = argp->iops;
1941                         dprintk("nfsd: couldn't allocate room for COMPOUND\n");
1942                         goto xdr_error;
1943                 }
1944         }
1945
1946         if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION)
1947                 argp->opcnt = 0;
1948
1949         for (i = 0; i < argp->opcnt; i++) {
1950                 op = &argp->ops[i];
1951                 op->replay = NULL;
1952
1953                 READ_BUF(4);
1954                 op->opnum = be32_to_cpup(p++);
1955
1956                 if (nfsd4_opnum_in_range(argp, op))
1957                         op->status = nfsd4_dec_ops[op->opnum](argp, &op->u);
1958                 else {
1959                         op->opnum = OP_ILLEGAL;
1960                         op->status = nfserr_op_illegal;
1961                 }
1962                 op->opdesc = OPDESC(op);
1963                 /*
1964                  * We'll try to cache the result in the DRC if any one
1965                  * op in the compound wants to be cached:
1966                  */
1967                 cachethis |= nfsd4_cache_this_op(op);
1968
1969                 if (op->opnum == OP_READ) {
1970                         readcount++;
1971                         readbytes += nfsd4_max_reply(argp->rqstp, op);
1972                 } else
1973                         max_reply += nfsd4_max_reply(argp->rqstp, op);
1974                 /*
1975                  * OP_LOCK and OP_LOCKT may return a conflicting lock.
1976                  * (Special case because it will just skip encoding this
1977                  * if it runs out of xdr buffer space, and it is the only
1978                  * operation that behaves this way.)
1979                  */
1980                 if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT)
1981                         max_reply += NFS4_OPAQUE_LIMIT;
1982
1983                 if (op->status) {
1984                         argp->opcnt = i+1;
1985                         break;
1986                 }
1987         }
1988         /* Sessions make the DRC unnecessary: */
1989         if (argp->minorversion)
1990                 cachethis = false;
1991         svc_reserve(argp->rqstp, max_reply + readbytes);
1992         argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;
1993
1994         if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack)
1995                 clear_bit(RQ_SPLICE_OK, &argp->rqstp->rq_flags);
1996
1997         DECODE_TAIL;
1998 }
1999
2000 static __be32 *encode_change(__be32 *p, struct kstat *stat, struct inode *inode,
2001                              struct svc_export *exp)
2002 {
2003         if (exp->ex_flags & NFSEXP_V4ROOT) {
2004                 *p++ = cpu_to_be32(convert_to_wallclock(exp->cd->flush_time));
2005                 *p++ = 0;
2006         } else if (IS_I_VERSION(inode)) {
2007                 p = xdr_encode_hyper(p, nfsd4_change_attribute(stat, inode));
2008         } else {
2009                 *p++ = cpu_to_be32(stat->ctime.tv_sec);
2010                 *p++ = cpu_to_be32(stat->ctime.tv_nsec);
2011         }
2012         return p;
2013 }
2014
2015 /*
2016  * ctime (in NFSv4, time_metadata) is not writeable, and the client
2017  * doesn't really care what resolution could theoretically be stored by
2018  * the filesystem.
2019  *
2020  * The client cares how close together changes can be while still
2021  * guaranteeing ctime changes.  For most filesystems (which have
2022  * timestamps with nanosecond fields) that is limited by the resolution
2023  * of the time returned from current_time() (which I'm assuming to be
2024  * 1/HZ).
2025  */
2026 static __be32 *encode_time_delta(__be32 *p, struct inode *inode)
2027 {
2028         struct timespec ts;
2029         u32 ns;
2030
2031         ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran);
2032         ts = ns_to_timespec(ns);
2033
2034         p = xdr_encode_hyper(p, ts.tv_sec);
2035         *p++ = cpu_to_be32(ts.tv_nsec);
2036
2037         return p;
2038 }
2039
2040 static __be32 *encode_cinfo(__be32 *p, struct nfsd4_change_info *c)
2041 {
2042         *p++ = cpu_to_be32(c->atomic);
2043         if (c->change_supported) {
2044                 p = xdr_encode_hyper(p, c->before_change);
2045                 p = xdr_encode_hyper(p, c->after_change);
2046         } else {
2047                 *p++ = cpu_to_be32(c->before_ctime_sec);
2048                 *p++ = cpu_to_be32(c->before_ctime_nsec);
2049                 *p++ = cpu_to_be32(c->after_ctime_sec);
2050                 *p++ = cpu_to_be32(c->after_ctime_nsec);
2051         }
2052         return p;
2053 }
2054
2055 /* Encode as an array of strings the string given with components
2056  * separated @sep, escaped with esc_enter and esc_exit.
2057  */
2058 static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep,
2059                                           char *components, char esc_enter,
2060                                           char esc_exit)
2061 {
2062         __be32 *p;
2063         __be32 pathlen;
2064         int pathlen_offset;
2065         int strlen, count=0;
2066         char *str, *end, *next;
2067
2068         dprintk("nfsd4_encode_components(%s)\n", components);
2069
2070         pathlen_offset = xdr->buf->len;
2071         p = xdr_reserve_space(xdr, 4);
2072         if (!p)
2073                 return nfserr_resource;
2074         p++; /* We will fill this in with @count later */
2075
2076         end = str = components;
2077         while (*end) {
2078                 bool found_esc = false;
2079
2080                 /* try to parse as esc_start, ..., esc_end, sep */
2081                 if (*str == esc_enter) {
2082                         for (; *end && (*end != esc_exit); end++)
2083                                 /* find esc_exit or end of string */;
2084                         next = end + 1;
2085                         if (*end && (!*next || *next == sep)) {
2086                                 str++;
2087                                 found_esc = true;
2088                         }
2089                 }
2090
2091                 if (!found_esc)
2092                         for (; *end && (*end != sep); end++)
2093                                 /* find sep or end of string */;
2094
2095                 strlen = end - str;
2096                 if (strlen) {
2097                         p = xdr_reserve_space(xdr, strlen + 4);
2098                         if (!p)
2099                                 return nfserr_resource;
2100                         p = xdr_encode_opaque(p, str, strlen);
2101                         count++;
2102                 }
2103                 else
2104                         end++;
2105                 if (found_esc)
2106                         end = next;
2107
2108                 str = end;
2109         }
2110         pathlen = htonl(count);
2111         write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4);
2112         return 0;
2113 }
2114
2115 /* Encode as an array of strings the string given with components
2116  * separated @sep.
2117  */
2118 static __be32 nfsd4_encode_components(struct xdr_stream *xdr, char sep,
2119                                       char *components)
2120 {
2121         return nfsd4_encode_components_esc(xdr, sep, components, 0, 0);
2122 }
2123
2124 /*
2125  * encode a location element of a fs_locations structure
2126  */
2127 static __be32 nfsd4_encode_fs_location4(struct xdr_stream *xdr,
2128                                         struct nfsd4_fs_location *location)
2129 {
2130         __be32 status;
2131
2132         status = nfsd4_encode_components_esc(xdr, ':', location->hosts,
2133                                                 '[', ']');
2134         if (status)
2135                 return status;
2136         status = nfsd4_encode_components(xdr, '/', location->path);
2137         if (status)
2138                 return status;
2139         return 0;
2140 }
2141
2142 /*
2143  * Encode a path in RFC3530 'pathname4' format
2144  */
2145 static __be32 nfsd4_encode_path(struct xdr_stream *xdr,
2146                                 const struct path *root,
2147                                 const struct path *path)
2148 {
2149         struct path cur = *path;
2150         __be32 *p;
2151         struct dentry **components = NULL;
2152         unsigned int ncomponents = 0;
2153         __be32 err = nfserr_jukebox;
2154
2155         dprintk("nfsd4_encode_components(");
2156
2157         path_get(&cur);
2158         /* First walk the path up to the nfsd root, and store the
2159          * dentries/path components in an array.
2160          */
2161         for (;;) {
2162                 if (path_equal(&cur, root))
2163                         break;
2164                 if (cur.dentry == cur.mnt->mnt_root) {
2165                         if (follow_up(&cur))
2166                                 continue;
2167                         goto out_free;
2168                 }
2169                 if ((ncomponents & 15) == 0) {
2170                         struct dentry **new;
2171                         new = krealloc(components,
2172                                         sizeof(*new) * (ncomponents + 16),
2173                                         GFP_KERNEL);
2174                         if (!new)
2175                                 goto out_free;
2176                         components = new;
2177                 }
2178                 components[ncomponents++] = cur.dentry;
2179                 cur.dentry = dget_parent(cur.dentry);
2180         }
2181         err = nfserr_resource;
2182         p = xdr_reserve_space(xdr, 4);
2183         if (!p)
2184                 goto out_free;
2185         *p++ = cpu_to_be32(ncomponents);
2186
2187         while (ncomponents) {
2188                 struct dentry *dentry = components[ncomponents - 1];
2189                 unsigned int len;
2190
2191                 spin_lock(&dentry->d_lock);
2192                 len = dentry->d_name.len;
2193                 p = xdr_reserve_space(xdr, len + 4);
2194                 if (!p) {
2195                         spin_unlock(&dentry->d_lock);
2196                         goto out_free;
2197                 }
2198                 p = xdr_encode_opaque(p, dentry->d_name.name, len);
2199                 dprintk("/%pd", dentry);
2200                 spin_unlock(&dentry->d_lock);
2201                 dput(dentry);
2202                 ncomponents--;
2203         }
2204
2205         err = 0;
2206 out_free:
2207         dprintk(")\n");
2208         while (ncomponents)
2209                 dput(components[--ncomponents]);
2210         kfree(components);
2211         path_put(&cur);
2212         return err;
2213 }
2214
2215 static __be32 nfsd4_encode_fsloc_fsroot(struct xdr_stream *xdr,
2216                         struct svc_rqst *rqstp, const struct path *path)
2217 {
2218         struct svc_export *exp_ps;
2219         __be32 res;
2220
2221         exp_ps = rqst_find_fsidzero_export(rqstp);
2222         if (IS_ERR(exp_ps))
2223                 return nfserrno(PTR_ERR(exp_ps));
2224         res = nfsd4_encode_path(xdr, &exp_ps->ex_path, path);
2225         exp_put(exp_ps);
2226         return res;
2227 }
2228
2229 /*
2230  *  encode a fs_locations structure
2231  */
2232 static __be32 nfsd4_encode_fs_locations(struct xdr_stream *xdr,
2233                         struct svc_rqst *rqstp, struct svc_export *exp)
2234 {
2235         __be32 status;
2236         int i;
2237         __be32 *p;
2238         struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;
2239
2240         status = nfsd4_encode_fsloc_fsroot(xdr, rqstp, &exp->ex_path);
2241         if (status)
2242                 return status;
2243         p = xdr_reserve_space(xdr, 4);
2244         if (!p)
2245                 return nfserr_resource;
2246         *p++ = cpu_to_be32(fslocs->locations_count);
2247         for (i=0; i<fslocs->locations_count; i++) {
2248                 status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]);
2249                 if (status)
2250                         return status;
2251         }
2252         return 0;
2253 }
2254
2255 static u32 nfs4_file_type(umode_t mode)
2256 {
2257         switch (mode & S_IFMT) {
2258         case S_IFIFO:   return NF4FIFO;
2259         case S_IFCHR:   return NF4CHR;
2260         case S_IFDIR:   return NF4DIR;
2261         case S_IFBLK:   return NF4BLK;
2262         case S_IFLNK:   return NF4LNK;
2263         case S_IFREG:   return NF4REG;
2264         case S_IFSOCK:  return NF4SOCK;
2265         default:        return NF4BAD;
2266         };
2267 }
2268
2269 static inline __be32
2270 nfsd4_encode_aclname(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2271                      struct nfs4_ace *ace)
2272 {
2273         if (ace->whotype != NFS4_ACL_WHO_NAMED)
2274                 return nfs4_acl_write_who(xdr, ace->whotype);
2275         else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
2276                 return nfsd4_encode_group(xdr, rqstp, ace->who_gid);
2277         else
2278                 return nfsd4_encode_user(xdr, rqstp, ace->who_uid);
2279 }
2280
2281 static inline __be32
2282 nfsd4_encode_layout_types(struct xdr_stream *xdr, u32 layout_types)
2283 {
2284         __be32          *p;
2285         unsigned long   i = hweight_long(layout_types);
2286
2287         p = xdr_reserve_space(xdr, 4 + 4 * i);
2288         if (!p)
2289                 return nfserr_resource;
2290
2291         *p++ = cpu_to_be32(i);
2292
2293         for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i)
2294                 if (layout_types & (1 << i))
2295                         *p++ = cpu_to_be32(i);
2296
2297         return 0;
2298 }
2299
2300 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
2301                               FATTR4_WORD0_RDATTR_ERROR)
2302 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
2303 #define WORD2_ABSENT_FS_ATTRS 0
2304
2305 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2306 static inline __be32
2307 nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2308                             void *context, int len)
2309 {
2310         __be32 *p;
2311
2312         p = xdr_reserve_space(xdr, len + 4 + 4 + 4);
2313         if (!p)
2314                 return nfserr_resource;
2315
2316         /*
2317          * For now we use a 0 here to indicate the null translation; in
2318          * the future we may place a call to translation code here.
2319          */
2320         *p++ = cpu_to_be32(0); /* lfs */
2321         *p++ = cpu_to_be32(0); /* pi */
2322         p = xdr_encode_opaque(p, context, len);
2323         return 0;
2324 }
2325 #else
2326 static inline __be32
2327 nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2328                             void *context, int len)
2329 { return 0; }
2330 #endif
2331
2332 static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *bmval2, u32 *rdattr_err)
2333 {
2334         /* As per referral draft:  */
2335         if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS ||
2336             *bmval1 & ~WORD1_ABSENT_FS_ATTRS) {
2337                 if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR ||
2338                     *bmval0 & FATTR4_WORD0_FS_LOCATIONS)
2339                         *rdattr_err = NFSERR_MOVED;
2340                 else
2341                         return nfserr_moved;
2342         }
2343         *bmval0 &= WORD0_ABSENT_FS_ATTRS;
2344         *bmval1 &= WORD1_ABSENT_FS_ATTRS;
2345         *bmval2 &= WORD2_ABSENT_FS_ATTRS;
2346         return 0;
2347 }
2348
2349
2350 static int get_parent_attributes(struct svc_export *exp, struct kstat *stat)
2351 {
2352         struct path path = exp->ex_path;
2353         int err;
2354
2355         path_get(&path);
2356         while (follow_up(&path)) {
2357                 if (path.dentry != path.mnt->mnt_root)
2358                         break;
2359         }
2360         err = vfs_getattr(&path, stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
2361         path_put(&path);
2362         return err;
2363 }
2364
2365 static __be32
2366 nfsd4_encode_bitmap(struct xdr_stream *xdr, u32 bmval0, u32 bmval1, u32 bmval2)
2367 {
2368         __be32 *p;
2369
2370         if (bmval2) {
2371                 p = xdr_reserve_space(xdr, 16);
2372                 if (!p)
2373                         goto out_resource;
2374                 *p++ = cpu_to_be32(3);
2375                 *p++ = cpu_to_be32(bmval0);
2376                 *p++ = cpu_to_be32(bmval1);
2377                 *p++ = cpu_to_be32(bmval2);
2378         } else if (bmval1) {
2379                 p = xdr_reserve_space(xdr, 12);
2380                 if (!p)
2381                         goto out_resource;
2382                 *p++ = cpu_to_be32(2);
2383                 *p++ = cpu_to_be32(bmval0);
2384                 *p++ = cpu_to_be32(bmval1);
2385         } else {
2386                 p = xdr_reserve_space(xdr, 8);
2387                 if (!p)
2388                         goto out_resource;
2389                 *p++ = cpu_to_be32(1);
2390                 *p++ = cpu_to_be32(bmval0);
2391         }
2392
2393         return 0;
2394 out_resource:
2395         return nfserr_resource;
2396 }
2397
2398 /*
2399  * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
2400  * ourselves.
2401  */
2402 static __be32
2403 nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
2404                 struct svc_export *exp,
2405                 struct dentry *dentry, u32 *bmval,
2406                 struct svc_rqst *rqstp, int ignore_crossmnt)
2407 {
2408         u32 bmval0 = bmval[0];
2409         u32 bmval1 = bmval[1];
2410         u32 bmval2 = bmval[2];
2411         struct kstat stat;
2412         struct svc_fh *tempfh = NULL;
2413         struct kstatfs statfs;
2414         __be32 *p;
2415         int starting_len = xdr->buf->len;
2416         int attrlen_offset;
2417         __be32 attrlen;
2418         u32 dummy;
2419         u64 dummy64;
2420         u32 rdattr_err = 0;
2421         __be32 status;
2422         int err;
2423         struct nfs4_acl *acl = NULL;
2424 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2425         void *context = NULL;
2426         int contextlen;
2427 #endif
2428         bool contextsupport = false;
2429         struct nfsd4_compoundres *resp = rqstp->rq_resp;
2430         u32 minorversion = resp->cstate.minorversion;
2431         struct path path = {
2432                 .mnt    = exp->ex_path.mnt,
2433                 .dentry = dentry,
2434         };
2435         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2436
2437         BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1);
2438         BUG_ON(!nfsd_attrs_supported(minorversion, bmval));
2439
2440         if (exp->ex_fslocs.migrated) {
2441                 status = fattr_handle_absent_fs(&bmval0, &bmval1, &bmval2, &rdattr_err);
2442                 if (status)
2443                         goto out;
2444         }
2445
2446         err = vfs_getattr(&path, &stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
2447         if (err)
2448                 goto out_nfserr;
2449         if ((bmval0 & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE |
2450                         FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) ||
2451             (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |
2452                        FATTR4_WORD1_SPACE_TOTAL))) {
2453                 err = vfs_statfs(&path, &statfs);
2454                 if (err)
2455                         goto out_nfserr;
2456         }
2457         if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) {
2458                 tempfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
2459                 status = nfserr_jukebox;
2460                 if (!tempfh)
2461                         goto out;
2462                 fh_init(tempfh, NFS4_FHSIZE);
2463                 status = fh_compose(tempfh, exp, dentry, NULL);
2464                 if (status)
2465                         goto out;
2466                 fhp = tempfh;
2467         }
2468         if (bmval0 & FATTR4_WORD0_ACL) {
2469                 err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl);
2470                 if (err == -EOPNOTSUPP)
2471                         bmval0 &= ~FATTR4_WORD0_ACL;
2472                 else if (err == -EINVAL) {
2473                         status = nfserr_attrnotsupp;
2474                         goto out;
2475                 } else if (err != 0)
2476                         goto out_nfserr;
2477         }
2478
2479 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2480         if ((bmval2 & FATTR4_WORD2_SECURITY_LABEL) ||
2481              bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
2482                 if (exp->ex_flags & NFSEXP_SECURITY_LABEL)
2483                         err = security_inode_getsecctx(d_inode(dentry),
2484                                                 &context, &contextlen);
2485                 else
2486                         err = -EOPNOTSUPP;
2487                 contextsupport = (err == 0);
2488                 if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
2489                         if (err == -EOPNOTSUPP)
2490                                 bmval2 &= ~FATTR4_WORD2_SECURITY_LABEL;
2491                         else if (err)
2492                                 goto out_nfserr;
2493                 }
2494         }
2495 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2496
2497         status = nfsd4_encode_bitmap(xdr, bmval0, bmval1, bmval2);
2498         if (status)
2499                 goto out;
2500
2501         attrlen_offset = xdr->buf->len;
2502         p = xdr_reserve_space(xdr, 4);
2503         if (!p)
2504                 goto out_resource;
2505         p++;                /* to be backfilled later */
2506
2507         if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
2508                 u32 supp[3];
2509
2510                 memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp));
2511
2512                 if (!IS_POSIXACL(dentry->d_inode))
2513                         supp[0] &= ~FATTR4_WORD0_ACL;
2514                 if (!contextsupport)
2515                         supp[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
2516                 if (!supp[2]) {
2517                         p = xdr_reserve_space(xdr, 12);
2518                         if (!p)
2519                                 goto out_resource;
2520                         *p++ = cpu_to_be32(2);
2521                         *p++ = cpu_to_be32(supp[0]);
2522                         *p++ = cpu_to_be32(supp[1]);
2523                 } else {
2524                         p = xdr_reserve_space(xdr, 16);
2525                         if (!p)
2526                                 goto out_resource;
2527                         *p++ = cpu_to_be32(3);
2528                         *p++ = cpu_to_be32(supp[0]);
2529                         *p++ = cpu_to_be32(supp[1]);
2530                         *p++ = cpu_to_be32(supp[2]);
2531                 }
2532         }
2533         if (bmval0 & FATTR4_WORD0_TYPE) {
2534                 p = xdr_reserve_space(xdr, 4);
2535                 if (!p)
2536                         goto out_resource;
2537                 dummy = nfs4_file_type(stat.mode);
2538                 if (dummy == NF4BAD) {
2539                         status = nfserr_serverfault;
2540                         goto out;
2541                 }
2542                 *p++ = cpu_to_be32(dummy);
2543         }
2544         if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) {
2545                 p = xdr_reserve_space(xdr, 4);
2546                 if (!p)
2547                         goto out_resource;
2548                 if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)
2549                         *p++ = cpu_to_be32(NFS4_FH_PERSISTENT);
2550                 else
2551                         *p++ = cpu_to_be32(NFS4_FH_PERSISTENT|
2552                                                 NFS4_FH_VOL_RENAME);
2553         }
2554         if (bmval0 & FATTR4_WORD0_CHANGE) {
2555                 p = xdr_reserve_space(xdr, 8);
2556                 if (!p)
2557                         goto out_resource;
2558                 p = encode_change(p, &stat, d_inode(dentry), exp);
2559         }
2560         if (bmval0 & FATTR4_WORD0_SIZE) {
2561                 p = xdr_reserve_space(xdr, 8);
2562                 if (!p)
2563                         goto out_resource;
2564                 p = xdr_encode_hyper(p, stat.size);
2565         }
2566         if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) {
2567                 p = xdr_reserve_space(xdr, 4);
2568                 if (!p)
2569                         goto out_resource;
2570                 *p++ = cpu_to_be32(1);
2571         }
2572         if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) {
2573                 p = xdr_reserve_space(xdr, 4);
2574                 if (!p)
2575                         goto out_resource;
2576                 *p++ = cpu_to_be32(1);
2577         }
2578         if (bmval0 & FATTR4_WORD0_NAMED_ATTR) {
2579                 p = xdr_reserve_space(xdr, 4);
2580                 if (!p)
2581                         goto out_resource;
2582                 *p++ = cpu_to_be32(0);
2583         }
2584         if (bmval0 & FATTR4_WORD0_FSID) {
2585                 p = xdr_reserve_space(xdr, 16);
2586                 if (!p)
2587                         goto out_resource;
2588                 if (exp->ex_fslocs.migrated) {
2589                         p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MAJOR);
2590                         p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MINOR);
2591                 } else switch(fsid_source(fhp)) {
2592                 case FSIDSOURCE_FSID:
2593                         p = xdr_encode_hyper(p, (u64)exp->ex_fsid);
2594                         p = xdr_encode_hyper(p, (u64)0);
2595                         break;
2596                 case FSIDSOURCE_DEV:
2597                         *p++ = cpu_to_be32(0);
2598                         *p++ = cpu_to_be32(MAJOR(stat.dev));
2599                         *p++ = cpu_to_be32(0);
2600                         *p++ = cpu_to_be32(MINOR(stat.dev));
2601                         break;
2602                 case FSIDSOURCE_UUID:
2603                         p = xdr_encode_opaque_fixed(p, exp->ex_uuid,
2604                                                                 EX_UUID_LEN);
2605                         break;
2606                 }
2607         }
2608         if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) {
2609                 p = xdr_reserve_space(xdr, 4);
2610                 if (!p)
2611                         goto out_resource;
2612                 *p++ = cpu_to_be32(0);
2613         }
2614         if (bmval0 & FATTR4_WORD0_LEASE_TIME) {
2615                 p = xdr_reserve_space(xdr, 4);
2616                 if (!p)
2617                         goto out_resource;
2618                 *p++ = cpu_to_be32(nn->nfsd4_lease);
2619         }
2620         if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) {
2621                 p = xdr_reserve_space(xdr, 4);
2622                 if (!p)
2623                         goto out_resource;
2624                 *p++ = cpu_to_be32(rdattr_err);
2625         }
2626         if (bmval0 & FATTR4_WORD0_ACL) {
2627                 struct nfs4_ace *ace;
2628
2629                 if (acl == NULL) {
2630                         p = xdr_reserve_space(xdr, 4);
2631                         if (!p)
2632                                 goto out_resource;
2633
2634                         *p++ = cpu_to_be32(0);
2635                         goto out_acl;
2636                 }
2637                 p = xdr_reserve_space(xdr, 4);
2638                 if (!p)
2639                         goto out_resource;
2640                 *p++ = cpu_to_be32(acl->naces);
2641
2642                 for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {
2643                         p = xdr_reserve_space(xdr, 4*3);
2644                         if (!p)
2645                                 goto out_resource;
2646                         *p++ = cpu_to_be32(ace->type);
2647                         *p++ = cpu_to_be32(ace->flag);
2648                         *p++ = cpu_to_be32(ace->access_mask &
2649                                                         NFS4_ACE_MASK_ALL);
2650                         status = nfsd4_encode_aclname(xdr, rqstp, ace);
2651                         if (status)
2652                                 goto out;
2653                 }
2654         }
2655 out_acl:
2656         if (bmval0 & FATTR4_WORD0_ACLSUPPORT) {
2657                 p = xdr_reserve_space(xdr, 4);
2658                 if (!p)
2659                         goto out_resource;
2660                 *p++ = cpu_to_be32(IS_POSIXACL(dentry->d_inode) ?
2661                         ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0);
2662         }
2663         if (bmval0 & FATTR4_WORD0_CANSETTIME) {
2664                 p = xdr_reserve_space(xdr, 4);
2665                 if (!p)
2666                         goto out_resource;
2667                 *p++ = cpu_to_be32(1);
2668         }
2669         if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) {
2670                 p = xdr_reserve_space(xdr, 4);
2671                 if (!p)
2672                         goto out_resource;
2673                 *p++ = cpu_to_be32(0);
2674         }
2675         if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) {
2676                 p = xdr_reserve_space(xdr, 4);
2677                 if (!p)
2678                         goto out_resource;
2679                 *p++ = cpu_to_be32(1);
2680         }
2681         if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) {
2682                 p = xdr_reserve_space(xdr, 4);
2683                 if (!p)
2684                         goto out_resource;
2685                 *p++ = cpu_to_be32(1);
2686         }
2687         if (bmval0 & FATTR4_WORD0_FILEHANDLE) {
2688                 p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4);
2689                 if (!p)
2690                         goto out_resource;
2691                 p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base,
2692                                         fhp->fh_handle.fh_size);
2693         }
2694         if (bmval0 & FATTR4_WORD0_FILEID) {
2695                 p = xdr_reserve_space(xdr, 8);
2696                 if (!p)
2697                         goto out_resource;
2698                 p = xdr_encode_hyper(p, stat.ino);
2699         }
2700         if (bmval0 & FATTR4_WORD0_FILES_AVAIL) {
2701                 p = xdr_reserve_space(xdr, 8);
2702                 if (!p)
2703                         goto out_resource;
2704                 p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
2705         }
2706         if (bmval0 & FATTR4_WORD0_FILES_FREE) {
2707                 p = xdr_reserve_space(xdr, 8);
2708                 if (!p)
2709                         goto out_resource;
2710                 p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
2711         }
2712         if (bmval0 & FATTR4_WORD0_FILES_TOTAL) {
2713                 p = xdr_reserve_space(xdr, 8);
2714                 if (!p)
2715                         goto out_resource;
2716                 p = xdr_encode_hyper(p, (u64) statfs.f_files);
2717         }
2718         if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) {
2719                 status = nfsd4_encode_fs_locations(xdr, rqstp, exp);
2720                 if (status)
2721                         goto out;
2722         }
2723         if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) {
2724                 p = xdr_reserve_space(xdr, 4);
2725                 if (!p)
2726                         goto out_resource;
2727                 *p++ = cpu_to_be32(1);
2728         }
2729         if (bmval0 & FATTR4_WORD0_MAXFILESIZE) {
2730                 p = xdr_reserve_space(xdr, 8);
2731                 if (!p)
2732                         goto out_resource;
2733                 p = xdr_encode_hyper(p, exp->ex_path.mnt->mnt_sb->s_maxbytes);
2734         }
2735         if (bmval0 & FATTR4_WORD0_MAXLINK) {
2736                 p = xdr_reserve_space(xdr, 4);
2737                 if (!p)
2738                         goto out_resource;
2739                 *p++ = cpu_to_be32(255);
2740         }
2741         if (bmval0 & FATTR4_WORD0_MAXNAME) {
2742                 p = xdr_reserve_space(xdr, 4);
2743                 if (!p)
2744                         goto out_resource;
2745                 *p++ = cpu_to_be32(statfs.f_namelen);
2746         }
2747         if (bmval0 & FATTR4_WORD0_MAXREAD) {
2748                 p = xdr_reserve_space(xdr, 8);
2749                 if (!p)
2750                         goto out_resource;
2751                 p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
2752         }
2753         if (bmval0 & FATTR4_WORD0_MAXWRITE) {
2754                 p = xdr_reserve_space(xdr, 8);
2755                 if (!p)
2756                         goto out_resource;
2757                 p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
2758         }
2759         if (bmval1 & FATTR4_WORD1_MODE) {
2760                 p = xdr_reserve_space(xdr, 4);
2761                 if (!p)
2762                         goto out_resource;
2763                 *p++ = cpu_to_be32(stat.mode & S_IALLUGO);
2764         }
2765         if (bmval1 & FATTR4_WORD1_NO_TRUNC) {
2766                 p = xdr_reserve_space(xdr, 4);
2767                 if (!p)
2768                         goto out_resource;
2769                 *p++ = cpu_to_be32(1);
2770         }
2771         if (bmval1 & FATTR4_WORD1_NUMLINKS) {
2772                 p = xdr_reserve_space(xdr, 4);
2773                 if (!p)
2774                         goto out_resource;
2775                 *p++ = cpu_to_be32(stat.nlink);
2776         }
2777         if (bmval1 & FATTR4_WORD1_OWNER) {
2778                 status = nfsd4_encode_user(xdr, rqstp, stat.uid);
2779                 if (status)
2780                         goto out;
2781         }
2782         if (bmval1 & FATTR4_WORD1_OWNER_GROUP) {
2783                 status = nfsd4_encode_group(xdr, rqstp, stat.gid);
2784                 if (status)
2785                         goto out;
2786         }
2787         if (bmval1 & FATTR4_WORD1_RAWDEV) {
2788                 p = xdr_reserve_space(xdr, 8);
2789                 if (!p)
2790                         goto out_resource;
2791                 *p++ = cpu_to_be32((u32) MAJOR(stat.rdev));
2792                 *p++ = cpu_to_be32((u32) MINOR(stat.rdev));
2793         }
2794         if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) {
2795                 p = xdr_reserve_space(xdr, 8);
2796                 if (!p)
2797                         goto out_resource;
2798                 dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize;
2799                 p = xdr_encode_hyper(p, dummy64);
2800         }
2801         if (bmval1 & FATTR4_WORD1_SPACE_FREE) {
2802                 p = xdr_reserve_space(xdr, 8);
2803                 if (!p)
2804                         goto out_resource;
2805                 dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize;
2806                 p = xdr_encode_hyper(p, dummy64);
2807         }
2808         if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) {
2809                 p = xdr_reserve_space(xdr, 8);
2810                 if (!p)
2811                         goto out_resource;
2812                 dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize;
2813                 p = xdr_encode_hyper(p, dummy64);
2814         }
2815         if (bmval1 & FATTR4_WORD1_SPACE_USED) {
2816                 p = xdr_reserve_space(xdr, 8);
2817                 if (!p)
2818                         goto out_resource;
2819                 dummy64 = (u64)stat.blocks << 9;
2820                 p = xdr_encode_hyper(p, dummy64);
2821         }
2822         if (bmval1 & FATTR4_WORD1_TIME_ACCESS) {
2823                 p = xdr_reserve_space(xdr, 12);
2824                 if (!p)
2825                         goto out_resource;
2826                 p = xdr_encode_hyper(p, (s64)stat.atime.tv_sec);
2827                 *p++ = cpu_to_be32(stat.atime.tv_nsec);
2828         }
2829         if (bmval1 & FATTR4_WORD1_TIME_DELTA) {
2830                 p = xdr_reserve_space(xdr, 12);
2831                 if (!p)
2832                         goto out_resource;
2833                 p = encode_time_delta(p, d_inode(dentry));
2834         }
2835         if (bmval1 & FATTR4_WORD1_TIME_METADATA) {
2836                 p = xdr_reserve_space(xdr, 12);
2837                 if (!p)
2838                         goto out_resource;
2839                 p = xdr_encode_hyper(p, (s64)stat.ctime.tv_sec);
2840                 *p++ = cpu_to_be32(stat.ctime.tv_nsec);
2841         }
2842         if (bmval1 & FATTR4_WORD1_TIME_MODIFY) {
2843                 p = xdr_reserve_space(xdr, 12);
2844                 if (!p)
2845                         goto out_resource;
2846                 p = xdr_encode_hyper(p, (s64)stat.mtime.tv_sec);
2847                 *p++ = cpu_to_be32(stat.mtime.tv_nsec);
2848         }
2849         if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) {
2850                 struct kstat parent_stat;
2851                 u64 ino = stat.ino;
2852
2853                 p = xdr_reserve_space(xdr, 8);
2854                 if (!p)
2855                         goto out_resource;
2856                 /*
2857                  * Get parent's attributes if not ignoring crossmount
2858                  * and this is the root of a cross-mounted filesystem.
2859                  */
2860                 if (ignore_crossmnt == 0 &&
2861                     dentry == exp->ex_path.mnt->mnt_root) {
2862                         err = get_parent_attributes(exp, &parent_stat);
2863                         if (err)
2864                                 goto out_nfserr;
2865                         ino = parent_stat.ino;
2866                 }
2867                 p = xdr_encode_hyper(p, ino);
2868         }
2869 #ifdef CONFIG_NFSD_PNFS
2870         if (bmval1 & FATTR4_WORD1_FS_LAYOUT_TYPES) {
2871                 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types);
2872                 if (status)
2873                         goto out;
2874         }
2875
2876         if (bmval2 & FATTR4_WORD2_LAYOUT_TYPES) {
2877                 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types);
2878                 if (status)
2879                         goto out;
2880         }
2881
2882         if (bmval2 & FATTR4_WORD2_LAYOUT_BLKSIZE) {
2883                 p = xdr_reserve_space(xdr, 4);
2884                 if (!p)
2885                         goto out_resource;
2886                 *p++ = cpu_to_be32(stat.blksize);
2887         }
2888 #endif /* CONFIG_NFSD_PNFS */
2889         if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
2890                 u32 supp[3];
2891
2892                 memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp));
2893                 supp[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0;
2894                 supp[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1;
2895                 supp[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2;
2896
2897                 status = nfsd4_encode_bitmap(xdr, supp[0], supp[1], supp[2]);
2898                 if (status)
2899                         goto out;
2900         }
2901
2902         if (bmval2 & FATTR4_WORD2_CHANGE_ATTR_TYPE) {
2903                 p = xdr_reserve_space(xdr, 4);
2904                 if (!p)
2905                         goto out_resource;
2906                 if (IS_I_VERSION(d_inode(dentry)))
2907                         *p++ = cpu_to_be32(NFS4_CHANGE_TYPE_IS_MONOTONIC_INCR);
2908                 else
2909                         *p++ = cpu_to_be32(NFS4_CHANGE_TYPE_IS_TIME_METADATA);
2910         }
2911
2912 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2913         if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
2914                 status = nfsd4_encode_security_label(xdr, rqstp, context,
2915                                                                 contextlen);
2916                 if (status)
2917                         goto out;
2918         }
2919 #endif
2920
2921         attrlen = htonl(xdr->buf->len - attrlen_offset - 4);
2922         write_bytes_to_xdr_buf(xdr->buf, attrlen_offset, &attrlen, 4);
2923         status = nfs_ok;
2924
2925 out:
2926 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2927         if (context)
2928                 security_release_secctx(context, contextlen);
2929 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2930         kfree(acl);
2931         if (tempfh) {
2932                 fh_put(tempfh);
2933                 kfree(tempfh);
2934         }
2935         if (status)
2936                 xdr_truncate_encode(xdr, starting_len);
2937         return status;
2938 out_nfserr:
2939         status = nfserrno(err);
2940         goto out;
2941 out_resource:
2942         status = nfserr_resource;
2943         goto out;
2944 }
2945
2946 static void svcxdr_init_encode_from_buffer(struct xdr_stream *xdr,
2947                                 struct xdr_buf *buf, __be32 *p, int bytes)
2948 {
2949         xdr->scratch.iov_len = 0;
2950         memset(buf, 0, sizeof(struct xdr_buf));
2951         buf->head[0].iov_base = p;
2952         buf->head[0].iov_len = 0;
2953         buf->len = 0;
2954         xdr->buf = buf;
2955         xdr->iov = buf->head;
2956         xdr->p = p;
2957         xdr->end = (void *)p + bytes;
2958         buf->buflen = bytes;
2959 }
2960
2961 __be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words,
2962                         struct svc_fh *fhp, struct svc_export *exp,
2963                         struct dentry *dentry, u32 *bmval,
2964                         struct svc_rqst *rqstp, int ignore_crossmnt)
2965 {
2966         struct xdr_buf dummy;
2967         struct xdr_stream xdr;
2968         __be32 ret;
2969
2970         svcxdr_init_encode_from_buffer(&xdr, &dummy, *p, words << 2);
2971         ret = nfsd4_encode_fattr(&xdr, fhp, exp, dentry, bmval, rqstp,
2972                                                         ignore_crossmnt);
2973         *p = xdr.p;
2974         return ret;
2975 }
2976
2977 static inline int attributes_need_mount(u32 *bmval)
2978 {
2979         if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME))
2980                 return 1;
2981         if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID)
2982                 return 1;
2983         return 0;
2984 }
2985
2986 static __be32
2987 nfsd4_encode_dirent_fattr(struct xdr_stream *xdr, struct nfsd4_readdir *cd,
2988                         const char *name, int namlen)
2989 {
2990         struct svc_export *exp = cd->rd_fhp->fh_export;
2991         struct dentry *dentry;
2992         __be32 nfserr;
2993         int ignore_crossmnt = 0;
2994
2995         dentry = lookup_one_len_unlocked(name, cd->rd_fhp->fh_dentry, namlen);
2996         if (IS_ERR(dentry))
2997                 return nfserrno(PTR_ERR(dentry));
2998         if (d_really_is_negative(dentry)) {
2999                 /*
3000                  * we're not holding the i_mutex here, so there's
3001                  * a window where this directory entry could have gone
3002                  * away.
3003                  */
3004                 dput(dentry);
3005                 return nfserr_noent;
3006         }
3007
3008         exp_get(exp);
3009         /*
3010          * In the case of a mountpoint, the client may be asking for
3011          * attributes that are only properties of the underlying filesystem
3012          * as opposed to the cross-mounted file system. In such a case,
3013          * we will not follow the cross mount and will fill the attribtutes
3014          * directly from the mountpoint dentry.
3015          */
3016         if (nfsd_mountpoint(dentry, exp)) {
3017                 int err;
3018
3019                 if (!(exp->ex_flags & NFSEXP_V4ROOT)
3020                                 && !attributes_need_mount(cd->rd_bmval)) {
3021                         ignore_crossmnt = 1;
3022                         goto out_encode;
3023                 }
3024                 /*
3025                  * Why the heck aren't we just using nfsd_lookup??
3026                  * Different "."/".." handling?  Something else?
3027                  * At least, add a comment here to explain....
3028                  */
3029                 err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);
3030                 if (err) {
3031                         nfserr = nfserrno(err);
3032                         goto out_put;
3033                 }
3034                 nfserr = check_nfsd_access(exp, cd->rd_rqstp);
3035                 if (nfserr)
3036                         goto out_put;
3037
3038         }
3039 out_encode:
3040         nfserr = nfsd4_encode_fattr(xdr, NULL, exp, dentry, cd->rd_bmval,
3041                                         cd->rd_rqstp, ignore_crossmnt);
3042 out_put:
3043         dput(dentry);
3044         exp_put(exp);
3045         return nfserr;
3046 }
3047
3048 static __be32 *
3049 nfsd4_encode_rdattr_error(struct xdr_stream *xdr, __be32 nfserr)
3050 {
3051         __be32 *p;
3052
3053         p = xdr_reserve_space(xdr, 20);
3054         if (!p)
3055                 return NULL;
3056         *p++ = htonl(2);
3057         *p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */
3058         *p++ = htonl(0);                         /* bmval1 */
3059
3060         *p++ = htonl(4);     /* attribute length */
3061         *p++ = nfserr;       /* no htonl */
3062         return p;
3063 }
3064
3065 static int
3066 nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,
3067                     loff_t offset, u64 ino, unsigned int d_type)
3068 {
3069         struct readdir_cd *ccd = ccdv;
3070         struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);
3071         struct xdr_stream *xdr = cd->xdr;
3072         int start_offset = xdr->buf->len;
3073         int cookie_offset;
3074         u32 name_and_cookie;
3075         int entry_bytes;
3076         __be32 nfserr = nfserr_toosmall;
3077         __be64 wire_offset;
3078         __be32 *p;
3079
3080         /* In nfsv4, "." and ".." never make it onto the wire.. */
3081         if (name && isdotent(name, namlen)) {
3082                 cd->common.err = nfs_ok;
3083                 return 0;
3084         }
3085
3086         if (cd->cookie_offset) {
3087                 wire_offset = cpu_to_be64(offset);
3088                 write_bytes_to_xdr_buf(xdr->buf, cd->cookie_offset,
3089                                                         &wire_offset, 8);
3090         }
3091
3092         p = xdr_reserve_space(xdr, 4);
3093         if (!p)
3094                 goto fail;
3095         *p++ = xdr_one;                             /* mark entry present */
3096         cookie_offset = xdr->buf->len;
3097         p = xdr_reserve_space(xdr, 3*4 + namlen);
3098         if (!p)
3099                 goto fail;
3100         p = xdr_encode_hyper(p, NFS_OFFSET_MAX);    /* offset of next entry */
3101         p = xdr_encode_array(p, name, namlen);      /* name length & name */
3102
3103         nfserr = nfsd4_encode_dirent_fattr(xdr, cd, name, namlen);
3104         switch (nfserr) {
3105         case nfs_ok:
3106                 break;
3107         case nfserr_resource:
3108                 nfserr = nfserr_toosmall;
3109                 goto fail;
3110         case nfserr_noent:
3111                 xdr_truncate_encode(xdr, start_offset);
3112                 goto skip_entry;
3113         default:
3114                 /*
3115                  * If the client requested the RDATTR_ERROR attribute,
3116                  * we stuff the error code into this attribute
3117                  * and continue.  If this attribute was not requested,
3118                  * then in accordance with the spec, we fail the
3119                  * entire READDIR operation(!)
3120                  */
3121                 if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))
3122                         goto fail;
3123                 p = nfsd4_encode_rdattr_error(xdr, nfserr);
3124                 if (p == NULL) {
3125                         nfserr = nfserr_toosmall;
3126                         goto fail;
3127                 }
3128         }
3129         nfserr = nfserr_toosmall;
3130         entry_bytes = xdr->buf->len - start_offset;
3131         if (entry_bytes > cd->rd_maxcount)
3132                 goto fail;
3133         cd->rd_maxcount -= entry_bytes;
3134         /*
3135          * RFC 3530 14.2.24 describes rd_dircount as only a "hint", so
3136          * let's always let through the first entry, at least:
3137          */
3138         if (!cd->rd_dircount)
3139                 goto fail;
3140         name_and_cookie = 4 + 4 * XDR_QUADLEN(namlen) + 8;
3141         if (name_and_cookie > cd->rd_dircount && cd->cookie_offset)
3142                 goto fail;
3143         cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie);
3144
3145         cd->cookie_offset = cookie_offset;
3146 skip_entry:
3147         cd->common.err = nfs_ok;
3148         return 0;
3149 fail:
3150         xdr_truncate_encode(xdr, start_offset);
3151         cd->common.err = nfserr;
3152         return -EINVAL;
3153 }
3154
3155 static __be32
3156 nfsd4_encode_stateid(struct xdr_stream *xdr, stateid_t *sid)
3157 {
3158         __be32 *p;
3159
3160         p = xdr_reserve_space(xdr, sizeof(stateid_t));
3161         if (!p)
3162                 return nfserr_resource;
3163         *p++ = cpu_to_be32(sid->si_generation);
3164         p = xdr_encode_opaque_fixed(p, &sid->si_opaque,
3165                                         sizeof(stateid_opaque_t));
3166         return 0;
3167 }
3168
3169 static __be32
3170 nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access)
3171 {
3172         struct xdr_stream *xdr = &resp->xdr;
3173         __be32 *p;
3174
3175         p = xdr_reserve_space(xdr, 8);
3176         if (!p)
3177                 return nfserr_resource;
3178         *p++ = cpu_to_be32(access->ac_supported);
3179         *p++ = cpu_to_be32(access->ac_resp_access);
3180         return 0;
3181 }
3182
3183 static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)
3184 {
3185         struct xdr_stream *xdr = &resp->xdr;
3186         __be32 *p;
3187
3188         p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 8);
3189         if (!p)
3190                 return nfserr_resource;
3191         p = xdr_encode_opaque_fixed(p, bcts->sessionid.data,
3192                                         NFS4_MAX_SESSIONID_LEN);
3193         *p++ = cpu_to_be32(bcts->dir);
3194         /* Upshifting from TCP to RDMA is not supported */
3195         *p++ = cpu_to_be32(0);
3196         return 0;
3197 }
3198
3199 static __be32
3200 nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close)
3201 {
3202         struct xdr_stream *xdr = &resp->xdr;
3203
3204         return nfsd4_encode_stateid(xdr, &close->cl_stateid);
3205 }
3206
3207
3208 static __be32
3209 nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit)
3210 {
3211         struct xdr_stream *xdr = &resp->xdr;
3212         __be32 *p;
3213
3214         p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
3215         if (!p)
3216                 return nfserr_resource;
3217         p = xdr_encode_opaque_fixed(p, commit->co_verf.data,
3218                                                 NFS4_VERIFIER_SIZE);
3219         return 0;
3220 }
3221
3222 static __be32
3223 nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create)
3224 {
3225         struct xdr_stream *xdr = &resp->xdr;
3226         __be32 *p;
3227
3228         p = xdr_reserve_space(xdr, 20);
3229         if (!p)
3230                 return nfserr_resource;
3231         encode_cinfo(p, &create->cr_cinfo);
3232         nfserr = nfsd4_encode_bitmap(xdr, create->cr_bmval[0],
3233                         create->cr_bmval[1], create->cr_bmval[2]);
3234         return 0;
3235 }
3236
3237 static __be32
3238 nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr)
3239 {
3240         struct svc_fh *fhp = getattr->ga_fhp;
3241         struct xdr_stream *xdr = &resp->xdr;
3242
3243         return nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry,
3244                                     getattr->ga_bmval, resp->rqstp, 0);
3245 }
3246
3247 static __be32
3248 nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp)
3249 {
3250         struct xdr_stream *xdr = &resp->xdr;
3251         struct svc_fh *fhp = *fhpp;
3252         unsigned int len;
3253         __be32 *p;
3254
3255         len = fhp->fh_handle.fh_size;
3256         p = xdr_reserve_space(xdr, len + 4);
3257         if (!p)
3258                 return nfserr_resource;
3259         p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, len);
3260         return 0;
3261 }
3262
3263 /*
3264 * Including all fields other than the name, a LOCK4denied structure requires
3265 *   8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
3266 */
3267 static __be32
3268 nfsd4_encode_lock_denied(struct xdr_stream *xdr, struct nfsd4_lock_denied *ld)
3269 {
3270         struct xdr_netobj *conf = &ld->ld_owner;
3271         __be32 *p;
3272
3273 again:
3274         p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len));
3275         if (!p) {
3276                 /*
3277                  * Don't fail to return the result just because we can't
3278                  * return the conflicting open:
3279                  */
3280                 if (conf->len) {
3281                         kfree(conf->data);
3282                         conf->len = 0;
3283                         conf->data = NULL;
3284                         goto again;
3285                 }
3286                 return nfserr_resource;
3287         }
3288         p = xdr_encode_hyper(p, ld->ld_start);
3289         p = xdr_encode_hyper(p, ld->ld_length);
3290         *p++ = cpu_to_be32(ld->ld_type);
3291         if (conf->len) {
3292                 p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8);
3293                 p = xdr_encode_opaque(p, conf->data, conf->len);
3294                 kfree(conf->data);
3295         }  else {  /* non - nfsv4 lock in conflict, no clientid nor owner */
3296                 p = xdr_encode_hyper(p, (u64)0); /* clientid */
3297                 *p++ = cpu_to_be32(0); /* length of owner name */
3298         }
3299         return nfserr_denied;
3300 }
3301
3302 static __be32
3303 nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock)
3304 {
3305         struct xdr_stream *xdr = &resp->xdr;
3306
3307         if (!nfserr)
3308                 nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid);
3309         else if (nfserr == nfserr_denied)
3310                 nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied);
3311
3312         return nfserr;
3313 }
3314
3315 static __be32
3316 nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt)
3317 {
3318         struct xdr_stream *xdr = &resp->xdr;
3319
3320         if (nfserr == nfserr_denied)
3321                 nfsd4_encode_lock_denied(xdr, &lockt->lt_denied);
3322         return nfserr;
3323 }
3324
3325 static __be32
3326 nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku)
3327 {
3328         struct xdr_stream *xdr = &resp->xdr;
3329
3330         return nfsd4_encode_stateid(xdr, &locku->lu_stateid);
3331 }
3332
3333
3334 static __be32
3335 nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link)
3336 {
3337         struct xdr_stream *xdr = &resp->xdr;
3338         __be32 *p;
3339
3340         p = xdr_reserve_space(xdr, 20);
3341         if (!p)
3342                 return nfserr_resource;
3343         p = encode_cinfo(p, &link->li_cinfo);
3344         return 0;
3345 }
3346
3347
3348 static __be32
3349 nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open)
3350 {
3351         struct xdr_stream *xdr = &resp->xdr;
3352         __be32 *p;
3353
3354         nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid);
3355         if (nfserr)
3356                 return nfserr;
3357         p = xdr_reserve_space(xdr, 24);
3358         if (!p)
3359                 return nfserr_resource;
3360         p = encode_cinfo(p, &open->op_cinfo);
3361         *p++ = cpu_to_be32(open->op_rflags);
3362
3363         nfserr = nfsd4_encode_bitmap(xdr, open->op_bmval[0], open->op_bmval[1],
3364                                         open->op_bmval[2]);
3365         if (nfserr)
3366                 return nfserr;
3367
3368         p = xdr_reserve_space(xdr, 4);
3369         if (!p)
3370                 return nfserr_resource;
3371
3372         *p++ = cpu_to_be32(open->op_delegate_type);
3373         switch (open->op_delegate_type) {
3374         case NFS4_OPEN_DELEGATE_NONE:
3375                 break;
3376         case NFS4_OPEN_DELEGATE_READ:
3377                 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
3378                 if (nfserr)
3379                         return nfserr;
3380                 p = xdr_reserve_space(xdr, 20);
3381                 if (!p)
3382                         return nfserr_resource;
3383                 *p++ = cpu_to_be32(open->op_recall);
3384
3385                 /*
3386                  * TODO: ACE's in delegations
3387                  */
3388                 *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
3389                 *p++ = cpu_to_be32(0);
3390                 *p++ = cpu_to_be32(0);
3391                 *p++ = cpu_to_be32(0);   /* XXX: is NULL principal ok? */
3392                 break;
3393         case NFS4_OPEN_DELEGATE_WRITE:
3394                 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
3395                 if (nfserr)
3396                         return nfserr;
3397                 p = xdr_reserve_space(xdr, 32);
3398                 if (!p)
3399                         return nfserr_resource;
3400                 *p++ = cpu_to_be32(0);
3401
3402                 /*
3403                  * TODO: space_limit's in delegations
3404                  */
3405                 *p++ = cpu_to_be32(NFS4_LIMIT_SIZE);
3406                 *p++ = cpu_to_be32(~(u32)0);
3407                 *p++ = cpu_to_be32(~(u32)0);
3408
3409                 /*
3410                  * TODO: ACE's in delegations
3411                  */
3412                 *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
3413                 *p++ = cpu_to_be32(0);
3414                 *p++ = cpu_to_be32(0);
3415                 *p++ = cpu_to_be32(0);   /* XXX: is NULL principal ok? */
3416                 break;
3417         case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */
3418                 switch (open->op_why_no_deleg) {
3419                 case WND4_CONTENTION:
3420                 case WND4_RESOURCE:
3421                         p = xdr_reserve_space(xdr, 8);
3422                         if (!p)
3423                                 return nfserr_resource;
3424                         *p++ = cpu_to_be32(open->op_why_no_deleg);
3425                         /* deleg signaling not supported yet: */
3426                         *p++ = cpu_to_be32(0);
3427                         break;
3428                 default:
3429                         p = xdr_reserve_space(xdr, 4);
3430                         if (!p)
3431                                 return nfserr_resource;
3432                         *p++ = cpu_to_be32(open->op_why_no_deleg);
3433                 }
3434                 break;
3435         default:
3436                 BUG();
3437         }
3438         /* XXX save filehandle here */
3439         return 0;
3440 }
3441
3442 static __be32
3443 nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc)
3444 {
3445         struct xdr_stream *xdr = &resp->xdr;
3446
3447         return nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid);
3448 }
3449
3450 static __be32
3451 nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od)
3452 {
3453         struct xdr_stream *xdr = &resp->xdr;
3454
3455         return nfsd4_encode_stateid(xdr, &od->od_stateid);
3456 }
3457
3458 static __be32 nfsd4_encode_splice_read(
3459                                 struct nfsd4_compoundres *resp,
3460                                 struct nfsd4_read *read,
3461                                 struct file *file, unsigned long maxcount)
3462 {
3463         struct xdr_stream *xdr = &resp->xdr;
3464         struct xdr_buf *buf = xdr->buf;
3465         u32 eof;
3466         long len;
3467         int space_left;
3468         __be32 nfserr;
3469         __be32 *p = xdr->p - 2;
3470
3471         /* Make sure there will be room for padding if needed */
3472         if (xdr->end - xdr->p < 1)
3473                 return nfserr_resource;
3474
3475         len = maxcount;
3476         nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp,
3477                                   file, read->rd_offset, &maxcount);
3478         read->rd_length = maxcount;
3479         if (nfserr) {
3480                 /*
3481                  * nfsd_splice_actor may have already messed with the
3482                  * page length; reset it so as not to confuse
3483                  * xdr_truncate_encode:
3484                  */
3485                 buf->page_len = 0;
3486                 return nfserr;
3487         }
3488
3489         eof = nfsd_eof_on_read(len, maxcount, read->rd_offset,
3490                                 d_inode(read->rd_fhp->fh_dentry)->i_size);
3491
3492         *(p++) = htonl(eof);
3493         *(p++) = htonl(maxcount);
3494
3495         buf->page_len = maxcount;
3496         buf->len += maxcount;
3497         xdr->page_ptr += (buf->page_base + maxcount + PAGE_SIZE - 1)
3498                                                         / PAGE_SIZE;
3499
3500         /* Use rest of head for padding and remaining ops: */
3501         buf->tail[0].iov_base = xdr->p;
3502         buf->tail[0].iov_len = 0;
3503         xdr->iov = buf->tail;
3504         if (maxcount&3) {
3505                 int pad = 4 - (maxcount&3);
3506
3507                 *(xdr->p++) = 0;
3508
3509                 buf->tail[0].iov_base += maxcount&3;
3510                 buf->tail[0].iov_len = pad;
3511                 buf->len += pad;
3512         }
3513
3514         space_left = min_t(int, (void *)xdr->end - (void *)xdr->p,
3515                                 buf->buflen - buf->len);
3516         buf->buflen = buf->len + space_left;
3517         xdr->end = (__be32 *)((void *)xdr->end + space_left);
3518
3519         return 0;
3520 }
3521
3522 static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp,
3523                                  struct nfsd4_read *read,
3524                                  struct file *file, unsigned long maxcount)
3525 {
3526         struct xdr_stream *xdr = &resp->xdr;
3527         u32 eof;
3528         int v;
3529         int starting_len = xdr->buf->len - 8;
3530         long len;
3531         int thislen;
3532         __be32 nfserr;
3533         __be32 tmp;
3534         __be32 *p;
3535         u32 zzz = 0;
3536         int pad;
3537
3538         len = maxcount;
3539         v = 0;
3540
3541         thislen = min_t(long, len, ((void *)xdr->end - (void *)xdr->p));
3542         p = xdr_reserve_space(xdr, (thislen+3)&~3);
3543         WARN_ON_ONCE(!p);
3544         resp->rqstp->rq_vec[v].iov_base = p;
3545         resp->rqstp->rq_vec[v].iov_len = thislen;
3546         v++;
3547         len -= thislen;
3548
3549         while (len) {
3550                 thislen = min_t(long, len, PAGE_SIZE);
3551                 p = xdr_reserve_space(xdr, (thislen+3)&~3);
3552                 WARN_ON_ONCE(!p);
3553                 resp->rqstp->rq_vec[v].iov_base = p;
3554                 resp->rqstp->rq_vec[v].iov_len = thislen;
3555                 v++;
3556                 len -= thislen;
3557         }
3558         read->rd_vlen = v;
3559
3560         len = maxcount;
3561         nfserr = nfsd_readv(resp->rqstp, read->rd_fhp, file, read->rd_offset,
3562                             resp->rqstp->rq_vec, read->rd_vlen, &maxcount);
3563         read->rd_length = maxcount;
3564         if (nfserr)
3565                 return nfserr;
3566         xdr_truncate_encode(xdr, starting_len + 8 + ((maxcount+3)&~3));
3567
3568         eof = nfsd_eof_on_read(len, maxcount, read->rd_offset,
3569                                 d_inode(read->rd_fhp->fh_dentry)->i_size);
3570
3571         tmp = htonl(eof);
3572         write_bytes_to_xdr_buf(xdr->buf, starting_len    , &tmp, 4);
3573         tmp = htonl(maxcount);
3574         write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4);
3575
3576         pad = (maxcount&3) ? 4 - (maxcount&3) : 0;
3577         write_bytes_to_xdr_buf(xdr->buf, starting_len + 8 + maxcount,
3578                                                                 &zzz, pad);
3579         return 0;
3580
3581 }
3582
3583 static __be32
3584 nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,
3585                   struct nfsd4_read *read)
3586 {
3587         unsigned long maxcount;
3588         struct xdr_stream *xdr = &resp->xdr;
3589         struct file *file = read->rd_filp;
3590         int starting_len = xdr->buf->len;
3591         struct raparms *ra = NULL;
3592         __be32 *p;
3593
3594         p = xdr_reserve_space(xdr, 8); /* eof flag and byte count */
3595         if (!p) {
3596                 WARN_ON_ONCE(test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags));
3597                 return nfserr_resource;
3598         }
3599         if (resp->xdr.buf->page_len &&
3600             test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)) {
3601                 WARN_ON_ONCE(1);
3602                 return nfserr_resource;
3603         }
3604         xdr_commit_encode(xdr);
3605
3606         maxcount = svc_max_payload(resp->rqstp);
3607         maxcount = min_t(unsigned long, maxcount,
3608                          (xdr->buf->buflen - xdr->buf->len));
3609         maxcount = min_t(unsigned long, maxcount, read->rd_length);
3610
3611         if (read->rd_tmp_file)
3612                 ra = nfsd_init_raparms(file);
3613
3614         if (file->f_op->splice_read &&
3615             test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags))
3616                 nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount);
3617         else
3618                 nfserr = nfsd4_encode_readv(resp, read, file, maxcount);
3619
3620         if (ra)
3621                 nfsd_put_raparams(file, ra);
3622
3623         if (nfserr)
3624                 xdr_truncate_encode(xdr, starting_len);
3625
3626         return nfserr;
3627 }
3628
3629 static __be32
3630 nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink)
3631 {
3632         int maxcount;
3633         __be32 wire_count;
3634         int zero = 0;
3635         struct xdr_stream *xdr = &resp->xdr;
3636         int length_offset = xdr->buf->len;
3637         __be32 *p;
3638
3639         p = xdr_reserve_space(xdr, 4);
3640         if (!p)
3641                 return nfserr_resource;
3642         maxcount = PAGE_SIZE;
3643
3644         p = xdr_reserve_space(xdr, maxcount);
3645         if (!p)
3646                 return nfserr_resource;
3647         /*
3648          * XXX: By default, vfs_readlink() will truncate symlinks if they
3649          * would overflow the buffer.  Is this kosher in NFSv4?  If not, one
3650          * easy fix is: if vfs_readlink() precisely fills the buffer, assume
3651          * that truncation occurred, and return NFS4ERR_RESOURCE.
3652          */
3653         nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp,
3654                                                 (char *)p, &maxcount);
3655         if (nfserr == nfserr_isdir)
3656                 nfserr = nfserr_inval;
3657         if (nfserr) {
3658                 xdr_truncate_encode(xdr, length_offset);
3659                 return nfserr;
3660         }
3661
3662         wire_count = htonl(maxcount);
3663         write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, 4);
3664         xdr_truncate_encode(xdr, length_offset + 4 + ALIGN(maxcount, 4));
3665         if (maxcount & 3)
3666                 write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount,
3667                                                 &zero, 4 - (maxcount&3));
3668         return 0;
3669 }
3670
3671 static __be32
3672 nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir)
3673 {
3674         int maxcount;
3675         int bytes_left;
3676         loff_t offset;
3677         __be64 wire_offset;
3678         struct xdr_stream *xdr = &resp->xdr;
3679         int starting_len = xdr->buf->len;
3680         __be32 *p;
3681
3682         p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
3683         if (!p)
3684                 return nfserr_resource;
3685
3686         /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
3687         *p++ = cpu_to_be32(0);
3688         *p++ = cpu_to_be32(0);
3689         resp->xdr.buf->head[0].iov_len = ((char *)resp->xdr.p)
3690                                 - (char *)resp->xdr.buf->head[0].iov_base;
3691
3692         /*
3693          * Number of bytes left for directory entries allowing for the
3694          * final 8 bytes of the readdir and a following failed op:
3695          */
3696         bytes_left = xdr->buf->buflen - xdr->buf->len
3697                         - COMPOUND_ERR_SLACK_SPACE - 8;
3698         if (bytes_left < 0) {
3699                 nfserr = nfserr_resource;
3700                 goto err_no_verf;
3701         }
3702         maxcount = svc_max_payload(resp->rqstp);
3703         maxcount = min_t(u32, readdir->rd_maxcount, maxcount);
3704         /*
3705          * Note the rfc defines rd_maxcount as the size of the
3706          * READDIR4resok structure, which includes the verifier above
3707          * and the 8 bytes encoded at the end of this function:
3708          */
3709         if (maxcount < 16) {
3710                 nfserr = nfserr_toosmall;
3711                 goto err_no_verf;
3712         }
3713         maxcount = min_t(int, maxcount-16, bytes_left);
3714
3715         /* RFC 3530 14.2.24 allows us to ignore dircount when it's 0: */
3716         if (!readdir->rd_dircount)
3717                 readdir->rd_dircount = svc_max_payload(resp->rqstp);
3718
3719         readdir->xdr = xdr;
3720         readdir->rd_maxcount = maxcount;
3721         readdir->common.err = 0;
3722         readdir->cookie_offset = 0;
3723
3724         offset = readdir->rd_cookie;
3725         nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp,
3726                               &offset,
3727                               &readdir->common, nfsd4_encode_dirent);
3728         if (nfserr == nfs_ok &&
3729             readdir->common.err == nfserr_toosmall &&
3730             xdr->buf->len == starting_len + 8) {
3731                 /* nothing encoded; which limit did we hit?: */
3732                 if (maxcount - 16 < bytes_left)
3733                         /* It was the fault of rd_maxcount: */
3734                         nfserr = nfserr_toosmall;
3735                 else
3736                         /* We ran out of buffer space: */
3737                         nfserr = nfserr_resource;
3738         }
3739         if (nfserr)
3740                 goto err_no_verf;
3741
3742         if (readdir->cookie_offset) {
3743                 wire_offset = cpu_to_be64(offset);
3744                 write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset,
3745                                                         &wire_offset, 8);
3746         }
3747
3748         p = xdr_reserve_space(xdr, 8);
3749         if (!p) {
3750                 WARN_ON_ONCE(1);
3751                 goto err_no_verf;
3752         }
3753         *p++ = 0;       /* no more entries */
3754         *p++ = htonl(readdir->common.err == nfserr_eof);
3755
3756         return 0;
3757 err_no_verf:
3758         xdr_truncate_encode(xdr, starting_len);
3759         return nfserr;
3760 }
3761
3762 static __be32
3763 nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove)
3764 {
3765         struct xdr_stream *xdr = &resp->xdr;
3766         __be32 *p;
3767
3768         p = xdr_reserve_space(xdr, 20);
3769         if (!p)
3770                 return nfserr_resource;
3771         p = encode_cinfo(p, &remove->rm_cinfo);
3772         return 0;
3773 }
3774
3775 static __be32
3776 nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename)
3777 {
3778         struct xdr_stream *xdr = &resp->xdr;
3779         __be32 *p;
3780
3781         p = xdr_reserve_space(xdr, 40);
3782         if (!p)
3783                 return nfserr_resource;
3784         p = encode_cinfo(p, &rename->rn_sinfo);
3785         p = encode_cinfo(p, &rename->rn_tinfo);
3786         return 0;
3787 }
3788
3789 static __be32
3790 nfsd4_do_encode_secinfo(struct xdr_stream *xdr, struct svc_export *exp)
3791 {
3792         u32 i, nflavs, supported;
3793         struct exp_flavor_info *flavs;
3794         struct exp_flavor_info def_flavs[2];
3795         __be32 *p, *flavorsp;
3796         static bool report = true;
3797
3798         if (exp->ex_nflavors) {
3799                 flavs = exp->ex_flavors;
3800                 nflavs = exp->ex_nflavors;
3801         } else { /* Handling of some defaults in absence of real secinfo: */
3802                 flavs = def_flavs;
3803                 if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {
3804                         nflavs = 2;
3805                         flavs[0].pseudoflavor = RPC_AUTH_UNIX;
3806                         flavs[1].pseudoflavor = RPC_AUTH_NULL;
3807                 } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {
3808                         nflavs = 1;
3809                         flavs[0].pseudoflavor
3810                                         = svcauth_gss_flavor(exp->ex_client);
3811                 } else {
3812                         nflavs = 1;
3813                         flavs[0].pseudoflavor
3814                                         = exp->ex_client->flavour->flavour;
3815                 }
3816         }
3817
3818         supported = 0;
3819         p = xdr_reserve_space(xdr, 4);
3820         if (!p)
3821                 return nfserr_resource;
3822         flavorsp = p++;         /* to be backfilled later */
3823
3824         for (i = 0; i < nflavs; i++) {
3825                 rpc_authflavor_t pf = flavs[i].pseudoflavor;
3826                 struct rpcsec_gss_info info;
3827
3828                 if (rpcauth_get_gssinfo(pf, &info) == 0) {
3829                         supported++;
3830                         p = xdr_reserve_space(xdr, 4 + 4 +
3831                                               XDR_LEN(info.oid.len) + 4 + 4);
3832                         if (!p)
3833                                 return nfserr_resource;
3834                         *p++ = cpu_to_be32(RPC_AUTH_GSS);
3835                         p = xdr_encode_opaque(p,  info.oid.data, info.oid.len);
3836                         *p++ = cpu_to_be32(info.qop);
3837                         *p++ = cpu_to_be32(info.service);
3838                 } else if (pf < RPC_AUTH_MAXFLAVOR) {
3839                         supported++;
3840                         p = xdr_reserve_space(xdr, 4);
3841                         if (!p)
3842                                 return nfserr_resource;
3843                         *p++ = cpu_to_be32(pf);
3844                 } else {
3845                         if (report)
3846                                 pr_warn("NFS: SECINFO: security flavor %u "
3847                                         "is not supported\n", pf);
3848                 }
3849         }
3850
3851         if (nflavs != supported)
3852                 report = false;
3853         *flavorsp = htonl(supported);
3854         return 0;
3855 }
3856
3857 static __be32
3858 nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
3859                      struct nfsd4_secinfo *secinfo)
3860 {
3861         struct xdr_stream *xdr = &resp->xdr;
3862
3863         return nfsd4_do_encode_secinfo(xdr, secinfo->si_exp);
3864 }
3865
3866 static __be32
3867 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,
3868                      struct nfsd4_secinfo_no_name *secinfo)
3869 {
3870         struct xdr_stream *xdr = &resp->xdr;
3871
3872         return nfsd4_do_encode_secinfo(xdr, secinfo->sin_exp);
3873 }
3874
3875 /*
3876  * The SETATTR encode routine is special -- it always encodes a bitmap,
3877  * regardless of the error status.
3878  */
3879 static __be32
3880 nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr)
3881 {
3882         struct xdr_stream *xdr = &resp->xdr;
3883         __be32 *p;
3884
3885         p = xdr_reserve_space(xdr, 16);
3886         if (!p)
3887                 return nfserr_resource;
3888         if (nfserr) {
3889                 *p++ = cpu_to_be32(3);
3890                 *p++ = cpu_to_be32(0);
3891                 *p++ = cpu_to_be32(0);
3892                 *p++ = cpu_to_be32(0);
3893         }
3894         else {
3895                 *p++ = cpu_to_be32(3);
3896                 *p++ = cpu_to_be32(setattr->sa_bmval[0]);
3897                 *p++ = cpu_to_be32(setattr->sa_bmval[1]);
3898                 *p++ = cpu_to_be32(setattr->sa_bmval[2]);
3899         }
3900         return nfserr;
3901 }
3902
3903 static __be32
3904 nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd)
3905 {
3906         struct xdr_stream *xdr = &resp->xdr;
3907         __be32 *p;
3908
3909         if (!nfserr) {
3910                 p = xdr_reserve_space(xdr, 8 + NFS4_VERIFIER_SIZE);
3911                 if (!p)
3912                         return nfserr_resource;
3913                 p = xdr_encode_opaque_fixed(p, &scd->se_clientid, 8);
3914                 p = xdr_encode_opaque_fixed(p, &scd->se_confirm,
3915                                                 NFS4_VERIFIER_SIZE);
3916         }
3917         else if (nfserr == nfserr_clid_inuse) {
3918                 p = xdr_reserve_space(xdr, 8);
3919                 if (!p)
3920                         return nfserr_resource;
3921                 *p++ = cpu_to_be32(0);
3922                 *p++ = cpu_to_be32(0);
3923         }
3924         return nfserr;
3925 }
3926
3927 static __be32
3928 nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write)
3929 {
3930         struct xdr_stream *xdr = &resp->xdr;
3931         __be32 *p;
3932
3933         p = xdr_reserve_space(xdr, 16);
3934         if (!p)
3935                 return nfserr_resource;
3936         *p++ = cpu_to_be32(write->wr_bytes_written);
3937         *p++ = cpu_to_be32(write->wr_how_written);
3938         p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
3939                                                 NFS4_VERIFIER_SIZE);
3940         return 0;
3941 }
3942
3943 static __be32
3944 nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
3945                          struct nfsd4_exchange_id *exid)
3946 {
3947         struct xdr_stream *xdr = &resp->xdr;
3948         __be32 *p;
3949         char *major_id;
3950         char *server_scope;
3951         int major_id_sz;
3952         int server_scope_sz;
3953         uint64_t minor_id = 0;
3954
3955         major_id = utsname()->nodename;
3956         major_id_sz = strlen(major_id);
3957         server_scope = utsname()->nodename;
3958         server_scope_sz = strlen(server_scope);
3959
3960         p = xdr_reserve_space(xdr,
3961                 8 /* eir_clientid */ +
3962                 4 /* eir_sequenceid */ +
3963                 4 /* eir_flags */ +
3964                 4 /* spr_how */);
3965         if (!p)
3966                 return nfserr_resource;
3967
3968         p = xdr_encode_opaque_fixed(p, &exid->clientid, 8);
3969         *p++ = cpu_to_be32(exid->seqid);
3970         *p++ = cpu_to_be32(exid->flags);
3971
3972         *p++ = cpu_to_be32(exid->spa_how);
3973
3974         switch (exid->spa_how) {
3975         case SP4_NONE:
3976                 break;
3977         case SP4_MACH_CRED:
3978                 /* spo_must_enforce bitmap: */
3979                 nfserr = nfsd4_encode_bitmap(xdr,
3980                                         exid->spo_must_enforce[0],
3981                                         exid->spo_must_enforce[1],
3982                                         exid->spo_must_enforce[2]);
3983                 if (nfserr)
3984                         return nfserr;
3985                 /* spo_must_allow bitmap: */
3986                 nfserr = nfsd4_encode_bitmap(xdr,
3987                                         exid->spo_must_allow[0],
3988                                         exid->spo_must_allow[1],
3989                                         exid->spo_must_allow[2]);
3990                 if (nfserr)
3991                         return nfserr;
3992                 break;
3993         default:
3994                 WARN_ON_ONCE(1);
3995         }
3996
3997         p = xdr_reserve_space(xdr,
3998                 8 /* so_minor_id */ +
3999                 4 /* so_major_id.len */ +
4000                 (XDR_QUADLEN(major_id_sz) * 4) +
4001                 4 /* eir_server_scope.len */ +
4002                 (XDR_QUADLEN(server_scope_sz) * 4) +
4003                 4 /* eir_server_impl_id.count (0) */);
4004         if (!p)
4005                 return nfserr_resource;
4006
4007         /* The server_owner struct */
4008         p = xdr_encode_hyper(p, minor_id);      /* Minor id */
4009         /* major id */
4010         p = xdr_encode_opaque(p, major_id, major_id_sz);
4011
4012         /* Server scope */
4013         p = xdr_encode_opaque(p, server_scope, server_scope_sz);
4014
4015         /* Implementation id */
4016         *p++ = cpu_to_be32(0);  /* zero length nfs_impl_id4 array */
4017         return 0;
4018 }
4019
4020 static __be32
4021 nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,
4022                             struct nfsd4_create_session *sess)
4023 {
4024         struct xdr_stream *xdr = &resp->xdr;
4025         __be32 *p;
4026
4027         p = xdr_reserve_space(xdr, 24);
4028         if (!p)
4029                 return nfserr_resource;
4030         p = xdr_encode_opaque_fixed(p, sess->sessionid.data,
4031                                         NFS4_MAX_SESSIONID_LEN);
4032         *p++ = cpu_to_be32(sess->seqid);
4033         *p++ = cpu_to_be32(sess->flags);
4034
4035         p = xdr_reserve_space(xdr, 28);
4036         if (!p)
4037                 return nfserr_resource;
4038         *p++ = cpu_to_be32(0); /* headerpadsz */
4039         *p++ = cpu_to_be32(sess->fore_channel.maxreq_sz);
4040         *p++ = cpu_to_be32(sess->fore_channel.maxresp_sz);
4041         *p++ = cpu_to_be32(sess->fore_channel.maxresp_cached);
4042         *p++ = cpu_to_be32(sess->fore_channel.maxops);
4043         *p++ = cpu_to_be32(sess->fore_channel.maxreqs);
4044         *p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs);
4045
4046         if (sess->fore_channel.nr_rdma_attrs) {
4047                 p = xdr_reserve_space(xdr, 4);
4048                 if (!p)
4049                         return nfserr_resource;
4050                 *p++ = cpu_to_be32(sess->fore_channel.rdma_attrs);
4051         }
4052
4053         p = xdr_reserve_space(xdr, 28);
4054         if (!p)
4055                 return nfserr_resource;
4056         *p++ = cpu_to_be32(0); /* headerpadsz */
4057         *p++ = cpu_to_be32(sess->back_channel.maxreq_sz);
4058         *p++ = cpu_to_be32(sess->back_channel.maxresp_sz);
4059         *p++ = cpu_to_be32(sess->back_channel.maxresp_cached);
4060         *p++ = cpu_to_be32(sess->back_channel.maxops);
4061         *p++ = cpu_to_be32(sess->back_channel.maxreqs);
4062         *p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs);
4063
4064         if (sess->back_channel.nr_rdma_attrs) {
4065                 p = xdr_reserve_space(xdr, 4);
4066                 if (!p)
4067                         return nfserr_resource;
4068                 *p++ = cpu_to_be32(sess->back_channel.rdma_attrs);
4069         }
4070         return 0;
4071 }
4072
4073 static __be32
4074 nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,
4075                       struct nfsd4_sequence *seq)
4076 {
4077         struct xdr_stream *xdr = &resp->xdr;
4078         __be32 *p;
4079
4080         p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 20);
4081         if (!p)
4082                 return nfserr_resource;
4083         p = xdr_encode_opaque_fixed(p, seq->sessionid.data,
4084                                         NFS4_MAX_SESSIONID_LEN);
4085         *p++ = cpu_to_be32(seq->seqid);
4086         *p++ = cpu_to_be32(seq->slotid);
4087         /* Note slotid's are numbered from zero: */
4088         *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */
4089         *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */
4090         *p++ = cpu_to_be32(seq->status_flags);
4091
4092         resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */
4093         return 0;
4094 }
4095
4096 static __be32
4097 nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,
4098                           struct nfsd4_test_stateid *test_stateid)
4099 {
4100         struct xdr_stream *xdr = &resp->xdr;
4101         struct nfsd4_test_stateid_id *stateid, *next;
4102         __be32 *p;
4103
4104         p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids));
4105         if (!p)
4106                 return nfserr_resource;
4107         *p++ = htonl(test_stateid->ts_num_ids);
4108
4109         list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) {
4110                 *p++ = stateid->ts_id_status;
4111         }
4112
4113         return 0;
4114 }
4115
4116 #ifdef CONFIG_NFSD_PNFS
4117 static __be32
4118 nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
4119                 struct nfsd4_getdeviceinfo *gdev)
4120 {
4121         struct xdr_stream *xdr = &resp->xdr;
4122         const struct nfsd4_layout_ops *ops;
4123         u32 starting_len = xdr->buf->len, needed_len;
4124         __be32 *p;
4125
4126         p = xdr_reserve_space(xdr, 4);
4127         if (!p)
4128                 return nfserr_resource;
4129
4130         *p++ = cpu_to_be32(gdev->gd_layout_type);
4131
4132         /* If maxcount is 0 then just update notifications */
4133         if (gdev->gd_maxcount != 0) {
4134                 ops = nfsd4_layout_ops[gdev->gd_layout_type];
4135                 nfserr = ops->encode_getdeviceinfo(xdr, gdev);
4136                 if (nfserr) {
4137                         /*
4138                          * We don't bother to burden the layout drivers with
4139                          * enforcing gd_maxcount, just tell the client to
4140                          * come back with a bigger buffer if it's not enough.
4141                          */
4142                         if (xdr->buf->len + 4 > gdev->gd_maxcount)
4143                                 goto toosmall;
4144                         return nfserr;
4145                 }
4146         }
4147
4148         if (gdev->gd_notify_types) {
4149                 p = xdr_reserve_space(xdr, 4 + 4);
4150                 if (!p)
4151                         return nfserr_resource;
4152                 *p++ = cpu_to_be32(1);                  /* bitmap length */
4153                 *p++ = cpu_to_be32(gdev->gd_notify_types);
4154         } else {
4155                 p = xdr_reserve_space(xdr, 4);
4156                 if (!p)
4157                         return nfserr_resource;
4158                 *p++ = 0;
4159         }
4160
4161         return 0;
4162 toosmall:
4163         dprintk("%s: maxcount too small\n", __func__);
4164         needed_len = xdr->buf->len + 4 /* notifications */;
4165         xdr_truncate_encode(xdr, starting_len);
4166         p = xdr_reserve_space(xdr, 4);
4167         if (!p)
4168                 return nfserr_resource;
4169         *p++ = cpu_to_be32(needed_len);
4170         return nfserr_toosmall;
4171 }
4172
4173 static __be32
4174 nfsd4_encode_layoutget(struct nfsd4_compoundres *resp, __be32 nfserr,
4175                 struct nfsd4_layoutget *lgp)
4176 {
4177         struct xdr_stream *xdr = &resp->xdr;
4178         const struct nfsd4_layout_ops *ops;
4179         __be32 *p;
4180
4181         p = xdr_reserve_space(xdr, 36 + sizeof(stateid_opaque_t));
4182         if (!p)
4183                 return nfserr_resource;
4184
4185         *p++ = cpu_to_be32(1);  /* we always set return-on-close */
4186         *p++ = cpu_to_be32(lgp->lg_sid.si_generation);
4187         p = xdr_encode_opaque_fixed(p, &lgp->lg_sid.si_opaque,
4188                                     sizeof(stateid_opaque_t));
4189
4190         *p++ = cpu_to_be32(1);  /* we always return a single layout */
4191         p = xdr_encode_hyper(p, lgp->lg_seg.offset);
4192         p = xdr_encode_hyper(p, lgp->lg_seg.length);
4193         *p++ = cpu_to_be32(lgp->lg_seg.iomode);
4194         *p++ = cpu_to_be32(lgp->lg_layout_type);
4195
4196         ops = nfsd4_layout_ops[lgp->lg_layout_type];
4197         return ops->encode_layoutget(xdr, lgp);
4198 }
4199
4200 static __be32
4201 nfsd4_encode_layoutcommit(struct nfsd4_compoundres *resp, __be32 nfserr,
4202                           struct nfsd4_layoutcommit *lcp)
4203 {
4204         struct xdr_stream *xdr = &resp->xdr;
4205         __be32 *p;
4206
4207         p = xdr_reserve_space(xdr, 4);
4208         if (!p)
4209                 return nfserr_resource;
4210         *p++ = cpu_to_be32(lcp->lc_size_chg);
4211         if (lcp->lc_size_chg) {
4212                 p = xdr_reserve_space(xdr, 8);
4213                 if (!p)
4214                         return nfserr_resource;
4215                 p = xdr_encode_hyper(p, lcp->lc_newsize);
4216         }
4217
4218         return 0;
4219 }
4220
4221 static __be32
4222 nfsd4_encode_layoutreturn(struct nfsd4_compoundres *resp, __be32 nfserr,
4223                 struct nfsd4_layoutreturn *lrp)
4224 {
4225         struct xdr_stream *xdr = &resp->xdr;
4226         __be32 *p;
4227
4228         p = xdr_reserve_space(xdr, 4);
4229         if (!p)
4230                 return nfserr_resource;
4231         *p++ = cpu_to_be32(lrp->lrs_present);
4232         if (lrp->lrs_present)
4233                 return nfsd4_encode_stateid(xdr, &lrp->lr_sid);
4234         return 0;
4235 }
4236 #endif /* CONFIG_NFSD_PNFS */
4237
4238 static __be32
4239 nfsd42_encode_write_res(struct nfsd4_compoundres *resp,
4240                 struct nfsd42_write_res *write, bool sync)
4241 {
4242         __be32 *p;
4243         p = xdr_reserve_space(&resp->xdr, 4);
4244         if (!p)
4245                 return nfserr_resource;
4246
4247         if (sync)
4248                 *p++ = cpu_to_be32(0);
4249         else {
4250                 __be32 nfserr;
4251                 *p++ = cpu_to_be32(1);
4252                 nfserr = nfsd4_encode_stateid(&resp->xdr, &write->cb_stateid);
4253                 if (nfserr)
4254                         return nfserr;
4255         }
4256         p = xdr_reserve_space(&resp->xdr, 8 + 4 + NFS4_VERIFIER_SIZE);
4257         if (!p)
4258                 return nfserr_resource;
4259
4260         p = xdr_encode_hyper(p, write->wr_bytes_written);
4261         *p++ = cpu_to_be32(write->wr_stable_how);
4262         p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
4263                                     NFS4_VERIFIER_SIZE);
4264         return nfs_ok;
4265 }
4266
4267 static __be32
4268 nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr,
4269                   struct nfsd4_copy *copy)
4270 {
4271         __be32 *p;
4272
4273         nfserr = nfsd42_encode_write_res(resp, &copy->cp_res,
4274                         copy->cp_synchronous);
4275         if (nfserr)
4276                 return nfserr;
4277
4278         p = xdr_reserve_space(&resp->xdr, 4 + 4);
4279         *p++ = xdr_one; /* cr_consecutive */
4280         *p++ = cpu_to_be32(copy->cp_synchronous);
4281         return 0;
4282 }
4283
4284 static __be32
4285 nfsd4_encode_offload_status(struct nfsd4_compoundres *resp, __be32 nfserr,
4286                             struct nfsd4_offload_status *os)
4287 {
4288         struct xdr_stream *xdr = &resp->xdr;
4289         __be32 *p;
4290
4291         p = xdr_reserve_space(xdr, 8 + 4);
4292         if (!p)
4293                 return nfserr_resource;
4294         p = xdr_encode_hyper(p, os->count);
4295         *p++ = cpu_to_be32(0);
4296
4297         return nfserr;
4298 }
4299
4300 static __be32
4301 nfsd4_encode_seek(struct nfsd4_compoundres *resp, __be32 nfserr,
4302                   struct nfsd4_seek *seek)
4303 {
4304         __be32 *p;
4305
4306         p = xdr_reserve_space(&resp->xdr, 4 + 8);
4307         *p++ = cpu_to_be32(seek->seek_eof);
4308         p = xdr_encode_hyper(p, seek->seek_pos);
4309
4310         return 0;
4311 }
4312
4313 static __be32
4314 nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p)
4315 {
4316         return nfserr;
4317 }
4318
4319 typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *);
4320
4321 /*
4322  * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
4323  * since we don't need to filter out obsolete ops as this is
4324  * done in the decoding phase.
4325  */
4326 static const nfsd4_enc nfsd4_enc_ops[] = {
4327         [OP_ACCESS]             = (nfsd4_enc)nfsd4_encode_access,
4328         [OP_CLOSE]              = (nfsd4_enc)nfsd4_encode_close,
4329         [OP_COMMIT]             = (nfsd4_enc)nfsd4_encode_commit,
4330         [OP_CREATE]             = (nfsd4_enc)nfsd4_encode_create,
4331         [OP_DELEGPURGE]         = (nfsd4_enc)nfsd4_encode_noop,
4332         [OP_DELEGRETURN]        = (nfsd4_enc)nfsd4_encode_noop,
4333         [OP_GETATTR]            = (nfsd4_enc)nfsd4_encode_getattr,
4334         [OP_GETFH]              = (nfsd4_enc)nfsd4_encode_getfh,
4335         [OP_LINK]               = (nfsd4_enc)nfsd4_encode_link,
4336         [OP_LOCK]               = (nfsd4_enc)nfsd4_encode_lock,
4337         [OP_LOCKT]              = (nfsd4_enc)nfsd4_encode_lockt,
4338         [OP_LOCKU]              = (nfsd4_enc)nfsd4_encode_locku,
4339         [OP_LOOKUP]             = (nfsd4_enc)nfsd4_encode_noop,
4340         [OP_LOOKUPP]            = (nfsd4_enc)nfsd4_encode_noop,
4341         [OP_NVERIFY]            = (nfsd4_enc)nfsd4_encode_noop,
4342         [OP_OPEN]               = (nfsd4_enc)nfsd4_encode_open,
4343         [OP_OPENATTR]           = (nfsd4_enc)nfsd4_encode_noop,
4344         [OP_OPEN_CONFIRM]       = (nfsd4_enc)nfsd4_encode_open_confirm,
4345         [OP_OPEN_DOWNGRADE]     = (nfsd4_enc)nfsd4_encode_open_downgrade,
4346         [OP_PUTFH]              = (nfsd4_enc)nfsd4_encode_noop,
4347         [OP_PUTPUBFH]           = (nfsd4_enc)nfsd4_encode_noop,
4348         [OP_PUTROOTFH]          = (nfsd4_enc)nfsd4_encode_noop,
4349         [OP_READ]               = (nfsd4_enc)nfsd4_encode_read,
4350         [OP_READDIR]            = (nfsd4_enc)nfsd4_encode_readdir,
4351         [OP_READLINK]           = (nfsd4_enc)nfsd4_encode_readlink,
4352         [OP_REMOVE]             = (nfsd4_enc)nfsd4_encode_remove,
4353         [OP_RENAME]             = (nfsd4_enc)nfsd4_encode_rename,
4354         [OP_RENEW]              = (nfsd4_enc)nfsd4_encode_noop,
4355         [OP_RESTOREFH]          = (nfsd4_enc)nfsd4_encode_noop,
4356         [OP_SAVEFH]             = (nfsd4_enc)nfsd4_encode_noop,
4357         [OP_SECINFO]            = (nfsd4_enc)nfsd4_encode_secinfo,
4358         [OP_SETATTR]            = (nfsd4_enc)nfsd4_encode_setattr,
4359         [OP_SETCLIENTID]        = (nfsd4_enc)nfsd4_encode_setclientid,
4360         [OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop,
4361         [OP_VERIFY]             = (nfsd4_enc)nfsd4_encode_noop,
4362         [OP_WRITE]              = (nfsd4_enc)nfsd4_encode_write,
4363         [OP_RELEASE_LOCKOWNER]  = (nfsd4_enc)nfsd4_encode_noop,
4364
4365         /* NFSv4.1 operations */
4366         [OP_BACKCHANNEL_CTL]    = (nfsd4_enc)nfsd4_encode_noop,
4367         [OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session,
4368         [OP_EXCHANGE_ID]        = (nfsd4_enc)nfsd4_encode_exchange_id,
4369         [OP_CREATE_SESSION]     = (nfsd4_enc)nfsd4_encode_create_session,
4370         [OP_DESTROY_SESSION]    = (nfsd4_enc)nfsd4_encode_noop,
4371         [OP_FREE_STATEID]       = (nfsd4_enc)nfsd4_encode_noop,
4372         [OP_GET_DIR_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop,
4373 #ifdef CONFIG_NFSD_PNFS
4374         [OP_GETDEVICEINFO]      = (nfsd4_enc)nfsd4_encode_getdeviceinfo,
4375         [OP_GETDEVICELIST]      = (nfsd4_enc)nfsd4_encode_noop,
4376         [OP_LAYOUTCOMMIT]       = (nfsd4_enc)nfsd4_encode_layoutcommit,
4377         [OP_LAYOUTGET]          = (nfsd4_enc)nfsd4_encode_layoutget,
4378         [OP_LAYOUTRETURN]       = (nfsd4_enc)nfsd4_encode_layoutreturn,
4379 #else
4380         [OP_GETDEVICEINFO]      = (nfsd4_enc)nfsd4_encode_noop,
4381         [OP_GETDEVICELIST]      = (nfsd4_enc)nfsd4_encode_noop,
4382         [OP_LAYOUTCOMMIT]       = (nfsd4_enc)nfsd4_encode_noop,
4383         [OP_LAYOUTGET]          = (nfsd4_enc)nfsd4_encode_noop,
4384         [OP_LAYOUTRETURN]       = (nfsd4_enc)nfsd4_encode_noop,
4385 #endif
4386         [OP_SECINFO_NO_NAME]    = (nfsd4_enc)nfsd4_encode_secinfo_no_name,
4387         [OP_SEQUENCE]           = (nfsd4_enc)nfsd4_encode_sequence,
4388         [OP_SET_SSV]            = (nfsd4_enc)nfsd4_encode_noop,
4389         [OP_TEST_STATEID]       = (nfsd4_enc)nfsd4_encode_test_stateid,
4390         [OP_WANT_DELEGATION]    = (nfsd4_enc)nfsd4_encode_noop,
4391         [OP_DESTROY_CLIENTID]   = (nfsd4_enc)nfsd4_encode_noop,
4392         [OP_RECLAIM_COMPLETE]   = (nfsd4_enc)nfsd4_encode_noop,
4393
4394         /* NFSv4.2 operations */
4395         [OP_ALLOCATE]           = (nfsd4_enc)nfsd4_encode_noop,
4396         [OP_COPY]               = (nfsd4_enc)nfsd4_encode_copy,
4397         [OP_COPY_NOTIFY]        = (nfsd4_enc)nfsd4_encode_noop,
4398         [OP_DEALLOCATE]         = (nfsd4_enc)nfsd4_encode_noop,
4399         [OP_IO_ADVISE]          = (nfsd4_enc)nfsd4_encode_noop,
4400         [OP_LAYOUTERROR]        = (nfsd4_enc)nfsd4_encode_noop,
4401         [OP_LAYOUTSTATS]        = (nfsd4_enc)nfsd4_encode_noop,
4402         [OP_OFFLOAD_CANCEL]     = (nfsd4_enc)nfsd4_encode_noop,
4403         [OP_OFFLOAD_STATUS]     = (nfsd4_enc)nfsd4_encode_offload_status,
4404         [OP_READ_PLUS]          = (nfsd4_enc)nfsd4_encode_noop,
4405         [OP_SEEK]               = (nfsd4_enc)nfsd4_encode_seek,
4406         [OP_WRITE_SAME]         = (nfsd4_enc)nfsd4_encode_noop,
4407         [OP_CLONE]              = (nfsd4_enc)nfsd4_encode_noop,
4408 };
4409
4410 /*
4411  * Calculate whether we still have space to encode repsize bytes.
4412  * There are two considerations:
4413  *     - For NFS versions >=4.1, the size of the reply must stay within
4414  *       session limits
4415  *     - For all NFS versions, we must stay within limited preallocated
4416  *       buffer space.
4417  *
4418  * This is called before the operation is processed, so can only provide
4419  * an upper estimate.  For some nonidempotent operations (such as
4420  * getattr), it's not necessarily a problem if that estimate is wrong,
4421  * as we can fail it after processing without significant side effects.
4422  */
4423 __be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize)
4424 {
4425         struct xdr_buf *buf = &resp->rqstp->rq_res;
4426         struct nfsd4_slot *slot = resp->cstate.slot;
4427
4428         if (buf->len + respsize <= buf->buflen)
4429                 return nfs_ok;
4430         if (!nfsd4_has_session(&resp->cstate))
4431                 return nfserr_resource;
4432         if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) {
4433                 WARN_ON_ONCE(1);
4434                 return nfserr_rep_too_big_to_cache;
4435         }
4436         return nfserr_rep_too_big;
4437 }
4438
4439 void
4440 nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
4441 {
4442         struct xdr_stream *xdr = &resp->xdr;
4443         struct nfs4_stateowner *so = resp->cstate.replay_owner;
4444         struct svc_rqst *rqstp = resp->rqstp;
4445         const struct nfsd4_operation *opdesc = op->opdesc;
4446         int post_err_offset;
4447         nfsd4_enc encoder;
4448         __be32 *p;
4449
4450         p = xdr_reserve_space(xdr, 8);
4451         if (!p) {
4452                 WARN_ON_ONCE(1);
4453                 return;
4454         }
4455         *p++ = cpu_to_be32(op->opnum);
4456         post_err_offset = xdr->buf->len;
4457
4458         if (op->opnum == OP_ILLEGAL)
4459                 goto status;
4460         if (op->status && opdesc &&
4461                         !(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE))
4462                 goto status;
4463         BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||
4464                !nfsd4_enc_ops[op->opnum]);
4465         encoder = nfsd4_enc_ops[op->opnum];
4466         op->status = encoder(resp, op->status, &op->u);
4467         if (opdesc && opdesc->op_release)
4468                 opdesc->op_release(&op->u);
4469         xdr_commit_encode(xdr);
4470
4471         /* nfsd4_check_resp_size guarantees enough room for error status */
4472         if (!op->status) {
4473                 int space_needed = 0;
4474                 if (!nfsd4_last_compound_op(rqstp))
4475                         space_needed = COMPOUND_ERR_SLACK_SPACE;
4476                 op->status = nfsd4_check_resp_size(resp, space_needed);
4477         }
4478         if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) {
4479                 struct nfsd4_slot *slot = resp->cstate.slot;
4480
4481                 if (slot->sl_flags & NFSD4_SLOT_CACHETHIS)
4482                         op->status = nfserr_rep_too_big_to_cache;
4483                 else
4484                         op->status = nfserr_rep_too_big;
4485         }
4486         if (op->status == nfserr_resource ||
4487             op->status == nfserr_rep_too_big ||
4488             op->status == nfserr_rep_too_big_to_cache) {
4489                 /*
4490                  * The operation may have already been encoded or
4491                  * partially encoded.  No op returns anything additional
4492                  * in the case of one of these three errors, so we can
4493                  * just truncate back to after the status.  But it's a
4494                  * bug if we had to do this on a non-idempotent op:
4495                  */
4496                 warn_on_nonidempotent_op(op);
4497                 xdr_truncate_encode(xdr, post_err_offset);
4498         }
4499         if (so) {
4500                 int len = xdr->buf->len - post_err_offset;
4501
4502                 so->so_replay.rp_status = op->status;
4503                 so->so_replay.rp_buflen = len;
4504                 read_bytes_from_xdr_buf(xdr->buf, post_err_offset,
4505                                                 so->so_replay.rp_buf, len);
4506         }
4507 status:
4508         /* Note that op->status is already in network byte order: */
4509         write_bytes_to_xdr_buf(xdr->buf, post_err_offset - 4, &op->status, 4);
4510 }
4511
4512 /*
4513  * Encode the reply stored in the stateowner reply cache
4514  *
4515  * XDR note: do not encode rp->rp_buflen: the buffer contains the
4516  * previously sent already encoded operation.
4517  */
4518 void
4519 nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op)
4520 {
4521         __be32 *p;
4522         struct nfs4_replay *rp = op->replay;
4523
4524         BUG_ON(!rp);
4525
4526         p = xdr_reserve_space(xdr, 8 + rp->rp_buflen);
4527         if (!p) {
4528                 WARN_ON_ONCE(1);
4529                 return;
4530         }
4531         *p++ = cpu_to_be32(op->opnum);
4532         *p++ = rp->rp_status;  /* already xdr'ed */
4533
4534         p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen);
4535 }
4536
4537 int
4538 nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p)
4539 {
4540         return xdr_ressize_check(rqstp, p);
4541 }
4542
4543 void nfsd4_release_compoundargs(struct svc_rqst *rqstp)
4544 {
4545         struct nfsd4_compoundargs *args = rqstp->rq_argp;
4546
4547         if (args->ops != args->iops) {
4548                 kfree(args->ops);
4549                 args->ops = args->iops;
4550         }
4551         kfree(args->tmpp);
4552         args->tmpp = NULL;
4553         while (args->to_free) {
4554                 struct svcxdr_tmpbuf *tb = args->to_free;
4555                 args->to_free = tb->next;
4556                 kfree(tb);
4557         }
4558 }
4559
4560 int
4561 nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p)
4562 {
4563         struct nfsd4_compoundargs *args = rqstp->rq_argp;
4564
4565         if (rqstp->rq_arg.head[0].iov_len % 4) {
4566                 /* client is nuts */
4567                 dprintk("%s: compound not properly padded! (peeraddr=%pISc xid=0x%x)",
4568                         __func__, svc_addr(rqstp), be32_to_cpu(rqstp->rq_xid));
4569                 return 0;
4570         }
4571         args->p = p;
4572         args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len;
4573         args->pagelist = rqstp->rq_arg.pages;
4574         args->pagelen = rqstp->rq_arg.page_len;
4575         args->tail = false;
4576         args->tmpp = NULL;
4577         args->to_free = NULL;
4578         args->ops = args->iops;
4579         args->rqstp = rqstp;
4580
4581         return !nfsd4_decode_compound(args);
4582 }
4583
4584 int
4585 nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p)
4586 {
4587         /*
4588          * All that remains is to write the tag and operation count...
4589          */
4590         struct nfsd4_compoundres *resp = rqstp->rq_resp;
4591         struct xdr_buf *buf = resp->xdr.buf;
4592
4593         WARN_ON_ONCE(buf->len != buf->head[0].iov_len + buf->page_len +
4594                                  buf->tail[0].iov_len);
4595
4596         rqstp->rq_next_page = resp->xdr.page_ptr + 1;
4597
4598         p = resp->tagp;
4599         *p++ = htonl(resp->taglen);
4600         memcpy(p, resp->tag, resp->taglen);
4601         p += XDR_QUADLEN(resp->taglen);
4602         *p++ = htonl(resp->opcnt);
4603
4604         nfsd4_sequence_done(resp);
4605         return 1;
4606 }
4607
4608 /*
4609  * Local variables:
4610  *  c-basic-offset: 8
4611  * End:
4612  */