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         u32 name_and_cookie;
2661         int entry_bytes;
2662         __be32 nfserr = nfserr_toosmall;
2663         __be64 wire_offset;
2664         __be32 *p;
2665
2666         /* In nfsv4, "." and ".." never make it onto the wire.. */
2667         if (name && isdotent(name, namlen)) {
2668                 cd->common.err = nfs_ok;
2669                 return 0;
2670         }
2671
2672         if (cd->cookie_offset) {
2673                 wire_offset = cpu_to_be64(offset);
2674                 write_bytes_to_xdr_buf(xdr->buf, cd->cookie_offset,
2675                                                         &wire_offset, 8);
2676         }
2677
2678         p = xdr_reserve_space(xdr, 4);
2679         if (!p)
2680                 goto fail;
2681         *p++ = xdr_one;                             /* mark entry present */
2682         cookie_offset = xdr->buf->len;
2683         p = xdr_reserve_space(xdr, 3*4 + namlen);
2684         if (!p)
2685                 goto fail;
2686         p = xdr_encode_hyper(p, NFS_OFFSET_MAX);    /* offset of next entry */
2687         p = xdr_encode_array(p, name, namlen);      /* name length & name */
2688
2689         nfserr = nfsd4_encode_dirent_fattr(xdr, cd, name, namlen);
2690         switch (nfserr) {
2691         case nfs_ok:
2692                 break;
2693         case nfserr_resource:
2694                 nfserr = nfserr_toosmall;
2695                 goto fail;
2696         case nfserr_noent:
2697                 xdr_truncate_encode(xdr, start_offset);
2698                 goto skip_entry;
2699         default:
2700                 /*
2701                  * If the client requested the RDATTR_ERROR attribute,
2702                  * we stuff the error code into this attribute
2703                  * and continue.  If this attribute was not requested,
2704                  * then in accordance with the spec, we fail the
2705                  * entire READDIR operation(!)
2706                  */
2707                 if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))
2708                         goto fail;
2709                 p = nfsd4_encode_rdattr_error(xdr, nfserr);
2710                 if (p == NULL) {
2711                         nfserr = nfserr_toosmall;
2712                         goto fail;
2713                 }
2714         }
2715         nfserr = nfserr_toosmall;
2716         entry_bytes = xdr->buf->len - start_offset;
2717         if (entry_bytes > cd->rd_maxcount)
2718                 goto fail;
2719         cd->rd_maxcount -= entry_bytes;
2720         if (!cd->rd_dircount)
2721                 goto fail;
2722         /*
2723          * RFC 3530 14.2.24 describes rd_dircount as only a "hint", so
2724          * let's always let through the first entry, at least:
2725          */
2726         name_and_cookie = 4 * XDR_QUADLEN(namlen) + 8;
2727         if (name_and_cookie > cd->rd_dircount && cd->cookie_offset)
2728                 goto fail;
2729         cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie);
2730         cd->cookie_offset = cookie_offset;
2731 skip_entry:
2732         cd->common.err = nfs_ok;
2733         return 0;
2734 fail:
2735         xdr_truncate_encode(xdr, start_offset);
2736         cd->common.err = nfserr;
2737         return -EINVAL;
2738 }
2739
2740 static __be32
2741 nfsd4_encode_stateid(struct xdr_stream *xdr, stateid_t *sid)
2742 {
2743         __be32 *p;
2744
2745         p = xdr_reserve_space(xdr, sizeof(stateid_t));
2746         if (!p)
2747                 return nfserr_resource;
2748         *p++ = cpu_to_be32(sid->si_generation);
2749         p = xdr_encode_opaque_fixed(p, &sid->si_opaque,
2750                                         sizeof(stateid_opaque_t));
2751         return 0;
2752 }
2753
2754 static __be32
2755 nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access)
2756 {
2757         struct xdr_stream *xdr = &resp->xdr;
2758         __be32 *p;
2759
2760         if (!nfserr) {
2761                 p = xdr_reserve_space(xdr, 8);
2762                 if (!p)
2763                         return nfserr_resource;
2764                 *p++ = cpu_to_be32(access->ac_supported);
2765                 *p++ = cpu_to_be32(access->ac_resp_access);
2766         }
2767         return nfserr;
2768 }
2769
2770 static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)
2771 {
2772         struct xdr_stream *xdr = &resp->xdr;
2773         __be32 *p;
2774
2775         if (!nfserr) {
2776                 p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 8);
2777                 if (!p)
2778                         return nfserr_resource;
2779                 p = xdr_encode_opaque_fixed(p, bcts->sessionid.data,
2780                                                 NFS4_MAX_SESSIONID_LEN);
2781                 *p++ = cpu_to_be32(bcts->dir);
2782                 /* Sorry, we do not yet support RDMA over 4.1: */
2783                 *p++ = cpu_to_be32(0);
2784         }
2785         return nfserr;
2786 }
2787
2788 static __be32
2789 nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close)
2790 {
2791         struct xdr_stream *xdr = &resp->xdr;
2792
2793         if (!nfserr)
2794                 nfserr = nfsd4_encode_stateid(xdr, &close->cl_stateid);
2795
2796         return nfserr;
2797 }
2798
2799
2800 static __be32
2801 nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit)
2802 {
2803         struct xdr_stream *xdr = &resp->xdr;
2804         __be32 *p;
2805
2806         if (!nfserr) {
2807                 p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
2808                 if (!p)
2809                         return nfserr_resource;
2810                 p = xdr_encode_opaque_fixed(p, commit->co_verf.data,
2811                                                 NFS4_VERIFIER_SIZE);
2812         }
2813         return nfserr;
2814 }
2815
2816 static __be32
2817 nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create)
2818 {
2819         struct xdr_stream *xdr = &resp->xdr;
2820         __be32 *p;
2821
2822         if (!nfserr) {
2823                 p = xdr_reserve_space(xdr, 32);
2824                 if (!p)
2825                         return nfserr_resource;
2826                 p = encode_cinfo(p, &create->cr_cinfo);
2827                 *p++ = cpu_to_be32(2);
2828                 *p++ = cpu_to_be32(create->cr_bmval[0]);
2829                 *p++ = cpu_to_be32(create->cr_bmval[1]);
2830         }
2831         return nfserr;
2832 }
2833
2834 static __be32
2835 nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr)
2836 {
2837         struct svc_fh *fhp = getattr->ga_fhp;
2838         struct xdr_stream *xdr = &resp->xdr;
2839
2840         if (nfserr)
2841                 return nfserr;
2842
2843         nfserr = nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry,
2844                                     getattr->ga_bmval,
2845                                     resp->rqstp, 0);
2846         return nfserr;
2847 }
2848
2849 static __be32
2850 nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp)
2851 {
2852         struct xdr_stream *xdr = &resp->xdr;
2853         struct svc_fh *fhp = *fhpp;
2854         unsigned int len;
2855         __be32 *p;
2856
2857         if (!nfserr) {
2858                 len = fhp->fh_handle.fh_size;
2859                 p = xdr_reserve_space(xdr, len + 4);
2860                 if (!p)
2861                         return nfserr_resource;
2862                 p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, len);
2863         }
2864         return nfserr;
2865 }
2866
2867 /*
2868 * Including all fields other than the name, a LOCK4denied structure requires
2869 *   8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
2870 */
2871 static __be32
2872 nfsd4_encode_lock_denied(struct xdr_stream *xdr, struct nfsd4_lock_denied *ld)
2873 {
2874         struct xdr_netobj *conf = &ld->ld_owner;
2875         __be32 *p;
2876
2877 again:
2878         p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len));
2879         if (!p) {
2880                 /*
2881                  * Don't fail to return the result just because we can't
2882                  * return the conflicting open:
2883                  */
2884                 if (conf->len) {
2885                         kfree(conf->data);
2886                         conf->len = 0;
2887                         conf->data = NULL;
2888                         goto again;
2889                 }
2890                 return nfserr_resource;
2891         }
2892         p = xdr_encode_hyper(p, ld->ld_start);
2893         p = xdr_encode_hyper(p, ld->ld_length);
2894         *p++ = cpu_to_be32(ld->ld_type);
2895         if (conf->len) {
2896                 p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8);
2897                 p = xdr_encode_opaque(p, conf->data, conf->len);
2898                 kfree(conf->data);
2899         }  else {  /* non - nfsv4 lock in conflict, no clientid nor owner */
2900                 p = xdr_encode_hyper(p, (u64)0); /* clientid */
2901                 *p++ = cpu_to_be32(0); /* length of owner name */
2902         }
2903         return nfserr_denied;
2904 }
2905
2906 static __be32
2907 nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock)
2908 {
2909         struct xdr_stream *xdr = &resp->xdr;
2910
2911         if (!nfserr)
2912                 nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid);
2913         else if (nfserr == nfserr_denied)
2914                 nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied);
2915
2916         return nfserr;
2917 }
2918
2919 static __be32
2920 nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt)
2921 {
2922         struct xdr_stream *xdr = &resp->xdr;
2923
2924         if (nfserr == nfserr_denied)
2925                 nfsd4_encode_lock_denied(xdr, &lockt->lt_denied);
2926         return nfserr;
2927 }
2928
2929 static __be32
2930 nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku)
2931 {
2932         struct xdr_stream *xdr = &resp->xdr;
2933
2934         if (!nfserr)
2935                 nfserr = nfsd4_encode_stateid(xdr, &locku->lu_stateid);
2936
2937         return nfserr;
2938 }
2939
2940
2941 static __be32
2942 nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link)
2943 {
2944         struct xdr_stream *xdr = &resp->xdr;
2945         __be32 *p;
2946
2947         if (!nfserr) {
2948                 p = xdr_reserve_space(xdr, 20);
2949                 if (!p)
2950                         return nfserr_resource;
2951                 p = encode_cinfo(p, &link->li_cinfo);
2952         }
2953         return nfserr;
2954 }
2955
2956
2957 static __be32
2958 nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open)
2959 {
2960         struct xdr_stream *xdr = &resp->xdr;
2961         __be32 *p;
2962
2963         if (nfserr)
2964                 goto out;
2965
2966         nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid);
2967         if (nfserr)
2968                 goto out;
2969         p = xdr_reserve_space(xdr, 40);
2970         if (!p)
2971                 return nfserr_resource;
2972         p = encode_cinfo(p, &open->op_cinfo);
2973         *p++ = cpu_to_be32(open->op_rflags);
2974         *p++ = cpu_to_be32(2);
2975         *p++ = cpu_to_be32(open->op_bmval[0]);
2976         *p++ = cpu_to_be32(open->op_bmval[1]);
2977         *p++ = cpu_to_be32(open->op_delegate_type);
2978
2979         switch (open->op_delegate_type) {
2980         case NFS4_OPEN_DELEGATE_NONE:
2981                 break;
2982         case NFS4_OPEN_DELEGATE_READ:
2983                 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
2984                 if (nfserr)
2985                         return nfserr;
2986                 p = xdr_reserve_space(xdr, 20);
2987                 if (!p)
2988                         return nfserr_resource;
2989                 *p++ = cpu_to_be32(open->op_recall);
2990
2991                 /*
2992                  * TODO: ACE's in delegations
2993                  */
2994                 *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
2995                 *p++ = cpu_to_be32(0);
2996                 *p++ = cpu_to_be32(0);
2997                 *p++ = cpu_to_be32(0);   /* XXX: is NULL principal ok? */
2998                 break;
2999         case NFS4_OPEN_DELEGATE_WRITE:
3000                 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
3001                 if (nfserr)
3002                         return nfserr;
3003                 p = xdr_reserve_space(xdr, 32);
3004                 if (!p)
3005                         return nfserr_resource;
3006                 *p++ = cpu_to_be32(0);
3007
3008                 /*
3009                  * TODO: space_limit's in delegations
3010                  */
3011                 *p++ = cpu_to_be32(NFS4_LIMIT_SIZE);
3012                 *p++ = cpu_to_be32(~(u32)0);
3013                 *p++ = cpu_to_be32(~(u32)0);
3014
3015                 /*
3016                  * TODO: ACE's in delegations
3017                  */
3018                 *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
3019                 *p++ = cpu_to_be32(0);
3020                 *p++ = cpu_to_be32(0);
3021                 *p++ = cpu_to_be32(0);   /* XXX: is NULL principal ok? */
3022                 break;
3023         case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */
3024                 switch (open->op_why_no_deleg) {
3025                 case WND4_CONTENTION:
3026                 case WND4_RESOURCE:
3027                         p = xdr_reserve_space(xdr, 8);
3028                         if (!p)
3029                                 return nfserr_resource;
3030                         *p++ = cpu_to_be32(open->op_why_no_deleg);
3031                         /* deleg signaling not supported yet: */
3032                         *p++ = cpu_to_be32(0);
3033                         break;
3034                 default:
3035                         p = xdr_reserve_space(xdr, 4);
3036                         if (!p)
3037                                 return nfserr_resource;
3038                         *p++ = cpu_to_be32(open->op_why_no_deleg);
3039                 }
3040                 break;
3041         default:
3042                 BUG();
3043         }
3044         /* XXX save filehandle here */
3045 out:
3046         return nfserr;
3047 }
3048
3049 static __be32
3050 nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc)
3051 {
3052         struct xdr_stream *xdr = &resp->xdr;
3053
3054         if (!nfserr)
3055                 nfserr = nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid);
3056
3057         return nfserr;
3058 }
3059
3060 static __be32
3061 nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od)
3062 {
3063         struct xdr_stream *xdr = &resp->xdr;
3064
3065         if (!nfserr)
3066                 nfserr = nfsd4_encode_stateid(xdr, &od->od_stateid);
3067
3068         return nfserr;
3069 }
3070
3071 static __be32 nfsd4_encode_splice_read(
3072                                 struct nfsd4_compoundres *resp,
3073                                 struct nfsd4_read *read,
3074                                 struct file *file, unsigned long maxcount)
3075 {
3076         struct xdr_stream *xdr = &resp->xdr;
3077         struct xdr_buf *buf = xdr->buf;
3078         u32 eof;
3079         int space_left;
3080         __be32 nfserr;
3081         __be32 *p = xdr->p - 2;
3082
3083         /* Make sure there will be room for padding if needed */
3084         if (xdr->end - xdr->p < 1)
3085                 return nfserr_resource;
3086
3087         nfserr = nfsd_splice_read(read->rd_rqstp, file,
3088                                   read->rd_offset, &maxcount);
3089         if (nfserr) {
3090                 /*
3091                  * nfsd_splice_actor may have already messed with the
3092                  * page length; reset it so as not to confuse
3093                  * xdr_truncate_encode:
3094                  */
3095                 buf->page_len = 0;
3096                 return nfserr;
3097         }
3098
3099         eof = (read->rd_offset + maxcount >=
3100                read->rd_fhp->fh_dentry->d_inode->i_size);
3101
3102         *(p++) = htonl(eof);
3103         *(p++) = htonl(maxcount);
3104
3105         buf->page_len = maxcount;
3106         buf->len += maxcount;
3107         xdr->page_ptr += (maxcount + PAGE_SIZE - 1) / PAGE_SIZE;
3108
3109         /* Use rest of head for padding and remaining ops: */
3110         buf->tail[0].iov_base = xdr->p;
3111         buf->tail[0].iov_len = 0;
3112         xdr->iov = buf->tail;
3113         if (maxcount&3) {
3114                 int pad = 4 - (maxcount&3);
3115
3116                 *(xdr->p++) = 0;
3117
3118                 buf->tail[0].iov_base += maxcount&3;
3119                 buf->tail[0].iov_len = pad;
3120                 buf->len += pad;
3121         }
3122
3123         space_left = min_t(int, (void *)xdr->end - (void *)xdr->p,
3124                                 buf->buflen - buf->len);
3125         buf->buflen = buf->len + space_left;
3126         xdr->end = (__be32 *)((void *)xdr->end + space_left);
3127
3128         return 0;
3129 }
3130
3131 static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp,
3132                                  struct nfsd4_read *read,
3133                                  struct file *file, unsigned long maxcount)
3134 {
3135         struct xdr_stream *xdr = &resp->xdr;
3136         u32 eof;
3137         int v;
3138         int starting_len = xdr->buf->len - 8;
3139         long len;
3140         int thislen;
3141         __be32 nfserr;
3142         __be32 tmp;
3143         __be32 *p;
3144         u32 zzz = 0;
3145         int pad;
3146
3147         len = maxcount;
3148         v = 0;
3149
3150         thislen = min_t(long, len, ((void *)xdr->end - (void *)xdr->p));
3151         p = xdr_reserve_space(xdr, (thislen+3)&~3);
3152         WARN_ON_ONCE(!p);
3153         resp->rqstp->rq_vec[v].iov_base = p;
3154         resp->rqstp->rq_vec[v].iov_len = thislen;
3155         v++;
3156         len -= thislen;
3157
3158         while (len) {
3159                 thislen = min_t(long, len, PAGE_SIZE);
3160                 p = xdr_reserve_space(xdr, (thislen+3)&~3);
3161                 WARN_ON_ONCE(!p);
3162                 resp->rqstp->rq_vec[v].iov_base = p;
3163                 resp->rqstp->rq_vec[v].iov_len = thislen;
3164                 v++;
3165                 len -= thislen;
3166         }
3167         read->rd_vlen = v;
3168
3169         nfserr = nfsd_readv(file, read->rd_offset, resp->rqstp->rq_vec,
3170                         read->rd_vlen, &maxcount);
3171         if (nfserr)
3172                 return nfserr;
3173         xdr_truncate_encode(xdr, starting_len + 8 + ((maxcount+3)&~3));
3174
3175         eof = (read->rd_offset + maxcount >=
3176                read->rd_fhp->fh_dentry->d_inode->i_size);
3177
3178         tmp = htonl(eof);
3179         write_bytes_to_xdr_buf(xdr->buf, starting_len    , &tmp, 4);
3180         tmp = htonl(maxcount);
3181         write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4);
3182
3183         pad = (maxcount&3) ? 4 - (maxcount&3) : 0;
3184         write_bytes_to_xdr_buf(xdr->buf, starting_len + 8 + maxcount,
3185                                                                 &zzz, pad);
3186         return 0;
3187
3188 }
3189
3190 static __be32
3191 nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,
3192                   struct nfsd4_read *read)
3193 {
3194         unsigned long maxcount;
3195         struct xdr_stream *xdr = &resp->xdr;
3196         struct file *file = read->rd_filp;
3197         int starting_len = xdr->buf->len;
3198         struct raparms *ra;
3199         __be32 *p;
3200         __be32 err;
3201
3202         if (nfserr)
3203                 return nfserr;
3204
3205         p = xdr_reserve_space(xdr, 8); /* eof flag and byte count */
3206         if (!p) {
3207                 WARN_ON_ONCE(resp->rqstp->rq_splice_ok);
3208                 return nfserr_resource;
3209         }
3210         if (resp->xdr.buf->page_len && resp->rqstp->rq_splice_ok) {
3211                 WARN_ON_ONCE(1);
3212                 return nfserr_resource;
3213         }
3214         xdr_commit_encode(xdr);
3215
3216         maxcount = svc_max_payload(resp->rqstp);
3217         maxcount = min_t(unsigned long, maxcount, (xdr->buf->buflen - xdr->buf->len));
3218         maxcount = min_t(unsigned long, maxcount, read->rd_length);
3219
3220         if (!read->rd_filp) {
3221                 err = nfsd_get_tmp_read_open(resp->rqstp, read->rd_fhp,
3222                                                 &file, &ra);
3223                 if (err)
3224                         goto err_truncate;
3225         }
3226
3227         if (file->f_op->splice_read && resp->rqstp->rq_splice_ok)
3228                 err = nfsd4_encode_splice_read(resp, read, file, maxcount);
3229         else
3230                 err = nfsd4_encode_readv(resp, read, file, maxcount);
3231
3232         if (!read->rd_filp)
3233                 nfsd_put_tmp_read_open(file, ra);
3234
3235 err_truncate:
3236         if (err)
3237                 xdr_truncate_encode(xdr, starting_len);
3238         return err;
3239 }
3240
3241 static __be32
3242 nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink)
3243 {
3244         int maxcount;
3245         __be32 wire_count;
3246         int zero = 0;
3247         struct xdr_stream *xdr = &resp->xdr;
3248         int length_offset = xdr->buf->len;
3249         __be32 *p;
3250
3251         if (nfserr)
3252                 return nfserr;
3253
3254         p = xdr_reserve_space(xdr, 4);
3255         if (!p)
3256                 return nfserr_resource;
3257         maxcount = PAGE_SIZE;
3258
3259         p = xdr_reserve_space(xdr, maxcount);
3260         if (!p)
3261                 return nfserr_resource;
3262         /*
3263          * XXX: By default, the ->readlink() VFS op will truncate symlinks
3264          * if they would overflow the buffer.  Is this kosher in NFSv4?  If
3265          * not, one easy fix is: if ->readlink() precisely fills the buffer,
3266          * assume that truncation occurred, and return NFS4ERR_RESOURCE.
3267          */
3268         nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp,
3269                                                 (char *)p, &maxcount);
3270         if (nfserr == nfserr_isdir)
3271                 nfserr = nfserr_inval;
3272         if (nfserr) {
3273                 xdr_truncate_encode(xdr, length_offset);
3274                 return nfserr;
3275         }
3276
3277         wire_count = htonl(maxcount);
3278         write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, 4);
3279         xdr_truncate_encode(xdr, length_offset + 4 + ALIGN(maxcount, 4));
3280         if (maxcount & 3)
3281                 write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount,
3282                                                 &zero, 4 - (maxcount&3));
3283         return 0;
3284 }
3285
3286 static __be32
3287 nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir)
3288 {
3289         int maxcount;
3290         int bytes_left;
3291         loff_t offset;
3292         __be64 wire_offset;
3293         struct xdr_stream *xdr = &resp->xdr;
3294         int starting_len = xdr->buf->len;
3295         __be32 *p;
3296
3297         if (nfserr)
3298                 return nfserr;
3299
3300         p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
3301         if (!p)
3302                 return nfserr_resource;
3303
3304         /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
3305         *p++ = cpu_to_be32(0);
3306         *p++ = cpu_to_be32(0);
3307         resp->xdr.buf->head[0].iov_len = ((char *)resp->xdr.p)
3308                                 - (char *)resp->xdr.buf->head[0].iov_base;
3309
3310         /*
3311          * Number of bytes left for directory entries allowing for the
3312          * final 8 bytes of the readdir and a following failed op:
3313          */
3314         bytes_left = xdr->buf->buflen - xdr->buf->len
3315                         - COMPOUND_ERR_SLACK_SPACE - 8;
3316         if (bytes_left < 0) {
3317                 nfserr = nfserr_resource;
3318                 goto err_no_verf;
3319         }
3320         maxcount = min_t(u32, readdir->rd_maxcount, INT_MAX);
3321         /*
3322          * Note the rfc defines rd_maxcount as the size of the
3323          * READDIR4resok structure, which includes the verifier above
3324          * and the 8 bytes encoded at the end of this function:
3325          */
3326         if (maxcount < 16) {
3327                 nfserr = nfserr_toosmall;
3328                 goto err_no_verf;
3329         }
3330         maxcount = min_t(int, maxcount-16, bytes_left);
3331
3332         /* RFC 3530 14.2.24 allows us to ignore dircount when it's 0: */
3333         if (!readdir->rd_dircount)
3334                 readdir->rd_dircount = INT_MAX;
3335
3336         readdir->xdr = xdr;
3337         readdir->rd_maxcount = maxcount;
3338         readdir->common.err = 0;
3339         readdir->cookie_offset = 0;
3340
3341         offset = readdir->rd_cookie;
3342         nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp,
3343                               &offset,
3344                               &readdir->common, nfsd4_encode_dirent);
3345         if (nfserr == nfs_ok &&
3346             readdir->common.err == nfserr_toosmall &&
3347             xdr->buf->len == starting_len + 8) {
3348                 /* nothing encoded; which limit did we hit?: */
3349                 if (maxcount - 16 < bytes_left)
3350                         /* It was the fault of rd_maxcount: */
3351                         nfserr = nfserr_toosmall;
3352                 else
3353                         /* We ran out of buffer space: */
3354                         nfserr = nfserr_resource;
3355         }
3356         if (nfserr)
3357                 goto err_no_verf;
3358
3359         if (readdir->cookie_offset) {
3360                 wire_offset = cpu_to_be64(offset);
3361                 write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset,
3362                                                         &wire_offset, 8);
3363         }
3364
3365         p = xdr_reserve_space(xdr, 8);
3366         if (!p) {
3367                 WARN_ON_ONCE(1);
3368                 goto err_no_verf;
3369         }
3370         *p++ = 0;       /* no more entries */
3371         *p++ = htonl(readdir->common.err == nfserr_eof);
3372
3373         return 0;
3374 err_no_verf:
3375         xdr_truncate_encode(xdr, starting_len);
3376         return nfserr;
3377 }
3378
3379 static __be32
3380 nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove)
3381 {
3382         struct xdr_stream *xdr = &resp->xdr;
3383         __be32 *p;
3384
3385         if (!nfserr) {
3386                 p = xdr_reserve_space(xdr, 20);
3387                 if (!p)
3388                         return nfserr_resource;
3389                 p = encode_cinfo(p, &remove->rm_cinfo);
3390         }
3391         return nfserr;
3392 }
3393
3394 static __be32
3395 nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename)
3396 {
3397         struct xdr_stream *xdr = &resp->xdr;
3398         __be32 *p;
3399
3400         if (!nfserr) {
3401                 p = xdr_reserve_space(xdr, 40);
3402                 if (!p)
3403                         return nfserr_resource;
3404                 p = encode_cinfo(p, &rename->rn_sinfo);
3405                 p = encode_cinfo(p, &rename->rn_tinfo);
3406         }
3407         return nfserr;
3408 }
3409
3410 static __be32
3411 nfsd4_do_encode_secinfo(struct xdr_stream *xdr,
3412                          __be32 nfserr, struct svc_export *exp)
3413 {
3414         u32 i, nflavs, supported;
3415         struct exp_flavor_info *flavs;
3416         struct exp_flavor_info def_flavs[2];
3417         __be32 *p, *flavorsp;
3418         static bool report = true;
3419
3420         if (nfserr)
3421                 goto out;
3422         nfserr = nfserr_resource;
3423         if (exp->ex_nflavors) {
3424                 flavs = exp->ex_flavors;
3425                 nflavs = exp->ex_nflavors;
3426         } else { /* Handling of some defaults in absence of real secinfo: */
3427                 flavs = def_flavs;
3428                 if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {
3429                         nflavs = 2;
3430                         flavs[0].pseudoflavor = RPC_AUTH_UNIX;
3431                         flavs[1].pseudoflavor = RPC_AUTH_NULL;
3432                 } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {
3433                         nflavs = 1;
3434                         flavs[0].pseudoflavor
3435                                         = svcauth_gss_flavor(exp->ex_client);
3436                 } else {
3437                         nflavs = 1;
3438                         flavs[0].pseudoflavor
3439                                         = exp->ex_client->flavour->flavour;
3440                 }
3441         }
3442
3443         supported = 0;
3444         p = xdr_reserve_space(xdr, 4);
3445         if (!p)
3446                 goto out;
3447         flavorsp = p++;         /* to be backfilled later */
3448
3449         for (i = 0; i < nflavs; i++) {
3450                 rpc_authflavor_t pf = flavs[i].pseudoflavor;
3451                 struct rpcsec_gss_info info;
3452
3453                 if (rpcauth_get_gssinfo(pf, &info) == 0) {
3454                         supported++;
3455                         p = xdr_reserve_space(xdr, 4 + 4 +
3456                                               XDR_LEN(info.oid.len) + 4 + 4);
3457                         if (!p)
3458                                 goto out;
3459                         *p++ = cpu_to_be32(RPC_AUTH_GSS);
3460                         p = xdr_encode_opaque(p,  info.oid.data, info.oid.len);
3461                         *p++ = cpu_to_be32(info.qop);
3462                         *p++ = cpu_to_be32(info.service);
3463                 } else if (pf < RPC_AUTH_MAXFLAVOR) {
3464                         supported++;
3465                         p = xdr_reserve_space(xdr, 4);
3466                         if (!p)
3467                                 goto out;
3468                         *p++ = cpu_to_be32(pf);
3469                 } else {
3470                         if (report)
3471                                 pr_warn("NFS: SECINFO: security flavor %u "
3472                                         "is not supported\n", pf);
3473                 }
3474         }
3475
3476         if (nflavs != supported)
3477                 report = false;
3478         *flavorsp = htonl(supported);
3479         nfserr = 0;
3480 out:
3481         if (exp)
3482                 exp_put(exp);
3483         return nfserr;
3484 }
3485
3486 static __be32
3487 nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
3488                      struct nfsd4_secinfo *secinfo)
3489 {
3490         struct xdr_stream *xdr = &resp->xdr;
3491
3492         return nfsd4_do_encode_secinfo(xdr, nfserr, secinfo->si_exp);
3493 }
3494
3495 static __be32
3496 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,
3497                      struct nfsd4_secinfo_no_name *secinfo)
3498 {
3499         struct xdr_stream *xdr = &resp->xdr;
3500
3501         return nfsd4_do_encode_secinfo(xdr, nfserr, secinfo->sin_exp);
3502 }
3503
3504 /*
3505  * The SETATTR encode routine is special -- it always encodes a bitmap,
3506  * regardless of the error status.
3507  */
3508 static __be32
3509 nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr)
3510 {
3511         struct xdr_stream *xdr = &resp->xdr;
3512         __be32 *p;
3513
3514         p = xdr_reserve_space(xdr, 16);
3515         if (!p)
3516                 return nfserr_resource;
3517         if (nfserr) {
3518                 *p++ = cpu_to_be32(3);
3519                 *p++ = cpu_to_be32(0);
3520                 *p++ = cpu_to_be32(0);
3521                 *p++ = cpu_to_be32(0);
3522         }
3523         else {
3524                 *p++ = cpu_to_be32(3);
3525                 *p++ = cpu_to_be32(setattr->sa_bmval[0]);
3526                 *p++ = cpu_to_be32(setattr->sa_bmval[1]);
3527                 *p++ = cpu_to_be32(setattr->sa_bmval[2]);
3528         }
3529         return nfserr;
3530 }
3531
3532 static __be32
3533 nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd)
3534 {
3535         struct xdr_stream *xdr = &resp->xdr;
3536         __be32 *p;
3537
3538         if (!nfserr) {
3539                 p = xdr_reserve_space(xdr, 8 + NFS4_VERIFIER_SIZE);
3540                 if (!p)
3541                         return nfserr_resource;
3542                 p = xdr_encode_opaque_fixed(p, &scd->se_clientid, 8);
3543                 p = xdr_encode_opaque_fixed(p, &scd->se_confirm,
3544                                                 NFS4_VERIFIER_SIZE);
3545         }
3546         else if (nfserr == nfserr_clid_inuse) {
3547                 p = xdr_reserve_space(xdr, 8);
3548                 if (!p)
3549                         return nfserr_resource;
3550                 *p++ = cpu_to_be32(0);
3551                 *p++ = cpu_to_be32(0);
3552         }
3553         return nfserr;
3554 }
3555
3556 static __be32
3557 nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write)
3558 {
3559         struct xdr_stream *xdr = &resp->xdr;
3560         __be32 *p;
3561
3562         if (!nfserr) {
3563                 p = xdr_reserve_space(xdr, 16);
3564                 if (!p)
3565                         return nfserr_resource;
3566                 *p++ = cpu_to_be32(write->wr_bytes_written);
3567                 *p++ = cpu_to_be32(write->wr_how_written);
3568                 p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
3569                                                         NFS4_VERIFIER_SIZE);
3570         }
3571         return nfserr;
3572 }
3573
3574 static const u32 nfs4_minimal_spo_must_enforce[2] = {
3575         [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
3576               1 << (OP_EXCHANGE_ID - 32) |
3577               1 << (OP_CREATE_SESSION - 32) |
3578               1 << (OP_DESTROY_SESSION - 32) |
3579               1 << (OP_DESTROY_CLIENTID - 32)
3580 };
3581
3582 static __be32
3583 nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
3584                          struct nfsd4_exchange_id *exid)
3585 {
3586         struct xdr_stream *xdr = &resp->xdr;
3587         __be32 *p;
3588         char *major_id;
3589         char *server_scope;
3590         int major_id_sz;
3591         int server_scope_sz;
3592         uint64_t minor_id = 0;
3593
3594         if (nfserr)
3595                 return nfserr;
3596
3597         major_id = utsname()->nodename;
3598         major_id_sz = strlen(major_id);
3599         server_scope = utsname()->nodename;
3600         server_scope_sz = strlen(server_scope);
3601
3602         p = xdr_reserve_space(xdr,
3603                 8 /* eir_clientid */ +
3604                 4 /* eir_sequenceid */ +
3605                 4 /* eir_flags */ +
3606                 4 /* spr_how */);
3607         if (!p)
3608                 return nfserr_resource;
3609
3610         p = xdr_encode_opaque_fixed(p, &exid->clientid, 8);
3611         *p++ = cpu_to_be32(exid->seqid);
3612         *p++ = cpu_to_be32(exid->flags);
3613
3614         *p++ = cpu_to_be32(exid->spa_how);
3615
3616         switch (exid->spa_how) {
3617         case SP4_NONE:
3618                 break;
3619         case SP4_MACH_CRED:
3620                 /* spo_must_enforce, spo_must_allow */
3621                 p = xdr_reserve_space(xdr, 16);
3622                 if (!p)
3623                         return nfserr_resource;
3624
3625                 /* spo_must_enforce bitmap: */
3626                 *p++ = cpu_to_be32(2);
3627                 *p++ = cpu_to_be32(nfs4_minimal_spo_must_enforce[0]);
3628                 *p++ = cpu_to_be32(nfs4_minimal_spo_must_enforce[1]);
3629                 /* empty spo_must_allow bitmap: */
3630                 *p++ = cpu_to_be32(0);
3631
3632                 break;
3633         default:
3634                 WARN_ON_ONCE(1);
3635         }
3636
3637         p = xdr_reserve_space(xdr,
3638                 8 /* so_minor_id */ +
3639                 4 /* so_major_id.len */ +
3640                 (XDR_QUADLEN(major_id_sz) * 4) +
3641                 4 /* eir_server_scope.len */ +
3642                 (XDR_QUADLEN(server_scope_sz) * 4) +
3643                 4 /* eir_server_impl_id.count (0) */);
3644         if (!p)
3645                 return nfserr_resource;
3646
3647         /* The server_owner struct */
3648         p = xdr_encode_hyper(p, minor_id);      /* Minor id */
3649         /* major id */
3650         p = xdr_encode_opaque(p, major_id, major_id_sz);
3651
3652         /* Server scope */
3653         p = xdr_encode_opaque(p, server_scope, server_scope_sz);
3654
3655         /* Implementation id */
3656         *p++ = cpu_to_be32(0);  /* zero length nfs_impl_id4 array */
3657         return 0;
3658 }
3659
3660 static __be32
3661 nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,
3662                             struct nfsd4_create_session *sess)
3663 {
3664         struct xdr_stream *xdr = &resp->xdr;
3665         __be32 *p;
3666
3667         if (nfserr)
3668                 return nfserr;
3669
3670         p = xdr_reserve_space(xdr, 24);
3671         if (!p)
3672                 return nfserr_resource;
3673         p = xdr_encode_opaque_fixed(p, sess->sessionid.data,
3674                                         NFS4_MAX_SESSIONID_LEN);
3675         *p++ = cpu_to_be32(sess->seqid);
3676         *p++ = cpu_to_be32(sess->flags);
3677
3678         p = xdr_reserve_space(xdr, 28);
3679         if (!p)
3680                 return nfserr_resource;
3681         *p++ = cpu_to_be32(0); /* headerpadsz */
3682         *p++ = cpu_to_be32(sess->fore_channel.maxreq_sz);
3683         *p++ = cpu_to_be32(sess->fore_channel.maxresp_sz);
3684         *p++ = cpu_to_be32(sess->fore_channel.maxresp_cached);
3685         *p++ = cpu_to_be32(sess->fore_channel.maxops);
3686         *p++ = cpu_to_be32(sess->fore_channel.maxreqs);
3687         *p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs);
3688
3689         if (sess->fore_channel.nr_rdma_attrs) {
3690                 p = xdr_reserve_space(xdr, 4);
3691                 if (!p)
3692                         return nfserr_resource;
3693                 *p++ = cpu_to_be32(sess->fore_channel.rdma_attrs);
3694         }
3695
3696         p = xdr_reserve_space(xdr, 28);
3697         if (!p)
3698                 return nfserr_resource;
3699         *p++ = cpu_to_be32(0); /* headerpadsz */
3700         *p++ = cpu_to_be32(sess->back_channel.maxreq_sz);
3701         *p++ = cpu_to_be32(sess->back_channel.maxresp_sz);
3702         *p++ = cpu_to_be32(sess->back_channel.maxresp_cached);
3703         *p++ = cpu_to_be32(sess->back_channel.maxops);
3704         *p++ = cpu_to_be32(sess->back_channel.maxreqs);
3705         *p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs);
3706
3707         if (sess->back_channel.nr_rdma_attrs) {
3708                 p = xdr_reserve_space(xdr, 4);
3709                 if (!p)
3710                         return nfserr_resource;
3711                 *p++ = cpu_to_be32(sess->back_channel.rdma_attrs);
3712         }
3713         return 0;
3714 }
3715
3716 static __be32
3717 nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,
3718                       struct nfsd4_sequence *seq)
3719 {
3720         struct xdr_stream *xdr = &resp->xdr;
3721         __be32 *p;
3722
3723         if (nfserr)
3724                 return nfserr;
3725
3726         p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 20);
3727         if (!p)
3728                 return nfserr_resource;
3729         p = xdr_encode_opaque_fixed(p, seq->sessionid.data,
3730                                         NFS4_MAX_SESSIONID_LEN);
3731         *p++ = cpu_to_be32(seq->seqid);
3732         *p++ = cpu_to_be32(seq->slotid);
3733         /* Note slotid's are numbered from zero: */
3734         *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */
3735         *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */
3736         *p++ = cpu_to_be32(seq->status_flags);
3737
3738         resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */
3739         return 0;
3740 }
3741
3742 static __be32
3743 nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,
3744                           struct nfsd4_test_stateid *test_stateid)
3745 {
3746         struct xdr_stream *xdr = &resp->xdr;
3747         struct nfsd4_test_stateid_id *stateid, *next;
3748         __be32 *p;
3749
3750         if (nfserr)
3751                 return nfserr;
3752
3753         p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids));
3754         if (!p)
3755                 return nfserr_resource;
3756         *p++ = htonl(test_stateid->ts_num_ids);
3757
3758         list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) {
3759                 *p++ = stateid->ts_id_status;
3760         }
3761
3762         return nfserr;
3763 }
3764
3765 static __be32
3766 nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p)
3767 {
3768         return nfserr;
3769 }
3770
3771 typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *);
3772
3773 /*
3774  * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
3775  * since we don't need to filter out obsolete ops as this is
3776  * done in the decoding phase.
3777  */
3778 static nfsd4_enc nfsd4_enc_ops[] = {
3779         [OP_ACCESS]             = (nfsd4_enc)nfsd4_encode_access,
3780         [OP_CLOSE]              = (nfsd4_enc)nfsd4_encode_close,
3781         [OP_COMMIT]             = (nfsd4_enc)nfsd4_encode_commit,
3782         [OP_CREATE]             = (nfsd4_enc)nfsd4_encode_create,
3783         [OP_DELEGPURGE]         = (nfsd4_enc)nfsd4_encode_noop,
3784         [OP_DELEGRETURN]        = (nfsd4_enc)nfsd4_encode_noop,
3785         [OP_GETATTR]            = (nfsd4_enc)nfsd4_encode_getattr,
3786         [OP_GETFH]              = (nfsd4_enc)nfsd4_encode_getfh,
3787         [OP_LINK]               = (nfsd4_enc)nfsd4_encode_link,
3788         [OP_LOCK]               = (nfsd4_enc)nfsd4_encode_lock,
3789         [OP_LOCKT]              = (nfsd4_enc)nfsd4_encode_lockt,
3790         [OP_LOCKU]              = (nfsd4_enc)nfsd4_encode_locku,
3791         [OP_LOOKUP]             = (nfsd4_enc)nfsd4_encode_noop,
3792         [OP_LOOKUPP]            = (nfsd4_enc)nfsd4_encode_noop,
3793         [OP_NVERIFY]            = (nfsd4_enc)nfsd4_encode_noop,
3794         [OP_OPEN]               = (nfsd4_enc)nfsd4_encode_open,
3795         [OP_OPENATTR]           = (nfsd4_enc)nfsd4_encode_noop,
3796         [OP_OPEN_CONFIRM]       = (nfsd4_enc)nfsd4_encode_open_confirm,
3797         [OP_OPEN_DOWNGRADE]     = (nfsd4_enc)nfsd4_encode_open_downgrade,
3798         [OP_PUTFH]              = (nfsd4_enc)nfsd4_encode_noop,
3799         [OP_PUTPUBFH]           = (nfsd4_enc)nfsd4_encode_noop,
3800         [OP_PUTROOTFH]          = (nfsd4_enc)nfsd4_encode_noop,
3801         [OP_READ]               = (nfsd4_enc)nfsd4_encode_read,
3802         [OP_READDIR]            = (nfsd4_enc)nfsd4_encode_readdir,
3803         [OP_READLINK]           = (nfsd4_enc)nfsd4_encode_readlink,
3804         [OP_REMOVE]             = (nfsd4_enc)nfsd4_encode_remove,
3805         [OP_RENAME]             = (nfsd4_enc)nfsd4_encode_rename,
3806         [OP_RENEW]              = (nfsd4_enc)nfsd4_encode_noop,
3807         [OP_RESTOREFH]          = (nfsd4_enc)nfsd4_encode_noop,
3808         [OP_SAVEFH]             = (nfsd4_enc)nfsd4_encode_noop,
3809         [OP_SECINFO]            = (nfsd4_enc)nfsd4_encode_secinfo,
3810         [OP_SETATTR]            = (nfsd4_enc)nfsd4_encode_setattr,
3811         [OP_SETCLIENTID]        = (nfsd4_enc)nfsd4_encode_setclientid,
3812         [OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop,
3813         [OP_VERIFY]             = (nfsd4_enc)nfsd4_encode_noop,
3814         [OP_WRITE]              = (nfsd4_enc)nfsd4_encode_write,
3815         [OP_RELEASE_LOCKOWNER]  = (nfsd4_enc)nfsd4_encode_noop,
3816
3817         /* NFSv4.1 operations */
3818         [OP_BACKCHANNEL_CTL]    = (nfsd4_enc)nfsd4_encode_noop,
3819         [OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session,
3820         [OP_EXCHANGE_ID]        = (nfsd4_enc)nfsd4_encode_exchange_id,
3821         [OP_CREATE_SESSION]     = (nfsd4_enc)nfsd4_encode_create_session,
3822         [OP_DESTROY_SESSION]    = (nfsd4_enc)nfsd4_encode_noop,
3823         [OP_FREE_STATEID]       = (nfsd4_enc)nfsd4_encode_noop,
3824         [OP_GET_DIR_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop,
3825         [OP_GETDEVICEINFO]      = (nfsd4_enc)nfsd4_encode_noop,
3826         [OP_GETDEVICELIST]      = (nfsd4_enc)nfsd4_encode_noop,
3827         [OP_LAYOUTCOMMIT]       = (nfsd4_enc)nfsd4_encode_noop,
3828         [OP_LAYOUTGET]          = (nfsd4_enc)nfsd4_encode_noop,
3829         [OP_LAYOUTRETURN]       = (nfsd4_enc)nfsd4_encode_noop,
3830         [OP_SECINFO_NO_NAME]    = (nfsd4_enc)nfsd4_encode_secinfo_no_name,
3831         [OP_SEQUENCE]           = (nfsd4_enc)nfsd4_encode_sequence,
3832         [OP_SET_SSV]            = (nfsd4_enc)nfsd4_encode_noop,
3833         [OP_TEST_STATEID]       = (nfsd4_enc)nfsd4_encode_test_stateid,
3834         [OP_WANT_DELEGATION]    = (nfsd4_enc)nfsd4_encode_noop,
3835         [OP_DESTROY_CLIENTID]   = (nfsd4_enc)nfsd4_encode_noop,
3836         [OP_RECLAIM_COMPLETE]   = (nfsd4_enc)nfsd4_encode_noop,
3837 };
3838
3839 /*
3840  * Calculate whether we still have space to encode repsize bytes.
3841  * There are two considerations:
3842  *     - For NFS versions >=4.1, the size of the reply must stay within
3843  *       session limits
3844  *     - For all NFS versions, we must stay within limited preallocated
3845  *       buffer space.
3846  *
3847  * This is called before the operation is processed, so can only provide
3848  * an upper estimate.  For some nonidempotent operations (such as
3849  * getattr), it's not necessarily a problem if that estimate is wrong,
3850  * as we can fail it after processing without significant side effects.
3851  */
3852 __be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize)
3853 {
3854         struct xdr_buf *buf = &resp->rqstp->rq_res;
3855         struct nfsd4_slot *slot = resp->cstate.slot;
3856
3857         if (buf->len + respsize <= buf->buflen)
3858                 return nfs_ok;
3859         if (!nfsd4_has_session(&resp->cstate))
3860                 return nfserr_resource;
3861         if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) {
3862                 WARN_ON_ONCE(1);
3863                 return nfserr_rep_too_big_to_cache;
3864         }
3865         return nfserr_rep_too_big;
3866 }
3867
3868 void
3869 nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
3870 {
3871         struct xdr_stream *xdr = &resp->xdr;
3872         struct nfs4_stateowner *so = resp->cstate.replay_owner;
3873         struct svc_rqst *rqstp = resp->rqstp;
3874         int post_err_offset;
3875         nfsd4_enc encoder;
3876         __be32 *p;
3877
3878         p = xdr_reserve_space(xdr, 8);
3879         if (!p) {
3880                 WARN_ON_ONCE(1);
3881                 return;
3882         }
3883         *p++ = cpu_to_be32(op->opnum);
3884         post_err_offset = xdr->buf->len;
3885
3886         if (op->opnum == OP_ILLEGAL)
3887                 goto status;
3888         BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||
3889                !nfsd4_enc_ops[op->opnum]);
3890         encoder = nfsd4_enc_ops[op->opnum];
3891         op->status = encoder(resp, op->status, &op->u);
3892         xdr_commit_encode(xdr);
3893
3894         /* nfsd4_check_resp_size guarantees enough room for error status */
3895         if (!op->status) {
3896                 int space_needed = 0;
3897                 if (!nfsd4_last_compound_op(rqstp))
3898                         space_needed = COMPOUND_ERR_SLACK_SPACE;
3899                 op->status = nfsd4_check_resp_size(resp, space_needed);
3900         }
3901         if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) {
3902                 struct nfsd4_slot *slot = resp->cstate.slot;
3903
3904                 if (slot->sl_flags & NFSD4_SLOT_CACHETHIS)
3905                         op->status = nfserr_rep_too_big_to_cache;
3906                 else
3907                         op->status = nfserr_rep_too_big;
3908         }
3909         if (op->status == nfserr_resource ||
3910             op->status == nfserr_rep_too_big ||
3911             op->status == nfserr_rep_too_big_to_cache) {
3912                 /*
3913                  * The operation may have already been encoded or
3914                  * partially encoded.  No op returns anything additional
3915                  * in the case of one of these three errors, so we can
3916                  * just truncate back to after the status.  But it's a
3917                  * bug if we had to do this on a non-idempotent op:
3918                  */
3919                 warn_on_nonidempotent_op(op);
3920                 xdr_truncate_encode(xdr, post_err_offset);
3921         }
3922         if (so) {
3923                 int len = xdr->buf->len - post_err_offset;
3924
3925                 so->so_replay.rp_status = op->status;
3926                 so->so_replay.rp_buflen = len;
3927                 read_bytes_from_xdr_buf(xdr->buf, post_err_offset,
3928                                                 so->so_replay.rp_buf, len);
3929         }
3930 status:
3931         /* Note that op->status is already in network byte order: */
3932         write_bytes_to_xdr_buf(xdr->buf, post_err_offset - 4, &op->status, 4);
3933 }
3934
3935 /*
3936  * Encode the reply stored in the stateowner reply cache
3937  *
3938  * XDR note: do not encode rp->rp_buflen: the buffer contains the
3939  * previously sent already encoded operation.
3940  */
3941 void
3942 nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op)
3943 {
3944         __be32 *p;
3945         struct nfs4_replay *rp = op->replay;
3946
3947         BUG_ON(!rp);
3948
3949         p = xdr_reserve_space(xdr, 8 + rp->rp_buflen);
3950         if (!p) {
3951                 WARN_ON_ONCE(1);
3952                 return;
3953         }
3954         *p++ = cpu_to_be32(op->opnum);
3955         *p++ = rp->rp_status;  /* already xdr'ed */
3956
3957         p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen);
3958 }
3959
3960 int
3961 nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)
3962 {
3963         return xdr_ressize_check(rqstp, p);
3964 }
3965
3966 int nfsd4_release_compoundargs(void *rq, __be32 *p, void *resp)
3967 {
3968         struct svc_rqst *rqstp = rq;
3969         struct nfsd4_compoundargs *args = rqstp->rq_argp;
3970
3971         if (args->ops != args->iops) {
3972                 kfree(args->ops);
3973                 args->ops = args->iops;
3974         }
3975         kfree(args->tmpp);
3976         args->tmpp = NULL;
3977         while (args->to_free) {
3978                 struct svcxdr_tmpbuf *tb = args->to_free;
3979                 args->to_free = tb->next;
3980                 kfree(tb);
3981         }
3982         return 1;
3983 }
3984
3985 int
3986 nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundargs *args)
3987 {
3988         if (rqstp->rq_arg.head[0].iov_len % 4) {
3989                 /* client is nuts */
3990                 dprintk("%s: compound not properly padded! (peeraddr=%pISc xid=0x%x)",
3991                         __func__, svc_addr(rqstp), be32_to_cpu(rqstp->rq_xid));
3992                 return 0;
3993         }
3994         args->p = p;
3995         args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len;
3996         args->pagelist = rqstp->rq_arg.pages;
3997         args->pagelen = rqstp->rq_arg.page_len;
3998         args->tmpp = NULL;
3999         args->to_free = NULL;
4000         args->ops = args->iops;
4001         args->rqstp = rqstp;
4002
4003         return !nfsd4_decode_compound(args);
4004 }
4005
4006 int
4007 nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundres *resp)
4008 {
4009         /*
4010          * All that remains is to write the tag and operation count...
4011          */
4012         struct xdr_buf *buf = resp->xdr.buf;
4013
4014         WARN_ON_ONCE(buf->len != buf->head[0].iov_len + buf->page_len +
4015                                  buf->tail[0].iov_len);
4016
4017         rqstp->rq_next_page = resp->xdr.page_ptr + 1;
4018
4019         p = resp->tagp;
4020         *p++ = htonl(resp->taglen);
4021         memcpy(p, resp->tag, resp->taglen);
4022         p += XDR_QUADLEN(resp->taglen);
4023         *p++ = htonl(resp->opcnt);
4024
4025         nfsd4_sequence_done(resp);
4026         return 1;
4027 }
4028
4029 /*
4030  * Local variables:
4031  *  c-basic-offset: 8
4032  * End:
4033  */