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