fs/nfs/nfs2xdr.c

   1 /*
   2  * linux/fs/nfs/nfs2xdr.c
   3  *
   4  * XDR functions to encode/decode NFS RPC arguments and results.
   5  *
   6  * Copyright (C) 1992, 1993, 1994  Rick Sladkey
   7  * Copyright (C) 1996 Olaf Kirch
   8  * 04 Aug 1998  Ion Badulescu <ionut@cs.columbia.edu>
   9  *              FIFO's need special handling in NFSv2
  10  */
  11
  12 #include <linux/param.h>
  13 #include <linux/time.h>
  14 #include <linux/mm.h>
  15 #include <linux/slab.h>
  16 #include <linux/utsname.h>
  17 #include <linux/errno.h>
  18 #include <linux/string.h>
  19 #include <linux/in.h>
  20 #include <linux/pagemap.h>
  21 #include <linux/proc_fs.h>
  22 #include <linux/sunrpc/clnt.h>
  23 #include <linux/nfs.h>
  24 #include <linux/nfs2.h>
  25 #include <linux/nfs_fs.h>
  26 #include "internal.h"
  27
  28 #define NFSDBG_FACILITY         NFSDBG_XDR
  29
  30 /* Mapping from NFS error code to "errno" error code. */
  31 #define errno_NFSERR_IO         EIO
  32
  33 /*
  34  * Declare the space requirements for NFS arguments and replies as
  35  * number of 32bit-words
  36  */
  37 #define NFS_fhandle_sz          (8)
  38 #define NFS_sattr_sz            (8)
  39 #define NFS_filename_sz         (1+(NFS2_MAXNAMLEN>>2))
  40 #define NFS_path_sz             (1+(NFS2_MAXPATHLEN>>2))
  41 #define NFS_fattr_sz            (17)
  42 #define NFS_info_sz             (5)
  43 #define NFS_entry_sz            (NFS_filename_sz+3)
  44
  45 #define NFS_diropargs_sz        (NFS_fhandle_sz+NFS_filename_sz)
  46 #define NFS_sattrargs_sz        (NFS_fhandle_sz+NFS_sattr_sz)
  47 #define NFS_readlinkargs_sz     (NFS_fhandle_sz)
  48 #define NFS_readargs_sz         (NFS_fhandle_sz+3)
  49 #define NFS_writeargs_sz        (NFS_fhandle_sz+4)
  50 #define NFS_createargs_sz       (NFS_diropargs_sz+NFS_sattr_sz)
  51 #define NFS_renameargs_sz       (NFS_diropargs_sz+NFS_diropargs_sz)
  52 #define NFS_linkargs_sz         (NFS_fhandle_sz+NFS_diropargs_sz)
  53 #define NFS_symlinkargs_sz      (NFS_diropargs_sz+1+NFS_sattr_sz)
  54 #define NFS_readdirargs_sz      (NFS_fhandle_sz+2)
  55
  56 #define NFS_attrstat_sz         (1+NFS_fattr_sz)
  57 #define NFS_diropres_sz         (1+NFS_fhandle_sz+NFS_fattr_sz)
  58 #define NFS_readlinkres_sz      (2)
  59 #define NFS_readres_sz          (1+NFS_fattr_sz+1)
  60 #define NFS_writeres_sz         (NFS_attrstat_sz)
  61 #define NFS_stat_sz             (1)
  62 #define NFS_readdirres_sz       (1)
  63 #define NFS_statfsres_sz        (1+NFS_info_sz)
  64
  65 /*
  66  * Common NFS XDR functions as inlines
  67  */
  68 static inline __be32 *
  69 xdr_encode_fhandle(__be32 *p, struct nfs_fh *fhandle)
  70 {
  71         memcpy(p, fhandle->data, NFS2_FHSIZE);
  72         return p + XDR_QUADLEN(NFS2_FHSIZE);
  73 }
  74
  75 static inline __be32 *
  76 xdr_decode_fhandle(__be32 *p, struct nfs_fh *fhandle)
  77 {
  78         /* NFSv2 handles have a fixed length */
  79         fhandle->size = NFS2_FHSIZE;
  80         memcpy(fhandle->data, p, NFS2_FHSIZE);
  81         return p + XDR_QUADLEN(NFS2_FHSIZE);
  82 }
  83
  84 static inline __be32*
  85 xdr_encode_time(__be32 *p, struct timespec *timep)
  86 {
  87         *p++ = htonl(timep->tv_sec);
  88         /* Convert nanoseconds into microseconds */
  89         *p++ = htonl(timep->tv_nsec ? timep->tv_nsec / 1000 : 0);
  90         return p;
  91 }
  92
  93 static inline __be32*
  94 xdr_encode_current_server_time(__be32 *p, struct timespec *timep)
  95 {
  96         /*
  97          * Passing the invalid value useconds=1000000 is a
  98          * Sun convention for "set to current server time".
  99          * It's needed to make permissions checks for the
 100          * "touch" program across v2 mounts to Solaris and
 101          * Irix boxes work correctly. See description of
 102          * sattr in section 6.1 of "NFS Illustrated" by
 103          * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5
 104          */
 105         *p++ = htonl(timep->tv_sec);
 106         *p++ = htonl(1000000);
 107         return p;
 108 }
 109
 110 static inline __be32*
 111 xdr_decode_time(__be32 *p, struct timespec *timep)
 112 {
 113         timep->tv_sec = ntohl(*p++);
 114         /* Convert microseconds into nanoseconds */
 115         timep->tv_nsec = ntohl(*p++) * 1000;
 116         return p;
 117 }
 118
 119 static __be32 *
 120 xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr)
 121 {
 122         u32 rdev;
 123         fattr->type = (enum nfs_ftype) ntohl(*p++);
 124         fattr->mode = ntohl(*p++);
 125         fattr->nlink = ntohl(*p++);
 126         fattr->uid = ntohl(*p++);
 127         fattr->gid = ntohl(*p++);
 128         fattr->size = ntohl(*p++);
 129         fattr->du.nfs2.blocksize = ntohl(*p++);
 130         rdev = ntohl(*p++);
 131         fattr->du.nfs2.blocks = ntohl(*p++);
 132         fattr->fsid.major = ntohl(*p++);
 133         fattr->fsid.minor = 0;
 134         fattr->fileid = ntohl(*p++);
 135         p = xdr_decode_time(p, &fattr->atime);
 136         p = xdr_decode_time(p, &fattr->mtime);
 137         p = xdr_decode_time(p, &fattr->ctime);
 138         fattr->valid |= NFS_ATTR_FATTR;
 139         fattr->rdev = new_decode_dev(rdev);
 140         if (fattr->type == NFCHR && rdev == NFS2_FIFO_DEV) {
 141                 fattr->type = NFFIFO;
 142                 fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO;
 143                 fattr->rdev = 0;
 144         }
 145         return p;
 146 }
 147
 148 static inline __be32 *
 149 xdr_encode_sattr(__be32 *p, struct iattr *attr)
 150 {
 151         const __be32 not_set = __constant_htonl(0xFFFFFFFF);
 152
 153         *p++ = (attr->ia_valid & ATTR_MODE) ? htonl(attr->ia_mode) : not_set;
 154         *p++ = (attr->ia_valid & ATTR_UID) ? htonl(attr->ia_uid) : not_set;
 155         *p++ = (attr->ia_valid & ATTR_GID) ? htonl(attr->ia_gid) : not_set;
 156         *p++ = (attr->ia_valid & ATTR_SIZE) ? htonl(attr->ia_size) : not_set;
 157
 158         if (attr->ia_valid & ATTR_ATIME_SET) {
 159                 p = xdr_encode_time(p, &attr->ia_atime);
 160         } else if (attr->ia_valid & ATTR_ATIME) {
 161                 p = xdr_encode_current_server_time(p, &attr->ia_atime);
 162         } else {
 163                 *p++ = not_set;
 164                 *p++ = not_set;
 165         }
 166
 167         if (attr->ia_valid & ATTR_MTIME_SET) {
 168                 p = xdr_encode_time(p, &attr->ia_mtime);
 169         } else if (attr->ia_valid & ATTR_MTIME) {
 170                 p = xdr_encode_current_server_time(p, &attr->ia_mtime);
 171         } else {
 172                 *p++ = not_set;
 173                 *p++ = not_set;
 174         }
 175         return p;
 176 }
 177
 178 /*
 179  * NFS encode functions
 180  */
 181 /*
 182  * Encode file handle argument
 183  * GETATTR, READLINK, STATFS
 184  */
 185 static int
 186 nfs_xdr_fhandle(struct rpc_rqst *req, __be32 *p, struct nfs_fh *fh)
 187 {
 188         p = xdr_encode_fhandle(p, fh);
 189         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 190         return 0;
 191 }
 192
 193 /*
 194  * Encode SETATTR arguments
 195  */
 196 static int
 197 nfs_xdr_sattrargs(struct rpc_rqst *req, __be32 *p, struct nfs_sattrargs *args)
 198 {
 199         p = xdr_encode_fhandle(p, args->fh);
 200         p = xdr_encode_sattr(p, args->sattr);
 201         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 202         return 0;
 203 }
 204
 205 /*
 206  * Encode directory ops argument
 207  * LOOKUP, REMOVE, RMDIR
 208  */
 209 static int
 210 nfs_xdr_diropargs(struct rpc_rqst *req, __be32 *p, struct nfs_diropargs *args)
 211 {
 212         p = xdr_encode_fhandle(p, args->fh);
 213         p = xdr_encode_array(p, args->name, args->len);
 214         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 215         return 0;
 216 }
 217
 218 /*
 219  * Arguments to a READ call. Since we read data directly into the page
 220  * cache, we also set up the reply iovec here so that iov[1] points
 221  * exactly to the page we want to fetch.
 222  */
 223 static int
 224 nfs_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
 225 {
 226         struct rpc_auth *auth = req->rq_task->tk_auth;
 227         unsigned int replen;
 228         u32 offset = (u32)args->offset;
 229         u32 count = args->count;
 230
 231         p = xdr_encode_fhandle(p, args->fh);
 232         *p++ = htonl(offset);
 233         *p++ = htonl(count);
 234         *p++ = htonl(count);
 235         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 236
 237         /* Inline the page array */
 238         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readres_sz) << 2;
 239         xdr_inline_pages(&req->rq_rcv_buf, replen,
 240                          args->pages, args->pgbase, count);
 241         return 0;
 242 }
 243
 244 /*
 245  * Decode READ reply
 246  */
 247 static int
 248 nfs_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res)
 249 {
 250         struct kvec *iov = req->rq_rcv_buf.head;
 251         int     status, count, recvd, hdrlen;
 252
 253         if ((status = ntohl(*p++)))
 254                 return -nfs_stat_to_errno(status);
 255         p = xdr_decode_fattr(p, res->fattr);
 256
 257         count = ntohl(*p++);
 258         res->eof = 0;
 259         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 260         if (iov->iov_len < hdrlen) {
 261                 printk(KERN_WARNING "NFS: READ reply header overflowed:"
 262                                 "length %d > %Zu\n", hdrlen, iov->iov_len);
 263                 return -errno_NFSERR_IO;
 264         } else if (iov->iov_len != hdrlen) {
 265                 dprintk("NFS: READ header is short. iovec will be shifted.\n");
 266                 xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen);
 267         }
 268
 269         recvd = req->rq_rcv_buf.len - hdrlen;
 270         if (count > recvd) {
 271                 printk(KERN_WARNING "NFS: server cheating in read reply: "
 272                         "count %d > recvd %d\n", count, recvd);
 273                 count = recvd;
 274         }
 275
 276         dprintk("RPC:      readres OK count %d\n", count);
 277         if (count < res->count)
 278                 res->count = count;
 279
 280         return count;
 281 }
 282
 283
 284 /*
 285  * Write arguments. Splice the buffer to be written into the iovec.
 286  */
 287 static int
 288 nfs_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
 289 {
 290         struct xdr_buf *sndbuf = &req->rq_snd_buf;
 291         u32 offset = (u32)args->offset;
 292         u32 count = args->count;
 293
 294         p = xdr_encode_fhandle(p, args->fh);
 295         *p++ = htonl(offset);
 296         *p++ = htonl(offset);
 297         *p++ = htonl(count);
 298         *p++ = htonl(count);
 299         sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
 300
 301         /* Copy the page array */
 302         xdr_encode_pages(sndbuf, args->pages, args->pgbase, count);
 303         return 0;
 304 }
 305
 306 /*
 307  * Encode create arguments
 308  * CREATE, MKDIR
 309  */
 310 static int
 311 nfs_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs_createargs *args)
 312 {
 313         p = xdr_encode_fhandle(p, args->fh);
 314         p = xdr_encode_array(p, args->name, args->len);
 315         p = xdr_encode_sattr(p, args->sattr);
 316         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 317         return 0;
 318 }
 319
 320 /*
 321  * Encode RENAME arguments
 322  */
 323 static int
 324 nfs_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs_renameargs *args)
 325 {
 326         p = xdr_encode_fhandle(p, args->fromfh);
 327         p = xdr_encode_array(p, args->fromname, args->fromlen);
 328         p = xdr_encode_fhandle(p, args->tofh);
 329         p = xdr_encode_array(p, args->toname, args->tolen);
 330         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 331         return 0;
 332 }
 333
 334 /*
 335  * Encode LINK arguments
 336  */
 337 static int
 338 nfs_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs_linkargs *args)
 339 {
 340         p = xdr_encode_fhandle(p, args->fromfh);
 341         p = xdr_encode_fhandle(p, args->tofh);
 342         p = xdr_encode_array(p, args->toname, args->tolen);
 343         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 344         return 0;
 345 }
 346
 347 /*
 348  * Encode SYMLINK arguments
 349  */
 350 static int
 351 nfs_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_symlinkargs *args)
 352 {
 353         struct xdr_buf *sndbuf = &req->rq_snd_buf;
 354         size_t pad;
 355
 356         p = xdr_encode_fhandle(p, args->fromfh);
 357         p = xdr_encode_array(p, args->fromname, args->fromlen);
 358         *p++ = htonl(args->pathlen);
 359         sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
 360
 361         xdr_encode_pages(sndbuf, args->pages, 0, args->pathlen);
 362
 363         /*
 364          * xdr_encode_pages may have added a few bytes to ensure the
 365          * pathname ends on a 4-byte boundary.  Start encoding the
 366          * attributes after the pad bytes.
 367          */
 368         pad = sndbuf->tail->iov_len;
 369         if (pad > 0)
 370                 p++;
 371         p = xdr_encode_sattr(p, args->sattr);
 372         sndbuf->len += xdr_adjust_iovec(sndbuf->tail, p) - pad;
 373         return 0;
 374 }
 375
 376 /*
 377  * Encode arguments to readdir call
 378  */
 379 static int
 380 nfs_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs_readdirargs *args)
 381 {
 382         struct rpc_task *task = req->rq_task;
 383         struct rpc_auth *auth = task->tk_auth;
 384         unsigned int replen;
 385         u32 count = args->count;
 386
 387         p = xdr_encode_fhandle(p, args->fh);
 388         *p++ = htonl(args->cookie);
 389         *p++ = htonl(count); /* see above */
 390         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 391
 392         /* Inline the page array */
 393         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readdirres_sz) << 2;
 394         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count);
 395         return 0;
 396 }
 397
 398 /*
 399  * Decode the result of a readdir call.
 400  * We're not really decoding anymore, we just leave the buffer untouched
 401  * and only check that it is syntactically correct.
 402  * The real decoding happens in nfs_decode_entry below, called directly
 403  * from nfs_readdir for each entry.
 404  */
 405 static int
 406 nfs_xdr_readdirres(struct rpc_rqst *req, __be32 *p, void *dummy)
 407 {
 408         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 409         struct kvec *iov = rcvbuf->head;
 410         struct page **page;
 411         int hdrlen, recvd;
 412         int status, nr;
 413         unsigned int len, pglen;
 414         __be32 *end, *entry, *kaddr;
 415
 416         if ((status = ntohl(*p++)))
 417                 return -nfs_stat_to_errno(status);
 418
 419         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 420         if (iov->iov_len < hdrlen) {
 421                 printk(KERN_WARNING "NFS: READDIR reply header overflowed:"
 422                                 "length %d > %Zu\n", hdrlen, iov->iov_len);
 423                 return -errno_NFSERR_IO;
 424         } else if (iov->iov_len != hdrlen) {
 425                 dprintk("NFS: READDIR header is short. iovec will be shifted.\n");
 426                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 427         }
 428
 429         pglen = rcvbuf->page_len;
 430         recvd = rcvbuf->len - hdrlen;
 431         if (pglen > recvd)
 432                 pglen = recvd;
 433         page = rcvbuf->pages;
 434         kaddr = p = kmap_atomic(*page, KM_USER0);
 435         end = (__be32 *)((char *)p + pglen);
 436         entry = p;
 437         for (nr = 0; *p++; nr++) {
 438                 if (p + 2 > end)
 439                         goto short_pkt;
 440                 p++; /* fileid */
 441                 len = ntohl(*p++);
 442                 p += XDR_QUADLEN(len) + 1;      /* name plus cookie */
 443                 if (len > NFS2_MAXNAMLEN) {
 444                         printk(KERN_WARNING "NFS: giant filename in readdir (len 0x%x)!\n",
 445                                                 len);
 446                         goto err_unmap;
 447                 }
 448                 if (p + 2 > end)
 449                         goto short_pkt;
 450                 entry = p;
 451         }
 452         if (!nr && (entry[0] != 0 || entry[1] == 0))
 453                 goto short_pkt;
 454  out:
 455         kunmap_atomic(kaddr, KM_USER0);
 456         return nr;
 457  short_pkt:
 458         entry[0] = entry[1] = 0;
 459         /* truncate listing ? */
 460         if (!nr) {
 461                 printk(KERN_NOTICE "NFS: readdir reply truncated!\n");
 462                 entry[1] = 1;
 463         }
 464         goto out;
 465 err_unmap:
 466         nr = -errno_NFSERR_IO;
 467         goto out;
 468 }
 469
 470 __be32 *
 471 nfs_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus)
 472 {
 473         if (!*p++) {
 474                 if (!*p)
 475                         return ERR_PTR(-EAGAIN);
 476                 entry->eof = 1;
 477                 return ERR_PTR(-EBADCOOKIE);
 478         }
 479
 480         entry->ino        = ntohl(*p++);
 481         entry->len        = ntohl(*p++);
 482         entry->name       = (const char *) p;
 483         p                += XDR_QUADLEN(entry->len);
 484         entry->prev_cookie        = entry->cookie;
 485         entry->cookie     = ntohl(*p++);
 486         entry->eof        = !p[0] && p[1];
 487
 488         return p;
 489 }
 490
 491 /*
 492  * NFS XDR decode functions
 493  */
 494 /*
 495  * Decode simple status reply
 496  */
 497 static int
 498 nfs_xdr_stat(struct rpc_rqst *req, __be32 *p, void *dummy)
 499 {
 500         int     status;
 501
 502         if ((status = ntohl(*p++)) != 0)
 503                 status = -nfs_stat_to_errno(status);
 504         return status;
 505 }
 506
 507 /*
 508  * Decode attrstat reply
 509  * GETATTR, SETATTR, WRITE
 510  */
 511 static int
 512 nfs_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
 513 {
 514         int     status;
 515
 516         if ((status = ntohl(*p++)))
 517                 return -nfs_stat_to_errno(status);
 518         xdr_decode_fattr(p, fattr);
 519         return 0;
 520 }
 521
 522 /*
 523  * Decode diropres reply
 524  * LOOKUP, CREATE, MKDIR
 525  */
 526 static int
 527 nfs_xdr_diropres(struct rpc_rqst *req, __be32 *p, struct nfs_diropok *res)
 528 {
 529         int     status;
 530
 531         if ((status = ntohl(*p++)))
 532                 return -nfs_stat_to_errno(status);
 533         p = xdr_decode_fhandle(p, res->fh);
 534         xdr_decode_fattr(p, res->fattr);
 535         return 0;
 536 }
 537
 538 /*
 539  * Encode READLINK args
 540  */
 541 static int
 542 nfs_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_readlinkargs *args)
 543 {
 544         struct rpc_auth *auth = req->rq_task->tk_auth;
 545         unsigned int replen;
 546
 547         p = xdr_encode_fhandle(p, args->fh);
 548         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 549
 550         /* Inline the page array */
 551         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2;
 552         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen);
 553         return 0;
 554 }
 555
 556 /*
 557  * Decode READLINK reply
 558  */
 559 static int
 560 nfs_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, void *dummy)
 561 {
 562         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 563         struct kvec *iov = rcvbuf->head;
 564         int hdrlen, len, recvd;
 565         char    *kaddr;
 566         int     status;
 567
 568         if ((status = ntohl(*p++)))
 569                 return -nfs_stat_to_errno(status);
 570         /* Convert length of symlink */
 571         len = ntohl(*p++);
 572         if (len >= rcvbuf->page_len || len <= 0) {
 573                 dprintk(KERN_WARNING "nfs: server returned giant symlink!\n");
 574                 return -ENAMETOOLONG;
 575         }
 576         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 577         if (iov->iov_len < hdrlen) {
 578                 printk(KERN_WARNING "NFS: READLINK reply header overflowed:"
 579                                 "length %d > %Zu\n", hdrlen, iov->iov_len);
 580                 return -errno_NFSERR_IO;
 581         } else if (iov->iov_len != hdrlen) {
 582                 dprintk("NFS: READLINK header is short. iovec will be shifted.\n");
 583                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 584         }
 585         recvd = req->rq_rcv_buf.len - hdrlen;
 586         if (recvd < len) {
 587                 printk(KERN_WARNING "NFS: server cheating in readlink reply: "
 588                                 "count %u > recvd %u\n", len, recvd);
 589                 return -EIO;
 590         }
 591
 592         /* NULL terminate the string we got */
 593         kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
 594         kaddr[len+rcvbuf->page_base] = '\0';
 595         kunmap_atomic(kaddr, KM_USER0);
 596         return 0;
 597 }
 598
 599 /*
 600  * Decode WRITE reply
 601  */
 602 static int
 603 nfs_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
 604 {
 605         res->verf->committed = NFS_FILE_SYNC;
 606         return nfs_xdr_attrstat(req, p, res->fattr);
 607 }
 608
 609 /*
 610  * Decode STATFS reply
 611  */
 612 static int
 613 nfs_xdr_statfsres(struct rpc_rqst *req, __be32 *p, struct nfs2_fsstat *res)
 614 {
 615         int     status;
 616
 617         if ((status = ntohl(*p++)))
 618                 return -nfs_stat_to_errno(status);
 619
 620         res->tsize  = ntohl(*p++);
 621         res->bsize  = ntohl(*p++);
 622         res->blocks = ntohl(*p++);
 623         res->bfree  = ntohl(*p++);
 624         res->bavail = ntohl(*p++);
 625         return 0;
 626 }
 627
 628 /*
 629  * We need to translate between nfs status return values and
 630  * the local errno values which may not be the same.
 631  */
 632 static struct {
 633         int stat;
 634         int errno;
 635 } nfs_errtbl[] = {
 636         { NFS_OK,               0               },
 637         { NFSERR_PERM,          EPERM           },
 638         { NFSERR_NOENT,         ENOENT          },
 639         { NFSERR_IO,            errno_NFSERR_IO },
 640         { NFSERR_NXIO,          ENXIO           },
 641 /*      { NFSERR_EAGAIN,        EAGAIN          }, */
 642         { NFSERR_ACCES,         EACCES          },
 643         { NFSERR_EXIST,         EEXIST          },
 644         { NFSERR_XDEV,          EXDEV           },
 645         { NFSERR_NODEV,         ENODEV          },
 646         { NFSERR_NOTDIR,        ENOTDIR         },
 647         { NFSERR_ISDIR,         EISDIR          },
 648         { NFSERR_INVAL,         EINVAL          },
 649         { NFSERR_FBIG,          EFBIG           },
 650         { NFSERR_NOSPC,         ENOSPC          },
 651         { NFSERR_ROFS,          EROFS           },
 652         { NFSERR_MLINK,         EMLINK          },
 653         { NFSERR_NAMETOOLONG,   ENAMETOOLONG    },
 654         { NFSERR_NOTEMPTY,      ENOTEMPTY       },
 655         { NFSERR_DQUOT,         EDQUOT          },
 656         { NFSERR_STALE,         ESTALE          },
 657         { NFSERR_REMOTE,        EREMOTE         },
 658 #ifdef EWFLUSH
 659         { NFSERR_WFLUSH,        EWFLUSH         },
 660 #endif
 661         { NFSERR_BADHANDLE,     EBADHANDLE      },
 662         { NFSERR_NOT_SYNC,      ENOTSYNC        },
 663         { NFSERR_BAD_COOKIE,    EBADCOOKIE      },
 664         { NFSERR_NOTSUPP,       ENOTSUPP        },
 665         { NFSERR_TOOSMALL,      ETOOSMALL       },
 666         { NFSERR_SERVERFAULT,   ESERVERFAULT    },
 667         { NFSERR_BADTYPE,       EBADTYPE        },
 668         { NFSERR_JUKEBOX,       EJUKEBOX        },
 669         { -1,                   EIO             }
 670 };
 671
 672 /*
 673  * Convert an NFS error code to a local one.
 674  * This one is used jointly by NFSv2 and NFSv3.
 675  */
 676 int
 677 nfs_stat_to_errno(int stat)
 678 {
 679         int i;
 680
 681         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
 682                 if (nfs_errtbl[i].stat == stat)
 683                         return nfs_errtbl[i].errno;
 684         }
 685         printk(KERN_ERR "nfs_stat_to_errno: bad nfs status return value: %d\n", stat);
 686         return nfs_errtbl[i].errno;
 687 }
 688
 689 #define PROC(proc, argtype, restype, timer)                             \
 690 [NFSPROC_##proc] = {                                                    \
 691         .p_proc     =  NFSPROC_##proc,                                  \
 692         .p_encode   =  (kxdrproc_t) nfs_xdr_##argtype,                  \
 693         .p_decode   =  (kxdrproc_t) nfs_xdr_##restype,                  \
 694         .p_arglen   =  NFS_##argtype##_sz,                              \
 695         .p_replen   =  NFS_##restype##_sz,                              \
 696         .p_timer    =  timer,                                           \
 697         .p_statidx  =  NFSPROC_##proc,                                  \
 698         .p_name     =  #proc,                                           \
 699         }
 700 struct rpc_procinfo     nfs_procedures[] = {
 701     PROC(GETATTR,       fhandle,        attrstat, 1),
 702     PROC(SETATTR,       sattrargs,      attrstat, 0),
 703     PROC(LOOKUP,        diropargs,      diropres, 2),
 704     PROC(READLINK,      readlinkargs,   readlinkres, 3),
 705     PROC(READ,          readargs,       readres, 3),
 706     PROC(WRITE,         writeargs,      writeres, 4),
 707     PROC(CREATE,        createargs,     diropres, 0),
 708     PROC(REMOVE,        diropargs,      stat, 0),
 709     PROC(RENAME,        renameargs,     stat, 0),
 710     PROC(LINK,          linkargs,       stat, 0),
 711     PROC(SYMLINK,       symlinkargs,    stat, 0),
 712     PROC(MKDIR,         createargs,     diropres, 0),
 713     PROC(RMDIR,         diropargs,      stat, 0),
 714     PROC(READDIR,       readdirargs,    readdirres, 3),
 715     PROC(STATFS,        fhandle,        statfsres, 0),
 716 };
 717
 718 struct rpc_version              nfs_version2 = {
 719         .number                 = 2,
 720         .nrprocs                = ARRAY_SIZE(nfs_procedures),
 721         .procs                  = nfs_procedures
 722 };