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