1 /* 2 * XDR support for nfsd/protocol version 3. 3 * 4 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de> 5 * 6 * 2003-08-09 Jamie Lokier: Use htonl() for nanoseconds, not htons()! 7 */ 8 9 #include <linux/namei.h> 10 #include <linux/sunrpc/svc_xprt.h> 11 #include "xdr3.h" 12 #include "auth.h" 13 #include "netns.h" 14 #include "vfs.h" 15 16 #define NFSDDBG_FACILITY NFSDDBG_XDR 17 18 19 /* 20 * Mapping of S_IF* types to NFS file types 21 */ 22 static u32 nfs3_ftypes[] = { 23 NF3NON, NF3FIFO, NF3CHR, NF3BAD, 24 NF3DIR, NF3BAD, NF3BLK, NF3BAD, 25 NF3REG, NF3BAD, NF3LNK, NF3BAD, 26 NF3SOCK, NF3BAD, NF3LNK, NF3BAD, 27 }; 28 29 /* 30 * XDR functions for basic NFS types 31 */ 32 static __be32 * 33 encode_time3(__be32 *p, struct timespec *time) 34 { 35 *p++ = htonl((u32) time->tv_sec); *p++ = htonl(time->tv_nsec); 36 return p; 37 } 38 39 static __be32 * 40 decode_time3(__be32 *p, struct timespec *time) 41 { 42 time->tv_sec = ntohl(*p++); 43 time->tv_nsec = ntohl(*p++); 44 return p; 45 } 46 47 static __be32 * 48 decode_fh(__be32 *p, struct svc_fh *fhp) 49 { 50 unsigned int size; 51 fh_init(fhp, NFS3_FHSIZE); 52 size = ntohl(*p++); 53 if (size > NFS3_FHSIZE) 54 return NULL; 55 56 memcpy(&fhp->fh_handle.fh_base, p, size); 57 fhp->fh_handle.fh_size = size; 58 return p + XDR_QUADLEN(size); 59 } 60 61 /* Helper function for NFSv3 ACL code */ 62 __be32 *nfs3svc_decode_fh(__be32 *p, struct svc_fh *fhp) 63 { 64 return decode_fh(p, fhp); 65 } 66 67 static __be32 * 68 encode_fh(__be32 *p, struct svc_fh *fhp) 69 { 70 unsigned int size = fhp->fh_handle.fh_size; 71 *p++ = htonl(size); 72 if (size) p[XDR_QUADLEN(size)-1]=0; 73 memcpy(p, &fhp->fh_handle.fh_base, size); 74 return p + XDR_QUADLEN(size); 75 } 76 77 /* 78 * Decode a file name and make sure that the path contains 79 * no slashes or null bytes. 80 */ 81 static __be32 * 82 decode_filename(__be32 *p, char **namp, unsigned int *lenp) 83 { 84 char *name; 85 unsigned int i; 86 87 if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS3_MAXNAMLEN)) != NULL) { 88 for (i = 0, name = *namp; i < *lenp; i++, name++) { 89 if (*name == '\0' || *name == '/') 90 return NULL; 91 } 92 } 93 94 return p; 95 } 96 97 static __be32 * 98 decode_sattr3(__be32 *p, struct iattr *iap) 99 { 100 u32 tmp; 101 102 iap->ia_valid = 0; 103 104 if (*p++) { 105 iap->ia_valid |= ATTR_MODE; 106 iap->ia_mode = ntohl(*p++); 107 } 108 if (*p++) { 109 iap->ia_uid = make_kuid(&init_user_ns, ntohl(*p++)); 110 if (uid_valid(iap->ia_uid)) 111 iap->ia_valid |= ATTR_UID; 112 } 113 if (*p++) { 114 iap->ia_gid = make_kgid(&init_user_ns, ntohl(*p++)); 115 if (gid_valid(iap->ia_gid)) 116 iap->ia_valid |= ATTR_GID; 117 } 118 if (*p++) { 119 u64 newsize; 120 121 iap->ia_valid |= ATTR_SIZE; 122 p = xdr_decode_hyper(p, &newsize); 123 iap->ia_size = min_t(u64, newsize, NFS_OFFSET_MAX); 124 } 125 if ((tmp = ntohl(*p++)) == 1) { /* set to server time */ 126 iap->ia_valid |= ATTR_ATIME; 127 } else if (tmp == 2) { /* set to client time */ 128 iap->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET; 129 iap->ia_atime.tv_sec = ntohl(*p++); 130 iap->ia_atime.tv_nsec = ntohl(*p++); 131 } 132 if ((tmp = ntohl(*p++)) == 1) { /* set to server time */ 133 iap->ia_valid |= ATTR_MTIME; 134 } else if (tmp == 2) { /* set to client time */ 135 iap->ia_valid |= ATTR_MTIME | ATTR_MTIME_SET; 136 iap->ia_mtime.tv_sec = ntohl(*p++); 137 iap->ia_mtime.tv_nsec = ntohl(*p++); 138 } 139 return p; 140 } 141 142 static __be32 *encode_fsid(__be32 *p, struct svc_fh *fhp) 143 { 144 u64 f; 145 switch(fsid_source(fhp)) { 146 default: 147 case FSIDSOURCE_DEV: 148 p = xdr_encode_hyper(p, (u64)huge_encode_dev 149 (fhp->fh_dentry->d_sb->s_dev)); 150 break; 151 case FSIDSOURCE_FSID: 152 p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid); 153 break; 154 case FSIDSOURCE_UUID: 155 f = ((u64*)fhp->fh_export->ex_uuid)[0]; 156 f ^= ((u64*)fhp->fh_export->ex_uuid)[1]; 157 p = xdr_encode_hyper(p, f); 158 break; 159 } 160 return p; 161 } 162 163 static __be32 * 164 encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp, 165 struct kstat *stat) 166 { 167 *p++ = htonl(nfs3_ftypes[(stat->mode & S_IFMT) >> 12]); 168 *p++ = htonl((u32) (stat->mode & S_IALLUGO)); 169 *p++ = htonl((u32) stat->nlink); 170 *p++ = htonl((u32) from_kuid(&init_user_ns, stat->uid)); 171 *p++ = htonl((u32) from_kgid(&init_user_ns, stat->gid)); 172 if (S_ISLNK(stat->mode) && stat->size > NFS3_MAXPATHLEN) { 173 p = xdr_encode_hyper(p, (u64) NFS3_MAXPATHLEN); 174 } else { 175 p = xdr_encode_hyper(p, (u64) stat->size); 176 } 177 p = xdr_encode_hyper(p, ((u64)stat->blocks) << 9); 178 *p++ = htonl((u32) MAJOR(stat->rdev)); 179 *p++ = htonl((u32) MINOR(stat->rdev)); 180 p = encode_fsid(p, fhp); 181 p = xdr_encode_hyper(p, stat->ino); 182 p = encode_time3(p, &stat->atime); 183 p = encode_time3(p, &stat->mtime); 184 p = encode_time3(p, &stat->ctime); 185 186 return p; 187 } 188 189 static __be32 * 190 encode_saved_post_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 191 { 192 /* Attributes to follow */ 193 *p++ = xdr_one; 194 return encode_fattr3(rqstp, p, fhp, &fhp->fh_post_attr); 195 } 196 197 /* 198 * Encode post-operation attributes. 199 * The inode may be NULL if the call failed because of a stale file 200 * handle. In this case, no attributes are returned. 201 */ 202 static __be32 * 203 encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 204 { 205 struct dentry *dentry = fhp->fh_dentry; 206 if (dentry && d_really_is_positive(dentry)) { 207 __be32 err; 208 struct kstat stat; 209 210 err = fh_getattr(fhp, &stat); 211 if (!err) { 212 *p++ = xdr_one; /* attributes follow */ 213 lease_get_mtime(d_inode(dentry), &stat.mtime); 214 return encode_fattr3(rqstp, p, fhp, &stat); 215 } 216 } 217 *p++ = xdr_zero; 218 return p; 219 } 220 221 /* Helper for NFSv3 ACLs */ 222 __be32 * 223 nfs3svc_encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 224 { 225 return encode_post_op_attr(rqstp, p, fhp); 226 } 227 228 /* 229 * Enocde weak cache consistency data 230 */ 231 static __be32 * 232 encode_wcc_data(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 233 { 234 struct dentry *dentry = fhp->fh_dentry; 235 236 if (dentry && d_really_is_positive(dentry) && fhp->fh_post_saved) { 237 if (fhp->fh_pre_saved) { 238 *p++ = xdr_one; 239 p = xdr_encode_hyper(p, (u64) fhp->fh_pre_size); 240 p = encode_time3(p, &fhp->fh_pre_mtime); 241 p = encode_time3(p, &fhp->fh_pre_ctime); 242 } else { 243 *p++ = xdr_zero; 244 } 245 return encode_saved_post_attr(rqstp, p, fhp); 246 } 247 /* no pre- or post-attrs */ 248 *p++ = xdr_zero; 249 return encode_post_op_attr(rqstp, p, fhp); 250 } 251 252 /* 253 * Fill in the post_op attr for the wcc data 254 */ 255 void fill_post_wcc(struct svc_fh *fhp) 256 { 257 __be32 err; 258 259 if (fhp->fh_post_saved) 260 printk("nfsd: inode locked twice during operation.\n"); 261 262 err = fh_getattr(fhp, &fhp->fh_post_attr); 263 fhp->fh_post_change = nfsd4_change_attribute(d_inode(fhp->fh_dentry)); 264 if (err) { 265 fhp->fh_post_saved = false; 266 /* Grab the ctime anyway - set_change_info might use it */ 267 fhp->fh_post_attr.ctime = d_inode(fhp->fh_dentry)->i_ctime; 268 } else 269 fhp->fh_post_saved = true; 270 } 271 272 /* 273 * XDR decode functions 274 */ 275 int 276 nfs3svc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p) 277 { 278 struct nfsd_fhandle *args = rqstp->rq_argp; 279 280 p = decode_fh(p, &args->fh); 281 if (!p) 282 return 0; 283 return xdr_argsize_check(rqstp, p); 284 } 285 286 int 287 nfs3svc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p) 288 { 289 struct nfsd3_sattrargs *args = rqstp->rq_argp; 290 291 p = decode_fh(p, &args->fh); 292 if (!p) 293 return 0; 294 p = decode_sattr3(p, &args->attrs); 295 296 if ((args->check_guard = ntohl(*p++)) != 0) { 297 struct timespec time; 298 p = decode_time3(p, &time); 299 args->guardtime = time.tv_sec; 300 } 301 302 return xdr_argsize_check(rqstp, p); 303 } 304 305 int 306 nfs3svc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p) 307 { 308 struct nfsd3_diropargs *args = rqstp->rq_argp; 309 310 if (!(p = decode_fh(p, &args->fh)) 311 || !(p = decode_filename(p, &args->name, &args->len))) 312 return 0; 313 314 return xdr_argsize_check(rqstp, p); 315 } 316 317 int 318 nfs3svc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p) 319 { 320 struct nfsd3_accessargs *args = rqstp->rq_argp; 321 322 p = decode_fh(p, &args->fh); 323 if (!p) 324 return 0; 325 args->access = ntohl(*p++); 326 327 return xdr_argsize_check(rqstp, p); 328 } 329 330 int 331 nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p) 332 { 333 struct nfsd3_readargs *args = rqstp->rq_argp; 334 unsigned int len; 335 int v; 336 u32 max_blocksize = svc_max_payload(rqstp); 337 338 p = decode_fh(p, &args->fh); 339 if (!p) 340 return 0; 341 p = xdr_decode_hyper(p, &args->offset); 342 343 args->count = ntohl(*p++); 344 len = min(args->count, max_blocksize); 345 346 /* set up the kvec */ 347 v=0; 348 while (len > 0) { 349 struct page *p = *(rqstp->rq_next_page++); 350 351 rqstp->rq_vec[v].iov_base = page_address(p); 352 rqstp->rq_vec[v].iov_len = min_t(unsigned int, len, PAGE_SIZE); 353 len -= rqstp->rq_vec[v].iov_len; 354 v++; 355 } 356 args->vlen = v; 357 return xdr_argsize_check(rqstp, p); 358 } 359 360 int 361 nfs3svc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p) 362 { 363 struct nfsd3_writeargs *args = rqstp->rq_argp; 364 unsigned int len, v, hdr, dlen; 365 u32 max_blocksize = svc_max_payload(rqstp); 366 struct kvec *head = rqstp->rq_arg.head; 367 struct kvec *tail = rqstp->rq_arg.tail; 368 369 p = decode_fh(p, &args->fh); 370 if (!p) 371 return 0; 372 p = xdr_decode_hyper(p, &args->offset); 373 374 args->count = ntohl(*p++); 375 args->stable = ntohl(*p++); 376 len = args->len = ntohl(*p++); 377 if ((void *)p > head->iov_base + head->iov_len) 378 return 0; 379 /* 380 * The count must equal the amount of data passed. 381 */ 382 if (args->count != args->len) 383 return 0; 384 385 /* 386 * Check to make sure that we got the right number of 387 * bytes. 388 */ 389 hdr = (void*)p - head->iov_base; 390 dlen = head->iov_len + rqstp->rq_arg.page_len + tail->iov_len - hdr; 391 /* 392 * Round the length of the data which was specified up to 393 * the next multiple of XDR units and then compare that 394 * against the length which was actually received. 395 * Note that when RPCSEC/GSS (for example) is used, the 396 * data buffer can be padded so dlen might be larger 397 * than required. It must never be smaller. 398 */ 399 if (dlen < XDR_QUADLEN(len)*4) 400 return 0; 401 402 if (args->count > max_blocksize) { 403 args->count = max_blocksize; 404 len = args->len = max_blocksize; 405 } 406 rqstp->rq_vec[0].iov_base = (void*)p; 407 rqstp->rq_vec[0].iov_len = head->iov_len - hdr; 408 v = 0; 409 while (len > rqstp->rq_vec[v].iov_len) { 410 len -= rqstp->rq_vec[v].iov_len; 411 v++; 412 rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_pages[v]); 413 rqstp->rq_vec[v].iov_len = PAGE_SIZE; 414 } 415 rqstp->rq_vec[v].iov_len = len; 416 args->vlen = v + 1; 417 return 1; 418 } 419 420 int 421 nfs3svc_decode_createargs(struct svc_rqst *rqstp, __be32 *p) 422 { 423 struct nfsd3_createargs *args = rqstp->rq_argp; 424 425 if (!(p = decode_fh(p, &args->fh)) 426 || !(p = decode_filename(p, &args->name, &args->len))) 427 return 0; 428 429 switch (args->createmode = ntohl(*p++)) { 430 case NFS3_CREATE_UNCHECKED: 431 case NFS3_CREATE_GUARDED: 432 p = decode_sattr3(p, &args->attrs); 433 break; 434 case NFS3_CREATE_EXCLUSIVE: 435 args->verf = p; 436 p += 2; 437 break; 438 default: 439 return 0; 440 } 441 442 return xdr_argsize_check(rqstp, p); 443 } 444 445 int 446 nfs3svc_decode_mkdirargs(struct svc_rqst *rqstp, __be32 *p) 447 { 448 struct nfsd3_createargs *args = rqstp->rq_argp; 449 450 if (!(p = decode_fh(p, &args->fh)) || 451 !(p = decode_filename(p, &args->name, &args->len))) 452 return 0; 453 p = decode_sattr3(p, &args->attrs); 454 455 return xdr_argsize_check(rqstp, p); 456 } 457 458 int 459 nfs3svc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p) 460 { 461 struct nfsd3_symlinkargs *args = rqstp->rq_argp; 462 unsigned int len, avail; 463 char *old, *new; 464 struct kvec *vec; 465 466 if (!(p = decode_fh(p, &args->ffh)) || 467 !(p = decode_filename(p, &args->fname, &args->flen)) 468 ) 469 return 0; 470 p = decode_sattr3(p, &args->attrs); 471 472 /* now decode the pathname, which might be larger than the first page. 473 * As we have to check for nul's anyway, we copy it into a new page 474 * This page appears in the rq_res.pages list, but as pages_len is always 475 * 0, it won't get in the way 476 */ 477 len = ntohl(*p++); 478 if (len == 0 || len > NFS3_MAXPATHLEN || len >= PAGE_SIZE) 479 return 0; 480 args->tname = new = page_address(*(rqstp->rq_next_page++)); 481 args->tlen = len; 482 /* first copy and check from the first page */ 483 old = (char*)p; 484 vec = &rqstp->rq_arg.head[0]; 485 if ((void *)old > vec->iov_base + vec->iov_len) 486 return 0; 487 avail = vec->iov_len - (old - (char*)vec->iov_base); 488 while (len && avail && *old) { 489 *new++ = *old++; 490 len--; 491 avail--; 492 } 493 /* now copy next page if there is one */ 494 if (len && !avail && rqstp->rq_arg.page_len) { 495 avail = min_t(unsigned int, rqstp->rq_arg.page_len, PAGE_SIZE); 496 old = page_address(rqstp->rq_arg.pages[0]); 497 } 498 while (len && avail && *old) { 499 *new++ = *old++; 500 len--; 501 avail--; 502 } 503 *new = '\0'; 504 if (len) 505 return 0; 506 507 return 1; 508 } 509 510 int 511 nfs3svc_decode_mknodargs(struct svc_rqst *rqstp, __be32 *p) 512 { 513 struct nfsd3_mknodargs *args = rqstp->rq_argp; 514 515 if (!(p = decode_fh(p, &args->fh)) 516 || !(p = decode_filename(p, &args->name, &args->len))) 517 return 0; 518 519 args->ftype = ntohl(*p++); 520 521 if (args->ftype == NF3BLK || args->ftype == NF3CHR 522 || args->ftype == NF3SOCK || args->ftype == NF3FIFO) 523 p = decode_sattr3(p, &args->attrs); 524 525 if (args->ftype == NF3BLK || args->ftype == NF3CHR) { 526 args->major = ntohl(*p++); 527 args->minor = ntohl(*p++); 528 } 529 530 return xdr_argsize_check(rqstp, p); 531 } 532 533 int 534 nfs3svc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p) 535 { 536 struct nfsd3_renameargs *args = rqstp->rq_argp; 537 538 if (!(p = decode_fh(p, &args->ffh)) 539 || !(p = decode_filename(p, &args->fname, &args->flen)) 540 || !(p = decode_fh(p, &args->tfh)) 541 || !(p = decode_filename(p, &args->tname, &args->tlen))) 542 return 0; 543 544 return xdr_argsize_check(rqstp, p); 545 } 546 547 int 548 nfs3svc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p) 549 { 550 struct nfsd3_readlinkargs *args = rqstp->rq_argp; 551 552 p = decode_fh(p, &args->fh); 553 if (!p) 554 return 0; 555 args->buffer = page_address(*(rqstp->rq_next_page++)); 556 557 return xdr_argsize_check(rqstp, p); 558 } 559 560 int 561 nfs3svc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p) 562 { 563 struct nfsd3_linkargs *args = rqstp->rq_argp; 564 565 if (!(p = decode_fh(p, &args->ffh)) 566 || !(p = decode_fh(p, &args->tfh)) 567 || !(p = decode_filename(p, &args->tname, &args->tlen))) 568 return 0; 569 570 return xdr_argsize_check(rqstp, p); 571 } 572 573 int 574 nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p) 575 { 576 struct nfsd3_readdirargs *args = rqstp->rq_argp; 577 p = decode_fh(p, &args->fh); 578 if (!p) 579 return 0; 580 p = xdr_decode_hyper(p, &args->cookie); 581 args->verf = p; p += 2; 582 args->dircount = ~0; 583 args->count = ntohl(*p++); 584 args->count = min_t(u32, args->count, PAGE_SIZE); 585 args->buffer = page_address(*(rqstp->rq_next_page++)); 586 587 return xdr_argsize_check(rqstp, p); 588 } 589 590 int 591 nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p) 592 { 593 struct nfsd3_readdirargs *args = rqstp->rq_argp; 594 int len; 595 u32 max_blocksize = svc_max_payload(rqstp); 596 597 p = decode_fh(p, &args->fh); 598 if (!p) 599 return 0; 600 p = xdr_decode_hyper(p, &args->cookie); 601 args->verf = p; p += 2; 602 args->dircount = ntohl(*p++); 603 args->count = ntohl(*p++); 604 605 len = args->count = min(args->count, max_blocksize); 606 while (len > 0) { 607 struct page *p = *(rqstp->rq_next_page++); 608 if (!args->buffer) 609 args->buffer = page_address(p); 610 len -= PAGE_SIZE; 611 } 612 613 return xdr_argsize_check(rqstp, p); 614 } 615 616 int 617 nfs3svc_decode_commitargs(struct svc_rqst *rqstp, __be32 *p) 618 { 619 struct nfsd3_commitargs *args = rqstp->rq_argp; 620 p = decode_fh(p, &args->fh); 621 if (!p) 622 return 0; 623 p = xdr_decode_hyper(p, &args->offset); 624 args->count = ntohl(*p++); 625 626 return xdr_argsize_check(rqstp, p); 627 } 628 629 /* 630 * XDR encode functions 631 */ 632 /* 633 * There must be an encoding function for void results so svc_process 634 * will work properly. 635 */ 636 int 637 nfs3svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p) 638 { 639 return xdr_ressize_check(rqstp, p); 640 } 641 642 /* GETATTR */ 643 int 644 nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p) 645 { 646 struct nfsd3_attrstat *resp = rqstp->rq_resp; 647 648 if (resp->status == 0) { 649 lease_get_mtime(d_inode(resp->fh.fh_dentry), 650 &resp->stat.mtime); 651 p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat); 652 } 653 return xdr_ressize_check(rqstp, p); 654 } 655 656 /* SETATTR, REMOVE, RMDIR */ 657 int 658 nfs3svc_encode_wccstat(struct svc_rqst *rqstp, __be32 *p) 659 { 660 struct nfsd3_attrstat *resp = rqstp->rq_resp; 661 662 p = encode_wcc_data(rqstp, p, &resp->fh); 663 return xdr_ressize_check(rqstp, p); 664 } 665 666 /* LOOKUP */ 667 int 668 nfs3svc_encode_diropres(struct svc_rqst *rqstp, __be32 *p) 669 { 670 struct nfsd3_diropres *resp = rqstp->rq_resp; 671 672 if (resp->status == 0) { 673 p = encode_fh(p, &resp->fh); 674 p = encode_post_op_attr(rqstp, p, &resp->fh); 675 } 676 p = encode_post_op_attr(rqstp, p, &resp->dirfh); 677 return xdr_ressize_check(rqstp, p); 678 } 679 680 /* ACCESS */ 681 int 682 nfs3svc_encode_accessres(struct svc_rqst *rqstp, __be32 *p) 683 { 684 struct nfsd3_accessres *resp = rqstp->rq_resp; 685 686 p = encode_post_op_attr(rqstp, p, &resp->fh); 687 if (resp->status == 0) 688 *p++ = htonl(resp->access); 689 return xdr_ressize_check(rqstp, p); 690 } 691 692 /* READLINK */ 693 int 694 nfs3svc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p) 695 { 696 struct nfsd3_readlinkres *resp = rqstp->rq_resp; 697 698 p = encode_post_op_attr(rqstp, p, &resp->fh); 699 if (resp->status == 0) { 700 *p++ = htonl(resp->len); 701 xdr_ressize_check(rqstp, p); 702 rqstp->rq_res.page_len = resp->len; 703 if (resp->len & 3) { 704 /* need to pad the tail */ 705 rqstp->rq_res.tail[0].iov_base = p; 706 *p = 0; 707 rqstp->rq_res.tail[0].iov_len = 4 - (resp->len&3); 708 } 709 return 1; 710 } else 711 return xdr_ressize_check(rqstp, p); 712 } 713 714 /* READ */ 715 int 716 nfs3svc_encode_readres(struct svc_rqst *rqstp, __be32 *p) 717 { 718 struct nfsd3_readres *resp = rqstp->rq_resp; 719 720 p = encode_post_op_attr(rqstp, p, &resp->fh); 721 if (resp->status == 0) { 722 *p++ = htonl(resp->count); 723 *p++ = htonl(resp->eof); 724 *p++ = htonl(resp->count); /* xdr opaque count */ 725 xdr_ressize_check(rqstp, p); 726 /* now update rqstp->rq_res to reflect data as well */ 727 rqstp->rq_res.page_len = resp->count; 728 if (resp->count & 3) { 729 /* need to pad the tail */ 730 rqstp->rq_res.tail[0].iov_base = p; 731 *p = 0; 732 rqstp->rq_res.tail[0].iov_len = 4 - (resp->count & 3); 733 } 734 return 1; 735 } else 736 return xdr_ressize_check(rqstp, p); 737 } 738 739 /* WRITE */ 740 int 741 nfs3svc_encode_writeres(struct svc_rqst *rqstp, __be32 *p) 742 { 743 struct nfsd3_writeres *resp = rqstp->rq_resp; 744 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 745 746 p = encode_wcc_data(rqstp, p, &resp->fh); 747 if (resp->status == 0) { 748 *p++ = htonl(resp->count); 749 *p++ = htonl(resp->committed); 750 *p++ = htonl(nn->nfssvc_boot.tv_sec); 751 *p++ = htonl(nn->nfssvc_boot.tv_usec); 752 } 753 return xdr_ressize_check(rqstp, p); 754 } 755 756 /* CREATE, MKDIR, SYMLINK, MKNOD */ 757 int 758 nfs3svc_encode_createres(struct svc_rqst *rqstp, __be32 *p) 759 { 760 struct nfsd3_diropres *resp = rqstp->rq_resp; 761 762 if (resp->status == 0) { 763 *p++ = xdr_one; 764 p = encode_fh(p, &resp->fh); 765 p = encode_post_op_attr(rqstp, p, &resp->fh); 766 } 767 p = encode_wcc_data(rqstp, p, &resp->dirfh); 768 return xdr_ressize_check(rqstp, p); 769 } 770 771 /* RENAME */ 772 int 773 nfs3svc_encode_renameres(struct svc_rqst *rqstp, __be32 *p) 774 { 775 struct nfsd3_renameres *resp = rqstp->rq_resp; 776 777 p = encode_wcc_data(rqstp, p, &resp->ffh); 778 p = encode_wcc_data(rqstp, p, &resp->tfh); 779 return xdr_ressize_check(rqstp, p); 780 } 781 782 /* LINK */ 783 int 784 nfs3svc_encode_linkres(struct svc_rqst *rqstp, __be32 *p) 785 { 786 struct nfsd3_linkres *resp = rqstp->rq_resp; 787 788 p = encode_post_op_attr(rqstp, p, &resp->fh); 789 p = encode_wcc_data(rqstp, p, &resp->tfh); 790 return xdr_ressize_check(rqstp, p); 791 } 792 793 /* READDIR */ 794 int 795 nfs3svc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p) 796 { 797 struct nfsd3_readdirres *resp = rqstp->rq_resp; 798 799 p = encode_post_op_attr(rqstp, p, &resp->fh); 800 801 if (resp->status == 0) { 802 /* stupid readdir cookie */ 803 memcpy(p, resp->verf, 8); p += 2; 804 xdr_ressize_check(rqstp, p); 805 if (rqstp->rq_res.head[0].iov_len + (2<<2) > PAGE_SIZE) 806 return 1; /*No room for trailer */ 807 rqstp->rq_res.page_len = (resp->count) << 2; 808 809 /* add the 'tail' to the end of the 'head' page - page 0. */ 810 rqstp->rq_res.tail[0].iov_base = p; 811 *p++ = 0; /* no more entries */ 812 *p++ = htonl(resp->common.err == nfserr_eof); 813 rqstp->rq_res.tail[0].iov_len = 2<<2; 814 return 1; 815 } else 816 return xdr_ressize_check(rqstp, p); 817 } 818 819 static __be32 * 820 encode_entry_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name, 821 int namlen, u64 ino) 822 { 823 *p++ = xdr_one; /* mark entry present */ 824 p = xdr_encode_hyper(p, ino); /* file id */ 825 p = xdr_encode_array(p, name, namlen);/* name length & name */ 826 827 cd->offset = p; /* remember pointer */ 828 p = xdr_encode_hyper(p, NFS_OFFSET_MAX);/* offset of next entry */ 829 830 return p; 831 } 832 833 static __be32 834 compose_entry_fh(struct nfsd3_readdirres *cd, struct svc_fh *fhp, 835 const char *name, int namlen, u64 ino) 836 { 837 struct svc_export *exp; 838 struct dentry *dparent, *dchild; 839 __be32 rv = nfserr_noent; 840 841 dparent = cd->fh.fh_dentry; 842 exp = cd->fh.fh_export; 843 844 if (isdotent(name, namlen)) { 845 if (namlen == 2) { 846 dchild = dget_parent(dparent); 847 /* filesystem root - cannot return filehandle for ".." */ 848 if (dchild == dparent) 849 goto out; 850 } else 851 dchild = dget(dparent); 852 } else 853 dchild = lookup_one_len_unlocked(name, dparent, namlen); 854 if (IS_ERR(dchild)) 855 return rv; 856 if (d_mountpoint(dchild)) 857 goto out; 858 if (d_really_is_negative(dchild)) 859 goto out; 860 if (dchild->d_inode->i_ino != ino) 861 goto out; 862 rv = fh_compose(fhp, exp, dchild, &cd->fh); 863 out: 864 dput(dchild); 865 return rv; 866 } 867 868 static __be32 *encode_entryplus_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name, int namlen, u64 ino) 869 { 870 struct svc_fh *fh = &cd->scratch; 871 __be32 err; 872 873 fh_init(fh, NFS3_FHSIZE); 874 err = compose_entry_fh(cd, fh, name, namlen, ino); 875 if (err) { 876 *p++ = 0; 877 *p++ = 0; 878 goto out; 879 } 880 p = encode_post_op_attr(cd->rqstp, p, fh); 881 *p++ = xdr_one; /* yes, a file handle follows */ 882 p = encode_fh(p, fh); 883 out: 884 fh_put(fh); 885 return p; 886 } 887 888 /* 889 * Encode a directory entry. This one works for both normal readdir 890 * and readdirplus. 891 * The normal readdir reply requires 2 (fileid) + 1 (stringlen) 892 * + string + 2 (cookie) + 1 (next) words, i.e. 6 + strlen. 893 * 894 * The readdirplus baggage is 1+21 words for post_op_attr, plus the 895 * file handle. 896 */ 897 898 #define NFS3_ENTRY_BAGGAGE (2 + 1 + 2 + 1) 899 #define NFS3_ENTRYPLUS_BAGGAGE (1 + 21 + 1 + (NFS3_FHSIZE >> 2)) 900 static int 901 encode_entry(struct readdir_cd *ccd, const char *name, int namlen, 902 loff_t offset, u64 ino, unsigned int d_type, int plus) 903 { 904 struct nfsd3_readdirres *cd = container_of(ccd, struct nfsd3_readdirres, 905 common); 906 __be32 *p = cd->buffer; 907 caddr_t curr_page_addr = NULL; 908 struct page ** page; 909 int slen; /* string (name) length */ 910 int elen; /* estimated entry length in words */ 911 int num_entry_words = 0; /* actual number of words */ 912 913 if (cd->offset) { 914 u64 offset64 = offset; 915 916 if (unlikely(cd->offset1)) { 917 /* we ended up with offset on a page boundary */ 918 *cd->offset = htonl(offset64 >> 32); 919 *cd->offset1 = htonl(offset64 & 0xffffffff); 920 cd->offset1 = NULL; 921 } else { 922 xdr_encode_hyper(cd->offset, offset64); 923 } 924 } 925 926 /* 927 dprintk("encode_entry(%.*s @%ld%s)\n", 928 namlen, name, (long) offset, plus? " plus" : ""); 929 */ 930 931 /* truncate filename if too long */ 932 namlen = min(namlen, NFS3_MAXNAMLEN); 933 934 slen = XDR_QUADLEN(namlen); 935 elen = slen + NFS3_ENTRY_BAGGAGE 936 + (plus? NFS3_ENTRYPLUS_BAGGAGE : 0); 937 938 if (cd->buflen < elen) { 939 cd->common.err = nfserr_toosmall; 940 return -EINVAL; 941 } 942 943 /* determine which page in rq_respages[] we are currently filling */ 944 for (page = cd->rqstp->rq_respages + 1; 945 page < cd->rqstp->rq_next_page; page++) { 946 curr_page_addr = page_address(*page); 947 948 if (((caddr_t)cd->buffer >= curr_page_addr) && 949 ((caddr_t)cd->buffer < curr_page_addr + PAGE_SIZE)) 950 break; 951 } 952 953 if ((caddr_t)(cd->buffer + elen) < (curr_page_addr + PAGE_SIZE)) { 954 /* encode entry in current page */ 955 956 p = encode_entry_baggage(cd, p, name, namlen, ino); 957 958 if (plus) 959 p = encode_entryplus_baggage(cd, p, name, namlen, ino); 960 num_entry_words = p - cd->buffer; 961 } else if (*(page+1) != NULL) { 962 /* temporarily encode entry into next page, then move back to 963 * current and next page in rq_respages[] */ 964 __be32 *p1, *tmp; 965 int len1, len2; 966 967 /* grab next page for temporary storage of entry */ 968 p1 = tmp = page_address(*(page+1)); 969 970 p1 = encode_entry_baggage(cd, p1, name, namlen, ino); 971 972 if (plus) 973 p1 = encode_entryplus_baggage(cd, p1, name, namlen, ino); 974 975 /* determine entry word length and lengths to go in pages */ 976 num_entry_words = p1 - tmp; 977 len1 = curr_page_addr + PAGE_SIZE - (caddr_t)cd->buffer; 978 if ((num_entry_words << 2) < len1) { 979 /* the actual number of words in the entry is less 980 * than elen and can still fit in the current page 981 */ 982 memmove(p, tmp, num_entry_words << 2); 983 p += num_entry_words; 984 985 /* update offset */ 986 cd->offset = cd->buffer + (cd->offset - tmp); 987 } else { 988 unsigned int offset_r = (cd->offset - tmp) << 2; 989 990 /* update pointer to offset location. 991 * This is a 64bit quantity, so we need to 992 * deal with 3 cases: 993 * - entirely in first page 994 * - entirely in second page 995 * - 4 bytes in each page 996 */ 997 if (offset_r + 8 <= len1) { 998 cd->offset = p + (cd->offset - tmp); 999 } else if (offset_r >= len1) { 1000 cd->offset -= len1 >> 2; 1001 } else { 1002 /* sitting on the fence */ 1003 BUG_ON(offset_r != len1 - 4); 1004 cd->offset = p + (cd->offset - tmp); 1005 cd->offset1 = tmp; 1006 } 1007 1008 len2 = (num_entry_words << 2) - len1; 1009 1010 /* move from temp page to current and next pages */ 1011 memmove(p, tmp, len1); 1012 memmove(tmp, (caddr_t)tmp+len1, len2); 1013 1014 p = tmp + (len2 >> 2); 1015 } 1016 } 1017 else { 1018 cd->common.err = nfserr_toosmall; 1019 return -EINVAL; 1020 } 1021 1022 cd->buflen -= num_entry_words; 1023 cd->buffer = p; 1024 cd->common.err = nfs_ok; 1025 return 0; 1026 1027 } 1028 1029 int 1030 nfs3svc_encode_entry(void *cd, const char *name, 1031 int namlen, loff_t offset, u64 ino, unsigned int d_type) 1032 { 1033 return encode_entry(cd, name, namlen, offset, ino, d_type, 0); 1034 } 1035 1036 int 1037 nfs3svc_encode_entry_plus(void *cd, const char *name, 1038 int namlen, loff_t offset, u64 ino, 1039 unsigned int d_type) 1040 { 1041 return encode_entry(cd, name, namlen, offset, ino, d_type, 1); 1042 } 1043 1044 /* FSSTAT */ 1045 int 1046 nfs3svc_encode_fsstatres(struct svc_rqst *rqstp, __be32 *p) 1047 { 1048 struct nfsd3_fsstatres *resp = rqstp->rq_resp; 1049 struct kstatfs *s = &resp->stats; 1050 u64 bs = s->f_bsize; 1051 1052 *p++ = xdr_zero; /* no post_op_attr */ 1053 1054 if (resp->status == 0) { 1055 p = xdr_encode_hyper(p, bs * s->f_blocks); /* total bytes */ 1056 p = xdr_encode_hyper(p, bs * s->f_bfree); /* free bytes */ 1057 p = xdr_encode_hyper(p, bs * s->f_bavail); /* user available bytes */ 1058 p = xdr_encode_hyper(p, s->f_files); /* total inodes */ 1059 p = xdr_encode_hyper(p, s->f_ffree); /* free inodes */ 1060 p = xdr_encode_hyper(p, s->f_ffree); /* user available inodes */ 1061 *p++ = htonl(resp->invarsec); /* mean unchanged time */ 1062 } 1063 return xdr_ressize_check(rqstp, p); 1064 } 1065 1066 /* FSINFO */ 1067 int 1068 nfs3svc_encode_fsinfores(struct svc_rqst *rqstp, __be32 *p) 1069 { 1070 struct nfsd3_fsinfores *resp = rqstp->rq_resp; 1071 1072 *p++ = xdr_zero; /* no post_op_attr */ 1073 1074 if (resp->status == 0) { 1075 *p++ = htonl(resp->f_rtmax); 1076 *p++ = htonl(resp->f_rtpref); 1077 *p++ = htonl(resp->f_rtmult); 1078 *p++ = htonl(resp->f_wtmax); 1079 *p++ = htonl(resp->f_wtpref); 1080 *p++ = htonl(resp->f_wtmult); 1081 *p++ = htonl(resp->f_dtpref); 1082 p = xdr_encode_hyper(p, resp->f_maxfilesize); 1083 *p++ = xdr_one; 1084 *p++ = xdr_zero; 1085 *p++ = htonl(resp->f_properties); 1086 } 1087 1088 return xdr_ressize_check(rqstp, p); 1089 } 1090 1091 /* PATHCONF */ 1092 int 1093 nfs3svc_encode_pathconfres(struct svc_rqst *rqstp, __be32 *p) 1094 { 1095 struct nfsd3_pathconfres *resp = rqstp->rq_resp; 1096 1097 *p++ = xdr_zero; /* no post_op_attr */ 1098 1099 if (resp->status == 0) { 1100 *p++ = htonl(resp->p_link_max); 1101 *p++ = htonl(resp->p_name_max); 1102 *p++ = htonl(resp->p_no_trunc); 1103 *p++ = htonl(resp->p_chown_restricted); 1104 *p++ = htonl(resp->p_case_insensitive); 1105 *p++ = htonl(resp->p_case_preserving); 1106 } 1107 1108 return xdr_ressize_check(rqstp, p); 1109 } 1110 1111 /* COMMIT */ 1112 int 1113 nfs3svc_encode_commitres(struct svc_rqst *rqstp, __be32 *p) 1114 { 1115 struct nfsd3_commitres *resp = rqstp->rq_resp; 1116 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 1117 1118 p = encode_wcc_data(rqstp, p, &resp->fh); 1119 /* Write verifier */ 1120 if (resp->status == 0) { 1121 *p++ = htonl(nn->nfssvc_boot.tv_sec); 1122 *p++ = htonl(nn->nfssvc_boot.tv_usec); 1123 } 1124 return xdr_ressize_check(rqstp, p); 1125 } 1126 1127 /* 1128 * XDR release functions 1129 */ 1130 void 1131 nfs3svc_release_fhandle(struct svc_rqst *rqstp) 1132 { 1133 struct nfsd3_attrstat *resp = rqstp->rq_resp; 1134 1135 fh_put(&resp->fh); 1136 } 1137 1138 void 1139 nfs3svc_release_fhandle2(struct svc_rqst *rqstp) 1140 { 1141 struct nfsd3_fhandle_pair *resp = rqstp->rq_resp; 1142 1143 fh_put(&resp->fh1); 1144 fh_put(&resp->fh2); 1145 } 1146