fs/nfsd/nfs3xdr.c

   1 /*
   2  * XDR support for nfsd/protocol version 3.
   3  *
   4  * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
   5  *
   6  * 2003-08-09 Jamie Lokier: Use htonl() for nanoseconds, not htons()!
   7  */
   8
   9 #include <linux/namei.h>
  10 #include "xdr3.h"
  11 #include "auth.h"
  12
  13 #define NFSDDBG_FACILITY                NFSDDBG_XDR
  14
  15
  16 /*
  17  * Mapping of S_IF* types to NFS file types
  18  */
  19 static u32      nfs3_ftypes[] = {
  20         NF3NON,  NF3FIFO, NF3CHR, NF3BAD,
  21         NF3DIR,  NF3BAD,  NF3BLK, NF3BAD,
  22         NF3REG,  NF3BAD,  NF3LNK, NF3BAD,
  23         NF3SOCK, NF3BAD,  NF3LNK, NF3BAD,
  24 };
  25
  26 /*
  27  * XDR functions for basic NFS types
  28  */
  29 static __be32 *
  30 encode_time3(__be32 *p, struct timespec *time)
  31 {
  32         *p++ = htonl((u32) time->tv_sec); *p++ = htonl(time->tv_nsec);
  33         return p;
  34 }
  35
  36 static __be32 *
  37 decode_time3(__be32 *p, struct timespec *time)
  38 {
  39         time->tv_sec = ntohl(*p++);
  40         time->tv_nsec = ntohl(*p++);
  41         return p;
  42 }
  43
  44 static __be32 *
  45 decode_fh(__be32 *p, struct svc_fh *fhp)
  46 {
  47         unsigned int size;
  48         fh_init(fhp, NFS3_FHSIZE);
  49         size = ntohl(*p++);
  50         if (size > NFS3_FHSIZE)
  51                 return NULL;
  52
  53         memcpy(&fhp->fh_handle.fh_base, p, size);
  54         fhp->fh_handle.fh_size = size;
  55         return p + XDR_QUADLEN(size);
  56 }
  57
  58 /* Helper function for NFSv3 ACL code */
  59 __be32 *nfs3svc_decode_fh(__be32 *p, struct svc_fh *fhp)
  60 {
  61         return decode_fh(p, fhp);
  62 }
  63
  64 static __be32 *
  65 encode_fh(__be32 *p, struct svc_fh *fhp)
  66 {
  67         unsigned int size = fhp->fh_handle.fh_size;
  68         *p++ = htonl(size);
  69         if (size) p[XDR_QUADLEN(size)-1]=0;
  70         memcpy(p, &fhp->fh_handle.fh_base, size);
  71         return p + XDR_QUADLEN(size);
  72 }
  73
  74 /*
  75  * Decode a file name and make sure that the path contains
  76  * no slashes or null bytes.
  77  */
  78 static __be32 *
  79 decode_filename(__be32 *p, char **namp, unsigned int *lenp)
  80 {
  81         char            *name;
  82         unsigned int    i;
  83
  84         if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS3_MAXNAMLEN)) != NULL) {
  85                 for (i = 0, name = *namp; i < *lenp; i++, name++) {
  86                         if (*name == '\0' || *name == '/')
  87                                 return NULL;
  88                 }
  89         }
  90
  91         return p;
  92 }
  93
  94 static __be32 *
  95 decode_sattr3(__be32 *p, struct iattr *iap)
  96 {
  97         u32     tmp;
  98
  99         iap->ia_valid = 0;
 100
 101         if (*p++) {
 102                 iap->ia_valid |= ATTR_MODE;
 103                 iap->ia_mode = ntohl(*p++);
 104         }
 105         if (*p++) {
 106                 iap->ia_valid |= ATTR_UID;
 107                 iap->ia_uid = ntohl(*p++);
 108         }
 109         if (*p++) {
 110                 iap->ia_valid |= ATTR_GID;
 111                 iap->ia_gid = ntohl(*p++);
 112         }
 113         if (*p++) {
 114                 u64     newsize;
 115
 116                 iap->ia_valid |= ATTR_SIZE;
 117                 p = xdr_decode_hyper(p, &newsize);
 118                 if (newsize <= NFS_OFFSET_MAX)
 119                         iap->ia_size = newsize;
 120                 else
 121                         iap->ia_size = NFS_OFFSET_MAX;
 122         }
 123         if ((tmp = ntohl(*p++)) == 1) { /* set to server time */
 124                 iap->ia_valid |= ATTR_ATIME;
 125         } else if (tmp == 2) {          /* set to client time */
 126                 iap->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET;
 127                 iap->ia_atime.tv_sec = ntohl(*p++);
 128                 iap->ia_atime.tv_nsec = ntohl(*p++);
 129         }
 130         if ((tmp = ntohl(*p++)) == 1) { /* set to server time */
 131                 iap->ia_valid |= ATTR_MTIME;
 132         } else if (tmp == 2) {          /* set to client time */
 133                 iap->ia_valid |= ATTR_MTIME | ATTR_MTIME_SET;
 134                 iap->ia_mtime.tv_sec = ntohl(*p++);
 135                 iap->ia_mtime.tv_nsec = ntohl(*p++);
 136         }
 137         return p;
 138 }
 139
 140 static __be32 *encode_fsid(__be32 *p, struct svc_fh *fhp)
 141 {
 142         u64 f;
 143         switch(fsid_source(fhp)) {
 144         default:
 145         case FSIDSOURCE_DEV:
 146                 p = xdr_encode_hyper(p, (u64)huge_encode_dev
 147                                      (fhp->fh_dentry->d_inode->i_sb->s_dev));
 148                 break;
 149         case FSIDSOURCE_FSID:
 150                 p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid);
 151                 break;
 152         case FSIDSOURCE_UUID:
 153                 f = ((u64*)fhp->fh_export->ex_uuid)[0];
 154                 f ^= ((u64*)fhp->fh_export->ex_uuid)[1];
 155                 p = xdr_encode_hyper(p, f);
 156                 break;
 157         }
 158         return p;
 159 }
 160
 161 static __be32 *
 162 encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
 163               struct kstat *stat)
 164 {
 165         *p++ = htonl(nfs3_ftypes[(stat->mode & S_IFMT) >> 12]);
 166         *p++ = htonl((u32) stat->mode);
 167         *p++ = htonl((u32) stat->nlink);
 168         *p++ = htonl((u32) nfsd_ruid(rqstp, stat->uid));
 169         *p++ = htonl((u32) nfsd_rgid(rqstp, stat->gid));
 170         if (S_ISLNK(stat->mode) && stat->size > NFS3_MAXPATHLEN) {
 171                 p = xdr_encode_hyper(p, (u64) NFS3_MAXPATHLEN);
 172         } else {
 173                 p = xdr_encode_hyper(p, (u64) stat->size);
 174         }
 175         p = xdr_encode_hyper(p, ((u64)stat->blocks) << 9);
 176         *p++ = htonl((u32) MAJOR(stat->rdev));
 177         *p++ = htonl((u32) MINOR(stat->rdev));
 178         p = encode_fsid(p, fhp);
 179         p = xdr_encode_hyper(p, stat->ino);
 180         p = encode_time3(p, &stat->atime);
 181         p = encode_time3(p, &stat->mtime);
 182         p = encode_time3(p, &stat->ctime);
 183
 184         return p;
 185 }
 186
 187 static __be32 *
 188 encode_saved_post_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
 189 {
 190         /* Attributes to follow */
 191         *p++ = xdr_one;
 192         return encode_fattr3(rqstp, p, fhp, &fhp->fh_post_attr);
 193 }
 194
 195 /*
 196  * Encode post-operation attributes.
 197  * The inode may be NULL if the call failed because of a stale file
 198  * handle. In this case, no attributes are returned.
 199  */
 200 static __be32 *
 201 encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
 202 {
 203         struct dentry *dentry = fhp->fh_dentry;
 204         if (dentry && dentry->d_inode) {
 205                 int err;
 206                 struct kstat stat;
 207
 208                 err = vfs_getattr(fhp->fh_export->ex_path.mnt, dentry, &stat);
 209                 if (!err) {
 210                         *p++ = xdr_one;         /* attributes follow */
 211                         lease_get_mtime(dentry->d_inode, &stat.mtime);
 212                         return encode_fattr3(rqstp, p, fhp, &stat);
 213                 }
 214         }
 215         *p++ = xdr_zero;
 216         return p;
 217 }
 218
 219 /* Helper for NFSv3 ACLs */
 220 __be32 *
 221 nfs3svc_encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
 222 {
 223         return encode_post_op_attr(rqstp, p, fhp);
 224 }
 225
 226 /*
 227  * Enocde weak cache consistency data
 228  */
 229 static __be32 *
 230 encode_wcc_data(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
 231 {
 232         struct dentry   *dentry = fhp->fh_dentry;
 233
 234         if (dentry && dentry->d_inode && fhp->fh_post_saved) {
 235                 if (fhp->fh_pre_saved) {
 236                         *p++ = xdr_one;
 237                         p = xdr_encode_hyper(p, (u64) fhp->fh_pre_size);
 238                         p = encode_time3(p, &fhp->fh_pre_mtime);
 239                         p = encode_time3(p, &fhp->fh_pre_ctime);
 240                 } else {
 241                         *p++ = xdr_zero;
 242                 }
 243                 return encode_saved_post_attr(rqstp, p, fhp);
 244         }
 245         /* no pre- or post-attrs */
 246         *p++ = xdr_zero;
 247         return encode_post_op_attr(rqstp, p, fhp);
 248 }
 249
 250 /*
 251  * Fill in the post_op attr for the wcc data
 252  */
 253 void fill_post_wcc(struct svc_fh *fhp)
 254 {
 255         int err;
 256
 257         if (fhp->fh_post_saved)
 258                 printk("nfsd: inode locked twice during operation.\n");
 259
 260         err = vfs_getattr(fhp->fh_export->ex_path.mnt, fhp->fh_dentry,
 261                         &fhp->fh_post_attr);
 262         fhp->fh_post_change = fhp->fh_dentry->d_inode->i_version;
 263         if (err) {
 264                 fhp->fh_post_saved = 0;
 265                 /* Grab the ctime anyway - set_change_info might use it */
 266                 fhp->fh_post_attr.ctime = fhp->fh_dentry->d_inode->i_ctime;
 267         } else
 268                 fhp->fh_post_saved = 1;
 269 }
 270
 271 /*
 272  * XDR decode functions
 273  */
 274 int
 275 nfs3svc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p, struct nfsd_fhandle *args)
 276 {
 277         if (!(p = decode_fh(p, &args->fh)))
 278                 return 0;
 279         return xdr_argsize_check(rqstp, p);
 280 }
 281
 282 int
 283 nfs3svc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p,
 284                                         struct nfsd3_sattrargs *args)
 285 {
 286         if (!(p = decode_fh(p, &args->fh)))
 287                 return 0;
 288         p = decode_sattr3(p, &args->attrs);
 289
 290         if ((args->check_guard = ntohl(*p++)) != 0) {
 291                 struct timespec time;
 292                 p = decode_time3(p, &time);
 293                 args->guardtime = time.tv_sec;
 294         }
 295
 296         return xdr_argsize_check(rqstp, p);
 297 }
 298
 299 int
 300 nfs3svc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p,
 301                                         struct nfsd3_diropargs *args)
 302 {
 303         if (!(p = decode_fh(p, &args->fh))
 304          || !(p = decode_filename(p, &args->name, &args->len)))
 305                 return 0;
 306
 307         return xdr_argsize_check(rqstp, p);
 308 }
 309
 310 int
 311 nfs3svc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p,
 312                                         struct nfsd3_accessargs *args)
 313 {
 314         if (!(p = decode_fh(p, &args->fh)))
 315                 return 0;
 316         args->access = ntohl(*p++);
 317
 318         return xdr_argsize_check(rqstp, p);
 319 }
 320
 321 int
 322 nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
 323                                         struct nfsd3_readargs *args)
 324 {
 325         unsigned int len;
 326         int v,pn;
 327         u32 max_blocksize = svc_max_payload(rqstp);
 328
 329         if (!(p = decode_fh(p, &args->fh)))
 330                 return 0;
 331         p = xdr_decode_hyper(p, &args->offset);
 332
 333         len = args->count = ntohl(*p++);
 334
 335         if (len > max_blocksize)
 336                 len = max_blocksize;
 337
 338         /* set up the kvec */
 339         v=0;
 340         while (len > 0) {
 341                 pn = rqstp->rq_resused++;
 342                 rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_respages[pn]);
 343                 rqstp->rq_vec[v].iov_len = len < PAGE_SIZE? len : PAGE_SIZE;
 344                 len -= rqstp->rq_vec[v].iov_len;
 345                 v++;
 346         }
 347         args->vlen = v;
 348         return xdr_argsize_check(rqstp, p);
 349 }
 350
 351 int
 352 nfs3svc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p,
 353                                         struct nfsd3_writeargs *args)
 354 {
 355         unsigned int len, v, hdr, dlen;
 356         u32 max_blocksize = svc_max_payload(rqstp);
 357
 358         if (!(p = decode_fh(p, &args->fh)))
 359                 return 0;
 360         p = xdr_decode_hyper(p, &args->offset);
 361
 362         args->count = ntohl(*p++);
 363         args->stable = ntohl(*p++);
 364         len = args->len = ntohl(*p++);
 365         /*
 366          * The count must equal the amount of data passed.
 367          */
 368         if (args->count != args->len)
 369                 return 0;
 370
 371         /*
 372          * Check to make sure that we got the right number of
 373          * bytes.
 374          */
 375         hdr = (void*)p - rqstp->rq_arg.head[0].iov_base;
 376         dlen = rqstp->rq_arg.head[0].iov_len + rqstp->rq_arg.page_len
 377                 - hdr;
 378         /*
 379          * Round the length of the data which was specified up to
 380          * the next multiple of XDR units and then compare that
 381          * against the length which was actually received.
 382          * Note that when RPCSEC/GSS (for example) is used, the
 383          * data buffer can be padded so dlen might be larger
 384          * than required.  It must never be smaller.
 385          */
 386         if (dlen < XDR_QUADLEN(len)*4)
 387                 return 0;
 388
 389         if (args->count > max_blocksize) {
 390                 args->count = max_blocksize;
 391                 len = args->len = max_blocksize;
 392         }
 393         rqstp->rq_vec[0].iov_base = (void*)p;
 394         rqstp->rq_vec[0].iov_len = rqstp->rq_arg.head[0].iov_len - hdr;
 395         v = 0;
 396         while (len > rqstp->rq_vec[v].iov_len) {
 397                 len -= rqstp->rq_vec[v].iov_len;
 398                 v++;
 399                 rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_pages[v]);
 400                 rqstp->rq_vec[v].iov_len = PAGE_SIZE;
 401         }
 402         rqstp->rq_vec[v].iov_len = len;
 403         args->vlen = v + 1;
 404         return 1;
 405 }
 406
 407 int
 408 nfs3svc_decode_createargs(struct svc_rqst *rqstp, __be32 *p,
 409                                         struct nfsd3_createargs *args)
 410 {
 411         if (!(p = decode_fh(p, &args->fh))
 412          || !(p = decode_filename(p, &args->name, &args->len)))
 413                 return 0;
 414
 415         switch (args->createmode = ntohl(*p++)) {
 416         case NFS3_CREATE_UNCHECKED:
 417         case NFS3_CREATE_GUARDED:
 418                 p = decode_sattr3(p, &args->attrs);
 419                 break;
 420         case NFS3_CREATE_EXCLUSIVE:
 421                 args->verf = p;
 422                 p += 2;
 423                 break;
 424         default:
 425                 return 0;
 426         }
 427
 428         return xdr_argsize_check(rqstp, p);
 429 }
 430 int
 431 nfs3svc_decode_mkdirargs(struct svc_rqst *rqstp, __be32 *p,
 432                                         struct nfsd3_createargs *args)
 433 {
 434         if (!(p = decode_fh(p, &args->fh)) ||
 435             !(p = decode_filename(p, &args->name, &args->len)))
 436                 return 0;
 437         p = decode_sattr3(p, &args->attrs);
 438
 439         return xdr_argsize_check(rqstp, p);
 440 }
 441
 442 int
 443 nfs3svc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p,
 444                                         struct nfsd3_symlinkargs *args)
 445 {
 446         unsigned int len, avail;
 447         char *old, *new;
 448         struct kvec *vec;
 449
 450         if (!(p = decode_fh(p, &args->ffh)) ||
 451             !(p = decode_filename(p, &args->fname, &args->flen))
 452                 )
 453                 return 0;
 454         p = decode_sattr3(p, &args->attrs);
 455
 456         /* now decode the pathname, which might be larger than the first page.
 457          * As we have to check for nul's anyway, we copy it into a new page
 458          * This page appears in the rq_res.pages list, but as pages_len is always
 459          * 0, it won't get in the way
 460          */
 461         len = ntohl(*p++);
 462         if (len == 0 || len > NFS3_MAXPATHLEN || len >= PAGE_SIZE)
 463                 return 0;
 464         args->tname = new =
 465                 page_address(rqstp->rq_respages[rqstp->rq_resused++]);
 466         args->tlen = len;
 467         /* first copy and check from the first page */
 468         old = (char*)p;
 469         vec = &rqstp->rq_arg.head[0];
 470         avail = vec->iov_len - (old - (char*)vec->iov_base);
 471         while (len && avail && *old) {
 472                 *new++ = *old++;
 473                 len--;
 474                 avail--;
 475         }
 476         /* now copy next page if there is one */
 477         if (len && !avail && rqstp->rq_arg.page_len) {
 478                 avail = rqstp->rq_arg.page_len;
 479                 if (avail > PAGE_SIZE)
 480                         avail = PAGE_SIZE;
 481                 old = page_address(rqstp->rq_arg.pages[0]);
 482         }
 483         while (len && avail && *old) {
 484                 *new++ = *old++;
 485                 len--;
 486                 avail--;
 487         }
 488         *new = '\0';
 489         if (len)
 490                 return 0;
 491
 492         return 1;
 493 }
 494
 495 int
 496 nfs3svc_decode_mknodargs(struct svc_rqst *rqstp, __be32 *p,
 497                                         struct nfsd3_mknodargs *args)
 498 {
 499         if (!(p = decode_fh(p, &args->fh))
 500          || !(p = decode_filename(p, &args->name, &args->len)))
 501                 return 0;
 502
 503         args->ftype = ntohl(*p++);
 504
 505         if (args->ftype == NF3BLK  || args->ftype == NF3CHR
 506          || args->ftype == NF3SOCK || args->ftype == NF3FIFO)
 507                 p = decode_sattr3(p, &args->attrs);
 508
 509         if (args->ftype == NF3BLK || args->ftype == NF3CHR) {
 510                 args->major = ntohl(*p++);
 511                 args->minor = ntohl(*p++);
 512         }
 513
 514         return xdr_argsize_check(rqstp, p);
 515 }
 516
 517 int
 518 nfs3svc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p,
 519                                         struct nfsd3_renameargs *args)
 520 {
 521         if (!(p = decode_fh(p, &args->ffh))
 522          || !(p = decode_filename(p, &args->fname, &args->flen))
 523          || !(p = decode_fh(p, &args->tfh))
 524          || !(p = decode_filename(p, &args->tname, &args->tlen)))
 525                 return 0;
 526
 527         return xdr_argsize_check(rqstp, p);
 528 }
 529
 530 int
 531 nfs3svc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p,
 532                                         struct nfsd3_readlinkargs *args)
 533 {
 534         if (!(p = decode_fh(p, &args->fh)))
 535                 return 0;
 536         args->buffer =
 537                 page_address(rqstp->rq_respages[rqstp->rq_resused++]);
 538
 539         return xdr_argsize_check(rqstp, p);
 540 }
 541
 542 int
 543 nfs3svc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p,
 544                                         struct nfsd3_linkargs *args)
 545 {
 546         if (!(p = decode_fh(p, &args->ffh))
 547          || !(p = decode_fh(p, &args->tfh))
 548          || !(p = decode_filename(p, &args->tname, &args->tlen)))
 549                 return 0;
 550
 551         return xdr_argsize_check(rqstp, p);
 552 }
 553
 554 int
 555 nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p,
 556                                         struct nfsd3_readdirargs *args)
 557 {
 558         if (!(p = decode_fh(p, &args->fh)))
 559                 return 0;
 560         p = xdr_decode_hyper(p, &args->cookie);
 561         args->verf   = p; p += 2;
 562         args->dircount = ~0;
 563         args->count  = ntohl(*p++);
 564
 565         if (args->count > PAGE_SIZE)
 566                 args->count = PAGE_SIZE;
 567
 568         args->buffer =
 569                 page_address(rqstp->rq_respages[rqstp->rq_resused++]);
 570
 571         return xdr_argsize_check(rqstp, p);
 572 }
 573
 574 int
 575 nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p,
 576                                         struct nfsd3_readdirargs *args)
 577 {
 578         int len, pn;
 579         u32 max_blocksize = svc_max_payload(rqstp);
 580
 581         if (!(p = decode_fh(p, &args->fh)))
 582                 return 0;
 583         p = xdr_decode_hyper(p, &args->cookie);
 584         args->verf     = p; p += 2;
 585         args->dircount = ntohl(*p++);
 586         args->count    = ntohl(*p++);
 587
 588         len = (args->count > max_blocksize) ? max_blocksize :
 589                                                   args->count;
 590         args->count = len;
 591
 592         while (len > 0) {
 593                 pn = rqstp->rq_resused++;
 594                 if (!args->buffer)
 595                         args->buffer = page_address(rqstp->rq_respages[pn]);
 596                 len -= PAGE_SIZE;
 597         }
 598
 599         return xdr_argsize_check(rqstp, p);
 600 }
 601
 602 int
 603 nfs3svc_decode_commitargs(struct svc_rqst *rqstp, __be32 *p,
 604                                         struct nfsd3_commitargs *args)
 605 {
 606         if (!(p = decode_fh(p, &args->fh)))
 607                 return 0;
 608         p = xdr_decode_hyper(p, &args->offset);
 609         args->count = ntohl(*p++);
 610
 611         return xdr_argsize_check(rqstp, p);
 612 }
 613
 614 /*
 615  * XDR encode functions
 616  */
 617 /*
 618  * There must be an encoding function for void results so svc_process
 619  * will work properly.
 620  */
 621 int
 622 nfs3svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)
 623 {
 624         return xdr_ressize_check(rqstp, p);
 625 }
 626
 627 /* GETATTR */
 628 int
 629 nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p,
 630                                         struct nfsd3_attrstat *resp)
 631 {
 632         if (resp->status == 0) {
 633                 lease_get_mtime(resp->fh.fh_dentry->d_inode,
 634                                 &resp->stat.mtime);
 635                 p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat);
 636         }
 637         return xdr_ressize_check(rqstp, p);
 638 }
 639
 640 /* SETATTR, REMOVE, RMDIR */
 641 int
 642 nfs3svc_encode_wccstat(struct svc_rqst *rqstp, __be32 *p,
 643                                         struct nfsd3_attrstat *resp)
 644 {
 645         p = encode_wcc_data(rqstp, p, &resp->fh);
 646         return xdr_ressize_check(rqstp, p);
 647 }
 648
 649 /* LOOKUP */
 650 int
 651 nfs3svc_encode_diropres(struct svc_rqst *rqstp, __be32 *p,
 652                                         struct nfsd3_diropres *resp)
 653 {
 654         if (resp->status == 0) {
 655                 p = encode_fh(p, &resp->fh);
 656                 p = encode_post_op_attr(rqstp, p, &resp->fh);
 657         }
 658         p = encode_post_op_attr(rqstp, p, &resp->dirfh);
 659         return xdr_ressize_check(rqstp, p);
 660 }
 661
 662 /* ACCESS */
 663 int
 664 nfs3svc_encode_accessres(struct svc_rqst *rqstp, __be32 *p,
 665                                         struct nfsd3_accessres *resp)
 666 {
 667         p = encode_post_op_attr(rqstp, p, &resp->fh);
 668         if (resp->status == 0)
 669                 *p++ = htonl(resp->access);
 670         return xdr_ressize_check(rqstp, p);
 671 }
 672
 673 /* READLINK */
 674 int
 675 nfs3svc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p,
 676                                         struct nfsd3_readlinkres *resp)
 677 {
 678         p = encode_post_op_attr(rqstp, p, &resp->fh);
 679         if (resp->status == 0) {
 680                 *p++ = htonl(resp->len);
 681                 xdr_ressize_check(rqstp, p);
 682                 rqstp->rq_res.page_len = resp->len;
 683                 if (resp->len & 3) {
 684                         /* need to pad the tail */
 685                         rqstp->rq_res.tail[0].iov_base = p;
 686                         *p = 0;
 687                         rqstp->rq_res.tail[0].iov_len = 4 - (resp->len&3);
 688                 }
 689                 return 1;
 690         } else
 691                 return xdr_ressize_check(rqstp, p);
 692 }
 693
 694 /* READ */
 695 int
 696 nfs3svc_encode_readres(struct svc_rqst *rqstp, __be32 *p,
 697                                         struct nfsd3_readres *resp)
 698 {
 699         p = encode_post_op_attr(rqstp, p, &resp->fh);
 700         if (resp->status == 0) {
 701                 *p++ = htonl(resp->count);
 702                 *p++ = htonl(resp->eof);
 703                 *p++ = htonl(resp->count);      /* xdr opaque count */
 704                 xdr_ressize_check(rqstp, p);
 705                 /* now update rqstp->rq_res to reflect data as well */
 706                 rqstp->rq_res.page_len = resp->count;
 707                 if (resp->count & 3) {
 708                         /* need to pad the tail */
 709                         rqstp->rq_res.tail[0].iov_base = p;
 710                         *p = 0;
 711                         rqstp->rq_res.tail[0].iov_len = 4 - (resp->count & 3);
 712                 }
 713                 return 1;
 714         } else
 715                 return xdr_ressize_check(rqstp, p);
 716 }
 717
 718 /* WRITE */
 719 int
 720 nfs3svc_encode_writeres(struct svc_rqst *rqstp, __be32 *p,
 721                                         struct nfsd3_writeres *resp)
 722 {
 723         p = encode_wcc_data(rqstp, p, &resp->fh);
 724         if (resp->status == 0) {
 725                 *p++ = htonl(resp->count);
 726                 *p++ = htonl(resp->committed);
 727                 *p++ = htonl(nfssvc_boot.tv_sec);
 728                 *p++ = htonl(nfssvc_boot.tv_usec);
 729         }
 730         return xdr_ressize_check(rqstp, p);
 731 }
 732
 733 /* CREATE, MKDIR, SYMLINK, MKNOD */
 734 int
 735 nfs3svc_encode_createres(struct svc_rqst *rqstp, __be32 *p,
 736                                         struct nfsd3_diropres *resp)
 737 {
 738         if (resp->status == 0) {
 739                 *p++ = xdr_one;
 740                 p = encode_fh(p, &resp->fh);
 741                 p = encode_post_op_attr(rqstp, p, &resp->fh);
 742         }
 743         p = encode_wcc_data(rqstp, p, &resp->dirfh);
 744         return xdr_ressize_check(rqstp, p);
 745 }
 746
 747 /* RENAME */
 748 int
 749 nfs3svc_encode_renameres(struct svc_rqst *rqstp, __be32 *p,
 750                                         struct nfsd3_renameres *resp)
 751 {
 752         p = encode_wcc_data(rqstp, p, &resp->ffh);
 753         p = encode_wcc_data(rqstp, p, &resp->tfh);
 754         return xdr_ressize_check(rqstp, p);
 755 }
 756
 757 /* LINK */
 758 int
 759 nfs3svc_encode_linkres(struct svc_rqst *rqstp, __be32 *p,
 760                                         struct nfsd3_linkres *resp)
 761 {
 762         p = encode_post_op_attr(rqstp, p, &resp->fh);
 763         p = encode_wcc_data(rqstp, p, &resp->tfh);
 764         return xdr_ressize_check(rqstp, p);
 765 }
 766
 767 /* READDIR */
 768 int
 769 nfs3svc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p,
 770                                         struct nfsd3_readdirres *resp)
 771 {
 772         p = encode_post_op_attr(rqstp, p, &resp->fh);
 773
 774         if (resp->status == 0) {
 775                 /* stupid readdir cookie */
 776                 memcpy(p, resp->verf, 8); p += 2;
 777                 xdr_ressize_check(rqstp, p);
 778                 if (rqstp->rq_res.head[0].iov_len + (2<<2) > PAGE_SIZE)
 779                         return 1; /*No room for trailer */
 780                 rqstp->rq_res.page_len = (resp->count) << 2;
 781
 782                 /* add the 'tail' to the end of the 'head' page - page 0. */
 783                 rqstp->rq_res.tail[0].iov_base = p;
 784                 *p++ = 0;               /* no more entries */
 785                 *p++ = htonl(resp->common.err == nfserr_eof);
 786                 rqstp->rq_res.tail[0].iov_len = 2<<2;
 787                 return 1;
 788         } else
 789                 return xdr_ressize_check(rqstp, p);
 790 }
 791
 792 static __be32 *
 793 encode_entry_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name,
 794              int namlen, u64 ino)
 795 {
 796         *p++ = xdr_one;                          /* mark entry present */
 797         p    = xdr_encode_hyper(p, ino);         /* file id */
 798         p    = xdr_encode_array(p, name, namlen);/* name length & name */
 799
 800         cd->offset = p;                         /* remember pointer */
 801         p = xdr_encode_hyper(p, NFS_OFFSET_MAX);/* offset of next entry */
 802
 803         return p;
 804 }
 805
 806 static int
 807 compose_entry_fh(struct nfsd3_readdirres *cd, struct svc_fh *fhp,
 808                 const char *name, int namlen)
 809 {
 810         struct svc_export       *exp;
 811         struct dentry           *dparent, *dchild;
 812         int rv = 0;
 813
 814         dparent = cd->fh.fh_dentry;
 815         exp  = cd->fh.fh_export;
 816
 817         if (isdotent(name, namlen)) {
 818                 if (namlen == 2) {
 819                         dchild = dget_parent(dparent);
 820                         if (dchild == dparent) {
 821                                 /* filesystem root - cannot return filehandle for ".." */
 822                                 dput(dchild);
 823                                 return -ENOENT;
 824                         }
 825                 } else
 826                         dchild = dget(dparent);
 827         } else
 828                 dchild = lookup_one_len(name, dparent, namlen);
 829         if (IS_ERR(dchild))
 830                 return -ENOENT;
 831         rv = -ENOENT;
 832         if (d_mountpoint(dchild))
 833                 goto out;
 834         rv = fh_compose(fhp, exp, dchild, &cd->fh);
 835         if (rv)
 836                 goto out;
 837         if (!dchild->d_inode)
 838                 goto out;
 839         rv = 0;
 840 out:
 841         dput(dchild);
 842         return rv;
 843 }
 844
 845 static __be32 *encode_entryplus_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name, int namlen)
 846 {
 847         struct svc_fh   fh;
 848         int err;
 849
 850         fh_init(&fh, NFS3_FHSIZE);
 851         err = compose_entry_fh(cd, &fh, name, namlen);
 852         if (err) {
 853                 *p++ = 0;
 854                 *p++ = 0;
 855                 goto out;
 856         }
 857         p = encode_post_op_attr(cd->rqstp, p, &fh);
 858         *p++ = xdr_one;                 /* yes, a file handle follows */
 859         p = encode_fh(p, &fh);
 860 out:
 861         fh_put(&fh);
 862         return p;
 863 }
 864
 865 /*
 866  * Encode a directory entry. This one works for both normal readdir
 867  * and readdirplus.
 868  * The normal readdir reply requires 2 (fileid) + 1 (stringlen)
 869  * + string + 2 (cookie) + 1 (next) words, i.e. 6 + strlen.
 870  *
 871  * The readdirplus baggage is 1+21 words for post_op_attr, plus the
 872  * file handle.
 873  */
 874
 875 #define NFS3_ENTRY_BAGGAGE      (2 + 1 + 2 + 1)
 876 #define NFS3_ENTRYPLUS_BAGGAGE  (1 + 21 + 1 + (NFS3_FHSIZE >> 2))
 877 static int
 878 encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
 879              loff_t offset, u64 ino, unsigned int d_type, int plus)
 880 {
 881         struct nfsd3_readdirres *cd = container_of(ccd, struct nfsd3_readdirres,
 882                                                         common);
 883         __be32          *p = cd->buffer;
 884         caddr_t         curr_page_addr = NULL;
 885         int             pn;             /* current page number */
 886         int             slen;           /* string (name) length */
 887         int             elen;           /* estimated entry length in words */
 888         int             num_entry_words = 0;    /* actual number of words */
 889
 890         if (cd->offset) {
 891                 u64 offset64 = offset;
 892
 893                 if (unlikely(cd->offset1)) {
 894                         /* we ended up with offset on a page boundary */
 895                         *cd->offset = htonl(offset64 >> 32);
 896                         *cd->offset1 = htonl(offset64 & 0xffffffff);
 897                         cd->offset1 = NULL;
 898                 } else {
 899                         xdr_encode_hyper(cd->offset, offset64);
 900                 }
 901         }
 902
 903         /*
 904         dprintk("encode_entry(%.*s @%ld%s)\n",
 905                 namlen, name, (long) offset, plus? " plus" : "");
 906          */
 907
 908         /* truncate filename if too long */
 909         if (namlen > NFS3_MAXNAMLEN)
 910                 namlen = NFS3_MAXNAMLEN;
 911
 912         slen = XDR_QUADLEN(namlen);
 913         elen = slen + NFS3_ENTRY_BAGGAGE
 914                 + (plus? NFS3_ENTRYPLUS_BAGGAGE : 0);
 915
 916         if (cd->buflen < elen) {
 917                 cd->common.err = nfserr_toosmall;
 918                 return -EINVAL;
 919         }
 920
 921         /* determine which page in rq_respages[] we are currently filling */
 922         for (pn=1; pn < cd->rqstp->rq_resused; pn++) {
 923                 curr_page_addr = page_address(cd->rqstp->rq_respages[pn]);
 924
 925                 if (((caddr_t)cd->buffer >= curr_page_addr) &&
 926                     ((caddr_t)cd->buffer <  curr_page_addr + PAGE_SIZE))
 927                         break;
 928         }
 929
 930         if ((caddr_t)(cd->buffer + elen) < (curr_page_addr + PAGE_SIZE)) {
 931                 /* encode entry in current page */
 932
 933                 p = encode_entry_baggage(cd, p, name, namlen, ino);
 934
 935                 if (plus)
 936                         p = encode_entryplus_baggage(cd, p, name, namlen);
 937                 num_entry_words = p - cd->buffer;
 938         } else if (cd->rqstp->rq_respages[pn+1] != NULL) {
 939                 /* temporarily encode entry into next page, then move back to
 940                  * current and next page in rq_respages[] */
 941                 __be32 *p1, *tmp;
 942                 int len1, len2;
 943
 944                 /* grab next page for temporary storage of entry */
 945                 p1 = tmp = page_address(cd->rqstp->rq_respages[pn+1]);
 946
 947                 p1 = encode_entry_baggage(cd, p1, name, namlen, ino);
 948
 949                 if (plus)
 950                         p1 = encode_entryplus_baggage(cd, p1, name, namlen);
 951
 952                 /* determine entry word length and lengths to go in pages */
 953                 num_entry_words = p1 - tmp;
 954                 len1 = curr_page_addr + PAGE_SIZE - (caddr_t)cd->buffer;
 955                 if ((num_entry_words << 2) < len1) {
 956                         /* the actual number of words in the entry is less
 957                          * than elen and can still fit in the current page
 958                          */
 959                         memmove(p, tmp, num_entry_words << 2);
 960                         p += num_entry_words;
 961
 962                         /* update offset */
 963                         cd->offset = cd->buffer + (cd->offset - tmp);
 964                 } else {
 965                         unsigned int offset_r = (cd->offset - tmp) << 2;
 966
 967                         /* update pointer to offset location.
 968                          * This is a 64bit quantity, so we need to
 969                          * deal with 3 cases:
 970                          *  -   entirely in first page
 971                          *  -   entirely in second page
 972                          *  -   4 bytes in each page
 973                          */
 974                         if (offset_r + 8 <= len1) {
 975                                 cd->offset = p + (cd->offset - tmp);
 976                         } else if (offset_r >= len1) {
 977                                 cd->offset -= len1 >> 2;
 978                         } else {
 979                                 /* sitting on the fence */
 980                                 BUG_ON(offset_r != len1 - 4);
 981                                 cd->offset = p + (cd->offset - tmp);
 982                                 cd->offset1 = tmp;
 983                         }
 984
 985                         len2 = (num_entry_words << 2) - len1;
 986
 987                         /* move from temp page to current and next pages */
 988                         memmove(p, tmp, len1);
 989                         memmove(tmp, (caddr_t)tmp+len1, len2);
 990
 991                         p = tmp + (len2 >> 2);
 992                 }
 993         }
 994         else {
 995                 cd->common.err = nfserr_toosmall;
 996                 return -EINVAL;
 997         }
 998
 999         cd->buflen -= num_entry_words;
1000         cd->buffer = p;
1001         cd->common.err = nfs_ok;
1002         return 0;
1003
1004 }
1005
1006 int
1007 nfs3svc_encode_entry(void *cd, const char *name,
1008                      int namlen, loff_t offset, u64 ino, unsigned int d_type)
1009 {
1010         return encode_entry(cd, name, namlen, offset, ino, d_type, 0);
1011 }
1012
1013 int
1014 nfs3svc_encode_entry_plus(void *cd, const char *name,
1015                           int namlen, loff_t offset, u64 ino,
1016                           unsigned int d_type)
1017 {
1018         return encode_entry(cd, name, namlen, offset, ino, d_type, 1);
1019 }
1020
1021 /* FSSTAT */
1022 int
1023 nfs3svc_encode_fsstatres(struct svc_rqst *rqstp, __be32 *p,
1024                                         struct nfsd3_fsstatres *resp)
1025 {
1026         struct kstatfs  *s = &resp->stats;
1027         u64             bs = s->f_bsize;
1028
1029         *p++ = xdr_zero;        /* no post_op_attr */
1030
1031         if (resp->status == 0) {
1032                 p = xdr_encode_hyper(p, bs * s->f_blocks);      /* total bytes */
1033                 p = xdr_encode_hyper(p, bs * s->f_bfree);       /* free bytes */
1034                 p = xdr_encode_hyper(p, bs * s->f_bavail);      /* user available bytes */
1035                 p = xdr_encode_hyper(p, s->f_files);    /* total inodes */
1036                 p = xdr_encode_hyper(p, s->f_ffree);    /* free inodes */
1037                 p = xdr_encode_hyper(p, s->f_ffree);    /* user available inodes */
1038                 *p++ = htonl(resp->invarsec);   /* mean unchanged time */
1039         }
1040         return xdr_ressize_check(rqstp, p);
1041 }
1042
1043 /* FSINFO */
1044 int
1045 nfs3svc_encode_fsinfores(struct svc_rqst *rqstp, __be32 *p,
1046                                         struct nfsd3_fsinfores *resp)
1047 {
1048         *p++ = xdr_zero;        /* no post_op_attr */
1049
1050         if (resp->status == 0) {
1051                 *p++ = htonl(resp->f_rtmax);
1052                 *p++ = htonl(resp->f_rtpref);
1053                 *p++ = htonl(resp->f_rtmult);
1054                 *p++ = htonl(resp->f_wtmax);
1055                 *p++ = htonl(resp->f_wtpref);
1056                 *p++ = htonl(resp->f_wtmult);
1057                 *p++ = htonl(resp->f_dtpref);
1058                 p = xdr_encode_hyper(p, resp->f_maxfilesize);
1059                 *p++ = xdr_one;
1060                 *p++ = xdr_zero;
1061                 *p++ = htonl(resp->f_properties);
1062         }
1063
1064         return xdr_ressize_check(rqstp, p);
1065 }
1066
1067 /* PATHCONF */
1068 int
1069 nfs3svc_encode_pathconfres(struct svc_rqst *rqstp, __be32 *p,
1070                                         struct nfsd3_pathconfres *resp)
1071 {
1072         *p++ = xdr_zero;        /* no post_op_attr */
1073
1074         if (resp->status == 0) {
1075                 *p++ = htonl(resp->p_link_max);
1076                 *p++ = htonl(resp->p_name_max);
1077                 *p++ = htonl(resp->p_no_trunc);
1078                 *p++ = htonl(resp->p_chown_restricted);
1079                 *p++ = htonl(resp->p_case_insensitive);
1080                 *p++ = htonl(resp->p_case_preserving);
1081         }
1082
1083         return xdr_ressize_check(rqstp, p);
1084 }
1085
1086 /* COMMIT */
1087 int
1088 nfs3svc_encode_commitres(struct svc_rqst *rqstp, __be32 *p,
1089                                         struct nfsd3_commitres *resp)
1090 {
1091         p = encode_wcc_data(rqstp, p, &resp->fh);
1092         /* Write verifier */
1093         if (resp->status == 0) {
1094                 *p++ = htonl(nfssvc_boot.tv_sec);
1095                 *p++ = htonl(nfssvc_boot.tv_usec);
1096         }
1097         return xdr_ressize_check(rqstp, p);
1098 }
1099
1100 /*
1101  * XDR release functions
1102  */
1103 int
1104 nfs3svc_release_fhandle(struct svc_rqst *rqstp, __be32 *p,
1105                                         struct nfsd3_attrstat *resp)
1106 {
1107         fh_put(&resp->fh);
1108         return 1;
1109 }
1110
1111 int
1112 nfs3svc_release_fhandle2(struct svc_rqst *rqstp, __be32 *p,
1113                                         struct nfsd3_fhandle_pair *resp)
1114 {
1115         fh_put(&resp->fh1);
1116         fh_put(&resp->fh2);
1117         return 1;
1118 }