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 <[email protected]>
   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 static int nfs_stat_to_errno(enum nfs_stat);
  65
  66 /*
  67  * While encoding arguments, set up the reply buffer in advance to
  68  * receive reply data directly into the page cache.
  69  */
  70 static void prepare_reply_buffer(struct rpc_rqst *req, struct page **pages,
  71                                  unsigned int base, unsigned int len,
  72                                  unsigned int bufsize)
  73 {
  74         struct rpc_auth *auth = req->rq_cred->cr_auth;
  75         unsigned int replen;
  76
  77         replen = RPC_REPHDRSIZE + auth->au_rslack + bufsize;
  78         xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len);
  79 }
  80
  81 /*
  82  * Handle decode buffer overflows out-of-line.
  83  */
  84 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
  85 {
  86         dprintk("NFS: %s prematurely hit the end of our receive buffer. "
  87                 "Remaining buffer length is %tu words.\n",
  88                 func, xdr->end - xdr->p);
  89 }
  90
  91
  92 /*
  93  * Encode/decode NFSv2 basic data types
  94  *
  95  * Basic NFSv2 data types are defined in section 2.3 of RFC 1094:
  96  * "NFS: Network File System Protocol Specification".
  97  *
  98  * Not all basic data types have their own encoding and decoding
  99  * functions.  For run-time efficiency, some data types are encoded
 100  * or decoded inline.
 101  */
 102
 103 /*
 104  *      typedef opaque  nfsdata<>;
 105  */
 106 static int decode_nfsdata(struct xdr_stream *xdr, struct nfs_pgio_res *result)
 107 {
 108         u32 recvd, count;
 109         __be32 *p;
 110
 111         p = xdr_inline_decode(xdr, 4);
 112         if (unlikely(p == NULL))
 113                 goto out_overflow;
 114         count = be32_to_cpup(p);
 115         recvd = xdr_read_pages(xdr, count);
 116         if (unlikely(count > recvd))
 117                 goto out_cheating;
 118 out:
 119         result->eof = 0;        /* NFSv2 does not pass EOF flag on the wire. */
 120         result->count = count;
 121         return count;
 122 out_cheating:
 123         dprintk("NFS: server cheating in read result: "
 124                 "count %u > recvd %u\n", count, recvd);
 125         count = recvd;
 126         goto out;
 127 out_overflow:
 128         print_overflow_msg(__func__, xdr);
 129         return -EIO;
 130 }
 131
 132 /*
 133  *      enum stat {
 134  *              NFS_OK = 0,
 135  *              NFSERR_PERM = 1,
 136  *              NFSERR_NOENT = 2,
 137  *              NFSERR_IO = 5,
 138  *              NFSERR_NXIO = 6,
 139  *              NFSERR_ACCES = 13,
 140  *              NFSERR_EXIST = 17,
 141  *              NFSERR_NODEV = 19,
 142  *              NFSERR_NOTDIR = 20,
 143  *              NFSERR_ISDIR = 21,
 144  *              NFSERR_FBIG = 27,
 145  *              NFSERR_NOSPC = 28,
 146  *              NFSERR_ROFS = 30,
 147  *              NFSERR_NAMETOOLONG = 63,
 148  *              NFSERR_NOTEMPTY = 66,
 149  *              NFSERR_DQUOT = 69,
 150  *              NFSERR_STALE = 70,
 151  *              NFSERR_WFLUSH = 99
 152  *      };
 153  */
 154 static int decode_stat(struct xdr_stream *xdr, enum nfs_stat *status)
 155 {
 156         __be32 *p;
 157
 158         p = xdr_inline_decode(xdr, 4);
 159         if (unlikely(p == NULL))
 160                 goto out_overflow;
 161         *status = be32_to_cpup(p);
 162         return 0;
 163 out_overflow:
 164         print_overflow_msg(__func__, xdr);
 165         return -EIO;
 166 }
 167
 168 /*
 169  * 2.3.2.  ftype
 170  *
 171  *      enum ftype {
 172  *              NFNON = 0,
 173  *              NFREG = 1,
 174  *              NFDIR = 2,
 175  *              NFBLK = 3,
 176  *              NFCHR = 4,
 177  *              NFLNK = 5
 178  *      };
 179  *
 180  */
 181 static __be32 *xdr_decode_ftype(__be32 *p, u32 *type)
 182 {
 183         *type = be32_to_cpup(p++);
 184         if (unlikely(*type > NF2FIFO))
 185                 *type = NFBAD;
 186         return p;
 187 }
 188
 189 /*
 190  * 2.3.3.  fhandle
 191  *
 192  *      typedef opaque fhandle[FHSIZE];
 193  */
 194 static void encode_fhandle(struct xdr_stream *xdr, const struct nfs_fh *fh)
 195 {
 196         __be32 *p;
 197
 198         p = xdr_reserve_space(xdr, NFS2_FHSIZE);
 199         memcpy(p, fh->data, NFS2_FHSIZE);
 200 }
 201
 202 static int decode_fhandle(struct xdr_stream *xdr, struct nfs_fh *fh)
 203 {
 204         __be32 *p;
 205
 206         p = xdr_inline_decode(xdr, NFS2_FHSIZE);
 207         if (unlikely(p == NULL))
 208                 goto out_overflow;
 209         fh->size = NFS2_FHSIZE;
 210         memcpy(fh->data, p, NFS2_FHSIZE);
 211         return 0;
 212 out_overflow:
 213         print_overflow_msg(__func__, xdr);
 214         return -EIO;
 215 }
 216
 217 /*
 218  * 2.3.4.  timeval
 219  *
 220  *      struct timeval {
 221  *              unsigned int seconds;
 222  *              unsigned int useconds;
 223  *      };
 224  */
 225 static __be32 *xdr_encode_time(__be32 *p, const struct timespec *timep)
 226 {
 227         *p++ = cpu_to_be32(timep->tv_sec);
 228         if (timep->tv_nsec != 0)
 229                 *p++ = cpu_to_be32(timep->tv_nsec / NSEC_PER_USEC);
 230         else
 231                 *p++ = cpu_to_be32(0);
 232         return p;
 233 }
 234
 235 /*
 236  * Passing the invalid value useconds=1000000 is a Sun convention for
 237  * "set to current server time".  It's needed to make permissions checks
 238  * for the "touch" program across v2 mounts to Solaris and Irix servers
 239  * work correctly.  See description of sattr in section 6.1 of "NFS
 240  * Illustrated" by Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5.
 241  */
 242 static __be32 *xdr_encode_current_server_time(__be32 *p,
 243                                               const struct timespec *timep)
 244 {
 245         *p++ = cpu_to_be32(timep->tv_sec);
 246         *p++ = cpu_to_be32(1000000);
 247         return p;
 248 }
 249
 250 static __be32 *xdr_decode_time(__be32 *p, struct timespec *timep)
 251 {
 252         timep->tv_sec = be32_to_cpup(p++);
 253         timep->tv_nsec = be32_to_cpup(p++) * NSEC_PER_USEC;
 254         return p;
 255 }
 256
 257 /*
 258  * 2.3.5.  fattr
 259  *
 260  *      struct fattr {
 261  *              ftype           type;
 262  *              unsigned int    mode;
 263  *              unsigned int    nlink;
 264  *              unsigned int    uid;
 265  *              unsigned int    gid;
 266  *              unsigned int    size;
 267  *              unsigned int    blocksize;
 268  *              unsigned int    rdev;
 269  *              unsigned int    blocks;
 270  *              unsigned int    fsid;
 271  *              unsigned int    fileid;
 272  *              timeval         atime;
 273  *              timeval         mtime;
 274  *              timeval         ctime;
 275  *      };
 276  *
 277  */
 278 static int decode_fattr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
 279 {
 280         u32 rdev, type;
 281         __be32 *p;
 282
 283         p = xdr_inline_decode(xdr, NFS_fattr_sz << 2);
 284         if (unlikely(p == NULL))
 285                 goto out_overflow;
 286
 287         fattr->valid |= NFS_ATTR_FATTR_V2;
 288
 289         p = xdr_decode_ftype(p, &type);
 290
 291         fattr->mode = be32_to_cpup(p++);
 292         fattr->nlink = be32_to_cpup(p++);
 293         fattr->uid = make_kuid(&init_user_ns, be32_to_cpup(p++));
 294         if (!uid_valid(fattr->uid))
 295                 goto out_uid;
 296         fattr->gid = make_kgid(&init_user_ns, be32_to_cpup(p++));
 297         if (!gid_valid(fattr->gid))
 298                 goto out_gid;
 299
 300         fattr->size = be32_to_cpup(p++);
 301         fattr->du.nfs2.blocksize = be32_to_cpup(p++);
 302
 303         rdev = be32_to_cpup(p++);
 304         fattr->rdev = new_decode_dev(rdev);
 305         if (type == (u32)NFCHR && rdev == (u32)NFS2_FIFO_DEV) {
 306                 fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO;
 307                 fattr->rdev = 0;
 308         }
 309
 310         fattr->du.nfs2.blocks = be32_to_cpup(p++);
 311         fattr->fsid.major = be32_to_cpup(p++);
 312         fattr->fsid.minor = 0;
 313         fattr->fileid = be32_to_cpup(p++);
 314
 315         p = xdr_decode_time(p, &fattr->atime);
 316         p = xdr_decode_time(p, &fattr->mtime);
 317         xdr_decode_time(p, &fattr->ctime);
 318         fattr->change_attr = nfs_timespec_to_change_attr(&fattr->ctime);
 319
 320         return 0;
 321 out_uid:
 322         dprintk("NFS: returned invalid uid\n");
 323         return -EINVAL;
 324 out_gid:
 325         dprintk("NFS: returned invalid gid\n");
 326         return -EINVAL;
 327 out_overflow:
 328         print_overflow_msg(__func__, xdr);
 329         return -EIO;
 330 }
 331
 332 /*
 333  * 2.3.6.  sattr
 334  *
 335  *      struct sattr {
 336  *              unsigned int    mode;
 337  *              unsigned int    uid;
 338  *              unsigned int    gid;
 339  *              unsigned int    size;
 340  *              timeval         atime;
 341  *              timeval         mtime;
 342  *      };
 343  */
 344
 345 #define NFS2_SATTR_NOT_SET      (0xffffffff)
 346
 347 static __be32 *xdr_time_not_set(__be32 *p)
 348 {
 349         *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 350         *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 351         return p;
 352 }
 353
 354 static void encode_sattr(struct xdr_stream *xdr, const struct iattr *attr)
 355 {
 356         __be32 *p;
 357
 358         p = xdr_reserve_space(xdr, NFS_sattr_sz << 2);
 359
 360         if (attr->ia_valid & ATTR_MODE)
 361                 *p++ = cpu_to_be32(attr->ia_mode);
 362         else
 363                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 364         if (attr->ia_valid & ATTR_UID)
 365                 *p++ = cpu_to_be32(from_kuid(&init_user_ns, attr->ia_uid));
 366         else
 367                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 368         if (attr->ia_valid & ATTR_GID)
 369                 *p++ = cpu_to_be32(from_kgid(&init_user_ns, attr->ia_gid));
 370         else
 371                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 372         if (attr->ia_valid & ATTR_SIZE)
 373                 *p++ = cpu_to_be32((u32)attr->ia_size);
 374         else
 375                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 376
 377         if (attr->ia_valid & ATTR_ATIME_SET)
 378                 p = xdr_encode_time(p, &attr->ia_atime);
 379         else if (attr->ia_valid & ATTR_ATIME)
 380                 p = xdr_encode_current_server_time(p, &attr->ia_atime);
 381         else
 382                 p = xdr_time_not_set(p);
 383         if (attr->ia_valid & ATTR_MTIME_SET)
 384                 xdr_encode_time(p, &attr->ia_mtime);
 385         else if (attr->ia_valid & ATTR_MTIME)
 386                 xdr_encode_current_server_time(p, &attr->ia_mtime);
 387         else
 388                 xdr_time_not_set(p);
 389 }
 390
 391 /*
 392  * 2.3.7.  filename
 393  *
 394  *      typedef string filename<MAXNAMLEN>;
 395  */
 396 static void encode_filename(struct xdr_stream *xdr,
 397                             const char *name, u32 length)
 398 {
 399         __be32 *p;
 400
 401         WARN_ON_ONCE(length > NFS2_MAXNAMLEN);
 402         p = xdr_reserve_space(xdr, 4 + length);
 403         xdr_encode_opaque(p, name, length);
 404 }
 405
 406 static int decode_filename_inline(struct xdr_stream *xdr,
 407                                   const char **name, u32 *length)
 408 {
 409         __be32 *p;
 410         u32 count;
 411
 412         p = xdr_inline_decode(xdr, 4);
 413         if (unlikely(p == NULL))
 414                 goto out_overflow;
 415         count = be32_to_cpup(p);
 416         if (count > NFS3_MAXNAMLEN)
 417                 goto out_nametoolong;
 418         p = xdr_inline_decode(xdr, count);
 419         if (unlikely(p == NULL))
 420                 goto out_overflow;
 421         *name = (const char *)p;
 422         *length = count;
 423         return 0;
 424 out_nametoolong:
 425         dprintk("NFS: returned filename too long: %u\n", count);
 426         return -ENAMETOOLONG;
 427 out_overflow:
 428         print_overflow_msg(__func__, xdr);
 429         return -EIO;
 430 }
 431
 432 /*
 433  * 2.3.8.  path
 434  *
 435  *      typedef string path<MAXPATHLEN>;
 436  */
 437 static void encode_path(struct xdr_stream *xdr, struct page **pages, u32 length)
 438 {
 439         __be32 *p;
 440
 441         p = xdr_reserve_space(xdr, 4);
 442         *p = cpu_to_be32(length);
 443         xdr_write_pages(xdr, pages, 0, length);
 444 }
 445
 446 static int decode_path(struct xdr_stream *xdr)
 447 {
 448         u32 length, recvd;
 449         __be32 *p;
 450
 451         p = xdr_inline_decode(xdr, 4);
 452         if (unlikely(p == NULL))
 453                 goto out_overflow;
 454         length = be32_to_cpup(p);
 455         if (unlikely(length >= xdr->buf->page_len || length > NFS_MAXPATHLEN))
 456                 goto out_size;
 457         recvd = xdr_read_pages(xdr, length);
 458         if (unlikely(length > recvd))
 459                 goto out_cheating;
 460         xdr_terminate_string(xdr->buf, length);
 461         return 0;
 462 out_size:
 463         dprintk("NFS: returned pathname too long: %u\n", length);
 464         return -ENAMETOOLONG;
 465 out_cheating:
 466         dprintk("NFS: server cheating in pathname result: "
 467                 "length %u > received %u\n", length, recvd);
 468         return -EIO;
 469 out_overflow:
 470         print_overflow_msg(__func__, xdr);
 471         return -EIO;
 472 }
 473
 474 /*
 475  * 2.3.9.  attrstat
 476  *
 477  *      union attrstat switch (stat status) {
 478  *      case NFS_OK:
 479  *              fattr attributes;
 480  *      default:
 481  *              void;
 482  *      };
 483  */
 484 static int decode_attrstat(struct xdr_stream *xdr, struct nfs_fattr *result,
 485                            __u32 *op_status)
 486 {
 487         enum nfs_stat status;
 488         int error;
 489
 490         error = decode_stat(xdr, &status);
 491         if (unlikely(error))
 492                 goto out;
 493         if (op_status)
 494                 *op_status = status;
 495         if (status != NFS_OK)
 496                 goto out_default;
 497         error = decode_fattr(xdr, result);
 498 out:
 499         return error;
 500 out_default:
 501         return nfs_stat_to_errno(status);
 502 }
 503
 504 /*
 505  * 2.3.10.  diropargs
 506  *
 507  *      struct diropargs {
 508  *              fhandle  dir;
 509  *              filename name;
 510  *      };
 511  */
 512 static void encode_diropargs(struct xdr_stream *xdr, const struct nfs_fh *fh,
 513                              const char *name, u32 length)
 514 {
 515         encode_fhandle(xdr, fh);
 516         encode_filename(xdr, name, length);
 517 }
 518
 519 /*
 520  * 2.3.11.  diropres
 521  *
 522  *      union diropres switch (stat status) {
 523  *      case NFS_OK:
 524  *              struct {
 525  *                      fhandle file;
 526  *                      fattr   attributes;
 527  *              } diropok;
 528  *      default:
 529  *              void;
 530  *      };
 531  */
 532 static int decode_diropok(struct xdr_stream *xdr, struct nfs_diropok *result)
 533 {
 534         int error;
 535
 536         error = decode_fhandle(xdr, result->fh);
 537         if (unlikely(error))
 538                 goto out;
 539         error = decode_fattr(xdr, result->fattr);
 540 out:
 541         return error;
 542 }
 543
 544 static int decode_diropres(struct xdr_stream *xdr, struct nfs_diropok *result)
 545 {
 546         enum nfs_stat status;
 547         int error;
 548
 549         error = decode_stat(xdr, &status);
 550         if (unlikely(error))
 551                 goto out;
 552         if (status != NFS_OK)
 553                 goto out_default;
 554         error = decode_diropok(xdr, result);
 555 out:
 556         return error;
 557 out_default:
 558         return nfs_stat_to_errno(status);
 559 }
 560
 561
 562 /*
 563  * NFSv2 XDR encode functions
 564  *
 565  * NFSv2 argument types are defined in section 2.2 of RFC 1094:
 566  * "NFS: Network File System Protocol Specification".
 567  */
 568
 569 static void nfs2_xdr_enc_fhandle(struct rpc_rqst *req,
 570                                  struct xdr_stream *xdr,
 571                                  const struct nfs_fh *fh)
 572 {
 573         encode_fhandle(xdr, fh);
 574 }
 575
 576 /*
 577  * 2.2.3.  sattrargs
 578  *
 579  *      struct sattrargs {
 580  *              fhandle file;
 581  *              sattr attributes;
 582  *      };
 583  */
 584 static void nfs2_xdr_enc_sattrargs(struct rpc_rqst *req,
 585                                    struct xdr_stream *xdr,
 586                                    const struct nfs_sattrargs *args)
 587 {
 588         encode_fhandle(xdr, args->fh);
 589         encode_sattr(xdr, args->sattr);
 590 }
 591
 592 static void nfs2_xdr_enc_diropargs(struct rpc_rqst *req,
 593                                    struct xdr_stream *xdr,
 594                                    const struct nfs_diropargs *args)
 595 {
 596         encode_diropargs(xdr, args->fh, args->name, args->len);
 597 }
 598
 599 static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req,
 600                                       struct xdr_stream *xdr,
 601                                       const struct nfs_readlinkargs *args)
 602 {
 603         encode_fhandle(xdr, args->fh);
 604         prepare_reply_buffer(req, args->pages, args->pgbase,
 605                                         args->pglen, NFS_readlinkres_sz);
 606 }
 607
 608 /*
 609  * 2.2.7.  readargs
 610  *
 611  *      struct readargs {
 612  *              fhandle file;
 613  *              unsigned offset;
 614  *              unsigned count;
 615  *              unsigned totalcount;
 616  *      };
 617  */
 618 static void encode_readargs(struct xdr_stream *xdr,
 619                             const struct nfs_pgio_args *args)
 620 {
 621         u32 offset = args->offset;
 622         u32 count = args->count;
 623         __be32 *p;
 624
 625         encode_fhandle(xdr, args->fh);
 626
 627         p = xdr_reserve_space(xdr, 4 + 4 + 4);
 628         *p++ = cpu_to_be32(offset);
 629         *p++ = cpu_to_be32(count);
 630         *p = cpu_to_be32(count);
 631 }
 632
 633 static void nfs2_xdr_enc_readargs(struct rpc_rqst *req,
 634                                   struct xdr_stream *xdr,
 635                                   const struct nfs_pgio_args *args)
 636 {
 637         encode_readargs(xdr, args);
 638         prepare_reply_buffer(req, args->pages, args->pgbase,
 639                                         args->count, NFS_readres_sz);
 640         req->rq_rcv_buf.flags |= XDRBUF_READ;
 641 }
 642
 643 /*
 644  * 2.2.9.  writeargs
 645  *
 646  *      struct writeargs {
 647  *              fhandle file;
 648  *              unsigned beginoffset;
 649  *              unsigned offset;
 650  *              unsigned totalcount;
 651  *              nfsdata data;
 652  *      };
 653  */
 654 static void encode_writeargs(struct xdr_stream *xdr,
 655                              const struct nfs_pgio_args *args)
 656 {
 657         u32 offset = args->offset;
 658         u32 count = args->count;
 659         __be32 *p;
 660
 661         encode_fhandle(xdr, args->fh);
 662
 663         p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4);
 664         *p++ = cpu_to_be32(offset);
 665         *p++ = cpu_to_be32(offset);
 666         *p++ = cpu_to_be32(count);
 667
 668         /* nfsdata */
 669         *p = cpu_to_be32(count);
 670         xdr_write_pages(xdr, args->pages, args->pgbase, count);
 671 }
 672
 673 static void nfs2_xdr_enc_writeargs(struct rpc_rqst *req,
 674                                    struct xdr_stream *xdr,
 675                                    const struct nfs_pgio_args *args)
 676 {
 677         encode_writeargs(xdr, args);
 678         xdr->buf->flags |= XDRBUF_WRITE;
 679 }
 680
 681 /*
 682  * 2.2.10.  createargs
 683  *
 684  *      struct createargs {
 685  *              diropargs where;
 686  *              sattr attributes;
 687  *      };
 688  */
 689 static void nfs2_xdr_enc_createargs(struct rpc_rqst *req,
 690                                     struct xdr_stream *xdr,
 691                                     const struct nfs_createargs *args)
 692 {
 693         encode_diropargs(xdr, args->fh, args->name, args->len);
 694         encode_sattr(xdr, args->sattr);
 695 }
 696
 697 static void nfs2_xdr_enc_removeargs(struct rpc_rqst *req,
 698                                     struct xdr_stream *xdr,
 699                                     const struct nfs_removeargs *args)
 700 {
 701         encode_diropargs(xdr, args->fh, args->name.name, args->name.len);
 702 }
 703
 704 /*
 705  * 2.2.12.  renameargs
 706  *
 707  *      struct renameargs {
 708  *              diropargs from;
 709  *              diropargs to;
 710  *      };
 711  */
 712 static void nfs2_xdr_enc_renameargs(struct rpc_rqst *req,
 713                                     struct xdr_stream *xdr,
 714                                     const struct nfs_renameargs *args)
 715 {
 716         const struct qstr *old = args->old_name;
 717         const struct qstr *new = args->new_name;
 718
 719         encode_diropargs(xdr, args->old_dir, old->name, old->len);
 720         encode_diropargs(xdr, args->new_dir, new->name, new->len);
 721 }
 722
 723 /*
 724  * 2.2.13.  linkargs
 725  *
 726  *      struct linkargs {
 727  *              fhandle from;
 728  *              diropargs to;
 729  *      };
 730  */
 731 static void nfs2_xdr_enc_linkargs(struct rpc_rqst *req,
 732                                   struct xdr_stream *xdr,
 733                                   const struct nfs_linkargs *args)
 734 {
 735         encode_fhandle(xdr, args->fromfh);
 736         encode_diropargs(xdr, args->tofh, args->toname, args->tolen);
 737 }
 738
 739 /*
 740  * 2.2.14.  symlinkargs
 741  *
 742  *      struct symlinkargs {
 743  *              diropargs from;
 744  *              path to;
 745  *              sattr attributes;
 746  *      };
 747  */
 748 static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req,
 749                                      struct xdr_stream *xdr,
 750                                      const struct nfs_symlinkargs *args)
 751 {
 752         encode_diropargs(xdr, args->fromfh, args->fromname, args->fromlen);
 753         encode_path(xdr, args->pages, args->pathlen);
 754         encode_sattr(xdr, args->sattr);
 755 }
 756
 757 /*
 758  * 2.2.17.  readdirargs
 759  *
 760  *      struct readdirargs {
 761  *              fhandle dir;
 762  *              nfscookie cookie;
 763  *              unsigned count;
 764  *      };
 765  */
 766 static void encode_readdirargs(struct xdr_stream *xdr,
 767                                const struct nfs_readdirargs *args)
 768 {
 769         __be32 *p;
 770
 771         encode_fhandle(xdr, args->fh);
 772
 773         p = xdr_reserve_space(xdr, 4 + 4);
 774         *p++ = cpu_to_be32(args->cookie);
 775         *p = cpu_to_be32(args->count);
 776 }
 777
 778 static void nfs2_xdr_enc_readdirargs(struct rpc_rqst *req,
 779                                      struct xdr_stream *xdr,
 780                                      const struct nfs_readdirargs *args)
 781 {
 782         encode_readdirargs(xdr, args);
 783         prepare_reply_buffer(req, args->pages, 0,
 784                                         args->count, NFS_readdirres_sz);
 785 }
 786
 787 /*
 788  * NFSv2 XDR decode functions
 789  *
 790  * NFSv2 result types are defined in section 2.2 of RFC 1094:
 791  * "NFS: Network File System Protocol Specification".
 792  */
 793
 794 static int nfs2_xdr_dec_stat(struct rpc_rqst *req, struct xdr_stream *xdr,
 795                              void *__unused)
 796 {
 797         enum nfs_stat status;
 798         int error;
 799
 800         error = decode_stat(xdr, &status);
 801         if (unlikely(error))
 802                 goto out;
 803         if (status != NFS_OK)
 804                 goto out_default;
 805 out:
 806         return error;
 807 out_default:
 808         return nfs_stat_to_errno(status);
 809 }
 810
 811 static int nfs2_xdr_dec_attrstat(struct rpc_rqst *req, struct xdr_stream *xdr,
 812                                  struct nfs_fattr *result)
 813 {
 814         return decode_attrstat(xdr, result, NULL);
 815 }
 816
 817 static int nfs2_xdr_dec_diropres(struct rpc_rqst *req, struct xdr_stream *xdr,
 818                                  struct nfs_diropok *result)
 819 {
 820         return decode_diropres(xdr, result);
 821 }
 822
 823 /*
 824  * 2.2.6.  readlinkres
 825  *
 826  *      union readlinkres switch (stat status) {
 827  *      case NFS_OK:
 828  *              path data;
 829  *      default:
 830  *              void;
 831  *      };
 832  */
 833 static int nfs2_xdr_dec_readlinkres(struct rpc_rqst *req,
 834                                     struct xdr_stream *xdr, void *__unused)
 835 {
 836         enum nfs_stat status;
 837         int error;
 838
 839         error = decode_stat(xdr, &status);
 840         if (unlikely(error))
 841                 goto out;
 842         if (status != NFS_OK)
 843                 goto out_default;
 844         error = decode_path(xdr);
 845 out:
 846         return error;
 847 out_default:
 848         return nfs_stat_to_errno(status);
 849 }
 850
 851 /*
 852  * 2.2.7.  readres
 853  *
 854  *      union readres switch (stat status) {
 855  *      case NFS_OK:
 856  *              fattr attributes;
 857  *              nfsdata data;
 858  *      default:
 859  *              void;
 860  *      };
 861  */
 862 static int nfs2_xdr_dec_readres(struct rpc_rqst *req, struct xdr_stream *xdr,
 863                                 struct nfs_pgio_res *result)
 864 {
 865         enum nfs_stat status;
 866         int error;
 867
 868         error = decode_stat(xdr, &status);
 869         if (unlikely(error))
 870                 goto out;
 871         result->op_status = status;
 872         if (status != NFS_OK)
 873                 goto out_default;
 874         error = decode_fattr(xdr, result->fattr);
 875         if (unlikely(error))
 876                 goto out;
 877         error = decode_nfsdata(xdr, result);
 878 out:
 879         return error;
 880 out_default:
 881         return nfs_stat_to_errno(status);
 882 }
 883
 884 static int nfs2_xdr_dec_writeres(struct rpc_rqst *req, struct xdr_stream *xdr,
 885                                  struct nfs_pgio_res *result)
 886 {
 887         /* All NFSv2 writes are "file sync" writes */
 888         result->verf->committed = NFS_FILE_SYNC;
 889         return decode_attrstat(xdr, result->fattr, &result->op_status);
 890 }
 891
 892 /**
 893  * nfs2_decode_dirent - Decode a single NFSv2 directory entry stored in
 894  *                      the local page cache.
 895  * @xdr: XDR stream where entry resides
 896  * @entry: buffer to fill in with entry data
 897  * @plus: boolean indicating whether this should be a readdirplus entry
 898  *
 899  * Returns zero if successful, otherwise a negative errno value is
 900  * returned.
 901  *
 902  * This function is not invoked during READDIR reply decoding, but
 903  * rather whenever an application invokes the getdents(2) system call
 904  * on a directory already in our cache.
 905  *
 906  * 2.2.17.  entry
 907  *
 908  *      struct entry {
 909  *              unsigned        fileid;
 910  *              filename        name;
 911  *              nfscookie       cookie;
 912  *              entry           *nextentry;
 913  *      };
 914  */
 915 int nfs2_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
 916                        int plus)
 917 {
 918         __be32 *p;
 919         int error;
 920
 921         p = xdr_inline_decode(xdr, 4);
 922         if (unlikely(p == NULL))
 923                 goto out_overflow;
 924         if (*p++ == xdr_zero) {
 925                 p = xdr_inline_decode(xdr, 4);
 926                 if (unlikely(p == NULL))
 927                         goto out_overflow;
 928                 if (*p++ == xdr_zero)
 929                         return -EAGAIN;
 930                 entry->eof = 1;
 931                 return -EBADCOOKIE;
 932         }
 933
 934         p = xdr_inline_decode(xdr, 4);
 935         if (unlikely(p == NULL))
 936                 goto out_overflow;
 937         entry->ino = be32_to_cpup(p);
 938
 939         error = decode_filename_inline(xdr, &entry->name, &entry->len);
 940         if (unlikely(error))
 941                 return error;
 942
 943         /*
 944          * The type (size and byte order) of nfscookie isn't defined in
 945          * RFC 1094.  This implementation assumes that it's an XDR uint32.
 946          */
 947         entry->prev_cookie = entry->cookie;
 948         p = xdr_inline_decode(xdr, 4);
 949         if (unlikely(p == NULL))
 950                 goto out_overflow;
 951         entry->cookie = be32_to_cpup(p);
 952
 953         entry->d_type = DT_UNKNOWN;
 954
 955         return 0;
 956
 957 out_overflow:
 958         print_overflow_msg(__func__, xdr);
 959         return -EAGAIN;
 960 }
 961
 962 /*
 963  * 2.2.17.  readdirres
 964  *
 965  *      union readdirres switch (stat status) {
 966  *      case NFS_OK:
 967  *              struct {
 968  *                      entry *entries;
 969  *                      bool eof;
 970  *              } readdirok;
 971  *      default:
 972  *              void;
 973  *      };
 974  *
 975  * Read the directory contents into the page cache, but don't
 976  * touch them.  The actual decoding is done by nfs2_decode_dirent()
 977  * during subsequent nfs_readdir() calls.
 978  */
 979 static int decode_readdirok(struct xdr_stream *xdr)
 980 {
 981         return xdr_read_pages(xdr, xdr->buf->page_len);
 982 }
 983
 984 static int nfs2_xdr_dec_readdirres(struct rpc_rqst *req,
 985                                    struct xdr_stream *xdr, void *__unused)
 986 {
 987         enum nfs_stat status;
 988         int error;
 989
 990         error = decode_stat(xdr, &status);
 991         if (unlikely(error))
 992                 goto out;
 993         if (status != NFS_OK)
 994                 goto out_default;
 995         error = decode_readdirok(xdr);
 996 out:
 997         return error;
 998 out_default:
 999         return nfs_stat_to_errno(status);
1000 }
1001
1002 /*
1003  * 2.2.18.  statfsres
1004  *
1005  *      union statfsres (stat status) {
1006  *      case NFS_OK:
1007  *              struct {
1008  *                      unsigned tsize;
1009  *                      unsigned bsize;
1010  *                      unsigned blocks;
1011  *                      unsigned bfree;
1012  *                      unsigned bavail;
1013  *              } info;
1014  *      default:
1015  *              void;
1016  *      };
1017  */
1018 static int decode_info(struct xdr_stream *xdr, struct nfs2_fsstat *result)
1019 {
1020         __be32 *p;
1021
1022         p = xdr_inline_decode(xdr, NFS_info_sz << 2);
1023         if (unlikely(p == NULL))
1024                 goto out_overflow;
1025         result->tsize  = be32_to_cpup(p++);
1026         result->bsize  = be32_to_cpup(p++);
1027         result->blocks = be32_to_cpup(p++);
1028         result->bfree  = be32_to_cpup(p++);
1029         result->bavail = be32_to_cpup(p);
1030         return 0;
1031 out_overflow:
1032         print_overflow_msg(__func__, xdr);
1033         return -EIO;
1034 }
1035
1036 static int nfs2_xdr_dec_statfsres(struct rpc_rqst *req, struct xdr_stream *xdr,
1037                                   struct nfs2_fsstat *result)
1038 {
1039         enum nfs_stat status;
1040         int error;
1041
1042         error = decode_stat(xdr, &status);
1043         if (unlikely(error))
1044                 goto out;
1045         if (status != NFS_OK)
1046                 goto out_default;
1047         error = decode_info(xdr, result);
1048 out:
1049         return error;
1050 out_default:
1051         return nfs_stat_to_errno(status);
1052 }
1053
1054
1055 /*
1056  * We need to translate between nfs status return values and
1057  * the local errno values which may not be the same.
1058  */
1059 static const struct {
1060         int stat;
1061         int errno;
1062 } nfs_errtbl[] = {
1063         { NFS_OK,               0               },
1064         { NFSERR_PERM,          -EPERM          },
1065         { NFSERR_NOENT,         -ENOENT         },
1066         { NFSERR_IO,            -errno_NFSERR_IO},
1067         { NFSERR_NXIO,          -ENXIO          },
1068 /*      { NFSERR_EAGAIN,        -EAGAIN         }, */
1069         { NFSERR_ACCES,         -EACCES         },
1070         { NFSERR_EXIST,         -EEXIST         },
1071         { NFSERR_XDEV,          -EXDEV          },
1072         { NFSERR_NODEV,         -ENODEV         },
1073         { NFSERR_NOTDIR,        -ENOTDIR        },
1074         { NFSERR_ISDIR,         -EISDIR         },
1075         { NFSERR_INVAL,         -EINVAL         },
1076         { NFSERR_FBIG,          -EFBIG          },
1077         { NFSERR_NOSPC,         -ENOSPC         },
1078         { NFSERR_ROFS,          -EROFS          },
1079         { NFSERR_MLINK,         -EMLINK         },
1080         { NFSERR_NAMETOOLONG,   -ENAMETOOLONG   },
1081         { NFSERR_NOTEMPTY,      -ENOTEMPTY      },
1082         { NFSERR_DQUOT,         -EDQUOT         },
1083         { NFSERR_STALE,         -ESTALE         },
1084         { NFSERR_REMOTE,        -EREMOTE        },
1085 #ifdef EWFLUSH
1086         { NFSERR_WFLUSH,        -EWFLUSH        },
1087 #endif
1088         { NFSERR_BADHANDLE,     -EBADHANDLE     },
1089         { NFSERR_NOT_SYNC,      -ENOTSYNC       },
1090         { NFSERR_BAD_COOKIE,    -EBADCOOKIE     },
1091         { NFSERR_NOTSUPP,       -ENOTSUPP       },
1092         { NFSERR_TOOSMALL,      -ETOOSMALL      },
1093         { NFSERR_SERVERFAULT,   -EREMOTEIO      },
1094         { NFSERR_BADTYPE,       -EBADTYPE       },
1095         { NFSERR_JUKEBOX,       -EJUKEBOX       },
1096         { -1,                   -EIO            }
1097 };
1098
1099 /**
1100  * nfs_stat_to_errno - convert an NFS status code to a local errno
1101  * @status: NFS status code to convert
1102  *
1103  * Returns a local errno value, or -EIO if the NFS status code is
1104  * not recognized.  This function is used jointly by NFSv2 and NFSv3.
1105  */
1106 static int nfs_stat_to_errno(enum nfs_stat status)
1107 {
1108         int i;
1109
1110         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
1111                 if (nfs_errtbl[i].stat == (int)status)
1112                         return nfs_errtbl[i].errno;
1113         }
1114         dprintk("NFS: Unrecognized nfs status value: %u\n", status);
1115         return nfs_errtbl[i].errno;
1116 }
1117
1118 #define PROC(proc, argtype, restype, timer)                             \
1119 [NFSPROC_##proc] = {                                                    \
1120         .p_proc     =  NFSPROC_##proc,                                  \
1121         .p_encode   =  (kxdreproc_t)nfs2_xdr_enc_##argtype,             \
1122         .p_decode   =  (kxdrdproc_t)nfs2_xdr_dec_##restype,             \
1123         .p_arglen   =  NFS_##argtype##_sz,                              \
1124         .p_replen   =  NFS_##restype##_sz,                              \
1125         .p_timer    =  timer,                                           \
1126         .p_statidx  =  NFSPROC_##proc,                                  \
1127         .p_name     =  #proc,                                           \
1128         }
1129 struct rpc_procinfo     nfs_procedures[] = {
1130         PROC(GETATTR,   fhandle,        attrstat,       1),
1131         PROC(SETATTR,   sattrargs,      attrstat,       0),
1132         PROC(LOOKUP,    diropargs,      diropres,       2),
1133         PROC(READLINK,  readlinkargs,   readlinkres,    3),
1134         PROC(READ,      readargs,       readres,        3),
1135         PROC(WRITE,     writeargs,      writeres,       4),
1136         PROC(CREATE,    createargs,     diropres,       0),
1137         PROC(REMOVE,    removeargs,     stat,           0),
1138         PROC(RENAME,    renameargs,     stat,           0),
1139         PROC(LINK,      linkargs,       stat,           0),
1140         PROC(SYMLINK,   symlinkargs,    stat,           0),
1141         PROC(MKDIR,     createargs,     diropres,       0),
1142         PROC(RMDIR,     diropargs,      stat,           0),
1143         PROC(READDIR,   readdirargs,    readdirres,     3),
1144         PROC(STATFS,    fhandle,        statfsres,      0),
1145 };
1146
1147 const struct rpc_version nfs_version2 = {
1148         .number                 = 2,
1149         .nrprocs                = ARRAY_SIZE(nfs_procedures),
1150         .procs                  = nfs_procedures
1151 };