LXR linux/fs/nfs/nfs3xdr.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * linux/fs/nfs/nfs3xdr.c
   4 *
   5 * XDR functions to encode/decode NFSv3 RPC arguments and results.
   6 *
   7 * Copyright (C) 1996, 1997 Olaf Kirch
   8 */
   9
  10#include <linux/param.h>
  11#include <linux/time.h>
  12#include <linux/mm.h>
  13#include <linux/errno.h>
  14#include <linux/string.h>
  15#include <linux/in.h>
  16#include <linux/pagemap.h>
  17#include <linux/proc_fs.h>
  18#include <linux/kdev_t.h>
  19#include <linux/sunrpc/clnt.h>
  20#include <linux/nfs.h>
  21#include <linux/nfs3.h>
  22#include <linux/nfs_fs.h>
  23#include <linux/nfsacl.h>
  24#include "nfstrace.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 NFS3_pagepad_sz         (1) /* Page padding */
  37#define NFS3_fhandle_sz         (1+16)
  38#define NFS3_fh_sz              (NFS3_fhandle_sz)       /* shorthand */
  39#define NFS3_post_op_fh_sz      (1+NFS3_fh_sz)
  40#define NFS3_sattr_sz           (15)
  41#define NFS3_filename_sz        (1+(NFS3_MAXNAMLEN>>2))
  42#define NFS3_path_sz            (1+(NFS3_MAXPATHLEN>>2))
  43#define NFS3_fattr_sz           (21)
  44#define NFS3_cookieverf_sz      (NFS3_COOKIEVERFSIZE>>2)
  45#define NFS3_wcc_attr_sz        (6)
  46#define NFS3_pre_op_attr_sz     (1+NFS3_wcc_attr_sz)
  47#define NFS3_post_op_attr_sz    (1+NFS3_fattr_sz)
  48#define NFS3_wcc_data_sz        (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
  49#define NFS3_diropargs_sz       (NFS3_fh_sz+NFS3_filename_sz)
  50
  51#define NFS3_getattrargs_sz     (NFS3_fh_sz)
  52#define NFS3_setattrargs_sz     (NFS3_fh_sz+NFS3_sattr_sz+3)
  53#define NFS3_lookupargs_sz      (NFS3_fh_sz+NFS3_filename_sz)
  54#define NFS3_accessargs_sz      (NFS3_fh_sz+1)
  55#define NFS3_readlinkargs_sz    (NFS3_fh_sz)
  56#define NFS3_readargs_sz        (NFS3_fh_sz+3)
  57#define NFS3_writeargs_sz       (NFS3_fh_sz+5)
  58#define NFS3_createargs_sz      (NFS3_diropargs_sz+NFS3_sattr_sz)
  59#define NFS3_mkdirargs_sz       (NFS3_diropargs_sz+NFS3_sattr_sz)
  60#define NFS3_symlinkargs_sz     (NFS3_diropargs_sz+1+NFS3_sattr_sz)
  61#define NFS3_mknodargs_sz       (NFS3_diropargs_sz+2+NFS3_sattr_sz)
  62#define NFS3_removeargs_sz      (NFS3_fh_sz+NFS3_filename_sz)
  63#define NFS3_renameargs_sz      (NFS3_diropargs_sz+NFS3_diropargs_sz)
  64#define NFS3_linkargs_sz                (NFS3_fh_sz+NFS3_diropargs_sz)
  65#define NFS3_readdirargs_sz     (NFS3_fh_sz+NFS3_cookieverf_sz+3)
  66#define NFS3_readdirplusargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+4)
  67#define NFS3_commitargs_sz      (NFS3_fh_sz+3)
  68
  69#define NFS3_getattrres_sz      (1+NFS3_fattr_sz)
  70#define NFS3_setattrres_sz      (1+NFS3_wcc_data_sz)
  71#define NFS3_removeres_sz       (NFS3_setattrres_sz)
  72#define NFS3_lookupres_sz       (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz))
  73#define NFS3_accessres_sz       (1+NFS3_post_op_attr_sz+1)
  74#define NFS3_readlinkres_sz     (1+NFS3_post_op_attr_sz+1+NFS3_pagepad_sz)
  75#define NFS3_readres_sz         (1+NFS3_post_op_attr_sz+3+NFS3_pagepad_sz)
  76#define NFS3_writeres_sz        (1+NFS3_wcc_data_sz+4)
  77#define NFS3_createres_sz       (1+NFS3_post_op_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
  78#define NFS3_renameres_sz       (1+(2 * NFS3_wcc_data_sz))
  79#define NFS3_linkres_sz         (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
  80#define NFS3_readdirres_sz      (1+NFS3_post_op_attr_sz+2+NFS3_pagepad_sz)
  81#define NFS3_fsstatres_sz       (1+NFS3_post_op_attr_sz+13)
  82#define NFS3_fsinfores_sz       (1+NFS3_post_op_attr_sz+12)
  83#define NFS3_pathconfres_sz     (1+NFS3_post_op_attr_sz+6)
  84#define NFS3_commitres_sz       (1+NFS3_wcc_data_sz+2)
  85
  86#define ACL3_getaclargs_sz      (NFS3_fh_sz+1)
  87#define ACL3_setaclargs_sz      (NFS3_fh_sz+1+ \
  88                                XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
  89#define ACL3_getaclres_sz       (1+NFS3_post_op_attr_sz+1+ \
  90                                XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE)+\
  91                                NFS3_pagepad_sz)
  92#define ACL3_setaclres_sz       (1+NFS3_post_op_attr_sz)
  93
  94static int nfs3_stat_to_errno(enum nfs_stat);
  95
  96/*
  97 * Map file type to S_IFMT bits
  98 */
  99static const umode_t nfs_type2fmt[] = {
 100        [NF3BAD] = 0,
 101        [NF3REG] = S_IFREG,
 102        [NF3DIR] = S_IFDIR,
 103        [NF3BLK] = S_IFBLK,
 104        [NF3CHR] = S_IFCHR,
 105        [NF3LNK] = S_IFLNK,
 106        [NF3SOCK] = S_IFSOCK,
 107        [NF3FIFO] = S_IFIFO,
 108};
 109
 110static struct user_namespace *rpc_userns(const struct rpc_clnt *clnt)
 111{
 112        if (clnt && clnt->cl_cred)
 113                return clnt->cl_cred->user_ns;
 114        return &init_user_ns;
 115}
 116
 117static struct user_namespace *rpc_rqst_userns(const struct rpc_rqst *rqstp)
 118{
 119        if (rqstp->rq_task)
 120                return rpc_userns(rqstp->rq_task->tk_client);
 121        return &init_user_ns;
 122}
 123
 124/*
 125 * Encode/decode NFSv3 basic data types
 126 *
 127 * Basic NFSv3 data types are defined in section 2.5 of RFC 1813:
 128 * "NFS Version 3 Protocol Specification".
 129 *
 130 * Not all basic data types have their own encoding and decoding
 131 * functions.  For run-time efficiency, some data types are encoded
 132 * or decoded inline.
 133 */
 134
 135static void encode_uint32(struct xdr_stream *xdr, u32 value)
 136{
 137        __be32 *p = xdr_reserve_space(xdr, 4);
 138        *p = cpu_to_be32(value);
 139}
 140
 141static int decode_uint32(struct xdr_stream *xdr, u32 *value)
 142{
 143        __be32 *p;
 144
 145        p = xdr_inline_decode(xdr, 4);
 146        if (unlikely(!p))
 147                return -EIO;
 148        *value = be32_to_cpup(p);
 149        return 0;
 150}
 151
 152static int decode_uint64(struct xdr_stream *xdr, u64 *value)
 153{
 154        __be32 *p;
 155
 156        p = xdr_inline_decode(xdr, 8);
 157        if (unlikely(!p))
 158                return -EIO;
 159        xdr_decode_hyper(p, value);
 160        return 0;
 161}
 162
 163/*
 164 * fileid3
 165 *
 166 *      typedef uint64 fileid3;
 167 */
 168static __be32 *xdr_decode_fileid3(__be32 *p, u64 *fileid)
 169{
 170        return xdr_decode_hyper(p, fileid);
 171}
 172
 173static int decode_fileid3(struct xdr_stream *xdr, u64 *fileid)
 174{
 175        return decode_uint64(xdr, fileid);
 176}
 177
 178/*
 179 * filename3
 180 *
 181 *      typedef string filename3<>;
 182 */
 183static void encode_filename3(struct xdr_stream *xdr,
 184                             const char *name, u32 length)
 185{
 186        __be32 *p;
 187
 188        WARN_ON_ONCE(length > NFS3_MAXNAMLEN);
 189        p = xdr_reserve_space(xdr, 4 + length);
 190        xdr_encode_opaque(p, name, length);
 191}
 192
 193static int decode_inline_filename3(struct xdr_stream *xdr,
 194                                   const char **name, u32 *length)
 195{
 196        __be32 *p;
 197        u32 count;
 198
 199        p = xdr_inline_decode(xdr, 4);
 200        if (unlikely(!p))
 201                return -EIO;
 202        count = be32_to_cpup(p);
 203        if (count > NFS3_MAXNAMLEN)
 204                goto out_nametoolong;
 205        p = xdr_inline_decode(xdr, count);
 206        if (unlikely(!p))
 207                return -EIO;
 208        *name = (const char *)p;
 209        *length = count;
 210        return 0;
 211
 212out_nametoolong:
 213        dprintk("NFS: returned filename too long: %u\n", count);
 214        return -ENAMETOOLONG;
 215}
 216
 217/*
 218 * nfspath3
 219 *
 220 *      typedef string nfspath3<>;
 221 */
 222static void encode_nfspath3(struct xdr_stream *xdr, struct page **pages,
 223                            const u32 length)
 224{
 225        encode_uint32(xdr, length);
 226        xdr_write_pages(xdr, pages, 0, length);
 227}
 228
 229static int decode_nfspath3(struct xdr_stream *xdr)
 230{
 231        u32 recvd, count;
 232        __be32 *p;
 233
 234        p = xdr_inline_decode(xdr, 4);
 235        if (unlikely(!p))
 236                return -EIO;
 237        count = be32_to_cpup(p);
 238        if (unlikely(count >= xdr->buf->page_len || count > NFS3_MAXPATHLEN))
 239                goto out_nametoolong;
 240        recvd = xdr_read_pages(xdr, count);
 241        if (unlikely(count > recvd))
 242                goto out_cheating;
 243        xdr_terminate_string(xdr->buf, count);
 244        return 0;
 245
 246out_nametoolong:
 247        dprintk("NFS: returned pathname too long: %u\n", count);
 248        return -ENAMETOOLONG;
 249out_cheating:
 250        dprintk("NFS: server cheating in pathname result: "
 251                "count %u > recvd %u\n", count, recvd);
 252        return -EIO;
 253}
 254
 255/*
 256 * cookie3
 257 *
 258 *      typedef uint64 cookie3
 259 */
 260static __be32 *xdr_encode_cookie3(__be32 *p, u64 cookie)
 261{
 262        return xdr_encode_hyper(p, cookie);
 263}
 264
 265static int decode_cookie3(struct xdr_stream *xdr, u64 *cookie)
 266{
 267        return decode_uint64(xdr, cookie);
 268}
 269
 270/*
 271 * cookieverf3
 272 *
 273 *      typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
 274 */
 275static __be32 *xdr_encode_cookieverf3(__be32 *p, const __be32 *verifier)
 276{
 277        memcpy(p, verifier, NFS3_COOKIEVERFSIZE);
 278        return p + XDR_QUADLEN(NFS3_COOKIEVERFSIZE);
 279}
 280
 281static int decode_cookieverf3(struct xdr_stream *xdr, __be32 *verifier)
 282{
 283        __be32 *p;
 284
 285        p = xdr_inline_decode(xdr, NFS3_COOKIEVERFSIZE);
 286        if (unlikely(!p))
 287                return -EIO;
 288        memcpy(verifier, p, NFS3_COOKIEVERFSIZE);
 289        return 0;
 290}
 291
 292/*
 293 * createverf3
 294 *
 295 *      typedef opaque createverf3[NFS3_CREATEVERFSIZE];
 296 */
 297static void encode_createverf3(struct xdr_stream *xdr, const __be32 *verifier)
 298{
 299        __be32 *p;
 300
 301        p = xdr_reserve_space(xdr, NFS3_CREATEVERFSIZE);
 302        memcpy(p, verifier, NFS3_CREATEVERFSIZE);
 303}
 304
 305static int decode_writeverf3(struct xdr_stream *xdr, struct nfs_write_verifier *verifier)
 306{
 307        __be32 *p;
 308
 309        p = xdr_inline_decode(xdr, NFS3_WRITEVERFSIZE);
 310        if (unlikely(!p))
 311                return -EIO;
 312        memcpy(verifier->data, p, NFS3_WRITEVERFSIZE);
 313        return 0;
 314}
 315
 316/*
 317 * size3
 318 *
 319 *      typedef uint64 size3;
 320 */
 321static __be32 *xdr_decode_size3(__be32 *p, u64 *size)
 322{
 323        return xdr_decode_hyper(p, size);
 324}
 325
 326/*
 327 * nfsstat3
 328 *
 329 *      enum nfsstat3 {
 330 *              NFS3_OK = 0,
 331 *              ...
 332 *      }
 333 */
 334#define NFS3_OK         NFS_OK
 335
 336static int decode_nfsstat3(struct xdr_stream *xdr, enum nfs_stat *status)
 337{
 338        __be32 *p;
 339
 340        p = xdr_inline_decode(xdr, 4);
 341        if (unlikely(!p))
 342                return -EIO;
 343        if (unlikely(*p != cpu_to_be32(NFS3_OK)))
 344                goto out_status;
 345        *status = 0;
 346        return 0;
 347out_status:
 348        *status = be32_to_cpup(p);
 349        trace_nfs_xdr_status(xdr, (int)*status);
 350        return 0;
 351}
 352
 353/*
 354 * ftype3
 355 *
 356 *      enum ftype3 {
 357 *              NF3REG  = 1,
 358 *              NF3DIR  = 2,
 359 *              NF3BLK  = 3,
 360 *              NF3CHR  = 4,
 361 *              NF3LNK  = 5,
 362 *              NF3SOCK = 6,
 363 *              NF3FIFO = 7
 364 *      };
 365 */
 366static void encode_ftype3(struct xdr_stream *xdr, const u32 type)
 367{
 368        encode_uint32(xdr, type);
 369}
 370
 371static __be32 *xdr_decode_ftype3(__be32 *p, umode_t *mode)
 372{
 373        u32 type;
 374
 375        type = be32_to_cpup(p++);
 376        if (type > NF3FIFO)
 377                type = NF3NON;
 378        *mode = nfs_type2fmt[type];
 379        return p;
 380}
 381
 382/*
 383 * specdata3
 384 *
 385 *     struct specdata3 {
 386 *             uint32  specdata1;
 387 *             uint32  specdata2;
 388 *     };
 389 */
 390static void encode_specdata3(struct xdr_stream *xdr, const dev_t rdev)
 391{
 392        __be32 *p;
 393
 394        p = xdr_reserve_space(xdr, 8);
 395        *p++ = cpu_to_be32(MAJOR(rdev));
 396        *p = cpu_to_be32(MINOR(rdev));
 397}
 398
 399static __be32 *xdr_decode_specdata3(__be32 *p, dev_t *rdev)
 400{
 401        unsigned int major, minor;
 402
 403        major = be32_to_cpup(p++);
 404        minor = be32_to_cpup(p++);
 405        *rdev = MKDEV(major, minor);
 406        if (MAJOR(*rdev) != major || MINOR(*rdev) != minor)
 407                *rdev = 0;
 408        return p;
 409}
 410
 411/*
 412 * nfs_fh3
 413 *
 414 *      struct nfs_fh3 {
 415 *              opaque       data<NFS3_FHSIZE>;
 416 *      };
 417 */
 418static void encode_nfs_fh3(struct xdr_stream *xdr, const struct nfs_fh *fh)
 419{
 420        __be32 *p;
 421
 422        WARN_ON_ONCE(fh->size > NFS3_FHSIZE);
 423        p = xdr_reserve_space(xdr, 4 + fh->size);
 424        xdr_encode_opaque(p, fh->data, fh->size);
 425}
 426
 427static int decode_nfs_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
 428{
 429        u32 length;
 430        __be32 *p;
 431
 432        p = xdr_inline_decode(xdr, 4);
 433        if (unlikely(!p))
 434                return -EIO;
 435        length = be32_to_cpup(p++);
 436        if (unlikely(length > NFS3_FHSIZE || length == 0))
 437                goto out_toobig;
 438        p = xdr_inline_decode(xdr, length);
 439        if (unlikely(!p))
 440                return -EIO;
 441        fh->size = length;
 442        memcpy(fh->data, p, length);
 443        return 0;
 444out_toobig:
 445        trace_nfs_xdr_bad_filehandle(xdr, NFSERR_BADHANDLE);
 446        return -E2BIG;
 447}
 448
 449static void zero_nfs_fh3(struct nfs_fh *fh)
 450{
 451        memset(fh, 0, sizeof(*fh));
 452}
 453
 454/*
 455 * nfstime3
 456 *
 457 *      struct nfstime3 {
 458 *              uint32  seconds;
 459 *              uint32  nseconds;
 460 *      };
 461 */
 462static __be32 *xdr_encode_nfstime3(__be32 *p, const struct timespec64 *timep)
 463{
 464        *p++ = cpu_to_be32((u32)timep->tv_sec);
 465        *p++ = cpu_to_be32(timep->tv_nsec);
 466        return p;
 467}
 468
 469static __be32 *xdr_decode_nfstime3(__be32 *p, struct timespec64 *timep)
 470{
 471        timep->tv_sec = be32_to_cpup(p++);
 472        timep->tv_nsec = be32_to_cpup(p++);
 473        return p;
 474}
 475
 476/*
 477 * sattr3
 478 *
 479 *      enum time_how {
 480 *              DONT_CHANGE             = 0,
 481 *              SET_TO_SERVER_TIME      = 1,
 482 *              SET_TO_CLIENT_TIME      = 2
 483 *      };
 484 *
 485 *      union set_mode3 switch (bool set_it) {
 486 *      case TRUE:
 487 *              mode3   mode;
 488 *      default:
 489 *              void;
 490 *      };
 491 *
 492 *      union set_uid3 switch (bool set_it) {
 493 *      case TRUE:
 494 *              uid3    uid;
 495 *      default:
 496 *              void;
 497 *      };
 498 *
 499 *      union set_gid3 switch (bool set_it) {
 500 *      case TRUE:
 501 *              gid3    gid;
 502 *      default:
 503 *              void;
 504 *      };
 505 *
 506 *      union set_size3 switch (bool set_it) {
 507 *      case TRUE:
 508 *              size3   size;
 509 *      default:
 510 *              void;
 511 *      };
 512 *
 513 *      union set_atime switch (time_how set_it) {
 514 *      case SET_TO_CLIENT_TIME:
 515 *              nfstime3        atime;
 516 *      default:
 517 *              void;
 518 *      };
 519 *
 520 *      union set_mtime switch (time_how set_it) {
 521 *      case SET_TO_CLIENT_TIME:
 522 *              nfstime3  mtime;
 523 *      default:
 524 *              void;
 525 *      };
 526 *
 527 *      struct sattr3 {
 528 *              set_mode3       mode;
 529 *              set_uid3        uid;
 530 *              set_gid3        gid;
 531 *              set_size3       size;
 532 *              set_atime       atime;
 533 *              set_mtime       mtime;
 534 *      };
 535 */
 536static void encode_sattr3(struct xdr_stream *xdr, const struct iattr *attr,
 537                struct user_namespace *userns)
 538{
 539        u32 nbytes;
 540        __be32 *p;
 541
 542        /*
 543         * In order to make only a single xdr_reserve_space() call,
 544         * pre-compute the total number of bytes to be reserved.
 545         * Six boolean values, one for each set_foo field, are always
 546         * present in the encoded result, so start there.
 547         */
 548        nbytes = 6 * 4;
 549        if (attr->ia_valid & ATTR_MODE)
 550                nbytes += 4;
 551        if (attr->ia_valid & ATTR_UID)
 552                nbytes += 4;
 553        if (attr->ia_valid & ATTR_GID)
 554                nbytes += 4;
 555        if (attr->ia_valid & ATTR_SIZE)
 556                nbytes += 8;
 557        if (attr->ia_valid & ATTR_ATIME_SET)
 558                nbytes += 8;
 559        if (attr->ia_valid & ATTR_MTIME_SET)
 560                nbytes += 8;
 561        p = xdr_reserve_space(xdr, nbytes);
 562
 563        if (attr->ia_valid & ATTR_MODE) {
 564                *p++ = xdr_one;
 565                *p++ = cpu_to_be32(attr->ia_mode & S_IALLUGO);
 566        } else
 567                *p++ = xdr_zero;
 568
 569        if (attr->ia_valid & ATTR_UID) {
 570                *p++ = xdr_one;
 571                *p++ = cpu_to_be32(from_kuid_munged(userns, attr->ia_uid));
 572        } else
 573                *p++ = xdr_zero;
 574
 575        if (attr->ia_valid & ATTR_GID) {
 576                *p++ = xdr_one;
 577                *p++ = cpu_to_be32(from_kgid_munged(userns, attr->ia_gid));
 578        } else
 579                *p++ = xdr_zero;
 580
 581        if (attr->ia_valid & ATTR_SIZE) {
 582                *p++ = xdr_one;
 583                p = xdr_encode_hyper(p, (u64)attr->ia_size);
 584        } else
 585                *p++ = xdr_zero;
 586
 587        if (attr->ia_valid & ATTR_ATIME_SET) {
 588                *p++ = xdr_two;
 589                p = xdr_encode_nfstime3(p, &attr->ia_atime);
 590        } else if (attr->ia_valid & ATTR_ATIME) {
 591                *p++ = xdr_one;
 592        } else
 593                *p++ = xdr_zero;
 594
 595        if (attr->ia_valid & ATTR_MTIME_SET) {
 596                *p++ = xdr_two;
 597                xdr_encode_nfstime3(p, &attr->ia_mtime);
 598        } else if (attr->ia_valid & ATTR_MTIME) {
 599                *p = xdr_one;
 600        } else
 601                *p = xdr_zero;
 602}
 603
 604/*
 605 * fattr3
 606 *
 607 *      struct fattr3 {
 608 *              ftype3          type;
 609 *              mode3           mode;
 610 *              uint32          nlink;
 611 *              uid3            uid;
 612 *              gid3            gid;
 613 *              size3           size;
 614 *              size3           used;
 615 *              specdata3       rdev;
 616 *              uint64          fsid;
 617 *              fileid3         fileid;
 618 *              nfstime3        atime;
 619 *              nfstime3        mtime;
 620 *              nfstime3        ctime;
 621 *      };
 622 */
 623static int decode_fattr3(struct xdr_stream *xdr, struct nfs_fattr *fattr,
 624                struct user_namespace *userns)
 625{
 626        umode_t fmode;
 627        __be32 *p;
 628
 629        p = xdr_inline_decode(xdr, NFS3_fattr_sz << 2);
 630        if (unlikely(!p))
 631                return -EIO;
 632
 633        p = xdr_decode_ftype3(p, &fmode);
 634
 635        fattr->mode = (be32_to_cpup(p++) & ~S_IFMT) | fmode;
 636        fattr->nlink = be32_to_cpup(p++);
 637        fattr->uid = make_kuid(userns, be32_to_cpup(p++));
 638        if (!uid_valid(fattr->uid))
 639                goto out_uid;
 640        fattr->gid = make_kgid(userns, be32_to_cpup(p++));
 641        if (!gid_valid(fattr->gid))
 642                goto out_gid;
 643
 644        p = xdr_decode_size3(p, &fattr->size);
 645        p = xdr_decode_size3(p, &fattr->du.nfs3.used);
 646        p = xdr_decode_specdata3(p, &fattr->rdev);
 647
 648        p = xdr_decode_hyper(p, &fattr->fsid.major);
 649        fattr->fsid.minor = 0;
 650
 651        p = xdr_decode_fileid3(p, &fattr->fileid);
 652        p = xdr_decode_nfstime3(p, &fattr->atime);
 653        p = xdr_decode_nfstime3(p, &fattr->mtime);
 654        xdr_decode_nfstime3(p, &fattr->ctime);
 655        fattr->change_attr = nfs_timespec_to_change_attr(&fattr->ctime);
 656
 657        fattr->valid |= NFS_ATTR_FATTR_V3;
 658        return 0;
 659out_uid:
 660        dprintk("NFS: returned invalid uid\n");
 661        return -EINVAL;
 662out_gid:
 663        dprintk("NFS: returned invalid gid\n");
 664        return -EINVAL;
 665}
 666
 667/*
 668 * post_op_attr
 669 *
 670 *      union post_op_attr switch (bool attributes_follow) {
 671 *      case TRUE:
 672 *              fattr3  attributes;
 673 *      case FALSE:
 674 *              void;
 675 *      };
 676 */
 677static int decode_post_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
 678                struct user_namespace *userns)
 679{
 680        __be32 *p;
 681
 682        p = xdr_inline_decode(xdr, 4);
 683        if (unlikely(!p))
 684                return -EIO;
 685        if (*p != xdr_zero)
 686                return decode_fattr3(xdr, fattr, userns);
 687        return 0;
 688}
 689
 690/*
 691 * wcc_attr
 692 *      struct wcc_attr {
 693 *              size3           size;
 694 *              nfstime3        mtime;
 695 *              nfstime3        ctime;
 696 *      };
 697 */
 698static int decode_wcc_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
 699{
 700        __be32 *p;
 701
 702        p = xdr_inline_decode(xdr, NFS3_wcc_attr_sz << 2);
 703        if (unlikely(!p))
 704                return -EIO;
 705
 706        fattr->valid |= NFS_ATTR_FATTR_PRESIZE
 707                | NFS_ATTR_FATTR_PRECHANGE
 708                | NFS_ATTR_FATTR_PREMTIME
 709                | NFS_ATTR_FATTR_PRECTIME;
 710
 711        p = xdr_decode_size3(p, &fattr->pre_size);
 712        p = xdr_decode_nfstime3(p, &fattr->pre_mtime);
 713        xdr_decode_nfstime3(p, &fattr->pre_ctime);
 714        fattr->pre_change_attr = nfs_timespec_to_change_attr(&fattr->pre_ctime);
 715
 716        return 0;
 717}
 718
 719/*
 720 * pre_op_attr
 721 *      union pre_op_attr switch (bool attributes_follow) {
 722 *      case TRUE:
 723 *              wcc_attr        attributes;
 724 *      case FALSE:
 725 *              void;
 726 *      };
 727 *
 728 * wcc_data
 729 *
 730 *      struct wcc_data {
 731 *              pre_op_attr     before;
 732 *              post_op_attr    after;
 733 *      };
 734 */
 735static int decode_pre_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
 736{
 737        __be32 *p;
 738
 739        p = xdr_inline_decode(xdr, 4);
 740        if (unlikely(!p))
 741                return -EIO;
 742        if (*p != xdr_zero)
 743                return decode_wcc_attr(xdr, fattr);
 744        return 0;
 745}
 746
 747static int decode_wcc_data(struct xdr_stream *xdr, struct nfs_fattr *fattr,
 748                struct user_namespace *userns)
 749{
 750        int error;
 751
 752        error = decode_pre_op_attr(xdr, fattr);
 753        if (unlikely(error))
 754                goto out;
 755        error = decode_post_op_attr(xdr, fattr, userns);
 756out:
 757        return error;
 758}
 759
 760/*
 761 * post_op_fh3
 762 *
 763 *      union post_op_fh3 switch (bool handle_follows) {
 764 *      case TRUE:
 765 *              nfs_fh3  handle;
 766 *      case FALSE:
 767 *              void;
 768 *      };
 769 */
 770static int decode_post_op_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
 771{
 772        __be32 *p = xdr_inline_decode(xdr, 4);
 773        if (unlikely(!p))
 774                return -EIO;
 775        if (*p != xdr_zero)
 776                return decode_nfs_fh3(xdr, fh);
 777        zero_nfs_fh3(fh);
 778        return 0;
 779}
 780
 781/*
 782 * diropargs3
 783 *
 784 *      struct diropargs3 {
 785 *              nfs_fh3         dir;
 786 *              filename3       name;
 787 *      };
 788 */
 789static void encode_diropargs3(struct xdr_stream *xdr, const struct nfs_fh *fh,
 790                              const char *name, u32 length)
 791{
 792        encode_nfs_fh3(xdr, fh);
 793        encode_filename3(xdr, name, length);
 794}
 795
 796
 797/*
 798 * NFSv3 XDR encode functions
 799 *
 800 * NFSv3 argument types are defined in section 3.3 of RFC 1813:
 801 * "NFS Version 3 Protocol Specification".
 802 */
 803
 804/*
 805 * 3.3.1  GETATTR3args
 806 *
 807 *      struct GETATTR3args {
 808 *              nfs_fh3  object;
 809 *      };
 810 */
 811static void nfs3_xdr_enc_getattr3args(struct rpc_rqst *req,
 812                                      struct xdr_stream *xdr,
 813                                      const void *data)
 814{
 815        const struct nfs_fh *fh = data;
 816
 817        encode_nfs_fh3(xdr, fh);
 818}
 819
 820/*
 821 * 3.3.2  SETATTR3args
 822 *
 823 *      union sattrguard3 switch (bool check) {
 824 *      case TRUE:
 825 *              nfstime3  obj_ctime;
 826 *      case FALSE:
 827 *              void;
 828 *      };
 829 *
 830 *      struct SETATTR3args {
 831 *              nfs_fh3         object;
 832 *              sattr3          new_attributes;
 833 *              sattrguard3     guard;
 834 *      };
 835 */
 836static void encode_sattrguard3(struct xdr_stream *xdr,
 837                               const struct nfs3_sattrargs *args)
 838{
 839        __be32 *p;
 840
 841        if (args->guard) {
 842                p = xdr_reserve_space(xdr, 4 + 8);
 843                *p++ = xdr_one;
 844                xdr_encode_nfstime3(p, &args->guardtime);
 845        } else {
 846                p = xdr_reserve_space(xdr, 4);
 847                *p = xdr_zero;
 848        }
 849}
 850
 851static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req,
 852                                      struct xdr_stream *xdr,
 853                                      const void *data)
 854{
 855        const struct nfs3_sattrargs *args = data;
 856        encode_nfs_fh3(xdr, args->fh);
 857        encode_sattr3(xdr, args->sattr, rpc_rqst_userns(req));
 858        encode_sattrguard3(xdr, args);
 859}
 860
 861/*
 862 * 3.3.3  LOOKUP3args
 863 *
 864 *      struct LOOKUP3args {
 865 *              diropargs3  what;
 866 *      };
 867 */
 868static void nfs3_xdr_enc_lookup3args(struct rpc_rqst *req,
 869                                     struct xdr_stream *xdr,
 870                                     const void *data)
 871{
 872        const struct nfs3_diropargs *args = data;
 873
 874        encode_diropargs3(xdr, args->fh, args->name, args->len);
 875}
 876
 877/*
 878 * 3.3.4  ACCESS3args
 879 *
 880 *      struct ACCESS3args {
 881 *              nfs_fh3         object;
 882 *              uint32          access;
 883 *      };
 884 */
 885static void encode_access3args(struct xdr_stream *xdr,
 886                               const struct nfs3_accessargs *args)
 887{
 888        encode_nfs_fh3(xdr, args->fh);
 889        encode_uint32(xdr, args->access);
 890}
 891
 892static void nfs3_xdr_enc_access3args(struct rpc_rqst *req,
 893                                     struct xdr_stream *xdr,
 894                                     const void *data)
 895{
 896        const struct nfs3_accessargs *args = data;
 897
 898        encode_access3args(xdr, args);
 899}
 900
 901/*
 902 * 3.3.5  READLINK3args
 903 *
 904 *      struct READLINK3args {
 905 *              nfs_fh3 symlink;
 906 *      };
 907 */
 908static void nfs3_xdr_enc_readlink3args(struct rpc_rqst *req,
 909                                       struct xdr_stream *xdr,
 910                                       const void *data)
 911{
 912        const struct nfs3_readlinkargs *args = data;
 913
 914        encode_nfs_fh3(xdr, args->fh);
 915        rpc_prepare_reply_pages(req, args->pages, args->pgbase, args->pglen,
 916                                NFS3_readlinkres_sz - NFS3_pagepad_sz);
 917}
 918
 919/*
 920 * 3.3.6  READ3args
 921 *
 922 *      struct READ3args {
 923 *              nfs_fh3         file;
 924 *              offset3         offset;
 925 *              count3          count;
 926 *      };
 927 */
 928static void encode_read3args(struct xdr_stream *xdr,
 929                             const struct nfs_pgio_args *args)
 930{
 931        __be32 *p;
 932
 933        encode_nfs_fh3(xdr, args->fh);
 934
 935        p = xdr_reserve_space(xdr, 8 + 4);
 936        p = xdr_encode_hyper(p, args->offset);
 937        *p = cpu_to_be32(args->count);
 938}
 939
 940static void nfs3_xdr_enc_read3args(struct rpc_rqst *req,
 941                                   struct xdr_stream *xdr,
 942                                   const void *data)
 943{
 944        const struct nfs_pgio_args *args = data;
 945        unsigned int replen = args->replen ? args->replen :
 946                                             NFS3_readres_sz - NFS3_pagepad_sz;
 947
 948        encode_read3args(xdr, args);
 949        rpc_prepare_reply_pages(req, args->pages, args->pgbase,
 950                                args->count, replen);
 951        req->rq_rcv_buf.flags |= XDRBUF_READ;
 952}
 953
 954/*
 955 * 3.3.7  WRITE3args
 956 *
 957 *      enum stable_how {
 958 *              UNSTABLE  = 0,
 959 *              DATA_SYNC = 1,
 960 *              FILE_SYNC = 2
 961 *      };
 962 *
 963 *      struct WRITE3args {
 964 *              nfs_fh3         file;
 965 *              offset3         offset;
 966 *              count3          count;
 967 *              stable_how      stable;
 968 *              opaque          data<>;
 969 *      };
 970 */
 971static void encode_write3args(struct xdr_stream *xdr,
 972                              const struct nfs_pgio_args *args)
 973{
 974        __be32 *p;
 975
 976        encode_nfs_fh3(xdr, args->fh);
 977
 978        p = xdr_reserve_space(xdr, 8 + 4 + 4 + 4);
 979        p = xdr_encode_hyper(p, args->offset);
 980        *p++ = cpu_to_be32(args->count);
 981        *p++ = cpu_to_be32(args->stable);
 982        *p = cpu_to_be32(args->count);
 983        xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
 984}
 985
 986static void nfs3_xdr_enc_write3args(struct rpc_rqst *req,
 987                                    struct xdr_stream *xdr,
 988                                    const void *data)
 989{
 990        const struct nfs_pgio_args *args = data;
 991
 992        encode_write3args(xdr, args);
 993        xdr->buf->flags |= XDRBUF_WRITE;
 994}
 995
 996/*
 997 * 3.3.8  CREATE3args
 998 *
 999 *      enum createmode3 {
1000 *              UNCHECKED = 0,

1001 *              GUARDED   = 1,
1002 *              EXCLUSIVE = 2
1003 *      };
1004 *
1005 *      union createhow3 switch (createmode3 mode) {
1006 *      case UNCHECKED:
1007 *      case GUARDED:
1008 *              sattr3       obj_attributes;
1009 *      case EXCLUSIVE:
1010 *              createverf3  verf;
1011 *      };
1012 *
1013 *      struct CREATE3args {
1014 *              diropargs3      where;
1015 *              createhow3      how;
1016 *      };
1017 */
1018static void encode_createhow3(struct xdr_stream *xdr,
1019                              const struct nfs3_createargs *args,
1020                              struct user_namespace *userns)
1021{
1022        encode_uint32(xdr, args->createmode);
1023        switch (args->createmode) {
1024        case NFS3_CREATE_UNCHECKED:
1025        case NFS3_CREATE_GUARDED:
1026                encode_sattr3(xdr, args->sattr, userns);
1027                break;
1028        case NFS3_CREATE_EXCLUSIVE:
1029                encode_createverf3(xdr, args->verifier);
1030                break;
1031        default:
1032                BUG();
1033        }
1034}
1035
1036static void nfs3_xdr_enc_create3args(struct rpc_rqst *req,
1037                                     struct xdr_stream *xdr,
1038                                     const void *data)
1039{
1040        const struct nfs3_createargs *args = data;
1041
1042        encode_diropargs3(xdr, args->fh, args->name, args->len);
1043        encode_createhow3(xdr, args, rpc_rqst_userns(req));
1044}
1045
1046/*
1047 * 3.3.9  MKDIR3args
1048 *
1049 *      struct MKDIR3args {
1050 *              diropargs3      where;
1051 *              sattr3          attributes;
1052 *      };
1053 */
1054static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req,
1055                                    struct xdr_stream *xdr,
1056                                    const void *data)
1057{
1058        const struct nfs3_mkdirargs *args = data;
1059
1060        encode_diropargs3(xdr, args->fh, args->name, args->len);
1061        encode_sattr3(xdr, args->sattr, rpc_rqst_userns(req));
1062}
1063
1064/*
1065 * 3.3.10  SYMLINK3args
1066 *
1067 *      struct symlinkdata3 {
1068 *              sattr3          symlink_attributes;
1069 *              nfspath3        symlink_data;
1070 *      };
1071 *
1072 *      struct SYMLINK3args {
1073 *              diropargs3      where;
1074 *              symlinkdata3    symlink;
1075 *      };
1076 */
1077static void encode_symlinkdata3(struct xdr_stream *xdr,
1078                                const void *data,
1079                                struct user_namespace *userns)
1080{
1081        const struct nfs3_symlinkargs *args = data;
1082
1083        encode_sattr3(xdr, args->sattr, userns);
1084        encode_nfspath3(xdr, args->pages, args->pathlen);
1085}
1086
1087static void nfs3_xdr_enc_symlink3args(struct rpc_rqst *req,
1088                                      struct xdr_stream *xdr,
1089                                      const void *data)
1090{
1091        const struct nfs3_symlinkargs *args = data;
1092
1093        encode_diropargs3(xdr, args->fromfh, args->fromname, args->fromlen);
1094        encode_symlinkdata3(xdr, args, rpc_rqst_userns(req));
1095        xdr->buf->flags |= XDRBUF_WRITE;
1096}
1097
1098/*
1099 * 3.3.11  MKNOD3args
1100 *
1101 *      struct devicedata3 {
1102 *              sattr3          dev_attributes;
1103 *              specdata3       spec;
1104 *      };
1105 *
1106 *      union mknoddata3 switch (ftype3 type) {
1107 *      case NF3CHR:
1108 *      case NF3BLK:
1109 *              devicedata3     device;
1110 *      case NF3SOCK:
1111 *      case NF3FIFO:
1112 *              sattr3          pipe_attributes;
1113 *      default:
1114 *              void;
1115 *      };
1116 *
1117 *      struct MKNOD3args {
1118 *              diropargs3      where;
1119 *              mknoddata3      what;
1120 *      };
1121 */
1122static void encode_devicedata3(struct xdr_stream *xdr,
1123                               const struct nfs3_mknodargs *args,
1124                               struct user_namespace *userns)
1125{
1126        encode_sattr3(xdr, args->sattr, userns);
1127        encode_specdata3(xdr, args->rdev);
1128}
1129
1130static void encode_mknoddata3(struct xdr_stream *xdr,
1131                              const struct nfs3_mknodargs *args,
1132                              struct user_namespace *userns)
1133{
1134        encode_ftype3(xdr, args->type);
1135        switch (args->type) {
1136        case NF3CHR:
1137        case NF3BLK:
1138                encode_devicedata3(xdr, args, userns);
1139                break;
1140        case NF3SOCK:
1141        case NF3FIFO:
1142                encode_sattr3(xdr, args->sattr, userns);
1143                break;
1144        case NF3REG:
1145        case NF3DIR:
1146                break;
1147        default:
1148                BUG();
1149        }
1150}
1151
1152static void nfs3_xdr_enc_mknod3args(struct rpc_rqst *req,
1153                                    struct xdr_stream *xdr,
1154                                    const void *data)
1155{
1156        const struct nfs3_mknodargs *args = data;
1157
1158        encode_diropargs3(xdr, args->fh, args->name, args->len);
1159        encode_mknoddata3(xdr, args, rpc_rqst_userns(req));
1160}
1161
1162/*
1163 * 3.3.12  REMOVE3args
1164 *
1165 *      struct REMOVE3args {
1166 *              diropargs3  object;
1167 *      };
1168 */
1169static void nfs3_xdr_enc_remove3args(struct rpc_rqst *req,
1170                                     struct xdr_stream *xdr,
1171                                     const void *data)
1172{
1173        const struct nfs_removeargs *args = data;
1174
1175        encode_diropargs3(xdr, args->fh, args->name.name, args->name.len);
1176}
1177
1178/*
1179 * 3.3.14  RENAME3args
1180 *
1181 *      struct RENAME3args {
1182 *              diropargs3      from;
1183 *              diropargs3      to;
1184 *      };
1185 */
1186static void nfs3_xdr_enc_rename3args(struct rpc_rqst *req,
1187                                     struct xdr_stream *xdr,
1188                                     const void *data)
1189{
1190        const struct nfs_renameargs *args = data;
1191        const struct qstr *old = args->old_name;
1192        const struct qstr *new = args->new_name;
1193
1194        encode_diropargs3(xdr, args->old_dir, old->name, old->len);
1195        encode_diropargs3(xdr, args->new_dir, new->name, new->len);
1196}
1197
1198/*
1199 * 3.3.15  LINK3args
1200 *
1201 *      struct LINK3args {
1202 *              nfs_fh3         file;
1203 *              diropargs3      link;
1204 *      };
1205 */
1206static void nfs3_xdr_enc_link3args(struct rpc_rqst *req,
1207                                   struct xdr_stream *xdr,
1208                                   const void *data)
1209{
1210        const struct nfs3_linkargs *args = data;
1211
1212        encode_nfs_fh3(xdr, args->fromfh);
1213        encode_diropargs3(xdr, args->tofh, args->toname, args->tolen);
1214}
1215
1216/*
1217 * 3.3.16  READDIR3args
1218 *
1219 *      struct READDIR3args {
1220 *              nfs_fh3         dir;
1221 *              cookie3         cookie;
1222 *              cookieverf3     cookieverf;
1223 *              count3          count;
1224 *      };
1225 */
1226static void encode_readdir3args(struct xdr_stream *xdr,
1227                                const struct nfs3_readdirargs *args)
1228{
1229        __be32 *p;
1230
1231        encode_nfs_fh3(xdr, args->fh);
1232
1233        p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4);
1234        p = xdr_encode_cookie3(p, args->cookie);
1235        p = xdr_encode_cookieverf3(p, args->verf);
1236        *p = cpu_to_be32(args->count);
1237}
1238
1239static void nfs3_xdr_enc_readdir3args(struct rpc_rqst *req,
1240                                      struct xdr_stream *xdr,
1241                                      const void *data)
1242{
1243        const struct nfs3_readdirargs *args = data;
1244
1245        encode_readdir3args(xdr, args);
1246        rpc_prepare_reply_pages(req, args->pages, 0, args->count,
1247                                NFS3_readdirres_sz - NFS3_pagepad_sz);
1248}
1249
1250/*
1251 * 3.3.17  READDIRPLUS3args
1252 *
1253 *      struct READDIRPLUS3args {
1254 *              nfs_fh3         dir;
1255 *              cookie3         cookie;
1256 *              cookieverf3     cookieverf;
1257 *              count3          dircount;
1258 *              count3          maxcount;
1259 *      };
1260 */
1261static void encode_readdirplus3args(struct xdr_stream *xdr,
1262                                    const struct nfs3_readdirargs *args)
1263{
1264        __be32 *p;
1265
1266        encode_nfs_fh3(xdr, args->fh);
1267
1268        p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4 + 4);
1269        p = xdr_encode_cookie3(p, args->cookie);
1270        p = xdr_encode_cookieverf3(p, args->verf);
1271
1272        /*
1273         * readdirplus: need dircount + buffer size.
1274         * We just make sure we make dircount big enough
1275         */
1276        *p++ = cpu_to_be32(args->count >> 3);
1277
1278        *p = cpu_to_be32(args->count);
1279}
1280
1281static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req,
1282                                          struct xdr_stream *xdr,
1283                                          const void *data)
1284{
1285        const struct nfs3_readdirargs *args = data;
1286
1287        encode_readdirplus3args(xdr, args);
1288        rpc_prepare_reply_pages(req, args->pages, 0, args->count,
1289                                NFS3_readdirres_sz - NFS3_pagepad_sz);
1290}
1291
1292/*
1293 * 3.3.21  COMMIT3args
1294 *
1295 *      struct COMMIT3args {
1296 *              nfs_fh3         file;
1297 *              offset3         offset;
1298 *              count3          count;
1299 *      };
1300 */
1301static void encode_commit3args(struct xdr_stream *xdr,
1302                               const struct nfs_commitargs *args)
1303{
1304        __be32 *p;
1305
1306        encode_nfs_fh3(xdr, args->fh);
1307
1308        p = xdr_reserve_space(xdr, 8 + 4);
1309        p = xdr_encode_hyper(p, args->offset);
1310        *p = cpu_to_be32(args->count);
1311}
1312
1313static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req,
1314                                     struct xdr_stream *xdr,
1315                                     const void *data)
1316{
1317        const struct nfs_commitargs *args = data;
1318
1319        encode_commit3args(xdr, args);
1320}
1321
1322#ifdef CONFIG_NFS_V3_ACL
1323
1324static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req,
1325                                     struct xdr_stream *xdr,
1326                                     const void *data)
1327{
1328        const struct nfs3_getaclargs *args = data;
1329
1330        encode_nfs_fh3(xdr, args->fh);
1331        encode_uint32(xdr, args->mask);
1332        if (args->mask & (NFS_ACL | NFS_DFACL)) {
1333                rpc_prepare_reply_pages(req, args->pages, 0,
1334                                        NFSACL_MAXPAGES << PAGE_SHIFT,
1335                                        ACL3_getaclres_sz - NFS3_pagepad_sz);
1336                req->rq_rcv_buf.flags |= XDRBUF_SPARSE_PAGES;
1337        }
1338}
1339
1340static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
1341                                     struct xdr_stream *xdr,
1342                                     const void *data)
1343{
1344        const struct nfs3_setaclargs *args = data;
1345        unsigned int base;
1346        int error;
1347
1348        encode_nfs_fh3(xdr, NFS_FH(args->inode));
1349        encode_uint32(xdr, args->mask);
1350
1351        base = req->rq_slen;
1352        if (args->npages != 0)
1353                xdr_write_pages(xdr, args->pages, 0, args->len);
1354        else
1355                xdr_reserve_space(xdr, args->len);
1356
1357        error = nfsacl_encode(xdr->buf, base, args->inode,
1358                            (args->mask & NFS_ACL) ?
1359                            args->acl_access : NULL, 1, 0);
1360        /* FIXME: this is just broken */
1361        BUG_ON(error < 0);
1362        error = nfsacl_encode(xdr->buf, base + error, args->inode,
1363                            (args->mask & NFS_DFACL) ?
1364                            args->acl_default : NULL, 1,
1365                            NFS_ACL_DEFAULT);
1366        BUG_ON(error < 0);
1367}
1368
1369#endif  /* CONFIG_NFS_V3_ACL */
1370
1371/*
1372 * NFSv3 XDR decode functions
1373 *
1374 * NFSv3 result types are defined in section 3.3 of RFC 1813:
1375 * "NFS Version 3 Protocol Specification".
1376 */
1377
1378/*
1379 * 3.3.1  GETATTR3res
1380 *
1381 *      struct GETATTR3resok {
1382 *              fattr3          obj_attributes;
1383 *      };
1384 *
1385 *      union GETATTR3res switch (nfsstat3 status) {
1386 *      case NFS3_OK:
1387 *              GETATTR3resok  resok;
1388 *      default:
1389 *              void;
1390 *      };
1391 */
1392static int nfs3_xdr_dec_getattr3res(struct rpc_rqst *req,
1393                                    struct xdr_stream *xdr,
1394                                    void *result)
1395{
1396        enum nfs_stat status;
1397        int error;
1398
1399        error = decode_nfsstat3(xdr, &status);
1400        if (unlikely(error))
1401                goto out;
1402        if (status != NFS3_OK)
1403                goto out_default;
1404        error = decode_fattr3(xdr, result, rpc_rqst_userns(req));
1405out:
1406        return error;
1407out_default:
1408        return nfs3_stat_to_errno(status);
1409}
1410
1411/*
1412 * 3.3.2  SETATTR3res
1413 *
1414 *      struct SETATTR3resok {
1415 *              wcc_data  obj_wcc;
1416 *      };
1417 *
1418 *      struct SETATTR3resfail {
1419 *              wcc_data  obj_wcc;
1420 *      };
1421 *
1422 *      union SETATTR3res switch (nfsstat3 status) {
1423 *      case NFS3_OK:
1424 *              SETATTR3resok   resok;
1425 *      default:
1426 *              SETATTR3resfail resfail;
1427 *      };
1428 */
1429static int nfs3_xdr_dec_setattr3res(struct rpc_rqst *req,
1430                                    struct xdr_stream *xdr,
1431                                    void *result)
1432{
1433        enum nfs_stat status;
1434        int error;
1435
1436        error = decode_nfsstat3(xdr, &status);
1437        if (unlikely(error))
1438                goto out;
1439        error = decode_wcc_data(xdr, result, rpc_rqst_userns(req));
1440        if (unlikely(error))
1441                goto out;
1442        if (status != NFS3_OK)
1443                goto out_status;
1444out:
1445        return error;
1446out_status:
1447        return nfs3_stat_to_errno(status);
1448}
1449
1450/*
1451 * 3.3.3  LOOKUP3res
1452 *
1453 *      struct LOOKUP3resok {
1454 *              nfs_fh3         object;
1455 *              post_op_attr    obj_attributes;
1456 *              post_op_attr    dir_attributes;
1457 *      };
1458 *
1459 *      struct LOOKUP3resfail {
1460 *              post_op_attr    dir_attributes;
1461 *      };
1462 *
1463 *      union LOOKUP3res switch (nfsstat3 status) {
1464 *      case NFS3_OK:
1465 *              LOOKUP3resok    resok;
1466 *      default:
1467 *              LOOKUP3resfail  resfail;
1468 *      };
1469 */
1470static int nfs3_xdr_dec_lookup3res(struct rpc_rqst *req,
1471                                   struct xdr_stream *xdr,
1472                                   void *data)
1473{
1474        struct user_namespace *userns = rpc_rqst_userns(req);
1475        struct nfs3_diropres *result = data;
1476        enum nfs_stat status;
1477        int error;
1478
1479        error = decode_nfsstat3(xdr, &status);
1480        if (unlikely(error))
1481                goto out;
1482        if (status != NFS3_OK)
1483                goto out_default;
1484        error = decode_nfs_fh3(xdr, result->fh);
1485        if (unlikely(error))
1486                goto out;
1487        error = decode_post_op_attr(xdr, result->fattr, userns);
1488        if (unlikely(error))
1489                goto out;
1490        error = decode_post_op_attr(xdr, result->dir_attr, userns);
1491out:
1492        return error;
1493out_default:
1494        error = decode_post_op_attr(xdr, result->dir_attr, userns);
1495        if (unlikely(error))
1496                goto out;
1497        return nfs3_stat_to_errno(status);
1498}
1499
1500/*
1501 * 3.3.4  ACCESS3res
1502 *
1503 *      struct ACCESS3resok {
1504 *              post_op_attr    obj_attributes;
1505 *              uint32          access;
1506 *      };
1507 *
1508 *      struct ACCESS3resfail {
1509 *              post_op_attr    obj_attributes;
1510 *      };
1511 *
1512 *      union ACCESS3res switch (nfsstat3 status) {
1513 *      case NFS3_OK:
1514 *              ACCESS3resok    resok;
1515 *      default:
1516 *              ACCESS3resfail  resfail;
1517 *      };
1518 */
1519static int nfs3_xdr_dec_access3res(struct rpc_rqst *req,
1520                                   struct xdr_stream *xdr,
1521                                   void *data)
1522{
1523        struct nfs3_accessres *result = data;
1524        enum nfs_stat status;
1525        int error;
1526
1527        error = decode_nfsstat3(xdr, &status);
1528        if (unlikely(error))
1529                goto out;
1530        error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
1531        if (unlikely(error))
1532                goto out;
1533        if (status != NFS3_OK)
1534                goto out_default;
1535        error = decode_uint32(xdr, &result->access);
1536out:
1537        return error;
1538out_default:
1539        return nfs3_stat_to_errno(status);
1540}
1541
1542/*
1543 * 3.3.5  READLINK3res
1544 *
1545 *      struct READLINK3resok {
1546 *              post_op_attr    symlink_attributes;
1547 *              nfspath3        data;
1548 *      };
1549 *
1550 *      struct READLINK3resfail {
1551 *              post_op_attr    symlink_attributes;
1552 *      };
1553 *
1554 *      union READLINK3res switch (nfsstat3 status) {
1555 *      case NFS3_OK:
1556 *              READLINK3resok  resok;
1557 *      default:
1558 *              READLINK3resfail resfail;
1559 *      };
1560 */
1561static int nfs3_xdr_dec_readlink3res(struct rpc_rqst *req,
1562                                     struct xdr_stream *xdr,
1563                                     void *result)
1564{
1565        enum nfs_stat status;
1566        int error;
1567
1568        error = decode_nfsstat3(xdr, &status);
1569        if (unlikely(error))
1570                goto out;
1571        error = decode_post_op_attr(xdr, result, rpc_rqst_userns(req));
1572        if (unlikely(error))
1573                goto out;
1574        if (status != NFS3_OK)
1575                goto out_default;
1576        error = decode_nfspath3(xdr);
1577out:
1578        return error;
1579out_default:
1580        return nfs3_stat_to_errno(status);
1581}
1582
1583/*
1584 * 3.3.6  READ3res
1585 *
1586 *      struct READ3resok {
1587 *              post_op_attr    file_attributes;
1588 *              count3          count;
1589 *              bool            eof;
1590 *              opaque          data<>;
1591 *      };
1592 *
1593 *      struct READ3resfail {
1594 *              post_op_attr    file_attributes;
1595 *      };
1596 *
1597 *      union READ3res switch (nfsstat3 status) {
1598 *      case NFS3_OK:
1599 *              READ3resok      resok;
1600 *      default:
1601 *              READ3resfail    resfail;
1602 *      };
1603 */
1604static int decode_read3resok(struct xdr_stream *xdr,
1605                             struct nfs_pgio_res *result)
1606{
1607        u32 eof, count, ocount, recvd;
1608        __be32 *p;
1609
1610        p = xdr_inline_decode(xdr, 4 + 4 + 4);
1611        if (unlikely(!p))
1612                return -EIO;
1613        count = be32_to_cpup(p++);
1614        eof = be32_to_cpup(p++);
1615        ocount = be32_to_cpup(p++);
1616        if (unlikely(ocount != count))
1617                goto out_mismatch;
1618        recvd = xdr_read_pages(xdr, count);
1619        if (unlikely(count > recvd))
1620                goto out_cheating;
1621out:
1622        result->eof = eof;
1623        result->count = count;
1624        return count;
1625out_mismatch:
1626        dprintk("NFS: READ count doesn't match length of opaque: "
1627                "count %u != ocount %u\n", count, ocount);
1628        return -EIO;
1629out_cheating:
1630        dprintk("NFS: server cheating in read result: "
1631                "count %u > recvd %u\n", count, recvd);
1632        count = recvd;
1633        eof = 0;
1634        goto out;
1635}
1636
1637static int nfs3_xdr_dec_read3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1638                                 void *data)
1639{
1640        struct nfs_pgio_res *result = data;
1641        unsigned int pos;
1642        enum nfs_stat status;
1643        int error;
1644
1645        pos = xdr_stream_pos(xdr);
1646        error = decode_nfsstat3(xdr, &status);
1647        if (unlikely(error))
1648                goto out;
1649        error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
1650        if (unlikely(error))
1651                goto out;
1652        result->op_status = status;
1653        if (status != NFS3_OK)
1654                goto out_status;
1655        result->replen = 3 + ((xdr_stream_pos(xdr) - pos) >> 2);
1656        error = decode_read3resok(xdr, result);
1657out:
1658        return error;
1659out_status:
1660        return nfs3_stat_to_errno(status);
1661}
1662
1663/*
1664 * 3.3.7  WRITE3res
1665 *
1666 *      enum stable_how {
1667 *              UNSTABLE  = 0,
1668 *              DATA_SYNC = 1,
1669 *              FILE_SYNC = 2
1670 *      };
1671 *
1672 *      struct WRITE3resok {
1673 *              wcc_data        file_wcc;
1674 *              count3          count;
1675 *              stable_how      committed;
1676 *              writeverf3      verf;
1677 *      };
1678 *
1679 *      struct WRITE3resfail {
1680 *              wcc_data        file_wcc;
1681 *      };
1682 *
1683 *      union WRITE3res switch (nfsstat3 status) {
1684 *      case NFS3_OK:
1685 *              WRITE3resok     resok;
1686 *      default:
1687 *              WRITE3resfail   resfail;
1688 *      };
1689 */
1690static int decode_write3resok(struct xdr_stream *xdr,
1691                              struct nfs_pgio_res *result)
1692{
1693        __be32 *p;
1694
1695        p = xdr_inline_decode(xdr, 4 + 4);
1696        if (unlikely(!p))
1697                return -EIO;
1698        result->count = be32_to_cpup(p++);
1699        result->verf->committed = be32_to_cpup(p++);
1700        if (unlikely(result->verf->committed > NFS_FILE_SYNC))
1701                goto out_badvalue;
1702        if (decode_writeverf3(xdr, &result->verf->verifier))
1703                return -EIO;
1704        return result->count;
1705out_badvalue:
1706        dprintk("NFS: bad stable_how value: %u\n", result->verf->committed);
1707        return -EIO;
1708}
1709
1710static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1711                                  void *data)
1712{
1713        struct nfs_pgio_res *result = data;
1714        enum nfs_stat status;
1715        int error;
1716
1717        error = decode_nfsstat3(xdr, &status);
1718        if (unlikely(error))
1719                goto out;
1720        error = decode_wcc_data(xdr, result->fattr, rpc_rqst_userns(req));
1721        if (unlikely(error))
1722                goto out;
1723        result->op_status = status;
1724        if (status != NFS3_OK)
1725                goto out_status;
1726        error = decode_write3resok(xdr, result);
1727out:
1728        return error;
1729out_status:
1730        return nfs3_stat_to_errno(status);
1731}
1732
1733/*
1734 * 3.3.8  CREATE3res
1735 *
1736 *      struct CREATE3resok {
1737 *              post_op_fh3     obj;
1738 *              post_op_attr    obj_attributes;
1739 *              wcc_data        dir_wcc;
1740 *      };
1741 *
1742 *      struct CREATE3resfail {
1743 *              wcc_data        dir_wcc;
1744 *      };
1745 *
1746 *      union CREATE3res switch (nfsstat3 status) {
1747 *      case NFS3_OK:
1748 *              CREATE3resok    resok;
1749 *      default:
1750 *              CREATE3resfail  resfail;
1751 *      };
1752 */
1753static int decode_create3resok(struct xdr_stream *xdr,
1754                               struct nfs3_diropres *result,
1755                               struct user_namespace *userns)
1756{
1757        int error;
1758
1759        error = decode_post_op_fh3(xdr, result->fh);
1760        if (unlikely(error))
1761                goto out;
1762        error = decode_post_op_attr(xdr, result->fattr, userns);
1763        if (unlikely(error))
1764                goto out;
1765        /* The server isn't required to return a file handle.
1766         * If it didn't, force the client to perform a LOOKUP
1767         * to determine the correct file handle and attribute
1768         * values for the new object. */
1769        if (result->fh->size == 0)
1770                result->fattr->valid = 0;
1771        error = decode_wcc_data(xdr, result->dir_attr, userns);
1772out:
1773        return error;
1774}
1775
1776static int nfs3_xdr_dec_create3res(struct rpc_rqst *req,
1777                                   struct xdr_stream *xdr,
1778                                   void *data)
1779{
1780        struct user_namespace *userns = rpc_rqst_userns(req);
1781        struct nfs3_diropres *result = data;
1782        enum nfs_stat status;
1783        int error;
1784
1785        error = decode_nfsstat3(xdr, &status);
1786        if (unlikely(error))
1787                goto out;
1788        if (status != NFS3_OK)
1789                goto out_default;
1790        error = decode_create3resok(xdr, result, userns);
1791out:
1792        return error;
1793out_default:
1794        error = decode_wcc_data(xdr, result->dir_attr, userns);
1795        if (unlikely(error))
1796                goto out;
1797        return nfs3_stat_to_errno(status);
1798}
1799
1800/*
1801 * 3.3.12  REMOVE3res
1802 *
1803 *      struct REMOVE3resok {
1804 *              wcc_data    dir_wcc;
1805 *      };
1806 *
1807 *      struct REMOVE3resfail {
1808 *              wcc_data    dir_wcc;
1809 *      };
1810 *
1811 *      union REMOVE3res switch (nfsstat3 status) {
1812 *      case NFS3_OK:
1813 *              REMOVE3resok   resok;
1814 *      default:
1815 *              REMOVE3resfail resfail;
1816 *      };
1817 */
1818static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req,
1819                                   struct xdr_stream *xdr,
1820                                   void *data)
1821{
1822        struct nfs_removeres *result = data;
1823        enum nfs_stat status;
1824        int error;
1825
1826        error = decode_nfsstat3(xdr, &status);
1827        if (unlikely(error))
1828                goto out;
1829        error = decode_wcc_data(xdr, result->dir_attr, rpc_rqst_userns(req));
1830        if (unlikely(error))
1831                goto out;
1832        if (status != NFS3_OK)
1833                goto out_status;
1834out:
1835        return error;
1836out_status:
1837        return nfs3_stat_to_errno(status);
1838}
1839
1840/*
1841 * 3.3.14  RENAME3res
1842 *
1843 *      struct RENAME3resok {
1844 *              wcc_data        fromdir_wcc;
1845 *              wcc_data        todir_wcc;
1846 *      };
1847 *
1848 *      struct RENAME3resfail {
1849 *              wcc_data        fromdir_wcc;
1850 *              wcc_data        todir_wcc;
1851 *      };
1852 *
1853 *      union RENAME3res switch (nfsstat3 status) {
1854 *      case NFS3_OK:
1855 *              RENAME3resok   resok;
1856 *      default:
1857 *              RENAME3resfail resfail;
1858 *      };
1859 */
1860static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req,
1861                                   struct xdr_stream *xdr,
1862                                   void *data)
1863{
1864        struct user_namespace *userns = rpc_rqst_userns(req);
1865        struct nfs_renameres *result = data;
1866        enum nfs_stat status;
1867        int error;
1868
1869        error = decode_nfsstat3(xdr, &status);
1870        if (unlikely(error))
1871                goto out;
1872        error = decode_wcc_data(xdr, result->old_fattr, userns);
1873        if (unlikely(error))
1874                goto out;
1875        error = decode_wcc_data(xdr, result->new_fattr, userns);
1876        if (unlikely(error))
1877                goto out;
1878        if (status != NFS3_OK)
1879                goto out_status;
1880out:
1881        return error;
1882out_status:
1883        return nfs3_stat_to_errno(status);
1884}
1885
1886/*
1887 * 3.3.15  LINK3res
1888 *
1889 *      struct LINK3resok {
1890 *              post_op_attr    file_attributes;
1891 *              wcc_data        linkdir_wcc;
1892 *      };
1893 *
1894 *      struct LINK3resfail {
1895 *              post_op_attr    file_attributes;
1896 *              wcc_data        linkdir_wcc;
1897 *      };
1898 *
1899 *      union LINK3res switch (nfsstat3 status) {
1900 *      case NFS3_OK:
1901 *              LINK3resok      resok;
1902 *      default:
1903 *              LINK3resfail    resfail;
1904 *      };
1905 */
1906static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1907                                 void *data)
1908{
1909        struct user_namespace *userns = rpc_rqst_userns(req);
1910        struct nfs3_linkres *result = data;
1911        enum nfs_stat status;
1912        int error;
1913
1914        error = decode_nfsstat3(xdr, &status);
1915        if (unlikely(error))
1916                goto out;
1917        error = decode_post_op_attr(xdr, result->fattr, userns);
1918        if (unlikely(error))
1919                goto out;
1920        error = decode_wcc_data(xdr, result->dir_attr, userns);
1921        if (unlikely(error))
1922                goto out;
1923        if (status != NFS3_OK)
1924                goto out_status;
1925out:
1926        return error;
1927out_status:
1928        return nfs3_stat_to_errno(status);
1929}
1930
1931/**
1932 * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1933 *                      the local page cache
1934 * @xdr: XDR stream where entry resides
1935 * @entry: buffer to fill in with entry data
1936 * @plus: boolean indicating whether this should be a readdirplus entry
1937 *
1938 * Returns zero if successful, otherwise a negative errno value is
1939 * returned.
1940 *
1941 * This function is not invoked during READDIR reply decoding, but
1942 * rather whenever an application invokes the getdents(2) system call
1943 * on a directory already in our cache.
1944 *
1945 * 3.3.16  entry3
1946 *
1947 *      struct entry3 {
1948 *              fileid3         fileid;
1949 *              filename3       name;
1950 *              cookie3         cookie;
1951 *              fhandle3        filehandle;
1952 *              post_op_attr3   attributes;
1953 *              entry3          *nextentry;
1954 *      };
1955 *
1956 * 3.3.17  entryplus3
1957 *      struct entryplus3 {
1958 *              fileid3         fileid;
1959 *              filename3       name;
1960 *              cookie3         cookie;
1961 *              post_op_attr    name_attributes;
1962 *              post_op_fh3     name_handle;
1963 *              entryplus3      *nextentry;
1964 *      };
1965 */
1966int nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
1967                       bool plus)
1968{
1969        struct user_namespace *userns = rpc_userns(entry->server->client);
1970        struct nfs_entry old = *entry;
1971        __be32 *p;
1972        int error;
1973        u64 new_cookie;
1974
1975        p = xdr_inline_decode(xdr, 4);
1976        if (unlikely(!p))
1977                return -EAGAIN;
1978        if (*p == xdr_zero) {
1979                p = xdr_inline_decode(xdr, 4);
1980                if (unlikely(!p))
1981                        return -EAGAIN;
1982                if (*p == xdr_zero)
1983                        return -EAGAIN;
1984                entry->eof = 1;
1985                return -EBADCOOKIE;
1986        }
1987
1988        error = decode_fileid3(xdr, &entry->ino);
1989        if (unlikely(error))
1990                return error;
1991
1992        error = decode_inline_filename3(xdr, &entry->name, &entry->len);
1993        if (unlikely(error))
1994                return error;
1995
1996        error = decode_cookie3(xdr, &new_cookie);
1997        if (unlikely(error))
1998                return error;
1999
2000        entry->d_type = DT_UNKNOWN;

2001
2002        if (plus) {
2003                entry->fattr->valid = 0;
2004                error = decode_post_op_attr(xdr, entry->fattr, userns);
2005                if (unlikely(error))
2006                        return error;
2007                if (entry->fattr->valid & NFS_ATTR_FATTR_V3)
2008                        entry->d_type = nfs_umode_to_dtype(entry->fattr->mode);
2009
2010                if (entry->fattr->fileid != entry->ino) {
2011                        entry->fattr->mounted_on_fileid = entry->ino;
2012                        entry->fattr->valid |= NFS_ATTR_FATTR_MOUNTED_ON_FILEID;
2013                }
2014
2015                /* In fact, a post_op_fh3: */
2016                p = xdr_inline_decode(xdr, 4);
2017                if (unlikely(!p))
2018                        return -EAGAIN;
2019                if (*p != xdr_zero) {
2020                        error = decode_nfs_fh3(xdr, entry->fh);
2021                        if (unlikely(error)) {
2022                                if (error == -E2BIG)
2023                                        goto out_truncated;
2024                                return error;
2025                        }
2026                } else
2027                        zero_nfs_fh3(entry->fh);
2028        }
2029
2030        entry->prev_cookie = entry->cookie;
2031        entry->cookie = new_cookie;
2032
2033        return 0;
2034
2035out_truncated:
2036        dprintk("NFS: directory entry contains invalid file handle\n");
2037        *entry = old;
2038        return -EAGAIN;
2039}
2040
2041/*
2042 * 3.3.16  READDIR3res
2043 *
2044 *      struct dirlist3 {
2045 *              entry3          *entries;
2046 *              bool            eof;
2047 *      };
2048 *
2049 *      struct READDIR3resok {
2050 *              post_op_attr    dir_attributes;
2051 *              cookieverf3     cookieverf;
2052 *              dirlist3        reply;
2053 *      };
2054 *
2055 *      struct READDIR3resfail {
2056 *              post_op_attr    dir_attributes;
2057 *      };
2058 *
2059 *      union READDIR3res switch (nfsstat3 status) {
2060 *      case NFS3_OK:
2061 *              READDIR3resok   resok;
2062 *      default:
2063 *              READDIR3resfail resfail;
2064 *      };
2065 *
2066 * Read the directory contents into the page cache, but otherwise
2067 * don't touch them.  The actual decoding is done by nfs3_decode_entry()
2068 * during subsequent nfs_readdir() calls.
2069 */
2070static int decode_dirlist3(struct xdr_stream *xdr)
2071{
2072        return xdr_read_pages(xdr, xdr->buf->page_len);
2073}
2074
2075static int decode_readdir3resok(struct xdr_stream *xdr,
2076                                struct nfs3_readdirres *result,
2077                                struct user_namespace *userns)
2078{
2079        int error;
2080
2081        error = decode_post_op_attr(xdr, result->dir_attr, userns);
2082        if (unlikely(error))
2083                goto out;
2084        /* XXX: do we need to check if result->verf != NULL ? */
2085        error = decode_cookieverf3(xdr, result->verf);
2086        if (unlikely(error))
2087                goto out;
2088        error = decode_dirlist3(xdr);
2089out:
2090        return error;
2091}
2092
2093static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req,
2094                                    struct xdr_stream *xdr,
2095                                    void *data)
2096{
2097        struct nfs3_readdirres *result = data;
2098        enum nfs_stat status;
2099        int error;
2100
2101        error = decode_nfsstat3(xdr, &status);
2102        if (unlikely(error))
2103                goto out;
2104        if (status != NFS3_OK)
2105                goto out_default;
2106        error = decode_readdir3resok(xdr, result, rpc_rqst_userns(req));
2107out:
2108        return error;
2109out_default:
2110        error = decode_post_op_attr(xdr, result->dir_attr, rpc_rqst_userns(req));
2111        if (unlikely(error))
2112                goto out;
2113        return nfs3_stat_to_errno(status);
2114}
2115
2116/*
2117 * 3.3.18  FSSTAT3res
2118 *
2119 *      struct FSSTAT3resok {
2120 *              post_op_attr    obj_attributes;
2121 *              size3           tbytes;
2122 *              size3           fbytes;
2123 *              size3           abytes;
2124 *              size3           tfiles;
2125 *              size3           ffiles;
2126 *              size3           afiles;
2127 *              uint32          invarsec;
2128 *      };
2129 *
2130 *      struct FSSTAT3resfail {
2131 *              post_op_attr    obj_attributes;
2132 *      };
2133 *
2134 *      union FSSTAT3res switch (nfsstat3 status) {
2135 *      case NFS3_OK:
2136 *              FSSTAT3resok    resok;
2137 *      default:
2138 *              FSSTAT3resfail  resfail;
2139 *      };
2140 */
2141static int decode_fsstat3resok(struct xdr_stream *xdr,
2142                               struct nfs_fsstat *result)
2143{
2144        __be32 *p;
2145
2146        p = xdr_inline_decode(xdr, 8 * 6 + 4);
2147        if (unlikely(!p))
2148                return -EIO;
2149        p = xdr_decode_size3(p, &result->tbytes);
2150        p = xdr_decode_size3(p, &result->fbytes);
2151        p = xdr_decode_size3(p, &result->abytes);
2152        p = xdr_decode_size3(p, &result->tfiles);
2153        p = xdr_decode_size3(p, &result->ffiles);
2154        xdr_decode_size3(p, &result->afiles);
2155        /* ignore invarsec */
2156        return 0;
2157}
2158
2159static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req,
2160                                   struct xdr_stream *xdr,
2161                                   void *data)
2162{
2163        struct nfs_fsstat *result = data;
2164        enum nfs_stat status;
2165        int error;
2166
2167        error = decode_nfsstat3(xdr, &status);
2168        if (unlikely(error))
2169                goto out;
2170        error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2171        if (unlikely(error))
2172                goto out;
2173        if (status != NFS3_OK)
2174                goto out_status;
2175        error = decode_fsstat3resok(xdr, result);
2176out:
2177        return error;
2178out_status:
2179        return nfs3_stat_to_errno(status);
2180}
2181
2182/*
2183 * 3.3.19  FSINFO3res
2184 *
2185 *      struct FSINFO3resok {
2186 *              post_op_attr    obj_attributes;
2187 *              uint32          rtmax;
2188 *              uint32          rtpref;
2189 *              uint32          rtmult;
2190 *              uint32          wtmax;
2191 *              uint32          wtpref;
2192 *              uint32          wtmult;
2193 *              uint32          dtpref;
2194 *              size3           maxfilesize;
2195 *              nfstime3        time_delta;
2196 *              uint32          properties;
2197 *      };
2198 *
2199 *      struct FSINFO3resfail {
2200 *              post_op_attr    obj_attributes;
2201 *      };
2202 *
2203 *      union FSINFO3res switch (nfsstat3 status) {
2204 *      case NFS3_OK:
2205 *              FSINFO3resok    resok;
2206 *      default:
2207 *              FSINFO3resfail  resfail;
2208 *      };
2209 */
2210static int decode_fsinfo3resok(struct xdr_stream *xdr,
2211                               struct nfs_fsinfo *result)
2212{
2213        __be32 *p;
2214
2215        p = xdr_inline_decode(xdr, 4 * 7 + 8 + 8 + 4);
2216        if (unlikely(!p))
2217                return -EIO;
2218        result->rtmax  = be32_to_cpup(p++);
2219        result->rtpref = be32_to_cpup(p++);
2220        result->rtmult = be32_to_cpup(p++);
2221        result->wtmax  = be32_to_cpup(p++);
2222        result->wtpref = be32_to_cpup(p++);
2223        result->wtmult = be32_to_cpup(p++);
2224        result->dtpref = be32_to_cpup(p++);
2225        p = xdr_decode_size3(p, &result->maxfilesize);
2226        xdr_decode_nfstime3(p, &result->time_delta);
2227
2228        /* ignore properties */
2229        result->lease_time = 0;
2230        result->change_attr_type = NFS4_CHANGE_TYPE_IS_TIME_METADATA;
2231        return 0;
2232}
2233
2234static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req,
2235                                   struct xdr_stream *xdr,
2236                                   void *data)
2237{
2238        struct nfs_fsinfo *result = data;
2239        enum nfs_stat status;
2240        int error;
2241
2242        error = decode_nfsstat3(xdr, &status);
2243        if (unlikely(error))
2244                goto out;
2245        error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2246        if (unlikely(error))
2247                goto out;
2248        if (status != NFS3_OK)
2249                goto out_status;
2250        error = decode_fsinfo3resok(xdr, result);
2251out:
2252        return error;
2253out_status:
2254        return nfs3_stat_to_errno(status);
2255}
2256
2257/*
2258 * 3.3.20  PATHCONF3res
2259 *
2260 *      struct PATHCONF3resok {
2261 *              post_op_attr    obj_attributes;
2262 *              uint32          linkmax;
2263 *              uint32          name_max;
2264 *              bool            no_trunc;
2265 *              bool            chown_restricted;
2266 *              bool            case_insensitive;
2267 *              bool            case_preserving;
2268 *      };
2269 *
2270 *      struct PATHCONF3resfail {
2271 *              post_op_attr    obj_attributes;
2272 *      };
2273 *
2274 *      union PATHCONF3res switch (nfsstat3 status) {
2275 *      case NFS3_OK:
2276 *              PATHCONF3resok  resok;
2277 *      default:
2278 *              PATHCONF3resfail resfail;
2279 *      };
2280 */
2281static int decode_pathconf3resok(struct xdr_stream *xdr,
2282                                 struct nfs_pathconf *result)
2283{
2284        __be32 *p;
2285
2286        p = xdr_inline_decode(xdr, 4 * 6);
2287        if (unlikely(!p))
2288                return -EIO;
2289        result->max_link = be32_to_cpup(p++);
2290        result->max_namelen = be32_to_cpup(p);
2291        /* ignore remaining fields */
2292        return 0;
2293}
2294
2295static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req,
2296                                     struct xdr_stream *xdr,
2297                                     void *data)
2298{
2299        struct nfs_pathconf *result = data;
2300        enum nfs_stat status;
2301        int error;
2302
2303        error = decode_nfsstat3(xdr, &status);
2304        if (unlikely(error))
2305                goto out;
2306        error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2307        if (unlikely(error))
2308                goto out;
2309        if (status != NFS3_OK)
2310                goto out_status;
2311        error = decode_pathconf3resok(xdr, result);
2312out:
2313        return error;
2314out_status:
2315        return nfs3_stat_to_errno(status);
2316}
2317
2318/*
2319 * 3.3.21  COMMIT3res
2320 *
2321 *      struct COMMIT3resok {
2322 *              wcc_data        file_wcc;
2323 *              writeverf3      verf;
2324 *      };
2325 *
2326 *      struct COMMIT3resfail {
2327 *              wcc_data        file_wcc;
2328 *      };
2329 *
2330 *      union COMMIT3res switch (nfsstat3 status) {
2331 *      case NFS3_OK:
2332 *              COMMIT3resok    resok;
2333 *      default:
2334 *              COMMIT3resfail  resfail;
2335 *      };
2336 */
2337static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req,
2338                                   struct xdr_stream *xdr,
2339                                   void *data)
2340{
2341        struct nfs_commitres *result = data;
2342        struct nfs_writeverf *verf = result->verf;
2343        enum nfs_stat status;
2344        int error;
2345
2346        error = decode_nfsstat3(xdr, &status);
2347        if (unlikely(error))
2348                goto out;
2349        error = decode_wcc_data(xdr, result->fattr, rpc_rqst_userns(req));
2350        if (unlikely(error))
2351                goto out;
2352        result->op_status = status;
2353        if (status != NFS3_OK)
2354                goto out_status;
2355        error = decode_writeverf3(xdr, &verf->verifier);
2356        if (!error)
2357                verf->committed = NFS_FILE_SYNC;
2358out:
2359        return error;
2360out_status:
2361        return nfs3_stat_to_errno(status);
2362}
2363
2364#ifdef CONFIG_NFS_V3_ACL
2365
2366static inline int decode_getacl3resok(struct xdr_stream *xdr,
2367                                      struct nfs3_getaclres *result,
2368                                      struct user_namespace *userns)
2369{
2370        struct posix_acl **acl;
2371        unsigned int *aclcnt;
2372        size_t hdrlen;
2373        int error;
2374
2375        error = decode_post_op_attr(xdr, result->fattr, userns);
2376        if (unlikely(error))
2377                goto out;
2378        error = decode_uint32(xdr, &result->mask);
2379        if (unlikely(error))
2380                goto out;
2381        error = -EINVAL;
2382        if (result->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
2383                goto out;
2384
2385        hdrlen = xdr_stream_pos(xdr);
2386
2387        acl = NULL;
2388        if (result->mask & NFS_ACL)
2389                acl = &result->acl_access;
2390        aclcnt = NULL;
2391        if (result->mask & NFS_ACLCNT)
2392                aclcnt = &result->acl_access_count;
2393        error = nfsacl_decode(xdr->buf, hdrlen, aclcnt, acl);
2394        if (unlikely(error <= 0))
2395                goto out;
2396
2397        acl = NULL;
2398        if (result->mask & NFS_DFACL)
2399                acl = &result->acl_default;
2400        aclcnt = NULL;
2401        if (result->mask & NFS_DFACLCNT)
2402                aclcnt = &result->acl_default_count;
2403        error = nfsacl_decode(xdr->buf, hdrlen + error, aclcnt, acl);
2404        if (unlikely(error <= 0))
2405                return error;
2406        error = 0;
2407out:
2408        return error;
2409}
2410
2411static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req,
2412                                   struct xdr_stream *xdr,
2413                                   void *result)
2414{
2415        enum nfs_stat status;
2416        int error;
2417
2418        error = decode_nfsstat3(xdr, &status);
2419        if (unlikely(error))
2420                goto out;
2421        if (status != NFS3_OK)
2422                goto out_default;
2423        error = decode_getacl3resok(xdr, result, rpc_rqst_userns(req));
2424out:
2425        return error;
2426out_default:
2427        return nfs3_stat_to_errno(status);
2428}
2429
2430static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req,
2431                                   struct xdr_stream *xdr,
2432                                   void *result)
2433{
2434        enum nfs_stat status;
2435        int error;
2436
2437        error = decode_nfsstat3(xdr, &status);
2438        if (unlikely(error))
2439                goto out;
2440        if (status != NFS3_OK)
2441                goto out_default;
2442        error = decode_post_op_attr(xdr, result, rpc_rqst_userns(req));
2443out:
2444        return error;
2445out_default:
2446        return nfs3_stat_to_errno(status);
2447}
2448
2449#endif  /* CONFIG_NFS_V3_ACL */
2450
2451
2452/*
2453 * We need to translate between nfs status return values and
2454 * the local errno values which may not be the same.
2455 */
2456static const struct {
2457        int stat;
2458        int errno;
2459} nfs_errtbl[] = {
2460        { NFS_OK,               0               },
2461        { NFSERR_PERM,          -EPERM          },
2462        { NFSERR_NOENT,         -ENOENT         },
2463        { NFSERR_IO,            -errno_NFSERR_IO},
2464        { NFSERR_NXIO,          -ENXIO          },
2465/*      { NFSERR_EAGAIN,        -EAGAIN         }, */
2466        { NFSERR_ACCES,         -EACCES         },
2467        { NFSERR_EXIST,         -EEXIST         },
2468        { NFSERR_XDEV,          -EXDEV          },
2469        { NFSERR_NODEV,         -ENODEV         },
2470        { NFSERR_NOTDIR,        -ENOTDIR        },
2471        { NFSERR_ISDIR,         -EISDIR         },
2472        { NFSERR_INVAL,         -EINVAL         },
2473        { NFSERR_FBIG,          -EFBIG          },
2474        { NFSERR_NOSPC,         -ENOSPC         },
2475        { NFSERR_ROFS,          -EROFS          },
2476        { NFSERR_MLINK,         -EMLINK         },
2477        { NFSERR_NAMETOOLONG,   -ENAMETOOLONG   },
2478        { NFSERR_NOTEMPTY,      -ENOTEMPTY      },
2479        { NFSERR_DQUOT,         -EDQUOT         },
2480        { NFSERR_STALE,         -ESTALE         },
2481        { NFSERR_REMOTE,        -EREMOTE        },
2482#ifdef EWFLUSH
2483        { NFSERR_WFLUSH,        -EWFLUSH        },
2484#endif
2485        { NFSERR_BADHANDLE,     -EBADHANDLE     },
2486        { NFSERR_NOT_SYNC,      -ENOTSYNC       },
2487        { NFSERR_BAD_COOKIE,    -EBADCOOKIE     },
2488        { NFSERR_NOTSUPP,       -ENOTSUPP       },
2489        { NFSERR_TOOSMALL,      -ETOOSMALL      },
2490        { NFSERR_SERVERFAULT,   -EREMOTEIO      },
2491        { NFSERR_BADTYPE,       -EBADTYPE       },
2492        { NFSERR_JUKEBOX,       -EJUKEBOX       },
2493        { -1,                   -EIO            }
2494};
2495
2496/**
2497 * nfs3_stat_to_errno - convert an NFS status code to a local errno
2498 * @status: NFS status code to convert
2499 *
2500 * Returns a local errno value, or -EIO if the NFS status code is
2501 * not recognized.  This function is used jointly by NFSv2 and NFSv3.
2502 */
2503static int nfs3_stat_to_errno(enum nfs_stat status)
2504{
2505        int i;
2506
2507        for (i = 0; nfs_errtbl[i].stat != -1; i++) {
2508                if (nfs_errtbl[i].stat == (int)status)
2509                        return nfs_errtbl[i].errno;
2510        }
2511        dprintk("NFS: Unrecognized nfs status value: %u\n", status);
2512        return nfs_errtbl[i].errno;
2513}
2514
2515
2516#define PROC(proc, argtype, restype, timer)                             \
2517[NFS3PROC_##proc] = {                                                   \
2518        .p_proc      = NFS3PROC_##proc,                                 \
2519        .p_encode    = nfs3_xdr_enc_##argtype##3args,                   \
2520        .p_decode    = nfs3_xdr_dec_##restype##3res,                    \
2521        .p_arglen    = NFS3_##argtype##args_sz,                         \
2522        .p_replen    = NFS3_##restype##res_sz,                          \
2523        .p_timer     = timer,                                           \
2524        .p_statidx   = NFS3PROC_##proc,                                 \
2525        .p_name      = #proc,                                           \
2526        }
2527
2528const struct rpc_procinfo nfs3_procedures[] = {
2529        PROC(GETATTR,           getattr,        getattr,        1),
2530        PROC(SETATTR,           setattr,        setattr,        0),
2531        PROC(LOOKUP,            lookup,         lookup,         2),
2532        PROC(ACCESS,            access,         access,         1),
2533        PROC(READLINK,          readlink,       readlink,       3),
2534        PROC(READ,              read,           read,           3),
2535        PROC(WRITE,             write,          write,          4),
2536        PROC(CREATE,            create,         create,         0),
2537        PROC(MKDIR,             mkdir,          create,         0),
2538        PROC(SYMLINK,           symlink,        create,         0),
2539        PROC(MKNOD,             mknod,          create,         0),
2540        PROC(REMOVE,            remove,         remove,         0),
2541        PROC(RMDIR,             lookup,         setattr,        0),
2542        PROC(RENAME,            rename,         rename,         0),
2543        PROC(LINK,              link,           link,           0),
2544        PROC(READDIR,           readdir,        readdir,        3),
2545        PROC(READDIRPLUS,       readdirplus,    readdir,        3),
2546        PROC(FSSTAT,            getattr,        fsstat,         0),
2547        PROC(FSINFO,            getattr,        fsinfo,         0),
2548        PROC(PATHCONF,          getattr,        pathconf,       0),
2549        PROC(COMMIT,            commit,         commit,         5),
2550};
2551
2552static unsigned int nfs_version3_counts[ARRAY_SIZE(nfs3_procedures)];
2553const struct rpc_version nfs_version3 = {
2554        .number                 = 3,
2555        .nrprocs                = ARRAY_SIZE(nfs3_procedures),
2556        .procs                  = nfs3_procedures,
2557        .counts                 = nfs_version3_counts,
2558};
2559
2560#ifdef CONFIG_NFS_V3_ACL
2561static const struct rpc_procinfo nfs3_acl_procedures[] = {
2562        [ACLPROC3_GETACL] = {
2563                .p_proc = ACLPROC3_GETACL,
2564                .p_encode = nfs3_xdr_enc_getacl3args,
2565                .p_decode = nfs3_xdr_dec_getacl3res,
2566                .p_arglen = ACL3_getaclargs_sz,
2567                .p_replen = ACL3_getaclres_sz,
2568                .p_timer = 1,
2569                .p_name = "GETACL",
2570        },
2571        [ACLPROC3_SETACL] = {
2572                .p_proc = ACLPROC3_SETACL,
2573                .p_encode = nfs3_xdr_enc_setacl3args,
2574                .p_decode = nfs3_xdr_dec_setacl3res,
2575                .p_arglen = ACL3_setaclargs_sz,
2576                .p_replen = ACL3_setaclres_sz,
2577                .p_timer = 0,
2578                .p_name = "SETACL",
2579        },
2580};
2581
2582static unsigned int nfs3_acl_counts[ARRAY_SIZE(nfs3_acl_procedures)];
2583const struct rpc_version nfsacl_version3 = {
2584        .number                 = 3,
2585        .nrprocs                = ARRAY_SIZE(nfs3_acl_procedures),
2586        .procs                  = nfs3_acl_procedures,
2587        .counts                 = nfs3_acl_counts,
2588};
2589#endif  /* CONFIG_NFS_V3_ACL */
2590