fs/nfsd/nfs3xdr.c

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