fs/nfsd/nfs4xdr.c

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