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