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