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 <[email protected]>
   8  *  Andy Adamson   <[email protected]>
   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 bool
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 false;
2336         max_reply += XDR_UNIT;
2337         argp->tag = NULL;
2338         if (unlikely(argp->taglen)) {
2339                 if (argp->taglen > NFSD4_MAX_TAGLEN)
2340                         return false;
2341                 p = xdr_inline_decode(argp->xdr, argp->taglen);
2342                 if (!p)
2343                         return false;
2344                 argp->tag = svcxdr_savemem(argp, p, argp->taglen);
2345                 if (!argp->tag)
2346                         return false;
2347                 max_reply += xdr_align_size(argp->taglen);
2348         }
2349
2350         if (xdr_stream_decode_u32(argp->xdr, &argp->minorversion) < 0)
2351                 return false;
2352         if (xdr_stream_decode_u32(argp->xdr, &argp->opcnt) < 0)
2353                 return false;
2354
2355         /*
2356          * NFS4ERR_RESOURCE is a more helpful error than GARBAGE_ARGS
2357          * here, so we return success at the xdr level so that
2358          * nfsd4_proc can handle this is an NFS-level error.
2359          */
2360         if (argp->opcnt > NFSD_MAX_OPS_PER_COMPOUND)
2361                 return true;
2362
2363         if (argp->opcnt > ARRAY_SIZE(argp->iops)) {
2364                 argp->ops = kzalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);
2365                 if (!argp->ops) {
2366                         argp->ops = argp->iops;
2367                         dprintk("nfsd: couldn't allocate room for COMPOUND\n");
2368                         return false;
2369                 }
2370         }
2371
2372         if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION)
2373                 argp->opcnt = 0;
2374
2375         for (i = 0; i < argp->opcnt; i++) {
2376                 op = &argp->ops[i];
2377                 op->replay = NULL;
2378
2379                 if (xdr_stream_decode_u32(argp->xdr, &op->opnum) < 0)
2380                         return false;
2381                 if (nfsd4_opnum_in_range(argp, op)) {
2382                         op->status = nfsd4_dec_ops[op->opnum](argp, &op->u);
2383                         if (op->status != nfs_ok)
2384                                 trace_nfsd_compound_decode_err(argp->rqstp,
2385                                                                argp->opcnt, i,
2386                                                                op->opnum,
2387                                                                op->status);
2388                 } else {
2389                         op->opnum = OP_ILLEGAL;
2390                         op->status = nfserr_op_illegal;
2391                 }
2392                 op->opdesc = OPDESC(op);
2393                 /*
2394                  * We'll try to cache the result in the DRC if any one
2395                  * op in the compound wants to be cached:
2396                  */
2397                 cachethis |= nfsd4_cache_this_op(op);
2398
2399                 if (op->opnum == OP_READ || op->opnum == OP_READ_PLUS) {
2400                         readcount++;
2401                         readbytes += nfsd4_max_reply(argp->rqstp, op);
2402                 } else
2403                         max_reply += nfsd4_max_reply(argp->rqstp, op);
2404                 /*
2405                  * OP_LOCK and OP_LOCKT may return a conflicting lock.
2406                  * (Special case because it will just skip encoding this
2407                  * if it runs out of xdr buffer space, and it is the only
2408                  * operation that behaves this way.)
2409                  */
2410                 if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT)
2411                         max_reply += NFS4_OPAQUE_LIMIT;
2412
2413                 if (op->status) {
2414                         argp->opcnt = i+1;
2415                         break;
2416                 }
2417         }
2418         /* Sessions make the DRC unnecessary: */
2419         if (argp->minorversion)
2420                 cachethis = false;
2421         svc_reserve(argp->rqstp, max_reply + readbytes);
2422         argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;
2423
2424         if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack)
2425                 clear_bit(RQ_SPLICE_OK, &argp->rqstp->rq_flags);
2426
2427         return true;
2428 }
2429
2430 static __be32 *encode_change(__be32 *p, struct kstat *stat, struct inode *inode,
2431                              struct svc_export *exp)
2432 {
2433         if (exp->ex_flags & NFSEXP_V4ROOT) {
2434                 *p++ = cpu_to_be32(convert_to_wallclock(exp->cd->flush_time));
2435                 *p++ = 0;
2436         } else
2437                 p = xdr_encode_hyper(p, nfsd4_change_attribute(stat, inode));
2438         return p;
2439 }
2440
2441 /*
2442  * ctime (in NFSv4, time_metadata) is not writeable, and the client
2443  * doesn't really care what resolution could theoretically be stored by
2444  * the filesystem.
2445  *
2446  * The client cares how close together changes can be while still
2447  * guaranteeing ctime changes.  For most filesystems (which have
2448  * timestamps with nanosecond fields) that is limited by the resolution
2449  * of the time returned from current_time() (which I'm assuming to be
2450  * 1/HZ).
2451  */
2452 static __be32 *encode_time_delta(__be32 *p, struct inode *inode)
2453 {
2454         struct timespec64 ts;
2455         u32 ns;
2456
2457         ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran);
2458         ts = ns_to_timespec64(ns);
2459
2460         p = xdr_encode_hyper(p, ts.tv_sec);
2461         *p++ = cpu_to_be32(ts.tv_nsec);
2462
2463         return p;
2464 }
2465
2466 static __be32 *encode_cinfo(__be32 *p, struct nfsd4_change_info *c)
2467 {
2468         *p++ = cpu_to_be32(c->atomic);
2469         p = xdr_encode_hyper(p, c->before_change);
2470         p = xdr_encode_hyper(p, c->after_change);
2471         return p;
2472 }
2473
2474 /* Encode as an array of strings the string given with components
2475  * separated @sep, escaped with esc_enter and esc_exit.
2476  */
2477 static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep,
2478                                           char *components, char esc_enter,
2479                                           char esc_exit)
2480 {
2481         __be32 *p;
2482         __be32 pathlen;
2483         int pathlen_offset;
2484         int strlen, count=0;
2485         char *str, *end, *next;
2486
2487         dprintk("nfsd4_encode_components(%s)\n", components);
2488
2489         pathlen_offset = xdr->buf->len;
2490         p = xdr_reserve_space(xdr, 4);
2491         if (!p)
2492                 return nfserr_resource;
2493         p++; /* We will fill this in with @count later */
2494
2495         end = str = components;
2496         while (*end) {
2497                 bool found_esc = false;
2498
2499                 /* try to parse as esc_start, ..., esc_end, sep */
2500                 if (*str == esc_enter) {
2501                         for (; *end && (*end != esc_exit); end++)
2502                                 /* find esc_exit or end of string */;
2503                         next = end + 1;
2504                         if (*end && (!*next || *next == sep)) {
2505                                 str++;
2506                                 found_esc = true;
2507                         }
2508                 }
2509
2510                 if (!found_esc)
2511                         for (; *end && (*end != sep); end++)
2512                                 /* find sep or end of string */;
2513
2514                 strlen = end - str;
2515                 if (strlen) {
2516                         p = xdr_reserve_space(xdr, strlen + 4);
2517                         if (!p)
2518                                 return nfserr_resource;
2519                         p = xdr_encode_opaque(p, str, strlen);
2520                         count++;
2521                 }
2522                 else
2523                         end++;
2524                 if (found_esc)
2525                         end = next;
2526
2527                 str = end;
2528         }
2529         pathlen = htonl(count);
2530         write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4);
2531         return 0;
2532 }
2533
2534 /* Encode as an array of strings the string given with components
2535  * separated @sep.
2536  */
2537 static __be32 nfsd4_encode_components(struct xdr_stream *xdr, char sep,
2538                                       char *components)
2539 {
2540         return nfsd4_encode_components_esc(xdr, sep, components, 0, 0);
2541 }
2542
2543 /*
2544  * encode a location element of a fs_locations structure
2545  */
2546 static __be32 nfsd4_encode_fs_location4(struct xdr_stream *xdr,
2547                                         struct nfsd4_fs_location *location)
2548 {
2549         __be32 status;
2550
2551         status = nfsd4_encode_components_esc(xdr, ':', location->hosts,
2552                                                 '[', ']');
2553         if (status)
2554                 return status;
2555         status = nfsd4_encode_components(xdr, '/', location->path);
2556         if (status)
2557                 return status;
2558         return 0;
2559 }
2560
2561 /*
2562  * Encode a path in RFC3530 'pathname4' format
2563  */
2564 static __be32 nfsd4_encode_path(struct xdr_stream *xdr,
2565                                 const struct path *root,
2566                                 const struct path *path)
2567 {
2568         struct path cur = *path;
2569         __be32 *p;
2570         struct dentry **components = NULL;
2571         unsigned int ncomponents = 0;
2572         __be32 err = nfserr_jukebox;
2573
2574         dprintk("nfsd4_encode_components(");
2575
2576         path_get(&cur);
2577         /* First walk the path up to the nfsd root, and store the
2578          * dentries/path components in an array.
2579          */
2580         for (;;) {
2581                 if (path_equal(&cur, root))
2582                         break;
2583                 if (cur.dentry == cur.mnt->mnt_root) {
2584                         if (follow_up(&cur))
2585                                 continue;
2586                         goto out_free;
2587                 }
2588                 if ((ncomponents & 15) == 0) {
2589                         struct dentry **new;
2590                         new = krealloc(components,
2591                                         sizeof(*new) * (ncomponents + 16),
2592                                         GFP_KERNEL);
2593                         if (!new)
2594                                 goto out_free;
2595                         components = new;
2596                 }
2597                 components[ncomponents++] = cur.dentry;
2598                 cur.dentry = dget_parent(cur.dentry);
2599         }
2600         err = nfserr_resource;
2601         p = xdr_reserve_space(xdr, 4);
2602         if (!p)
2603                 goto out_free;
2604         *p++ = cpu_to_be32(ncomponents);
2605
2606         while (ncomponents) {
2607                 struct dentry *dentry = components[ncomponents - 1];
2608                 unsigned int len;
2609
2610                 spin_lock(&dentry->d_lock);
2611                 len = dentry->d_name.len;
2612                 p = xdr_reserve_space(xdr, len + 4);
2613                 if (!p) {
2614                         spin_unlock(&dentry->d_lock);
2615                         goto out_free;
2616                 }
2617                 p = xdr_encode_opaque(p, dentry->d_name.name, len);
2618                 dprintk("/%pd", dentry);
2619                 spin_unlock(&dentry->d_lock);
2620                 dput(dentry);
2621                 ncomponents--;
2622         }
2623
2624         err = 0;
2625 out_free:
2626         dprintk(")\n");
2627         while (ncomponents)
2628                 dput(components[--ncomponents]);
2629         kfree(components);
2630         path_put(&cur);
2631         return err;
2632 }
2633
2634 static __be32 nfsd4_encode_fsloc_fsroot(struct xdr_stream *xdr,
2635                         struct svc_rqst *rqstp, const struct path *path)
2636 {
2637         struct svc_export *exp_ps;
2638         __be32 res;
2639
2640         exp_ps = rqst_find_fsidzero_export(rqstp);
2641         if (IS_ERR(exp_ps))
2642                 return nfserrno(PTR_ERR(exp_ps));
2643         res = nfsd4_encode_path(xdr, &exp_ps->ex_path, path);
2644         exp_put(exp_ps);
2645         return res;
2646 }
2647
2648 /*
2649  *  encode a fs_locations structure
2650  */
2651 static __be32 nfsd4_encode_fs_locations(struct xdr_stream *xdr,
2652                         struct svc_rqst *rqstp, struct svc_export *exp)
2653 {
2654         __be32 status;
2655         int i;
2656         __be32 *p;
2657         struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;
2658
2659         status = nfsd4_encode_fsloc_fsroot(xdr, rqstp, &exp->ex_path);
2660         if (status)
2661                 return status;
2662         p = xdr_reserve_space(xdr, 4);
2663         if (!p)
2664                 return nfserr_resource;
2665         *p++ = cpu_to_be32(fslocs->locations_count);
2666         for (i=0; i<fslocs->locations_count; i++) {
2667                 status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]);
2668                 if (status)
2669                         return status;
2670         }
2671         return 0;
2672 }
2673
2674 static u32 nfs4_file_type(umode_t mode)
2675 {
2676         switch (mode & S_IFMT) {
2677         case S_IFIFO:   return NF4FIFO;
2678         case S_IFCHR:   return NF4CHR;
2679         case S_IFDIR:   return NF4DIR;
2680         case S_IFBLK:   return NF4BLK;
2681         case S_IFLNK:   return NF4LNK;
2682         case S_IFREG:   return NF4REG;
2683         case S_IFSOCK:  return NF4SOCK;
2684         default:        return NF4BAD;
2685         }
2686 }
2687
2688 static inline __be32
2689 nfsd4_encode_aclname(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2690                      struct nfs4_ace *ace)
2691 {
2692         if (ace->whotype != NFS4_ACL_WHO_NAMED)
2693                 return nfs4_acl_write_who(xdr, ace->whotype);
2694         else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
2695                 return nfsd4_encode_group(xdr, rqstp, ace->who_gid);
2696         else
2697                 return nfsd4_encode_user(xdr, rqstp, ace->who_uid);
2698 }
2699
2700 static inline __be32
2701 nfsd4_encode_layout_types(struct xdr_stream *xdr, u32 layout_types)
2702 {
2703         __be32          *p;
2704         unsigned long   i = hweight_long(layout_types);
2705
2706         p = xdr_reserve_space(xdr, 4 + 4 * i);
2707         if (!p)
2708                 return nfserr_resource;
2709
2710         *p++ = cpu_to_be32(i);
2711
2712         for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i)
2713                 if (layout_types & (1 << i))
2714                         *p++ = cpu_to_be32(i);
2715
2716         return 0;
2717 }
2718
2719 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
2720                               FATTR4_WORD0_RDATTR_ERROR)
2721 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
2722 #define WORD2_ABSENT_FS_ATTRS 0
2723
2724 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2725 static inline __be32
2726 nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2727                             void *context, int len)
2728 {
2729         __be32 *p;
2730
2731         p = xdr_reserve_space(xdr, len + 4 + 4 + 4);
2732         if (!p)
2733                 return nfserr_resource;
2734
2735         /*
2736          * For now we use a 0 here to indicate the null translation; in
2737          * the future we may place a call to translation code here.
2738          */
2739         *p++ = cpu_to_be32(0); /* lfs */
2740         *p++ = cpu_to_be32(0); /* pi */
2741         p = xdr_encode_opaque(p, context, len);
2742         return 0;
2743 }
2744 #else
2745 static inline __be32
2746 nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2747                             void *context, int len)
2748 { return 0; }
2749 #endif
2750
2751 static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *bmval2, u32 *rdattr_err)
2752 {
2753         /* As per referral draft:  */
2754         if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS ||
2755             *bmval1 & ~WORD1_ABSENT_FS_ATTRS) {
2756                 if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR ||
2757                     *bmval0 & FATTR4_WORD0_FS_LOCATIONS)
2758                         *rdattr_err = NFSERR_MOVED;
2759                 else
2760                         return nfserr_moved;
2761         }
2762         *bmval0 &= WORD0_ABSENT_FS_ATTRS;
2763         *bmval1 &= WORD1_ABSENT_FS_ATTRS;
2764         *bmval2 &= WORD2_ABSENT_FS_ATTRS;
2765         return 0;
2766 }
2767
2768
2769 static int get_parent_attributes(struct svc_export *exp, struct kstat *stat)
2770 {
2771         struct path path = exp->ex_path;
2772         int err;
2773
2774         path_get(&path);
2775         while (follow_up(&path)) {
2776                 if (path.dentry != path.mnt->mnt_root)
2777                         break;
2778         }
2779         err = vfs_getattr(&path, stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
2780         path_put(&path);
2781         return err;
2782 }
2783
2784 static __be32
2785 nfsd4_encode_bitmap(struct xdr_stream *xdr, u32 bmval0, u32 bmval1, u32 bmval2)
2786 {
2787         __be32 *p;
2788
2789         if (bmval2) {
2790                 p = xdr_reserve_space(xdr, 16);
2791                 if (!p)
2792                         goto out_resource;
2793                 *p++ = cpu_to_be32(3);
2794                 *p++ = cpu_to_be32(bmval0);
2795                 *p++ = cpu_to_be32(bmval1);
2796                 *p++ = cpu_to_be32(bmval2);
2797         } else if (bmval1) {
2798                 p = xdr_reserve_space(xdr, 12);
2799                 if (!p)
2800                         goto out_resource;
2801                 *p++ = cpu_to_be32(2);
2802                 *p++ = cpu_to_be32(bmval0);
2803                 *p++ = cpu_to_be32(bmval1);
2804         } else {
2805                 p = xdr_reserve_space(xdr, 8);
2806                 if (!p)
2807                         goto out_resource;
2808                 *p++ = cpu_to_be32(1);
2809                 *p++ = cpu_to_be32(bmval0);
2810         }
2811
2812         return 0;
2813 out_resource:
2814         return nfserr_resource;
2815 }
2816
2817 /*
2818  * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
2819  * ourselves.
2820  */
2821 static __be32
2822 nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
2823                 struct svc_export *exp,
2824                 struct dentry *dentry, u32 *bmval,
2825                 struct svc_rqst *rqstp, int ignore_crossmnt)
2826 {
2827         u32 bmval0 = bmval[0];
2828         u32 bmval1 = bmval[1];
2829         u32 bmval2 = bmval[2];
2830         struct kstat stat;
2831         struct svc_fh *tempfh = NULL;
2832         struct kstatfs statfs;
2833         __be32 *p;
2834         int starting_len = xdr->buf->len;
2835         int attrlen_offset;
2836         __be32 attrlen;
2837         u32 dummy;
2838         u64 dummy64;
2839         u32 rdattr_err = 0;
2840         __be32 status;
2841         int err;
2842         struct nfs4_acl *acl = NULL;
2843 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2844         void *context = NULL;
2845         int contextlen;
2846 #endif
2847         bool contextsupport = false;
2848         struct nfsd4_compoundres *resp = rqstp->rq_resp;
2849         u32 minorversion = resp->cstate.minorversion;
2850         struct path path = {
2851                 .mnt    = exp->ex_path.mnt,
2852                 .dentry = dentry,
2853         };
2854         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2855
2856         BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1);
2857         BUG_ON(!nfsd_attrs_supported(minorversion, bmval));
2858
2859         if (exp->ex_fslocs.migrated) {
2860                 status = fattr_handle_absent_fs(&bmval0, &bmval1, &bmval2, &rdattr_err);
2861                 if (status)
2862                         goto out;
2863         }
2864
2865         err = vfs_getattr(&path, &stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
2866         if (err)
2867                 goto out_nfserr;
2868         if ((bmval0 & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE |
2869                         FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) ||
2870             (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |
2871                        FATTR4_WORD1_SPACE_TOTAL))) {
2872                 err = vfs_statfs(&path, &statfs);
2873                 if (err)
2874                         goto out_nfserr;
2875         }
2876         if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) {
2877                 tempfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
2878                 status = nfserr_jukebox;
2879                 if (!tempfh)
2880                         goto out;
2881                 fh_init(tempfh, NFS4_FHSIZE);
2882                 status = fh_compose(tempfh, exp, dentry, NULL);
2883                 if (status)
2884                         goto out;
2885                 fhp = tempfh;
2886         }
2887         if (bmval0 & FATTR4_WORD0_ACL) {
2888                 err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl);
2889                 if (err == -EOPNOTSUPP)
2890                         bmval0 &= ~FATTR4_WORD0_ACL;
2891                 else if (err == -EINVAL) {
2892                         status = nfserr_attrnotsupp;
2893                         goto out;
2894                 } else if (err != 0)
2895                         goto out_nfserr;
2896         }
2897
2898 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2899         if ((bmval2 & FATTR4_WORD2_SECURITY_LABEL) ||
2900              bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
2901                 if (exp->ex_flags & NFSEXP_SECURITY_LABEL)
2902                         err = security_inode_getsecctx(d_inode(dentry),
2903                                                 &context, &contextlen);
2904                 else
2905                         err = -EOPNOTSUPP;
2906                 contextsupport = (err == 0);
2907                 if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
2908                         if (err == -EOPNOTSUPP)
2909                                 bmval2 &= ~FATTR4_WORD2_SECURITY_LABEL;
2910                         else if (err)
2911                                 goto out_nfserr;
2912                 }
2913         }
2914 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2915
2916         status = nfsd4_encode_bitmap(xdr, bmval0, bmval1, bmval2);
2917         if (status)
2918                 goto out;
2919
2920         attrlen_offset = xdr->buf->len;
2921         p = xdr_reserve_space(xdr, 4);
2922         if (!p)
2923                 goto out_resource;
2924         p++;                /* to be backfilled later */
2925
2926         if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
2927                 u32 supp[3];
2928
2929                 memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp));
2930
2931                 if (!IS_POSIXACL(dentry->d_inode))
2932                         supp[0] &= ~FATTR4_WORD0_ACL;
2933                 if (!contextsupport)
2934                         supp[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
2935                 if (!supp[2]) {
2936                         p = xdr_reserve_space(xdr, 12);
2937                         if (!p)
2938                                 goto out_resource;
2939                         *p++ = cpu_to_be32(2);
2940                         *p++ = cpu_to_be32(supp[0]);
2941                         *p++ = cpu_to_be32(supp[1]);
2942                 } else {
2943                         p = xdr_reserve_space(xdr, 16);
2944                         if (!p)
2945                                 goto out_resource;
2946                         *p++ = cpu_to_be32(3);
2947                         *p++ = cpu_to_be32(supp[0]);
2948                         *p++ = cpu_to_be32(supp[1]);
2949                         *p++ = cpu_to_be32(supp[2]);
2950                 }
2951         }
2952         if (bmval0 & FATTR4_WORD0_TYPE) {
2953                 p = xdr_reserve_space(xdr, 4);
2954                 if (!p)
2955                         goto out_resource;
2956                 dummy = nfs4_file_type(stat.mode);
2957                 if (dummy == NF4BAD) {
2958                         status = nfserr_serverfault;
2959                         goto out;
2960                 }
2961                 *p++ = cpu_to_be32(dummy);
2962         }
2963         if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) {
2964                 p = xdr_reserve_space(xdr, 4);
2965                 if (!p)
2966                         goto out_resource;
2967                 if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)
2968                         *p++ = cpu_to_be32(NFS4_FH_PERSISTENT);
2969                 else
2970                         *p++ = cpu_to_be32(NFS4_FH_PERSISTENT|
2971                                                 NFS4_FH_VOL_RENAME);
2972         }
2973         if (bmval0 & FATTR4_WORD0_CHANGE) {
2974                 p = xdr_reserve_space(xdr, 8);
2975                 if (!p)
2976                         goto out_resource;
2977                 p = encode_change(p, &stat, d_inode(dentry), exp);
2978         }
2979         if (bmval0 & FATTR4_WORD0_SIZE) {
2980                 p = xdr_reserve_space(xdr, 8);
2981                 if (!p)
2982                         goto out_resource;
2983                 p = xdr_encode_hyper(p, stat.size);
2984         }
2985         if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) {
2986                 p = xdr_reserve_space(xdr, 4);
2987                 if (!p)
2988                         goto out_resource;
2989                 *p++ = cpu_to_be32(1);
2990         }
2991         if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) {
2992                 p = xdr_reserve_space(xdr, 4);
2993                 if (!p)
2994                         goto out_resource;
2995                 *p++ = cpu_to_be32(1);
2996         }
2997         if (bmval0 & FATTR4_WORD0_NAMED_ATTR) {
2998                 p = xdr_reserve_space(xdr, 4);
2999                 if (!p)
3000                         goto out_resource;
3001                 *p++ = cpu_to_be32(0);
3002         }
3003         if (bmval0 & FATTR4_WORD0_FSID) {
3004                 p = xdr_reserve_space(xdr, 16);
3005                 if (!p)
3006                         goto out_resource;
3007                 if (exp->ex_fslocs.migrated) {
3008                         p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MAJOR);
3009                         p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MINOR);
3010                 } else switch(fsid_source(fhp)) {
3011                 case FSIDSOURCE_FSID:
3012                         p = xdr_encode_hyper(p, (u64)exp->ex_fsid);
3013                         p = xdr_encode_hyper(p, (u64)0);
3014                         break;
3015                 case FSIDSOURCE_DEV:
3016                         *p++ = cpu_to_be32(0);
3017                         *p++ = cpu_to_be32(MAJOR(stat.dev));
3018                         *p++ = cpu_to_be32(0);
3019                         *p++ = cpu_to_be32(MINOR(stat.dev));
3020                         break;
3021                 case FSIDSOURCE_UUID:
3022                         p = xdr_encode_opaque_fixed(p, exp->ex_uuid,
3023                                                                 EX_UUID_LEN);
3024                         break;
3025                 }
3026         }
3027         if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) {
3028                 p = xdr_reserve_space(xdr, 4);
3029                 if (!p)
3030                         goto out_resource;
3031                 *p++ = cpu_to_be32(0);
3032         }
3033         if (bmval0 & FATTR4_WORD0_LEASE_TIME) {
3034                 p = xdr_reserve_space(xdr, 4);
3035                 if (!p)
3036                         goto out_resource;
3037                 *p++ = cpu_to_be32(nn->nfsd4_lease);
3038         }
3039         if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) {
3040                 p = xdr_reserve_space(xdr, 4);
3041                 if (!p)
3042                         goto out_resource;
3043                 *p++ = cpu_to_be32(rdattr_err);
3044         }
3045         if (bmval0 & FATTR4_WORD0_ACL) {
3046                 struct nfs4_ace *ace;
3047
3048                 if (acl == NULL) {
3049                         p = xdr_reserve_space(xdr, 4);
3050                         if (!p)
3051                                 goto out_resource;
3052
3053                         *p++ = cpu_to_be32(0);
3054                         goto out_acl;
3055                 }
3056                 p = xdr_reserve_space(xdr, 4);
3057                 if (!p)
3058                         goto out_resource;
3059                 *p++ = cpu_to_be32(acl->naces);
3060
3061                 for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {
3062                         p = xdr_reserve_space(xdr, 4*3);
3063                         if (!p)
3064                                 goto out_resource;
3065                         *p++ = cpu_to_be32(ace->type);
3066                         *p++ = cpu_to_be32(ace->flag);
3067                         *p++ = cpu_to_be32(ace->access_mask &
3068                                                         NFS4_ACE_MASK_ALL);
3069                         status = nfsd4_encode_aclname(xdr, rqstp, ace);
3070                         if (status)
3071                                 goto out;
3072                 }
3073         }
3074 out_acl:
3075         if (bmval0 & FATTR4_WORD0_ACLSUPPORT) {
3076                 p = xdr_reserve_space(xdr, 4);
3077                 if (!p)
3078                         goto out_resource;
3079                 *p++ = cpu_to_be32(IS_POSIXACL(dentry->d_inode) ?
3080                         ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0);
3081         }
3082         if (bmval0 & FATTR4_WORD0_CANSETTIME) {
3083                 p = xdr_reserve_space(xdr, 4);
3084                 if (!p)
3085                         goto out_resource;
3086                 *p++ = cpu_to_be32(1);
3087         }
3088         if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) {
3089                 p = xdr_reserve_space(xdr, 4);
3090                 if (!p)
3091                         goto out_resource;
3092                 *p++ = cpu_to_be32(0);
3093         }
3094         if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) {
3095                 p = xdr_reserve_space(xdr, 4);
3096                 if (!p)
3097                         goto out_resource;
3098                 *p++ = cpu_to_be32(1);
3099         }
3100         if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) {
3101                 p = xdr_reserve_space(xdr, 4);
3102                 if (!p)
3103                         goto out_resource;
3104                 *p++ = cpu_to_be32(1);
3105         }
3106         if (bmval0 & FATTR4_WORD0_FILEHANDLE) {
3107                 p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4);
3108                 if (!p)
3109                         goto out_resource;
3110                 p = xdr_encode_opaque(p, &fhp->fh_handle.fh_raw,
3111                                         fhp->fh_handle.fh_size);
3112         }
3113         if (bmval0 & FATTR4_WORD0_FILEID) {
3114                 p = xdr_reserve_space(xdr, 8);
3115                 if (!p)
3116                         goto out_resource;
3117                 p = xdr_encode_hyper(p, stat.ino);
3118         }
3119         if (bmval0 & FATTR4_WORD0_FILES_AVAIL) {
3120                 p = xdr_reserve_space(xdr, 8);
3121                 if (!p)
3122                         goto out_resource;
3123                 p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
3124         }
3125         if (bmval0 & FATTR4_WORD0_FILES_FREE) {
3126                 p = xdr_reserve_space(xdr, 8);
3127                 if (!p)
3128                         goto out_resource;
3129                 p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
3130         }
3131         if (bmval0 & FATTR4_WORD0_FILES_TOTAL) {
3132                 p = xdr_reserve_space(xdr, 8);
3133                 if (!p)
3134                         goto out_resource;
3135                 p = xdr_encode_hyper(p, (u64) statfs.f_files);
3136         }
3137         if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) {
3138                 status = nfsd4_encode_fs_locations(xdr, rqstp, exp);
3139                 if (status)
3140                         goto out;
3141         }
3142         if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) {
3143                 p = xdr_reserve_space(xdr, 4);
3144                 if (!p)
3145                         goto out_resource;
3146                 *p++ = cpu_to_be32(1);
3147         }
3148         if (bmval0 & FATTR4_WORD0_MAXFILESIZE) {
3149                 p = xdr_reserve_space(xdr, 8);
3150                 if (!p)
3151                         goto out_resource;
3152                 p = xdr_encode_hyper(p, exp->ex_path.mnt->mnt_sb->s_maxbytes);
3153         }
3154         if (bmval0 & FATTR4_WORD0_MAXLINK) {
3155                 p = xdr_reserve_space(xdr, 4);
3156                 if (!p)
3157                         goto out_resource;
3158                 *p++ = cpu_to_be32(255);
3159         }
3160         if (bmval0 & FATTR4_WORD0_MAXNAME) {
3161                 p = xdr_reserve_space(xdr, 4);
3162                 if (!p)
3163                         goto out_resource;
3164                 *p++ = cpu_to_be32(statfs.f_namelen);
3165         }
3166         if (bmval0 & FATTR4_WORD0_MAXREAD) {
3167                 p = xdr_reserve_space(xdr, 8);
3168                 if (!p)
3169                         goto out_resource;
3170                 p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
3171         }
3172         if (bmval0 & FATTR4_WORD0_MAXWRITE) {
3173                 p = xdr_reserve_space(xdr, 8);
3174                 if (!p)
3175                         goto out_resource;
3176                 p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
3177         }
3178         if (bmval1 & FATTR4_WORD1_MODE) {
3179                 p = xdr_reserve_space(xdr, 4);
3180                 if (!p)
3181                         goto out_resource;
3182                 *p++ = cpu_to_be32(stat.mode & S_IALLUGO);
3183         }
3184         if (bmval1 & FATTR4_WORD1_NO_TRUNC) {
3185                 p = xdr_reserve_space(xdr, 4);
3186                 if (!p)
3187                         goto out_resource;
3188                 *p++ = cpu_to_be32(1);
3189         }
3190         if (bmval1 & FATTR4_WORD1_NUMLINKS) {
3191                 p = xdr_reserve_space(xdr, 4);
3192                 if (!p)
3193                         goto out_resource;
3194                 *p++ = cpu_to_be32(stat.nlink);
3195         }
3196         if (bmval1 & FATTR4_WORD1_OWNER) {
3197                 status = nfsd4_encode_user(xdr, rqstp, stat.uid);
3198                 if (status)
3199                         goto out;
3200         }
3201         if (bmval1 & FATTR4_WORD1_OWNER_GROUP) {
3202                 status = nfsd4_encode_group(xdr, rqstp, stat.gid);
3203                 if (status)
3204                         goto out;
3205         }
3206         if (bmval1 & FATTR4_WORD1_RAWDEV) {
3207                 p = xdr_reserve_space(xdr, 8);
3208                 if (!p)
3209                         goto out_resource;
3210                 *p++ = cpu_to_be32((u32) MAJOR(stat.rdev));
3211                 *p++ = cpu_to_be32((u32) MINOR(stat.rdev));
3212         }
3213         if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) {
3214                 p = xdr_reserve_space(xdr, 8);
3215                 if (!p)
3216                         goto out_resource;
3217                 dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize;
3218                 p = xdr_encode_hyper(p, dummy64);
3219         }
3220         if (bmval1 & FATTR4_WORD1_SPACE_FREE) {
3221                 p = xdr_reserve_space(xdr, 8);
3222                 if (!p)
3223                         goto out_resource;
3224                 dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize;
3225                 p = xdr_encode_hyper(p, dummy64);
3226         }
3227         if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) {
3228                 p = xdr_reserve_space(xdr, 8);
3229                 if (!p)
3230                         goto out_resource;
3231                 dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize;
3232                 p = xdr_encode_hyper(p, dummy64);
3233         }
3234         if (bmval1 & FATTR4_WORD1_SPACE_USED) {
3235                 p = xdr_reserve_space(xdr, 8);
3236                 if (!p)
3237                         goto out_resource;
3238                 dummy64 = (u64)stat.blocks << 9;
3239                 p = xdr_encode_hyper(p, dummy64);
3240         }
3241         if (bmval1 & FATTR4_WORD1_TIME_ACCESS) {
3242                 p = xdr_reserve_space(xdr, 12);
3243                 if (!p)
3244                         goto out_resource;
3245                 p = xdr_encode_hyper(p, (s64)stat.atime.tv_sec);
3246                 *p++ = cpu_to_be32(stat.atime.tv_nsec);
3247         }
3248         if (bmval1 & FATTR4_WORD1_TIME_DELTA) {
3249                 p = xdr_reserve_space(xdr, 12);
3250                 if (!p)
3251                         goto out_resource;
3252                 p = encode_time_delta(p, d_inode(dentry));
3253         }
3254         if (bmval1 & FATTR4_WORD1_TIME_METADATA) {
3255                 p = xdr_reserve_space(xdr, 12);
3256                 if (!p)
3257                         goto out_resource;
3258                 p = xdr_encode_hyper(p, (s64)stat.ctime.tv_sec);
3259                 *p++ = cpu_to_be32(stat.ctime.tv_nsec);
3260         }
3261         if (bmval1 & FATTR4_WORD1_TIME_MODIFY) {
3262                 p = xdr_reserve_space(xdr, 12);
3263                 if (!p)
3264                         goto out_resource;
3265                 p = xdr_encode_hyper(p, (s64)stat.mtime.tv_sec);
3266                 *p++ = cpu_to_be32(stat.mtime.tv_nsec);
3267         }
3268         if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) {
3269                 struct kstat parent_stat;
3270                 u64 ino = stat.ino;
3271
3272                 p = xdr_reserve_space(xdr, 8);
3273                 if (!p)
3274                         goto out_resource;
3275                 /*
3276                  * Get parent's attributes if not ignoring crossmount
3277                  * and this is the root of a cross-mounted filesystem.
3278                  */
3279                 if (ignore_crossmnt == 0 &&
3280                     dentry == exp->ex_path.mnt->mnt_root) {
3281                         err = get_parent_attributes(exp, &parent_stat);
3282                         if (err)
3283                                 goto out_nfserr;
3284                         ino = parent_stat.ino;
3285                 }
3286                 p = xdr_encode_hyper(p, ino);
3287         }
3288 #ifdef CONFIG_NFSD_PNFS
3289         if (bmval1 & FATTR4_WORD1_FS_LAYOUT_TYPES) {
3290                 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types);
3291                 if (status)
3292                         goto out;
3293         }
3294
3295         if (bmval2 & FATTR4_WORD2_LAYOUT_TYPES) {
3296                 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types);
3297                 if (status)
3298                         goto out;
3299         }
3300
3301         if (bmval2 & FATTR4_WORD2_LAYOUT_BLKSIZE) {
3302                 p = xdr_reserve_space(xdr, 4);
3303                 if (!p)
3304                         goto out_resource;
3305                 *p++ = cpu_to_be32(stat.blksize);
3306         }
3307 #endif /* CONFIG_NFSD_PNFS */
3308         if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
3309                 u32 supp[3];
3310
3311                 memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp));
3312                 supp[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0;
3313                 supp[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1;
3314                 supp[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2;
3315
3316                 status = nfsd4_encode_bitmap(xdr, supp[0], supp[1], supp[2]);
3317                 if (status)
3318                         goto out;
3319         }
3320
3321 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3322         if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
3323                 status = nfsd4_encode_security_label(xdr, rqstp, context,
3324                                                                 contextlen);
3325                 if (status)
3326                         goto out;
3327         }
3328 #endif
3329
3330         if (bmval2 & FATTR4_WORD2_XATTR_SUPPORT) {
3331                 p = xdr_reserve_space(xdr, 4);
3332                 if (!p)
3333                         goto out_resource;
3334                 err = xattr_supported_namespace(d_inode(dentry),
3335                                                 XATTR_USER_PREFIX);
3336                 *p++ = cpu_to_be32(err == 0);
3337         }
3338
3339         attrlen = htonl(xdr->buf->len - attrlen_offset - 4);
3340         write_bytes_to_xdr_buf(xdr->buf, attrlen_offset, &attrlen, 4);
3341         status = nfs_ok;
3342
3343 out:
3344 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3345         if (context)
3346                 security_release_secctx(context, contextlen);
3347 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
3348         kfree(acl);
3349         if (tempfh) {
3350                 fh_put(tempfh);
3351                 kfree(tempfh);
3352         }
3353         if (status)
3354                 xdr_truncate_encode(xdr, starting_len);
3355         return status;
3356 out_nfserr:
3357         status = nfserrno(err);
3358         goto out;
3359 out_resource:
3360         status = nfserr_resource;
3361         goto out;
3362 }
3363
3364 static void svcxdr_init_encode_from_buffer(struct xdr_stream *xdr,
3365                                 struct xdr_buf *buf, __be32 *p, int bytes)
3366 {
3367         xdr->scratch.iov_len = 0;
3368         memset(buf, 0, sizeof(struct xdr_buf));
3369         buf->head[0].iov_base = p;
3370         buf->head[0].iov_len = 0;
3371         buf->len = 0;
3372         xdr->buf = buf;
3373         xdr->iov = buf->head;
3374         xdr->p = p;
3375         xdr->end = (void *)p + bytes;
3376         buf->buflen = bytes;
3377 }
3378
3379 __be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words,
3380                         struct svc_fh *fhp, struct svc_export *exp,
3381                         struct dentry *dentry, u32 *bmval,
3382                         struct svc_rqst *rqstp, int ignore_crossmnt)
3383 {
3384         struct xdr_buf dummy;
3385         struct xdr_stream xdr;
3386         __be32 ret;
3387
3388         svcxdr_init_encode_from_buffer(&xdr, &dummy, *p, words << 2);
3389         ret = nfsd4_encode_fattr(&xdr, fhp, exp, dentry, bmval, rqstp,
3390                                                         ignore_crossmnt);
3391         *p = xdr.p;
3392         return ret;
3393 }
3394
3395 static inline int attributes_need_mount(u32 *bmval)
3396 {
3397         if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME))
3398                 return 1;
3399         if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID)
3400                 return 1;
3401         return 0;
3402 }
3403
3404 static __be32
3405 nfsd4_encode_dirent_fattr(struct xdr_stream *xdr, struct nfsd4_readdir *cd,
3406                         const char *name, int namlen)
3407 {
3408         struct svc_export *exp = cd->rd_fhp->fh_export;
3409         struct dentry *dentry;
3410         __be32 nfserr;
3411         int ignore_crossmnt = 0;
3412
3413         dentry = lookup_positive_unlocked(name, cd->rd_fhp->fh_dentry, namlen);
3414         if (IS_ERR(dentry))
3415                 return nfserrno(PTR_ERR(dentry));
3416
3417         exp_get(exp);
3418         /*
3419          * In the case of a mountpoint, the client may be asking for
3420          * attributes that are only properties of the underlying filesystem
3421          * as opposed to the cross-mounted file system. In such a case,
3422          * we will not follow the cross mount and will fill the attribtutes
3423          * directly from the mountpoint dentry.
3424          */
3425         if (nfsd_mountpoint(dentry, exp)) {
3426                 int err;
3427
3428                 if (!(exp->ex_flags & NFSEXP_V4ROOT)
3429                                 && !attributes_need_mount(cd->rd_bmval)) {
3430                         ignore_crossmnt = 1;
3431                         goto out_encode;
3432                 }
3433                 /*
3434                  * Why the heck aren't we just using nfsd_lookup??
3435                  * Different "."/".." handling?  Something else?
3436                  * At least, add a comment here to explain....
3437                  */
3438                 err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);
3439                 if (err) {
3440                         nfserr = nfserrno(err);
3441                         goto out_put;
3442                 }
3443                 nfserr = check_nfsd_access(exp, cd->rd_rqstp);
3444                 if (nfserr)
3445                         goto out_put;
3446
3447         }
3448 out_encode:
3449         nfserr = nfsd4_encode_fattr(xdr, NULL, exp, dentry, cd->rd_bmval,
3450                                         cd->rd_rqstp, ignore_crossmnt);
3451 out_put:
3452         dput(dentry);
3453         exp_put(exp);
3454         return nfserr;
3455 }
3456
3457 static __be32 *
3458 nfsd4_encode_rdattr_error(struct xdr_stream *xdr, __be32 nfserr)
3459 {
3460         __be32 *p;
3461
3462         p = xdr_reserve_space(xdr, 20);
3463         if (!p)
3464                 return NULL;
3465         *p++ = htonl(2);
3466         *p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */
3467         *p++ = htonl(0);                         /* bmval1 */
3468
3469         *p++ = htonl(4);     /* attribute length */
3470         *p++ = nfserr;       /* no htonl */
3471         return p;
3472 }
3473
3474 static int
3475 nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,
3476                     loff_t offset, u64 ino, unsigned int d_type)
3477 {
3478         struct readdir_cd *ccd = ccdv;
3479         struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);
3480         struct xdr_stream *xdr = cd->xdr;
3481         int start_offset = xdr->buf->len;
3482         int cookie_offset;
3483         u32 name_and_cookie;
3484         int entry_bytes;
3485         __be32 nfserr = nfserr_toosmall;
3486         __be64 wire_offset;
3487         __be32 *p;
3488
3489         /* In nfsv4, "." and ".." never make it onto the wire.. */
3490         if (name && isdotent(name, namlen)) {
3491                 cd->common.err = nfs_ok;
3492                 return 0;
3493         }
3494
3495         if (cd->cookie_offset) {
3496                 wire_offset = cpu_to_be64(offset);
3497                 write_bytes_to_xdr_buf(xdr->buf, cd->cookie_offset,
3498                                                         &wire_offset, 8);
3499         }
3500
3501         p = xdr_reserve_space(xdr, 4);
3502         if (!p)
3503                 goto fail;
3504         *p++ = xdr_one;                             /* mark entry present */
3505         cookie_offset = xdr->buf->len;
3506         p = xdr_reserve_space(xdr, 3*4 + namlen);
3507         if (!p)
3508                 goto fail;
3509         p = xdr_encode_hyper(p, NFS_OFFSET_MAX);    /* offset of next entry */
3510         p = xdr_encode_array(p, name, namlen);      /* name length & name */
3511
3512         nfserr = nfsd4_encode_dirent_fattr(xdr, cd, name, namlen);
3513         switch (nfserr) {
3514         case nfs_ok:
3515                 break;
3516         case nfserr_resource:
3517                 nfserr = nfserr_toosmall;
3518                 goto fail;
3519         case nfserr_noent:
3520                 xdr_truncate_encode(xdr, start_offset);
3521                 goto skip_entry;
3522         default:
3523                 /*
3524                  * If the client requested the RDATTR_ERROR attribute,
3525                  * we stuff the error code into this attribute
3526                  * and continue.  If this attribute was not requested,
3527                  * then in accordance with the spec, we fail the
3528                  * entire READDIR operation(!)
3529                  */
3530                 if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))
3531                         goto fail;
3532                 p = nfsd4_encode_rdattr_error(xdr, nfserr);
3533                 if (p == NULL) {
3534                         nfserr = nfserr_toosmall;
3535                         goto fail;
3536                 }
3537         }
3538         nfserr = nfserr_toosmall;
3539         entry_bytes = xdr->buf->len - start_offset;
3540         if (entry_bytes > cd->rd_maxcount)
3541                 goto fail;
3542         cd->rd_maxcount -= entry_bytes;
3543         /*
3544          * RFC 3530 14.2.24 describes rd_dircount as only a "hint", and
3545          * notes that it could be zero. If it is zero, then the server
3546          * should enforce only the rd_maxcount value.
3547          */
3548         if (cd->rd_dircount) {
3549                 name_and_cookie = 4 + 4 * XDR_QUADLEN(namlen) + 8;
3550                 if (name_and_cookie > cd->rd_dircount && cd->cookie_offset)
3551                         goto fail;
3552                 cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie);
3553                 if (!cd->rd_dircount)
3554                         cd->rd_maxcount = 0;
3555         }
3556
3557         cd->cookie_offset = cookie_offset;
3558 skip_entry:
3559         cd->common.err = nfs_ok;
3560         return 0;
3561 fail:
3562         xdr_truncate_encode(xdr, start_offset);
3563         cd->common.err = nfserr;
3564         return -EINVAL;
3565 }
3566
3567 static __be32
3568 nfsd4_encode_stateid(struct xdr_stream *xdr, stateid_t *sid)
3569 {
3570         __be32 *p;
3571
3572         p = xdr_reserve_space(xdr, sizeof(stateid_t));
3573         if (!p)
3574                 return nfserr_resource;
3575         *p++ = cpu_to_be32(sid->si_generation);
3576         p = xdr_encode_opaque_fixed(p, &sid->si_opaque,
3577                                         sizeof(stateid_opaque_t));
3578         return 0;
3579 }
3580
3581 static __be32
3582 nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access)
3583 {
3584         struct xdr_stream *xdr = resp->xdr;
3585         __be32 *p;
3586
3587         p = xdr_reserve_space(xdr, 8);
3588         if (!p)
3589                 return nfserr_resource;
3590         *p++ = cpu_to_be32(access->ac_supported);
3591         *p++ = cpu_to_be32(access->ac_resp_access);
3592         return 0;
3593 }
3594
3595 static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)
3596 {
3597         struct xdr_stream *xdr = resp->xdr;
3598         __be32 *p;
3599
3600         p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 8);
3601         if (!p)
3602                 return nfserr_resource;
3603         p = xdr_encode_opaque_fixed(p, bcts->sessionid.data,
3604                                         NFS4_MAX_SESSIONID_LEN);
3605         *p++ = cpu_to_be32(bcts->dir);
3606         /* Upshifting from TCP to RDMA is not supported */
3607         *p++ = cpu_to_be32(0);
3608         return 0;
3609 }
3610
3611 static __be32
3612 nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close)
3613 {
3614         struct xdr_stream *xdr = resp->xdr;
3615
3616         return nfsd4_encode_stateid(xdr, &close->cl_stateid);
3617 }
3618
3619
3620 static __be32
3621 nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit)
3622 {
3623         struct xdr_stream *xdr = resp->xdr;
3624         __be32 *p;
3625
3626         p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
3627         if (!p)
3628                 return nfserr_resource;
3629         p = xdr_encode_opaque_fixed(p, commit->co_verf.data,
3630                                                 NFS4_VERIFIER_SIZE);
3631         return 0;
3632 }
3633
3634 static __be32
3635 nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create)
3636 {
3637         struct xdr_stream *xdr = resp->xdr;
3638         __be32 *p;
3639
3640         p = xdr_reserve_space(xdr, 20);
3641         if (!p)
3642                 return nfserr_resource;
3643         encode_cinfo(p, &create->cr_cinfo);
3644         return nfsd4_encode_bitmap(xdr, create->cr_bmval[0],
3645                         create->cr_bmval[1], create->cr_bmval[2]);
3646 }
3647
3648 static __be32
3649 nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr)
3650 {
3651         struct svc_fh *fhp = getattr->ga_fhp;
3652         struct xdr_stream *xdr = resp->xdr;
3653
3654         return nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry,
3655                                     getattr->ga_bmval, resp->rqstp, 0);
3656 }
3657
3658 static __be32
3659 nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp)
3660 {
3661         struct xdr_stream *xdr = resp->xdr;
3662         struct svc_fh *fhp = *fhpp;
3663         unsigned int len;
3664         __be32 *p;
3665
3666         len = fhp->fh_handle.fh_size;
3667         p = xdr_reserve_space(xdr, len + 4);
3668         if (!p)
3669                 return nfserr_resource;
3670         p = xdr_encode_opaque(p, &fhp->fh_handle.fh_raw, len);
3671         return 0;
3672 }
3673
3674 /*
3675 * Including all fields other than the name, a LOCK4denied structure requires
3676 *   8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
3677 */
3678 static __be32
3679 nfsd4_encode_lock_denied(struct xdr_stream *xdr, struct nfsd4_lock_denied *ld)
3680 {
3681         struct xdr_netobj *conf = &ld->ld_owner;
3682         __be32 *p;
3683
3684 again:
3685         p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len));
3686         if (!p) {
3687                 /*
3688                  * Don't fail to return the result just because we can't
3689                  * return the conflicting open:
3690                  */
3691                 if (conf->len) {
3692                         kfree(conf->data);
3693                         conf->len = 0;
3694                         conf->data = NULL;
3695                         goto again;
3696                 }
3697                 return nfserr_resource;
3698         }
3699         p = xdr_encode_hyper(p, ld->ld_start);
3700         p = xdr_encode_hyper(p, ld->ld_length);
3701         *p++ = cpu_to_be32(ld->ld_type);
3702         if (conf->len) {
3703                 p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8);
3704                 p = xdr_encode_opaque(p, conf->data, conf->len);
3705                 kfree(conf->data);
3706         }  else {  /* non - nfsv4 lock in conflict, no clientid nor owner */
3707                 p = xdr_encode_hyper(p, (u64)0); /* clientid */
3708                 *p++ = cpu_to_be32(0); /* length of owner name */
3709         }
3710         return nfserr_denied;
3711 }
3712
3713 static __be32
3714 nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock)
3715 {
3716         struct xdr_stream *xdr = resp->xdr;
3717
3718         if (!nfserr)
3719                 nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid);
3720         else if (nfserr == nfserr_denied)
3721                 nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied);
3722
3723         return nfserr;
3724 }
3725
3726 static __be32
3727 nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt)
3728 {
3729         struct xdr_stream *xdr = resp->xdr;
3730
3731         if (nfserr == nfserr_denied)
3732                 nfsd4_encode_lock_denied(xdr, &lockt->lt_denied);
3733         return nfserr;
3734 }
3735
3736 static __be32
3737 nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku)
3738 {
3739         struct xdr_stream *xdr = resp->xdr;
3740
3741         return nfsd4_encode_stateid(xdr, &locku->lu_stateid);
3742 }
3743
3744
3745 static __be32
3746 nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link)
3747 {
3748         struct xdr_stream *xdr = resp->xdr;
3749         __be32 *p;
3750
3751         p = xdr_reserve_space(xdr, 20);
3752         if (!p)
3753                 return nfserr_resource;
3754         p = encode_cinfo(p, &link->li_cinfo);
3755         return 0;
3756 }
3757
3758
3759 static __be32
3760 nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open)
3761 {
3762         struct xdr_stream *xdr = resp->xdr;
3763         __be32 *p;
3764
3765         nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid);
3766         if (nfserr)
3767                 return nfserr;
3768         p = xdr_reserve_space(xdr, 24);
3769         if (!p)
3770                 return nfserr_resource;
3771         p = encode_cinfo(p, &open->op_cinfo);
3772         *p++ = cpu_to_be32(open->op_rflags);
3773
3774         nfserr = nfsd4_encode_bitmap(xdr, open->op_bmval[0], open->op_bmval[1],
3775                                         open->op_bmval[2]);
3776         if (nfserr)
3777                 return nfserr;
3778
3779         p = xdr_reserve_space(xdr, 4);
3780         if (!p)
3781                 return nfserr_resource;
3782
3783         *p++ = cpu_to_be32(open->op_delegate_type);
3784         switch (open->op_delegate_type) {
3785         case NFS4_OPEN_DELEGATE_NONE:
3786                 break;
3787         case NFS4_OPEN_DELEGATE_READ:
3788                 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
3789                 if (nfserr)
3790                         return nfserr;
3791                 p = xdr_reserve_space(xdr, 20);
3792                 if (!p)
3793                         return nfserr_resource;
3794                 *p++ = cpu_to_be32(open->op_recall);
3795
3796                 /*
3797                  * TODO: ACE's in delegations
3798                  */
3799                 *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
3800                 *p++ = cpu_to_be32(0);
3801                 *p++ = cpu_to_be32(0);
3802                 *p++ = cpu_to_be32(0);   /* XXX: is NULL principal ok? */
3803                 break;
3804         case NFS4_OPEN_DELEGATE_WRITE:
3805                 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
3806                 if (nfserr)
3807                         return nfserr;
3808                 p = xdr_reserve_space(xdr, 32);
3809                 if (!p)
3810                         return nfserr_resource;
3811                 *p++ = cpu_to_be32(0);
3812
3813                 /*
3814                  * TODO: space_limit's in delegations
3815                  */
3816                 *p++ = cpu_to_be32(NFS4_LIMIT_SIZE);
3817                 *p++ = cpu_to_be32(~(u32)0);
3818                 *p++ = cpu_to_be32(~(u32)0);
3819
3820                 /*
3821                  * TODO: ACE's in delegations
3822                  */
3823                 *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
3824                 *p++ = cpu_to_be32(0);
3825                 *p++ = cpu_to_be32(0);
3826                 *p++ = cpu_to_be32(0);   /* XXX: is NULL principal ok? */
3827                 break;
3828         case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */
3829                 switch (open->op_why_no_deleg) {
3830                 case WND4_CONTENTION:
3831                 case WND4_RESOURCE:
3832                         p = xdr_reserve_space(xdr, 8);
3833                         if (!p)
3834                                 return nfserr_resource;
3835                         *p++ = cpu_to_be32(open->op_why_no_deleg);
3836                         /* deleg signaling not supported yet: */
3837                         *p++ = cpu_to_be32(0);
3838                         break;
3839                 default:
3840                         p = xdr_reserve_space(xdr, 4);
3841                         if (!p)
3842                                 return nfserr_resource;
3843                         *p++ = cpu_to_be32(open->op_why_no_deleg);
3844                 }
3845                 break;
3846         default:
3847                 BUG();
3848         }
3849         /* XXX save filehandle here */
3850         return 0;
3851 }
3852
3853 static __be32
3854 nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc)
3855 {
3856         struct xdr_stream *xdr = resp->xdr;
3857
3858         return nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid);
3859 }
3860
3861 static __be32
3862 nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od)
3863 {
3864         struct xdr_stream *xdr = resp->xdr;
3865
3866         return nfsd4_encode_stateid(xdr, &od->od_stateid);
3867 }
3868
3869 static __be32 nfsd4_encode_splice_read(
3870                                 struct nfsd4_compoundres *resp,
3871                                 struct nfsd4_read *read,
3872                                 struct file *file, unsigned long maxcount)
3873 {
3874         struct xdr_stream *xdr = resp->xdr;
3875         struct xdr_buf *buf = xdr->buf;
3876         int status, space_left;
3877         u32 eof;
3878         __be32 nfserr;
3879         __be32 *p = xdr->p - 2;
3880
3881         /* Make sure there will be room for padding if needed */
3882         if (xdr->end - xdr->p < 1)
3883                 return nfserr_resource;
3884
3885         nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp,
3886                                   file, read->rd_offset, &maxcount, &eof);
3887         read->rd_length = maxcount;
3888         if (nfserr)
3889                 goto out_err;
3890         status = svc_encode_result_payload(read->rd_rqstp,
3891                                            buf->head[0].iov_len, maxcount);
3892         if (status) {
3893                 nfserr = nfserrno(status);
3894                 goto out_err;
3895         }
3896
3897         *(p++) = htonl(eof);
3898         *(p++) = htonl(maxcount);
3899
3900         buf->page_len = maxcount;
3901         buf->len += maxcount;
3902         xdr->page_ptr += (buf->page_base + maxcount + PAGE_SIZE - 1)
3903                                                         / PAGE_SIZE;
3904
3905         /* Use rest of head for padding and remaining ops: */
3906         buf->tail[0].iov_base = xdr->p;
3907         buf->tail[0].iov_len = 0;
3908         xdr->iov = buf->tail;
3909         if (maxcount&3) {
3910                 int pad = 4 - (maxcount&3);
3911
3912                 *(xdr->p++) = 0;
3913
3914                 buf->tail[0].iov_base += maxcount&3;
3915                 buf->tail[0].iov_len = pad;
3916                 buf->len += pad;
3917         }
3918
3919         space_left = min_t(int, (void *)xdr->end - (void *)xdr->p,
3920                                 buf->buflen - buf->len);
3921         buf->buflen = buf->len + space_left;
3922         xdr->end = (__be32 *)((void *)xdr->end + space_left);
3923
3924         return 0;
3925
3926 out_err:
3927         /*
3928          * nfsd_splice_actor may have already messed with the
3929          * page length; reset it so as not to confuse
3930          * xdr_truncate_encode in our caller.
3931          */
3932         buf->page_len = 0;
3933         return nfserr;
3934 }
3935
3936 static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp,
3937                                  struct nfsd4_read *read,
3938                                  struct file *file, unsigned long maxcount)
3939 {
3940         struct xdr_stream *xdr = resp->xdr;
3941         u32 eof;
3942         int starting_len = xdr->buf->len - 8;
3943         __be32 nfserr;
3944         __be32 tmp;
3945         int pad;
3946
3947         read->rd_vlen = xdr_reserve_space_vec(xdr, resp->rqstp->rq_vec, maxcount);
3948         if (read->rd_vlen < 0)
3949                 return nfserr_resource;
3950
3951         nfserr = nfsd_readv(resp->rqstp, read->rd_fhp, file, read->rd_offset,
3952                             resp->rqstp->rq_vec, read->rd_vlen, &maxcount,
3953                             &eof);
3954         read->rd_length = maxcount;
3955         if (nfserr)
3956                 return nfserr;
3957         if (svc_encode_result_payload(resp->rqstp, starting_len + 8, maxcount))
3958                 return nfserr_io;
3959         xdr_truncate_encode(xdr, starting_len + 8 + xdr_align_size(maxcount));
3960
3961         tmp = htonl(eof);
3962         write_bytes_to_xdr_buf(xdr->buf, starting_len    , &tmp, 4);
3963         tmp = htonl(maxcount);
3964         write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4);
3965
3966         tmp = xdr_zero;
3967         pad = (maxcount&3) ? 4 - (maxcount&3) : 0;
3968         write_bytes_to_xdr_buf(xdr->buf, starting_len + 8 + maxcount,
3969                                                                 &tmp, pad);
3970         return 0;
3971
3972 }
3973
3974 static __be32
3975 nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,
3976                   struct nfsd4_read *read)
3977 {
3978         unsigned long maxcount;
3979         struct xdr_stream *xdr = resp->xdr;
3980         struct file *file;
3981         int starting_len = xdr->buf->len;
3982         __be32 *p;
3983
3984         if (nfserr)
3985                 return nfserr;
3986         file = read->rd_nf->nf_file;
3987
3988         p = xdr_reserve_space(xdr, 8); /* eof flag and byte count */
3989         if (!p) {
3990                 WARN_ON_ONCE(test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags));
3991                 return nfserr_resource;
3992         }
3993         if (resp->xdr->buf->page_len &&
3994             test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)) {
3995                 WARN_ON_ONCE(1);
3996                 return nfserr_resource;
3997         }
3998         xdr_commit_encode(xdr);
3999
4000         maxcount = svc_max_payload(resp->rqstp);
4001         maxcount = min_t(unsigned long, maxcount,
4002                          (xdr->buf->buflen - xdr->buf->len));
4003         maxcount = min_t(unsigned long, maxcount, read->rd_length);
4004
4005         if (file->f_op->splice_read &&
4006             test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags))
4007                 nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount);
4008         else
4009                 nfserr = nfsd4_encode_readv(resp, read, file, maxcount);
4010
4011         if (nfserr)
4012                 xdr_truncate_encode(xdr, starting_len);
4013
4014         return nfserr;
4015 }
4016
4017 static __be32
4018 nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink)
4019 {
4020         int maxcount;
4021         __be32 wire_count;
4022         int zero = 0;
4023         struct xdr_stream *xdr = resp->xdr;
4024         int length_offset = xdr->buf->len;
4025         int status;
4026         __be32 *p;
4027
4028         p = xdr_reserve_space(xdr, 4);
4029         if (!p)
4030                 return nfserr_resource;
4031         maxcount = PAGE_SIZE;
4032
4033         p = xdr_reserve_space(xdr, maxcount);
4034         if (!p)
4035                 return nfserr_resource;
4036         /*
4037          * XXX: By default, vfs_readlink() will truncate symlinks if they
4038          * would overflow the buffer.  Is this kosher in NFSv4?  If not, one
4039          * easy fix is: if vfs_readlink() precisely fills the buffer, assume
4040          * that truncation occurred, and return NFS4ERR_RESOURCE.
4041          */
4042         nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp,
4043                                                 (char *)p, &maxcount);
4044         if (nfserr == nfserr_isdir)
4045                 nfserr = nfserr_inval;
4046         if (nfserr)
4047                 goto out_err;
4048         status = svc_encode_result_payload(readlink->rl_rqstp, length_offset,
4049                                            maxcount);
4050         if (status) {
4051                 nfserr = nfserrno(status);
4052                 goto out_err;
4053         }
4054
4055         wire_count = htonl(maxcount);
4056         write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, 4);
4057         xdr_truncate_encode(xdr, length_offset + 4 + ALIGN(maxcount, 4));
4058         if (maxcount & 3)
4059                 write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount,
4060                                                 &zero, 4 - (maxcount&3));
4061         return 0;
4062
4063 out_err:
4064         xdr_truncate_encode(xdr, length_offset);
4065         return nfserr;
4066 }
4067
4068 static __be32
4069 nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir)
4070 {
4071         int maxcount;
4072         int bytes_left;
4073         loff_t offset;
4074         __be64 wire_offset;
4075         struct xdr_stream *xdr = resp->xdr;
4076         int starting_len = xdr->buf->len;
4077         __be32 *p;
4078
4079         p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
4080         if (!p)
4081                 return nfserr_resource;
4082
4083         /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
4084         *p++ = cpu_to_be32(0);
4085         *p++ = cpu_to_be32(0);
4086         xdr->buf->head[0].iov_len = (char *)xdr->p -
4087                                     (char *)xdr->buf->head[0].iov_base;
4088
4089         /*
4090          * Number of bytes left for directory entries allowing for the
4091          * final 8 bytes of the readdir and a following failed op:
4092          */
4093         bytes_left = xdr->buf->buflen - xdr->buf->len
4094                         - COMPOUND_ERR_SLACK_SPACE - 8;
4095         if (bytes_left < 0) {
4096                 nfserr = nfserr_resource;
4097                 goto err_no_verf;
4098         }
4099         maxcount = svc_max_payload(resp->rqstp);
4100         maxcount = min_t(u32, readdir->rd_maxcount, maxcount);
4101         /*
4102          * Note the rfc defines rd_maxcount as the size of the
4103          * READDIR4resok structure, which includes the verifier above
4104          * and the 8 bytes encoded at the end of this function:
4105          */
4106         if (maxcount < 16) {
4107                 nfserr = nfserr_toosmall;
4108                 goto err_no_verf;
4109         }
4110         maxcount = min_t(int, maxcount-16, bytes_left);
4111
4112         /* RFC 3530 14.2.24 allows us to ignore dircount when it's 0: */
4113         if (!readdir->rd_dircount)
4114                 readdir->rd_dircount = svc_max_payload(resp->rqstp);
4115
4116         readdir->xdr = xdr;
4117         readdir->rd_maxcount = maxcount;
4118         readdir->common.err = 0;
4119         readdir->cookie_offset = 0;
4120
4121         offset = readdir->rd_cookie;
4122         nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp,
4123                               &offset,
4124                               &readdir->common, nfsd4_encode_dirent);
4125         if (nfserr == nfs_ok &&
4126             readdir->common.err == nfserr_toosmall &&
4127             xdr->buf->len == starting_len + 8) {
4128                 /* nothing encoded; which limit did we hit?: */
4129                 if (maxcount - 16 < bytes_left)
4130                         /* It was the fault of rd_maxcount: */
4131                         nfserr = nfserr_toosmall;
4132                 else
4133                         /* We ran out of buffer space: */
4134                         nfserr = nfserr_resource;
4135         }
4136         if (nfserr)
4137                 goto err_no_verf;
4138
4139         if (readdir->cookie_offset) {
4140                 wire_offset = cpu_to_be64(offset);
4141                 write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset,
4142                                                         &wire_offset, 8);
4143         }
4144
4145         p = xdr_reserve_space(xdr, 8);
4146         if (!p) {
4147                 WARN_ON_ONCE(1);
4148                 goto err_no_verf;
4149         }
4150         *p++ = 0;       /* no more entries */
4151         *p++ = htonl(readdir->common.err == nfserr_eof);
4152
4153         return 0;
4154 err_no_verf:
4155         xdr_truncate_encode(xdr, starting_len);
4156         return nfserr;
4157 }
4158
4159 static __be32
4160 nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove)
4161 {
4162         struct xdr_stream *xdr = resp->xdr;
4163         __be32 *p;
4164
4165         p = xdr_reserve_space(xdr, 20);
4166         if (!p)
4167                 return nfserr_resource;
4168         p = encode_cinfo(p, &remove->rm_cinfo);
4169         return 0;
4170 }
4171
4172 static __be32
4173 nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename)
4174 {
4175         struct xdr_stream *xdr = resp->xdr;
4176         __be32 *p;
4177
4178         p = xdr_reserve_space(xdr, 40);
4179         if (!p)
4180                 return nfserr_resource;
4181         p = encode_cinfo(p, &rename->rn_sinfo);
4182         p = encode_cinfo(p, &rename->rn_tinfo);
4183         return 0;
4184 }
4185
4186 static __be32
4187 nfsd4_do_encode_secinfo(struct xdr_stream *xdr, struct svc_export *exp)
4188 {
4189         u32 i, nflavs, supported;
4190         struct exp_flavor_info *flavs;
4191         struct exp_flavor_info def_flavs[2];
4192         __be32 *p, *flavorsp;
4193         static bool report = true;
4194
4195         if (exp->ex_nflavors) {
4196                 flavs = exp->ex_flavors;
4197                 nflavs = exp->ex_nflavors;
4198         } else { /* Handling of some defaults in absence of real secinfo: */
4199                 flavs = def_flavs;
4200                 if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {
4201                         nflavs = 2;
4202                         flavs[0].pseudoflavor = RPC_AUTH_UNIX;
4203                         flavs[1].pseudoflavor = RPC_AUTH_NULL;
4204                 } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {
4205                         nflavs = 1;
4206                         flavs[0].pseudoflavor
4207                                         = svcauth_gss_flavor(exp->ex_client);
4208                 } else {
4209                         nflavs = 1;
4210                         flavs[0].pseudoflavor
4211                                         = exp->ex_client->flavour->flavour;
4212                 }
4213         }
4214
4215         supported = 0;
4216         p = xdr_reserve_space(xdr, 4);
4217         if (!p)
4218                 return nfserr_resource;
4219         flavorsp = p++;         /* to be backfilled later */
4220
4221         for (i = 0; i < nflavs; i++) {
4222                 rpc_authflavor_t pf = flavs[i].pseudoflavor;
4223                 struct rpcsec_gss_info info;
4224
4225                 if (rpcauth_get_gssinfo(pf, &info) == 0) {
4226                         supported++;
4227                         p = xdr_reserve_space(xdr, 4 + 4 +
4228                                               XDR_LEN(info.oid.len) + 4 + 4);
4229                         if (!p)
4230                                 return nfserr_resource;
4231                         *p++ = cpu_to_be32(RPC_AUTH_GSS);
4232                         p = xdr_encode_opaque(p,  info.oid.data, info.oid.len);
4233                         *p++ = cpu_to_be32(info.qop);
4234                         *p++ = cpu_to_be32(info.service);
4235                 } else if (pf < RPC_AUTH_MAXFLAVOR) {
4236                         supported++;
4237                         p = xdr_reserve_space(xdr, 4);
4238                         if (!p)
4239                                 return nfserr_resource;
4240                         *p++ = cpu_to_be32(pf);
4241                 } else {
4242                         if (report)
4243                                 pr_warn("NFS: SECINFO: security flavor %u "
4244                                         "is not supported\n", pf);
4245                 }
4246         }
4247
4248         if (nflavs != supported)
4249                 report = false;
4250         *flavorsp = htonl(supported);
4251         return 0;
4252 }
4253
4254 static __be32
4255 nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
4256                      struct nfsd4_secinfo *secinfo)
4257 {
4258         struct xdr_stream *xdr = resp->xdr;
4259
4260         return nfsd4_do_encode_secinfo(xdr, secinfo->si_exp);
4261 }
4262
4263 static __be32
4264 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,
4265                      struct nfsd4_secinfo_no_name *secinfo)
4266 {
4267         struct xdr_stream *xdr = resp->xdr;
4268
4269         return nfsd4_do_encode_secinfo(xdr, secinfo->sin_exp);
4270 }
4271
4272 /*
4273  * The SETATTR encode routine is special -- it always encodes a bitmap,
4274  * regardless of the error status.
4275  */
4276 static __be32
4277 nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr)
4278 {
4279         struct xdr_stream *xdr = resp->xdr;
4280         __be32 *p;
4281
4282         p = xdr_reserve_space(xdr, 16);
4283         if (!p)
4284                 return nfserr_resource;
4285         if (nfserr) {
4286                 *p++ = cpu_to_be32(3);
4287                 *p++ = cpu_to_be32(0);
4288                 *p++ = cpu_to_be32(0);
4289                 *p++ = cpu_to_be32(0);
4290         }
4291         else {
4292                 *p++ = cpu_to_be32(3);
4293                 *p++ = cpu_to_be32(setattr->sa_bmval[0]);
4294                 *p++ = cpu_to_be32(setattr->sa_bmval[1]);
4295                 *p++ = cpu_to_be32(setattr->sa_bmval[2]);
4296         }
4297         return nfserr;
4298 }
4299
4300 static __be32
4301 nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd)
4302 {
4303         struct xdr_stream *xdr = resp->xdr;
4304         __be32 *p;
4305
4306         if (!nfserr) {
4307                 p = xdr_reserve_space(xdr, 8 + NFS4_VERIFIER_SIZE);
4308                 if (!p)
4309                         return nfserr_resource;
4310                 p = xdr_encode_opaque_fixed(p, &scd->se_clientid, 8);
4311                 p = xdr_encode_opaque_fixed(p, &scd->se_confirm,
4312                                                 NFS4_VERIFIER_SIZE);
4313         }
4314         else if (nfserr == nfserr_clid_inuse) {
4315                 p = xdr_reserve_space(xdr, 8);
4316                 if (!p)
4317                         return nfserr_resource;
4318                 *p++ = cpu_to_be32(0);
4319                 *p++ = cpu_to_be32(0);
4320         }
4321         return nfserr;
4322 }
4323
4324 static __be32
4325 nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write)
4326 {
4327         struct xdr_stream *xdr = resp->xdr;
4328         __be32 *p;
4329
4330         p = xdr_reserve_space(xdr, 16);
4331         if (!p)
4332                 return nfserr_resource;
4333         *p++ = cpu_to_be32(write->wr_bytes_written);
4334         *p++ = cpu_to_be32(write->wr_how_written);
4335         p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
4336                                                 NFS4_VERIFIER_SIZE);
4337         return 0;
4338 }
4339
4340 static __be32
4341 nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
4342                          struct nfsd4_exchange_id *exid)
4343 {
4344         struct xdr_stream *xdr = resp->xdr;
4345         __be32 *p;
4346         char *major_id;
4347         char *server_scope;
4348         int major_id_sz;
4349         int server_scope_sz;
4350         uint64_t minor_id = 0;
4351         struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), nfsd_net_id);
4352
4353         major_id = nn->nfsd_name;
4354         major_id_sz = strlen(nn->nfsd_name);
4355         server_scope = nn->nfsd_name;
4356         server_scope_sz = strlen(nn->nfsd_name);
4357
4358         p = xdr_reserve_space(xdr,
4359                 8 /* eir_clientid */ +
4360                 4 /* eir_sequenceid */ +
4361                 4 /* eir_flags */ +
4362                 4 /* spr_how */);
4363         if (!p)
4364                 return nfserr_resource;
4365
4366         p = xdr_encode_opaque_fixed(p, &exid->clientid, 8);
4367         *p++ = cpu_to_be32(exid->seqid);
4368         *p++ = cpu_to_be32(exid->flags);
4369
4370         *p++ = cpu_to_be32(exid->spa_how);
4371
4372         switch (exid->spa_how) {
4373         case SP4_NONE:
4374                 break;
4375         case SP4_MACH_CRED:
4376                 /* spo_must_enforce bitmap: */
4377                 nfserr = nfsd4_encode_bitmap(xdr,
4378                                         exid->spo_must_enforce[0],
4379                                         exid->spo_must_enforce[1],
4380                                         exid->spo_must_enforce[2]);
4381                 if (nfserr)
4382                         return nfserr;
4383                 /* spo_must_allow bitmap: */
4384                 nfserr = nfsd4_encode_bitmap(xdr,
4385                                         exid->spo_must_allow[0],
4386                                         exid->spo_must_allow[1],
4387                                         exid->spo_must_allow[2]);
4388                 if (nfserr)
4389                         return nfserr;
4390                 break;
4391         default:
4392                 WARN_ON_ONCE(1);
4393         }
4394
4395         p = xdr_reserve_space(xdr,
4396                 8 /* so_minor_id */ +
4397                 4 /* so_major_id.len */ +
4398                 (XDR_QUADLEN(major_id_sz) * 4) +
4399                 4 /* eir_server_scope.len */ +
4400                 (XDR_QUADLEN(server_scope_sz) * 4) +
4401                 4 /* eir_server_impl_id.count (0) */);
4402         if (!p)
4403                 return nfserr_resource;
4404
4405         /* The server_owner struct */
4406         p = xdr_encode_hyper(p, minor_id);      /* Minor id */
4407         /* major id */
4408         p = xdr_encode_opaque(p, major_id, major_id_sz);
4409
4410         /* Server scope */
4411         p = xdr_encode_opaque(p, server_scope, server_scope_sz);
4412
4413         /* Implementation id */
4414         *p++ = cpu_to_be32(0);  /* zero length nfs_impl_id4 array */
4415         return 0;
4416 }
4417
4418 static __be32
4419 nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,
4420                             struct nfsd4_create_session *sess)
4421 {
4422         struct xdr_stream *xdr = resp->xdr;
4423         __be32 *p;
4424
4425         p = xdr_reserve_space(xdr, 24);
4426         if (!p)
4427                 return nfserr_resource;
4428         p = xdr_encode_opaque_fixed(p, sess->sessionid.data,
4429                                         NFS4_MAX_SESSIONID_LEN);
4430         *p++ = cpu_to_be32(sess->seqid);
4431         *p++ = cpu_to_be32(sess->flags);
4432
4433         p = xdr_reserve_space(xdr, 28);
4434         if (!p)
4435                 return nfserr_resource;
4436         *p++ = cpu_to_be32(0); /* headerpadsz */
4437         *p++ = cpu_to_be32(sess->fore_channel.maxreq_sz);
4438         *p++ = cpu_to_be32(sess->fore_channel.maxresp_sz);
4439         *p++ = cpu_to_be32(sess->fore_channel.maxresp_cached);
4440         *p++ = cpu_to_be32(sess->fore_channel.maxops);
4441         *p++ = cpu_to_be32(sess->fore_channel.maxreqs);
4442         *p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs);
4443
4444         if (sess->fore_channel.nr_rdma_attrs) {
4445                 p = xdr_reserve_space(xdr, 4);
4446                 if (!p)
4447                         return nfserr_resource;
4448                 *p++ = cpu_to_be32(sess->fore_channel.rdma_attrs);
4449         }
4450
4451         p = xdr_reserve_space(xdr, 28);
4452         if (!p)
4453                 return nfserr_resource;
4454         *p++ = cpu_to_be32(0); /* headerpadsz */
4455         *p++ = cpu_to_be32(sess->back_channel.maxreq_sz);
4456         *p++ = cpu_to_be32(sess->back_channel.maxresp_sz);
4457         *p++ = cpu_to_be32(sess->back_channel.maxresp_cached);
4458         *p++ = cpu_to_be32(sess->back_channel.maxops);
4459         *p++ = cpu_to_be32(sess->back_channel.maxreqs);
4460         *p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs);
4461
4462         if (sess->back_channel.nr_rdma_attrs) {
4463                 p = xdr_reserve_space(xdr, 4);
4464                 if (!p)
4465                         return nfserr_resource;
4466                 *p++ = cpu_to_be32(sess->back_channel.rdma_attrs);
4467         }
4468         return 0;
4469 }
4470
4471 static __be32
4472 nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,
4473                       struct nfsd4_sequence *seq)
4474 {
4475         struct xdr_stream *xdr = resp->xdr;
4476         __be32 *p;
4477
4478         p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 20);
4479         if (!p)
4480                 return nfserr_resource;
4481         p = xdr_encode_opaque_fixed(p, seq->sessionid.data,
4482                                         NFS4_MAX_SESSIONID_LEN);
4483         *p++ = cpu_to_be32(seq->seqid);
4484         *p++ = cpu_to_be32(seq->slotid);
4485         /* Note slotid's are numbered from zero: */
4486         *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */
4487         *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */
4488         *p++ = cpu_to_be32(seq->status_flags);
4489
4490         resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */
4491         return 0;
4492 }
4493
4494 static __be32
4495 nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,
4496                           struct nfsd4_test_stateid *test_stateid)
4497 {
4498         struct xdr_stream *xdr = resp->xdr;
4499         struct nfsd4_test_stateid_id *stateid, *next;
4500         __be32 *p;
4501
4502         p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids));
4503         if (!p)
4504                 return nfserr_resource;
4505         *p++ = htonl(test_stateid->ts_num_ids);
4506
4507         list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) {
4508                 *p++ = stateid->ts_id_status;
4509         }
4510
4511         return 0;
4512 }
4513
4514 #ifdef CONFIG_NFSD_PNFS
4515 static __be32
4516 nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
4517                 struct nfsd4_getdeviceinfo *gdev)
4518 {
4519         struct xdr_stream *xdr = resp->xdr;
4520         const struct nfsd4_layout_ops *ops;
4521         u32 starting_len = xdr->buf->len, needed_len;
4522         __be32 *p;
4523
4524         p = xdr_reserve_space(xdr, 4);
4525         if (!p)
4526                 return nfserr_resource;
4527
4528         *p++ = cpu_to_be32(gdev->gd_layout_type);
4529
4530         /* If maxcount is 0 then just update notifications */
4531         if (gdev->gd_maxcount != 0) {
4532                 ops = nfsd4_layout_ops[gdev->gd_layout_type];
4533                 nfserr = ops->encode_getdeviceinfo(xdr, gdev);
4534                 if (nfserr) {
4535                         /*
4536                          * We don't bother to burden the layout drivers with
4537                          * enforcing gd_maxcount, just tell the client to
4538                          * come back with a bigger buffer if it's not enough.
4539                          */
4540                         if (xdr->buf->len + 4 > gdev->gd_maxcount)
4541                                 goto toosmall;
4542                         return nfserr;
4543                 }
4544         }
4545
4546         if (gdev->gd_notify_types) {
4547                 p = xdr_reserve_space(xdr, 4 + 4);
4548                 if (!p)
4549                         return nfserr_resource;
4550                 *p++ = cpu_to_be32(1);                  /* bitmap length */
4551                 *p++ = cpu_to_be32(gdev->gd_notify_types);
4552         } else {
4553                 p = xdr_reserve_space(xdr, 4);
4554                 if (!p)
4555                         return nfserr_resource;
4556                 *p++ = 0;
4557         }
4558
4559         return 0;
4560 toosmall:
4561         dprintk("%s: maxcount too small\n", __func__);
4562         needed_len = xdr->buf->len + 4 /* notifications */;
4563         xdr_truncate_encode(xdr, starting_len);
4564         p = xdr_reserve_space(xdr, 4);
4565         if (!p)
4566                 return nfserr_resource;
4567         *p++ = cpu_to_be32(needed_len);
4568         return nfserr_toosmall;
4569 }
4570
4571 static __be32
4572 nfsd4_encode_layoutget(struct nfsd4_compoundres *resp, __be32 nfserr,
4573                 struct nfsd4_layoutget *lgp)
4574 {
4575         struct xdr_stream *xdr = resp->xdr;
4576         const struct nfsd4_layout_ops *ops;
4577         __be32 *p;
4578
4579         p = xdr_reserve_space(xdr, 36 + sizeof(stateid_opaque_t));
4580         if (!p)
4581                 return nfserr_resource;
4582
4583         *p++ = cpu_to_be32(1);  /* we always set return-on-close */
4584         *p++ = cpu_to_be32(lgp->lg_sid.si_generation);
4585         p = xdr_encode_opaque_fixed(p, &lgp->lg_sid.si_opaque,
4586                                     sizeof(stateid_opaque_t));
4587
4588         *p++ = cpu_to_be32(1);  /* we always return a single layout */
4589         p = xdr_encode_hyper(p, lgp->lg_seg.offset);
4590         p = xdr_encode_hyper(p, lgp->lg_seg.length);
4591         *p++ = cpu_to_be32(lgp->lg_seg.iomode);
4592         *p++ = cpu_to_be32(lgp->lg_layout_type);
4593
4594         ops = nfsd4_layout_ops[lgp->lg_layout_type];
4595         return ops->encode_layoutget(xdr, lgp);
4596 }
4597
4598 static __be32
4599 nfsd4_encode_layoutcommit(struct nfsd4_compoundres *resp, __be32 nfserr,
4600                           struct nfsd4_layoutcommit *lcp)
4601 {
4602         struct xdr_stream *xdr = resp->xdr;
4603         __be32 *p;
4604
4605         p = xdr_reserve_space(xdr, 4);
4606         if (!p)
4607                 return nfserr_resource;
4608         *p++ = cpu_to_be32(lcp->lc_size_chg);
4609         if (lcp->lc_size_chg) {
4610                 p = xdr_reserve_space(xdr, 8);
4611                 if (!p)
4612                         return nfserr_resource;
4613                 p = xdr_encode_hyper(p, lcp->lc_newsize);
4614         }
4615
4616         return 0;
4617 }
4618
4619 static __be32
4620 nfsd4_encode_layoutreturn(struct nfsd4_compoundres *resp, __be32 nfserr,
4621                 struct nfsd4_layoutreturn *lrp)
4622 {
4623         struct xdr_stream *xdr = resp->xdr;
4624         __be32 *p;
4625
4626         p = xdr_reserve_space(xdr, 4);
4627         if (!p)
4628                 return nfserr_resource;
4629         *p++ = cpu_to_be32(lrp->lrs_present);
4630         if (lrp->lrs_present)
4631                 return nfsd4_encode_stateid(xdr, &lrp->lr_sid);
4632         return 0;
4633 }
4634 #endif /* CONFIG_NFSD_PNFS */
4635
4636 static __be32
4637 nfsd42_encode_write_res(struct nfsd4_compoundres *resp,
4638                 struct nfsd42_write_res *write, bool sync)
4639 {
4640         __be32 *p;
4641         p = xdr_reserve_space(resp->xdr, 4);
4642         if (!p)
4643                 return nfserr_resource;
4644
4645         if (sync)
4646                 *p++ = cpu_to_be32(0);
4647         else {
4648                 __be32 nfserr;
4649                 *p++ = cpu_to_be32(1);
4650                 nfserr = nfsd4_encode_stateid(resp->xdr, &write->cb_stateid);
4651                 if (nfserr)
4652                         return nfserr;
4653         }
4654         p = xdr_reserve_space(resp->xdr, 8 + 4 + NFS4_VERIFIER_SIZE);
4655         if (!p)
4656                 return nfserr_resource;
4657
4658         p = xdr_encode_hyper(p, write->wr_bytes_written);
4659         *p++ = cpu_to_be32(write->wr_stable_how);
4660         p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
4661                                     NFS4_VERIFIER_SIZE);
4662         return nfs_ok;
4663 }
4664
4665 static __be32
4666 nfsd42_encode_nl4_server(struct nfsd4_compoundres *resp, struct nl4_server *ns)
4667 {
4668         struct xdr_stream *xdr = resp->xdr;
4669         struct nfs42_netaddr *addr;
4670         __be32 *p;
4671
4672         p = xdr_reserve_space(xdr, 4);
4673         *p++ = cpu_to_be32(ns->nl4_type);
4674
4675         switch (ns->nl4_type) {
4676         case NL4_NETADDR:
4677                 addr = &ns->u.nl4_addr;
4678
4679                 /* netid_len, netid, uaddr_len, uaddr (port included
4680                  * in RPCBIND_MAXUADDRLEN)
4681                  */
4682                 p = xdr_reserve_space(xdr,
4683                         4 /* netid len */ +
4684                         (XDR_QUADLEN(addr->netid_len) * 4) +
4685                         4 /* uaddr len */ +
4686                         (XDR_QUADLEN(addr->addr_len) * 4));
4687                 if (!p)
4688                         return nfserr_resource;
4689
4690                 *p++ = cpu_to_be32(addr->netid_len);
4691                 p = xdr_encode_opaque_fixed(p, addr->netid,
4692                                             addr->netid_len);
4693                 *p++ = cpu_to_be32(addr->addr_len);
4694                 p = xdr_encode_opaque_fixed(p, addr->addr,
4695                                         addr->addr_len);
4696                 break;
4697         default:
4698                 WARN_ON_ONCE(ns->nl4_type != NL4_NETADDR);
4699                 return nfserr_inval;
4700         }
4701
4702         return 0;
4703 }
4704
4705 static __be32
4706 nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr,
4707                   struct nfsd4_copy *copy)
4708 {
4709         __be32 *p;
4710
4711         nfserr = nfsd42_encode_write_res(resp, &copy->cp_res,
4712                                          !!copy->cp_synchronous);
4713         if (nfserr)
4714                 return nfserr;
4715
4716         p = xdr_reserve_space(resp->xdr, 4 + 4);
4717         *p++ = xdr_one; /* cr_consecutive */
4718         *p++ = cpu_to_be32(copy->cp_synchronous);
4719         return 0;
4720 }
4721
4722 static __be32
4723 nfsd4_encode_offload_status(struct nfsd4_compoundres *resp, __be32 nfserr,
4724                             struct nfsd4_offload_status *os)
4725 {
4726         struct xdr_stream *xdr = resp->xdr;
4727         __be32 *p;
4728
4729         p = xdr_reserve_space(xdr, 8 + 4);
4730         if (!p)
4731                 return nfserr_resource;
4732         p = xdr_encode_hyper(p, os->count);
4733         *p++ = cpu_to_be32(0);
4734         return nfserr;
4735 }
4736
4737 static __be32
4738 nfsd4_encode_read_plus_data(struct nfsd4_compoundres *resp,
4739                             struct nfsd4_read *read,
4740                             unsigned long *maxcount, u32 *eof,
4741                             loff_t *pos)
4742 {
4743         struct xdr_stream *xdr = resp->xdr;
4744         struct file *file = read->rd_nf->nf_file;
4745         int starting_len = xdr->buf->len;
4746         loff_t hole_pos;
4747         __be32 nfserr;
4748         __be32 *p, tmp;
4749         __be64 tmp64;
4750
4751         hole_pos = pos ? *pos : vfs_llseek(file, read->rd_offset, SEEK_HOLE);
4752         if (hole_pos > read->rd_offset)
4753                 *maxcount = min_t(unsigned long, *maxcount, hole_pos - read->rd_offset);
4754         *maxcount = min_t(unsigned long, *maxcount, (xdr->buf->buflen - xdr->buf->len));
4755
4756         /* Content type, offset, byte count */
4757         p = xdr_reserve_space(xdr, 4 + 8 + 4);
4758         if (!p)
4759                 return nfserr_resource;
4760
4761         read->rd_vlen = xdr_reserve_space_vec(xdr, resp->rqstp->rq_vec, *maxcount);
4762         if (read->rd_vlen < 0)
4763                 return nfserr_resource;
4764
4765         nfserr = nfsd_readv(resp->rqstp, read->rd_fhp, file, read->rd_offset,
4766                             resp->rqstp->rq_vec, read->rd_vlen, maxcount, eof);
4767         if (nfserr)
4768                 return nfserr;
4769         xdr_truncate_encode(xdr, starting_len + 16 + xdr_align_size(*maxcount));
4770
4771         tmp = htonl(NFS4_CONTENT_DATA);
4772         write_bytes_to_xdr_buf(xdr->buf, starting_len,      &tmp,   4);
4773         tmp64 = cpu_to_be64(read->rd_offset);
4774         write_bytes_to_xdr_buf(xdr->buf, starting_len + 4,  &tmp64, 8);
4775         tmp = htonl(*maxcount);
4776         write_bytes_to_xdr_buf(xdr->buf, starting_len + 12, &tmp,   4);
4777
4778         tmp = xdr_zero;
4779         write_bytes_to_xdr_buf(xdr->buf, starting_len + 16 + *maxcount, &tmp,
4780                                xdr_pad_size(*maxcount));
4781         return nfs_ok;
4782 }
4783
4784 static __be32
4785 nfsd4_encode_read_plus_hole(struct nfsd4_compoundres *resp,
4786                             struct nfsd4_read *read,
4787                             unsigned long *maxcount, u32 *eof)
4788 {
4789         struct file *file = read->rd_nf->nf_file;
4790         loff_t data_pos = vfs_llseek(file, read->rd_offset, SEEK_DATA);
4791         loff_t f_size = i_size_read(file_inode(file));
4792         unsigned long count;
4793         __be32 *p;
4794
4795         if (data_pos == -ENXIO)
4796                 data_pos = f_size;
4797         else if (data_pos <= read->rd_offset || (data_pos < f_size && data_pos % PAGE_SIZE))
4798                 return nfsd4_encode_read_plus_data(resp, read, maxcount, eof, &f_size);
4799         count = data_pos - read->rd_offset;
4800
4801         /* Content type, offset, byte count */
4802         p = xdr_reserve_space(resp->xdr, 4 + 8 + 8);
4803         if (!p)
4804                 return nfserr_resource;
4805
4806         *p++ = htonl(NFS4_CONTENT_HOLE);
4807          p   = xdr_encode_hyper(p, read->rd_offset);
4808          p   = xdr_encode_hyper(p, count);
4809
4810         *eof = (read->rd_offset + count) >= f_size;
4811         *maxcount = min_t(unsigned long, count, *maxcount);
4812         return nfs_ok;
4813 }
4814
4815 static __be32
4816 nfsd4_encode_read_plus(struct nfsd4_compoundres *resp, __be32 nfserr,
4817                        struct nfsd4_read *read)
4818 {
4819         unsigned long maxcount, count;
4820         struct xdr_stream *xdr = resp->xdr;
4821         struct file *file;
4822         int starting_len = xdr->buf->len;
4823         int last_segment = xdr->buf->len;
4824         int segments = 0;
4825         __be32 *p, tmp;
4826         bool is_data;
4827         loff_t pos;
4828         u32 eof;
4829
4830         if (nfserr)
4831                 return nfserr;
4832         file = read->rd_nf->nf_file;
4833
4834         /* eof flag, segment count */
4835         p = xdr_reserve_space(xdr, 4 + 4);
4836         if (!p)
4837                 return nfserr_resource;
4838         xdr_commit_encode(xdr);
4839
4840         maxcount = svc_max_payload(resp->rqstp);
4841         maxcount = min_t(unsigned long, maxcount,
4842                          (xdr->buf->buflen - xdr->buf->len));
4843         maxcount = min_t(unsigned long, maxcount, read->rd_length);
4844         count    = maxcount;
4845
4846         eof = read->rd_offset >= i_size_read(file_inode(file));
4847         if (eof)
4848                 goto out;
4849
4850         pos = vfs_llseek(file, read->rd_offset, SEEK_HOLE);
4851         is_data = pos > read->rd_offset;
4852
4853         while (count > 0 && !eof) {
4854                 maxcount = count;
4855                 if (is_data)
4856                         nfserr = nfsd4_encode_read_plus_data(resp, read, &maxcount, &eof,
4857                                                 segments == 0 ? &pos : NULL);
4858                 else
4859                         nfserr = nfsd4_encode_read_plus_hole(resp, read, &maxcount, &eof);
4860                 if (nfserr)
4861                         goto out;
4862                 count -= maxcount;
4863                 read->rd_offset += maxcount;
4864                 is_data = !is_data;
4865                 last_segment = xdr->buf->len;
4866                 segments++;
4867         }
4868
4869 out:
4870         if (nfserr && segments == 0)
4871                 xdr_truncate_encode(xdr, starting_len);
4872         else {
4873                 if (nfserr) {
4874                         xdr_truncate_encode(xdr, last_segment);
4875                         nfserr = nfs_ok;
4876                         eof = 0;
4877                 }
4878                 tmp = htonl(eof);
4879                 write_bytes_to_xdr_buf(xdr->buf, starting_len,     &tmp, 4);
4880                 tmp = htonl(segments);
4881                 write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4);
4882         }
4883
4884         return nfserr;
4885 }
4886
4887 static __be32
4888 nfsd4_encode_copy_notify(struct nfsd4_compoundres *resp, __be32 nfserr,
4889                          struct nfsd4_copy_notify *cn)
4890 {
4891         struct xdr_stream *xdr = resp->xdr;
4892         __be32 *p;
4893
4894         if (nfserr)
4895                 return nfserr;
4896
4897         /* 8 sec, 4 nsec */
4898         p = xdr_reserve_space(xdr, 12);
4899         if (!p)
4900                 return nfserr_resource;
4901
4902         /* cnr_lease_time */
4903         p = xdr_encode_hyper(p, cn->cpn_sec);
4904         *p++ = cpu_to_be32(cn->cpn_nsec);
4905
4906         /* cnr_stateid */
4907         nfserr = nfsd4_encode_stateid(xdr, &cn->cpn_cnr_stateid);
4908         if (nfserr)
4909                 return nfserr;
4910
4911         /* cnr_src.nl_nsvr */
4912         p = xdr_reserve_space(xdr, 4);
4913         if (!p)
4914                 return nfserr_resource;
4915
4916         *p++ = cpu_to_be32(1);
4917
4918         return nfsd42_encode_nl4_server(resp, &cn->cpn_src);
4919 }
4920
4921 static __be32
4922 nfsd4_encode_seek(struct nfsd4_compoundres *resp, __be32 nfserr,
4923                   struct nfsd4_seek *seek)
4924 {
4925         __be32 *p;
4926
4927         p = xdr_reserve_space(resp->xdr, 4 + 8);
4928         *p++ = cpu_to_be32(seek->seek_eof);
4929         p = xdr_encode_hyper(p, seek->seek_pos);
4930
4931         return 0;
4932 }
4933
4934 static __be32
4935 nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p)
4936 {
4937         return nfserr;
4938 }
4939
4940 /*
4941  * Encode kmalloc-ed buffer in to XDR stream.
4942  */
4943 static __be32
4944 nfsd4_vbuf_to_stream(struct xdr_stream *xdr, char *buf, u32 buflen)
4945 {
4946         u32 cplen;
4947         __be32 *p;
4948
4949         cplen = min_t(unsigned long, buflen,
4950                       ((void *)xdr->end - (void *)xdr->p));
4951         p = xdr_reserve_space(xdr, cplen);
4952         if (!p)
4953                 return nfserr_resource;
4954
4955         memcpy(p, buf, cplen);
4956         buf += cplen;
4957         buflen -= cplen;
4958
4959         while (buflen) {
4960                 cplen = min_t(u32, buflen, PAGE_SIZE);
4961                 p = xdr_reserve_space(xdr, cplen);
4962                 if (!p)
4963                         return nfserr_resource;
4964
4965                 memcpy(p, buf, cplen);
4966
4967                 if (cplen < PAGE_SIZE) {
4968                         /*
4969                          * We're done, with a length that wasn't page
4970                          * aligned, so possibly not word aligned. Pad
4971                          * any trailing bytes with 0.
4972                          */
4973                         xdr_encode_opaque_fixed(p, NULL, cplen);
4974                         break;
4975                 }
4976
4977                 buflen -= PAGE_SIZE;
4978                 buf += PAGE_SIZE;
4979         }
4980
4981         return 0;
4982 }
4983
4984 static __be32
4985 nfsd4_encode_getxattr(struct nfsd4_compoundres *resp, __be32 nfserr,
4986                       struct nfsd4_getxattr *getxattr)
4987 {
4988         struct xdr_stream *xdr = resp->xdr;
4989         __be32 *p, err;
4990
4991         p = xdr_reserve_space(xdr, 4);
4992         if (!p)
4993                 return nfserr_resource;
4994
4995         *p = cpu_to_be32(getxattr->getxa_len);
4996
4997         if (getxattr->getxa_len == 0)
4998                 return 0;
4999
5000         err = nfsd4_vbuf_to_stream(xdr, getxattr->getxa_buf,
5001                                     getxattr->getxa_len);
5002
5003         kvfree(getxattr->getxa_buf);
5004
5005         return err;
5006 }
5007
5008 static __be32
5009 nfsd4_encode_setxattr(struct nfsd4_compoundres *resp, __be32 nfserr,
5010                       struct nfsd4_setxattr *setxattr)
5011 {
5012         struct xdr_stream *xdr = resp->xdr;
5013         __be32 *p;
5014
5015         p = xdr_reserve_space(xdr, 20);
5016         if (!p)
5017                 return nfserr_resource;
5018
5019         encode_cinfo(p, &setxattr->setxa_cinfo);
5020
5021         return 0;
5022 }
5023
5024 /*
5025  * See if there are cookie values that can be rejected outright.
5026  */
5027 static __be32
5028 nfsd4_listxattr_validate_cookie(struct nfsd4_listxattrs *listxattrs,
5029                                 u32 *offsetp)
5030 {
5031         u64 cookie = listxattrs->lsxa_cookie;
5032
5033         /*
5034          * If the cookie is larger than the maximum number we can fit
5035          * in either the buffer we just got back from vfs_listxattr, or,
5036          * XDR-encoded, in the return buffer, it's invalid.
5037          */
5038         if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2))
5039                 return nfserr_badcookie;
5040
5041         if (cookie > (listxattrs->lsxa_maxcount /
5042                       (XDR_QUADLEN(XATTR_USER_PREFIX_LEN + 2) + 4)))
5043                 return nfserr_badcookie;
5044
5045         *offsetp = (u32)cookie;
5046         return 0;
5047 }
5048
5049 static __be32
5050 nfsd4_encode_listxattrs(struct nfsd4_compoundres *resp, __be32 nfserr,
5051                         struct nfsd4_listxattrs *listxattrs)
5052 {
5053         struct xdr_stream *xdr = resp->xdr;
5054         u32 cookie_offset, count_offset, eof;
5055         u32 left, xdrleft, slen, count;
5056         u32 xdrlen, offset;
5057         u64 cookie;
5058         char *sp;
5059         __be32 status, tmp;
5060         __be32 *p;
5061         u32 nuser;
5062
5063         eof = 1;
5064
5065         status = nfsd4_listxattr_validate_cookie(listxattrs, &offset);
5066         if (status)
5067                 goto out;
5068
5069         /*
5070          * Reserve space for the cookie and the name array count. Record
5071          * the offsets to save them later.
5072          */
5073         cookie_offset = xdr->buf->len;
5074         count_offset = cookie_offset + 8;
5075         p = xdr_reserve_space(xdr, 12);
5076         if (!p) {
5077                 status = nfserr_resource;
5078                 goto out;
5079         }
5080
5081         count = 0;
5082         left = listxattrs->lsxa_len;
5083         sp = listxattrs->lsxa_buf;
5084         nuser = 0;
5085
5086         xdrleft = listxattrs->lsxa_maxcount;
5087
5088         while (left > 0 && xdrleft > 0) {
5089                 slen = strlen(sp);
5090
5091                 /*
5092                  * Check if this is a "user." attribute, skip it if not.
5093                  */
5094                 if (strncmp(sp, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN))
5095                         goto contloop;
5096
5097                 slen -= XATTR_USER_PREFIX_LEN;
5098                 xdrlen = 4 + ((slen + 3) & ~3);
5099                 if (xdrlen > xdrleft) {
5100                         if (count == 0) {
5101                                 /*
5102                                  * Can't even fit the first attribute name.
5103                                  */
5104                                 status = nfserr_toosmall;
5105                                 goto out;
5106                         }
5107                         eof = 0;
5108                         goto wreof;
5109                 }
5110
5111                 left -= XATTR_USER_PREFIX_LEN;
5112                 sp += XATTR_USER_PREFIX_LEN;
5113                 if (nuser++ < offset)
5114                         goto contloop;
5115
5116
5117                 p = xdr_reserve_space(xdr, xdrlen);
5118                 if (!p) {
5119                         status = nfserr_resource;
5120                         goto out;
5121                 }
5122
5123                 xdr_encode_opaque(p, sp, slen);
5124
5125                 xdrleft -= xdrlen;
5126                 count++;
5127 contloop:
5128                 sp += slen + 1;
5129                 left -= slen + 1;
5130         }
5131
5132         /*
5133          * If there were user attributes to copy, but we didn't copy
5134          * any, the offset was too large (e.g. the cookie was invalid).
5135          */
5136         if (nuser > 0 && count == 0) {
5137                 status = nfserr_badcookie;
5138                 goto out;
5139         }
5140
5141 wreof:
5142         p = xdr_reserve_space(xdr, 4);
5143         if (!p) {
5144                 status = nfserr_resource;
5145                 goto out;
5146         }
5147         *p = cpu_to_be32(eof);
5148
5149         cookie = offset + count;
5150
5151         write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &cookie, 8);
5152         tmp = cpu_to_be32(count);
5153         write_bytes_to_xdr_buf(xdr->buf, count_offset, &tmp, 4);
5154 out:
5155         if (listxattrs->lsxa_len)
5156                 kvfree(listxattrs->lsxa_buf);
5157         return status;
5158 }
5159
5160 static __be32
5161 nfsd4_encode_removexattr(struct nfsd4_compoundres *resp, __be32 nfserr,
5162                          struct nfsd4_removexattr *removexattr)
5163 {
5164         struct xdr_stream *xdr = resp->xdr;
5165         __be32 *p;
5166
5167         p = xdr_reserve_space(xdr, 20);
5168         if (!p)
5169                 return nfserr_resource;
5170
5171         p = encode_cinfo(p, &removexattr->rmxa_cinfo);
5172         return 0;
5173 }
5174
5175 typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *);
5176
5177 /*
5178  * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
5179  * since we don't need to filter out obsolete ops as this is
5180  * done in the decoding phase.
5181  */
5182 static const nfsd4_enc nfsd4_enc_ops[] = {
5183         [OP_ACCESS]             = (nfsd4_enc)nfsd4_encode_access,
5184         [OP_CLOSE]              = (nfsd4_enc)nfsd4_encode_close,
5185         [OP_COMMIT]             = (nfsd4_enc)nfsd4_encode_commit,
5186         [OP_CREATE]             = (nfsd4_enc)nfsd4_encode_create,
5187         [OP_DELEGPURGE]         = (nfsd4_enc)nfsd4_encode_noop,
5188         [OP_DELEGRETURN]        = (nfsd4_enc)nfsd4_encode_noop,
5189         [OP_GETATTR]            = (nfsd4_enc)nfsd4_encode_getattr,
5190         [OP_GETFH]              = (nfsd4_enc)nfsd4_encode_getfh,
5191         [OP_LINK]               = (nfsd4_enc)nfsd4_encode_link,
5192         [OP_LOCK]               = (nfsd4_enc)nfsd4_encode_lock,
5193         [OP_LOCKT]              = (nfsd4_enc)nfsd4_encode_lockt,
5194         [OP_LOCKU]              = (nfsd4_enc)nfsd4_encode_locku,
5195         [OP_LOOKUP]             = (nfsd4_enc)nfsd4_encode_noop,
5196         [OP_LOOKUPP]            = (nfsd4_enc)nfsd4_encode_noop,
5197         [OP_NVERIFY]            = (nfsd4_enc)nfsd4_encode_noop,
5198         [OP_OPEN]               = (nfsd4_enc)nfsd4_encode_open,
5199         [OP_OPENATTR]           = (nfsd4_enc)nfsd4_encode_noop,
5200         [OP_OPEN_CONFIRM]       = (nfsd4_enc)nfsd4_encode_open_confirm,
5201         [OP_OPEN_DOWNGRADE]     = (nfsd4_enc)nfsd4_encode_open_downgrade,
5202         [OP_PUTFH]              = (nfsd4_enc)nfsd4_encode_noop,
5203         [OP_PUTPUBFH]           = (nfsd4_enc)nfsd4_encode_noop,
5204         [OP_PUTROOTFH]          = (nfsd4_enc)nfsd4_encode_noop,
5205         [OP_READ]               = (nfsd4_enc)nfsd4_encode_read,
5206         [OP_READDIR]            = (nfsd4_enc)nfsd4_encode_readdir,
5207         [OP_READLINK]           = (nfsd4_enc)nfsd4_encode_readlink,
5208         [OP_REMOVE]             = (nfsd4_enc)nfsd4_encode_remove,
5209         [OP_RENAME]             = (nfsd4_enc)nfsd4_encode_rename,
5210         [OP_RENEW]              = (nfsd4_enc)nfsd4_encode_noop,
5211         [OP_RESTOREFH]          = (nfsd4_enc)nfsd4_encode_noop,
5212         [OP_SAVEFH]             = (nfsd4_enc)nfsd4_encode_noop,
5213         [OP_SECINFO]            = (nfsd4_enc)nfsd4_encode_secinfo,
5214         [OP_SETATTR]            = (nfsd4_enc)nfsd4_encode_setattr,
5215         [OP_SETCLIENTID]        = (nfsd4_enc)nfsd4_encode_setclientid,
5216         [OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop,
5217         [OP_VERIFY]             = (nfsd4_enc)nfsd4_encode_noop,
5218         [OP_WRITE]              = (nfsd4_enc)nfsd4_encode_write,
5219         [OP_RELEASE_LOCKOWNER]  = (nfsd4_enc)nfsd4_encode_noop,
5220
5221         /* NFSv4.1 operations */
5222         [OP_BACKCHANNEL_CTL]    = (nfsd4_enc)nfsd4_encode_noop,
5223         [OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session,
5224         [OP_EXCHANGE_ID]        = (nfsd4_enc)nfsd4_encode_exchange_id,
5225         [OP_CREATE_SESSION]     = (nfsd4_enc)nfsd4_encode_create_session,
5226         [OP_DESTROY_SESSION]    = (nfsd4_enc)nfsd4_encode_noop,
5227         [OP_FREE_STATEID]       = (nfsd4_enc)nfsd4_encode_noop,
5228         [OP_GET_DIR_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop,
5229 #ifdef CONFIG_NFSD_PNFS
5230         [OP_GETDEVICEINFO]      = (nfsd4_enc)nfsd4_encode_getdeviceinfo,
5231         [OP_GETDEVICELIST]      = (nfsd4_enc)nfsd4_encode_noop,
5232         [OP_LAYOUTCOMMIT]       = (nfsd4_enc)nfsd4_encode_layoutcommit,
5233         [OP_LAYOUTGET]          = (nfsd4_enc)nfsd4_encode_layoutget,
5234         [OP_LAYOUTRETURN]       = (nfsd4_enc)nfsd4_encode_layoutreturn,
5235 #else
5236         [OP_GETDEVICEINFO]      = (nfsd4_enc)nfsd4_encode_noop,
5237         [OP_GETDEVICELIST]      = (nfsd4_enc)nfsd4_encode_noop,
5238         [OP_LAYOUTCOMMIT]       = (nfsd4_enc)nfsd4_encode_noop,
5239         [OP_LAYOUTGET]          = (nfsd4_enc)nfsd4_encode_noop,
5240         [OP_LAYOUTRETURN]       = (nfsd4_enc)nfsd4_encode_noop,
5241 #endif
5242         [OP_SECINFO_NO_NAME]    = (nfsd4_enc)nfsd4_encode_secinfo_no_name,
5243         [OP_SEQUENCE]           = (nfsd4_enc)nfsd4_encode_sequence,
5244         [OP_SET_SSV]            = (nfsd4_enc)nfsd4_encode_noop,
5245         [OP_TEST_STATEID]       = (nfsd4_enc)nfsd4_encode_test_stateid,
5246         [OP_WANT_DELEGATION]    = (nfsd4_enc)nfsd4_encode_noop,
5247         [OP_DESTROY_CLIENTID]   = (nfsd4_enc)nfsd4_encode_noop,
5248         [OP_RECLAIM_COMPLETE]   = (nfsd4_enc)nfsd4_encode_noop,
5249
5250         /* NFSv4.2 operations */
5251         [OP_ALLOCATE]           = (nfsd4_enc)nfsd4_encode_noop,
5252         [OP_COPY]               = (nfsd4_enc)nfsd4_encode_copy,
5253         [OP_COPY_NOTIFY]        = (nfsd4_enc)nfsd4_encode_copy_notify,
5254         [OP_DEALLOCATE]         = (nfsd4_enc)nfsd4_encode_noop,
5255         [OP_IO_ADVISE]          = (nfsd4_enc)nfsd4_encode_noop,
5256         [OP_LAYOUTERROR]        = (nfsd4_enc)nfsd4_encode_noop,
5257         [OP_LAYOUTSTATS]        = (nfsd4_enc)nfsd4_encode_noop,
5258         [OP_OFFLOAD_CANCEL]     = (nfsd4_enc)nfsd4_encode_noop,
5259         [OP_OFFLOAD_STATUS]     = (nfsd4_enc)nfsd4_encode_offload_status,
5260         [OP_READ_PLUS]          = (nfsd4_enc)nfsd4_encode_read_plus,
5261         [OP_SEEK]               = (nfsd4_enc)nfsd4_encode_seek,
5262         [OP_WRITE_SAME]         = (nfsd4_enc)nfsd4_encode_noop,
5263         [OP_CLONE]              = (nfsd4_enc)nfsd4_encode_noop,
5264
5265         /* RFC 8276 extended atributes operations */
5266         [OP_GETXATTR]           = (nfsd4_enc)nfsd4_encode_getxattr,
5267         [OP_SETXATTR]           = (nfsd4_enc)nfsd4_encode_setxattr,
5268         [OP_LISTXATTRS]         = (nfsd4_enc)nfsd4_encode_listxattrs,
5269         [OP_REMOVEXATTR]        = (nfsd4_enc)nfsd4_encode_removexattr,
5270 };
5271
5272 /*
5273  * Calculate whether we still have space to encode repsize bytes.
5274  * There are two considerations:
5275  *     - For NFS versions >=4.1, the size of the reply must stay within
5276  *       session limits
5277  *     - For all NFS versions, we must stay within limited preallocated
5278  *       buffer space.
5279  *
5280  * This is called before the operation is processed, so can only provide
5281  * an upper estimate.  For some nonidempotent operations (such as
5282  * getattr), it's not necessarily a problem if that estimate is wrong,
5283  * as we can fail it after processing without significant side effects.
5284  */
5285 __be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize)
5286 {
5287         struct xdr_buf *buf = &resp->rqstp->rq_res;
5288         struct nfsd4_slot *slot = resp->cstate.slot;
5289
5290         if (buf->len + respsize <= buf->buflen)
5291                 return nfs_ok;
5292         if (!nfsd4_has_session(&resp->cstate))
5293                 return nfserr_resource;
5294         if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) {
5295                 WARN_ON_ONCE(1);
5296                 return nfserr_rep_too_big_to_cache;
5297         }
5298         return nfserr_rep_too_big;
5299 }
5300
5301 void
5302 nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
5303 {
5304         struct xdr_stream *xdr = resp->xdr;
5305         struct nfs4_stateowner *so = resp->cstate.replay_owner;
5306         struct svc_rqst *rqstp = resp->rqstp;
5307         const struct nfsd4_operation *opdesc = op->opdesc;
5308         int post_err_offset;
5309         nfsd4_enc encoder;
5310         __be32 *p;
5311
5312         p = xdr_reserve_space(xdr, 8);
5313         if (!p) {
5314                 WARN_ON_ONCE(1);
5315                 return;
5316         }
5317         *p++ = cpu_to_be32(op->opnum);
5318         post_err_offset = xdr->buf->len;
5319
5320         if (op->opnum == OP_ILLEGAL)
5321                 goto status;
5322         if (op->status && opdesc &&
5323                         !(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE))
5324                 goto status;
5325         BUG_ON(op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||
5326                !nfsd4_enc_ops[op->opnum]);
5327         encoder = nfsd4_enc_ops[op->opnum];
5328         op->status = encoder(resp, op->status, &op->u);
5329         if (op->status)
5330                 trace_nfsd_compound_encode_err(rqstp, op->opnum, op->status);
5331         if (opdesc && opdesc->op_release)
5332                 opdesc->op_release(&op->u);
5333         xdr_commit_encode(xdr);
5334
5335         /* nfsd4_check_resp_size guarantees enough room for error status */
5336         if (!op->status) {
5337                 int space_needed = 0;
5338                 if (!nfsd4_last_compound_op(rqstp))
5339                         space_needed = COMPOUND_ERR_SLACK_SPACE;
5340                 op->status = nfsd4_check_resp_size(resp, space_needed);
5341         }
5342         if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) {
5343                 struct nfsd4_slot *slot = resp->cstate.slot;
5344
5345                 if (slot->sl_flags & NFSD4_SLOT_CACHETHIS)
5346                         op->status = nfserr_rep_too_big_to_cache;
5347                 else
5348                         op->status = nfserr_rep_too_big;
5349         }
5350         if (op->status == nfserr_resource ||
5351             op->status == nfserr_rep_too_big ||
5352             op->status == nfserr_rep_too_big_to_cache) {
5353                 /*
5354                  * The operation may have already been encoded or
5355                  * partially encoded.  No op returns anything additional
5356                  * in the case of one of these three errors, so we can
5357                  * just truncate back to after the status.  But it's a
5358                  * bug if we had to do this on a non-idempotent op:
5359                  */
5360                 warn_on_nonidempotent_op(op);
5361                 xdr_truncate_encode(xdr, post_err_offset);
5362         }
5363         if (so) {
5364                 int len = xdr->buf->len - post_err_offset;
5365
5366                 so->so_replay.rp_status = op->status;
5367                 so->so_replay.rp_buflen = len;
5368                 read_bytes_from_xdr_buf(xdr->buf, post_err_offset,
5369                                                 so->so_replay.rp_buf, len);
5370         }
5371 status:
5372         /* Note that op->status is already in network byte order: */
5373         write_bytes_to_xdr_buf(xdr->buf, post_err_offset - 4, &op->status, 4);
5374 }
5375
5376 /*
5377  * Encode the reply stored in the stateowner reply cache
5378  *
5379  * XDR note: do not encode rp->rp_buflen: the buffer contains the
5380  * previously sent already encoded operation.
5381  */
5382 void
5383 nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op)
5384 {
5385         __be32 *p;
5386         struct nfs4_replay *rp = op->replay;
5387
5388         p = xdr_reserve_space(xdr, 8 + rp->rp_buflen);
5389         if (!p) {
5390                 WARN_ON_ONCE(1);
5391                 return;
5392         }
5393         *p++ = cpu_to_be32(op->opnum);
5394         *p++ = rp->rp_status;  /* already xdr'ed */
5395
5396         p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen);
5397 }
5398
5399 void nfsd4_release_compoundargs(struct svc_rqst *rqstp)
5400 {
5401         struct nfsd4_compoundargs *args = rqstp->rq_argp;
5402
5403         if (args->ops != args->iops) {
5404                 kfree(args->ops);
5405                 args->ops = args->iops;
5406         }
5407         while (args->to_free) {
5408                 struct svcxdr_tmpbuf *tb = args->to_free;
5409                 args->to_free = tb->next;
5410                 kfree(tb);
5411         }
5412 }
5413
5414 bool
5415 nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
5416 {
5417         struct nfsd4_compoundargs *args = rqstp->rq_argp;
5418
5419         /* svcxdr_tmp_alloc */
5420         args->to_free = NULL;
5421
5422         args->xdr = xdr;
5423         args->ops = args->iops;
5424         args->rqstp = rqstp;
5425
5426         return nfsd4_decode_compound(args);
5427 }
5428
5429 bool
5430 nfs4svc_encode_compoundres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
5431 {
5432         struct nfsd4_compoundres *resp = rqstp->rq_resp;
5433         struct xdr_buf *buf = xdr->buf;
5434         __be32 *p;
5435
5436         WARN_ON_ONCE(buf->len != buf->head[0].iov_len + buf->page_len +
5437                                  buf->tail[0].iov_len);
5438
5439         /*
5440          * Send buffer space for the following items is reserved
5441          * at the top of nfsd4_proc_compound().
5442          */
5443         p = resp->statusp;
5444
5445         *p++ = resp->cstate.status;
5446
5447         rqstp->rq_next_page = xdr->page_ptr + 1;
5448
5449         *p++ = htonl(resp->taglen);
5450         memcpy(p, resp->tag, resp->taglen);
5451         p += XDR_QUADLEN(resp->taglen);
5452         *p++ = htonl(resp->opcnt);
5453
5454         nfsd4_sequence_done(resp);
5455         return true;
5456 }