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_readres *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 {
 486         enum nfs_stat status;
 487         int error;
 488
 489         error = decode_stat(xdr, &status);
 490         if (unlikely(error))
 491                 goto out;
 492         if (status != NFS_OK)
 493                 goto out_default;
 494         error = decode_fattr(xdr, result);
 495 out:
 496         return error;
 497 out_default:
 498         return nfs_stat_to_errno(status);
 499 }
 500
 501 /*
 502  * 2.3.10.  diropargs
 503  *
 504  *      struct diropargs {
 505  *              fhandle  dir;
 506  *              filename name;
 507  *      };
 508  */
 509 static void encode_diropargs(struct xdr_stream *xdr, const struct nfs_fh *fh,
 510                              const char *name, u32 length)
 511 {
 512         encode_fhandle(xdr, fh);
 513         encode_filename(xdr, name, length);
 514 }
 515
 516 /*
 517  * 2.3.11.  diropres
 518  *
 519  *      union diropres switch (stat status) {
 520  *      case NFS_OK:
 521  *              struct {
 522  *                      fhandle file;
 523  *                      fattr   attributes;
 524  *              } diropok;
 525  *      default:
 526  *              void;
 527  *      };
 528  */
 529 static int decode_diropok(struct xdr_stream *xdr, struct nfs_diropok *result)
 530 {
 531         int error;
 532
 533         error = decode_fhandle(xdr, result->fh);
 534         if (unlikely(error))
 535                 goto out;
 536         error = decode_fattr(xdr, result->fattr);
 537 out:
 538         return error;
 539 }
 540
 541 static int decode_diropres(struct xdr_stream *xdr, struct nfs_diropok *result)
 542 {
 543         enum nfs_stat status;
 544         int error;
 545
 546         error = decode_stat(xdr, &status);
 547         if (unlikely(error))
 548                 goto out;
 549         if (status != NFS_OK)
 550                 goto out_default;
 551         error = decode_diropok(xdr, result);
 552 out:
 553         return error;
 554 out_default:
 555         return nfs_stat_to_errno(status);
 556 }
 557
 558
 559 /*
 560  * NFSv2 XDR encode functions
 561  *
 562  * NFSv2 argument types are defined in section 2.2 of RFC 1094:
 563  * "NFS: Network File System Protocol Specification".
 564  */
 565
 566 static void nfs2_xdr_enc_fhandle(struct rpc_rqst *req,
 567                                  struct xdr_stream *xdr,
 568                                  const struct nfs_fh *fh)
 569 {
 570         encode_fhandle(xdr, fh);
 571 }
 572
 573 /*
 574  * 2.2.3.  sattrargs
 575  *
 576  *      struct sattrargs {
 577  *              fhandle file;
 578  *              sattr attributes;
 579  *      };
 580  */
 581 static void nfs2_xdr_enc_sattrargs(struct rpc_rqst *req,
 582                                    struct xdr_stream *xdr,
 583                                    const struct nfs_sattrargs *args)
 584 {
 585         encode_fhandle(xdr, args->fh);
 586         encode_sattr(xdr, args->sattr);
 587 }
 588
 589 static void nfs2_xdr_enc_diropargs(struct rpc_rqst *req,
 590                                    struct xdr_stream *xdr,
 591                                    const struct nfs_diropargs *args)
 592 {
 593         encode_diropargs(xdr, args->fh, args->name, args->len);
 594 }
 595
 596 static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req,
 597                                       struct xdr_stream *xdr,
 598                                       const struct nfs_readlinkargs *args)
 599 {
 600         encode_fhandle(xdr, args->fh);
 601         prepare_reply_buffer(req, args->pages, args->pgbase,
 602                                         args->pglen, NFS_readlinkres_sz);
 603 }
 604
 605 /*
 606  * 2.2.7.  readargs
 607  *
 608  *      struct readargs {
 609  *              fhandle file;
 610  *              unsigned offset;
 611  *              unsigned count;
 612  *              unsigned totalcount;
 613  *      };
 614  */
 615 static void encode_readargs(struct xdr_stream *xdr,
 616                             const struct nfs_readargs *args)
 617 {
 618         u32 offset = args->offset;
 619         u32 count = args->count;
 620         __be32 *p;
 621
 622         encode_fhandle(xdr, args->fh);
 623
 624         p = xdr_reserve_space(xdr, 4 + 4 + 4);
 625         *p++ = cpu_to_be32(offset);
 626         *p++ = cpu_to_be32(count);
 627         *p = cpu_to_be32(count);
 628 }
 629
 630 static void nfs2_xdr_enc_readargs(struct rpc_rqst *req,
 631                                   struct xdr_stream *xdr,
 632                                   const struct nfs_readargs *args)
 633 {
 634         encode_readargs(xdr, args);
 635         prepare_reply_buffer(req, args->pages, args->pgbase,
 636                                         args->count, NFS_readres_sz);
 637         req->rq_rcv_buf.flags |= XDRBUF_READ;
 638 }
 639
 640 /*
 641  * 2.2.9.  writeargs
 642  *
 643  *      struct writeargs {
 644  *              fhandle file;
 645  *              unsigned beginoffset;
 646  *              unsigned offset;
 647  *              unsigned totalcount;
 648  *              nfsdata data;
 649  *      };
 650  */
 651 static void encode_writeargs(struct xdr_stream *xdr,
 652                              const struct nfs_writeargs *args)
 653 {
 654         u32 offset = args->offset;
 655         u32 count = args->count;
 656         __be32 *p;
 657
 658         encode_fhandle(xdr, args->fh);
 659
 660         p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4);
 661         *p++ = cpu_to_be32(offset);
 662         *p++ = cpu_to_be32(offset);
 663         *p++ = cpu_to_be32(count);
 664
 665         /* nfsdata */
 666         *p = cpu_to_be32(count);
 667         xdr_write_pages(xdr, args->pages, args->pgbase, count);
 668 }
 669
 670 static void nfs2_xdr_enc_writeargs(struct rpc_rqst *req,
 671                                    struct xdr_stream *xdr,
 672                                    const struct nfs_writeargs *args)
 673 {
 674         encode_writeargs(xdr, args);
 675         xdr->buf->flags |= XDRBUF_WRITE;
 676 }
 677
 678 /*
 679  * 2.2.10.  createargs
 680  *
 681  *      struct createargs {
 682  *              diropargs where;
 683  *              sattr attributes;
 684  *      };
 685  */
 686 static void nfs2_xdr_enc_createargs(struct rpc_rqst *req,
 687                                     struct xdr_stream *xdr,
 688                                     const struct nfs_createargs *args)
 689 {
 690         encode_diropargs(xdr, args->fh, args->name, args->len);
 691         encode_sattr(xdr, args->sattr);
 692 }
 693
 694 static void nfs2_xdr_enc_removeargs(struct rpc_rqst *req,
 695                                     struct xdr_stream *xdr,
 696                                     const struct nfs_removeargs *args)
 697 {
 698         encode_diropargs(xdr, args->fh, args->name.name, args->name.len);
 699 }
 700
 701 /*
 702  * 2.2.12.  renameargs
 703  *
 704  *      struct renameargs {
 705  *              diropargs from;
 706  *              diropargs to;
 707  *      };
 708  */
 709 static void nfs2_xdr_enc_renameargs(struct rpc_rqst *req,
 710                                     struct xdr_stream *xdr,
 711                                     const struct nfs_renameargs *args)
 712 {
 713         const struct qstr *old = args->old_name;
 714         const struct qstr *new = args->new_name;
 715
 716         encode_diropargs(xdr, args->old_dir, old->name, old->len);
 717         encode_diropargs(xdr, args->new_dir, new->name, new->len);
 718 }
 719
 720 /*
 721  * 2.2.13.  linkargs
 722  *
 723  *      struct linkargs {
 724  *              fhandle from;
 725  *              diropargs to;
 726  *      };
 727  */
 728 static void nfs2_xdr_enc_linkargs(struct rpc_rqst *req,
 729                                   struct xdr_stream *xdr,
 730                                   const struct nfs_linkargs *args)
 731 {
 732         encode_fhandle(xdr, args->fromfh);
 733         encode_diropargs(xdr, args->tofh, args->toname, args->tolen);
 734 }
 735
 736 /*
 737  * 2.2.14.  symlinkargs
 738  *
 739  *      struct symlinkargs {
 740  *              diropargs from;
 741  *              path to;
 742  *              sattr attributes;
 743  *      };
 744  */
 745 static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req,
 746                                      struct xdr_stream *xdr,
 747                                      const struct nfs_symlinkargs *args)
 748 {
 749         encode_diropargs(xdr, args->fromfh, args->fromname, args->fromlen);
 750         encode_path(xdr, args->pages, args->pathlen);
 751         encode_sattr(xdr, args->sattr);
 752 }
 753
 754 /*
 755  * 2.2.17.  readdirargs
 756  *
 757  *      struct readdirargs {
 758  *              fhandle dir;
 759  *              nfscookie cookie;
 760  *              unsigned count;
 761  *      };
 762  */
 763 static void encode_readdirargs(struct xdr_stream *xdr,
 764                                const struct nfs_readdirargs *args)
 765 {
 766         __be32 *p;
 767
 768         encode_fhandle(xdr, args->fh);
 769
 770         p = xdr_reserve_space(xdr, 4 + 4);
 771         *p++ = cpu_to_be32(args->cookie);
 772         *p = cpu_to_be32(args->count);
 773 }
 774
 775 static void nfs2_xdr_enc_readdirargs(struct rpc_rqst *req,
 776                                      struct xdr_stream *xdr,
 777                                      const struct nfs_readdirargs *args)
 778 {
 779         encode_readdirargs(xdr, args);
 780         prepare_reply_buffer(req, args->pages, 0,
 781                                         args->count, NFS_readdirres_sz);
 782 }
 783
 784 /*
 785  * NFSv2 XDR decode functions
 786  *
 787  * NFSv2 result types are defined in section 2.2 of RFC 1094:
 788  * "NFS: Network File System Protocol Specification".
 789  */
 790
 791 static int nfs2_xdr_dec_stat(struct rpc_rqst *req, struct xdr_stream *xdr,
 792                              void *__unused)
 793 {
 794         enum nfs_stat status;
 795         int error;
 796
 797         error = decode_stat(xdr, &status);
 798         if (unlikely(error))
 799                 goto out;
 800         if (status != NFS_OK)
 801                 goto out_default;
 802 out:
 803         return error;
 804 out_default:
 805         return nfs_stat_to_errno(status);
 806 }
 807
 808 static int nfs2_xdr_dec_attrstat(struct rpc_rqst *req, struct xdr_stream *xdr,
 809                                  struct nfs_fattr *result)
 810 {
 811         return decode_attrstat(xdr, result);
 812 }
 813
 814 static int nfs2_xdr_dec_diropres(struct rpc_rqst *req, struct xdr_stream *xdr,
 815                                  struct nfs_diropok *result)
 816 {
 817         return decode_diropres(xdr, result);
 818 }
 819
 820 /*
 821  * 2.2.6.  readlinkres
 822  *
 823  *      union readlinkres switch (stat status) {
 824  *      case NFS_OK:
 825  *              path data;
 826  *      default:
 827  *              void;
 828  *      };
 829  */
 830 static int nfs2_xdr_dec_readlinkres(struct rpc_rqst *req,
 831                                     struct xdr_stream *xdr, void *__unused)
 832 {
 833         enum nfs_stat status;
 834         int error;
 835
 836         error = decode_stat(xdr, &status);
 837         if (unlikely(error))
 838                 goto out;
 839         if (status != NFS_OK)
 840                 goto out_default;
 841         error = decode_path(xdr);
 842 out:
 843         return error;
 844 out_default:
 845         return nfs_stat_to_errno(status);
 846 }
 847
 848 /*
 849  * 2.2.7.  readres
 850  *
 851  *      union readres switch (stat status) {
 852  *      case NFS_OK:
 853  *              fattr attributes;
 854  *              nfsdata data;
 855  *      default:
 856  *              void;
 857  *      };
 858  */
 859 static int nfs2_xdr_dec_readres(struct rpc_rqst *req, struct xdr_stream *xdr,
 860                                 struct nfs_readres *result)
 861 {
 862         enum nfs_stat status;
 863         int error;
 864
 865         error = decode_stat(xdr, &status);
 866         if (unlikely(error))
 867                 goto out;
 868         if (status != NFS_OK)
 869                 goto out_default;
 870         error = decode_fattr(xdr, result->fattr);
 871         if (unlikely(error))
 872                 goto out;
 873         error = decode_nfsdata(xdr, result);
 874 out:
 875         return error;
 876 out_default:
 877         return nfs_stat_to_errno(status);
 878 }
 879
 880 static int nfs2_xdr_dec_writeres(struct rpc_rqst *req, struct xdr_stream *xdr,
 881                                  struct nfs_writeres *result)
 882 {
 883         /* All NFSv2 writes are "file sync" writes */
 884         result->verf->committed = NFS_FILE_SYNC;
 885         return decode_attrstat(xdr, result->fattr);
 886 }
 887
 888 /**
 889  * nfs2_decode_dirent - Decode a single NFSv2 directory entry stored in
 890  *                      the local page cache.
 891  * @xdr: XDR stream where entry resides
 892  * @entry: buffer to fill in with entry data
 893  * @plus: boolean indicating whether this should be a readdirplus entry
 894  *
 895  * Returns zero if successful, otherwise a negative errno value is
 896  * returned.
 897  *
 898  * This function is not invoked during READDIR reply decoding, but
 899  * rather whenever an application invokes the getdents(2) system call
 900  * on a directory already in our cache.
 901  *
 902  * 2.2.17.  entry
 903  *
 904  *      struct entry {
 905  *              unsigned        fileid;
 906  *              filename        name;
 907  *              nfscookie       cookie;
 908  *              entry           *nextentry;
 909  *      };
 910  */
 911 int nfs2_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
 912                        int plus)
 913 {
 914         __be32 *p;
 915         int error;
 916
 917         p = xdr_inline_decode(xdr, 4);
 918         if (unlikely(p == NULL))
 919                 goto out_overflow;
 920         if (*p++ == xdr_zero) {
 921                 p = xdr_inline_decode(xdr, 4);
 922                 if (unlikely(p == NULL))
 923                         goto out_overflow;
 924                 if (*p++ == xdr_zero)
 925                         return -EAGAIN;
 926                 entry->eof = 1;
 927                 return -EBADCOOKIE;
 928         }
 929
 930         p = xdr_inline_decode(xdr, 4);
 931         if (unlikely(p == NULL))
 932                 goto out_overflow;
 933         entry->ino = be32_to_cpup(p);
 934
 935         error = decode_filename_inline(xdr, &entry->name, &entry->len);
 936         if (unlikely(error))
 937                 return error;
 938
 939         /*
 940          * The type (size and byte order) of nfscookie isn't defined in
 941          * RFC 1094.  This implementation assumes that it's an XDR uint32.
 942          */
 943         entry->prev_cookie = entry->cookie;
 944         p = xdr_inline_decode(xdr, 4);
 945         if (unlikely(p == NULL))
 946                 goto out_overflow;
 947         entry->cookie = be32_to_cpup(p);
 948
 949         entry->d_type = DT_UNKNOWN;
 950
 951         return 0;
 952
 953 out_overflow:
 954         print_overflow_msg(__func__, xdr);
 955         return -EAGAIN;
 956 }
 957
 958 /*
 959  * 2.2.17.  readdirres
 960  *
 961  *      union readdirres switch (stat status) {
 962  *      case NFS_OK:
 963  *              struct {
 964  *                      entry *entries;
 965  *                      bool eof;
 966  *              } readdirok;
 967  *      default:
 968  *              void;
 969  *      };
 970  *
 971  * Read the directory contents into the page cache, but don't
 972  * touch them.  The actual decoding is done by nfs2_decode_dirent()
 973  * during subsequent nfs_readdir() calls.
 974  */
 975 static int decode_readdirok(struct xdr_stream *xdr)
 976 {
 977         return xdr_read_pages(xdr, xdr->buf->page_len);
 978 }
 979
 980 static int nfs2_xdr_dec_readdirres(struct rpc_rqst *req,
 981                                    struct xdr_stream *xdr, void *__unused)
 982 {
 983         enum nfs_stat status;
 984         int error;
 985
 986         error = decode_stat(xdr, &status);
 987         if (unlikely(error))
 988                 goto out;
 989         if (status != NFS_OK)
 990                 goto out_default;
 991         error = decode_readdirok(xdr);
 992 out:
 993         return error;
 994 out_default:
 995         return nfs_stat_to_errno(status);
 996 }
 997
 998 /*
 999  * 2.2.18.  statfsres
1000  *
1001  *      union statfsres (stat status) {
1002  *      case NFS_OK:
1003  *              struct {
1004  *                      unsigned tsize;
1005  *                      unsigned bsize;
1006  *                      unsigned blocks;
1007  *                      unsigned bfree;
1008  *                      unsigned bavail;
1009  *              } info;
1010  *      default:
1011  *              void;
1012  *      };
1013  */
1014 static int decode_info(struct xdr_stream *xdr, struct nfs2_fsstat *result)
1015 {
1016         __be32 *p;
1017
1018         p = xdr_inline_decode(xdr, NFS_info_sz << 2);
1019         if (unlikely(p == NULL))
1020                 goto out_overflow;
1021         result->tsize  = be32_to_cpup(p++);
1022         result->bsize  = be32_to_cpup(p++);
1023         result->blocks = be32_to_cpup(p++);
1024         result->bfree  = be32_to_cpup(p++);
1025         result->bavail = be32_to_cpup(p);
1026         return 0;
1027 out_overflow:
1028         print_overflow_msg(__func__, xdr);
1029         return -EIO;
1030 }
1031
1032 static int nfs2_xdr_dec_statfsres(struct rpc_rqst *req, struct xdr_stream *xdr,
1033                                   struct nfs2_fsstat *result)
1034 {
1035         enum nfs_stat status;
1036         int error;
1037
1038         error = decode_stat(xdr, &status);
1039         if (unlikely(error))
1040                 goto out;
1041         if (status != NFS_OK)
1042                 goto out_default;
1043         error = decode_info(xdr, result);
1044 out:
1045         return error;
1046 out_default:
1047         return nfs_stat_to_errno(status);
1048 }
1049
1050
1051 /*
1052  * We need to translate between nfs status return values and
1053  * the local errno values which may not be the same.
1054  */
1055 static const struct {
1056         int stat;
1057         int errno;
1058 } nfs_errtbl[] = {
1059         { NFS_OK,               0               },
1060         { NFSERR_PERM,          -EPERM          },
1061         { NFSERR_NOENT,         -ENOENT         },
1062         { NFSERR_IO,            -errno_NFSERR_IO},
1063         { NFSERR_NXIO,          -ENXIO          },
1064 /*      { NFSERR_EAGAIN,        -EAGAIN         }, */
1065         { NFSERR_ACCES,         -EACCES         },
1066         { NFSERR_EXIST,         -EEXIST         },
1067         { NFSERR_XDEV,          -EXDEV          },
1068         { NFSERR_NODEV,         -ENODEV         },
1069         { NFSERR_NOTDIR,        -ENOTDIR        },
1070         { NFSERR_ISDIR,         -EISDIR         },
1071         { NFSERR_INVAL,         -EINVAL         },
1072         { NFSERR_FBIG,          -EFBIG          },
1073         { NFSERR_NOSPC,         -ENOSPC         },
1074         { NFSERR_ROFS,          -EROFS          },
1075         { NFSERR_MLINK,         -EMLINK         },
1076         { NFSERR_NAMETOOLONG,   -ENAMETOOLONG   },
1077         { NFSERR_NOTEMPTY,      -ENOTEMPTY      },
1078         { NFSERR_DQUOT,         -EDQUOT         },
1079         { NFSERR_STALE,         -ESTALE         },
1080         { NFSERR_REMOTE,        -EREMOTE        },
1081 #ifdef EWFLUSH
1082         { NFSERR_WFLUSH,        -EWFLUSH        },
1083 #endif
1084         { NFSERR_BADHANDLE,     -EBADHANDLE     },
1085         { NFSERR_NOT_SYNC,      -ENOTSYNC       },
1086         { NFSERR_BAD_COOKIE,    -EBADCOOKIE     },
1087         { NFSERR_NOTSUPP,       -ENOTSUPP       },
1088         { NFSERR_TOOSMALL,      -ETOOSMALL      },
1089         { NFSERR_SERVERFAULT,   -EREMOTEIO      },
1090         { NFSERR_BADTYPE,       -EBADTYPE       },
1091         { NFSERR_JUKEBOX,       -EJUKEBOX       },
1092         { -1,                   -EIO            }
1093 };
1094
1095 /**
1096  * nfs_stat_to_errno - convert an NFS status code to a local errno
1097  * @status: NFS status code to convert
1098  *
1099  * Returns a local errno value, or -EIO if the NFS status code is
1100  * not recognized.  This function is used jointly by NFSv2 and NFSv3.
1101  */
1102 static int nfs_stat_to_errno(enum nfs_stat status)
1103 {
1104         int i;
1105
1106         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
1107                 if (nfs_errtbl[i].stat == (int)status)
1108                         return nfs_errtbl[i].errno;
1109         }
1110         dprintk("NFS: Unrecognized nfs status value: %u\n", status);
1111         return nfs_errtbl[i].errno;
1112 }
1113
1114 #define PROC(proc, argtype, restype, timer)                             \
1115 [NFSPROC_##proc] = {                                                    \
1116         .p_proc     =  NFSPROC_##proc,                                  \
1117         .p_encode   =  (kxdreproc_t)nfs2_xdr_enc_##argtype,             \
1118         .p_decode   =  (kxdrdproc_t)nfs2_xdr_dec_##restype,             \
1119         .p_arglen   =  NFS_##argtype##_sz,                              \
1120         .p_replen   =  NFS_##restype##_sz,                              \
1121         .p_timer    =  timer,                                           \
1122         .p_statidx  =  NFSPROC_##proc,                                  \
1123         .p_name     =  #proc,                                           \
1124         }
1125 struct rpc_procinfo     nfs_procedures[] = {
1126         PROC(GETATTR,   fhandle,        attrstat,       1),
1127         PROC(SETATTR,   sattrargs,      attrstat,       0),
1128         PROC(LOOKUP,    diropargs,      diropres,       2),
1129         PROC(READLINK,  readlinkargs,   readlinkres,    3),
1130         PROC(READ,      readargs,       readres,        3),
1131         PROC(WRITE,     writeargs,      writeres,       4),
1132         PROC(CREATE,    createargs,     diropres,       0),
1133         PROC(REMOVE,    removeargs,     stat,           0),
1134         PROC(RENAME,    renameargs,     stat,           0),
1135         PROC(LINK,      linkargs,       stat,           0),
1136         PROC(SYMLINK,   symlinkargs,    stat,           0),
1137         PROC(MKDIR,     createargs,     diropres,       0),
1138         PROC(RMDIR,     diropargs,      stat,           0),
1139         PROC(READDIR,   readdirargs,    readdirres,     3),
1140         PROC(STATFS,    fhandle,        statfsres,      0),
1141 };
1142
1143 const struct rpc_version nfs_version2 = {
1144         .number                 = 2,
1145         .nrprocs                = ARRAY_SIZE(nfs_procedures),
1146         .procs                  = nfs_procedures
1147 };