git.oblomov.eu Git - linux-2.6/blob - 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_removeargs_sz       (NFS_fhandle_sz+NFS_filename_sz)
  47 #define NFS_sattrargs_sz        (NFS_fhandle_sz+NFS_sattr_sz)
  48 #define NFS_readlinkargs_sz     (NFS_fhandle_sz)
  49 #define NFS_readargs_sz         (NFS_fhandle_sz+3)
  50 #define NFS_writeargs_sz        (NFS_fhandle_sz+4)
  51 #define NFS_createargs_sz       (NFS_diropargs_sz+NFS_sattr_sz)
  52 #define NFS_renameargs_sz       (NFS_diropargs_sz+NFS_diropargs_sz)
  53 #define NFS_linkargs_sz         (NFS_fhandle_sz+NFS_diropargs_sz)
  54 #define NFS_symlinkargs_sz      (NFS_diropargs_sz+1+NFS_sattr_sz)
  55 #define NFS_readdirargs_sz      (NFS_fhandle_sz+2)
  56
  57 #define NFS_attrstat_sz         (1+NFS_fattr_sz)
  58 #define NFS_diropres_sz         (1+NFS_fhandle_sz+NFS_fattr_sz)
  59 #define NFS_readlinkres_sz      (2)
  60 #define NFS_readres_sz          (1+NFS_fattr_sz+1)
  61 #define NFS_writeres_sz         (NFS_attrstat_sz)
  62 #define NFS_stat_sz             (1)
  63 #define NFS_readdirres_sz       (1)
  64 #define NFS_statfsres_sz        (1+NFS_info_sz)
  65
  66 /*
  67  * Common NFS XDR functions as inlines
  68  */
  69 static inline __be32 *
  70 xdr_encode_fhandle(__be32 *p, const struct nfs_fh *fhandle)
  71 {
  72         memcpy(p, fhandle->data, NFS2_FHSIZE);
  73         return p + XDR_QUADLEN(NFS2_FHSIZE);
  74 }
  75
  76 static inline __be32 *
  77 xdr_decode_fhandle(__be32 *p, struct nfs_fh *fhandle)
  78 {
  79         /* NFSv2 handles have a fixed length */
  80         fhandle->size = NFS2_FHSIZE;
  81         memcpy(fhandle->data, p, NFS2_FHSIZE);
  82         return p + XDR_QUADLEN(NFS2_FHSIZE);
  83 }
  84
  85 static inline __be32*
  86 xdr_encode_time(__be32 *p, struct timespec *timep)
  87 {
  88         *p++ = htonl(timep->tv_sec);
  89         /* Convert nanoseconds into microseconds */
  90         *p++ = htonl(timep->tv_nsec ? timep->tv_nsec / 1000 : 0);
  91         return p;
  92 }
  93
  94 static inline __be32*
  95 xdr_encode_current_server_time(__be32 *p, struct timespec *timep)
  96 {
  97         /*
  98          * Passing the invalid value useconds=1000000 is a
  99          * Sun convention for "set to current server time".
 100          * It's needed to make permissions checks for the
 101          * "touch" program across v2 mounts to Solaris and
 102          * Irix boxes work correctly. See description of
 103          * sattr in section 6.1 of "NFS Illustrated" by
 104          * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5
 105          */
 106         *p++ = htonl(timep->tv_sec);
 107         *p++ = htonl(1000000);
 108         return p;
 109 }
 110
 111 static inline __be32*
 112 xdr_decode_time(__be32 *p, struct timespec *timep)
 113 {
 114         timep->tv_sec = ntohl(*p++);
 115         /* Convert microseconds into nanoseconds */
 116         timep->tv_nsec = ntohl(*p++) * 1000;
 117         return p;
 118 }
 119
 120 static __be32 *
 121 xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr)
 122 {
 123         u32 rdev, type;
 124         type = ntohl(*p++);
 125         fattr->mode = ntohl(*p++);
 126         fattr->nlink = ntohl(*p++);
 127         fattr->uid = ntohl(*p++);
 128         fattr->gid = ntohl(*p++);
 129         fattr->size = ntohl(*p++);
 130         fattr->du.nfs2.blocksize = ntohl(*p++);
 131         rdev = ntohl(*p++);
 132         fattr->du.nfs2.blocks = ntohl(*p++);
 133         fattr->fsid.major = ntohl(*p++);
 134         fattr->fsid.minor = 0;
 135         fattr->fileid = ntohl(*p++);
 136         p = xdr_decode_time(p, &fattr->atime);
 137         p = xdr_decode_time(p, &fattr->mtime);
 138         p = xdr_decode_time(p, &fattr->ctime);
 139         fattr->valid |= NFS_ATTR_FATTR_V2;
 140         fattr->rdev = new_decode_dev(rdev);
 141         if (type == NFCHR && rdev == NFS2_FIFO_DEV) {
 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, 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  * Encode REMOVE argument
 220  */
 221 static int
 222 nfs_xdr_removeargs(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args)
 223 {
 224         p = xdr_encode_fhandle(p, args->fh);
 225         p = xdr_encode_array(p, args->name.name, args->name.len);
 226         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 227         return 0;
 228 }
 229
 230 /*
 231  * Arguments to a READ call. Since we read data directly into the page
 232  * cache, we also set up the reply iovec here so that iov[1] points
 233  * exactly to the page we want to fetch.
 234  */
 235 static int
 236 nfs_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
 237 {
 238         struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 239         unsigned int replen;
 240         u32 offset = (u32)args->offset;
 241         u32 count = args->count;
 242
 243         p = xdr_encode_fhandle(p, args->fh);
 244         *p++ = htonl(offset);
 245         *p++ = htonl(count);
 246         *p++ = htonl(count);
 247         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 248
 249         /* Inline the page array */
 250         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readres_sz) << 2;
 251         xdr_inline_pages(&req->rq_rcv_buf, replen,
 252                          args->pages, args->pgbase, count);
 253         req->rq_rcv_buf.flags |= XDRBUF_READ;
 254         return 0;
 255 }
 256
 257 /*
 258  * Decode READ reply
 259  */
 260 static int
 261 nfs_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res)
 262 {
 263         struct kvec *iov = req->rq_rcv_buf.head;
 264         size_t hdrlen;
 265         u32 count, recvd;
 266         int status;
 267
 268         if ((status = ntohl(*p++)))
 269                 return nfs_stat_to_errno(status);
 270         p = xdr_decode_fattr(p, res->fattr);
 271
 272         count = ntohl(*p++);
 273         res->eof = 0;
 274         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 275         if (iov->iov_len < hdrlen) {
 276                 dprintk("NFS: READ reply header overflowed:"
 277                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
 278                 return -errno_NFSERR_IO;
 279         } else if (iov->iov_len != hdrlen) {
 280                 dprintk("NFS: READ header is short. iovec will be shifted.\n");
 281                 xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen);
 282         }
 283
 284         recvd = req->rq_rcv_buf.len - hdrlen;
 285         if (count > recvd) {
 286                 dprintk("NFS: server cheating in read reply: "
 287                         "count %u > recvd %u\n", count, recvd);
 288                 count = recvd;
 289         }
 290
 291         dprintk("RPC:      readres OK count %u\n", count);
 292         if (count < res->count)
 293                 res->count = count;
 294
 295         return count;
 296 }
 297
 298
 299 /*
 300  * Write arguments. Splice the buffer to be written into the iovec.
 301  */
 302 static int
 303 nfs_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
 304 {
 305         struct xdr_buf *sndbuf = &req->rq_snd_buf;
 306         u32 offset = (u32)args->offset;
 307         u32 count = args->count;
 308
 309         p = xdr_encode_fhandle(p, args->fh);
 310         *p++ = htonl(offset);
 311         *p++ = htonl(offset);
 312         *p++ = htonl(count);
 313         *p++ = htonl(count);
 314         sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
 315
 316         /* Copy the page array */
 317         xdr_encode_pages(sndbuf, args->pages, args->pgbase, count);
 318         sndbuf->flags |= XDRBUF_WRITE;
 319         return 0;
 320 }
 321
 322 /*
 323  * Encode create arguments
 324  * CREATE, MKDIR
 325  */
 326 static int
 327 nfs_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs_createargs *args)
 328 {
 329         p = xdr_encode_fhandle(p, args->fh);
 330         p = xdr_encode_array(p, args->name, args->len);
 331         p = xdr_encode_sattr(p, args->sattr);
 332         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 333         return 0;
 334 }
 335
 336 /*
 337  * Encode RENAME arguments
 338  */
 339 static int
 340 nfs_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs_renameargs *args)
 341 {
 342         p = xdr_encode_fhandle(p, args->fromfh);
 343         p = xdr_encode_array(p, args->fromname, args->fromlen);
 344         p = xdr_encode_fhandle(p, args->tofh);
 345         p = xdr_encode_array(p, args->toname, args->tolen);
 346         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 347         return 0;
 348 }
 349
 350 /*
 351  * Encode LINK arguments
 352  */
 353 static int
 354 nfs_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs_linkargs *args)
 355 {
 356         p = xdr_encode_fhandle(p, args->fromfh);
 357         p = xdr_encode_fhandle(p, args->tofh);
 358         p = xdr_encode_array(p, args->toname, args->tolen);
 359         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 360         return 0;
 361 }
 362
 363 /*
 364  * Encode SYMLINK arguments
 365  */
 366 static int
 367 nfs_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_symlinkargs *args)
 368 {
 369         struct xdr_buf *sndbuf = &req->rq_snd_buf;
 370         size_t pad;
 371
 372         p = xdr_encode_fhandle(p, args->fromfh);
 373         p = xdr_encode_array(p, args->fromname, args->fromlen);
 374         *p++ = htonl(args->pathlen);
 375         sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
 376
 377         xdr_encode_pages(sndbuf, args->pages, 0, args->pathlen);
 378
 379         /*
 380          * xdr_encode_pages may have added a few bytes to ensure the
 381          * pathname ends on a 4-byte boundary.  Start encoding the
 382          * attributes after the pad bytes.
 383          */
 384         pad = sndbuf->tail->iov_len;
 385         if (pad > 0)
 386                 p++;
 387         p = xdr_encode_sattr(p, args->sattr);
 388         sndbuf->len += xdr_adjust_iovec(sndbuf->tail, p) - pad;
 389         return 0;
 390 }
 391
 392 /*
 393  * Encode arguments to readdir call
 394  */
 395 static int
 396 nfs_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs_readdirargs *args)
 397 {
 398         struct rpc_task *task = req->rq_task;
 399         struct rpc_auth *auth = task->tk_msg.rpc_cred->cr_auth;
 400         unsigned int replen;
 401         u32 count = args->count;
 402
 403         p = xdr_encode_fhandle(p, args->fh);
 404         *p++ = htonl(args->cookie);
 405         *p++ = htonl(count); /* see above */
 406         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 407
 408         /* Inline the page array */
 409         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readdirres_sz) << 2;
 410         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count);
 411         return 0;
 412 }
 413
 414 /*
 415  * Decode the result of a readdir call.
 416  * We're not really decoding anymore, we just leave the buffer untouched
 417  * and only check that it is syntactically correct.
 418  * The real decoding happens in nfs_decode_entry below, called directly
 419  * from nfs_readdir for each entry.
 420  */
 421 static int
 422 nfs_xdr_readdirres(struct rpc_rqst *req, __be32 *p, void *dummy)
 423 {
 424         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 425         struct kvec *iov = rcvbuf->head;
 426         struct page **page;
 427         size_t hdrlen;
 428         unsigned int pglen, recvd;
 429         u32 len;
 430         int status, nr = 0;
 431         __be32 *end, *entry, *kaddr;
 432
 433         if ((status = ntohl(*p++)))
 434                 return nfs_stat_to_errno(status);
 435
 436         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 437         if (iov->iov_len < hdrlen) {
 438                 dprintk("NFS: READDIR reply header overflowed:"
 439                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
 440                 return -errno_NFSERR_IO;
 441         } else if (iov->iov_len != hdrlen) {
 442                 dprintk("NFS: READDIR header is short. iovec will be shifted.\n");
 443                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 444         }
 445
 446         pglen = rcvbuf->page_len;
 447         recvd = rcvbuf->len - hdrlen;
 448         if (pglen > recvd)
 449                 pglen = recvd;
 450         page = rcvbuf->pages;
 451         kaddr = p = kmap_atomic(*page, KM_USER0);
 452         end = (__be32 *)((char *)p + pglen);
 453         entry = p;
 454
 455         /* Make sure the packet actually has a value_follows and EOF entry */
 456         if ((entry + 1) > end)
 457                 goto short_pkt;
 458
 459         for (; *p++; nr++) {
 460                 if (p + 2 > end)
 461                         goto short_pkt;
 462                 p++; /* fileid */
 463                 len = ntohl(*p++);
 464                 p += XDR_QUADLEN(len) + 1;      /* name plus cookie */
 465                 if (len > NFS2_MAXNAMLEN) {
 466                         dprintk("NFS: giant filename in readdir (len 0x%x)!\n",
 467                                                 len);
 468                         goto err_unmap;
 469                 }
 470                 if (p + 2 > end)
 471                         goto short_pkt;
 472                 entry = p;
 473         }
 474
 475         /*
 476          * Apparently some server sends responses that are a valid size, but
 477          * contain no entries, and have value_follows==0 and EOF==0. For
 478          * those, just set the EOF marker.
 479          */
 480         if (!nr && entry[1] == 0) {
 481                 dprintk("NFS: readdir reply truncated!\n");
 482                 entry[1] = 1;
 483         }
 484  out:
 485         kunmap_atomic(kaddr, KM_USER0);
 486         return nr;
 487  short_pkt:
 488         /*
 489          * When we get a short packet there are 2 possibilities. We can
 490          * return an error, or fix up the response to look like a valid
 491          * response and return what we have so far. If there are no
 492          * entries and the packet was short, then return -EIO. If there
 493          * are valid entries in the response, return them and pretend that
 494          * the call was successful, but incomplete. The caller can retry the
 495          * readdir starting at the last cookie.
 496          */
 497         entry[0] = entry[1] = 0;
 498         if (!nr)
 499                 nr = -errno_NFSERR_IO;
 500         goto out;
 501 err_unmap:
 502         nr = -errno_NFSERR_IO;
 503         goto out;
 504 }
 505
 506 __be32 *
 507 nfs_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus)
 508 {
 509         if (!*p++) {
 510                 if (!*p)
 511                         return ERR_PTR(-EAGAIN);
 512                 entry->eof = 1;
 513                 return ERR_PTR(-EBADCOOKIE);
 514         }
 515
 516         entry->ino        = ntohl(*p++);
 517         entry->len        = ntohl(*p++);
 518         entry->name       = (const char *) p;
 519         p                += XDR_QUADLEN(entry->len);
 520         entry->prev_cookie        = entry->cookie;
 521         entry->cookie     = ntohl(*p++);
 522         entry->eof        = !p[0] && p[1];
 523
 524         return p;
 525 }
 526
 527 /*
 528  * NFS XDR decode functions
 529  */
 530 /*
 531  * Decode simple status reply
 532  */
 533 static int
 534 nfs_xdr_stat(struct rpc_rqst *req, __be32 *p, void *dummy)
 535 {
 536         int     status;
 537
 538         if ((status = ntohl(*p++)) != 0)
 539                 status = nfs_stat_to_errno(status);
 540         return status;
 541 }
 542
 543 /*
 544  * Decode attrstat reply
 545  * GETATTR, SETATTR, WRITE
 546  */
 547 static int
 548 nfs_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
 549 {
 550         int     status;
 551
 552         if ((status = ntohl(*p++)))
 553                 return nfs_stat_to_errno(status);
 554         xdr_decode_fattr(p, fattr);
 555         return 0;
 556 }
 557
 558 /*
 559  * Decode diropres reply
 560  * LOOKUP, CREATE, MKDIR
 561  */
 562 static int
 563 nfs_xdr_diropres(struct rpc_rqst *req, __be32 *p, struct nfs_diropok *res)
 564 {
 565         int     status;
 566
 567         if ((status = ntohl(*p++)))
 568                 return nfs_stat_to_errno(status);
 569         p = xdr_decode_fhandle(p, res->fh);
 570         xdr_decode_fattr(p, res->fattr);
 571         return 0;
 572 }
 573
 574 /*
 575  * Encode READLINK args
 576  */
 577 static int
 578 nfs_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_readlinkargs *args)
 579 {
 580         struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 581         unsigned int replen;
 582
 583         p = xdr_encode_fhandle(p, args->fh);
 584         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 585
 586         /* Inline the page array */
 587         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2;
 588         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen);
 589         return 0;
 590 }
 591
 592 /*
 593  * Decode READLINK reply
 594  */
 595 static int
 596 nfs_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, void *dummy)
 597 {
 598         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 599         struct kvec *iov = rcvbuf->head;
 600         size_t hdrlen;
 601         u32 len, recvd;
 602         char    *kaddr;
 603         int     status;
 604
 605         if ((status = ntohl(*p++)))
 606                 return nfs_stat_to_errno(status);
 607         /* Convert length of symlink */
 608         len = ntohl(*p++);
 609         if (len >= rcvbuf->page_len) {
 610                 dprintk("nfs: server returned giant symlink!\n");
 611                 return -ENAMETOOLONG;
 612         }
 613         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 614         if (iov->iov_len < hdrlen) {
 615                 dprintk("NFS: READLINK reply header overflowed:"
 616                                 "length %Zu > %Zu\n", hdrlen, iov->iov_len);
 617                 return -errno_NFSERR_IO;
 618         } else if (iov->iov_len != hdrlen) {
 619                 dprintk("NFS: READLINK header is short. iovec will be shifted.\n");
 620                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 621         }
 622         recvd = req->rq_rcv_buf.len - hdrlen;
 623         if (recvd < len) {
 624                 dprintk("NFS: server cheating in readlink reply: "
 625                                 "count %u > recvd %u\n", len, recvd);
 626                 return -EIO;
 627         }
 628
 629         /* NULL terminate the string we got */
 630         kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
 631         kaddr[len+rcvbuf->page_base] = '\0';
 632         kunmap_atomic(kaddr, KM_USER0);
 633         return 0;
 634 }
 635
 636 /*
 637  * Decode WRITE reply
 638  */
 639 static int
 640 nfs_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
 641 {
 642         res->verf->committed = NFS_FILE_SYNC;
 643         return nfs_xdr_attrstat(req, p, res->fattr);
 644 }
 645
 646 /*
 647  * Decode STATFS reply
 648  */
 649 static int
 650 nfs_xdr_statfsres(struct rpc_rqst *req, __be32 *p, struct nfs2_fsstat *res)
 651 {
 652         int     status;
 653
 654         if ((status = ntohl(*p++)))
 655                 return nfs_stat_to_errno(status);
 656
 657         res->tsize  = ntohl(*p++);
 658         res->bsize  = ntohl(*p++);
 659         res->blocks = ntohl(*p++);
 660         res->bfree  = ntohl(*p++);
 661         res->bavail = ntohl(*p++);
 662         return 0;
 663 }
 664
 665 /*
 666  * We need to translate between nfs status return values and
 667  * the local errno values which may not be the same.
 668  */
 669 static struct {
 670         int stat;
 671         int errno;
 672 } nfs_errtbl[] = {
 673         { NFS_OK,               0               },
 674         { NFSERR_PERM,          -EPERM          },
 675         { NFSERR_NOENT,         -ENOENT         },
 676         { NFSERR_IO,            -errno_NFSERR_IO},
 677         { NFSERR_NXIO,          -ENXIO          },
 678 /*      { NFSERR_EAGAIN,        -EAGAIN         }, */
 679         { NFSERR_ACCES,         -EACCES         },
 680         { NFSERR_EXIST,         -EEXIST         },
 681         { NFSERR_XDEV,          -EXDEV          },
 682         { NFSERR_NODEV,         -ENODEV         },
 683         { NFSERR_NOTDIR,        -ENOTDIR        },
 684         { NFSERR_ISDIR,         -EISDIR         },
 685         { NFSERR_INVAL,         -EINVAL         },
 686         { NFSERR_FBIG,          -EFBIG          },
 687         { NFSERR_NOSPC,         -ENOSPC         },
 688         { NFSERR_ROFS,          -EROFS          },
 689         { NFSERR_MLINK,         -EMLINK         },
 690         { NFSERR_NAMETOOLONG,   -ENAMETOOLONG   },
 691         { NFSERR_NOTEMPTY,      -ENOTEMPTY      },
 692         { NFSERR_DQUOT,         -EDQUOT         },
 693         { NFSERR_STALE,         -ESTALE         },
 694         { NFSERR_REMOTE,        -EREMOTE        },
 695 #ifdef EWFLUSH
 696         { NFSERR_WFLUSH,        -EWFLUSH        },
 697 #endif
 698         { NFSERR_BADHANDLE,     -EBADHANDLE     },
 699         { NFSERR_NOT_SYNC,      -ENOTSYNC       },
 700         { NFSERR_BAD_COOKIE,    -EBADCOOKIE     },
 701         { NFSERR_NOTSUPP,       -ENOTSUPP       },
 702         { NFSERR_TOOSMALL,      -ETOOSMALL      },
 703         { NFSERR_SERVERFAULT,   -ESERVERFAULT   },
 704         { NFSERR_BADTYPE,       -EBADTYPE       },
 705         { NFSERR_JUKEBOX,       -EJUKEBOX       },
 706         { -1,                   -EIO            }
 707 };
 708
 709 /*
 710  * Convert an NFS error code to a local one.
 711  * This one is used jointly by NFSv2 and NFSv3.
 712  */
 713 int
 714 nfs_stat_to_errno(int stat)
 715 {
 716         int i;
 717
 718         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
 719                 if (nfs_errtbl[i].stat == stat)
 720                         return nfs_errtbl[i].errno;
 721         }
 722         dprintk("nfs_stat_to_errno: bad nfs status return value: %d\n", stat);
 723         return nfs_errtbl[i].errno;
 724 }
 725
 726 #define PROC(proc, argtype, restype, timer)                             \
 727 [NFSPROC_##proc] = {                                                    \
 728         .p_proc     =  NFSPROC_##proc,                                  \
 729         .p_encode   =  (kxdrproc_t) nfs_xdr_##argtype,                  \
 730         .p_decode   =  (kxdrproc_t) nfs_xdr_##restype,                  \
 731         .p_arglen   =  NFS_##argtype##_sz,                              \
 732         .p_replen   =  NFS_##restype##_sz,                              \
 733         .p_timer    =  timer,                                           \
 734         .p_statidx  =  NFSPROC_##proc,                                  \
 735         .p_name     =  #proc,                                           \
 736         }
 737 struct rpc_procinfo     nfs_procedures[] = {
 738     PROC(GETATTR,       fhandle,        attrstat, 1),
 739     PROC(SETATTR,       sattrargs,      attrstat, 0),
 740     PROC(LOOKUP,        diropargs,      diropres, 2),
 741     PROC(READLINK,      readlinkargs,   readlinkres, 3),
 742     PROC(READ,          readargs,       readres, 3),
 743     PROC(WRITE,         writeargs,      writeres, 4),
 744     PROC(CREATE,        createargs,     diropres, 0),
 745     PROC(REMOVE,        removeargs,     stat, 0),
 746     PROC(RENAME,        renameargs,     stat, 0),
 747     PROC(LINK,          linkargs,       stat, 0),
 748     PROC(SYMLINK,       symlinkargs,    stat, 0),
 749     PROC(MKDIR,         createargs,     diropres, 0),
 750     PROC(RMDIR,         diropargs,      stat, 0),
 751     PROC(READDIR,       readdirargs,    readdirres, 3),
 752     PROC(STATFS,        fhandle,        statfsres, 0),
 753 };
 754
 755 struct rpc_version              nfs_version2 = {
 756         .number                 = 2,
 757         .nrprocs                = ARRAY_SIZE(nfs_procedures),
 758         .procs                  = nfs_procedures
 759 };