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