1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * XDR support for nfsd/protocol version 3. 4 * 5 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de> 6 * 7 * 2003-08-09 Jamie Lokier: Use htonl() for nanoseconds, not htons()! 8 */ 9 10 #include <linux/namei.h> 11 #include <linux/sunrpc/svc_xprt.h> 12 #include "xdr3.h" 13 #include "auth.h" 14 #include "netns.h" 15 #include "vfs.h" 16 17 #define NFSDDBG_FACILITY NFSDDBG_XDR 18 19 20 /* 21 * Mapping of S_IF* types to NFS file types 22 */ 23 static u32 nfs3_ftypes[] = { 24 NF3NON, NF3FIFO, NF3CHR, NF3BAD, 25 NF3DIR, NF3BAD, NF3BLK, NF3BAD, 26 NF3REG, NF3BAD, NF3LNK, NF3BAD, 27 NF3SOCK, NF3BAD, NF3LNK, NF3BAD, 28 }; 29 30 /* 31 * XDR functions for basic NFS types 32 */ 33 static __be32 * 34 encode_time3(__be32 *p, struct timespec *time) 35 { 36 *p++ = htonl((u32) time->tv_sec); *p++ = htonl(time->tv_nsec); 37 return p; 38 } 39 40 static __be32 * 41 decode_time3(__be32 *p, struct timespec *time) 42 { 43 time->tv_sec = ntohl(*p++); 44 time->tv_nsec = ntohl(*p++); 45 return p; 46 } 47 48 static __be32 * 49 decode_fh(__be32 *p, struct svc_fh *fhp) 50 { 51 unsigned int size; 52 fh_init(fhp, NFS3_FHSIZE); 53 size = ntohl(*p++); 54 if (size > NFS3_FHSIZE) 55 return NULL; 56 57 memcpy(&fhp->fh_handle.fh_base, p, size); 58 fhp->fh_handle.fh_size = size; 59 return p + XDR_QUADLEN(size); 60 } 61 62 /* Helper function for NFSv3 ACL code */ 63 __be32 *nfs3svc_decode_fh(__be32 *p, struct svc_fh *fhp) 64 { 65 return decode_fh(p, fhp); 66 } 67 68 static __be32 * 69 encode_fh(__be32 *p, struct svc_fh *fhp) 70 { 71 unsigned int size = fhp->fh_handle.fh_size; 72 *p++ = htonl(size); 73 if (size) p[XDR_QUADLEN(size)-1]=0; 74 memcpy(p, &fhp->fh_handle.fh_base, size); 75 return p + XDR_QUADLEN(size); 76 } 77 78 /* 79 * Decode a file name and make sure that the path contains 80 * no slashes or null bytes. 81 */ 82 static __be32 * 83 decode_filename(__be32 *p, char **namp, unsigned int *lenp) 84 { 85 char *name; 86 unsigned int i; 87 88 if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS3_MAXNAMLEN)) != NULL) { 89 for (i = 0, name = *namp; i < *lenp; i++, name++) { 90 if (*name == '\0' || *name == '/') 91 return NULL; 92 } 93 } 94 95 return p; 96 } 97 98 static __be32 * 99 decode_sattr3(__be32 *p, struct iattr *iap) 100 { 101 u32 tmp; 102 103 iap->ia_valid = 0; 104 105 if (*p++) { 106 iap->ia_valid |= ATTR_MODE; 107 iap->ia_mode = ntohl(*p++); 108 } 109 if (*p++) { 110 iap->ia_uid = make_kuid(&init_user_ns, ntohl(*p++)); 111 if (uid_valid(iap->ia_uid)) 112 iap->ia_valid |= ATTR_UID; 113 } 114 if (*p++) { 115 iap->ia_gid = make_kgid(&init_user_ns, ntohl(*p++)); 116 if (gid_valid(iap->ia_gid)) 117 iap->ia_valid |= ATTR_GID; 118 } 119 if (*p++) { 120 u64 newsize; 121 122 iap->ia_valid |= ATTR_SIZE; 123 p = xdr_decode_hyper(p, &newsize); 124 iap->ia_size = min_t(u64, newsize, NFS_OFFSET_MAX); 125 } 126 if ((tmp = ntohl(*p++)) == 1) { /* set to server time */ 127 iap->ia_valid |= ATTR_ATIME; 128 } else if (tmp == 2) { /* set to client time */ 129 iap->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET; 130 iap->ia_atime.tv_sec = ntohl(*p++); 131 iap->ia_atime.tv_nsec = ntohl(*p++); 132 } 133 if ((tmp = ntohl(*p++)) == 1) { /* set to server time */ 134 iap->ia_valid |= ATTR_MTIME; 135 } else if (tmp == 2) { /* set to client time */ 136 iap->ia_valid |= ATTR_MTIME | ATTR_MTIME_SET; 137 iap->ia_mtime.tv_sec = ntohl(*p++); 138 iap->ia_mtime.tv_nsec = ntohl(*p++); 139 } 140 return p; 141 } 142 143 static __be32 *encode_fsid(__be32 *p, struct svc_fh *fhp) 144 { 145 u64 f; 146 switch(fsid_source(fhp)) { 147 default: 148 case FSIDSOURCE_DEV: 149 p = xdr_encode_hyper(p, (u64)huge_encode_dev 150 (fhp->fh_dentry->d_sb->s_dev)); 151 break; 152 case FSIDSOURCE_FSID: 153 p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid); 154 break; 155 case FSIDSOURCE_UUID: 156 f = ((u64*)fhp->fh_export->ex_uuid)[0]; 157 f ^= ((u64*)fhp->fh_export->ex_uuid)[1]; 158 p = xdr_encode_hyper(p, f); 159 break; 160 } 161 return p; 162 } 163 164 static __be32 * 165 encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp, 166 struct kstat *stat) 167 { 168 struct timespec ts; 169 *p++ = htonl(nfs3_ftypes[(stat->mode & S_IFMT) >> 12]); 170 *p++ = htonl((u32) (stat->mode & S_IALLUGO)); 171 *p++ = htonl((u32) stat->nlink); 172 *p++ = htonl((u32) from_kuid(&init_user_ns, stat->uid)); 173 *p++ = htonl((u32) from_kgid(&init_user_ns, stat->gid)); 174 if (S_ISLNK(stat->mode) && stat->size > NFS3_MAXPATHLEN) { 175 p = xdr_encode_hyper(p, (u64) NFS3_MAXPATHLEN); 176 } else { 177 p = xdr_encode_hyper(p, (u64) stat->size); 178 } 179 p = xdr_encode_hyper(p, ((u64)stat->blocks) << 9); 180 *p++ = htonl((u32) MAJOR(stat->rdev)); 181 *p++ = htonl((u32) MINOR(stat->rdev)); 182 p = encode_fsid(p, fhp); 183 p = xdr_encode_hyper(p, stat->ino); 184 ts = timespec64_to_timespec(stat->atime); 185 p = encode_time3(p, &ts); 186 ts = timespec64_to_timespec(stat->mtime); 187 p = encode_time3(p, &ts); 188 ts = timespec64_to_timespec(stat->ctime); 189 p = encode_time3(p, &ts); 190 191 return p; 192 } 193 194 static __be32 * 195 encode_saved_post_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 196 { 197 /* Attributes to follow */ 198 *p++ = xdr_one; 199 return encode_fattr3(rqstp, p, fhp, &fhp->fh_post_attr); 200 } 201 202 /* 203 * Encode post-operation attributes. 204 * The inode may be NULL if the call failed because of a stale file 205 * handle. In this case, no attributes are returned. 206 */ 207 static __be32 * 208 encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 209 { 210 struct dentry *dentry = fhp->fh_dentry; 211 if (dentry && d_really_is_positive(dentry)) { 212 __be32 err; 213 struct kstat stat; 214 215 err = fh_getattr(fhp, &stat); 216 if (!err) { 217 *p++ = xdr_one; /* attributes follow */ 218 lease_get_mtime(d_inode(dentry), &stat.mtime); 219 return encode_fattr3(rqstp, p, fhp, &stat); 220 } 221 } 222 *p++ = xdr_zero; 223 return p; 224 } 225 226 /* Helper for NFSv3 ACLs */ 227 __be32 * 228 nfs3svc_encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 229 { 230 return encode_post_op_attr(rqstp, p, fhp); 231 } 232 233 /* 234 * Enocde weak cache consistency data 235 */ 236 static __be32 * 237 encode_wcc_data(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 238 { 239 struct dentry *dentry = fhp->fh_dentry; 240 241 if (dentry && d_really_is_positive(dentry) && fhp->fh_post_saved) { 242 if (fhp->fh_pre_saved) { 243 *p++ = xdr_one; 244 p = xdr_encode_hyper(p, (u64) fhp->fh_pre_size); 245 p = encode_time3(p, &fhp->fh_pre_mtime); 246 p = encode_time3(p, &fhp->fh_pre_ctime); 247 } else { 248 *p++ = xdr_zero; 249 } 250 return encode_saved_post_attr(rqstp, p, fhp); 251 } 252 /* no pre- or post-attrs */ 253 *p++ = xdr_zero; 254 return encode_post_op_attr(rqstp, p, fhp); 255 } 256 257 /* 258 * Fill in the pre_op attr for the wcc data 259 */ 260 void fill_pre_wcc(struct svc_fh *fhp) 261 { 262 struct inode *inode; 263 struct kstat stat; 264 __be32 err; 265 266 if (fhp->fh_pre_saved) 267 return; 268 269 inode = d_inode(fhp->fh_dentry); 270 err = fh_getattr(fhp, &stat); 271 if (err) { 272 /* Grab the times from inode anyway */ 273 stat.mtime = inode->i_mtime; 274 stat.ctime = inode->i_ctime; 275 stat.size = inode->i_size; 276 } 277 278 fhp->fh_pre_mtime = timespec64_to_timespec(stat.mtime); 279 fhp->fh_pre_ctime = timespec64_to_timespec(stat.ctime); 280 fhp->fh_pre_size = stat.size; 281 fhp->fh_pre_change = nfsd4_change_attribute(&stat, inode); 282 fhp->fh_pre_saved = true; 283 } 284 285 /* 286 * Fill in the post_op attr for the wcc data 287 */ 288 void fill_post_wcc(struct svc_fh *fhp) 289 { 290 __be32 err; 291 292 if (fhp->fh_post_saved) 293 printk("nfsd: inode locked twice during operation.\n"); 294 295 err = fh_getattr(fhp, &fhp->fh_post_attr); 296 fhp->fh_post_change = nfsd4_change_attribute(&fhp->fh_post_attr, 297 d_inode(fhp->fh_dentry)); 298 if (err) { 299 fhp->fh_post_saved = false; 300 /* Grab the ctime anyway - set_change_info might use it */ 301 fhp->fh_post_attr.ctime = d_inode(fhp->fh_dentry)->i_ctime; 302 } else 303 fhp->fh_post_saved = true; 304 } 305 306 /* 307 * XDR decode functions 308 */ 309 int 310 nfs3svc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p) 311 { 312 struct nfsd_fhandle *args = rqstp->rq_argp; 313 314 p = decode_fh(p, &args->fh); 315 if (!p) 316 return 0; 317 return xdr_argsize_check(rqstp, p); 318 } 319 320 int 321 nfs3svc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p) 322 { 323 struct nfsd3_sattrargs *args = rqstp->rq_argp; 324 325 p = decode_fh(p, &args->fh); 326 if (!p) 327 return 0; 328 p = decode_sattr3(p, &args->attrs); 329 330 if ((args->check_guard = ntohl(*p++)) != 0) { 331 struct timespec time; 332 p = decode_time3(p, &time); 333 args->guardtime = time.tv_sec; 334 } 335 336 return xdr_argsize_check(rqstp, p); 337 } 338 339 int 340 nfs3svc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p) 341 { 342 struct nfsd3_diropargs *args = rqstp->rq_argp; 343 344 if (!(p = decode_fh(p, &args->fh)) 345 || !(p = decode_filename(p, &args->name, &args->len))) 346 return 0; 347 348 return xdr_argsize_check(rqstp, p); 349 } 350 351 int 352 nfs3svc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p) 353 { 354 struct nfsd3_accessargs *args = rqstp->rq_argp; 355 356 p = decode_fh(p, &args->fh); 357 if (!p) 358 return 0; 359 args->access = ntohl(*p++); 360 361 return xdr_argsize_check(rqstp, p); 362 } 363 364 int 365 nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p) 366 { 367 struct nfsd3_readargs *args = rqstp->rq_argp; 368 unsigned int len; 369 int v; 370 u32 max_blocksize = svc_max_payload(rqstp); 371 372 p = decode_fh(p, &args->fh); 373 if (!p) 374 return 0; 375 p = xdr_decode_hyper(p, &args->offset); 376 377 args->count = ntohl(*p++); 378 len = min(args->count, max_blocksize); 379 380 /* set up the kvec */ 381 v=0; 382 while (len > 0) { 383 struct page *p = *(rqstp->rq_next_page++); 384 385 rqstp->rq_vec[v].iov_base = page_address(p); 386 rqstp->rq_vec[v].iov_len = min_t(unsigned int, len, PAGE_SIZE); 387 len -= rqstp->rq_vec[v].iov_len; 388 v++; 389 } 390 args->vlen = v; 391 return xdr_argsize_check(rqstp, p); 392 } 393 394 int 395 nfs3svc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p) 396 { 397 struct nfsd3_writeargs *args = rqstp->rq_argp; 398 unsigned int len, hdr, dlen; 399 u32 max_blocksize = svc_max_payload(rqstp); 400 struct kvec *head = rqstp->rq_arg.head; 401 struct kvec *tail = rqstp->rq_arg.tail; 402 403 p = decode_fh(p, &args->fh); 404 if (!p) 405 return 0; 406 p = xdr_decode_hyper(p, &args->offset); 407 408 args->count = ntohl(*p++); 409 args->stable = ntohl(*p++); 410 len = args->len = ntohl(*p++); 411 if ((void *)p > head->iov_base + head->iov_len) 412 return 0; 413 /* 414 * The count must equal the amount of data passed. 415 */ 416 if (args->count != args->len) 417 return 0; 418 419 /* 420 * Check to make sure that we got the right number of 421 * bytes. 422 */ 423 hdr = (void*)p - head->iov_base; 424 dlen = head->iov_len + rqstp->rq_arg.page_len + tail->iov_len - hdr; 425 /* 426 * Round the length of the data which was specified up to 427 * the next multiple of XDR units and then compare that 428 * against the length which was actually received. 429 * Note that when RPCSEC/GSS (for example) is used, the 430 * data buffer can be padded so dlen might be larger 431 * than required. It must never be smaller. 432 */ 433 if (dlen < XDR_QUADLEN(len)*4) 434 return 0; 435 436 if (args->count > max_blocksize) { 437 args->count = max_blocksize; 438 len = args->len = max_blocksize; 439 } 440 441 args->first.iov_base = (void *)p; 442 args->first.iov_len = head->iov_len - hdr; 443 return 1; 444 } 445 446 int 447 nfs3svc_decode_createargs(struct svc_rqst *rqstp, __be32 *p) 448 { 449 struct nfsd3_createargs *args = rqstp->rq_argp; 450 451 if (!(p = decode_fh(p, &args->fh)) 452 || !(p = decode_filename(p, &args->name, &args->len))) 453 return 0; 454 455 switch (args->createmode = ntohl(*p++)) { 456 case NFS3_CREATE_UNCHECKED: 457 case NFS3_CREATE_GUARDED: 458 p = decode_sattr3(p, &args->attrs); 459 break; 460 case NFS3_CREATE_EXCLUSIVE: 461 args->verf = p; 462 p += 2; 463 break; 464 default: 465 return 0; 466 } 467 468 return xdr_argsize_check(rqstp, p); 469 } 470 471 int 472 nfs3svc_decode_mkdirargs(struct svc_rqst *rqstp, __be32 *p) 473 { 474 struct nfsd3_createargs *args = rqstp->rq_argp; 475 476 if (!(p = decode_fh(p, &args->fh)) || 477 !(p = decode_filename(p, &args->name, &args->len))) 478 return 0; 479 p = decode_sattr3(p, &args->attrs); 480 481 return xdr_argsize_check(rqstp, p); 482 } 483 484 int 485 nfs3svc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p) 486 { 487 struct nfsd3_symlinkargs *args = rqstp->rq_argp; 488 char *base = (char *)p; 489 size_t dlen; 490 491 if (!(p = decode_fh(p, &args->ffh)) || 492 !(p = decode_filename(p, &args->fname, &args->flen))) 493 return 0; 494 p = decode_sattr3(p, &args->attrs); 495 496 args->tlen = ntohl(*p++); 497 498 args->first.iov_base = p; 499 args->first.iov_len = rqstp->rq_arg.head[0].iov_len; 500 args->first.iov_len -= (char *)p - base; 501 502 dlen = args->first.iov_len + rqstp->rq_arg.page_len + 503 rqstp->rq_arg.tail[0].iov_len; 504 if (dlen < XDR_QUADLEN(args->tlen) << 2) 505 return 0; 506 return 1; 507 } 508 509 int 510 nfs3svc_decode_mknodargs(struct svc_rqst *rqstp, __be32 *p) 511 { 512 struct nfsd3_mknodargs *args = rqstp->rq_argp; 513 514 if (!(p = decode_fh(p, &args->fh)) 515 || !(p = decode_filename(p, &args->name, &args->len))) 516 return 0; 517 518 args->ftype = ntohl(*p++); 519 520 if (args->ftype == NF3BLK || args->ftype == NF3CHR 521 || args->ftype == NF3SOCK || args->ftype == NF3FIFO) 522 p = decode_sattr3(p, &args->attrs); 523 524 if (args->ftype == NF3BLK || args->ftype == NF3CHR) { 525 args->major = ntohl(*p++); 526 args->minor = ntohl(*p++); 527 } 528 529 return xdr_argsize_check(rqstp, p); 530 } 531 532 int 533 nfs3svc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p) 534 { 535 struct nfsd3_renameargs *args = rqstp->rq_argp; 536 537 if (!(p = decode_fh(p, &args->ffh)) 538 || !(p = decode_filename(p, &args->fname, &args->flen)) 539 || !(p = decode_fh(p, &args->tfh)) 540 || !(p = decode_filename(p, &args->tname, &args->tlen))) 541 return 0; 542 543 return xdr_argsize_check(rqstp, p); 544 } 545 546 int 547 nfs3svc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p) 548 { 549 struct nfsd3_readlinkargs *args = rqstp->rq_argp; 550 551 p = decode_fh(p, &args->fh); 552 if (!p) 553 return 0; 554 args->buffer = page_address(*(rqstp->rq_next_page++)); 555 556 return xdr_argsize_check(rqstp, p); 557 } 558 559 int 560 nfs3svc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p) 561 { 562 struct nfsd3_linkargs *args = rqstp->rq_argp; 563 564 if (!(p = decode_fh(p, &args->ffh)) 565 || !(p = decode_fh(p, &args->tfh)) 566 || !(p = decode_filename(p, &args->tname, &args->tlen))) 567 return 0; 568 569 return xdr_argsize_check(rqstp, p); 570 } 571 572 int 573 nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p) 574 { 575 struct nfsd3_readdirargs *args = rqstp->rq_argp; 576 p = decode_fh(p, &args->fh); 577 if (!p) 578 return 0; 579 p = xdr_decode_hyper(p, &args->cookie); 580 args->verf = p; p += 2; 581 args->dircount = ~0; 582 args->count = ntohl(*p++); 583 args->count = min_t(u32, args->count, PAGE_SIZE); 584 args->buffer = page_address(*(rqstp->rq_next_page++)); 585 586 return xdr_argsize_check(rqstp, p); 587 } 588 589 int 590 nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p) 591 { 592 struct nfsd3_readdirargs *args = rqstp->rq_argp; 593 int len; 594 u32 max_blocksize = svc_max_payload(rqstp); 595 596 p = decode_fh(p, &args->fh); 597 if (!p) 598 return 0; 599 p = xdr_decode_hyper(p, &args->cookie); 600 args->verf = p; p += 2; 601 args->dircount = ntohl(*p++); 602 args->count = ntohl(*p++); 603 604 len = args->count = min(args->count, max_blocksize); 605 while (len > 0) { 606 struct page *p = *(rqstp->rq_next_page++); 607 if (!args->buffer) 608 args->buffer = page_address(p); 609 len -= PAGE_SIZE; 610 } 611 612 return xdr_argsize_check(rqstp, p); 613 } 614 615 int 616 nfs3svc_decode_commitargs(struct svc_rqst *rqstp, __be32 *p) 617 { 618 struct nfsd3_commitargs *args = rqstp->rq_argp; 619 p = decode_fh(p, &args->fh); 620 if (!p) 621 return 0; 622 p = xdr_decode_hyper(p, &args->offset); 623 args->count = ntohl(*p++); 624 625 return xdr_argsize_check(rqstp, p); 626 } 627 628 /* 629 * XDR encode functions 630 */ 631 /* 632 * There must be an encoding function for void results so svc_process 633 * will work properly. 634 */ 635 int 636 nfs3svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p) 637 { 638 return xdr_ressize_check(rqstp, p); 639 } 640 641 /* GETATTR */ 642 int 643 nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p) 644 { 645 struct nfsd3_attrstat *resp = rqstp->rq_resp; 646 647 if (resp->status == 0) { 648 lease_get_mtime(d_inode(resp->fh.fh_dentry), 649 &resp->stat.mtime); 650 p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat); 651 } 652 return xdr_ressize_check(rqstp, p); 653 } 654 655 /* SETATTR, REMOVE, RMDIR */ 656 int 657 nfs3svc_encode_wccstat(struct svc_rqst *rqstp, __be32 *p) 658 { 659 struct nfsd3_attrstat *resp = rqstp->rq_resp; 660 661 p = encode_wcc_data(rqstp, p, &resp->fh); 662 return xdr_ressize_check(rqstp, p); 663 } 664 665 /* LOOKUP */ 666 int 667 nfs3svc_encode_diropres(struct svc_rqst *rqstp, __be32 *p) 668 { 669 struct nfsd3_diropres *resp = rqstp->rq_resp; 670 671 if (resp->status == 0) { 672 p = encode_fh(p, &resp->fh); 673 p = encode_post_op_attr(rqstp, p, &resp->fh); 674 } 675 p = encode_post_op_attr(rqstp, p, &resp->dirfh); 676 return xdr_ressize_check(rqstp, p); 677 } 678 679 /* ACCESS */ 680 int 681 nfs3svc_encode_accessres(struct svc_rqst *rqstp, __be32 *p) 682 { 683 struct nfsd3_accessres *resp = rqstp->rq_resp; 684 685 p = encode_post_op_attr(rqstp, p, &resp->fh); 686 if (resp->status == 0) 687 *p++ = htonl(resp->access); 688 return xdr_ressize_check(rqstp, p); 689 } 690 691 /* READLINK */ 692 int 693 nfs3svc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p) 694 { 695 struct nfsd3_readlinkres *resp = rqstp->rq_resp; 696 697 p = encode_post_op_attr(rqstp, p, &resp->fh); 698 if (resp->status == 0) { 699 *p++ = htonl(resp->len); 700 xdr_ressize_check(rqstp, p); 701 rqstp->rq_res.page_len = resp->len; 702 if (resp->len & 3) { 703 /* need to pad the tail */ 704 rqstp->rq_res.tail[0].iov_base = p; 705 *p = 0; 706 rqstp->rq_res.tail[0].iov_len = 4 - (resp->len&3); 707 } 708 return 1; 709 } else 710 return xdr_ressize_check(rqstp, p); 711 } 712 713 /* READ */ 714 int 715 nfs3svc_encode_readres(struct svc_rqst *rqstp, __be32 *p) 716 { 717 struct nfsd3_readres *resp = rqstp->rq_resp; 718 719 p = encode_post_op_attr(rqstp, p, &resp->fh); 720 if (resp->status == 0) { 721 *p++ = htonl(resp->count); 722 *p++ = htonl(resp->eof); 723 *p++ = htonl(resp->count); /* xdr opaque count */ 724 xdr_ressize_check(rqstp, p); 725 /* now update rqstp->rq_res to reflect data as well */ 726 rqstp->rq_res.page_len = resp->count; 727 if (resp->count & 3) { 728 /* need to pad the tail */ 729 rqstp->rq_res.tail[0].iov_base = p; 730 *p = 0; 731 rqstp->rq_res.tail[0].iov_len = 4 - (resp->count & 3); 732 } 733 return 1; 734 } else 735 return xdr_ressize_check(rqstp, p); 736 } 737 738 /* WRITE */ 739 int 740 nfs3svc_encode_writeres(struct svc_rqst *rqstp, __be32 *p) 741 { 742 struct nfsd3_writeres *resp = rqstp->rq_resp; 743 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 744 745 p = encode_wcc_data(rqstp, p, &resp->fh); 746 if (resp->status == 0) { 747 *p++ = htonl(resp->count); 748 *p++ = htonl(resp->committed); 749 /* unique identifier, y2038 overflow can be ignored */ 750 *p++ = htonl((u32)nn->nfssvc_boot.tv_sec); 751 *p++ = htonl(nn->nfssvc_boot.tv_nsec); 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 /* unique identifier, y2038 overflow can be ignored */ 1122 *p++ = htonl((u32)nn->nfssvc_boot.tv_sec); 1123 *p++ = htonl(nn->nfssvc_boot.tv_nsec); 1124 } 1125 return xdr_ressize_check(rqstp, p); 1126 } 1127 1128 /* 1129 * XDR release functions 1130 */ 1131 void 1132 nfs3svc_release_fhandle(struct svc_rqst *rqstp) 1133 { 1134 struct nfsd3_attrstat *resp = rqstp->rq_resp; 1135 1136 fh_put(&resp->fh); 1137 } 1138 1139 void 1140 nfs3svc_release_fhandle2(struct svc_rqst *rqstp) 1141 { 1142 struct nfsd3_fhandle_pair *resp = rqstp->rq_resp; 1143 1144 fh_put(&resp->fh1); 1145 fh_put(&resp->fh2); 1146 } 1147