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