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;
 124         fattr->type = (enum nfs_ftype) 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;
 140         fattr->rdev = new_decode_dev(rdev);
 141         if (fattr->type == NFCHR && rdev == NFS2_FIFO_DEV) {
 142                 fattr->type = NFFIFO;
 143                 fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO;
 144                 fattr->rdev = 0;
 145         }
 146         return p;
 147 }
 148
 149 static inline __be32 *
 150 xdr_encode_sattr(__be32 *p, struct iattr *attr)
 151 {
 152         const __be32 not_set = __constant_htonl(0xFFFFFFFF);
 153
 154         *p++ = (attr->ia_valid & ATTR_MODE) ? htonl(attr->ia_mode) : not_set;
 155         *p++ = (attr->ia_valid & ATTR_UID) ? htonl(attr->ia_uid) : not_set;
 156         *p++ = (attr->ia_valid & ATTR_GID) ? htonl(attr->ia_gid) : not_set;
 157         *p++ = (attr->ia_valid & ATTR_SIZE) ? htonl(attr->ia_size) : not_set;
 158
 159         if (attr->ia_valid & ATTR_ATIME_SET) {
 160                 p = xdr_encode_time(p, &attr->ia_atime);
 161         } else if (attr->ia_valid & ATTR_ATIME) {
 162                 p = xdr_encode_current_server_time(p, &attr->ia_atime);
 163         } else {
 164                 *p++ = not_set;
 165                 *p++ = not_set;
 166         }
 167
 168         if (attr->ia_valid & ATTR_MTIME_SET) {
 169                 p = xdr_encode_time(p, &attr->ia_mtime);
 170         } else if (attr->ia_valid & ATTR_MTIME) {
 171                 p = xdr_encode_current_server_time(p, &attr->ia_mtime);
 172         } else {
 173                 *p++ = not_set;
 174                 *p++ = not_set;
 175         }
 176         return p;
 177 }
 178
 179 /*
 180  * NFS encode functions
 181  */
 182 /*
 183  * Encode file handle argument
 184  * GETATTR, READLINK, STATFS
 185  */
 186 static int
 187 nfs_xdr_fhandle(struct rpc_rqst *req, __be32 *p, struct nfs_fh *fh)
 188 {
 189         p = xdr_encode_fhandle(p, fh);
 190         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 191         return 0;
 192 }
 193
 194 /*
 195  * Encode SETATTR arguments
 196  */
 197 static int
 198 nfs_xdr_sattrargs(struct rpc_rqst *req, __be32 *p, struct nfs_sattrargs *args)
 199 {
 200         p = xdr_encode_fhandle(p, args->fh);
 201         p = xdr_encode_sattr(p, args->sattr);
 202         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 203         return 0;
 204 }
 205
 206 /*
 207  * Encode directory ops argument
 208  * LOOKUP, RMDIR
 209  */
 210 static int
 211 nfs_xdr_diropargs(struct rpc_rqst *req, __be32 *p, struct nfs_diropargs *args)
 212 {
 213         p = xdr_encode_fhandle(p, args->fh);
 214         p = xdr_encode_array(p, args->name, args->len);
 215         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 216         return 0;
 217 }
 218
 219 /*
 220  * Encode REMOVE argument
 221  */
 222 static int
 223 nfs_xdr_removeargs(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args)
 224 {
 225         p = xdr_encode_fhandle(p, args->fh);
 226         p = xdr_encode_array(p, args->name.name, args->name.len);
 227         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 228         return 0;
 229 }
 230
 231 /*
 232  * Arguments to a READ call. Since we read data directly into the page
 233  * cache, we also set up the reply iovec here so that iov[1] points
 234  * exactly to the page we want to fetch.
 235  */
 236 static int
 237 nfs_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
 238 {
 239         struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 240         unsigned int replen;
 241         u32 offset = (u32)args->offset;
 242         u32 count = args->count;
 243
 244         p = xdr_encode_fhandle(p, args->fh);
 245         *p++ = htonl(offset);
 246         *p++ = htonl(count);
 247         *p++ = htonl(count);
 248         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 249
 250         /* Inline the page array */
 251         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readres_sz) << 2;
 252         xdr_inline_pages(&req->rq_rcv_buf, replen,
 253                          args->pages, args->pgbase, count);
 254         req->rq_rcv_buf.flags |= XDRBUF_READ;
 255         return 0;
 256 }
 257
 258 /*
 259  * Decode READ reply
 260  */
 261 static int
 262 nfs_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res)
 263 {
 264         struct kvec *iov = req->rq_rcv_buf.head;
 265         int     status, count, recvd, hdrlen;
 266
 267         if ((status = ntohl(*p++)))
 268                 return -nfs_stat_to_errno(status);
 269         p = xdr_decode_fattr(p, res->fattr);
 270
 271         count = ntohl(*p++);
 272         res->eof = 0;
 273         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 274         if (iov->iov_len < hdrlen) {
 275                 dprintk("NFS: READ reply header overflowed:"
 276                                 "length %d > %Zu\n", hdrlen, iov->iov_len);
 277                 return -errno_NFSERR_IO;
 278         } else if (iov->iov_len != hdrlen) {
 279                 dprintk("NFS: READ header is short. iovec will be shifted.\n");
 280                 xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen);
 281         }
 282
 283         recvd = req->rq_rcv_buf.len - hdrlen;
 284         if (count > recvd) {
 285                 dprintk("NFS: server cheating in read reply: "
 286                         "count %d > recvd %d\n", count, recvd);
 287                 count = recvd;
 288         }
 289
 290         dprintk("RPC:      readres OK count %d\n", count);
 291         if (count < res->count)
 292                 res->count = count;
 293
 294         return count;
 295 }
 296
 297
 298 /*
 299  * Write arguments. Splice the buffer to be written into the iovec.
 300  */
 301 static int
 302 nfs_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
 303 {
 304         struct xdr_buf *sndbuf = &req->rq_snd_buf;
 305         u32 offset = (u32)args->offset;
 306         u32 count = args->count;
 307
 308         p = xdr_encode_fhandle(p, args->fh);
 309         *p++ = htonl(offset);
 310         *p++ = htonl(offset);
 311         *p++ = htonl(count);
 312         *p++ = htonl(count);
 313         sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
 314
 315         /* Copy the page array */
 316         xdr_encode_pages(sndbuf, args->pages, args->pgbase, count);
 317         sndbuf->flags |= XDRBUF_WRITE;
 318         return 0;
 319 }
 320
 321 /*
 322  * Encode create arguments
 323  * CREATE, MKDIR
 324  */
 325 static int
 326 nfs_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs_createargs *args)
 327 {
 328         p = xdr_encode_fhandle(p, args->fh);
 329         p = xdr_encode_array(p, args->name, args->len);
 330         p = xdr_encode_sattr(p, args->sattr);
 331         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 332         return 0;
 333 }
 334
 335 /*
 336  * Encode RENAME arguments
 337  */
 338 static int
 339 nfs_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs_renameargs *args)
 340 {
 341         p = xdr_encode_fhandle(p, args->fromfh);
 342         p = xdr_encode_array(p, args->fromname, args->fromlen);
 343         p = xdr_encode_fhandle(p, args->tofh);
 344         p = xdr_encode_array(p, args->toname, args->tolen);
 345         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 346         return 0;
 347 }
 348
 349 /*
 350  * Encode LINK arguments
 351  */
 352 static int
 353 nfs_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs_linkargs *args)
 354 {
 355         p = xdr_encode_fhandle(p, args->fromfh);
 356         p = xdr_encode_fhandle(p, args->tofh);
 357         p = xdr_encode_array(p, args->toname, args->tolen);
 358         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 359         return 0;
 360 }
 361
 362 /*
 363  * Encode SYMLINK arguments
 364  */
 365 static int
 366 nfs_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_symlinkargs *args)
 367 {
 368         struct xdr_buf *sndbuf = &req->rq_snd_buf;
 369         size_t pad;
 370
 371         p = xdr_encode_fhandle(p, args->fromfh);
 372         p = xdr_encode_array(p, args->fromname, args->fromlen);
 373         *p++ = htonl(args->pathlen);
 374         sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
 375
 376         xdr_encode_pages(sndbuf, args->pages, 0, args->pathlen);
 377
 378         /*
 379          * xdr_encode_pages may have added a few bytes to ensure the
 380          * pathname ends on a 4-byte boundary.  Start encoding the
 381          * attributes after the pad bytes.
 382          */
 383         pad = sndbuf->tail->iov_len;
 384         if (pad > 0)
 385                 p++;
 386         p = xdr_encode_sattr(p, args->sattr);
 387         sndbuf->len += xdr_adjust_iovec(sndbuf->tail, p) - pad;
 388         return 0;
 389 }
 390
 391 /*
 392  * Encode arguments to readdir call
 393  */
 394 static int
 395 nfs_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs_readdirargs *args)
 396 {
 397         struct rpc_task *task = req->rq_task;
 398         struct rpc_auth *auth = task->tk_msg.rpc_cred->cr_auth;
 399         unsigned int replen;
 400         u32 count = args->count;
 401
 402         p = xdr_encode_fhandle(p, args->fh);
 403         *p++ = htonl(args->cookie);
 404         *p++ = htonl(count); /* see above */
 405         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 406
 407         /* Inline the page array */
 408         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readdirres_sz) << 2;
 409         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count);
 410         return 0;
 411 }
 412
 413 /*
 414  * Decode the result of a readdir call.
 415  * We're not really decoding anymore, we just leave the buffer untouched
 416  * and only check that it is syntactically correct.
 417  * The real decoding happens in nfs_decode_entry below, called directly
 418  * from nfs_readdir for each entry.
 419  */
 420 static int
 421 nfs_xdr_readdirres(struct rpc_rqst *req, __be32 *p, void *dummy)
 422 {
 423         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 424         struct kvec *iov = rcvbuf->head;
 425         struct page **page;
 426         int hdrlen, recvd;
 427         int status, nr;
 428         unsigned int len, pglen;
 429         __be32 *end, *entry, *kaddr;
 430
 431         if ((status = ntohl(*p++)))
 432                 return -nfs_stat_to_errno(status);
 433
 434         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 435         if (iov->iov_len < hdrlen) {
 436                 dprintk("NFS: READDIR reply header overflowed:"
 437                                 "length %d > %Zu\n", hdrlen, iov->iov_len);
 438                 return -errno_NFSERR_IO;
 439         } else if (iov->iov_len != hdrlen) {
 440                 dprintk("NFS: READDIR header is short. iovec will be shifted.\n");
 441                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 442         }
 443
 444         pglen = rcvbuf->page_len;
 445         recvd = rcvbuf->len - hdrlen;
 446         if (pglen > recvd)
 447                 pglen = recvd;
 448         page = rcvbuf->pages;
 449         kaddr = p = kmap_atomic(*page, KM_USER0);
 450         end = (__be32 *)((char *)p + pglen);
 451         entry = p;
 452         for (nr = 0; *p++; nr++) {
 453                 if (p + 2 > end)
 454                         goto short_pkt;
 455                 p++; /* fileid */
 456                 len = ntohl(*p++);
 457                 p += XDR_QUADLEN(len) + 1;      /* name plus cookie */
 458                 if (len > NFS2_MAXNAMLEN) {
 459                         dprintk("NFS: giant filename in readdir (len 0x%x)!\n",
 460                                                 len);
 461                         goto err_unmap;
 462                 }
 463                 if (p + 2 > end)
 464                         goto short_pkt;
 465                 entry = p;
 466         }
 467         if (!nr && (entry[0] != 0 || entry[1] == 0))
 468                 goto short_pkt;
 469  out:
 470         kunmap_atomic(kaddr, KM_USER0);
 471         return nr;
 472  short_pkt:
 473         entry[0] = entry[1] = 0;
 474         /* truncate listing ? */
 475         if (!nr) {
 476                 dprintk("NFS: readdir reply truncated!\n");
 477                 entry[1] = 1;
 478         }
 479         goto out;
 480 err_unmap:
 481         nr = -errno_NFSERR_IO;
 482         goto out;
 483 }
 484
 485 __be32 *
 486 nfs_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus)
 487 {
 488         if (!*p++) {
 489                 if (!*p)
 490                         return ERR_PTR(-EAGAIN);
 491                 entry->eof = 1;
 492                 return ERR_PTR(-EBADCOOKIE);
 493         }
 494
 495         entry->ino        = ntohl(*p++);
 496         entry->len        = ntohl(*p++);
 497         entry->name       = (const char *) p;
 498         p                += XDR_QUADLEN(entry->len);
 499         entry->prev_cookie        = entry->cookie;
 500         entry->cookie     = ntohl(*p++);
 501         entry->eof        = !p[0] && p[1];
 502
 503         return p;
 504 }
 505
 506 /*
 507  * NFS XDR decode functions
 508  */
 509 /*
 510  * Decode simple status reply
 511  */
 512 static int
 513 nfs_xdr_stat(struct rpc_rqst *req, __be32 *p, void *dummy)
 514 {
 515         int     status;
 516
 517         if ((status = ntohl(*p++)) != 0)
 518                 status = -nfs_stat_to_errno(status);
 519         return status;
 520 }
 521
 522 /*
 523  * Decode attrstat reply
 524  * GETATTR, SETATTR, WRITE
 525  */
 526 static int
 527 nfs_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
 528 {
 529         int     status;
 530
 531         if ((status = ntohl(*p++)))
 532                 return -nfs_stat_to_errno(status);
 533         xdr_decode_fattr(p, fattr);
 534         return 0;
 535 }
 536
 537 /*
 538  * Decode diropres reply
 539  * LOOKUP, CREATE, MKDIR
 540  */
 541 static int
 542 nfs_xdr_diropres(struct rpc_rqst *req, __be32 *p, struct nfs_diropok *res)
 543 {
 544         int     status;
 545
 546         if ((status = ntohl(*p++)))
 547                 return -nfs_stat_to_errno(status);
 548         p = xdr_decode_fhandle(p, res->fh);
 549         xdr_decode_fattr(p, res->fattr);
 550         return 0;
 551 }
 552
 553 /*
 554  * Encode READLINK args
 555  */
 556 static int
 557 nfs_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_readlinkargs *args)
 558 {
 559         struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 560         unsigned int replen;
 561
 562         p = xdr_encode_fhandle(p, args->fh);
 563         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
 564
 565         /* Inline the page array */
 566         replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2;
 567         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen);
 568         return 0;
 569 }
 570
 571 /*
 572  * Decode READLINK reply
 573  */
 574 static int
 575 nfs_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, void *dummy)
 576 {
 577         struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
 578         struct kvec *iov = rcvbuf->head;
 579         int hdrlen, len, recvd;
 580         char    *kaddr;
 581         int     status;
 582
 583         if ((status = ntohl(*p++)))
 584                 return -nfs_stat_to_errno(status);
 585         /* Convert length of symlink */
 586         len = ntohl(*p++);
 587         if (len >= rcvbuf->page_len || len <= 0) {
 588                 dprintk("nfs: server returned giant symlink!\n");
 589                 return -ENAMETOOLONG;
 590         }
 591         hdrlen = (u8 *) p - (u8 *) iov->iov_base;
 592         if (iov->iov_len < hdrlen) {
 593                 dprintk("NFS: READLINK reply header overflowed:"
 594                                 "length %d > %Zu\n", hdrlen, iov->iov_len);
 595                 return -errno_NFSERR_IO;
 596         } else if (iov->iov_len != hdrlen) {
 597                 dprintk("NFS: READLINK header is short. iovec will be shifted.\n");
 598                 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
 599         }
 600         recvd = req->rq_rcv_buf.len - hdrlen;
 601         if (recvd < len) {
 602                 dprintk("NFS: server cheating in readlink reply: "
 603                                 "count %u > recvd %u\n", len, recvd);
 604                 return -EIO;
 605         }
 606
 607         /* NULL terminate the string we got */
 608         kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
 609         kaddr[len+rcvbuf->page_base] = '\0';
 610         kunmap_atomic(kaddr, KM_USER0);
 611         return 0;
 612 }
 613
 614 /*
 615  * Decode WRITE reply
 616  */
 617 static int
 618 nfs_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
 619 {
 620         res->verf->committed = NFS_FILE_SYNC;
 621         return nfs_xdr_attrstat(req, p, res->fattr);
 622 }
 623
 624 /*
 625  * Decode STATFS reply
 626  */
 627 static int
 628 nfs_xdr_statfsres(struct rpc_rqst *req, __be32 *p, struct nfs2_fsstat *res)
 629 {
 630         int     status;
 631
 632         if ((status = ntohl(*p++)))
 633                 return -nfs_stat_to_errno(status);
 634
 635         res->tsize  = ntohl(*p++);
 636         res->bsize  = ntohl(*p++);
 637         res->blocks = ntohl(*p++);
 638         res->bfree  = ntohl(*p++);
 639         res->bavail = ntohl(*p++);
 640         return 0;
 641 }
 642
 643 /*
 644  * We need to translate between nfs status return values and
 645  * the local errno values which may not be the same.
 646  */
 647 static struct {
 648         int stat;
 649         int errno;
 650 } nfs_errtbl[] = {
 651         { NFS_OK,               0               },
 652         { NFSERR_PERM,          EPERM           },
 653         { NFSERR_NOENT,         ENOENT          },
 654         { NFSERR_IO,            errno_NFSERR_IO },
 655         { NFSERR_NXIO,          ENXIO           },
 656 /*      { NFSERR_EAGAIN,        EAGAIN          }, */
 657         { NFSERR_ACCES,         EACCES          },
 658         { NFSERR_EXIST,         EEXIST          },
 659         { NFSERR_XDEV,          EXDEV           },
 660         { NFSERR_NODEV,         ENODEV          },
 661         { NFSERR_NOTDIR,        ENOTDIR         },
 662         { NFSERR_ISDIR,         EISDIR          },
 663         { NFSERR_INVAL,         EINVAL          },
 664         { NFSERR_FBIG,          EFBIG           },
 665         { NFSERR_NOSPC,         ENOSPC          },
 666         { NFSERR_ROFS,          EROFS           },
 667         { NFSERR_MLINK,         EMLINK          },
 668         { NFSERR_NAMETOOLONG,   ENAMETOOLONG    },
 669         { NFSERR_NOTEMPTY,      ENOTEMPTY       },
 670         { NFSERR_DQUOT,         EDQUOT          },
 671         { NFSERR_STALE,         ESTALE          },
 672         { NFSERR_REMOTE,        EREMOTE         },
 673 #ifdef EWFLUSH
 674         { NFSERR_WFLUSH,        EWFLUSH         },
 675 #endif
 676         { NFSERR_BADHANDLE,     EBADHANDLE      },
 677         { NFSERR_NOT_SYNC,      ENOTSYNC        },
 678         { NFSERR_BAD_COOKIE,    EBADCOOKIE      },
 679         { NFSERR_NOTSUPP,       ENOTSUPP        },
 680         { NFSERR_TOOSMALL,      ETOOSMALL       },
 681         { NFSERR_SERVERFAULT,   ESERVERFAULT    },
 682         { NFSERR_BADTYPE,       EBADTYPE        },
 683         { NFSERR_JUKEBOX,       EJUKEBOX        },
 684         { -1,                   EIO             }
 685 };
 686
 687 /*
 688  * Convert an NFS error code to a local one.
 689  * This one is used jointly by NFSv2 and NFSv3.
 690  */
 691 int
 692 nfs_stat_to_errno(int stat)
 693 {
 694         int i;
 695
 696         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
 697                 if (nfs_errtbl[i].stat == stat)
 698                         return nfs_errtbl[i].errno;
 699         }
 700         dprintk("nfs_stat_to_errno: bad nfs status return value: %d\n", stat);
 701         return nfs_errtbl[i].errno;
 702 }
 703
 704 #define PROC(proc, argtype, restype, timer)                             \
 705 [NFSPROC_##proc] = {                                                    \
 706         .p_proc     =  NFSPROC_##proc,                                  \
 707         .p_encode   =  (kxdrproc_t) nfs_xdr_##argtype,                  \
 708         .p_decode   =  (kxdrproc_t) nfs_xdr_##restype,                  \
 709         .p_arglen   =  NFS_##argtype##_sz,                              \
 710         .p_replen   =  NFS_##restype##_sz,                              \
 711         .p_timer    =  timer,                                           \
 712         .p_statidx  =  NFSPROC_##proc,                                  \
 713         .p_name     =  #proc,                                           \
 714         }
 715 struct rpc_procinfo     nfs_procedures[] = {
 716     PROC(GETATTR,       fhandle,        attrstat, 1),
 717     PROC(SETATTR,       sattrargs,      attrstat, 0),
 718     PROC(LOOKUP,        diropargs,      diropres, 2),
 719     PROC(READLINK,      readlinkargs,   readlinkres, 3),
 720     PROC(READ,          readargs,       readres, 3),
 721     PROC(WRITE,         writeargs,      writeres, 4),
 722     PROC(CREATE,        createargs,     diropres, 0),
 723     PROC(REMOVE,        removeargs,     stat, 0),
 724     PROC(RENAME,        renameargs,     stat, 0),
 725     PROC(LINK,          linkargs,       stat, 0),
 726     PROC(SYMLINK,       symlinkargs,    stat, 0),
 727     PROC(MKDIR,         createargs,     diropres, 0),
 728     PROC(RMDIR,         diropargs,      stat, 0),
 729     PROC(READDIR,       readdirargs,    readdirres, 3),
 730     PROC(STATFS,        fhandle,        statfsres, 0),
 731 };
 732
 733 struct rpc_version              nfs_version2 = {
 734         .number                 = 2,
 735         .nrprocs                = ARRAY_SIZE(nfs_procedures),
 736         .procs                  = nfs_procedures
 737 };