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