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