SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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         return 0;
 350 }
 351
 352 /*
 353  * Write arguments. Splice the buffer to be written into the iovec.
 354  */
 355 static int
 356 nfs3_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
 357 {
 358         struct xdr_buf *sndbuf = &req->rq_snd_buf;
 359         u32 count = args->count;
 360
 361         p = xdr_encode_fhandle(p, args->fh);
 362         p = xdr_encode_hyper(p, args->offset);
 363         *p++ = htonl(count);
 364         *p++ = htonl(args->stable);
 365         *p++ = htonl(count);
 366         sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
 367
 368         /* Copy the page array */
 369         xdr_encode_pages(sndbuf, args->pages, args->pgbase, count);
 370         return 0;
 371 }
 372
 373 /*
 374  * Encode CREATE arguments
 375  */
 376 static int
 377 nfs3_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs3_createargs *args)
 378 {
 379         p = xdr_encode_fhandle(p, args->fh);
 380         p = xdr_encode_array(p, args->name, args->len);
 381
 382         *p++ = htonl(args->createmode);
 383         if (args->createmode == NFS3_CREATE_EXCLUSIVE) {
 384                 *p++ = args->verifier[0];
 385                 *p++ = args->verifier[1];
 386         } else
 387                 p = xdr_encode_sattr(p, args->sattr);
 388
 389         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 390         return 0;
 391 }
 392
 393 /*
 394  * Encode MKDIR arguments
 395  */
 396 static int
 397 nfs3_xdr_mkdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_mkdirargs *args)
 398 {
 399         p = xdr_encode_fhandle(p, args->fh);
 400         p = xdr_encode_array(p, args->name, args->len);
 401         p = xdr_encode_sattr(p, args->sattr);
 402         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 403         return 0;
 404 }
 405
 406 /*
 407  * Encode SYMLINK arguments
 408  */
 409 static int
 410 nfs3_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_symlinkargs *args)
 411 {
 412         p = xdr_encode_fhandle(p, args->fromfh);
 413         p = xdr_encode_array(p, args->fromname, args->fromlen);
 414         p = xdr_encode_sattr(p, args->sattr);
 415         *p++ = htonl(args->pathlen);
 416         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 417
 418         /* Copy the page */
 419         xdr_encode_pages(&req->rq_snd_buf, args->pages, 0, args->pathlen);
 420         return 0;
 421 }
 422
 423 /*
 424  * Encode MKNOD arguments
 425  */
 426 static int
 427 nfs3_xdr_mknodargs(struct rpc_rqst *req, __be32 *p, struct nfs3_mknodargs *args)
 428 {
 429         p = xdr_encode_fhandle(p, args->fh);
 430         p = xdr_encode_array(p, args->name, args->len);
 431         *p++ = htonl(args->type);
 432         p = xdr_encode_sattr(p, args->sattr);
 433         if (args->type == NF3CHR || args->type == NF3BLK) {
 434                 *p++ = htonl(MAJOR(args->rdev));
 435                 *p++ = htonl(MINOR(args->rdev));
 436         }
 437
 438         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 439         return 0;
 440 }
 441
 442 /*
 443  * Encode RENAME arguments
 444  */
 445 static int
 446 nfs3_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs3_renameargs *args)
 447 {
 448         p = xdr_encode_fhandle(p, args->fromfh);
 449         p = xdr_encode_array(p, args->fromname, args->fromlen);
 450         p = xdr_encode_fhandle(p, args->tofh);
 451         p = xdr_encode_array(p, args->toname, args->tolen);
 452         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 453         return 0;
 454 }
 455
 456 /*
 457  * Encode LINK arguments
 458  */
 459 static int
 460 nfs3_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_linkargs *args)
 461 {
 462         p = xdr_encode_fhandle(p, args->fromfh);
 463         p = xdr_encode_fhandle(p, args->tofh);
 464         p = xdr_encode_array(p, args->toname, args->tolen);
 465         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 466         return 0;
 467 }
 468
 469 /*
 470  * Encode arguments to readdir call
 471  */
 472 static int
 473 nfs3_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirargs *args)
 474 {
 475         struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 476         unsigned int replen;
 477         u32 count = args->count;
 478
 479         p = xdr_encode_fhandle(p, args->fh);
 480         p = xdr_encode_hyper(p, args->cookie);
 481         *p++ = args->verf[0];
 482         *p++ = args->verf[1];
 483         if (args->plus) {
 484                 /* readdirplus: need dircount + buffer size.
 485                  * We just make sure we make dircount big enough */
 486                 *p++ = htonl(count >> 3);
 487         }
 488         *p++ = htonl(count);
 489         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 490
 491         /* Inline the page array */
 492         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readdirres_sz) << 2;
 493         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count);
 494         return 0;
 495 }
 496
 497 /*
 498  * Decode the result of a readdir call.
 499  * We just check for syntactical correctness.
 500  */
 501 static int
 502 nfs3_xdr_readdirres(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirres *res)
 503 {
 504         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 505         struct kvec *iov = rcvbuf->head;
 506         struct page **page;
 507         int hdrlen, recvd;
 508         int status, nr;
 509         unsigned int len, pglen;
 510         __be32 *entry, *end, *kaddr;
 511
 512         status = ntohl(*p++);
 513         /* Decode post_op_attrs */
 514         p = xdr_decode_post_op_attr(p, res->dir_attr);
 515         if (status)
 516                 return -nfs_stat_to_errno(status);
 517         /* Decode verifier cookie */
 518         if (res->verf) {
 519                 res->verf[0] = *p++;
 520                 res->verf[1] = *p++;
 521         } else {
 522                 p += 2;
 523         }
 524
 525         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 526         if (iov->iov_len < hdrlen) {
 527                 printk(KERN_WARNING "NFS: READDIR reply header overflowed:"
 528                                 "length %d > %Zu\n", hdrlen, iov->iov_len);
 529                 return -errno_NFSERR_IO;
 530         } else if (iov->iov_len != hdrlen) {
 531                 dprintk("NFS: READDIR header is short. iovec will be shifted.\n");
 532                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 533         }
 534
 535         pglen = rcvbuf->page_len;
 536         recvd = rcvbuf->len - hdrlen;
 537         if (pglen > recvd)
 538                 pglen = recvd;
 539         page = rcvbuf->pages;
 540         kaddr = p = kmap_atomic(*page, KM_USER0);
 541         end = (__be32 *)((char *)p + pglen);
 542         entry = p;
 543         for (nr = 0; *p++; nr++) {
 544                 if (p + 3 > end)
 545                         goto short_pkt;
 546                 p += 2;                         /* inode # */
 547                 len = ntohl(*p++);              /* string length */
 548                 p += XDR_QUADLEN(len) + 2;      /* name + cookie */
 549                 if (len > NFS3_MAXNAMLEN) {
 550                         printk(KERN_WARNING "NFS: giant filename in readdir (len %x)!\n",
 551                                                 len);
 552                         goto err_unmap;
 553                 }
 554
 555                 if (res->plus) {
 556                         /* post_op_attr */
 557                         if (p + 2 > end)
 558                                 goto short_pkt;
 559                         if (*p++) {
 560                                 p += 21;
 561                                 if (p + 1 > end)
 562                                         goto short_pkt;
 563                         }
 564                         /* post_op_fh3 */
 565                         if (*p++) {
 566                                 if (p + 1 > end)
 567                                         goto short_pkt;
 568                                 len = ntohl(*p++);
 569                                 if (len > NFS3_FHSIZE) {
 570                                         printk(KERN_WARNING "NFS: giant filehandle in "
 571                                                 "readdir (len %x)!\n", len);
 572                                         goto err_unmap;
 573                                 }
 574                                 p += XDR_QUADLEN(len);
 575                         }
 576                 }
 577
 578                 if (p + 2 > end)
 579                         goto short_pkt;
 580                 entry = p;
 581         }
 582         if (!nr && (entry[0] != 0 || entry[1] == 0))
 583                 goto short_pkt;
 584  out:
 585         kunmap_atomic(kaddr, KM_USER0);
 586         return nr;
 587  short_pkt:
 588         entry[0] = entry[1] = 0;
 589         /* truncate listing ? */
 590         if (!nr) {
 591                 printk(KERN_NOTICE "NFS: readdir reply truncated!\n");
 592                 entry[1] = 1;
 593         }
 594         goto out;
 595 err_unmap:
 596         nr = -errno_NFSERR_IO;
 597         goto out;
 598 }
 599
 600 __be32 *
 601 nfs3_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus)
 602 {
 603         struct nfs_entry old = *entry;
 604
 605         if (!*p++) {
 606                 if (!*p)
 607                         return ERR_PTR(-EAGAIN);
 608                 entry->eof = 1;
 609                 return ERR_PTR(-EBADCOOKIE);
 610         }
 611
 612         p = xdr_decode_hyper(p, &entry->ino);
 613         entry->len  = ntohl(*p++);
 614         entry->name = (const char *) p;
 615         p += XDR_QUADLEN(entry->len);
 616         entry->prev_cookie = entry->cookie;
 617         p = xdr_decode_hyper(p, &entry->cookie);
 618
 619         if (plus) {
 620                 entry->fattr->valid = 0;
 621                 p = xdr_decode_post_op_attr(p, entry->fattr);
 622                 /* In fact, a post_op_fh3: */
 623                 if (*p++) {
 624                         p = xdr_decode_fhandle(p, entry->fh);
 625                         /* Ugh -- server reply was truncated */
 626                         if (p == NULL) {
 627                                 dprintk("NFS: FH truncated\n");
 628                                 *entry = old;
 629                                 return ERR_PTR(-EAGAIN);
 630                         }
 631                 } else
 632                         memset((u8*)(entry->fh), 0, sizeof(*entry->fh));
 633         }
 634
 635         entry->eof = !p[0] && p[1];
 636         return p;
 637 }
 638
 639 /*
 640  * Encode COMMIT arguments
 641  */
 642 static int
 643 nfs3_xdr_commitargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
 644 {
 645         p = xdr_encode_fhandle(p, args->fh);
 646         p = xdr_encode_hyper(p, args->offset);
 647         *p++ = htonl(args->count);
 648         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 649         return 0;
 650 }
 651
 652 #ifdef CONFIG_NFS_V3_ACL
 653 /*
 654  * Encode GETACL arguments
 655  */
 656 static int
 657 nfs3_xdr_getaclargs(struct rpc_rqst *req, __be32 *p,
 658                     struct nfs3_getaclargs *args)
 659 {
 660         struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 661         unsigned int replen;
 662
 663         p = xdr_encode_fhandle(p, args->fh);
 664         *p++ = htonl(args->mask);
 665         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 666
 667         if (args->mask & (NFS_ACL | NFS_DFACL)) {
 668                 /* Inline the page array */
 669                 replen = (RPC_REPHDRSIZE + auth->au_rslack +
 670                           ACL3_getaclres_sz) << 2;
 671                 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0,
 672                                  NFSACL_MAXPAGES << PAGE_SHIFT);
 673         }
 674         return 0;
 675 }
 676
 677 /*
 678  * Encode SETACL arguments
 679  */
 680 static int
 681 nfs3_xdr_setaclargs(struct rpc_rqst *req, __be32 *p,
 682                    struct nfs3_setaclargs *args)
 683 {
 684         struct xdr_buf *buf = &req->rq_snd_buf;
 685         unsigned int base, len_in_head, len = nfsacl_size(
 686                 (args->mask & NFS_ACL)   ? args->acl_access  : NULL,
 687                 (args->mask & NFS_DFACL) ? args->acl_default : NULL);
 688         int count, err;
 689
 690         p = xdr_encode_fhandle(p, NFS_FH(args->inode));
 691         *p++ = htonl(args->mask);
 692         base = (char *)p - (char *)buf->head->iov_base;
 693         /* put as much of the acls into head as possible. */
 694         len_in_head = min_t(unsigned int, buf->head->iov_len - base, len);
 695         len -= len_in_head;
 696         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p + (len_in_head >> 2));
 697
 698         for (count = 0; (count << PAGE_SHIFT) < len; count++) {
 699                 args->pages[count] = alloc_page(GFP_KERNEL);
 700                 if (!args->pages[count]) {
 701                         while (count)
 702                                 __free_page(args->pages[--count]);
 703                         return -ENOMEM;
 704                 }
 705         }
 706         xdr_encode_pages(buf, args->pages, 0, len);
 707
 708         err = nfsacl_encode(buf, base, args->inode,
 709                             (args->mask & NFS_ACL) ?
 710                             args->acl_access : NULL, 1, 0);
 711         if (err > 0)
 712                 err = nfsacl_encode(buf, base + err, args->inode,
 713                                     (args->mask & NFS_DFACL) ?
 714                                     args->acl_default : NULL, 1,
 715                                     NFS_ACL_DEFAULT);
 716         return (err > 0) ? 0 : err;
 717 }
 718 #endif  /* CONFIG_NFS_V3_ACL */
 719
 720 /*
 721  * NFS XDR decode functions
 722  */
 723
 724 /*
 725  * Decode attrstat reply.
 726  */
 727 static int
 728 nfs3_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
 729 {
 730         int     status;
 731
 732         if ((status = ntohl(*p++)))
 733                 return -nfs_stat_to_errno(status);
 734         xdr_decode_fattr(p, fattr);
 735         return 0;
 736 }
 737
 738 /*
 739  * Decode status+wcc_data reply
 740  * SATTR, REMOVE, RMDIR
 741  */
 742 static int
 743 nfs3_xdr_wccstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
 744 {
 745         int     status;
 746
 747         if ((status = ntohl(*p++)))
 748                 status = -nfs_stat_to_errno(status);
 749         xdr_decode_wcc_data(p, fattr);
 750         return status;
 751 }
 752
 753 static int
 754 nfs3_xdr_removeres(struct rpc_rqst *req, __be32 *p, struct nfs_removeres *res)
 755 {
 756         return nfs3_xdr_wccstat(req, p, &res->dir_attr);
 757 }
 758
 759 /*
 760  * Decode LOOKUP reply
 761  */
 762 static int
 763 nfs3_xdr_lookupres(struct rpc_rqst *req, __be32 *p, struct nfs3_diropres *res)
 764 {
 765         int     status;
 766
 767         if ((status = ntohl(*p++))) {
 768                 status = -nfs_stat_to_errno(status);
 769         } else {
 770                 if (!(p = xdr_decode_fhandle(p, res->fh)))
 771                         return -errno_NFSERR_IO;
 772                 p = xdr_decode_post_op_attr(p, res->fattr);
 773         }
 774         xdr_decode_post_op_attr(p, res->dir_attr);
 775         return status;
 776 }
 777
 778 /*
 779  * Decode ACCESS reply
 780  */
 781 static int
 782 nfs3_xdr_accessres(struct rpc_rqst *req, __be32 *p, struct nfs3_accessres *res)
 783 {
 784         int     status = ntohl(*p++);
 785
 786         p = xdr_decode_post_op_attr(p, res->fattr);
 787         if (status)
 788                 return -nfs_stat_to_errno(status);
 789         res->access = ntohl(*p++);
 790         return 0;
 791 }
 792
 793 static int
 794 nfs3_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readlinkargs *args)
 795 {
 796         struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 797         unsigned int replen;
 798
 799         p = xdr_encode_fhandle(p, args->fh);
 800         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 801
 802         /* Inline the page array */
 803         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readlinkres_sz) << 2;
 804         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen);
 805         return 0;
 806 }
 807
 808 /*
 809  * Decode READLINK reply
 810  */
 811 static int
 812 nfs3_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
 813 {
 814         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 815         struct kvec *iov = rcvbuf->head;
 816         int hdrlen, len, recvd;
 817         char    *kaddr;
 818         int     status;
 819
 820         status = ntohl(*p++);
 821         p = xdr_decode_post_op_attr(p, fattr);
 822
 823         if (status != 0)
 824                 return -nfs_stat_to_errno(status);
 825
 826         /* Convert length of symlink */
 827         len = ntohl(*p++);
 828         if (len >= rcvbuf->page_len || len <= 0) {
 829                 dprintk(KERN_WARNING "nfs: server returned giant symlink!\n");
 830                 return -ENAMETOOLONG;
 831         }
 832
 833         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 834         if (iov->iov_len < hdrlen) {
 835                 printk(KERN_WARNING "NFS: READLINK reply header overflowed:"
 836                                 "length %d > %Zu\n", hdrlen, iov->iov_len);
 837                 return -errno_NFSERR_IO;
 838         } else if (iov->iov_len != hdrlen) {
 839                 dprintk("NFS: READLINK header is short. iovec will be shifted.\n");
 840                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 841         }
 842         recvd = req->rq_rcv_buf.len - hdrlen;
 843         if (recvd < len) {
 844                 printk(KERN_WARNING "NFS: server cheating in readlink reply: "
 845                                 "count %u > recvd %u\n", len, recvd);
 846                 return -EIO;
 847         }
 848
 849         /* NULL terminate the string we got */
 850         kaddr = (char*)kmap_atomic(rcvbuf->pages[0], KM_USER0);
 851         kaddr[len+rcvbuf->page_base] = '\0';
 852         kunmap_atomic(kaddr, KM_USER0);
 853         return 0;
 854 }
 855
 856 /*
 857  * Decode READ reply
 858  */
 859 static int
 860 nfs3_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res)
 861 {
 862         struct kvec *iov = req->rq_rcv_buf.head;
 863         int     status, count, ocount, recvd, hdrlen;
 864
 865         status = ntohl(*p++);
 866         p = xdr_decode_post_op_attr(p, res->fattr);
 867
 868         if (status != 0)
 869                 return -nfs_stat_to_errno(status);
 870
 871         /* Decode reply could and EOF flag. NFSv3 is somewhat redundant
 872          * in that it puts the count both in the res struct and in the
 873          * opaque data count. */
 874         count    = ntohl(*p++);
 875         res->eof = ntohl(*p++);
 876         ocount   = ntohl(*p++);
 877
 878         if (ocount != count) {
 879                 printk(KERN_WARNING "NFS: READ count doesn't match RPC opaque count.\n");
 880                 return -errno_NFSERR_IO;
 881         }
 882
 883         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 884         if (iov->iov_len < hdrlen) {
 885                 printk(KERN_WARNING "NFS: READ reply header overflowed:"
 886                                 "length %d > %Zu\n", hdrlen, iov->iov_len);
 887                 return -errno_NFSERR_IO;
 888         } else if (iov->iov_len != hdrlen) {
 889                 dprintk("NFS: READ header is short. iovec will be shifted.\n");
 890                 xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen);
 891         }
 892
 893         recvd = req->rq_rcv_buf.len - hdrlen;
 894         if (count > recvd) {
 895                 printk(KERN_WARNING "NFS: server cheating in read reply: "
 896                         "count %d > recvd %d\n", count, recvd);
 897                 count = recvd;
 898                 res->eof = 0;
 899         }
 900
 901         if (count < res->count)
 902                 res->count = count;
 903
 904         return count;
 905 }
 906
 907 /*
 908  * Decode WRITE response
 909  */
 910 static int
 911 nfs3_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
 912 {
 913         int     status;
 914
 915         status = ntohl(*p++);
 916         p = xdr_decode_wcc_data(p, res->fattr);
 917
 918         if (status != 0)
 919                 return -nfs_stat_to_errno(status);
 920
 921         res->count = ntohl(*p++);
 922         res->verf->committed = (enum nfs3_stable_how)ntohl(*p++);
 923         res->verf->verifier[0] = *p++;
 924         res->verf->verifier[1] = *p++;
 925
 926         return res->count;
 927 }
 928
 929 /*
 930  * Decode a CREATE response
 931  */
 932 static int
 933 nfs3_xdr_createres(struct rpc_rqst *req, __be32 *p, struct nfs3_diropres *res)
 934 {
 935         int     status;
 936
 937         status = ntohl(*p++);
 938         if (status == 0) {
 939                 if (*p++) {
 940                         if (!(p = xdr_decode_fhandle(p, res->fh)))
 941                                 return -errno_NFSERR_IO;
 942                         p = xdr_decode_post_op_attr(p, res->fattr);
 943                 } else {
 944                         memset(res->fh, 0, sizeof(*res->fh));
 945                         /* Do decode post_op_attr but set it to NULL */
 946                         p = xdr_decode_post_op_attr(p, res->fattr);
 947                         res->fattr->valid = 0;
 948                 }
 949         } else {
 950                 status = -nfs_stat_to_errno(status);
 951         }
 952         p = xdr_decode_wcc_data(p, res->dir_attr);
 953         return status;
 954 }
 955
 956 /*
 957  * Decode RENAME reply
 958  */
 959 static int
 960 nfs3_xdr_renameres(struct rpc_rqst *req, __be32 *p, struct nfs3_renameres *res)
 961 {
 962         int     status;
 963
 964         if ((status = ntohl(*p++)) != 0)
 965                 status = -nfs_stat_to_errno(status);
 966         p = xdr_decode_wcc_data(p, res->fromattr);
 967         p = xdr_decode_wcc_data(p, res->toattr);
 968         return status;
 969 }
 970
 971 /*
 972  * Decode LINK reply
 973  */
 974 static int
 975 nfs3_xdr_linkres(struct rpc_rqst *req, __be32 *p, struct nfs3_linkres *res)
 976 {
 977         int     status;
 978
 979         if ((status = ntohl(*p++)) != 0)
 980                 status = -nfs_stat_to_errno(status);
 981         p = xdr_decode_post_op_attr(p, res->fattr);
 982         p = xdr_decode_wcc_data(p, res->dir_attr);
 983         return status;
 984 }
 985
 986 /*
 987  * Decode FSSTAT reply
 988  */
 989 static int
 990 nfs3_xdr_fsstatres(struct rpc_rqst *req, __be32 *p, struct nfs_fsstat *res)
 991 {
 992         int             status;
 993
 994         status = ntohl(*p++);
 995
 996         p = xdr_decode_post_op_attr(p, res->fattr);
 997         if (status != 0)
 998                 return -nfs_stat_to_errno(status);
 999
1000         p = xdr_decode_hyper(p, &res->tbytes);
1001         p = xdr_decode_hyper(p, &res->fbytes);
1002         p = xdr_decode_hyper(p, &res->abytes);
1003         p = xdr_decode_hyper(p, &res->tfiles);
1004         p = xdr_decode_hyper(p, &res->ffiles);
1005         p = xdr_decode_hyper(p, &res->afiles);
1006
1007         /* ignore invarsec */
1008         return 0;
1009 }
1010
1011 /*
1012  * Decode FSINFO reply
1013  */
1014 static int
1015 nfs3_xdr_fsinfores(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfo *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         res->rtmax  = ntohl(*p++);
1026         res->rtpref = ntohl(*p++);
1027         res->rtmult = ntohl(*p++);
1028         res->wtmax  = ntohl(*p++);
1029         res->wtpref = ntohl(*p++);
1030         res->wtmult = ntohl(*p++);
1031         res->dtpref = ntohl(*p++);
1032         p = xdr_decode_hyper(p, &res->maxfilesize);
1033
1034         /* ignore time_delta and properties */
1035         res->lease_time = 0;
1036         return 0;
1037 }
1038
1039 /*
1040  * Decode PATHCONF reply
1041  */
1042 static int
1043 nfs3_xdr_pathconfres(struct rpc_rqst *req, __be32 *p, struct nfs_pathconf *res)
1044 {
1045         int             status;
1046
1047         status = ntohl(*p++);
1048
1049         p = xdr_decode_post_op_attr(p, res->fattr);
1050         if (status != 0)
1051                 return -nfs_stat_to_errno(status);
1052         res->max_link = ntohl(*p++);
1053         res->max_namelen = ntohl(*p++);
1054
1055         /* ignore remaining fields */
1056         return 0;
1057 }
1058
1059 /*
1060  * Decode COMMIT reply
1061  */
1062 static int
1063 nfs3_xdr_commitres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
1064 {
1065         int             status;
1066
1067         status = ntohl(*p++);
1068         p = xdr_decode_wcc_data(p, res->fattr);
1069         if (status != 0)
1070                 return -nfs_stat_to_errno(status);
1071
1072         res->verf->verifier[0] = *p++;
1073         res->verf->verifier[1] = *p++;
1074         return 0;
1075 }
1076
1077 #ifdef CONFIG_NFS_V3_ACL
1078 /*
1079  * Decode GETACL reply
1080  */
1081 static int
1082 nfs3_xdr_getaclres(struct rpc_rqst *req, __be32 *p,
1083                    struct nfs3_getaclres *res)
1084 {
1085         struct xdr_buf *buf = &req->rq_rcv_buf;
1086         int status = ntohl(*p++);
1087         struct posix_acl **acl;
1088         unsigned int *aclcnt;
1089         int err, base;
1090
1091         if (status != 0)
1092                 return -nfs_stat_to_errno(status);
1093         p = xdr_decode_post_op_attr(p, res->fattr);
1094         res->mask = ntohl(*p++);
1095         if (res->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
1096                 return -EINVAL;
1097         base = (char *)p - (char *)req->rq_rcv_buf.head->iov_base;
1098
1099         acl = (res->mask & NFS_ACL) ? &res->acl_access : NULL;
1100         aclcnt = (res->mask & NFS_ACLCNT) ? &res->acl_access_count : NULL;
1101         err = nfsacl_decode(buf, base, aclcnt, acl);
1102
1103         acl = (res->mask & NFS_DFACL) ? &res->acl_default : NULL;
1104         aclcnt = (res->mask & NFS_DFACLCNT) ? &res->acl_default_count : NULL;
1105         if (err > 0)
1106                 err = nfsacl_decode(buf, base + err, aclcnt, acl);
1107         return (err > 0) ? 0 : err;
1108 }
1109
1110 /*
1111  * Decode setacl reply.
1112  */
1113 static int
1114 nfs3_xdr_setaclres(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
1115 {
1116         int status = ntohl(*p++);
1117
1118         if (status)
1119                 return -nfs_stat_to_errno(status);
1120         xdr_decode_post_op_attr(p, fattr);
1121         return 0;
1122 }
1123 #endif  /* CONFIG_NFS_V3_ACL */
1124
1125 #define PROC(proc, argtype, restype, timer)                             \
1126 [NFS3PROC_##proc] = {                                                   \
1127         .p_proc      = NFS3PROC_##proc,                                 \
1128         .p_encode    = (kxdrproc_t) nfs3_xdr_##argtype,                 \
1129         .p_decode    = (kxdrproc_t) nfs3_xdr_##restype,                 \
1130         .p_arglen    = NFS3_##argtype##_sz,                             \
1131         .p_replen    = NFS3_##restype##_sz,                             \
1132         .p_timer     = timer,                                           \
1133         .p_statidx   = NFS3PROC_##proc,                                 \
1134         .p_name      = #proc,                                           \
1135         }
1136
1137 struct rpc_procinfo     nfs3_procedures[] = {
1138   PROC(GETATTR,         fhandle,        attrstat, 1),
1139   PROC(SETATTR,         sattrargs,      wccstat, 0),
1140   PROC(LOOKUP,          diropargs,      lookupres, 2),
1141   PROC(ACCESS,          accessargs,     accessres, 1),
1142   PROC(READLINK,        readlinkargs,   readlinkres, 3),
1143   PROC(READ,            readargs,       readres, 3),
1144   PROC(WRITE,           writeargs,      writeres, 4),
1145   PROC(CREATE,          createargs,     createres, 0),
1146   PROC(MKDIR,           mkdirargs,      createres, 0),
1147   PROC(SYMLINK,         symlinkargs,    createres, 0),
1148   PROC(MKNOD,           mknodargs,      createres, 0),
1149   PROC(REMOVE,          removeargs,     removeres, 0),
1150   PROC(RMDIR,           diropargs,      wccstat, 0),
1151   PROC(RENAME,          renameargs,     renameres, 0),
1152   PROC(LINK,            linkargs,       linkres, 0),
1153   PROC(READDIR,         readdirargs,    readdirres, 3),
1154   PROC(READDIRPLUS,     readdirargs,    readdirres, 3),
1155   PROC(FSSTAT,          fhandle,        fsstatres, 0),
1156   PROC(FSINFO,          fhandle,        fsinfores, 0),
1157   PROC(PATHCONF,        fhandle,        pathconfres, 0),
1158   PROC(COMMIT,          commitargs,     commitres, 5),
1159 };
1160
1161 struct rpc_version              nfs_version3 = {
1162         .number                 = 3,
1163         .nrprocs                = ARRAY_SIZE(nfs3_procedures),
1164         .procs                  = nfs3_procedures
1165 };
1166
1167 #ifdef CONFIG_NFS_V3_ACL
1168 static struct rpc_procinfo      nfs3_acl_procedures[] = {
1169         [ACLPROC3_GETACL] = {
1170                 .p_proc = ACLPROC3_GETACL,
1171                 .p_encode = (kxdrproc_t) nfs3_xdr_getaclargs,
1172                 .p_decode = (kxdrproc_t) nfs3_xdr_getaclres,
1173                 .p_arglen = ACL3_getaclargs_sz,
1174                 .p_replen = ACL3_getaclres_sz,
1175                 .p_timer = 1,
1176                 .p_name = "GETACL",
1177         },
1178         [ACLPROC3_SETACL] = {
1179                 .p_proc = ACLPROC3_SETACL,
1180                 .p_encode = (kxdrproc_t) nfs3_xdr_setaclargs,
1181                 .p_decode = (kxdrproc_t) nfs3_xdr_setaclres,
1182                 .p_arglen = ACL3_setaclargs_sz,
1183                 .p_replen = ACL3_setaclres_sz,
1184                 .p_timer = 0,
1185                 .p_name = "SETACL",
1186         },
1187 };
1188
1189 struct rpc_version              nfsacl_version3 = {
1190         .number                 = 3,
1191         .nrprocs                = sizeof(nfs3_acl_procedures)/
1192                                   sizeof(nfs3_acl_procedures[0]),
1193         .procs                  = nfs3_acl_procedures,
1194 };
1195 #endif  /* CONFIG_NFS_V3_ACL */