fs/nfsd/nfs4xdr.c

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