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