fs/nfs/nfs2xdr.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * linux/fs/nfs/nfs2xdr.c
   4  *
   5  * XDR functions to encode/decode NFS RPC arguments and results.
   6  *
   7  * Copyright (C) 1992, 1993, 1994  Rick Sladkey
   8  * Copyright (C) 1996 Olaf Kirch
   9  * 04 Aug 1998  Ion Badulescu <ionut@cs.columbia.edu>
  10  *              FIFO's need special handling in NFSv2
  11  */
  12
  13 #include <linux/param.h>
  14 #include <linux/time.h>
  15 #include <linux/mm.h>
  16 #include <linux/errno.h>
  17 #include <linux/string.h>
  18 #include <linux/in.h>
  19 #include <linux/pagemap.h>
  20 #include <linux/proc_fs.h>
  21 #include <linux/sunrpc/clnt.h>
  22 #include <linux/nfs.h>
  23 #include <linux/nfs2.h>
  24 #include <linux/nfs_fs.h>
  25 #include "internal.h"
  26
  27 #define NFSDBG_FACILITY         NFSDBG_XDR
  28
  29 /* Mapping from NFS error code to "errno" error code. */
  30 #define errno_NFSERR_IO         EIO
  31
  32 /*
  33  * Declare the space requirements for NFS arguments and replies as
  34  * number of 32bit-words
  35  */
  36 #define NFS_fhandle_sz          (8)
  37 #define NFS_sattr_sz            (8)
  38 #define NFS_filename_sz         (1+(NFS2_MAXNAMLEN>>2))
  39 #define NFS_path_sz             (1+(NFS2_MAXPATHLEN>>2))
  40 #define NFS_fattr_sz            (17)
  41 #define NFS_info_sz             (5)
  42 #define NFS_entry_sz            (NFS_filename_sz+3)
  43
  44 #define NFS_diropargs_sz        (NFS_fhandle_sz+NFS_filename_sz)
  45 #define NFS_removeargs_sz       (NFS_fhandle_sz+NFS_filename_sz)
  46 #define NFS_sattrargs_sz        (NFS_fhandle_sz+NFS_sattr_sz)
  47 #define NFS_readlinkargs_sz     (NFS_fhandle_sz)
  48 #define NFS_readargs_sz         (NFS_fhandle_sz+3)
  49 #define NFS_writeargs_sz        (NFS_fhandle_sz+4)
  50 #define NFS_createargs_sz       (NFS_diropargs_sz+NFS_sattr_sz)
  51 #define NFS_renameargs_sz       (NFS_diropargs_sz+NFS_diropargs_sz)
  52 #define NFS_linkargs_sz         (NFS_fhandle_sz+NFS_diropargs_sz)
  53 #define NFS_symlinkargs_sz      (NFS_diropargs_sz+1+NFS_sattr_sz)
  54 #define NFS_readdirargs_sz      (NFS_fhandle_sz+2)
  55
  56 #define NFS_attrstat_sz         (1+NFS_fattr_sz)
  57 #define NFS_diropres_sz         (1+NFS_fhandle_sz+NFS_fattr_sz)
  58 #define NFS_readlinkres_sz      (2)
  59 #define NFS_readres_sz          (1+NFS_fattr_sz+1)
  60 #define NFS_writeres_sz         (NFS_attrstat_sz)
  61 #define NFS_stat_sz             (1)
  62 #define NFS_readdirres_sz       (1)
  63 #define NFS_statfsres_sz        (1+NFS_info_sz)
  64
  65 static int nfs_stat_to_errno(enum nfs_stat);
  66
  67 /*
  68  * While encoding arguments, set up the reply buffer in advance to
  69  * receive reply data directly into the page cache.
  70  */
  71 static void prepare_reply_buffer(struct rpc_rqst *req, struct page **pages,
  72                                  unsigned int base, unsigned int len,
  73                                  unsigned int bufsize)
  74 {
  75         struct rpc_auth *auth = req->rq_cred->cr_auth;
  76         unsigned int replen;
  77
  78         replen = RPC_REPHDRSIZE + auth->au_rslack + bufsize;
  79         xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len);
  80 }
  81
  82 /*
  83  * Handle decode buffer overflows out-of-line.
  84  */
  85 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
  86 {
  87         dprintk("NFS: %s prematurely hit the end of our receive buffer. "
  88                 "Remaining buffer length is %tu words.\n",
  89                 func, xdr->end - xdr->p);
  90 }
  91
  92
  93 /*
  94  * Encode/decode NFSv2 basic data types
  95  *
  96  * Basic NFSv2 data types are defined in section 2.3 of RFC 1094:
  97  * "NFS: Network File System Protocol Specification".
  98  *
  99  * Not all basic data types have their own encoding and decoding
 100  * functions.  For run-time efficiency, some data types are encoded
 101  * or decoded inline.
 102  */
 103
 104 /*
 105  *      typedef opaque  nfsdata<>;
 106  */
 107 static int decode_nfsdata(struct xdr_stream *xdr, struct nfs_pgio_res *result)
 108 {
 109         u32 recvd, count;
 110         __be32 *p;
 111
 112         p = xdr_inline_decode(xdr, 4);
 113         if (unlikely(p == NULL))
 114                 goto out_overflow;
 115         count = be32_to_cpup(p);
 116         recvd = xdr_read_pages(xdr, count);
 117         if (unlikely(count > recvd))
 118                 goto out_cheating;
 119 out:
 120         result->eof = 0;        /* NFSv2 does not pass EOF flag on the wire. */
 121         result->count = count;
 122         return count;
 123 out_cheating:
 124         dprintk("NFS: server cheating in read result: "
 125                 "count %u > recvd %u\n", count, recvd);
 126         count = recvd;
 127         goto out;
 128 out_overflow:
 129         print_overflow_msg(__func__, xdr);
 130         return -EIO;
 131 }
 132
 133 /*
 134  *      enum stat {
 135  *              NFS_OK = 0,
 136  *              NFSERR_PERM = 1,
 137  *              NFSERR_NOENT = 2,
 138  *              NFSERR_IO = 5,
 139  *              NFSERR_NXIO = 6,
 140  *              NFSERR_ACCES = 13,
 141  *              NFSERR_EXIST = 17,
 142  *              NFSERR_NODEV = 19,
 143  *              NFSERR_NOTDIR = 20,
 144  *              NFSERR_ISDIR = 21,
 145  *              NFSERR_FBIG = 27,
 146  *              NFSERR_NOSPC = 28,
 147  *              NFSERR_ROFS = 30,
 148  *              NFSERR_NAMETOOLONG = 63,
 149  *              NFSERR_NOTEMPTY = 66,
 150  *              NFSERR_DQUOT = 69,
 151  *              NFSERR_STALE = 70,
 152  *              NFSERR_WFLUSH = 99
 153  *      };
 154  */
 155 static int decode_stat(struct xdr_stream *xdr, enum nfs_stat *status)
 156 {
 157         __be32 *p;
 158
 159         p = xdr_inline_decode(xdr, 4);
 160         if (unlikely(p == NULL))
 161                 goto out_overflow;
 162         *status = be32_to_cpup(p);
 163         return 0;
 164 out_overflow:
 165         print_overflow_msg(__func__, xdr);
 166         return -EIO;
 167 }
 168
 169 /*
 170  * 2.3.2.  ftype
 171  *
 172  *      enum ftype {
 173  *              NFNON = 0,
 174  *              NFREG = 1,
 175  *              NFDIR = 2,
 176  *              NFBLK = 3,
 177  *              NFCHR = 4,
 178  *              NFLNK = 5
 179  *      };
 180  *
 181  */
 182 static __be32 *xdr_decode_ftype(__be32 *p, u32 *type)
 183 {
 184         *type = be32_to_cpup(p++);
 185         if (unlikely(*type > NF2FIFO))
 186                 *type = NFBAD;
 187         return p;
 188 }
 189
 190 /*
 191  * 2.3.3.  fhandle
 192  *
 193  *      typedef opaque fhandle[FHSIZE];
 194  */
 195 static void encode_fhandle(struct xdr_stream *xdr, const struct nfs_fh *fh)
 196 {
 197         __be32 *p;
 198
 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 = make_kuid(&init_user_ns, be32_to_cpup(p++));
 295         if (!uid_valid(fattr->uid))
 296                 goto out_uid;
 297         fattr->gid = make_kgid(&init_user_ns, be32_to_cpup(p++));
 298         if (!gid_valid(fattr->gid))
 299                 goto out_gid;
 300
 301         fattr->size = be32_to_cpup(p++);
 302         fattr->du.nfs2.blocksize = be32_to_cpup(p++);
 303
 304         rdev = be32_to_cpup(p++);
 305         fattr->rdev = new_decode_dev(rdev);
 306         if (type == (u32)NFCHR && rdev == (u32)NFS2_FIFO_DEV) {
 307                 fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO;
 308                 fattr->rdev = 0;
 309         }
 310
 311         fattr->du.nfs2.blocks = be32_to_cpup(p++);
 312         fattr->fsid.major = be32_to_cpup(p++);
 313         fattr->fsid.minor = 0;
 314         fattr->fileid = be32_to_cpup(p++);
 315
 316         p = xdr_decode_time(p, &fattr->atime);
 317         p = xdr_decode_time(p, &fattr->mtime);
 318         xdr_decode_time(p, &fattr->ctime);
 319         fattr->change_attr = nfs_timespec_to_change_attr(&fattr->ctime);
 320
 321         return 0;
 322 out_uid:
 323         dprintk("NFS: returned invalid uid\n");
 324         return -EINVAL;
 325 out_gid:
 326         dprintk("NFS: returned invalid gid\n");
 327         return -EINVAL;
 328 out_overflow:
 329         print_overflow_msg(__func__, xdr);
 330         return -EIO;
 331 }
 332
 333 /*
 334  * 2.3.6.  sattr
 335  *
 336  *      struct sattr {
 337  *              unsigned int    mode;
 338  *              unsigned int    uid;
 339  *              unsigned int    gid;
 340  *              unsigned int    size;
 341  *              timeval         atime;
 342  *              timeval         mtime;
 343  *      };
 344  */
 345
 346 #define NFS2_SATTR_NOT_SET      (0xffffffff)
 347
 348 static __be32 *xdr_time_not_set(__be32 *p)
 349 {
 350         *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 351         *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 352         return p;
 353 }
 354
 355 static void encode_sattr(struct xdr_stream *xdr, const struct iattr *attr)
 356 {
 357         struct timespec ts;
 358         __be32 *p;
 359
 360         p = xdr_reserve_space(xdr, NFS_sattr_sz << 2);
 361
 362         if (attr->ia_valid & ATTR_MODE)
 363                 *p++ = cpu_to_be32(attr->ia_mode);
 364         else
 365                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 366         if (attr->ia_valid & ATTR_UID)
 367                 *p++ = cpu_to_be32(from_kuid(&init_user_ns, attr->ia_uid));
 368         else
 369                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 370         if (attr->ia_valid & ATTR_GID)
 371                 *p++ = cpu_to_be32(from_kgid(&init_user_ns, attr->ia_gid));
 372         else
 373                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 374         if (attr->ia_valid & ATTR_SIZE)
 375                 *p++ = cpu_to_be32((u32)attr->ia_size);
 376         else
 377                 *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
 378
 379         if (attr->ia_valid & ATTR_ATIME_SET) {
 380                 ts = timespec64_to_timespec(attr->ia_atime);
 381                 p = xdr_encode_time(p, &ts);
 382         } else if (attr->ia_valid & ATTR_ATIME) {
 383                 ts = timespec64_to_timespec(attr->ia_atime);
 384                 p = xdr_encode_current_server_time(p, &ts);
 385         } else
 386                 p = xdr_time_not_set(p);
 387         if (attr->ia_valid & ATTR_MTIME_SET) {
 388                 ts = timespec64_to_timespec(attr->ia_atime);
 389                 xdr_encode_time(p, &ts);
 390         } else if (attr->ia_valid & ATTR_MTIME) {
 391                 ts = timespec64_to_timespec(attr->ia_mtime);
 392                 xdr_encode_current_server_time(p, &ts);
 393         } else
 394                 xdr_time_not_set(p);
 395 }
 396
 397 /*
 398  * 2.3.7.  filename
 399  *
 400  *      typedef string filename<MAXNAMLEN>;
 401  */
 402 static void encode_filename(struct xdr_stream *xdr,
 403                             const char *name, u32 length)
 404 {
 405         __be32 *p;
 406
 407         WARN_ON_ONCE(length > NFS2_MAXNAMLEN);
 408         p = xdr_reserve_space(xdr, 4 + length);
 409         xdr_encode_opaque(p, name, length);
 410 }
 411
 412 static int decode_filename_inline(struct xdr_stream *xdr,
 413                                   const char **name, u32 *length)
 414 {
 415         __be32 *p;
 416         u32 count;
 417
 418         p = xdr_inline_decode(xdr, 4);
 419         if (unlikely(p == NULL))
 420                 goto out_overflow;
 421         count = be32_to_cpup(p);
 422         if (count > NFS3_MAXNAMLEN)
 423                 goto out_nametoolong;
 424         p = xdr_inline_decode(xdr, count);
 425         if (unlikely(p == NULL))
 426                 goto out_overflow;
 427         *name = (const char *)p;
 428         *length = count;
 429         return 0;
 430 out_nametoolong:
 431         dprintk("NFS: returned filename too long: %u\n", count);
 432         return -ENAMETOOLONG;
 433 out_overflow:
 434         print_overflow_msg(__func__, xdr);
 435         return -EIO;
 436 }
 437
 438 /*
 439  * 2.3.8.  path
 440  *
 441  *      typedef string path<MAXPATHLEN>;
 442  */
 443 static void encode_path(struct xdr_stream *xdr, struct page **pages, u32 length)
 444 {
 445         __be32 *p;
 446
 447         p = xdr_reserve_space(xdr, 4);
 448         *p = cpu_to_be32(length);
 449         xdr_write_pages(xdr, pages, 0, length);
 450 }
 451
 452 static int decode_path(struct xdr_stream *xdr)
 453 {
 454         u32 length, recvd;
 455         __be32 *p;
 456
 457         p = xdr_inline_decode(xdr, 4);
 458         if (unlikely(p == NULL))
 459                 goto out_overflow;
 460         length = be32_to_cpup(p);
 461         if (unlikely(length >= xdr->buf->page_len || length > NFS_MAXPATHLEN))
 462                 goto out_size;
 463         recvd = xdr_read_pages(xdr, length);
 464         if (unlikely(length > recvd))
 465                 goto out_cheating;
 466         xdr_terminate_string(xdr->buf, length);
 467         return 0;
 468 out_size:
 469         dprintk("NFS: returned pathname too long: %u\n", length);
 470         return -ENAMETOOLONG;
 471 out_cheating:
 472         dprintk("NFS: server cheating in pathname result: "
 473                 "length %u > received %u\n", length, recvd);
 474         return -EIO;
 475 out_overflow:
 476         print_overflow_msg(__func__, xdr);
 477         return -EIO;
 478 }
 479
 480 /*
 481  * 2.3.9.  attrstat
 482  *
 483  *      union attrstat switch (stat status) {
 484  *      case NFS_OK:
 485  *              fattr attributes;
 486  *      default:
 487  *              void;
 488  *      };
 489  */
 490 static int decode_attrstat(struct xdr_stream *xdr, struct nfs_fattr *result,
 491                            __u32 *op_status)
 492 {
 493         enum nfs_stat status;
 494         int error;
 495
 496         error = decode_stat(xdr, &status);
 497         if (unlikely(error))
 498                 goto out;
 499         if (op_status)
 500                 *op_status = status;
 501         if (status != NFS_OK)
 502                 goto out_default;
 503         error = decode_fattr(xdr, result);
 504 out:
 505         return error;
 506 out_default:
 507         return nfs_stat_to_errno(status);
 508 }
 509
 510 /*
 511  * 2.3.10.  diropargs
 512  *
 513  *      struct diropargs {
 514  *              fhandle  dir;
 515  *              filename name;
 516  *      };
 517  */
 518 static void encode_diropargs(struct xdr_stream *xdr, const struct nfs_fh *fh,
 519                              const char *name, u32 length)
 520 {
 521         encode_fhandle(xdr, fh);
 522         encode_filename(xdr, name, length);
 523 }
 524
 525 /*
 526  * 2.3.11.  diropres
 527  *
 528  *      union diropres switch (stat status) {
 529  *      case NFS_OK:
 530  *              struct {
 531  *                      fhandle file;
 532  *                      fattr   attributes;
 533  *              } diropok;
 534  *      default:
 535  *              void;
 536  *      };
 537  */
 538 static int decode_diropok(struct xdr_stream *xdr, struct nfs_diropok *result)
 539 {
 540         int error;
 541
 542         error = decode_fhandle(xdr, result->fh);
 543         if (unlikely(error))
 544                 goto out;
 545         error = decode_fattr(xdr, result->fattr);
 546 out:
 547         return error;
 548 }
 549
 550 static int decode_diropres(struct xdr_stream *xdr, struct nfs_diropok *result)
 551 {
 552         enum nfs_stat status;
 553         int error;
 554
 555         error = decode_stat(xdr, &status);
 556         if (unlikely(error))
 557                 goto out;
 558         if (status != NFS_OK)
 559                 goto out_default;
 560         error = decode_diropok(xdr, result);
 561 out:
 562         return error;
 563 out_default:
 564         return nfs_stat_to_errno(status);
 565 }
 566
 567
 568 /*
 569  * NFSv2 XDR encode functions
 570  *
 571  * NFSv2 argument types are defined in section 2.2 of RFC 1094:
 572  * "NFS: Network File System Protocol Specification".
 573  */
 574
 575 static void nfs2_xdr_enc_fhandle(struct rpc_rqst *req,
 576                                  struct xdr_stream *xdr,
 577                                  const void *data)
 578 {
 579         const struct nfs_fh *fh = data;
 580
 581         encode_fhandle(xdr, fh);
 582 }
 583
 584 /*
 585  * 2.2.3.  sattrargs
 586  *
 587  *      struct sattrargs {
 588  *              fhandle file;
 589  *              sattr attributes;
 590  *      };
 591  */
 592 static void nfs2_xdr_enc_sattrargs(struct rpc_rqst *req,
 593                                    struct xdr_stream *xdr,
 594                                    const void *data)
 595 {
 596         const struct nfs_sattrargs *args = data;
 597
 598         encode_fhandle(xdr, args->fh);
 599         encode_sattr(xdr, args->sattr);
 600 }
 601
 602 static void nfs2_xdr_enc_diropargs(struct rpc_rqst *req,
 603                                    struct xdr_stream *xdr,
 604                                    const void *data)
 605 {
 606         const struct nfs_diropargs *args = data;
 607
 608         encode_diropargs(xdr, args->fh, args->name, args->len);
 609 }
 610
 611 static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req,
 612                                       struct xdr_stream *xdr,
 613                                       const void *data)
 614 {
 615         const struct nfs_readlinkargs *args = data;
 616
 617         encode_fhandle(xdr, args->fh);
 618         prepare_reply_buffer(req, args->pages, args->pgbase,
 619                                         args->pglen, NFS_readlinkres_sz);
 620 }
 621
 622 /*
 623  * 2.2.7.  readargs
 624  *
 625  *      struct readargs {
 626  *              fhandle file;
 627  *              unsigned offset;
 628  *              unsigned count;
 629  *              unsigned totalcount;
 630  *      };
 631  */
 632 static void encode_readargs(struct xdr_stream *xdr,
 633                             const struct nfs_pgio_args *args)
 634 {
 635         u32 offset = args->offset;
 636         u32 count = args->count;
 637         __be32 *p;
 638
 639         encode_fhandle(xdr, args->fh);
 640
 641         p = xdr_reserve_space(xdr, 4 + 4 + 4);
 642         *p++ = cpu_to_be32(offset);
 643         *p++ = cpu_to_be32(count);
 644         *p = cpu_to_be32(count);
 645 }
 646
 647 static void nfs2_xdr_enc_readargs(struct rpc_rqst *req,
 648                                   struct xdr_stream *xdr,
 649                                   const void *data)
 650 {
 651         const struct nfs_pgio_args *args = data;
 652
 653         encode_readargs(xdr, args);
 654         prepare_reply_buffer(req, args->pages, args->pgbase,
 655                                         args->count, NFS_readres_sz);
 656         req->rq_rcv_buf.flags |= XDRBUF_READ;
 657 }
 658
 659 /*
 660  * 2.2.9.  writeargs
 661  *
 662  *      struct writeargs {
 663  *              fhandle file;
 664  *              unsigned beginoffset;
 665  *              unsigned offset;
 666  *              unsigned totalcount;
 667  *              nfsdata data;
 668  *      };
 669  */
 670 static void encode_writeargs(struct xdr_stream *xdr,
 671                              const struct nfs_pgio_args *args)
 672 {
 673         u32 offset = args->offset;
 674         u32 count = args->count;
 675         __be32 *p;
 676
 677         encode_fhandle(xdr, args->fh);
 678
 679         p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4);
 680         *p++ = cpu_to_be32(offset);
 681         *p++ = cpu_to_be32(offset);
 682         *p++ = cpu_to_be32(count);
 683
 684         /* nfsdata */
 685         *p = cpu_to_be32(count);
 686         xdr_write_pages(xdr, args->pages, args->pgbase, count);
 687 }
 688
 689 static void nfs2_xdr_enc_writeargs(struct rpc_rqst *req,
 690                                    struct xdr_stream *xdr,
 691                                    const void *data)
 692 {
 693         const struct nfs_pgio_args *args = data;
 694
 695         encode_writeargs(xdr, args);
 696         xdr->buf->flags |= XDRBUF_WRITE;
 697 }
 698
 699 /*
 700  * 2.2.10.  createargs
 701  *
 702  *      struct createargs {
 703  *              diropargs where;
 704  *              sattr attributes;
 705  *      };
 706  */
 707 static void nfs2_xdr_enc_createargs(struct rpc_rqst *req,
 708                                     struct xdr_stream *xdr,
 709                                     const void *data)
 710 {
 711         const struct nfs_createargs *args = data;
 712
 713         encode_diropargs(xdr, args->fh, args->name, args->len);
 714         encode_sattr(xdr, args->sattr);
 715 }
 716
 717 static void nfs2_xdr_enc_removeargs(struct rpc_rqst *req,
 718                                     struct xdr_stream *xdr,
 719                                     const void *data)
 720 {
 721         const struct nfs_removeargs *args = data;
 722
 723         encode_diropargs(xdr, args->fh, args->name.name, args->name.len);
 724 }
 725
 726 /*
 727  * 2.2.12.  renameargs
 728  *
 729  *      struct renameargs {
 730  *              diropargs from;
 731  *              diropargs to;
 732  *      };
 733  */
 734 static void nfs2_xdr_enc_renameargs(struct rpc_rqst *req,
 735                                     struct xdr_stream *xdr,
 736                                     const void *data)
 737 {
 738         const struct nfs_renameargs *args = data;
 739         const struct qstr *old = args->old_name;
 740         const struct qstr *new = args->new_name;
 741
 742         encode_diropargs(xdr, args->old_dir, old->name, old->len);
 743         encode_diropargs(xdr, args->new_dir, new->name, new->len);
 744 }
 745
 746 /*
 747  * 2.2.13.  linkargs
 748  *
 749  *      struct linkargs {
 750  *              fhandle from;
 751  *              diropargs to;
 752  *      };
 753  */
 754 static void nfs2_xdr_enc_linkargs(struct rpc_rqst *req,
 755                                   struct xdr_stream *xdr,
 756                                   const void *data)
 757 {
 758         const struct nfs_linkargs *args = data;
 759
 760         encode_fhandle(xdr, args->fromfh);
 761         encode_diropargs(xdr, args->tofh, args->toname, args->tolen);
 762 }
 763
 764 /*
 765  * 2.2.14.  symlinkargs
 766  *
 767  *      struct symlinkargs {
 768  *              diropargs from;
 769  *              path to;
 770  *              sattr attributes;
 771  *      };
 772  */
 773 static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req,
 774                                      struct xdr_stream *xdr,
 775                                      const void *data)
 776 {
 777         const struct nfs_symlinkargs *args = data;
 778
 779         encode_diropargs(xdr, args->fromfh, args->fromname, args->fromlen);
 780         encode_path(xdr, args->pages, args->pathlen);
 781         encode_sattr(xdr, args->sattr);
 782 }
 783
 784 /*
 785  * 2.2.17.  readdirargs
 786  *
 787  *      struct readdirargs {
 788  *              fhandle dir;
 789  *              nfscookie cookie;
 790  *              unsigned count;
 791  *      };
 792  */
 793 static void encode_readdirargs(struct xdr_stream *xdr,
 794                                const struct nfs_readdirargs *args)
 795 {
 796         __be32 *p;
 797
 798         encode_fhandle(xdr, args->fh);
 799
 800         p = xdr_reserve_space(xdr, 4 + 4);
 801         *p++ = cpu_to_be32(args->cookie);
 802         *p = cpu_to_be32(args->count);
 803 }
 804
 805 static void nfs2_xdr_enc_readdirargs(struct rpc_rqst *req,
 806                                      struct xdr_stream *xdr,
 807                                      const void *data)
 808 {
 809         const struct nfs_readdirargs *args = data;
 810
 811         encode_readdirargs(xdr, args);
 812         prepare_reply_buffer(req, args->pages, 0,
 813                                         args->count, NFS_readdirres_sz);
 814 }
 815
 816 /*
 817  * NFSv2 XDR decode functions
 818  *
 819  * NFSv2 result types are defined in section 2.2 of RFC 1094:
 820  * "NFS: Network File System Protocol Specification".
 821  */
 822
 823 static int nfs2_xdr_dec_stat(struct rpc_rqst *req, struct xdr_stream *xdr,
 824                              void *__unused)
 825 {
 826         enum nfs_stat status;
 827         int error;
 828
 829         error = decode_stat(xdr, &status);
 830         if (unlikely(error))
 831                 goto out;
 832         if (status != NFS_OK)
 833                 goto out_default;
 834 out:
 835         return error;
 836 out_default:
 837         return nfs_stat_to_errno(status);
 838 }
 839
 840 static int nfs2_xdr_dec_attrstat(struct rpc_rqst *req, struct xdr_stream *xdr,
 841                                  void *result)
 842 {
 843         return decode_attrstat(xdr, result, NULL);
 844 }
 845
 846 static int nfs2_xdr_dec_diropres(struct rpc_rqst *req, struct xdr_stream *xdr,
 847                                  void *result)
 848 {
 849         return decode_diropres(xdr, result);
 850 }
 851
 852 /*
 853  * 2.2.6.  readlinkres
 854  *
 855  *      union readlinkres switch (stat status) {
 856  *      case NFS_OK:
 857  *              path data;
 858  *      default:
 859  *              void;
 860  *      };
 861  */
 862 static int nfs2_xdr_dec_readlinkres(struct rpc_rqst *req,
 863                                     struct xdr_stream *xdr, void *__unused)
 864 {
 865         enum nfs_stat status;
 866         int error;
 867
 868         error = decode_stat(xdr, &status);
 869         if (unlikely(error))
 870                 goto out;
 871         if (status != NFS_OK)
 872                 goto out_default;
 873         error = decode_path(xdr);
 874 out:
 875         return error;
 876 out_default:
 877         return nfs_stat_to_errno(status);
 878 }
 879
 880 /*
 881  * 2.2.7.  readres
 882  *
 883  *      union readres switch (stat status) {
 884  *      case NFS_OK:
 885  *              fattr attributes;
 886  *              nfsdata data;
 887  *      default:
 888  *              void;
 889  *      };
 890  */
 891 static int nfs2_xdr_dec_readres(struct rpc_rqst *req, struct xdr_stream *xdr,
 892                                 void *data)
 893 {
 894         struct nfs_pgio_res *result = data;
 895         enum nfs_stat status;
 896         int error;
 897
 898         error = decode_stat(xdr, &status);
 899         if (unlikely(error))
 900                 goto out;
 901         result->op_status = status;
 902         if (status != NFS_OK)
 903                 goto out_default;
 904         error = decode_fattr(xdr, result->fattr);
 905         if (unlikely(error))
 906                 goto out;
 907         error = decode_nfsdata(xdr, result);
 908 out:
 909         return error;
 910 out_default:
 911         return nfs_stat_to_errno(status);
 912 }
 913
 914 static int nfs2_xdr_dec_writeres(struct rpc_rqst *req, struct xdr_stream *xdr,
 915                                  void *data)
 916 {
 917         struct nfs_pgio_res *result = data;
 918
 919         /* All NFSv2 writes are "file sync" writes */
 920         result->verf->committed = NFS_FILE_SYNC;
 921         return decode_attrstat(xdr, result->fattr, &result->op_status);
 922 }
 923
 924 /**
 925  * nfs2_decode_dirent - Decode a single NFSv2 directory entry stored in
 926  *                      the local page cache.
 927  * @xdr: XDR stream where entry resides
 928  * @entry: buffer to fill in with entry data
 929  * @plus: boolean indicating whether this should be a readdirplus entry
 930  *
 931  * Returns zero if successful, otherwise a negative errno value is
 932  * returned.
 933  *
 934  * This function is not invoked during READDIR reply decoding, but
 935  * rather whenever an application invokes the getdents(2) system call
 936  * on a directory already in our cache.
 937  *
 938  * 2.2.17.  entry
 939  *
 940  *      struct entry {
 941  *              unsigned        fileid;
 942  *              filename        name;
 943  *              nfscookie       cookie;
 944  *              entry           *nextentry;
 945  *      };
 946  */
 947 int nfs2_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
 948                        bool plus)
 949 {
 950         __be32 *p;
 951         int error;
 952
 953         p = xdr_inline_decode(xdr, 4);
 954         if (unlikely(p == NULL))
 955                 goto out_overflow;
 956         if (*p++ == xdr_zero) {
 957                 p = xdr_inline_decode(xdr, 4);
 958                 if (unlikely(p == NULL))
 959                         goto out_overflow;
 960                 if (*p++ == xdr_zero)
 961                         return -EAGAIN;
 962                 entry->eof = 1;
 963                 return -EBADCOOKIE;
 964         }
 965
 966         p = xdr_inline_decode(xdr, 4);
 967         if (unlikely(p == NULL))
 968                 goto out_overflow;
 969         entry->ino = be32_to_cpup(p);
 970
 971         error = decode_filename_inline(xdr, &entry->name, &entry->len);
 972         if (unlikely(error))
 973                 return error;
 974
 975         /*
 976          * The type (size and byte order) of nfscookie isn't defined in
 977          * RFC 1094.  This implementation assumes that it's an XDR uint32.
 978          */
 979         entry->prev_cookie = entry->cookie;
 980         p = xdr_inline_decode(xdr, 4);
 981         if (unlikely(p == NULL))
 982                 goto out_overflow;
 983         entry->cookie = be32_to_cpup(p);
 984
 985         entry->d_type = DT_UNKNOWN;
 986
 987         return 0;
 988
 989 out_overflow:
 990         print_overflow_msg(__func__, xdr);
 991         return -EAGAIN;
 992 }
 993
 994 /*
 995  * 2.2.17.  readdirres
 996  *
 997  *      union readdirres switch (stat status) {
 998  *      case NFS_OK:
 999  *              struct {
1000  *                      entry *entries;
1001  *                      bool eof;
1002  *              } readdirok;
1003  *      default:
1004  *              void;
1005  *      };
1006  *
1007  * Read the directory contents into the page cache, but don't
1008  * touch them.  The actual decoding is done by nfs2_decode_dirent()
1009  * during subsequent nfs_readdir() calls.
1010  */
1011 static int decode_readdirok(struct xdr_stream *xdr)
1012 {
1013         return xdr_read_pages(xdr, xdr->buf->page_len);
1014 }
1015
1016 static int nfs2_xdr_dec_readdirres(struct rpc_rqst *req,
1017                                    struct xdr_stream *xdr, void *__unused)
1018 {
1019         enum nfs_stat status;
1020         int error;
1021
1022         error = decode_stat(xdr, &status);
1023         if (unlikely(error))
1024                 goto out;
1025         if (status != NFS_OK)
1026                 goto out_default;
1027         error = decode_readdirok(xdr);
1028 out:
1029         return error;
1030 out_default:
1031         return nfs_stat_to_errno(status);
1032 }
1033
1034 /*
1035  * 2.2.18.  statfsres
1036  *
1037  *      union statfsres (stat status) {
1038  *      case NFS_OK:
1039  *              struct {
1040  *                      unsigned tsize;
1041  *                      unsigned bsize;
1042  *                      unsigned blocks;
1043  *                      unsigned bfree;
1044  *                      unsigned bavail;
1045  *              } info;
1046  *      default:
1047  *              void;
1048  *      };
1049  */
1050 static int decode_info(struct xdr_stream *xdr, struct nfs2_fsstat *result)
1051 {
1052         __be32 *p;
1053
1054         p = xdr_inline_decode(xdr, NFS_info_sz << 2);
1055         if (unlikely(p == NULL))
1056                 goto out_overflow;
1057         result->tsize  = be32_to_cpup(p++);
1058         result->bsize  = be32_to_cpup(p++);
1059         result->blocks = be32_to_cpup(p++);
1060         result->bfree  = be32_to_cpup(p++);
1061         result->bavail = be32_to_cpup(p);
1062         return 0;
1063 out_overflow:
1064         print_overflow_msg(__func__, xdr);
1065         return -EIO;
1066 }
1067
1068 static int nfs2_xdr_dec_statfsres(struct rpc_rqst *req, struct xdr_stream *xdr,
1069                                   void *result)
1070 {
1071         enum nfs_stat status;
1072         int error;
1073
1074         error = decode_stat(xdr, &status);
1075         if (unlikely(error))
1076                 goto out;
1077         if (status != NFS_OK)
1078                 goto out_default;
1079         error = decode_info(xdr, result);
1080 out:
1081         return error;
1082 out_default:
1083         return nfs_stat_to_errno(status);
1084 }
1085
1086
1087 /*
1088  * We need to translate between nfs status return values and
1089  * the local errno values which may not be the same.
1090  */
1091 static const struct {
1092         int stat;
1093         int errno;
1094 } nfs_errtbl[] = {
1095         { NFS_OK,               0               },
1096         { NFSERR_PERM,          -EPERM          },
1097         { NFSERR_NOENT,         -ENOENT         },
1098         { NFSERR_IO,            -errno_NFSERR_IO},
1099         { NFSERR_NXIO,          -ENXIO          },
1100 /*      { NFSERR_EAGAIN,        -EAGAIN         }, */
1101         { NFSERR_ACCES,         -EACCES         },
1102         { NFSERR_EXIST,         -EEXIST         },
1103         { NFSERR_XDEV,          -EXDEV          },
1104         { NFSERR_NODEV,         -ENODEV         },
1105         { NFSERR_NOTDIR,        -ENOTDIR        },
1106         { NFSERR_ISDIR,         -EISDIR         },
1107         { NFSERR_INVAL,         -EINVAL         },
1108         { NFSERR_FBIG,          -EFBIG          },
1109         { NFSERR_NOSPC,         -ENOSPC         },
1110         { NFSERR_ROFS,          -EROFS          },
1111         { NFSERR_MLINK,         -EMLINK         },
1112         { NFSERR_NAMETOOLONG,   -ENAMETOOLONG   },
1113         { NFSERR_NOTEMPTY,      -ENOTEMPTY      },
1114         { NFSERR_DQUOT,         -EDQUOT         },
1115         { NFSERR_STALE,         -ESTALE         },
1116         { NFSERR_REMOTE,        -EREMOTE        },
1117 #ifdef EWFLUSH
1118         { NFSERR_WFLUSH,        -EWFLUSH        },
1119 #endif
1120         { NFSERR_BADHANDLE,     -EBADHANDLE     },
1121         { NFSERR_NOT_SYNC,      -ENOTSYNC       },
1122         { NFSERR_BAD_COOKIE,    -EBADCOOKIE     },
1123         { NFSERR_NOTSUPP,       -ENOTSUPP       },
1124         { NFSERR_TOOSMALL,      -ETOOSMALL      },
1125         { NFSERR_SERVERFAULT,   -EREMOTEIO      },
1126         { NFSERR_BADTYPE,       -EBADTYPE       },
1127         { NFSERR_JUKEBOX,       -EJUKEBOX       },
1128         { -1,                   -EIO            }
1129 };
1130
1131 /**
1132  * nfs_stat_to_errno - convert an NFS status code to a local errno
1133  * @status: NFS status code to convert
1134  *
1135  * Returns a local errno value, or -EIO if the NFS status code is
1136  * not recognized.  This function is used jointly by NFSv2 and NFSv3.
1137  */
1138 static int nfs_stat_to_errno(enum nfs_stat status)
1139 {
1140         int i;
1141
1142         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
1143                 if (nfs_errtbl[i].stat == (int)status)
1144                         return nfs_errtbl[i].errno;
1145         }
1146         dprintk("NFS: Unrecognized nfs status value: %u\n", status);
1147         return nfs_errtbl[i].errno;
1148 }
1149
1150 #define PROC(proc, argtype, restype, timer)                             \
1151 [NFSPROC_##proc] = {                                                    \
1152         .p_proc     =  NFSPROC_##proc,                                  \
1153         .p_encode   =  nfs2_xdr_enc_##argtype,                          \
1154         .p_decode   =  nfs2_xdr_dec_##restype,                          \
1155         .p_arglen   =  NFS_##argtype##_sz,                              \
1156         .p_replen   =  NFS_##restype##_sz,                              \
1157         .p_timer    =  timer,                                           \
1158         .p_statidx  =  NFSPROC_##proc,                                  \
1159         .p_name     =  #proc,                                           \
1160         }
1161 const struct rpc_procinfo nfs_procedures[] = {
1162         PROC(GETATTR,   fhandle,        attrstat,       1),
1163         PROC(SETATTR,   sattrargs,      attrstat,       0),
1164         PROC(LOOKUP,    diropargs,      diropres,       2),
1165         PROC(READLINK,  readlinkargs,   readlinkres,    3),
1166         PROC(READ,      readargs,       readres,        3),
1167         PROC(WRITE,     writeargs,      writeres,       4),
1168         PROC(CREATE,    createargs,     diropres,       0),
1169         PROC(REMOVE,    removeargs,     stat,           0),
1170         PROC(RENAME,    renameargs,     stat,           0),
1171         PROC(LINK,      linkargs,       stat,           0),
1172         PROC(SYMLINK,   symlinkargs,    stat,           0),
1173         PROC(MKDIR,     createargs,     diropres,       0),
1174         PROC(RMDIR,     diropargs,      stat,           0),
1175         PROC(READDIR,   readdirargs,    readdirres,     3),
1176         PROC(STATFS,    fhandle,        statfsres,      0),
1177 };
1178
1179 static unsigned int nfs_version2_counts[ARRAY_SIZE(nfs_procedures)];
1180 const struct rpc_version nfs_version2 = {
1181         .number                 = 2,
1182         .nrprocs                = ARRAY_SIZE(nfs_procedures),
1183         .procs                  = nfs_procedures,
1184         .counts                 = nfs_version2_counts,
1185 };