fs/nfs/nfs3xdr.c

   1 /*
   2  * linux/fs/nfs/nfs3xdr.c
   3  *
   4  * XDR functions to encode/decode NFSv3 RPC arguments and results.
   5  *
   6  * Copyright (C) 1996, 1997 Olaf Kirch
   7  */
   8
   9 #include <linux/param.h>
  10 #include <linux/time.h>
  11 #include <linux/mm.h>
  12 #include <linux/errno.h>
  13 #include <linux/string.h>
  14 #include <linux/in.h>
  15 #include <linux/pagemap.h>
  16 #include <linux/proc_fs.h>
  17 #include <linux/kdev_t.h>
  18 #include <linux/sunrpc/clnt.h>
  19 #include <linux/nfs.h>
  20 #include <linux/nfs3.h>
  21 #include <linux/nfs_fs.h>
  22 #include <linux/nfsacl.h>
  23 #include "internal.h"
  24
  25 #define NFSDBG_FACILITY         NFSDBG_XDR
  26
  27 /* Mapping from NFS error code to "errno" error code. */
  28 #define errno_NFSERR_IO         EIO
  29
  30 /*
  31  * Declare the space requirements for NFS arguments and replies as
  32  * number of 32bit-words
  33  */
  34 #define NFS3_fhandle_sz         (1+16)
  35 #define NFS3_fh_sz              (NFS3_fhandle_sz)       /* shorthand */
  36 #define NFS3_sattr_sz           (15)
  37 #define NFS3_filename_sz        (1+(NFS3_MAXNAMLEN>>2))
  38 #define NFS3_path_sz            (1+(NFS3_MAXPATHLEN>>2))
  39 #define NFS3_fattr_sz           (21)
  40 #define NFS3_wcc_attr_sz                (6)
  41 #define NFS3_pre_op_attr_sz     (1+NFS3_wcc_attr_sz)
  42 #define NFS3_post_op_attr_sz    (1+NFS3_fattr_sz)
  43 #define NFS3_wcc_data_sz                (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
  44 #define NFS3_fsstat_sz
  45 #define NFS3_fsinfo_sz
  46 #define NFS3_pathconf_sz
  47 #define NFS3_entry_sz           (NFS3_filename_sz+3)
  48
  49 #define NFS3_sattrargs_sz       (NFS3_fh_sz+NFS3_sattr_sz+3)
  50 #define NFS3_diropargs_sz       (NFS3_fh_sz+NFS3_filename_sz)
  51 #define NFS3_removeargs_sz      (NFS3_fh_sz+NFS3_filename_sz)
  52 #define NFS3_accessargs_sz      (NFS3_fh_sz+1)
  53 #define NFS3_readlinkargs_sz    (NFS3_fh_sz)
  54 #define NFS3_readargs_sz        (NFS3_fh_sz+3)
  55 #define NFS3_writeargs_sz       (NFS3_fh_sz+5)
  56 #define NFS3_createargs_sz      (NFS3_diropargs_sz+NFS3_sattr_sz)
  57 #define NFS3_mkdirargs_sz       (NFS3_diropargs_sz+NFS3_sattr_sz)
  58 #define NFS3_symlinkargs_sz     (NFS3_diropargs_sz+1+NFS3_sattr_sz)
  59 #define NFS3_mknodargs_sz       (NFS3_diropargs_sz+2+NFS3_sattr_sz)
  60 #define NFS3_renameargs_sz      (NFS3_diropargs_sz+NFS3_diropargs_sz)
  61 #define NFS3_linkargs_sz                (NFS3_fh_sz+NFS3_diropargs_sz)
  62 #define NFS3_readdirargs_sz     (NFS3_fh_sz+2)
  63 #define NFS3_commitargs_sz      (NFS3_fh_sz+3)
  64
  65 #define NFS3_attrstat_sz        (1+NFS3_fattr_sz)
  66 #define NFS3_wccstat_sz         (1+NFS3_wcc_data_sz)
  67 #define NFS3_removeres_sz       (NFS3_wccstat_sz)
  68 #define NFS3_lookupres_sz       (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz))
  69 #define NFS3_accessres_sz       (1+NFS3_post_op_attr_sz+1)
  70 #define NFS3_readlinkres_sz     (1+NFS3_post_op_attr_sz+1)
  71 #define NFS3_readres_sz         (1+NFS3_post_op_attr_sz+3)
  72 #define NFS3_writeres_sz        (1+NFS3_wcc_data_sz+4)
  73 #define NFS3_createres_sz       (1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
  74 #define NFS3_renameres_sz       (1+(2 * NFS3_wcc_data_sz))
  75 #define NFS3_linkres_sz         (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
  76 #define NFS3_readdirres_sz      (1+NFS3_post_op_attr_sz+2)
  77 #define NFS3_fsstatres_sz       (1+NFS3_post_op_attr_sz+13)
  78 #define NFS3_fsinfores_sz       (1+NFS3_post_op_attr_sz+12)
  79 #define NFS3_pathconfres_sz     (1+NFS3_post_op_attr_sz+6)
  80 #define NFS3_commitres_sz       (1+NFS3_wcc_data_sz+2)
  81
  82 #define ACL3_getaclargs_sz      (NFS3_fh_sz+1)
  83 #define ACL3_setaclargs_sz      (NFS3_fh_sz+1+ \
  84                                 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
  85 #define ACL3_getaclres_sz       (1+NFS3_post_op_attr_sz+1+ \
  86                                 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
  87 #define ACL3_setaclres_sz       (1+NFS3_post_op_attr_sz)
  88
  89 /*
  90  * Map file type to S_IFMT bits
  91  */
  92 static const umode_t nfs_type2fmt[] = {
  93         [NF3BAD] = 0,
  94         [NF3REG] = S_IFREG,
  95         [NF3DIR] = S_IFDIR,
  96         [NF3BLK] = S_IFBLK,
  97         [NF3CHR] = S_IFCHR,
  98         [NF3LNK] = S_IFLNK,
  99         [NF3SOCK] = S_IFSOCK,
 100         [NF3FIFO] = S_IFIFO,
 101 };
 102
 103 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
 104 {
 105         dprintk("nfs: %s: prematurely hit end of receive buffer. "
 106                 "Remaining buffer length is %tu words.\n",
 107                 func, xdr->end - xdr->p);
 108 }
 109
 110 /*
 111  * Common NFS XDR functions as inlines
 112  */
 113 static inline __be32 *
 114 xdr_encode_fhandle(__be32 *p, const struct nfs_fh *fh)
 115 {
 116         return xdr_encode_array(p, fh->data, fh->size);
 117 }
 118
 119 static inline __be32 *
 120 xdr_decode_fhandle(__be32 *p, struct nfs_fh *fh)
 121 {
 122         if ((fh->size = ntohl(*p++)) <= NFS3_FHSIZE) {
 123                 memcpy(fh->data, p, fh->size);
 124                 return p + XDR_QUADLEN(fh->size);
 125         }
 126         return NULL;
 127 }
 128
 129 static inline __be32 *
 130 xdr_decode_fhandle_stream(struct xdr_stream *xdr, struct nfs_fh *fh)
 131 {
 132         __be32 *p;
 133         p = xdr_inline_decode(xdr, 4);
 134         if (unlikely(!p))
 135                 goto out_overflow;
 136         fh->size = ntohl(*p++);
 137
 138         if (fh->size <= NFS3_FHSIZE) {
 139                 p = xdr_inline_decode(xdr, fh->size);
 140                 if (unlikely(!p))
 141                         goto out_overflow;
 142                 memcpy(fh->data, p, fh->size);
 143                 return p + XDR_QUADLEN(fh->size);
 144         }
 145         return NULL;
 146
 147 out_overflow:
 148         print_overflow_msg(__func__, xdr);
 149         return ERR_PTR(-EIO);
 150 }
 151
 152 /*
 153  * Encode/decode time.
 154  */
 155 static inline __be32 *
 156 xdr_encode_time3(__be32 *p, struct timespec *timep)
 157 {
 158         *p++ = htonl(timep->tv_sec);
 159         *p++ = htonl(timep->tv_nsec);
 160         return p;
 161 }
 162
 163 static inline __be32 *
 164 xdr_decode_time3(__be32 *p, struct timespec *timep)
 165 {
 166         timep->tv_sec = ntohl(*p++);
 167         timep->tv_nsec = ntohl(*p++);
 168         return p;
 169 }
 170
 171 static __be32 *
 172 xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr)
 173 {
 174         unsigned int    type, major, minor;
 175         umode_t         fmode;
 176
 177         type = ntohl(*p++);
 178         if (type > NF3FIFO)
 179                 type = NF3NON;
 180         fmode = nfs_type2fmt[type];
 181         fattr->mode = (ntohl(*p++) & ~S_IFMT) | fmode;
 182         fattr->nlink = ntohl(*p++);
 183         fattr->uid = ntohl(*p++);
 184         fattr->gid = ntohl(*p++);
 185         p = xdr_decode_hyper(p, &fattr->size);
 186         p = xdr_decode_hyper(p, &fattr->du.nfs3.used);
 187
 188         /* Turn remote device info into Linux-specific dev_t */
 189         major = ntohl(*p++);
 190         minor = ntohl(*p++);
 191         fattr->rdev = MKDEV(major, minor);
 192         if (MAJOR(fattr->rdev) != major || MINOR(fattr->rdev) != minor)
 193                 fattr->rdev = 0;
 194
 195         p = xdr_decode_hyper(p, &fattr->fsid.major);
 196         fattr->fsid.minor = 0;
 197         p = xdr_decode_hyper(p, &fattr->fileid);
 198         p = xdr_decode_time3(p, &fattr->atime);
 199         p = xdr_decode_time3(p, &fattr->mtime);
 200         p = xdr_decode_time3(p, &fattr->ctime);
 201
 202         /* Update the mode bits */
 203         fattr->valid |= NFS_ATTR_FATTR_V3;
 204         return p;
 205 }
 206
 207 static inline __be32 *
 208 xdr_encode_sattr(__be32 *p, struct iattr *attr)
 209 {
 210         if (attr->ia_valid & ATTR_MODE) {
 211                 *p++ = xdr_one;
 212                 *p++ = htonl(attr->ia_mode & S_IALLUGO);
 213         } else {
 214                 *p++ = xdr_zero;
 215         }
 216         if (attr->ia_valid & ATTR_UID) {
 217                 *p++ = xdr_one;
 218                 *p++ = htonl(attr->ia_uid);
 219         } else {
 220                 *p++ = xdr_zero;
 221         }
 222         if (attr->ia_valid & ATTR_GID) {
 223                 *p++ = xdr_one;
 224                 *p++ = htonl(attr->ia_gid);
 225         } else {
 226                 *p++ = xdr_zero;
 227         }
 228         if (attr->ia_valid & ATTR_SIZE) {
 229                 *p++ = xdr_one;
 230                 p = xdr_encode_hyper(p, (__u64) attr->ia_size);
 231         } else {
 232                 *p++ = xdr_zero;
 233         }
 234         if (attr->ia_valid & ATTR_ATIME_SET) {
 235                 *p++ = xdr_two;
 236                 p = xdr_encode_time3(p, &attr->ia_atime);
 237         } else if (attr->ia_valid & ATTR_ATIME) {
 238                 *p++ = xdr_one;
 239         } else {
 240                 *p++ = xdr_zero;
 241         }
 242         if (attr->ia_valid & ATTR_MTIME_SET) {
 243                 *p++ = xdr_two;
 244                 p = xdr_encode_time3(p, &attr->ia_mtime);
 245         } else if (attr->ia_valid & ATTR_MTIME) {
 246                 *p++ = xdr_one;
 247         } else {
 248                 *p++ = xdr_zero;
 249         }
 250         return p;
 251 }
 252
 253 static inline __be32 *
 254 xdr_decode_wcc_attr(__be32 *p, struct nfs_fattr *fattr)
 255 {
 256         p = xdr_decode_hyper(p, &fattr->pre_size);
 257         p = xdr_decode_time3(p, &fattr->pre_mtime);
 258         p = xdr_decode_time3(p, &fattr->pre_ctime);
 259         fattr->valid |= NFS_ATTR_FATTR_PRESIZE
 260                 | NFS_ATTR_FATTR_PREMTIME
 261                 | NFS_ATTR_FATTR_PRECTIME;
 262         return p;
 263 }
 264
 265 static inline __be32 *
 266 xdr_decode_post_op_attr(__be32 *p, struct nfs_fattr *fattr)
 267 {
 268         if (*p++)
 269                 p = xdr_decode_fattr(p, fattr);
 270         return p;
 271 }
 272
 273 static inline __be32 *
 274 xdr_decode_post_op_attr_stream(struct xdr_stream *xdr, struct nfs_fattr *fattr)
 275 {
 276         __be32 *p;
 277
 278         p = xdr_inline_decode(xdr, 4);
 279         if (unlikely(!p))
 280                 goto out_overflow;
 281         if (ntohl(*p++)) {
 282                 p = xdr_inline_decode(xdr, 84);
 283                 if (unlikely(!p))
 284                         goto out_overflow;
 285                 p = xdr_decode_fattr(p, fattr);
 286         }
 287         return p;
 288 out_overflow:
 289         print_overflow_msg(__func__, xdr);
 290         return ERR_PTR(-EIO);
 291 }
 292
 293 static inline __be32 *
 294 xdr_decode_pre_op_attr(__be32 *p, struct nfs_fattr *fattr)
 295 {
 296         if (*p++)
 297                 return xdr_decode_wcc_attr(p, fattr);
 298         return p;
 299 }
 300
 301
 302 static inline __be32 *
 303 xdr_decode_wcc_data(__be32 *p, struct nfs_fattr *fattr)
 304 {
 305         p = xdr_decode_pre_op_attr(p, fattr);
 306         return xdr_decode_post_op_attr(p, fattr);
 307 }
 308
 309 /*
 310  * NFS encode functions
 311  */
 312
 313 /*
 314  * Encode file handle argument
 315  */
 316 static int
 317 nfs3_xdr_fhandle(struct rpc_rqst *req, __be32 *p, struct nfs_fh *fh)
 318 {
 319         p = xdr_encode_fhandle(p, fh);
 320         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 321         return 0;
 322 }
 323
 324 /*
 325  * Encode SETATTR arguments
 326  */
 327 static int
 328 nfs3_xdr_sattrargs(struct rpc_rqst *req, __be32 *p, struct nfs3_sattrargs *args)
 329 {
 330         p = xdr_encode_fhandle(p, args->fh);
 331         p = xdr_encode_sattr(p, args->sattr);
 332         *p++ = htonl(args->guard);
 333         if (args->guard)
 334                 p = xdr_encode_time3(p, &args->guardtime);
 335         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 336         return 0;
 337 }
 338
 339 /*
 340  * Encode directory ops argument
 341  */
 342 static int
 343 nfs3_xdr_diropargs(struct rpc_rqst *req, __be32 *p, struct nfs3_diropargs *args)
 344 {
 345         p = xdr_encode_fhandle(p, args->fh);
 346         p = xdr_encode_array(p, args->name, args->len);
 347         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 348         return 0;
 349 }
 350
 351 /*
 352  * Encode REMOVE argument
 353  */
 354 static int
 355 nfs3_xdr_removeargs(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args)
 356 {
 357         p = xdr_encode_fhandle(p, args->fh);
 358         p = xdr_encode_array(p, args->name.name, args->name.len);
 359         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 360         return 0;
 361 }
 362
 363 /*
 364  * Encode access() argument
 365  */
 366 static int
 367 nfs3_xdr_accessargs(struct rpc_rqst *req, __be32 *p, struct nfs3_accessargs *args)
 368 {
 369         p = xdr_encode_fhandle(p, args->fh);
 370         *p++ = htonl(args->access);
 371         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 372         return 0;
 373 }
 374
 375 /*
 376  * Arguments to a READ call. Since we read data directly into the page
 377  * cache, we also set up the reply iovec here so that iov[1] points
 378  * exactly to the page we want to fetch.
 379  */
 380 static int
 381 nfs3_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
 382 {
 383         struct rpc_auth *auth = req->rq_cred->cr_auth;
 384         unsigned int replen;
 385         u32 count = args->count;
 386
 387         p = xdr_encode_fhandle(p, args->fh);
 388         p = xdr_encode_hyper(p, args->offset);
 389         *p++ = htonl(count);
 390         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 391
 392         /* Inline the page array */
 393         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readres_sz) << 2;
 394         xdr_inline_pages(&req->rq_rcv_buf, replen,
 395                          args->pages, args->pgbase, count);
 396         req->rq_rcv_buf.flags |= XDRBUF_READ;
 397         return 0;
 398 }
 399
 400 /*
 401  * Write arguments. Splice the buffer to be written into the iovec.
 402  */
 403 static int
 404 nfs3_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
 405 {
 406         struct xdr_buf *sndbuf = &req->rq_snd_buf;
 407         u32 count = args->count;
 408
 409         p = xdr_encode_fhandle(p, args->fh);
 410         p = xdr_encode_hyper(p, args->offset);
 411         *p++ = htonl(count);
 412         *p++ = htonl(args->stable);
 413         *p++ = htonl(count);
 414         sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
 415
 416         /* Copy the page array */
 417         xdr_encode_pages(sndbuf, args->pages, args->pgbase, count);
 418         sndbuf->flags |= XDRBUF_WRITE;
 419         return 0;
 420 }
 421
 422 /*
 423  * Encode CREATE arguments
 424  */
 425 static int
 426 nfs3_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs3_createargs *args)
 427 {
 428         p = xdr_encode_fhandle(p, args->fh);
 429         p = xdr_encode_array(p, args->name, args->len);
 430
 431         *p++ = htonl(args->createmode);
 432         if (args->createmode == NFS3_CREATE_EXCLUSIVE) {
 433                 *p++ = args->verifier[0];
 434                 *p++ = args->verifier[1];
 435         } else
 436                 p = xdr_encode_sattr(p, args->sattr);
 437
 438         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 439         return 0;
 440 }
 441
 442 /*
 443  * Encode MKDIR arguments
 444  */
 445 static int
 446 nfs3_xdr_mkdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_mkdirargs *args)
 447 {
 448         p = xdr_encode_fhandle(p, args->fh);
 449         p = xdr_encode_array(p, args->name, args->len);
 450         p = xdr_encode_sattr(p, args->sattr);
 451         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 452         return 0;
 453 }
 454
 455 /*
 456  * Encode SYMLINK arguments
 457  */
 458 static int
 459 nfs3_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_symlinkargs *args)
 460 {
 461         p = xdr_encode_fhandle(p, args->fromfh);
 462         p = xdr_encode_array(p, args->fromname, args->fromlen);
 463         p = xdr_encode_sattr(p, args->sattr);
 464         *p++ = htonl(args->pathlen);
 465         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 466
 467         /* Copy the page */
 468         xdr_encode_pages(&req->rq_snd_buf, args->pages, 0, args->pathlen);
 469         return 0;
 470 }
 471
 472 /*
 473  * Encode MKNOD arguments
 474  */
 475 static int
 476 nfs3_xdr_mknodargs(struct rpc_rqst *req, __be32 *p, struct nfs3_mknodargs *args)
 477 {
 478         p = xdr_encode_fhandle(p, args->fh);
 479         p = xdr_encode_array(p, args->name, args->len);
 480         *p++ = htonl(args->type);
 481         p = xdr_encode_sattr(p, args->sattr);
 482         if (args->type == NF3CHR || args->type == NF3BLK) {
 483                 *p++ = htonl(MAJOR(args->rdev));
 484                 *p++ = htonl(MINOR(args->rdev));
 485         }
 486
 487         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 488         return 0;
 489 }
 490
 491 /*
 492  * Encode RENAME arguments
 493  */
 494 static int
 495 nfs3_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs_renameargs *args)
 496 {
 497         p = xdr_encode_fhandle(p, args->old_dir);
 498         p = xdr_encode_array(p, args->old_name->name, args->old_name->len);
 499         p = xdr_encode_fhandle(p, args->new_dir);
 500         p = xdr_encode_array(p, args->new_name->name, args->new_name->len);
 501         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 502         return 0;
 503 }
 504
 505 /*
 506  * Encode LINK arguments
 507  */
 508 static int
 509 nfs3_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_linkargs *args)
 510 {
 511         p = xdr_encode_fhandle(p, args->fromfh);
 512         p = xdr_encode_fhandle(p, args->tofh);
 513         p = xdr_encode_array(p, args->toname, args->tolen);
 514         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 515         return 0;
 516 }
 517
 518 /*
 519  * Encode arguments to readdir call
 520  */
 521 static int
 522 nfs3_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirargs *args)
 523 {
 524         struct rpc_auth *auth = req->rq_cred->cr_auth;
 525         unsigned int replen;
 526         u32 count = args->count;
 527
 528         p = xdr_encode_fhandle(p, args->fh);
 529         p = xdr_encode_hyper(p, args->cookie);
 530         *p++ = args->verf[0];
 531         *p++ = args->verf[1];
 532         if (args->plus) {
 533                 /* readdirplus: need dircount + buffer size.
 534                  * We just make sure we make dircount big enough */
 535                 *p++ = htonl(count >> 3);
 536         }
 537         *p++ = htonl(count);
 538         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 539
 540         /* Inline the page array */
 541         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readdirres_sz) << 2;
 542         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count);
 543         return 0;
 544 }
 545
 546 /*
 547  * Decode the result of a readdir call.
 548  * We just check for syntactical correctness.
 549  */
 550 static int
 551 nfs3_xdr_readdirres(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirres *res)
 552 {
 553         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 554         struct kvec *iov = rcvbuf->head;
 555         struct page **page;
 556         size_t hdrlen;
 557         u32 recvd, pglen;
 558         int status;
 559
 560         status = ntohl(*p++);
 561         /* Decode post_op_attrs */
 562         p = xdr_decode_post_op_attr(p, res->dir_attr);
 563         if (status)
 564                 return nfs_stat_to_errno(status);
 565         /* Decode verifier cookie */
 566         if (res->verf) {
 567                 res->verf[0] = *p++;
 568                 res->verf[1] = *p++;
 569         } else {
 570                 p += 2;
 571         }
 572
 573         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 574         if (iov->iov_len < hdrlen) {
 575                 dprintk("NFS: READDIR reply header overflowed:"
 576                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
 577                 return -errno_NFSERR_IO;
 578         } else if (iov->iov_len != hdrlen) {
 579                 dprintk("NFS: READDIR header is short. iovec will be shifted.\n");
 580                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 581         }
 582
 583         pglen = rcvbuf->page_len;
 584         recvd = rcvbuf->len - hdrlen;
 585         if (pglen > recvd)
 586                 pglen = recvd;
 587         page = rcvbuf->pages;
 588
 589         return pglen;
 590 }
 591
 592 __be32 *
 593 nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry, struct nfs_server *server, int plus)
 594 {
 595         __be32 *p;
 596         struct nfs_entry old = *entry;
 597
 598         p = xdr_inline_decode(xdr, 4);
 599         if (unlikely(!p))
 600                 goto out_overflow;
 601         if (!ntohl(*p++)) {
 602                 p = xdr_inline_decode(xdr, 4);
 603                 if (unlikely(!p))
 604                         goto out_overflow;
 605                 if (!ntohl(*p++))
 606                         return ERR_PTR(-EAGAIN);
 607                 entry->eof = 1;
 608                 return ERR_PTR(-EBADCOOKIE);
 609         }
 610
 611         p = xdr_inline_decode(xdr, 12);
 612         if (unlikely(!p))
 613                 goto out_overflow;
 614         p = xdr_decode_hyper(p, &entry->ino);
 615         entry->len  = ntohl(*p++);
 616
 617         p = xdr_inline_decode(xdr, entry->len + 8);
 618         if (unlikely(!p))
 619                 goto out_overflow;
 620         entry->name = (const char *) p;
 621         p += XDR_QUADLEN(entry->len);
 622         entry->prev_cookie = entry->cookie;
 623         p = xdr_decode_hyper(p, &entry->cookie);
 624
 625         entry->d_type = DT_UNKNOWN;
 626         if (plus) {
 627                 entry->fattr->valid = 0;
 628                 p = xdr_decode_post_op_attr_stream(xdr, entry->fattr);
 629                 if (IS_ERR(p))
 630                         goto out_overflow_exit;
 631                 entry->d_type = nfs_umode_to_dtype(entry->fattr->mode);
 632                 /* In fact, a post_op_fh3: */
 633                 p = xdr_inline_decode(xdr, 4);
 634                 if (unlikely(!p))
 635                         goto out_overflow;
 636                 if (*p++) {
 637                         p = xdr_decode_fhandle_stream(xdr, entry->fh);
 638                         if (IS_ERR(p))
 639                                 goto out_overflow_exit;
 640                         /* Ugh -- server reply was truncated */
 641                         if (p == NULL) {
 642                                 dprintk("NFS: FH truncated\n");
 643                                 *entry = old;
 644                                 return ERR_PTR(-EAGAIN);
 645                         }
 646                 } else
 647                         memset((u8*)(entry->fh), 0, sizeof(*entry->fh));
 648         }
 649
 650         return p;
 651
 652 out_overflow:
 653         print_overflow_msg(__func__, xdr);
 654 out_overflow_exit:
 655         return ERR_PTR(-EAGAIN);
 656 }
 657
 658 /*
 659  * Encode COMMIT arguments
 660  */
 661 static int
 662 nfs3_xdr_commitargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
 663 {
 664         p = xdr_encode_fhandle(p, args->fh);
 665         p = xdr_encode_hyper(p, args->offset);
 666         *p++ = htonl(args->count);
 667         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 668         return 0;
 669 }
 670
 671 #ifdef CONFIG_NFS_V3_ACL
 672 /*
 673  * Encode GETACL arguments
 674  */
 675 static int
 676 nfs3_xdr_getaclargs(struct rpc_rqst *req, __be32 *p,
 677                     struct nfs3_getaclargs *args)
 678 {
 679         struct rpc_auth *auth = req->rq_cred->cr_auth;
 680         unsigned int replen;
 681
 682         p = xdr_encode_fhandle(p, args->fh);
 683         *p++ = htonl(args->mask);
 684         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 685
 686         if (args->mask & (NFS_ACL | NFS_DFACL)) {
 687                 /* Inline the page array */
 688                 replen = (RPC_REPHDRSIZE + auth->au_rslack +
 689                           ACL3_getaclres_sz) << 2;
 690                 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0,
 691                                  NFSACL_MAXPAGES << PAGE_SHIFT);
 692         }
 693         return 0;
 694 }
 695
 696 /*
 697  * Encode SETACL arguments
 698  */
 699 static int
 700 nfs3_xdr_setaclargs(struct rpc_rqst *req, __be32 *p,
 701                    struct nfs3_setaclargs *args)
 702 {
 703         struct xdr_buf *buf = &req->rq_snd_buf;
 704         unsigned int base;
 705         int err;
 706
 707         p = xdr_encode_fhandle(p, NFS_FH(args->inode));
 708         *p++ = htonl(args->mask);
 709         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 710         base = req->rq_slen;
 711
 712         if (args->npages != 0)
 713                 xdr_encode_pages(buf, args->pages, 0, args->len);
 714         else
 715                 req->rq_slen = xdr_adjust_iovec(req->rq_svec,
 716                                 p + XDR_QUADLEN(args->len));
 717
 718         err = nfsacl_encode(buf, base, args->inode,
 719                             (args->mask & NFS_ACL) ?
 720                             args->acl_access : NULL, 1, 0);
 721         if (err > 0)
 722                 err = nfsacl_encode(buf, base + err, args->inode,
 723                                     (args->mask & NFS_DFACL) ?
 724                                     args->acl_default : NULL, 1,
 725                                     NFS_ACL_DEFAULT);
 726         return (err > 0) ? 0 : err;
 727 }
 728 #endif  /* CONFIG_NFS_V3_ACL */
 729
 730 /*
 731  * NFS XDR decode functions
 732  */
 733
 734 /*
 735  * Decode attrstat reply.
 736  */
 737 static int
 738 nfs3_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
 739 {
 740         int     status;
 741
 742         if ((status = ntohl(*p++)))
 743                 return nfs_stat_to_errno(status);
 744         xdr_decode_fattr(p, fattr);
 745         return 0;
 746 }
 747
 748 /*
 749  * Decode status+wcc_data reply
 750  * SATTR, REMOVE, RMDIR
 751  */
 752 static int
 753 nfs3_xdr_wccstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
 754 {
 755         int     status;
 756
 757         if ((status = ntohl(*p++)))
 758                 status = nfs_stat_to_errno(status);
 759         xdr_decode_wcc_data(p, fattr);
 760         return status;
 761 }
 762
 763 static int
 764 nfs3_xdr_removeres(struct rpc_rqst *req, __be32 *p, struct nfs_removeres *res)
 765 {
 766         return nfs3_xdr_wccstat(req, p, res->dir_attr);
 767 }
 768
 769 /*
 770  * Decode LOOKUP reply
 771  */
 772 static int
 773 nfs3_xdr_lookupres(struct rpc_rqst *req, __be32 *p, struct nfs3_diropres *res)
 774 {
 775         int     status;
 776
 777         if ((status = ntohl(*p++))) {
 778                 status = nfs_stat_to_errno(status);
 779         } else {
 780                 if (!(p = xdr_decode_fhandle(p, res->fh)))
 781                         return -errno_NFSERR_IO;
 782                 p = xdr_decode_post_op_attr(p, res->fattr);
 783         }
 784         xdr_decode_post_op_attr(p, res->dir_attr);
 785         return status;
 786 }
 787
 788 /*
 789  * Decode ACCESS reply
 790  */
 791 static int
 792 nfs3_xdr_accessres(struct rpc_rqst *req, __be32 *p, struct nfs3_accessres *res)
 793 {
 794         int     status = ntohl(*p++);
 795
 796         p = xdr_decode_post_op_attr(p, res->fattr);
 797         if (status)
 798                 return nfs_stat_to_errno(status);
 799         res->access = ntohl(*p++);
 800         return 0;
 801 }
 802
 803 static int
 804 nfs3_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readlinkargs *args)
 805 {
 806         struct rpc_auth *auth = req->rq_cred->cr_auth;
 807         unsigned int replen;
 808
 809         p = xdr_encode_fhandle(p, args->fh);
 810         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 811
 812         /* Inline the page array */
 813         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readlinkres_sz) << 2;
 814         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen);
 815         return 0;
 816 }
 817
 818 /*
 819  * Decode READLINK reply
 820  */
 821 static int
 822 nfs3_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
 823 {
 824         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 825         struct kvec *iov = rcvbuf->head;
 826         size_t hdrlen;
 827         u32 len, recvd;
 828         int     status;
 829
 830         status = ntohl(*p++);
 831         p = xdr_decode_post_op_attr(p, fattr);
 832
 833         if (status != 0)
 834                 return nfs_stat_to_errno(status);
 835
 836         /* Convert length of symlink */
 837         len = ntohl(*p++);
 838         if (len >= rcvbuf->page_len) {
 839                 dprintk("nfs: server returned giant symlink!\n");
 840                 return -ENAMETOOLONG;
 841         }
 842
 843         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 844         if (iov->iov_len < hdrlen) {
 845                 dprintk("NFS: READLINK reply header overflowed:"
 846                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
 847                 return -errno_NFSERR_IO;
 848         } else if (iov->iov_len != hdrlen) {
 849                 dprintk("NFS: READLINK header is short. "
 850                         "iovec will be shifted.\n");
 851                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 852         }
 853         recvd = req->rq_rcv_buf.len - hdrlen;
 854         if (recvd < len) {
 855                 dprintk("NFS: server cheating in readlink reply: "
 856                                 "count %u > recvd %u\n", len, recvd);
 857                 return -EIO;
 858         }
 859
 860         xdr_terminate_string(rcvbuf, len);
 861         return 0;
 862 }
 863
 864 /*
 865  * Decode READ reply
 866  */
 867 static int
 868 nfs3_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res)
 869 {
 870         struct kvec *iov = req->rq_rcv_buf.head;
 871         size_t hdrlen;
 872         u32 count, ocount, recvd;
 873         int status;
 874
 875         status = ntohl(*p++);
 876         p = xdr_decode_post_op_attr(p, res->fattr);
 877
 878         if (status != 0)
 879                 return nfs_stat_to_errno(status);
 880
 881         /* Decode reply count and EOF flag. NFSv3 is somewhat redundant
 882          * in that it puts the count both in the res struct and in the
 883          * opaque data count. */
 884         count    = ntohl(*p++);
 885         res->eof = ntohl(*p++);
 886         ocount   = ntohl(*p++);
 887
 888         if (ocount != count) {
 889                 dprintk("NFS: READ count doesn't match RPC opaque count.\n");
 890                 return -errno_NFSERR_IO;
 891         }
 892
 893         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 894         if (iov->iov_len < hdrlen) {
 895                 dprintk("NFS: READ reply header overflowed:"
 896                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
 897                 return -errno_NFSERR_IO;
 898         } else if (iov->iov_len != hdrlen) {
 899                 dprintk("NFS: READ header is short. iovec will be shifted.\n");
 900                 xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen);
 901         }
 902
 903         recvd = req->rq_rcv_buf.len - hdrlen;
 904         if (count > recvd) {
 905                 dprintk("NFS: server cheating in read reply: "
 906                         "count %u > recvd %u\n", count, recvd);
 907                 count = recvd;
 908                 res->eof = 0;
 909         }
 910
 911         if (count < res->count)
 912                 res->count = count;
 913
 914         return count;
 915 }
 916
 917 /*
 918  * Decode WRITE response
 919  */
 920 static int
 921 nfs3_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
 922 {
 923         int     status;
 924
 925         status = ntohl(*p++);
 926         p = xdr_decode_wcc_data(p, res->fattr);
 927
 928         if (status != 0)
 929                 return nfs_stat_to_errno(status);
 930
 931         res->count = ntohl(*p++);
 932         res->verf->committed = (enum nfs3_stable_how)ntohl(*p++);
 933         res->verf->verifier[0] = *p++;
 934         res->verf->verifier[1] = *p++;
 935
 936         return res->count;
 937 }
 938
 939 /*
 940  * Decode a CREATE response
 941  */
 942 static int
 943 nfs3_xdr_createres(struct rpc_rqst *req, __be32 *p, struct nfs3_diropres *res)
 944 {
 945         int     status;
 946
 947         status = ntohl(*p++);
 948         if (status == 0) {
 949                 if (*p++) {
 950                         if (!(p = xdr_decode_fhandle(p, res->fh)))
 951                                 return -errno_NFSERR_IO;
 952                         p = xdr_decode_post_op_attr(p, res->fattr);
 953                 } else {
 954                         memset(res->fh, 0, sizeof(*res->fh));
 955                         /* Do decode post_op_attr but set it to NULL */
 956                         p = xdr_decode_post_op_attr(p, res->fattr);
 957                         res->fattr->valid = 0;
 958                 }
 959         } else {
 960                 status = nfs_stat_to_errno(status);
 961         }
 962         p = xdr_decode_wcc_data(p, res->dir_attr);
 963         return status;
 964 }
 965
 966 /*
 967  * Decode RENAME reply
 968  */
 969 static int
 970 nfs3_xdr_renameres(struct rpc_rqst *req, __be32 *p, struct nfs_renameres *res)
 971 {
 972         int     status;
 973
 974         if ((status = ntohl(*p++)) != 0)
 975                 status = nfs_stat_to_errno(status);
 976         p = xdr_decode_wcc_data(p, res->old_fattr);
 977         p = xdr_decode_wcc_data(p, res->new_fattr);
 978         return status;
 979 }
 980
 981 /*
 982  * Decode LINK reply
 983  */
 984 static int
 985 nfs3_xdr_linkres(struct rpc_rqst *req, __be32 *p, struct nfs3_linkres *res)
 986 {
 987         int     status;
 988
 989         if ((status = ntohl(*p++)) != 0)
 990                 status = nfs_stat_to_errno(status);
 991         p = xdr_decode_post_op_attr(p, res->fattr);
 992         p = xdr_decode_wcc_data(p, res->dir_attr);
 993         return status;
 994 }
 995
 996 /*
 997  * Decode FSSTAT reply
 998  */
 999 static int
1000 nfs3_xdr_fsstatres(struct rpc_rqst *req, __be32 *p, struct nfs_fsstat *res)
1001 {
1002         int             status;
1003
1004         status = ntohl(*p++);
1005
1006         p = xdr_decode_post_op_attr(p, res->fattr);
1007         if (status != 0)
1008                 return nfs_stat_to_errno(status);
1009
1010         p = xdr_decode_hyper(p, &res->tbytes);
1011         p = xdr_decode_hyper(p, &res->fbytes);
1012         p = xdr_decode_hyper(p, &res->abytes);
1013         p = xdr_decode_hyper(p, &res->tfiles);
1014         p = xdr_decode_hyper(p, &res->ffiles);
1015         p = xdr_decode_hyper(p, &res->afiles);
1016
1017         /* ignore invarsec */
1018         return 0;
1019 }
1020
1021 /*
1022  * Decode FSINFO reply
1023  */
1024 static int
1025 nfs3_xdr_fsinfores(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfo *res)
1026 {
1027         int             status;
1028
1029         status = ntohl(*p++);
1030
1031         p = xdr_decode_post_op_attr(p, res->fattr);
1032         if (status != 0)
1033                 return nfs_stat_to_errno(status);
1034
1035         res->rtmax  = ntohl(*p++);
1036         res->rtpref = ntohl(*p++);
1037         res->rtmult = ntohl(*p++);
1038         res->wtmax  = ntohl(*p++);
1039         res->wtpref = ntohl(*p++);
1040         res->wtmult = ntohl(*p++);
1041         res->dtpref = ntohl(*p++);
1042         p = xdr_decode_hyper(p, &res->maxfilesize);
1043         p = xdr_decode_time3(p, &res->time_delta);
1044
1045         /* ignore properties */
1046         res->lease_time = 0;
1047         return 0;
1048 }
1049
1050 /*
1051  * Decode PATHCONF reply
1052  */
1053 static int
1054 nfs3_xdr_pathconfres(struct rpc_rqst *req, __be32 *p, struct nfs_pathconf *res)
1055 {
1056         int             status;
1057
1058         status = ntohl(*p++);
1059
1060         p = xdr_decode_post_op_attr(p, res->fattr);
1061         if (status != 0)
1062                 return nfs_stat_to_errno(status);
1063         res->max_link = ntohl(*p++);
1064         res->max_namelen = ntohl(*p++);
1065
1066         /* ignore remaining fields */
1067         return 0;
1068 }
1069
1070 /*
1071  * Decode COMMIT reply
1072  */
1073 static int
1074 nfs3_xdr_commitres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
1075 {
1076         int             status;
1077
1078         status = ntohl(*p++);
1079         p = xdr_decode_wcc_data(p, res->fattr);
1080         if (status != 0)
1081                 return nfs_stat_to_errno(status);
1082
1083         res->verf->verifier[0] = *p++;
1084         res->verf->verifier[1] = *p++;
1085         return 0;
1086 }
1087
1088 #ifdef CONFIG_NFS_V3_ACL
1089 /*
1090  * Decode GETACL reply
1091  */
1092 static int
1093 nfs3_xdr_getaclres(struct rpc_rqst *req, __be32 *p,
1094                    struct nfs3_getaclres *res)
1095 {
1096         struct xdr_buf *buf = &req->rq_rcv_buf;
1097         int status = ntohl(*p++);
1098         struct posix_acl **acl;
1099         unsigned int *aclcnt;
1100         int err, base;
1101
1102         if (status != 0)
1103                 return nfs_stat_to_errno(status);
1104         p = xdr_decode_post_op_attr(p, res->fattr);
1105         res->mask = ntohl(*p++);
1106         if (res->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
1107                 return -EINVAL;
1108         base = (char *)p - (char *)req->rq_rcv_buf.head->iov_base;
1109
1110         acl = (res->mask & NFS_ACL) ? &res->acl_access : NULL;
1111         aclcnt = (res->mask & NFS_ACLCNT) ? &res->acl_access_count : NULL;
1112         err = nfsacl_decode(buf, base, aclcnt, acl);
1113
1114         acl = (res->mask & NFS_DFACL) ? &res->acl_default : NULL;
1115         aclcnt = (res->mask & NFS_DFACLCNT) ? &res->acl_default_count : NULL;
1116         if (err > 0)
1117                 err = nfsacl_decode(buf, base + err, aclcnt, acl);
1118         return (err > 0) ? 0 : err;
1119 }
1120
1121 /*
1122  * Decode setacl reply.
1123  */
1124 static int
1125 nfs3_xdr_setaclres(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
1126 {
1127         int status = ntohl(*p++);
1128
1129         if (status)
1130                 return nfs_stat_to_errno(status);
1131         xdr_decode_post_op_attr(p, fattr);
1132         return 0;
1133 }
1134 #endif  /* CONFIG_NFS_V3_ACL */
1135
1136 #define PROC(proc, argtype, restype, timer)                             \
1137 [NFS3PROC_##proc] = {                                                   \
1138         .p_proc      = NFS3PROC_##proc,                                 \
1139         .p_encode    = (kxdrproc_t) nfs3_xdr_##argtype,                 \
1140         .p_decode    = (kxdrproc_t) nfs3_xdr_##restype,                 \
1141         .p_arglen    = NFS3_##argtype##_sz,                             \
1142         .p_replen    = NFS3_##restype##_sz,                             \
1143         .p_timer     = timer,                                           \
1144         .p_statidx   = NFS3PROC_##proc,                                 \
1145         .p_name      = #proc,                                           \
1146         }
1147
1148 struct rpc_procinfo     nfs3_procedures[] = {
1149   PROC(GETATTR,         fhandle,        attrstat, 1),
1150   PROC(SETATTR,         sattrargs,      wccstat, 0),
1151   PROC(LOOKUP,          diropargs,      lookupres, 2),
1152   PROC(ACCESS,          accessargs,     accessres, 1),
1153   PROC(READLINK,        readlinkargs,   readlinkres, 3),
1154   PROC(READ,            readargs,       readres, 3),
1155   PROC(WRITE,           writeargs,      writeres, 4),
1156   PROC(CREATE,          createargs,     createres, 0),
1157   PROC(MKDIR,           mkdirargs,      createres, 0),
1158   PROC(SYMLINK,         symlinkargs,    createres, 0),
1159   PROC(MKNOD,           mknodargs,      createres, 0),
1160   PROC(REMOVE,          removeargs,     removeres, 0),
1161   PROC(RMDIR,           diropargs,      wccstat, 0),
1162   PROC(RENAME,          renameargs,     renameres, 0),
1163   PROC(LINK,            linkargs,       linkres, 0),
1164   PROC(READDIR,         readdirargs,    readdirres, 3),
1165   PROC(READDIRPLUS,     readdirargs,    readdirres, 3),
1166   PROC(FSSTAT,          fhandle,        fsstatres, 0),
1167   PROC(FSINFO,          fhandle,        fsinfores, 0),
1168   PROC(PATHCONF,        fhandle,        pathconfres, 0),
1169   PROC(COMMIT,          commitargs,     commitres, 5),
1170 };
1171
1172 struct rpc_version              nfs_version3 = {
1173         .number                 = 3,
1174         .nrprocs                = ARRAY_SIZE(nfs3_procedures),
1175         .procs                  = nfs3_procedures
1176 };
1177
1178 #ifdef CONFIG_NFS_V3_ACL
1179 static struct rpc_procinfo      nfs3_acl_procedures[] = {
1180         [ACLPROC3_GETACL] = {
1181                 .p_proc = ACLPROC3_GETACL,
1182                 .p_encode = (kxdrproc_t) nfs3_xdr_getaclargs,
1183                 .p_decode = (kxdrproc_t) nfs3_xdr_getaclres,
1184                 .p_arglen = ACL3_getaclargs_sz,
1185                 .p_replen = ACL3_getaclres_sz,
1186                 .p_timer = 1,
1187                 .p_name = "GETACL",
1188         },
1189         [ACLPROC3_SETACL] = {
1190                 .p_proc = ACLPROC3_SETACL,
1191                 .p_encode = (kxdrproc_t) nfs3_xdr_setaclargs,
1192                 .p_decode = (kxdrproc_t) nfs3_xdr_setaclres,
1193                 .p_arglen = ACL3_setaclargs_sz,
1194                 .p_replen = ACL3_setaclres_sz,
1195                 .p_timer = 0,
1196                 .p_name = "SETACL",
1197         },
1198 };
1199
1200 struct rpc_version              nfsacl_version3 = {
1201         .number                 = 3,
1202         .nrprocs                = sizeof(nfs3_acl_procedures)/
1203                                   sizeof(nfs3_acl_procedures[0]),
1204         .procs                  = nfs3_acl_procedures,
1205 };
1206 #endif  /* CONFIG_NFS_V3_ACL */