fs/nfs/nfs2xdr.c

   1 /*
   2  * linux/fs/nfs/nfs2xdr.c
   3  *
   4  * XDR functions to encode/decode NFS RPC arguments and results.
   5  *
   6  * Copyright (C) 1992, 1993, 1994  Rick Sladkey
   7  * Copyright (C) 1996 Olaf Kirch
   8  * 04 Aug 1998  Ion Badulescu <ionut@cs.columbia.edu>
   9  *              FIFO's need special handling in NFSv2
  10  */
  11
  12 #include <linux/param.h>
  13 #include <linux/time.h>
  14 #include <linux/mm.h>
  15 #include <linux/errno.h>
  16 #include <linux/string.h>
  17 #include <linux/in.h>
  18 #include <linux/pagemap.h>
  19 #include <linux/proc_fs.h>
  20 #include <linux/sunrpc/clnt.h>
  21 #include <linux/nfs.h>
  22 #include <linux/nfs2.h>
  23 #include <linux/nfs_fs.h>
  24 #include "internal.h"
  25
  26 #define NFSDBG_FACILITY         NFSDBG_XDR
  27
  28 /* Mapping from NFS error code to "errno" error code. */
  29 #define errno_NFSERR_IO         EIO
  30
  31 /*
  32  * Declare the space requirements for NFS arguments and replies as
  33  * number of 32bit-words
  34  */
  35 #define NFS_fhandle_sz          (8)
  36 #define NFS_sattr_sz            (8)
  37 #define NFS_filename_sz         (1+(NFS2_MAXNAMLEN>>2))
  38 #define NFS_path_sz             (1+(NFS2_MAXPATHLEN>>2))
  39 #define NFS_fattr_sz            (17)
  40 #define NFS_info_sz             (5)
  41 #define NFS_entry_sz            (NFS_filename_sz+3)
  42
  43 #define NFS_diropargs_sz        (NFS_fhandle_sz+NFS_filename_sz)
  44 #define NFS_removeargs_sz       (NFS_fhandle_sz+NFS_filename_sz)
  45 #define NFS_sattrargs_sz        (NFS_fhandle_sz+NFS_sattr_sz)
  46 #define NFS_readlinkargs_sz     (NFS_fhandle_sz)
  47 #define NFS_readargs_sz         (NFS_fhandle_sz+3)
  48 #define NFS_writeargs_sz        (NFS_fhandle_sz+4)
  49 #define NFS_createargs_sz       (NFS_diropargs_sz+NFS_sattr_sz)
  50 #define NFS_renameargs_sz       (NFS_diropargs_sz+NFS_diropargs_sz)
  51 #define NFS_linkargs_sz         (NFS_fhandle_sz+NFS_diropargs_sz)
  52 #define NFS_symlinkargs_sz      (NFS_diropargs_sz+1+NFS_sattr_sz)
  53 #define NFS_readdirargs_sz      (NFS_fhandle_sz+2)
  54
  55 #define NFS_attrstat_sz         (1+NFS_fattr_sz)
  56 #define NFS_diropres_sz         (1+NFS_fhandle_sz+NFS_fattr_sz)
  57 #define NFS_readlinkres_sz      (2)
  58 #define NFS_readres_sz          (1+NFS_fattr_sz+1)
  59 #define NFS_writeres_sz         (NFS_attrstat_sz)
  60 #define NFS_stat_sz             (1)
  61 #define NFS_readdirres_sz       (1)
  62 #define NFS_statfsres_sz        (1+NFS_info_sz)
  63
  64
  65 /*
  66  * While encoding arguments, set up the reply buffer in advance to
  67  * receive reply data directly into the page cache.
  68  */
  69 static void prepare_reply_buffer(struct rpc_rqst *req, struct page **pages,
  70                                  unsigned int base, unsigned int len,
  71                                  unsigned int bufsize)
  72 {
  73         struct rpc_auth *auth = req->rq_cred->cr_auth;
  74         unsigned int replen;
  75
  76         replen = RPC_REPHDRSIZE + auth->au_rslack + bufsize;
  77         xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len);
  78 }
  79
  80
  81 /*
  82  * Common NFS XDR functions as inlines
  83  */
  84 static inline __be32 *
  85 xdr_decode_fhandle(__be32 *p, struct nfs_fh *fhandle)
  86 {
  87         /* NFSv2 handles have a fixed length */
  88         fhandle->size = NFS2_FHSIZE;
  89         memcpy(fhandle->data, p, NFS2_FHSIZE);
  90         return p + XDR_QUADLEN(NFS2_FHSIZE);
  91 }
  92
  93 static inline __be32*
  94 xdr_encode_time(__be32 *p, const struct timespec *timep)
  95 {
  96         *p++ = htonl(timep->tv_sec);
  97         /* Convert nanoseconds into microseconds */
  98         *p++ = htonl(timep->tv_nsec ? timep->tv_nsec / 1000 : 0);
  99         return p;
 100 }
 101
 102 static inline __be32*
 103 xdr_encode_current_server_time(__be32 *p, const struct timespec *timep)
 104 {
 105         /*
 106          * Passing the invalid value useconds=1000000 is a
 107          * Sun convention for "set to current server time".
 108          * It's needed to make permissions checks for the
 109          * "touch" program across v2 mounts to Solaris and
 110          * Irix boxes work correctly. See description of
 111          * sattr in section 6.1 of "NFS Illustrated" by
 112          * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5
 113          */
 114         *p++ = htonl(timep->tv_sec);
 115         *p++ = htonl(1000000);
 116         return p;
 117 }
 118
 119 static inline __be32*
 120 xdr_decode_time(__be32 *p, struct timespec *timep)
 121 {
 122         timep->tv_sec = ntohl(*p++);
 123         /* Convert microseconds into nanoseconds */
 124         timep->tv_nsec = ntohl(*p++) * 1000;
 125         return p;
 126 }
 127
 128 static __be32 *
 129 xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr)
 130 {
 131         u32 rdev, type;
 132         type = ntohl(*p++);
 133         fattr->mode = ntohl(*p++);
 134         fattr->nlink = ntohl(*p++);
 135         fattr->uid = ntohl(*p++);
 136         fattr->gid = ntohl(*p++);
 137         fattr->size = ntohl(*p++);
 138         fattr->du.nfs2.blocksize = ntohl(*p++);
 139         rdev = ntohl(*p++);
 140         fattr->du.nfs2.blocks = ntohl(*p++);
 141         fattr->fsid.major = ntohl(*p++);
 142         fattr->fsid.minor = 0;
 143         fattr->fileid = ntohl(*p++);
 144         p = xdr_decode_time(p, &fattr->atime);
 145         p = xdr_decode_time(p, &fattr->mtime);
 146         p = xdr_decode_time(p, &fattr->ctime);
 147         fattr->valid |= NFS_ATTR_FATTR_V2;
 148         fattr->rdev = new_decode_dev(rdev);
 149         if (type == NFCHR && rdev == NFS2_FIFO_DEV) {
 150                 fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO;
 151                 fattr->rdev = 0;
 152         }
 153         return p;
 154 }
 155
 156 /*
 157  * Encode/decode NFSv2 basic data types
 158  *
 159  * Basic NFSv2 data types are defined in section 2.3 of RFC 1094:
 160  * "NFS: Network File System Protocol Specification".
 161  *
 162  * Not all basic data types have their own encoding and decoding
 163  * functions.  For run-time efficiency, some data types are encoded
 164  * or decoded inline.
 165  */
 166
 167 /*
 168  * 2.3.3.  fhandle
 169  *
 170  *      typedef opaque fhandle[FHSIZE];
 171  */
 172 static void encode_fhandle(struct xdr_stream *xdr, const struct nfs_fh *fh)
 173 {
 174         __be32 *p;
 175
 176         BUG_ON(fh->size != NFS2_FHSIZE);
 177         p = xdr_reserve_space(xdr, NFS2_FHSIZE);
 178         memcpy(p, fh->data, NFS2_FHSIZE);
 179 }
 180
 181 /*
 182  * 2.3.6.  sattr
 183  *
 184  *      struct sattr {
 185  *              unsigned int    mode;
 186  *              unsigned int    uid;
 187  *              unsigned int    gid;
 188  *              unsigned int    size;
 189  *              timeval         atime;
 190  *              timeval         mtime;
 191  *      };
 192  */
 193
 194 #define NFS2_SATTR_NOT_SET      (0xffffffff)
 195
 196 static __be32 *xdr_time_not_set(__be32 *p)
 197 {
 198         *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 199         *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 200         return p;
 201 }
 202
 203 static void encode_sattr(struct xdr_stream *xdr, const struct iattr *attr)
 204 {
 205         __be32 *p;
 206
 207         p = xdr_reserve_space(xdr, NFS_sattr_sz << 2);
 208
 209         if (attr->ia_valid & ATTR_MODE)
 210                 *p++ = cpu_to_be32(attr->ia_mode);
 211         else
 212                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 213         if (attr->ia_valid & ATTR_UID)
 214                 *p++ = cpu_to_be32(attr->ia_uid);
 215         else
 216                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 217         if (attr->ia_valid & ATTR_GID)
 218                 *p++ = cpu_to_be32(attr->ia_gid);
 219         else
 220                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 221         if (attr->ia_valid & ATTR_SIZE)
 222                 *p++ = cpu_to_be32((u32)attr->ia_size);
 223         else
 224                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 225
 226         if (attr->ia_valid & ATTR_ATIME_SET)
 227                 p = xdr_encode_time(p, &attr->ia_atime);
 228         else if (attr->ia_valid & ATTR_ATIME)
 229                 p = xdr_encode_current_server_time(p, &attr->ia_atime);
 230         else
 231                 p = xdr_time_not_set(p);
 232         if (attr->ia_valid & ATTR_MTIME_SET)
 233                 xdr_encode_time(p, &attr->ia_mtime);
 234         else if (attr->ia_valid & ATTR_MTIME)
 235                 xdr_encode_current_server_time(p, &attr->ia_mtime);
 236         else
 237                 xdr_time_not_set(p);
 238 }
 239
 240 /*
 241  * 2.3.7.  filename
 242  *
 243  *      typedef string filename<MAXNAMLEN>;
 244  */
 245 static void encode_filename(struct xdr_stream *xdr,
 246                             const char *name, u32 length)
 247 {
 248         __be32 *p;
 249
 250         BUG_ON(length > NFS2_MAXNAMLEN);
 251         p = xdr_reserve_space(xdr, 4 + length);
 252         xdr_encode_opaque(p, name, length);
 253 }
 254
 255 /*
 256  * 2.3.8.  path
 257  *
 258  *      typedef string path<MAXPATHLEN>;
 259  */
 260 static void encode_path(struct xdr_stream *xdr, struct page **pages, u32 length)
 261 {
 262         __be32 *p;
 263
 264         BUG_ON(length > NFS2_MAXPATHLEN);
 265         p = xdr_reserve_space(xdr, 4);
 266         *p = cpu_to_be32(length);
 267         xdr_write_pages(xdr, pages, 0, length);
 268 }
 269
 270 /*
 271  * 2.3.10.  diropargs
 272  *
 273  *      struct diropargs {
 274  *              fhandle  dir;
 275  *              filename name;
 276  *      };
 277  */
 278 static void encode_diropargs(struct xdr_stream *xdr, const struct nfs_fh *fh,
 279                              const char *name, u32 length)
 280 {
 281         encode_fhandle(xdr, fh);
 282         encode_filename(xdr, name, length);
 283 }
 284
 285
 286 /*
 287  * NFSv2 XDR encode functions
 288  *
 289  * NFSv2 argument types are defined in section 2.2 of RFC 1094:
 290  * "NFS: Network File System Protocol Specification".
 291  */
 292
 293 static int nfs2_xdr_enc_fhandle(struct rpc_rqst *req, __be32 *p,
 294                                 const struct nfs_fh *fh)
 295 {
 296         struct xdr_stream xdr;
 297
 298         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 299         encode_fhandle(&xdr, fh);
 300         return 0;
 301 }
 302
 303 /*
 304  * 2.2.3.  sattrargs
 305  *
 306  *      struct sattrargs {
 307  *              fhandle file;
 308  *              sattr attributes;
 309  *      };
 310  */
 311 static int nfs2_xdr_enc_sattrargs(struct rpc_rqst *req, __be32 *p,
 312                                   const struct nfs_sattrargs *args)
 313 {
 314         struct xdr_stream xdr;
 315
 316         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 317         encode_fhandle(&xdr, args->fh);
 318         encode_sattr(&xdr, args->sattr);
 319         return 0;
 320 }
 321
 322 static int nfs2_xdr_enc_diropargs(struct rpc_rqst *req, __be32 *p,
 323                                   const struct nfs_diropargs *args)
 324 {
 325         struct xdr_stream xdr;
 326
 327         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 328         encode_diropargs(&xdr, args->fh, args->name, args->len);
 329         return 0;
 330 }
 331
 332 static int nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req, __be32 *p,
 333                                      const struct nfs_readlinkargs *args)
 334 {
 335         struct xdr_stream xdr;
 336
 337         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 338         encode_fhandle(&xdr, args->fh);
 339         prepare_reply_buffer(req, args->pages, args->pgbase,
 340                                         args->pglen, NFS_readlinkres_sz);
 341         return 0;
 342 }
 343
 344 /*
 345  * 2.2.7.  readargs
 346  *
 347  *      struct readargs {
 348  *              fhandle file;
 349  *              unsigned offset;
 350  *              unsigned count;
 351  *              unsigned totalcount;
 352  *      };
 353  */
 354 static void encode_readargs(struct xdr_stream *xdr,
 355                             const struct nfs_readargs *args)
 356 {
 357         u32 offset = args->offset;
 358         u32 count = args->count;
 359         __be32 *p;
 360
 361         encode_fhandle(xdr, args->fh);
 362
 363         p = xdr_reserve_space(xdr, 4 + 4 + 4);
 364         *p++ = cpu_to_be32(offset);
 365         *p++ = cpu_to_be32(count);
 366         *p = cpu_to_be32(count);
 367 }
 368
 369 static int nfs2_xdr_enc_readargs(struct rpc_rqst *req, __be32 *p,
 370                                  const struct nfs_readargs *args)
 371 {
 372         struct xdr_stream xdr;
 373
 374         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 375         encode_readargs(&xdr, args);
 376         prepare_reply_buffer(req, args->pages, args->pgbase,
 377                                         args->count, NFS_readres_sz);
 378         req->rq_rcv_buf.flags |= XDRBUF_READ;
 379         return 0;
 380 }
 381
 382 /*
 383  * Decode READ reply
 384  */
 385 static int
 386 nfs_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res)
 387 {
 388         struct kvec *iov = req->rq_rcv_buf.head;
 389         size_t hdrlen;
 390         u32 count, recvd;
 391         int status;
 392
 393         if ((status = ntohl(*p++)))
 394                 return nfs_stat_to_errno(status);
 395         p = xdr_decode_fattr(p, res->fattr);
 396
 397         count = ntohl(*p++);
 398         res->eof = 0;
 399         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 400         if (iov->iov_len < hdrlen) {
 401                 dprintk("NFS: READ reply header overflowed:"
 402                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
 403                 return -errno_NFSERR_IO;
 404         } else if (iov->iov_len != hdrlen) {
 405                 dprintk("NFS: READ header is short. iovec will be shifted.\n");
 406                 xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen);
 407         }
 408
 409         recvd = req->rq_rcv_buf.len - hdrlen;
 410         if (count > recvd) {
 411                 dprintk("NFS: server cheating in read reply: "
 412                         "count %u > recvd %u\n", count, recvd);
 413                 count = recvd;
 414         }
 415
 416         dprintk("RPC:      readres OK count %u\n", count);
 417         if (count < res->count)
 418                 res->count = count;
 419
 420         return count;
 421 }
 422
 423
 424 /*
 425  * 2.2.9.  writeargs
 426  *
 427  *      struct writeargs {
 428  *              fhandle file;
 429  *              unsigned beginoffset;
 430  *              unsigned offset;
 431  *              unsigned totalcount;
 432  *              nfsdata data;
 433  *      };
 434  */
 435 static void encode_writeargs(struct xdr_stream *xdr,
 436                              const struct nfs_writeargs *args)
 437 {
 438         u32 offset = args->offset;
 439         u32 count = args->count;
 440         __be32 *p;
 441
 442         encode_fhandle(xdr, args->fh);
 443
 444         p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4);
 445         *p++ = cpu_to_be32(offset);
 446         *p++ = cpu_to_be32(offset);
 447         *p++ = cpu_to_be32(count);
 448
 449         /* nfsdata */
 450         *p = cpu_to_be32(count);
 451         xdr_write_pages(xdr, args->pages, args->pgbase, count);
 452 }
 453
 454 static int nfs2_xdr_enc_writeargs(struct rpc_rqst *req, __be32 *p,
 455                                   const struct nfs_writeargs *args)
 456 {
 457         struct xdr_stream xdr;
 458
 459         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 460         encode_writeargs(&xdr, args);
 461         xdr.buf->flags |= XDRBUF_WRITE;
 462         return 0;
 463 }
 464
 465 /*
 466  * 2.2.10.  createargs
 467  *
 468  *      struct createargs {
 469  *              diropargs where;
 470  *              sattr attributes;
 471  *      };
 472  */
 473 static int nfs2_xdr_enc_createargs(struct rpc_rqst *req, __be32 *p,
 474                                    const struct nfs_createargs *args)
 475 {
 476         struct xdr_stream xdr;
 477
 478         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 479         encode_diropargs(&xdr, args->fh, args->name, args->len);
 480         encode_sattr(&xdr, args->sattr);
 481         return 0;
 482 }
 483
 484 static int nfs2_xdr_enc_removeargs(struct rpc_rqst *req, __be32 *p,
 485                                    const struct nfs_removeargs *args)
 486 {
 487         struct xdr_stream xdr;
 488
 489         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 490         encode_diropargs(&xdr, args->fh, args->name.name, args->name.len);
 491         return 0;
 492 }
 493
 494 /*
 495  * 2.2.12.  renameargs
 496  *
 497  *      struct renameargs {
 498  *              diropargs from;
 499  *              diropargs to;
 500  *      };
 501  */
 502 static int nfs2_xdr_enc_renameargs(struct rpc_rqst *req, __be32 *p,
 503                                    const struct nfs_renameargs *args)
 504 {
 505         const struct qstr *old = args->old_name;
 506         const struct qstr *new = args->new_name;
 507         struct xdr_stream xdr;
 508
 509         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 510         encode_diropargs(&xdr, args->old_dir, old->name, old->len);
 511         encode_diropargs(&xdr, args->new_dir, new->name, new->len);
 512         return 0;
 513 }
 514
 515 /*
 516  * 2.2.13.  linkargs
 517  *
 518  *      struct linkargs {
 519  *              fhandle from;
 520  *              diropargs to;
 521  *      };
 522  */
 523 static int nfs2_xdr_enc_linkargs(struct rpc_rqst *req, __be32 *p,
 524                                  const struct nfs_linkargs *args)
 525 {
 526         struct xdr_stream xdr;
 527
 528         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 529         encode_fhandle(&xdr, args->fromfh);
 530         encode_diropargs(&xdr, args->tofh, args->toname, args->tolen);
 531         return 0;
 532 }
 533
 534 /*
 535  * 2.2.14.  symlinkargs
 536  *
 537  *      struct symlinkargs {
 538  *              diropargs from;
 539  *              path to;
 540  *              sattr attributes;
 541  *      };
 542  */
 543 static int nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req, __be32 *p,
 544                                     const struct nfs_symlinkargs *args)
 545 {
 546         struct xdr_stream xdr;
 547
 548         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 549         encode_diropargs(&xdr, args->fromfh, args->fromname, args->fromlen);
 550         encode_path(&xdr, args->pages, args->pathlen);
 551         encode_sattr(&xdr, args->sattr);
 552         return 0;
 553 }
 554
 555 /*
 556  * 2.2.17.  readdirargs
 557  *
 558  *      struct readdirargs {
 559  *              fhandle dir;
 560  *              nfscookie cookie;
 561  *              unsigned count;
 562  *      };
 563  */
 564 static void encode_readdirargs(struct xdr_stream *xdr,
 565                                const struct nfs_readdirargs *args)
 566 {
 567         __be32 *p;
 568
 569         encode_fhandle(xdr, args->fh);
 570
 571         p = xdr_reserve_space(xdr, 4 + 4);
 572         *p++ = cpu_to_be32(args->cookie);
 573         *p = cpu_to_be32(args->count);
 574 }
 575
 576 static int nfs2_xdr_enc_readdirargs(struct rpc_rqst *req, __be32 *p,
 577                                     const struct nfs_readdirargs *args)
 578 {
 579         struct xdr_stream xdr;
 580
 581         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
 582         encode_readdirargs(&xdr, args);
 583         prepare_reply_buffer(req, args->pages, 0,
 584                                         args->count, NFS_readdirres_sz);
 585         return 0;
 586 }
 587
 588 /*
 589  * Decode the result of a readdir call.
 590  * We're not really decoding anymore, we just leave the buffer untouched
 591  * and only check that it is syntactically correct.
 592  * The real decoding happens in nfs_decode_entry below, called directly
 593  * from nfs_readdir for each entry.
 594  */
 595 static int
 596 nfs_xdr_readdirres(struct rpc_rqst *req, __be32 *p, void *dummy)
 597 {
 598         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 599         struct kvec *iov = rcvbuf->head;
 600         struct page **page;
 601         size_t hdrlen;
 602         unsigned int pglen, recvd;
 603         int status;
 604
 605         if ((status = ntohl(*p++)))
 606                 return nfs_stat_to_errno(status);
 607
 608         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 609         if (iov->iov_len < hdrlen) {
 610                 dprintk("NFS: READDIR reply header overflowed:"
 611                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
 612                 return -errno_NFSERR_IO;
 613         } else if (iov->iov_len != hdrlen) {
 614                 dprintk("NFS: READDIR header is short. iovec will be shifted.\n");
 615                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 616         }
 617
 618         pglen = rcvbuf->page_len;
 619         recvd = rcvbuf->len - hdrlen;
 620         if (pglen > recvd)
 621                 pglen = recvd;
 622         page = rcvbuf->pages;
 623         return pglen;
 624 }
 625
 626 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
 627 {
 628         dprintk("nfs: %s: prematurely hit end of receive buffer. "
 629                 "Remaining buffer length is %tu words.\n",
 630                 func, xdr->end - xdr->p);
 631 }
 632
 633 __be32 *
 634 nfs_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry, struct nfs_server *server, int plus)
 635 {
 636         __be32 *p;
 637         p = xdr_inline_decode(xdr, 4);
 638         if (unlikely(!p))
 639                 goto out_overflow;
 640         if (!ntohl(*p++)) {
 641                 p = xdr_inline_decode(xdr, 4);
 642                 if (unlikely(!p))
 643                         goto out_overflow;
 644                 if (!ntohl(*p++))
 645                         return ERR_PTR(-EAGAIN);
 646                 entry->eof = 1;
 647                 return ERR_PTR(-EBADCOOKIE);
 648         }
 649
 650         p = xdr_inline_decode(xdr, 8);
 651         if (unlikely(!p))
 652                 goto out_overflow;
 653
 654         entry->ino        = ntohl(*p++);
 655         entry->len        = ntohl(*p++);
 656
 657         p = xdr_inline_decode(xdr, entry->len + 4);
 658         if (unlikely(!p))
 659                 goto out_overflow;
 660         entry->name       = (const char *) p;
 661         p                += XDR_QUADLEN(entry->len);
 662         entry->prev_cookie        = entry->cookie;
 663         entry->cookie     = ntohl(*p++);
 664
 665         entry->d_type = DT_UNKNOWN;
 666
 667         p = xdr_inline_peek(xdr, 8);
 668         if (p != NULL)
 669                 entry->eof = !p[0] && p[1];
 670         else
 671                 entry->eof = 0;
 672
 673         return p;
 674
 675 out_overflow:
 676         print_overflow_msg(__func__, xdr);
 677         return ERR_PTR(-EAGAIN);
 678 }
 679
 680 /*
 681  * NFS XDR decode functions
 682  */
 683 /*
 684  * Decode simple status reply
 685  */
 686 static int
 687 nfs_xdr_stat(struct rpc_rqst *req, __be32 *p, void *dummy)
 688 {
 689         int     status;
 690
 691         if ((status = ntohl(*p++)) != 0)
 692                 status = nfs_stat_to_errno(status);
 693         return status;
 694 }
 695
 696 /*
 697  * Decode attrstat reply
 698  * GETATTR, SETATTR, WRITE
 699  */
 700 static int
 701 nfs_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
 702 {
 703         int     status;
 704
 705         if ((status = ntohl(*p++)))
 706                 return nfs_stat_to_errno(status);
 707         xdr_decode_fattr(p, fattr);
 708         return 0;
 709 }
 710
 711 /*
 712  * Decode diropres reply
 713  * LOOKUP, CREATE, MKDIR
 714  */
 715 static int
 716 nfs_xdr_diropres(struct rpc_rqst *req, __be32 *p, struct nfs_diropok *res)
 717 {
 718         int     status;
 719
 720         if ((status = ntohl(*p++)))
 721                 return nfs_stat_to_errno(status);
 722         p = xdr_decode_fhandle(p, res->fh);
 723         xdr_decode_fattr(p, res->fattr);
 724         return 0;
 725 }
 726
 727 /*
 728  * Decode READLINK reply
 729  */
 730 static int
 731 nfs_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, void *dummy)
 732 {
 733         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 734         struct kvec *iov = rcvbuf->head;
 735         size_t hdrlen;
 736         u32 len, recvd;
 737         int     status;
 738
 739         if ((status = ntohl(*p++)))
 740                 return nfs_stat_to_errno(status);
 741         /* Convert length of symlink */
 742         len = ntohl(*p++);
 743         if (len >= rcvbuf->page_len) {
 744                 dprintk("nfs: server returned giant symlink!\n");
 745                 return -ENAMETOOLONG;
 746         }
 747         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 748         if (iov->iov_len < hdrlen) {
 749                 dprintk("NFS: READLINK reply header overflowed:"
 750                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
 751                 return -errno_NFSERR_IO;
 752         } else if (iov->iov_len != hdrlen) {
 753                 dprintk("NFS: READLINK header is short. iovec will be shifted.\n");
 754                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 755         }
 756         recvd = req->rq_rcv_buf.len - hdrlen;
 757         if (recvd < len) {
 758                 dprintk("NFS: server cheating in readlink reply: "
 759                                 "count %u > recvd %u\n", len, recvd);
 760                 return -EIO;
 761         }
 762
 763         xdr_terminate_string(rcvbuf, len);
 764         return 0;
 765 }
 766
 767 /*
 768  * Decode WRITE reply
 769  */
 770 static int
 771 nfs_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
 772 {
 773         res->verf->committed = NFS_FILE_SYNC;
 774         return nfs_xdr_attrstat(req, p, res->fattr);
 775 }
 776
 777 /*
 778  * Decode STATFS reply
 779  */
 780 static int
 781 nfs_xdr_statfsres(struct rpc_rqst *req, __be32 *p, struct nfs2_fsstat *res)
 782 {
 783         int     status;
 784
 785         if ((status = ntohl(*p++)))
 786                 return nfs_stat_to_errno(status);
 787
 788         res->tsize  = ntohl(*p++);
 789         res->bsize  = ntohl(*p++);
 790         res->blocks = ntohl(*p++);
 791         res->bfree  = ntohl(*p++);
 792         res->bavail = ntohl(*p++);
 793         return 0;
 794 }
 795
 796 /*
 797  * We need to translate between nfs status return values and
 798  * the local errno values which may not be the same.
 799  */
 800 static struct {
 801         int stat;
 802         int errno;
 803 } nfs_errtbl[] = {
 804         { NFS_OK,               0               },
 805         { NFSERR_PERM,          -EPERM          },
 806         { NFSERR_NOENT,         -ENOENT         },
 807         { NFSERR_IO,            -errno_NFSERR_IO},
 808         { NFSERR_NXIO,          -ENXIO          },
 809 /*      { NFSERR_EAGAIN,        -EAGAIN         }, */
 810         { NFSERR_ACCES,         -EACCES         },
 811         { NFSERR_EXIST,         -EEXIST         },
 812         { NFSERR_XDEV,          -EXDEV          },
 813         { NFSERR_NODEV,         -ENODEV         },
 814         { NFSERR_NOTDIR,        -ENOTDIR        },
 815         { NFSERR_ISDIR,         -EISDIR         },
 816         { NFSERR_INVAL,         -EINVAL         },
 817         { NFSERR_FBIG,          -EFBIG          },
 818         { NFSERR_NOSPC,         -ENOSPC         },
 819         { NFSERR_ROFS,          -EROFS          },
 820         { NFSERR_MLINK,         -EMLINK         },
 821         { NFSERR_NAMETOOLONG,   -ENAMETOOLONG   },
 822         { NFSERR_NOTEMPTY,      -ENOTEMPTY      },
 823         { NFSERR_DQUOT,         -EDQUOT         },
 824         { NFSERR_STALE,         -ESTALE         },
 825         { NFSERR_REMOTE,        -EREMOTE        },
 826 #ifdef EWFLUSH
 827         { NFSERR_WFLUSH,        -EWFLUSH        },
 828 #endif
 829         { NFSERR_BADHANDLE,     -EBADHANDLE     },
 830         { NFSERR_NOT_SYNC,      -ENOTSYNC       },
 831         { NFSERR_BAD_COOKIE,    -EBADCOOKIE     },
 832         { NFSERR_NOTSUPP,       -ENOTSUPP       },
 833         { NFSERR_TOOSMALL,      -ETOOSMALL      },
 834         { NFSERR_SERVERFAULT,   -EREMOTEIO      },
 835         { NFSERR_BADTYPE,       -EBADTYPE       },
 836         { NFSERR_JUKEBOX,       -EJUKEBOX       },
 837         { -1,                   -EIO            }
 838 };
 839
 840 /*
 841  * Convert an NFS error code to a local one.
 842  * This one is used jointly by NFSv2 and NFSv3.
 843  */
 844 int
 845 nfs_stat_to_errno(int stat)
 846 {
 847         int i;
 848
 849         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
 850                 if (nfs_errtbl[i].stat == stat)
 851                         return nfs_errtbl[i].errno;
 852         }
 853         dprintk("nfs_stat_to_errno: bad nfs status return value: %d\n", stat);
 854         return nfs_errtbl[i].errno;
 855 }
 856
 857 #define PROC(proc, argtype, restype, timer)                             \
 858 [NFSPROC_##proc] = {                                                    \
 859         .p_proc     =  NFSPROC_##proc,                                  \
 860         .p_encode   =  (kxdrproc_t)nfs2_xdr_enc_##argtype,              \
 861         .p_decode   =  (kxdrproc_t) nfs_xdr_##restype,                  \
 862         .p_arglen   =  NFS_##argtype##_sz,                              \
 863         .p_replen   =  NFS_##restype##_sz,                              \
 864         .p_timer    =  timer,                                           \
 865         .p_statidx  =  NFSPROC_##proc,                                  \
 866         .p_name     =  #proc,                                           \
 867         }
 868 struct rpc_procinfo     nfs_procedures[] = {
 869     PROC(GETATTR,       fhandle,        attrstat, 1),
 870     PROC(SETATTR,       sattrargs,      attrstat, 0),
 871     PROC(LOOKUP,        diropargs,      diropres, 2),
 872     PROC(READLINK,      readlinkargs,   readlinkres, 3),
 873     PROC(READ,          readargs,       readres, 3),
 874     PROC(WRITE,         writeargs,      writeres, 4),
 875     PROC(CREATE,        createargs,     diropres, 0),
 876     PROC(REMOVE,        removeargs,     stat, 0),
 877     PROC(RENAME,        renameargs,     stat, 0),
 878     PROC(LINK,          linkargs,       stat, 0),
 879     PROC(SYMLINK,       symlinkargs,    stat, 0),
 880     PROC(MKDIR,         createargs,     diropres, 0),
 881     PROC(RMDIR,         diropargs,      stat, 0),
 882     PROC(READDIR,       readdirargs,    readdirres, 3),
 883     PROC(STATFS,        fhandle,        statfsres, 0),
 884 };
 885
 886 struct rpc_version              nfs_version2 = {
 887         .number                 = 2,
 888         .nrprocs                = ARRAY_SIZE(nfs_procedures),
 889         .procs                  = nfs_procedures
 890 };