1 /* 2 * linux/fs/nfs/nfs3xdr.c 3 * 4 * XDR functions to encode/decode NFSv3 RPC arguments and results. 5 * 6 * Copyright (C) 1996, 1997 Olaf Kirch 7 */ 8 9 #include <linux/param.h> 10 #include <linux/time.h> 11 #include <linux/mm.h> 12 #include <linux/errno.h> 13 #include <linux/string.h> 14 #include <linux/in.h> 15 #include <linux/pagemap.h> 16 #include <linux/proc_fs.h> 17 #include <linux/kdev_t.h> 18 #include <linux/sunrpc/clnt.h> 19 #include <linux/nfs.h> 20 #include <linux/nfs3.h> 21 #include <linux/nfs_fs.h> 22 #include <linux/nfsacl.h> 23 #include "internal.h" 24 25 #define NFSDBG_FACILITY NFSDBG_XDR 26 27 /* Mapping from NFS error code to "errno" error code. */ 28 #define errno_NFSERR_IO EIO 29 30 /* 31 * Declare the space requirements for NFS arguments and replies as 32 * number of 32bit-words 33 */ 34 #define NFS3_fhandle_sz (1+16) 35 #define NFS3_fh_sz (NFS3_fhandle_sz) /* shorthand */ 36 #define NFS3_sattr_sz (15) 37 #define NFS3_filename_sz (1+(NFS3_MAXNAMLEN>>2)) 38 #define NFS3_path_sz (1+(NFS3_MAXPATHLEN>>2)) 39 #define NFS3_fattr_sz (21) 40 #define NFS3_wcc_attr_sz (6) 41 #define NFS3_pre_op_attr_sz (1+NFS3_wcc_attr_sz) 42 #define NFS3_post_op_attr_sz (1+NFS3_fattr_sz) 43 #define NFS3_wcc_data_sz (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz) 44 #define NFS3_fsstat_sz 45 #define NFS3_fsinfo_sz 46 #define NFS3_pathconf_sz 47 #define NFS3_entry_sz (NFS3_filename_sz+3) 48 49 #define NFS3_sattrargs_sz (NFS3_fh_sz+NFS3_sattr_sz+3) 50 #define NFS3_diropargs_sz (NFS3_fh_sz+NFS3_filename_sz) 51 #define NFS3_removeargs_sz (NFS3_fh_sz+NFS3_filename_sz) 52 #define NFS3_accessargs_sz (NFS3_fh_sz+1) 53 #define NFS3_readlinkargs_sz (NFS3_fh_sz) 54 #define NFS3_readargs_sz (NFS3_fh_sz+3) 55 #define NFS3_writeargs_sz (NFS3_fh_sz+5) 56 #define NFS3_createargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz) 57 #define NFS3_mkdirargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz) 58 #define NFS3_symlinkargs_sz (NFS3_diropargs_sz+1+NFS3_sattr_sz) 59 #define NFS3_mknodargs_sz (NFS3_diropargs_sz+2+NFS3_sattr_sz) 60 #define NFS3_renameargs_sz (NFS3_diropargs_sz+NFS3_diropargs_sz) 61 #define NFS3_linkargs_sz (NFS3_fh_sz+NFS3_diropargs_sz) 62 #define NFS3_readdirargs_sz (NFS3_fh_sz+2) 63 #define NFS3_commitargs_sz (NFS3_fh_sz+3) 64 65 #define NFS3_attrstat_sz (1+NFS3_fattr_sz) 66 #define NFS3_wccstat_sz (1+NFS3_wcc_data_sz) 67 #define NFS3_removeres_sz (NFS3_wccstat_sz) 68 #define NFS3_lookupres_sz (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz)) 69 #define NFS3_accessres_sz (1+NFS3_post_op_attr_sz+1) 70 #define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1) 71 #define NFS3_readres_sz (1+NFS3_post_op_attr_sz+3) 72 #define NFS3_writeres_sz (1+NFS3_wcc_data_sz+4) 73 #define NFS3_createres_sz (1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz) 74 #define NFS3_renameres_sz (1+(2 * NFS3_wcc_data_sz)) 75 #define NFS3_linkres_sz (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz) 76 #define NFS3_readdirres_sz (1+NFS3_post_op_attr_sz+2) 77 #define NFS3_fsstatres_sz (1+NFS3_post_op_attr_sz+13) 78 #define NFS3_fsinfores_sz (1+NFS3_post_op_attr_sz+12) 79 #define NFS3_pathconfres_sz (1+NFS3_post_op_attr_sz+6) 80 #define NFS3_commitres_sz (1+NFS3_wcc_data_sz+2) 81 82 #define ACL3_getaclargs_sz (NFS3_fh_sz+1) 83 #define ACL3_setaclargs_sz (NFS3_fh_sz+1+ \ 84 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE)) 85 #define ACL3_getaclres_sz (1+NFS3_post_op_attr_sz+1+ \ 86 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE)) 87 #define ACL3_setaclres_sz (1+NFS3_post_op_attr_sz) 88 89 /* 90 * Map file type to S_IFMT bits 91 */ 92 static const umode_t nfs_type2fmt[] = { 93 [NF3BAD] = 0, 94 [NF3REG] = S_IFREG, 95 [NF3DIR] = S_IFDIR, 96 [NF3BLK] = S_IFBLK, 97 [NF3CHR] = S_IFCHR, 98 [NF3LNK] = S_IFLNK, 99 [NF3SOCK] = S_IFSOCK, 100 [NF3FIFO] = S_IFIFO, 101 }; 102 103 /* 104 * Common NFS XDR functions as inlines 105 */ 106 static inline __be32 * 107 xdr_encode_fhandle(__be32 *p, const struct nfs_fh *fh) 108 { 109 return xdr_encode_array(p, fh->data, fh->size); 110 } 111 112 static inline __be32 * 113 xdr_decode_fhandle(__be32 *p, struct nfs_fh *fh) 114 { 115 if ((fh->size = ntohl(*p++)) <= NFS3_FHSIZE) { 116 memcpy(fh->data, p, fh->size); 117 return p + XDR_QUADLEN(fh->size); 118 } 119 return NULL; 120 } 121 122 /* 123 * Encode/decode time. 124 */ 125 static inline __be32 * 126 xdr_encode_time3(__be32 *p, struct timespec *timep) 127 { 128 *p++ = htonl(timep->tv_sec); 129 *p++ = htonl(timep->tv_nsec); 130 return p; 131 } 132 133 static inline __be32 * 134 xdr_decode_time3(__be32 *p, struct timespec *timep) 135 { 136 timep->tv_sec = ntohl(*p++); 137 timep->tv_nsec = ntohl(*p++); 138 return p; 139 } 140 141 static __be32 * 142 xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr) 143 { 144 unsigned int type, major, minor; 145 umode_t fmode; 146 147 type = ntohl(*p++); 148 if (type > NF3FIFO) 149 type = NF3NON; 150 fmode = nfs_type2fmt[type]; 151 fattr->mode = (ntohl(*p++) & ~S_IFMT) | fmode; 152 fattr->nlink = ntohl(*p++); 153 fattr->uid = ntohl(*p++); 154 fattr->gid = ntohl(*p++); 155 p = xdr_decode_hyper(p, &fattr->size); 156 p = xdr_decode_hyper(p, &fattr->du.nfs3.used); 157 158 /* Turn remote device info into Linux-specific dev_t */ 159 major = ntohl(*p++); 160 minor = ntohl(*p++); 161 fattr->rdev = MKDEV(major, minor); 162 if (MAJOR(fattr->rdev) != major || MINOR(fattr->rdev) != minor) 163 fattr->rdev = 0; 164 165 p = xdr_decode_hyper(p, &fattr->fsid.major); 166 fattr->fsid.minor = 0; 167 p = xdr_decode_hyper(p, &fattr->fileid); 168 p = xdr_decode_time3(p, &fattr->atime); 169 p = xdr_decode_time3(p, &fattr->mtime); 170 p = xdr_decode_time3(p, &fattr->ctime); 171 172 /* Update the mode bits */ 173 fattr->valid |= NFS_ATTR_FATTR_V3; 174 return p; 175 } 176 177 static inline __be32 * 178 xdr_encode_sattr(__be32 *p, struct iattr *attr) 179 { 180 if (attr->ia_valid & ATTR_MODE) { 181 *p++ = xdr_one; 182 *p++ = htonl(attr->ia_mode & S_IALLUGO); 183 } else { 184 *p++ = xdr_zero; 185 } 186 if (attr->ia_valid & ATTR_UID) { 187 *p++ = xdr_one; 188 *p++ = htonl(attr->ia_uid); 189 } else { 190 *p++ = xdr_zero; 191 } 192 if (attr->ia_valid & ATTR_GID) { 193 *p++ = xdr_one; 194 *p++ = htonl(attr->ia_gid); 195 } else { 196 *p++ = xdr_zero; 197 } 198 if (attr->ia_valid & ATTR_SIZE) { 199 *p++ = xdr_one; 200 p = xdr_encode_hyper(p, (__u64) attr->ia_size); 201 } else { 202 *p++ = xdr_zero; 203 } 204 if (attr->ia_valid & ATTR_ATIME_SET) { 205 *p++ = xdr_two; 206 p = xdr_encode_time3(p, &attr->ia_atime); 207 } else if (attr->ia_valid & ATTR_ATIME) { 208 *p++ = xdr_one; 209 } else { 210 *p++ = xdr_zero; 211 } 212 if (attr->ia_valid & ATTR_MTIME_SET) { 213 *p++ = xdr_two; 214 p = xdr_encode_time3(p, &attr->ia_mtime); 215 } else if (attr->ia_valid & ATTR_MTIME) { 216 *p++ = xdr_one; 217 } else { 218 *p++ = xdr_zero; 219 } 220 return p; 221 } 222 223 static inline __be32 * 224 xdr_decode_wcc_attr(__be32 *p, struct nfs_fattr *fattr) 225 { 226 p = xdr_decode_hyper(p, &fattr->pre_size); 227 p = xdr_decode_time3(p, &fattr->pre_mtime); 228 p = xdr_decode_time3(p, &fattr->pre_ctime); 229 fattr->valid |= NFS_ATTR_FATTR_PRESIZE 230 | NFS_ATTR_FATTR_PREMTIME 231 | NFS_ATTR_FATTR_PRECTIME; 232 return p; 233 } 234 235 static inline __be32 * 236 xdr_decode_post_op_attr(__be32 *p, struct nfs_fattr *fattr) 237 { 238 if (*p++) 239 p = xdr_decode_fattr(p, fattr); 240 return p; 241 } 242 243 static inline __be32 * 244 xdr_decode_pre_op_attr(__be32 *p, struct nfs_fattr *fattr) 245 { 246 if (*p++) 247 return xdr_decode_wcc_attr(p, fattr); 248 return p; 249 } 250 251 252 static inline __be32 * 253 xdr_decode_wcc_data(__be32 *p, struct nfs_fattr *fattr) 254 { 255 p = xdr_decode_pre_op_attr(p, fattr); 256 return xdr_decode_post_op_attr(p, fattr); 257 } 258 259 /* 260 * NFS encode functions 261 */ 262 263 /* 264 * Encode file handle argument 265 */ 266 static int 267 nfs3_xdr_fhandle(struct rpc_rqst *req, __be32 *p, struct nfs_fh *fh) 268 { 269 p = xdr_encode_fhandle(p, fh); 270 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 271 return 0; 272 } 273 274 /* 275 * Encode SETATTR arguments 276 */ 277 static int 278 nfs3_xdr_sattrargs(struct rpc_rqst *req, __be32 *p, struct nfs3_sattrargs *args) 279 { 280 p = xdr_encode_fhandle(p, args->fh); 281 p = xdr_encode_sattr(p, args->sattr); 282 *p++ = htonl(args->guard); 283 if (args->guard) 284 p = xdr_encode_time3(p, &args->guardtime); 285 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 286 return 0; 287 } 288 289 /* 290 * Encode directory ops argument 291 */ 292 static int 293 nfs3_xdr_diropargs(struct rpc_rqst *req, __be32 *p, struct nfs3_diropargs *args) 294 { 295 p = xdr_encode_fhandle(p, args->fh); 296 p = xdr_encode_array(p, args->name, args->len); 297 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 298 return 0; 299 } 300 301 /* 302 * Encode REMOVE argument 303 */ 304 static int 305 nfs3_xdr_removeargs(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args) 306 { 307 p = xdr_encode_fhandle(p, args->fh); 308 p = xdr_encode_array(p, args->name.name, args->name.len); 309 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 310 return 0; 311 } 312 313 /* 314 * Encode access() argument 315 */ 316 static int 317 nfs3_xdr_accessargs(struct rpc_rqst *req, __be32 *p, struct nfs3_accessargs *args) 318 { 319 p = xdr_encode_fhandle(p, args->fh); 320 *p++ = htonl(args->access); 321 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 322 return 0; 323 } 324 325 /* 326 * Arguments to a READ call. Since we read data directly into the page 327 * cache, we also set up the reply iovec here so that iov[1] points 328 * exactly to the page we want to fetch. 329 */ 330 static int 331 nfs3_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args) 332 { 333 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; 334 unsigned int replen; 335 u32 count = args->count; 336 337 p = xdr_encode_fhandle(p, args->fh); 338 p = xdr_encode_hyper(p, args->offset); 339 *p++ = htonl(count); 340 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 341 342 /* Inline the page array */ 343 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readres_sz) << 2; 344 xdr_inline_pages(&req->rq_rcv_buf, replen, 345 args->pages, args->pgbase, count); 346 req->rq_rcv_buf.flags |= XDRBUF_READ; 347 return 0; 348 } 349 350 /* 351 * Write arguments. Splice the buffer to be written into the iovec. 352 */ 353 static int 354 nfs3_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args) 355 { 356 struct xdr_buf *sndbuf = &req->rq_snd_buf; 357 u32 count = args->count; 358 359 p = xdr_encode_fhandle(p, args->fh); 360 p = xdr_encode_hyper(p, args->offset); 361 *p++ = htonl(count); 362 *p++ = htonl(args->stable); 363 *p++ = htonl(count); 364 sndbuf->len = xdr_adjust_iovec(sndbuf->head, p); 365 366 /* Copy the page array */ 367 xdr_encode_pages(sndbuf, args->pages, args->pgbase, count); 368 sndbuf->flags |= XDRBUF_WRITE; 369 return 0; 370 } 371 372 /* 373 * Encode CREATE arguments 374 */ 375 static int 376 nfs3_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs3_createargs *args) 377 { 378 p = xdr_encode_fhandle(p, args->fh); 379 p = xdr_encode_array(p, args->name, args->len); 380 381 *p++ = htonl(args->createmode); 382 if (args->createmode == NFS3_CREATE_EXCLUSIVE) { 383 *p++ = args->verifier[0]; 384 *p++ = args->verifier[1]; 385 } else 386 p = xdr_encode_sattr(p, args->sattr); 387 388 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 389 return 0; 390 } 391 392 /* 393 * Encode MKDIR arguments 394 */ 395 static int 396 nfs3_xdr_mkdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_mkdirargs *args) 397 { 398 p = xdr_encode_fhandle(p, args->fh); 399 p = xdr_encode_array(p, args->name, args->len); 400 p = xdr_encode_sattr(p, args->sattr); 401 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 402 return 0; 403 } 404 405 /* 406 * Encode SYMLINK arguments 407 */ 408 static int 409 nfs3_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_symlinkargs *args) 410 { 411 p = xdr_encode_fhandle(p, args->fromfh); 412 p = xdr_encode_array(p, args->fromname, args->fromlen); 413 p = xdr_encode_sattr(p, args->sattr); 414 *p++ = htonl(args->pathlen); 415 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 416 417 /* Copy the page */ 418 xdr_encode_pages(&req->rq_snd_buf, args->pages, 0, args->pathlen); 419 return 0; 420 } 421 422 /* 423 * Encode MKNOD arguments 424 */ 425 static int 426 nfs3_xdr_mknodargs(struct rpc_rqst *req, __be32 *p, struct nfs3_mknodargs *args) 427 { 428 p = xdr_encode_fhandle(p, args->fh); 429 p = xdr_encode_array(p, args->name, args->len); 430 *p++ = htonl(args->type); 431 p = xdr_encode_sattr(p, args->sattr); 432 if (args->type == NF3CHR || args->type == NF3BLK) { 433 *p++ = htonl(MAJOR(args->rdev)); 434 *p++ = htonl(MINOR(args->rdev)); 435 } 436 437 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 438 return 0; 439 } 440 441 /* 442 * Encode RENAME arguments 443 */ 444 static int 445 nfs3_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs3_renameargs *args) 446 { 447 p = xdr_encode_fhandle(p, args->fromfh); 448 p = xdr_encode_array(p, args->fromname, args->fromlen); 449 p = xdr_encode_fhandle(p, args->tofh); 450 p = xdr_encode_array(p, args->toname, args->tolen); 451 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 452 return 0; 453 } 454 455 /* 456 * Encode LINK arguments 457 */ 458 static int 459 nfs3_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_linkargs *args) 460 { 461 p = xdr_encode_fhandle(p, args->fromfh); 462 p = xdr_encode_fhandle(p, args->tofh); 463 p = xdr_encode_array(p, args->toname, args->tolen); 464 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 465 return 0; 466 } 467 468 /* 469 * Encode arguments to readdir call 470 */ 471 static int 472 nfs3_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirargs *args) 473 { 474 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; 475 unsigned int replen; 476 u32 count = args->count; 477 478 p = xdr_encode_fhandle(p, args->fh); 479 p = xdr_encode_hyper(p, args->cookie); 480 *p++ = args->verf[0]; 481 *p++ = args->verf[1]; 482 if (args->plus) { 483 /* readdirplus: need dircount + buffer size. 484 * We just make sure we make dircount big enough */ 485 *p++ = htonl(count >> 3); 486 } 487 *p++ = htonl(count); 488 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 489 490 /* Inline the page array */ 491 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readdirres_sz) << 2; 492 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count); 493 return 0; 494 } 495 496 /* 497 * Decode the result of a readdir call. 498 * We just check for syntactical correctness. 499 */ 500 static int 501 nfs3_xdr_readdirres(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirres *res) 502 { 503 struct xdr_buf *rcvbuf = &req->rq_rcv_buf; 504 struct kvec *iov = rcvbuf->head; 505 struct page **page; 506 size_t hdrlen; 507 u32 len, recvd, pglen; 508 int status, nr = 0; 509 __be32 *entry, *end, *kaddr; 510 511 status = ntohl(*p++); 512 /* Decode post_op_attrs */ 513 p = xdr_decode_post_op_attr(p, res->dir_attr); 514 if (status) 515 return nfs_stat_to_errno(status); 516 /* Decode verifier cookie */ 517 if (res->verf) { 518 res->verf[0] = *p++; 519 res->verf[1] = *p++; 520 } else { 521 p += 2; 522 } 523 524 hdrlen = (u8 *) p - (u8 *) iov->iov_base; 525 if (iov->iov_len < hdrlen) { 526 dprintk("NFS: READDIR reply header overflowed:" 527 "length %Zu > %Zu\n", hdrlen, iov->iov_len); 528 return -errno_NFSERR_IO; 529 } else if (iov->iov_len != hdrlen) { 530 dprintk("NFS: READDIR header is short. iovec will be shifted.\n"); 531 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen); 532 } 533 534 pglen = rcvbuf->page_len; 535 recvd = rcvbuf->len - hdrlen; 536 if (pglen > recvd) 537 pglen = recvd; 538 page = rcvbuf->pages; 539 kaddr = p = kmap_atomic(*page, KM_USER0); 540 end = (__be32 *)((char *)p + pglen); 541 entry = p; 542 543 /* Make sure the packet actually has a value_follows and EOF entry */ 544 if ((entry + 1) > end) 545 goto short_pkt; 546 547 for (; *p++; nr++) { 548 if (p + 3 > end) 549 goto short_pkt; 550 p += 2; /* inode # */ 551 len = ntohl(*p++); /* string length */ 552 p += XDR_QUADLEN(len) + 2; /* name + cookie */ 553 if (len > NFS3_MAXNAMLEN) { 554 dprintk("NFS: giant filename in readdir (len 0x%x)!\n", 555 len); 556 goto err_unmap; 557 } 558 559 if (res->plus) { 560 /* post_op_attr */ 561 if (p + 2 > end) 562 goto short_pkt; 563 if (*p++) { 564 p += 21; 565 if (p + 1 > end) 566 goto short_pkt; 567 } 568 /* post_op_fh3 */ 569 if (*p++) { 570 if (p + 1 > end) 571 goto short_pkt; 572 len = ntohl(*p++); 573 if (len > NFS3_FHSIZE) { 574 dprintk("NFS: giant filehandle in " 575 "readdir (len 0x%x)!\n", len); 576 goto err_unmap; 577 } 578 p += XDR_QUADLEN(len); 579 } 580 } 581 582 if (p + 2 > end) 583 goto short_pkt; 584 entry = p; 585 } 586 587 /* 588 * Apparently some server sends responses that are a valid size, but 589 * contain no entries, and have value_follows==0 and EOF==0. For 590 * those, just set the EOF marker. 591 */ 592 if (!nr && entry[1] == 0) { 593 dprintk("NFS: readdir reply truncated!\n"); 594 entry[1] = 1; 595 } 596 out: 597 kunmap_atomic(kaddr, KM_USER0); 598 return nr; 599 short_pkt: 600 /* 601 * When we get a short packet there are 2 possibilities. We can 602 * return an error, or fix up the response to look like a valid 603 * response and return what we have so far. If there are no 604 * entries and the packet was short, then return -EIO. If there 605 * are valid entries in the response, return them and pretend that 606 * the call was successful, but incomplete. The caller can retry the 607 * readdir starting at the last cookie. 608 */ 609 entry[0] = entry[1] = 0; 610 if (!nr) 611 nr = -errno_NFSERR_IO; 612 goto out; 613 err_unmap: 614 nr = -errno_NFSERR_IO; 615 goto out; 616 } 617 618 __be32 * 619 nfs3_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus) 620 { 621 struct nfs_entry old = *entry; 622 623 if (!*p++) { 624 if (!*p) 625 return ERR_PTR(-EAGAIN); 626 entry->eof = 1; 627 return ERR_PTR(-EBADCOOKIE); 628 } 629 630 p = xdr_decode_hyper(p, &entry->ino); 631 entry->len = ntohl(*p++); 632 entry->name = (const char *) p; 633 p += XDR_QUADLEN(entry->len); 634 entry->prev_cookie = entry->cookie; 635 p = xdr_decode_hyper(p, &entry->cookie); 636 637 if (plus) { 638 entry->fattr->valid = 0; 639 p = xdr_decode_post_op_attr(p, entry->fattr); 640 /* In fact, a post_op_fh3: */ 641 if (*p++) { 642 p = xdr_decode_fhandle(p, entry->fh); 643 /* Ugh -- server reply was truncated */ 644 if (p == NULL) { 645 dprintk("NFS: FH truncated\n"); 646 *entry = old; 647 return ERR_PTR(-EAGAIN); 648 } 649 } else 650 memset((u8*)(entry->fh), 0, sizeof(*entry->fh)); 651 } 652 653 entry->eof = !p[0] && p[1]; 654 return p; 655 } 656 657 /* 658 * Encode COMMIT arguments 659 */ 660 static int 661 nfs3_xdr_commitargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args) 662 { 663 p = xdr_encode_fhandle(p, args->fh); 664 p = xdr_encode_hyper(p, args->offset); 665 *p++ = htonl(args->count); 666 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 667 return 0; 668 } 669 670 #ifdef CONFIG_NFS_V3_ACL 671 /* 672 * Encode GETACL arguments 673 */ 674 static int 675 nfs3_xdr_getaclargs(struct rpc_rqst *req, __be32 *p, 676 struct nfs3_getaclargs *args) 677 { 678 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; 679 unsigned int replen; 680 681 p = xdr_encode_fhandle(p, args->fh); 682 *p++ = htonl(args->mask); 683 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 684 685 if (args->mask & (NFS_ACL | NFS_DFACL)) { 686 /* Inline the page array */ 687 replen = (RPC_REPHDRSIZE + auth->au_rslack + 688 ACL3_getaclres_sz) << 2; 689 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, 690 NFSACL_MAXPAGES << PAGE_SHIFT); 691 } 692 return 0; 693 } 694 695 /* 696 * Encode SETACL arguments 697 */ 698 static int 699 nfs3_xdr_setaclargs(struct rpc_rqst *req, __be32 *p, 700 struct nfs3_setaclargs *args) 701 { 702 struct xdr_buf *buf = &req->rq_snd_buf; 703 unsigned int base; 704 int err; 705 706 p = xdr_encode_fhandle(p, NFS_FH(args->inode)); 707 *p++ = htonl(args->mask); 708 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 709 base = req->rq_slen; 710 711 if (args->npages != 0) 712 xdr_encode_pages(buf, args->pages, 0, args->len); 713 else 714 req->rq_slen = xdr_adjust_iovec(req->rq_svec, 715 p + XDR_QUADLEN(args->len)); 716 717 err = nfsacl_encode(buf, base, args->inode, 718 (args->mask & NFS_ACL) ? 719 args->acl_access : NULL, 1, 0); 720 if (err > 0) 721 err = nfsacl_encode(buf, base + err, args->inode, 722 (args->mask & NFS_DFACL) ? 723 args->acl_default : NULL, 1, 724 NFS_ACL_DEFAULT); 725 return (err > 0) ? 0 : err; 726 } 727 #endif /* CONFIG_NFS_V3_ACL */ 728 729 /* 730 * NFS XDR decode functions 731 */ 732 733 /* 734 * Decode attrstat reply. 735 */ 736 static int 737 nfs3_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr) 738 { 739 int status; 740 741 if ((status = ntohl(*p++))) 742 return nfs_stat_to_errno(status); 743 xdr_decode_fattr(p, fattr); 744 return 0; 745 } 746 747 /* 748 * Decode status+wcc_data reply 749 * SATTR, REMOVE, RMDIR 750 */ 751 static int 752 nfs3_xdr_wccstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr) 753 { 754 int status; 755 756 if ((status = ntohl(*p++))) 757 status = nfs_stat_to_errno(status); 758 xdr_decode_wcc_data(p, fattr); 759 return status; 760 } 761 762 static int 763 nfs3_xdr_removeres(struct rpc_rqst *req, __be32 *p, struct nfs_removeres *res) 764 { 765 return nfs3_xdr_wccstat(req, p, res->dir_attr); 766 } 767 768 /* 769 * Decode LOOKUP reply 770 */ 771 static int 772 nfs3_xdr_lookupres(struct rpc_rqst *req, __be32 *p, struct nfs3_diropres *res) 773 { 774 int status; 775 776 if ((status = ntohl(*p++))) { 777 status = nfs_stat_to_errno(status); 778 } else { 779 if (!(p = xdr_decode_fhandle(p, res->fh))) 780 return -errno_NFSERR_IO; 781 p = xdr_decode_post_op_attr(p, res->fattr); 782 } 783 xdr_decode_post_op_attr(p, res->dir_attr); 784 return status; 785 } 786 787 /* 788 * Decode ACCESS reply 789 */ 790 static int 791 nfs3_xdr_accessres(struct rpc_rqst *req, __be32 *p, struct nfs3_accessres *res) 792 { 793 int status = ntohl(*p++); 794 795 p = xdr_decode_post_op_attr(p, res->fattr); 796 if (status) 797 return nfs_stat_to_errno(status); 798 res->access = ntohl(*p++); 799 return 0; 800 } 801 802 static int 803 nfs3_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readlinkargs *args) 804 { 805 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; 806 unsigned int replen; 807 808 p = xdr_encode_fhandle(p, args->fh); 809 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 810 811 /* Inline the page array */ 812 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readlinkres_sz) << 2; 813 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen); 814 return 0; 815 } 816 817 /* 818 * Decode READLINK reply 819 */ 820 static int 821 nfs3_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr) 822 { 823 struct xdr_buf *rcvbuf = &req->rq_rcv_buf; 824 struct kvec *iov = rcvbuf->head; 825 size_t hdrlen; 826 u32 len, recvd; 827 char *kaddr; 828 int status; 829 830 status = ntohl(*p++); 831 p = xdr_decode_post_op_attr(p, fattr); 832 833 if (status != 0) 834 return nfs_stat_to_errno(status); 835 836 /* Convert length of symlink */ 837 len = ntohl(*p++); 838 if (len >= rcvbuf->page_len) { 839 dprintk("nfs: server returned giant symlink!\n"); 840 return -ENAMETOOLONG; 841 } 842 843 hdrlen = (u8 *) p - (u8 *) iov->iov_base; 844 if (iov->iov_len < hdrlen) { 845 dprintk("NFS: READLINK reply header overflowed:" 846 "length %Zu > %Zu\n", hdrlen, iov->iov_len); 847 return -errno_NFSERR_IO; 848 } else if (iov->iov_len != hdrlen) { 849 dprintk("NFS: READLINK header is short. " 850 "iovec will be shifted.\n"); 851 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen); 852 } 853 recvd = req->rq_rcv_buf.len - hdrlen; 854 if (recvd < len) { 855 dprintk("NFS: server cheating in readlink reply: " 856 "count %u > recvd %u\n", len, recvd); 857 return -EIO; 858 } 859 860 /* NULL terminate the string we got */ 861 kaddr = (char*)kmap_atomic(rcvbuf->pages[0], KM_USER0); 862 kaddr[len+rcvbuf->page_base] = '\0'; 863 kunmap_atomic(kaddr, KM_USER0); 864 return 0; 865 } 866 867 /* 868 * Decode READ reply 869 */ 870 static int 871 nfs3_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res) 872 { 873 struct kvec *iov = req->rq_rcv_buf.head; 874 size_t hdrlen; 875 u32 count, ocount, recvd; 876 int status; 877 878 status = ntohl(*p++); 879 p = xdr_decode_post_op_attr(p, res->fattr); 880 881 if (status != 0) 882 return nfs_stat_to_errno(status); 883 884 /* Decode reply count and EOF flag. NFSv3 is somewhat redundant 885 * in that it puts the count both in the res struct and in the 886 * opaque data count. */ 887 count = ntohl(*p++); 888 res->eof = ntohl(*p++); 889 ocount = ntohl(*p++); 890 891 if (ocount != count) { 892 dprintk("NFS: READ count doesn't match RPC opaque count.\n"); 893 return -errno_NFSERR_IO; 894 } 895 896 hdrlen = (u8 *) p - (u8 *) iov->iov_base; 897 if (iov->iov_len < hdrlen) { 898 dprintk("NFS: READ reply header overflowed:" 899 "length %Zu > %Zu\n", hdrlen, iov->iov_len); 900 return -errno_NFSERR_IO; 901 } else if (iov->iov_len != hdrlen) { 902 dprintk("NFS: READ header is short. iovec will be shifted.\n"); 903 xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen); 904 } 905 906 recvd = req->rq_rcv_buf.len - hdrlen; 907 if (count > recvd) { 908 dprintk("NFS: server cheating in read reply: " 909 "count %u > recvd %u\n", count, recvd); 910 count = recvd; 911 res->eof = 0; 912 } 913 914 if (count < res->count) 915 res->count = count; 916 917 return count; 918 } 919 920 /* 921 * Decode WRITE response 922 */ 923 static int 924 nfs3_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res) 925 { 926 int status; 927 928 status = ntohl(*p++); 929 p = xdr_decode_wcc_data(p, res->fattr); 930 931 if (status != 0) 932 return nfs_stat_to_errno(status); 933 934 res->count = ntohl(*p++); 935 res->verf->committed = (enum nfs3_stable_how)ntohl(*p++); 936 res->verf->verifier[0] = *p++; 937 res->verf->verifier[1] = *p++; 938 939 return res->count; 940 } 941 942 /* 943 * Decode a CREATE response 944 */ 945 static int 946 nfs3_xdr_createres(struct rpc_rqst *req, __be32 *p, struct nfs3_diropres *res) 947 { 948 int status; 949 950 status = ntohl(*p++); 951 if (status == 0) { 952 if (*p++) { 953 if (!(p = xdr_decode_fhandle(p, res->fh))) 954 return -errno_NFSERR_IO; 955 p = xdr_decode_post_op_attr(p, res->fattr); 956 } else { 957 memset(res->fh, 0, sizeof(*res->fh)); 958 /* Do decode post_op_attr but set it to NULL */ 959 p = xdr_decode_post_op_attr(p, res->fattr); 960 res->fattr->valid = 0; 961 } 962 } else { 963 status = nfs_stat_to_errno(status); 964 } 965 p = xdr_decode_wcc_data(p, res->dir_attr); 966 return status; 967 } 968 969 /* 970 * Decode RENAME reply 971 */ 972 static int 973 nfs3_xdr_renameres(struct rpc_rqst *req, __be32 *p, struct nfs3_renameres *res) 974 { 975 int status; 976 977 if ((status = ntohl(*p++)) != 0) 978 status = nfs_stat_to_errno(status); 979 p = xdr_decode_wcc_data(p, res->fromattr); 980 p = xdr_decode_wcc_data(p, res->toattr); 981 return status; 982 } 983 984 /* 985 * Decode LINK reply 986 */ 987 static int 988 nfs3_xdr_linkres(struct rpc_rqst *req, __be32 *p, struct nfs3_linkres *res) 989 { 990 int status; 991 992 if ((status = ntohl(*p++)) != 0) 993 status = nfs_stat_to_errno(status); 994 p = xdr_decode_post_op_attr(p, res->fattr); 995 p = xdr_decode_wcc_data(p, res->dir_attr); 996 return status; 997 } 998 999 /* 1000 * Decode FSSTAT reply 1001 */ 1002 static int 1003 nfs3_xdr_fsstatres(struct rpc_rqst *req, __be32 *p, struct nfs_fsstat *res) 1004 { 1005 int status; 1006 1007 status = ntohl(*p++); 1008 1009 p = xdr_decode_post_op_attr(p, res->fattr); 1010 if (status != 0) 1011 return nfs_stat_to_errno(status); 1012 1013 p = xdr_decode_hyper(p, &res->tbytes); 1014 p = xdr_decode_hyper(p, &res->fbytes); 1015 p = xdr_decode_hyper(p, &res->abytes); 1016 p = xdr_decode_hyper(p, &res->tfiles); 1017 p = xdr_decode_hyper(p, &res->ffiles); 1018 p = xdr_decode_hyper(p, &res->afiles); 1019 1020 /* ignore invarsec */ 1021 return 0; 1022 } 1023 1024 /* 1025 * Decode FSINFO reply 1026 */ 1027 static int 1028 nfs3_xdr_fsinfores(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfo *res) 1029 { 1030 int status; 1031 1032 status = ntohl(*p++); 1033 1034 p = xdr_decode_post_op_attr(p, res->fattr); 1035 if (status != 0) 1036 return nfs_stat_to_errno(status); 1037 1038 res->rtmax = ntohl(*p++); 1039 res->rtpref = ntohl(*p++); 1040 res->rtmult = ntohl(*p++); 1041 res->wtmax = ntohl(*p++); 1042 res->wtpref = ntohl(*p++); 1043 res->wtmult = ntohl(*p++); 1044 res->dtpref = ntohl(*p++); 1045 p = xdr_decode_hyper(p, &res->maxfilesize); 1046 1047 /* ignore time_delta and properties */ 1048 res->lease_time = 0; 1049 return 0; 1050 } 1051 1052 /* 1053 * Decode PATHCONF reply 1054 */ 1055 static int 1056 nfs3_xdr_pathconfres(struct rpc_rqst *req, __be32 *p, struct nfs_pathconf *res) 1057 { 1058 int status; 1059 1060 status = ntohl(*p++); 1061 1062 p = xdr_decode_post_op_attr(p, res->fattr); 1063 if (status != 0) 1064 return nfs_stat_to_errno(status); 1065 res->max_link = ntohl(*p++); 1066 res->max_namelen = ntohl(*p++); 1067 1068 /* ignore remaining fields */ 1069 return 0; 1070 } 1071 1072 /* 1073 * Decode COMMIT reply 1074 */ 1075 static int 1076 nfs3_xdr_commitres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res) 1077 { 1078 int status; 1079 1080 status = ntohl(*p++); 1081 p = xdr_decode_wcc_data(p, res->fattr); 1082 if (status != 0) 1083 return nfs_stat_to_errno(status); 1084 1085 res->verf->verifier[0] = *p++; 1086 res->verf->verifier[1] = *p++; 1087 return 0; 1088 } 1089 1090 #ifdef CONFIG_NFS_V3_ACL 1091 /* 1092 * Decode GETACL reply 1093 */ 1094 static int 1095 nfs3_xdr_getaclres(struct rpc_rqst *req, __be32 *p, 1096 struct nfs3_getaclres *res) 1097 { 1098 struct xdr_buf *buf = &req->rq_rcv_buf; 1099 int status = ntohl(*p++); 1100 struct posix_acl **acl; 1101 unsigned int *aclcnt; 1102 int err, base; 1103 1104 if (status != 0) 1105 return nfs_stat_to_errno(status); 1106 p = xdr_decode_post_op_attr(p, res->fattr); 1107 res->mask = ntohl(*p++); 1108 if (res->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT)) 1109 return -EINVAL; 1110 base = (char *)p - (char *)req->rq_rcv_buf.head->iov_base; 1111 1112 acl = (res->mask & NFS_ACL) ? &res->acl_access : NULL; 1113 aclcnt = (res->mask & NFS_ACLCNT) ? &res->acl_access_count : NULL; 1114 err = nfsacl_decode(buf, base, aclcnt, acl); 1115 1116 acl = (res->mask & NFS_DFACL) ? &res->acl_default : NULL; 1117 aclcnt = (res->mask & NFS_DFACLCNT) ? &res->acl_default_count : NULL; 1118 if (err > 0) 1119 err = nfsacl_decode(buf, base + err, aclcnt, acl); 1120 return (err > 0) ? 0 : err; 1121 } 1122 1123 /* 1124 * Decode setacl reply. 1125 */ 1126 static int 1127 nfs3_xdr_setaclres(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr) 1128 { 1129 int status = ntohl(*p++); 1130 1131 if (status) 1132 return nfs_stat_to_errno(status); 1133 xdr_decode_post_op_attr(p, fattr); 1134 return 0; 1135 } 1136 #endif /* CONFIG_NFS_V3_ACL */ 1137 1138 #define PROC(proc, argtype, restype, timer) \ 1139 [NFS3PROC_##proc] = { \ 1140 .p_proc = NFS3PROC_##proc, \ 1141 .p_encode = (kxdrproc_t) nfs3_xdr_##argtype, \ 1142 .p_decode = (kxdrproc_t) nfs3_xdr_##restype, \ 1143 .p_arglen = NFS3_##argtype##_sz, \ 1144 .p_replen = NFS3_##restype##_sz, \ 1145 .p_timer = timer, \ 1146 .p_statidx = NFS3PROC_##proc, \ 1147 .p_name = #proc, \ 1148 } 1149 1150 struct rpc_procinfo nfs3_procedures[] = { 1151 PROC(GETATTR, fhandle, attrstat, 1), 1152 PROC(SETATTR, sattrargs, wccstat, 0), 1153 PROC(LOOKUP, diropargs, lookupres, 2), 1154 PROC(ACCESS, accessargs, accessres, 1), 1155 PROC(READLINK, readlinkargs, readlinkres, 3), 1156 PROC(READ, readargs, readres, 3), 1157 PROC(WRITE, writeargs, writeres, 4), 1158 PROC(CREATE, createargs, createres, 0), 1159 PROC(MKDIR, mkdirargs, createres, 0), 1160 PROC(SYMLINK, symlinkargs, createres, 0), 1161 PROC(MKNOD, mknodargs, createres, 0), 1162 PROC(REMOVE, removeargs, removeres, 0), 1163 PROC(RMDIR, diropargs, wccstat, 0), 1164 PROC(RENAME, renameargs, renameres, 0), 1165 PROC(LINK, linkargs, linkres, 0), 1166 PROC(READDIR, readdirargs, readdirres, 3), 1167 PROC(READDIRPLUS, readdirargs, readdirres, 3), 1168 PROC(FSSTAT, fhandle, fsstatres, 0), 1169 PROC(FSINFO, fhandle, fsinfores, 0), 1170 PROC(PATHCONF, fhandle, pathconfres, 0), 1171 PROC(COMMIT, commitargs, commitres, 5), 1172 }; 1173 1174 struct rpc_version nfs_version3 = { 1175 .number = 3, 1176 .nrprocs = ARRAY_SIZE(nfs3_procedures), 1177 .procs = nfs3_procedures 1178 }; 1179 1180 #ifdef CONFIG_NFS_V3_ACL 1181 static struct rpc_procinfo nfs3_acl_procedures[] = { 1182 [ACLPROC3_GETACL] = { 1183 .p_proc = ACLPROC3_GETACL, 1184 .p_encode = (kxdrproc_t) nfs3_xdr_getaclargs, 1185 .p_decode = (kxdrproc_t) nfs3_xdr_getaclres, 1186 .p_arglen = ACL3_getaclargs_sz, 1187 .p_replen = ACL3_getaclres_sz, 1188 .p_timer = 1, 1189 .p_name = "GETACL", 1190 }, 1191 [ACLPROC3_SETACL] = { 1192 .p_proc = ACLPROC3_SETACL, 1193 .p_encode = (kxdrproc_t) nfs3_xdr_setaclargs, 1194 .p_decode = (kxdrproc_t) nfs3_xdr_setaclres, 1195 .p_arglen = ACL3_setaclargs_sz, 1196 .p_replen = ACL3_setaclres_sz, 1197 .p_timer = 0, 1198 .p_name = "SETACL", 1199 }, 1200 }; 1201 1202 struct rpc_version nfsacl_version3 = { 1203 .number = 3, 1204 .nrprocs = sizeof(nfs3_acl_procedures)/ 1205 sizeof(nfs3_acl_procedures[0]), 1206 .procs = nfs3_acl_procedures, 1207 }; 1208 #endif /* CONFIG_NFS_V3_ACL */ 1209