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