1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 24 */ 25 26 /* 27 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 28 * Use is subject to license terms. 29 */ 30 31 #include <sys/param.h> 32 #include <sys/types.h> 33 #include <sys/systm.h> 34 #include <sys/cred.h> 35 #include <sys/buf.h> 36 #include <sys/vfs.h> 37 #include <sys/vnode.h> 38 #include <sys/uio.h> 39 #include <sys/errno.h> 40 #include <sys/sysmacros.h> 41 #include <sys/statvfs.h> 42 #include <sys/kmem.h> 43 #include <sys/dirent.h> 44 #include <rpc/types.h> 45 #include <rpc/auth.h> 46 #include <rpc/rpcsec_gss.h> 47 #include <rpc/svc.h> 48 #include <sys/strsubr.h> 49 #include <sys/strsun.h> 50 #include <sys/sdt.h> 51 52 #include <nfs/nfs.h> 53 #include <nfs/export.h> 54 #include <nfs/nfs4.h> 55 #include <nfs/nfs_cmd.h> 56 57 58 /* 59 * RFS4_MINLEN_ENTRY4: XDR-encoded size of smallest possible dirent. 60 * This is used to return NFS4ERR_TOOSMALL when clients specify 61 * maxcount that isn't large enough to hold the smallest possible 62 * XDR encoded dirent. 63 * 64 * sizeof cookie (8 bytes) + 65 * sizeof name_len (4 bytes) + 66 * sizeof smallest (padded) name (4 bytes) + 67 * sizeof bitmap4_len (12 bytes) + NOTE: we always encode len=2 bm4 68 * sizeof attrlist4_len (4 bytes) + 69 * sizeof next boolean (4 bytes) 70 * 71 * RFS4_MINLEN_RDDIR4: XDR-encoded size of READDIR op reply containing 72 * the smallest possible entry4 (assumes no attrs requested). 73 * sizeof nfsstat4 (4 bytes) + 74 * sizeof verifier4 (8 bytes) + 75 * sizeof entsecond_to_ry4list bool (4 bytes) + 76 * sizeof entry4 (36 bytes) + 77 * sizeof eof bool (4 bytes) 78 * 79 * RFS4_MINLEN_RDDIR_BUF: minimum length of buffer server will provide to 80 * VOP_READDIR. Its value is the size of the maximum possible dirent 81 * for solaris. The DIRENT64_RECLEN macro returns the size of dirent 82 * required for a given name length. MAXNAMELEN is the maximum 83 * filename length allowed in Solaris. The first two DIRENT64_RECLEN() 84 * macros are to allow for . and .. entries -- just a minor tweak to try 85 * and guarantee that buffer we give to VOP_READDIR will be large enough 86 * to hold ., .., and the largest possible solaris dirent64. 87 */ 88 #define RFS4_MINLEN_ENTRY4 36 89 #define RFS4_MINLEN_RDDIR4 (4 + NFS4_VERIFIER_SIZE + 4 + RFS4_MINLEN_ENTRY4 + 4) 90 #define RFS4_MINLEN_RDDIR_BUF \ 91 (DIRENT64_RECLEN(1) + DIRENT64_RECLEN(2) + DIRENT64_RECLEN(MAXNAMELEN)) 92 93 94 #ifdef nextdp 95 #undef nextdp 96 #endif 97 #define nextdp(dp) ((struct dirent64 *)((char *)(dp) + (dp)->d_reclen)) 98 99 verifier4 Readdir4verf = 0x0; 100 101 static nfs_ftype4 vt_to_nf4[] = { 102 0, NF4REG, NF4DIR, NF4BLK, NF4CHR, NF4LNK, NF4FIFO, 0, 0, NF4SOCK, 0 103 }; 104 105 /* 106 * RFC 7530 Section 8.3.2 107 * Supported attributes for READDIR for the root of an absent filesystem. 108 */ 109 #define ABSENT_FS_ATTRS (FATTR4_FS_LOCATIONS_MASK | FATTR4_FSID_MASK | \ 110 FATTR4_MOUNTED_ON_FILEID_MASK | FATTR4_RDATTR_ERROR_MASK) 111 112 int 113 nfs4_readdir_getvp(vnode_t *dvp, char *d_name, vnode_t **vpp, 114 struct exportinfo **exi, struct svc_req *req, struct compound_state *cs, 115 int expseudo, bool_t *migrated) 116 { 117 int error; 118 int ismntpt; 119 fid_t fid; 120 vnode_t *vp, *pre_tvp; 121 nfsstat4 status; 122 struct exportinfo *newexi, *saveexi; 123 cred_t *scr; 124 125 *vpp = vp = NULL; 126 127 error = VOP_LOOKUP(dvp, d_name, &vp, NULL, 0, NULL, cs->cr, 128 NULL, NULL, NULL); 129 if (error != 0) 130 return (error); 131 132 /* referral point ? */ 133 if (vn_is_nfs_reparse(vp, cs->cr) && !client_is_downrev(req)) { 134 DTRACE_PROBE2(nfs4serv__func__referral__moved, 135 vnode_t *, vp, char *, "nfs4_readdir_getvp"); 136 *migrated = TRUE; 137 *vpp = vp; 138 return (0); 139 } 140 141 /* Is this object mounted upon? */ 142 ismntpt = vn_ismntpt(vp); 143 144 /* 145 * Nothing more to do if object is not a mount point or 146 * a possible LOFS shadow of an LOFS mount (which won't 147 * have v_vfsmountedhere set) 148 */ 149 if (ismntpt == 0 && dvp->v_vfsp == vp->v_vfsp && expseudo == 0) { 150 *vpp = vp; 151 return (0); 152 } 153 154 if (ismntpt) { 155 /* 156 * Something is mounted here. Traverse and manage the 157 * namespace 158 */ 159 pre_tvp = vp; 160 VN_HOLD(pre_tvp); 161 162 if ((error = traverse(&vp)) != 0) { 163 VN_RELE(vp); 164 VN_RELE(pre_tvp); 165 return (error); 166 } 167 } 168 169 bzero(&fid, sizeof (fid)); 170 fid.fid_len = MAXFIDSZ; 171 172 /* 173 * If VOP_FID not supported by underlying fs (mntfs, procfs, 174 * etc.), then return attrs for stub instead of VROOT object. 175 * If it fails for any other reason, then return the error. 176 */ 177 error = VOP_FID(vp, &fid, NULL); 178 if (error != 0) { 179 if (ismntpt == 0) { 180 VN_RELE(vp); 181 return (error); 182 } 183 184 if (error != ENOSYS && error != ENOTSUP) { 185 VN_RELE(vp); 186 VN_RELE(pre_tvp); 187 return (error); 188 } 189 /* go back to vnode that is "under" mount */ 190 VN_RELE(vp); 191 *vpp = pre_tvp; 192 return (0); 193 } 194 195 newexi = checkexport4(&vp->v_vfsp->vfs_fsid, &fid, vp); 196 if (newexi == NULL) { 197 if (ismntpt == 0) { 198 *vpp = vp; 199 } else { 200 VN_RELE(vp); 201 *vpp = pre_tvp; 202 } 203 return (0); 204 } 205 206 if (ismntpt) 207 VN_RELE(pre_tvp); 208 209 /* Save the exi and present the new one to checkauth4() */ 210 saveexi = cs->exi; 211 cs->exi = newexi; 212 213 /* Get the right cred like lookup does */ 214 scr = cs->cr; 215 cs->cr = crdup(cs->basecr); 216 217 status = call_checkauth4(cs, req); 218 219 crfree(cs->cr); 220 cs->cr = scr; 221 cs->exi = saveexi; 222 223 /* Reset what call_checkauth4() may have set */ 224 *cs->statusp = NFS4_OK; 225 226 if (status != NFS4_OK) { 227 VN_RELE(vp); 228 if (status == NFS4ERR_DELAY) 229 status = NFS4ERR_ACCESS; 230 return (status); 231 } 232 *vpp = vp; 233 *exi = newexi; 234 235 return (0); 236 } 237 238 /* This is the set of pathconf data for vfs */ 239 typedef struct { 240 uint64_t maxfilesize; 241 uint32_t maxlink; 242 uint32_t maxname; 243 } rfs4_pc_encode_t; 244 245 246 static int 247 rfs4_get_pc_encode(vnode_t *vp, rfs4_pc_encode_t *pce, bitmap4 ar, cred_t *cr) 248 { 249 int error; 250 ulong_t pc_val; 251 252 pce->maxfilesize = 0; 253 pce->maxlink = 0; 254 pce->maxname = 0; 255 256 if (ar & FATTR4_MAXFILESIZE_MASK) { 257 /* Maximum File Size */ 258 error = VOP_PATHCONF(vp, _PC_FILESIZEBITS, &pc_val, cr, NULL); 259 if (error) 260 return (error); 261 262 /* 263 * If the underlying file system does not support 264 * _PC_FILESIZEBITS, return a reasonable default. Note that 265 * error code on VOP_PATHCONF will be 0, even if the underlying 266 * file system does not support _PC_FILESIZEBITS. 267 */ 268 if (pc_val == (ulong_t)-1) { 269 pce->maxfilesize = MAXOFF32_T; 270 } else { 271 if (pc_val >= (sizeof (uint64_t) * 8)) 272 pce->maxfilesize = INT64_MAX; 273 else 274 pce->maxfilesize = ((1LL << (pc_val - 1)) - 1); 275 } 276 } 277 278 if (ar & FATTR4_MAXLINK_MASK) { 279 /* Maximum Link Count */ 280 error = VOP_PATHCONF(vp, _PC_LINK_MAX, &pc_val, cr, NULL); 281 if (error) 282 return (error); 283 284 pce->maxlink = pc_val; 285 } 286 287 if (ar & FATTR4_MAXNAME_MASK) { 288 /* Maximum Name Length */ 289 error = VOP_PATHCONF(vp, _PC_NAME_MAX, &pc_val, cr, NULL); 290 if (error) 291 return (error); 292 293 pce->maxname = pc_val; 294 } 295 296 return (0); 297 } 298 299 /* This is the set of statvfs data that is ready for encoding */ 300 typedef struct { 301 uint64_t space_avail; 302 uint64_t space_free; 303 uint64_t space_total; 304 u_longlong_t fa; 305 u_longlong_t ff; 306 u_longlong_t ft; 307 } rfs4_sb_encode_t; 308 309 static int 310 rfs4_get_sb_encode(vfs_t *vfsp, rfs4_sb_encode_t *psbe) 311 { 312 int error; 313 struct statvfs64 sb; 314 315 /* Grab the per filesystem info */ 316 error = VFS_STATVFS(vfsp, &sb); 317 if (error != 0) { 318 return (error); 319 } 320 321 /* Calculate space available */ 322 if (sb.f_bavail != (fsblkcnt64_t)-1) { 323 psbe->space_avail = 324 (fattr4_space_avail) sb.f_frsize * 325 (fattr4_space_avail) sb.f_bavail; 326 } else { 327 psbe->space_avail = 328 (fattr4_space_avail) sb.f_bavail; 329 } 330 331 /* Calculate space free */ 332 if (sb.f_bfree != (fsblkcnt64_t)-1) { 333 psbe->space_free = 334 (fattr4_space_free) sb.f_frsize * 335 (fattr4_space_free) sb.f_bfree; 336 } else { 337 psbe->space_free = 338 (fattr4_space_free) sb.f_bfree; 339 } 340 341 /* Calculate space total */ 342 if (sb.f_blocks != (fsblkcnt64_t)-1) { 343 psbe->space_total = 344 (fattr4_space_total) sb.f_frsize * 345 (fattr4_space_total) sb.f_blocks; 346 } else { 347 psbe->space_total = 348 (fattr4_space_total) sb.f_blocks; 349 } 350 351 /* For use later on attr encode */ 352 psbe->fa = sb.f_favail; 353 psbe->ff = sb.f_ffree; 354 psbe->ft = sb.f_files; 355 356 return (0); 357 } 358 359 extern void rfs4_free_fs_locations4(fs_locations4 *); 360 361 /* 362 * If readdir only needs to return FILEID, we can take it from the 363 * dirent struct and save doing the lookup. 364 */ 365 /* ARGSUSED */ 366 void 367 rfs4_op_readdir(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req, 368 struct compound_state *cs) 369 { 370 READDIR4args *args = &argop->nfs_argop4_u.opreaddir; 371 READDIR4res *resp = &resop->nfs_resop4_u.opreaddir; 372 struct exportinfo *newexi = NULL; 373 int error; 374 mblk_t *mp; 375 uint_t mpcount; 376 int alloc_err = 0; 377 vnode_t *dvp = cs->vp; 378 vnode_t *vp; 379 vattr_t va; 380 struct dirent64 *dp; 381 rfs4_sb_encode_t dsbe, sbe; 382 int vfs_different; 383 int rddir_data_len, rddir_result_size; 384 caddr_t rddir_data; 385 offset_t rddir_next_offset; 386 int dircount; 387 int no_space; 388 int iseofdir; 389 uint_t eof; 390 struct iovec iov; 391 struct uio uio; 392 int tsize; 393 int check_visible; 394 struct exp_visible *visp; 395 396 uint32_t *ptr, *ptr_redzone; 397 uint32_t *beginning_ptr; 398 uint32_t *lastentry_ptr; 399 uint32_t *attrmask_ptr; 400 uint32_t *attr_offset_ptr; 401 uint32_t attr_length; 402 uint32_t rndup; 403 uint32_t namelen; 404 uint32_t rddirattr_error = 0; 405 int nents; 406 bitmap4 ar = args->attr_request & NFS4_SRV_RDDIR_SUPPORTED_ATTRS; 407 bitmap4 ae; 408 rfs4_pc_encode_t dpce, pce; 409 ulong_t pc_val; 410 uint64_t maxread; 411 uint64_t maxwrite; 412 uint_t true = TRUE; 413 uint_t false = FALSE; 414 uid_t lastuid; 415 gid_t lastgid; 416 int lu_set, lg_set; 417 utf8string owner, group; 418 int owner_error, group_error; 419 struct sockaddr *ca; 420 char *name = NULL; 421 nfsstat4 status = NFS4_OK; 422 423 DTRACE_NFSV4_2(op__readdir__start, struct compound_state *, cs, 424 READDIR4args *, args); 425 426 lu_set = lg_set = 0; 427 owner.utf8string_len = group.utf8string_len = 0; 428 owner.utf8string_val = group.utf8string_val = NULL; 429 430 resp->mblk = NULL; 431 432 /* Maximum read and write size */ 433 maxread = maxwrite = rfs4_tsize(req); 434 435 if (dvp == NULL) { 436 *cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE; 437 goto out; 438 } 439 440 /* 441 * If there is an unshared filesystem mounted on this vnode, 442 * do not allow readdir in this directory. 443 */ 444 if (vn_ismntpt(dvp)) { 445 *cs->statusp = resp->status = NFS4ERR_ACCESS; 446 goto out; 447 } 448 449 if (dvp->v_type != VDIR) { 450 *cs->statusp = resp->status = NFS4ERR_NOTDIR; 451 goto out; 452 } 453 454 if (args->maxcount <= RFS4_MINLEN_RDDIR4) { 455 *cs->statusp = resp->status = NFS4ERR_TOOSMALL; 456 goto out; 457 } 458 459 /* 460 * If write-only attrs are requested, then fail the readdir op 461 */ 462 if (args->attr_request & 463 (FATTR4_TIME_MODIFY_SET_MASK | FATTR4_TIME_ACCESS_SET_MASK)) { 464 *cs->statusp = resp->status = NFS4ERR_INVAL; 465 goto out; 466 } 467 468 error = VOP_ACCESS(dvp, VREAD, 0, cs->cr, NULL); 469 if (error) { 470 *cs->statusp = resp->status = puterrno4(error); 471 goto out; 472 } 473 474 if (args->cookieverf != Readdir4verf) { 475 *cs->statusp = resp->status = NFS4ERR_NOT_SAME; 476 goto out; 477 } 478 479 /* Is there pseudo-fs work that is needed for this readdir? */ 480 check_visible = PSEUDO(cs->exi) || 481 ! is_exported_sec(cs->nfsflavor, cs->exi) || 482 cs->access & CS_ACCESS_LIMITED; 483 484 /* Check the requested attributes and only do the work if needed */ 485 486 if (ar & (FATTR4_MAXFILESIZE_MASK | 487 FATTR4_MAXLINK_MASK | 488 FATTR4_MAXNAME_MASK)) { 489 error = rfs4_get_pc_encode(cs->vp, &dpce, ar, cs->cr); 490 if (error != 0) { 491 *cs->statusp = resp->status = puterrno4(error); 492 goto out; 493 } 494 pce = dpce; 495 } 496 497 /* If there is statvfs data requested, pick it up once */ 498 if (ar & 499 (FATTR4_FILES_AVAIL_MASK | 500 FATTR4_FILES_FREE_MASK | 501 FATTR4_FILES_TOTAL_MASK | 502 FATTR4_FILES_AVAIL_MASK | 503 FATTR4_FILES_FREE_MASK | 504 FATTR4_FILES_TOTAL_MASK)) { 505 error = rfs4_get_sb_encode(dvp->v_vfsp, &dsbe); 506 if (error != 0) { 507 *cs->statusp = resp->status = puterrno4(error); 508 goto out; 509 } 510 sbe = dsbe; 511 } 512 513 /* 514 * Max transfer size of the server is the absolute limite. 515 * If the client has decided to max out with something really 516 * tiny, then return toosmall. Otherwise, move forward and 517 * see if a single entry can be encoded. 518 */ 519 tsize = rfs4_tsize(req); 520 if (args->maxcount > tsize) 521 args->maxcount = tsize; 522 else if (args->maxcount < RFS4_MINLEN_RDDIR_BUF) { 523 if (args->maxcount < RFS4_MINLEN_ENTRY4) { 524 *cs->statusp = resp->status = NFS4ERR_TOOSMALL; 525 goto out; 526 } 527 } 528 529 /* 530 * How large should the mblk be for outgoing encoding. 531 */ 532 if (args->maxcount < MAXBSIZE) 533 mpcount = MAXBSIZE; 534 else 535 mpcount = args->maxcount; 536 537 /* 538 * mp will contain the data to be sent out in the readdir reply. 539 * It will be freed after the reply has been sent. 540 * Let's roundup the data to a BYTES_PER_XDR_UNIX multiple, 541 * so that the call to xdrmblk_putmblk() never fails. 542 */ 543 mp = allocb(RNDUP(mpcount), BPRI_MED); 544 545 if (mp == NULL) { 546 /* 547 * The allocation of the client's requested size has 548 * failed. It may be that the size is too large for 549 * current system utilization; step down to a "common" 550 * size and wait for the allocation to occur. 551 */ 552 if (mpcount > MAXBSIZE) 553 args->maxcount = mpcount = MAXBSIZE; 554 mp = allocb_wait(RNDUP(mpcount), BPRI_MED, 555 STR_NOSIG, &alloc_err); 556 } 557 558 ASSERT(mp != NULL); 559 ASSERT(alloc_err == 0); 560 561 resp->mblk = mp; 562 563 ptr = beginning_ptr = (uint32_t *)mp->b_datap->db_base; 564 565 /* 566 * The "redzone" at the end of the encoding buffer is used 567 * to deal with xdr encoding length. Instead of checking 568 * each encoding of an attribute value before it is done, 569 * make the assumption that it will fit into the buffer and 570 * check occasionally. 571 * 572 * The largest block of attributes that are encoded without 573 * checking the redzone is 18 * BYTES_PER_XDR_UNIT (72 bytes) 574 * "round" to 128 as the redzone size. 575 */ 576 if (args->maxcount < (mpcount - 128)) 577 ptr_redzone = 578 (uint32_t *)(((char *)ptr) + RNDUP(args->maxcount)); 579 else 580 ptr_redzone = 581 (uint32_t *)((((char *)ptr) + RNDUP(mpcount)) - 128); 582 583 /* 584 * Set the dircount; this will be used as the size for the 585 * readdir of the underlying filesystem. First make sure 586 * that it is large enough to do a reasonable readdir (client 587 * may have short changed us - it is an advisory number); 588 * then make sure that it isn't too large. 589 * After all of that, if maxcount is "small" then just use 590 * that for the dircount number. 591 */ 592 dircount = (args->dircount < MAXBSIZE) ? MAXBSIZE : args->dircount; 593 dircount = (dircount > tsize) ? tsize : dircount; 594 if (dircount > args->maxcount) 595 dircount = args->maxcount; 596 if (args->maxcount <= MAXBSIZE) { 597 if (args->maxcount < RFS4_MINLEN_RDDIR_BUF) 598 dircount = RFS4_MINLEN_RDDIR_BUF; 599 else 600 dircount = args->maxcount; 601 } 602 603 /* number of entries fully encoded in outgoing buffer */ 604 nents = 0; 605 606 /* ENCODE READDIR4res.cookieverf */ 607 IXDR_PUT_HYPER(ptr, Readdir4verf); 608 609 rddir_data_len = dircount; 610 rddir_data = kmem_alloc(rddir_data_len, KM_NOSLEEP); 611 if (rddir_data == NULL) { 612 /* The allocation failed; downsize and wait for it this time */ 613 if (rddir_data_len > MAXBSIZE) 614 rddir_data_len = dircount = MAXBSIZE; 615 rddir_data = kmem_alloc(rddir_data_len, KM_SLEEP); 616 } 617 618 rddir_next_offset = (offset_t)args->cookie; 619 620 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf; 621 622 readagain: 623 624 no_space = FALSE; 625 iseofdir = FALSE; 626 627 vp = NULL; 628 629 /* Move on to reading the directory contents */ 630 iov.iov_base = rddir_data; 631 iov.iov_len = rddir_data_len; 632 uio.uio_iov = &iov; 633 uio.uio_iovcnt = 1; 634 uio.uio_segflg = UIO_SYSSPACE; 635 uio.uio_extflg = UIO_COPY_CACHED; 636 uio.uio_loffset = rddir_next_offset; 637 uio.uio_resid = rddir_data_len; 638 639 (void) VOP_RWLOCK(dvp, V_WRITELOCK_FALSE, NULL); 640 641 error = VOP_READDIR(dvp, &uio, cs->cr, &iseofdir, NULL, 0); 642 643 VOP_RWUNLOCK(dvp, V_WRITELOCK_FALSE, NULL); 644 645 if (error) { 646 kmem_free((caddr_t)rddir_data, rddir_data_len); 647 freeb(resp->mblk); 648 resp->mblk = NULL; 649 resp->data_len = 0; 650 *cs->statusp = resp->status = puterrno4(error); 651 goto out; 652 } 653 654 655 rddir_result_size = rddir_data_len - uio.uio_resid; 656 657 /* No data were read. Check if we reached the end of the directory. */ 658 if (rddir_result_size == 0) { 659 /* encode the BOOLEAN marking no further entries */ 660 IXDR_PUT_U_INT32(ptr, false); 661 /* encode the BOOLEAN signifying end of directory */ 662 IXDR_PUT_U_INT32(ptr, iseofdir ? true : false); 663 resp->data_len = (char *)ptr - (char *)beginning_ptr; 664 resp->mblk->b_wptr += resp->data_len; 665 kmem_free((caddr_t)rddir_data, rddir_data_len); 666 *cs->statusp = resp->status = NFS4_OK; 667 goto out; 668 } 669 670 lastentry_ptr = ptr; 671 no_space = 0; 672 for (dp = (struct dirent64 *)rddir_data; 673 !no_space && rddir_result_size > 0; dp = nextdp(dp)) { 674 bool_t fs_migrated = FALSE; 675 676 /* reset visp */ 677 visp = NULL; 678 679 if (vp) { 680 VN_RELE(vp); 681 vp = NULL; 682 } 683 684 if (newexi) 685 newexi = NULL; 686 687 rddir_result_size -= dp->d_reclen; 688 689 /* skip "." and ".." entries */ 690 if (dp->d_ino == 0 || NFS_IS_DOTNAME(dp->d_name)) { 691 rddir_next_offset = dp->d_off; 692 continue; 693 } 694 695 if (check_visible && 696 !nfs_visible_inode(cs->exi, dp->d_ino, &visp)) { 697 rddir_next_offset = dp->d_off; 698 continue; 699 } 700 701 /* 702 * Only if the client requested attributes... 703 * If the VOP_LOOKUP fails ENOENT, then skip this entry 704 * for the readdir response. If there was another error, 705 * then set the rddirattr_error and the error will be 706 * encoded later in the "attributes" section. 707 */ 708 ae = ar; 709 if (ar == 0) 710 goto reencode_attrs; 711 712 error = nfs4_readdir_getvp(dvp, dp->d_name, 713 &vp, &newexi, req, cs, 714 visp != NULL ? visp->vis_exported : 0, &fs_migrated); 715 if (error == ENOENT) { 716 rddir_next_offset = dp->d_off; 717 continue; 718 } 719 720 rddirattr_error = error; 721 722 /* 723 * The vp obtained from above may be from a 724 * different filesystem mount and the vfs-like 725 * attributes should be obtained from that 726 * different vfs; only do this if appropriate. 727 */ 728 if (vp && 729 (vfs_different = (dvp->v_vfsp != vp->v_vfsp))) { 730 if (ae & (FATTR4_FILES_AVAIL_MASK | 731 FATTR4_FILES_FREE_MASK | 732 FATTR4_FILES_TOTAL_MASK | 733 FATTR4_FILES_AVAIL_MASK | 734 FATTR4_FILES_FREE_MASK | 735 FATTR4_FILES_TOTAL_MASK)) { 736 error = rfs4_get_sb_encode(dvp->v_vfsp, &sbe); 737 if (error != 0) { 738 /* Remove attrs from encode */ 739 ae &= ~(FATTR4_FILES_AVAIL_MASK | 740 FATTR4_FILES_FREE_MASK | 741 FATTR4_FILES_TOTAL_MASK | 742 FATTR4_FILES_AVAIL_MASK | 743 FATTR4_FILES_FREE_MASK | 744 FATTR4_FILES_TOTAL_MASK); 745 rddirattr_error = error; 746 } 747 } 748 if (ae & (FATTR4_MAXFILESIZE_MASK | 749 FATTR4_MAXLINK_MASK | 750 FATTR4_MAXNAME_MASK)) { 751 error = rfs4_get_pc_encode(cs->vp, 752 &pce, ae, cs->cr); 753 if (error != 0) { 754 ae &= ~(FATTR4_MAXFILESIZE_MASK | 755 FATTR4_MAXLINK_MASK | 756 FATTR4_MAXNAME_MASK); 757 rddirattr_error = error; 758 } 759 } 760 } 761 762 reencode_attrs: 763 /* encode the BOOLEAN for the existence of the next entry */ 764 IXDR_PUT_U_INT32(ptr, true); 765 /* encode the COOKIE for the entry */ 766 IXDR_PUT_U_HYPER(ptr, dp->d_off); 767 768 name = nfscmd_convname(ca, cs->exi, dp->d_name, 769 NFSCMD_CONV_OUTBOUND, MAXPATHLEN + 1); 770 771 if (name == NULL) { 772 rddir_next_offset = dp->d_off; 773 continue; 774 } 775 /* Calculate the dirent name length */ 776 namelen = strlen(name); 777 778 rndup = RNDUP(namelen) / BYTES_PER_XDR_UNIT; 779 780 /* room for LENGTH + string ? */ 781 if ((ptr + (1 + rndup)) > ptr_redzone) { 782 no_space = TRUE; 783 continue; 784 } 785 786 /* encode the LENGTH of the name */ 787 IXDR_PUT_U_INT32(ptr, namelen); 788 /* encode the RNDUP FILL first */ 789 ptr[rndup - 1] = 0; 790 /* encode the NAME of the entry */ 791 bcopy(name, (char *)ptr, namelen); 792 /* now bump the ptr after... */ 793 ptr += rndup; 794 795 if (name != dp->d_name) 796 kmem_free(name, MAXPATHLEN + 1); 797 798 /* 799 * Keep checking on the dircount to see if we have 800 * reached the limit; from the RFC, dircount is to be 801 * the XDR encoded limit of the cookie plus name. 802 * So the count is the name, XDR_UNIT of length for 803 * that name and 2 * XDR_UNIT bytes of cookie; 804 * However, use the regular DIRENT64 to match most 805 * client's APIs. 806 */ 807 dircount -= DIRENT64_RECLEN(namelen); 808 if (nents != 0 && dircount < 0) { 809 no_space = TRUE; 810 continue; 811 } 812 813 /* 814 * Attributes requested? 815 * Gather up the attribute info and the previous VOP_LOOKUP() 816 * succeeded; if an error occurs on the VOP_GETATTR() then 817 * return just the error (again if it is requested). 818 * Note that the previous VOP_LOOKUP() could have failed 819 * itself which leaves this code without anything for 820 * a VOP_GETATTR(). 821 * Also note that the readdir_attr_error is left in the 822 * encoding mask if requested and so is the mounted_on_fileid. 823 */ 824 if (ae != 0) { 825 if (!vp) { 826 ae = ar & (FATTR4_RDATTR_ERROR_MASK | 827 FATTR4_MOUNTED_ON_FILEID_MASK); 828 } else if (fs_migrated) { 829 /* 830 * RFC 7530 Section 8.3.2 831 * Restrict to actually available attributes in 832 * case of an absent filesystem. 833 */ 834 ae &= ABSENT_FS_ATTRS; 835 836 if (!(ae & FATTR4_FS_LOCATIONS_MASK)) 837 rddirattr_error = NFS4ERR_MOVED; 838 } else { 839 va.va_mask = AT_ALL; 840 rddirattr_error = 841 VOP_GETATTR(vp, &va, 0, cs->cr, NULL); 842 if (rddirattr_error) { 843 ae = ae & (FATTR4_RDATTR_ERROR_MASK | 844 FATTR4_MOUNTED_ON_FILEID_MASK); 845 } else { 846 /* 847 * We may lie about the object 848 * type for a referral 849 */ 850 if (vn_is_nfs_reparse(vp, cs->cr) && 851 client_is_downrev(req)) 852 va.va_type = VLNK; 853 } 854 } 855 856 /* RFC 7530 Section 8.3.2 and 16.24.4 */ 857 if (rddirattr_error != 0 && 858 !(ae & FATTR4_RDATTR_ERROR_MASK)) { 859 status = puterrno4(rddirattr_error); 860 goto out_free; 861 } 862 } 863 864 /* START OF ATTRIBUTE ENCODING */ 865 866 /* encode the LENGTH of the BITMAP4 array */ 867 IXDR_PUT_U_INT32(ptr, 2); 868 /* encode the BITMAP4 */ 869 attrmask_ptr = ptr; 870 IXDR_PUT_HYPER(ptr, ae); 871 attr_offset_ptr = ptr; 872 /* encode the default LENGTH of the attributes for entry */ 873 IXDR_PUT_U_INT32(ptr, 0); 874 875 if (ptr > ptr_redzone) { 876 no_space = TRUE; 877 continue; 878 } 879 880 /* Check if any of the first 32 attributes are being encoded */ 881 if (ae & 0xffffffff00000000) { 882 /* 883 * Redzone check is done at the end of this section. 884 * This particular section will encode a maximum of 885 * 18 * BYTES_PER_XDR_UNIT of data 886 */ 887 if (ae & 888 (FATTR4_SUPPORTED_ATTRS_MASK | 889 FATTR4_TYPE_MASK | 890 FATTR4_FH_EXPIRE_TYPE_MASK | 891 FATTR4_CHANGE_MASK | 892 FATTR4_SIZE_MASK | 893 FATTR4_LINK_SUPPORT_MASK | 894 FATTR4_SYMLINK_SUPPORT_MASK | 895 FATTR4_NAMED_ATTR_MASK | 896 FATTR4_FSID_MASK | 897 FATTR4_UNIQUE_HANDLES_MASK | 898 FATTR4_LEASE_TIME_MASK | 899 FATTR4_RDATTR_ERROR_MASK)) { 900 901 if (ae & FATTR4_SUPPORTED_ATTRS_MASK) { 902 IXDR_PUT_INT32(ptr, 2); 903 IXDR_PUT_HYPER(ptr, 904 rfs4_supported_attrs); 905 } 906 if (ae & FATTR4_TYPE_MASK) { 907 uint_t ftype = vt_to_nf4[va.va_type]; 908 if (dvp->v_flag & V_XATTRDIR) { 909 if (va.va_type == VDIR) 910 ftype = NF4ATTRDIR; 911 else 912 ftype = NF4NAMEDATTR; 913 } 914 IXDR_PUT_U_INT32(ptr, ftype); 915 } 916 if (ae & FATTR4_FH_EXPIRE_TYPE_MASK) { 917 uint_t expire_type = FH4_PERSISTENT; 918 IXDR_PUT_U_INT32(ptr, expire_type); 919 } 920 if (ae & FATTR4_CHANGE_MASK) { 921 u_longlong_t change; 922 NFS4_SET_FATTR4_CHANGE(change, 923 va.va_ctime); 924 if (visp != NULL) { 925 u_longlong_t visch; 926 NFS4_SET_FATTR4_CHANGE(visch, 927 visp->vis_change); 928 if (visch > change) 929 change = visch; 930 } 931 IXDR_PUT_HYPER(ptr, change); 932 } 933 if (ae & FATTR4_SIZE_MASK) { 934 u_longlong_t size = va.va_size; 935 IXDR_PUT_HYPER(ptr, size); 936 } 937 if (ae & FATTR4_LINK_SUPPORT_MASK) { 938 IXDR_PUT_U_INT32(ptr, true); 939 } 940 if (ae & FATTR4_SYMLINK_SUPPORT_MASK) { 941 IXDR_PUT_U_INT32(ptr, true); 942 } 943 if (ae & FATTR4_NAMED_ATTR_MASK) { 944 uint_t isit; 945 pc_val = FALSE; 946 int sattr_error; 947 948 if (!(vp->v_vfsp->vfs_flag & 949 VFS_XATTR)) { 950 isit = FALSE; 951 } else { 952 sattr_error = VOP_PATHCONF(vp, 953 _PC_SATTR_EXISTS, 954 &pc_val, cs->cr, NULL); 955 if (sattr_error || pc_val == 0) 956 (void) VOP_PATHCONF(vp, 957 _PC_XATTR_EXISTS, 958 &pc_val, 959 cs->cr, NULL); 960 } 961 isit = (pc_val ? TRUE : FALSE); 962 IXDR_PUT_U_INT32(ptr, isit); 963 } 964 if (ae & FATTR4_FSID_MASK) { 965 u_longlong_t major, minor; 966 struct exportinfo *exi; 967 968 exi = newexi ? newexi : cs->exi; 969 if (fs_migrated) { 970 major = 1; 971 minor = 0; 972 } else if (exi->exi_volatile_dev) { 973 int *pmaj = (int *)&major; 974 975 pmaj[0] = exi->exi_fsid.val[0]; 976 pmaj[1] = exi->exi_fsid.val[1]; 977 minor = 0; 978 } else { 979 major = getmajor(va.va_fsid); 980 minor = getminor(va.va_fsid); 981 } 982 IXDR_PUT_HYPER(ptr, major); 983 IXDR_PUT_HYPER(ptr, minor); 984 } 985 if (ae & FATTR4_UNIQUE_HANDLES_MASK) { 986 IXDR_PUT_U_INT32(ptr, false); 987 } 988 if (ae & FATTR4_LEASE_TIME_MASK) { 989 uint_t lt = rfs4_lease_time; 990 IXDR_PUT_U_INT32(ptr, lt); 991 } 992 if (ae & FATTR4_RDATTR_ERROR_MASK) { 993 rddirattr_error = 994 (rddirattr_error == 0 ? 995 0 : puterrno4(rddirattr_error)); 996 IXDR_PUT_U_INT32(ptr, rddirattr_error); 997 } 998 999 /* Check the redzone boundary */ 1000 if (ptr > ptr_redzone) { 1001 no_space = TRUE; 1002 break; 1003 } 1004 } 1005 /* 1006 * Redzone check is done at the end of this section. 1007 * This particular section will encode a maximum of 1008 * 4 * BYTES_PER_XDR_UNIT of data. 1009 * NOTE: that if ACLs are supported that the 1010 * redzone calculations will need to change. 1011 */ 1012 if (ae & 1013 (FATTR4_ACL_MASK | 1014 FATTR4_ACLSUPPORT_MASK | 1015 FATTR4_ARCHIVE_MASK | 1016 FATTR4_CANSETTIME_MASK | 1017 FATTR4_CASE_INSENSITIVE_MASK | 1018 FATTR4_CASE_PRESERVING_MASK | 1019 FATTR4_CHOWN_RESTRICTED_MASK)) { 1020 1021 if (ae & FATTR4_ACL_MASK) { 1022 ASSERT(0); 1023 } 1024 if (ae & FATTR4_ACLSUPPORT_MASK) { 1025 ASSERT(0); 1026 } 1027 if (ae & FATTR4_ARCHIVE_MASK) { 1028 ASSERT(0); 1029 } 1030 if (ae & FATTR4_CANSETTIME_MASK) { 1031 IXDR_PUT_U_INT32(ptr, true); 1032 } 1033 if (ae & FATTR4_CASE_INSENSITIVE_MASK) { 1034 IXDR_PUT_U_INT32(ptr, false); 1035 } 1036 if (ae & FATTR4_CASE_PRESERVING_MASK) { 1037 IXDR_PUT_U_INT32(ptr, true); 1038 } 1039 if (ae & FATTR4_CHOWN_RESTRICTED_MASK) { 1040 uint_t isit; 1041 pc_val = FALSE; 1042 (void) VOP_PATHCONF(vp, 1043 _PC_CHOWN_RESTRICTED, 1044 &pc_val, cs->cr, NULL); 1045 isit = (pc_val ? TRUE : FALSE); 1046 IXDR_PUT_U_INT32(ptr, isit); 1047 } 1048 /* Check the redzone boundary */ 1049 if (ptr > ptr_redzone) { 1050 no_space = TRUE; 1051 break; 1052 } 1053 } 1054 /* 1055 * Redzone check is done before the filehandle 1056 * is encoded. 1057 */ 1058 if (ae & 1059 (FATTR4_FILEHANDLE_MASK | 1060 FATTR4_FILEID_MASK)) { 1061 1062 if (ae & FATTR4_FILEHANDLE_MASK) { 1063 struct { 1064 uint_t len; 1065 char *val; 1066 char fh[NFS_FH4_LEN]; 1067 } fh; 1068 fh.len = 0; 1069 fh.val = fh.fh; 1070 (void) makefh4((nfs_fh4 *)&fh, vp, 1071 (newexi ? newexi : cs->exi)); 1072 1073 if (dvp->v_flag & V_XATTRDIR) 1074 set_fh4_flag((nfs_fh4 *)&fh, 1075 FH4_NAMEDATTR); 1076 1077 if (!xdr_inline_encode_nfs_fh4( 1078 &ptr, ptr_redzone, 1079 (nfs_fh4_fmt_t *)fh.val)) { 1080 no_space = TRUE; 1081 break; 1082 } 1083 } 1084 if (ae & FATTR4_FILEID_MASK) { 1085 IXDR_PUT_HYPER(ptr, va.va_nodeid); 1086 } 1087 /* Check the redzone boundary */ 1088 if (ptr > ptr_redzone) { 1089 no_space = TRUE; 1090 break; 1091 } 1092 } 1093 1094 /* 1095 * Redzone check is done at the end of this section. 1096 * This particular section will encode a maximum of 1097 * 6 * BYTES_PER_XDR_UNIT of data. 1098 */ 1099 if (ae & 1100 (FATTR4_FILES_AVAIL_MASK | 1101 FATTR4_FILES_FREE_MASK | 1102 FATTR4_FILES_TOTAL_MASK)) { 1103 1104 if (ae & FATTR4_FILES_AVAIL_MASK) { 1105 IXDR_PUT_HYPER(ptr, sbe.fa); 1106 } 1107 if (ae & FATTR4_FILES_FREE_MASK) { 1108 IXDR_PUT_HYPER(ptr, sbe.ff); 1109 } 1110 if (ae & FATTR4_FILES_TOTAL_MASK) { 1111 IXDR_PUT_HYPER(ptr, sbe.ft); 1112 } 1113 1114 /* Check the redzone boundary */ 1115 if (ptr > ptr_redzone) { 1116 no_space = TRUE; 1117 break; 1118 } 1119 } 1120 1121 /* 1122 * Handle fs_locations separately. 1123 * This can be quite slow for referrals. Usually 1124 * clients don't use this attribute in readdir. 1125 */ 1126 if (ae & FATTR4_FS_LOCATIONS_MASK) { 1127 fs_locations4 *p; 1128 fs_locations4 fs; 1129 bool_t pushed; 1130 XDR xdr; 1131 1132 (void) memset(&fs, 0, sizeof (fs_locations4)); 1133 1134 ASSERT(vp); 1135 p = fetch_referral(vp, cs->cr); 1136 if (p != NULL) { 1137 fs = *p; 1138 kmem_free(p, sizeof (fs_locations4)); 1139 } 1140 1141 ASSERT(ptr_redzone >= ptr); 1142 ASSERT((uintptr_t)ptr_redzone - (uintptr_t)ptr 1143 <= UINT_MAX); 1144 xdrmem_create(&xdr, (caddr_t)ptr, 1145 (uintptr_t)ptr_redzone - (uintptr_t)ptr, 1146 XDR_ENCODE); 1147 1148 pushed = xdr_fattr4_fs_locations(&xdr, &fs); 1149 if (pushed) 1150 ptr = (uint32_t *)((char *)ptr + 1151 xdr_getpos(&xdr)); 1152 1153 xdr_destroy(&xdr); 1154 rfs4_free_fs_locations4(&fs); 1155 1156 if (!pushed || ptr > ptr_redzone) { 1157 no_space = TRUE; 1158 break; 1159 } 1160 } 1161 1162 if (ae & 1163 (FATTR4_HIDDEN_MASK | 1164 FATTR4_HOMOGENEOUS_MASK | 1165 FATTR4_MAXFILESIZE_MASK | 1166 FATTR4_MAXLINK_MASK | 1167 FATTR4_MAXNAME_MASK | 1168 FATTR4_MAXREAD_MASK | 1169 FATTR4_MAXWRITE_MASK)) { 1170 1171 if (ae & FATTR4_HIDDEN_MASK) { 1172 ASSERT(0); 1173 } 1174 if (ae & FATTR4_HOMOGENEOUS_MASK) { 1175 IXDR_PUT_U_INT32(ptr, true); 1176 } 1177 if (ae & FATTR4_MAXFILESIZE_MASK) { 1178 IXDR_PUT_HYPER(ptr, pce.maxfilesize); 1179 } 1180 if (ae & FATTR4_MAXLINK_MASK) { 1181 IXDR_PUT_U_INT32(ptr, pce.maxlink); 1182 } 1183 if (ae & FATTR4_MAXNAME_MASK) { 1184 IXDR_PUT_U_INT32(ptr, pce.maxname); 1185 } 1186 if (ae & FATTR4_MAXREAD_MASK) { 1187 IXDR_PUT_HYPER(ptr, maxread); 1188 } 1189 if (ae & FATTR4_MAXWRITE_MASK) { 1190 IXDR_PUT_HYPER(ptr, maxwrite); 1191 } 1192 /* Check the redzone boundary */ 1193 if (ptr > ptr_redzone) { 1194 no_space = TRUE; 1195 break; 1196 } 1197 } 1198 } 1199 1200 if (ae & 0x00000000ffffffff) { 1201 /* 1202 * Redzone check is done at the end of this section. 1203 * This particular section will encode a maximum of 1204 * 3 * BYTES_PER_XDR_UNIT of data. 1205 */ 1206 if (ae & 1207 (FATTR4_MIMETYPE_MASK | 1208 FATTR4_MODE_MASK | 1209 FATTR4_NO_TRUNC_MASK | 1210 FATTR4_NUMLINKS_MASK)) { 1211 1212 if (ae & FATTR4_MIMETYPE_MASK) { 1213 ASSERT(0); 1214 } 1215 if (ae & FATTR4_MODE_MASK) { 1216 uint_t m = va.va_mode; 1217 IXDR_PUT_U_INT32(ptr, m); 1218 } 1219 if (ae & FATTR4_NO_TRUNC_MASK) { 1220 IXDR_PUT_U_INT32(ptr, true); 1221 } 1222 if (ae & FATTR4_NUMLINKS_MASK) { 1223 IXDR_PUT_U_INT32(ptr, va.va_nlink); 1224 } 1225 /* Check the redzone boundary */ 1226 if (ptr > ptr_redzone) { 1227 no_space = TRUE; 1228 break; 1229 } 1230 } 1231 /* 1232 * Redzone check is done before the encoding of the 1233 * owner string since the length is indeterminate. 1234 */ 1235 if (ae & FATTR4_OWNER_MASK) { 1236 if (!lu_set) { 1237 owner_error = nfs_idmap_uid_str( 1238 va.va_uid, &owner, TRUE); 1239 if (!owner_error) { 1240 lu_set = TRUE; 1241 lastuid = va.va_uid; 1242 } 1243 } else if (va.va_uid != lastuid) { 1244 if (owner.utf8string_len != 0) { 1245 kmem_free(owner.utf8string_val, 1246 owner.utf8string_len); 1247 owner.utf8string_len = 0; 1248 owner.utf8string_val = NULL; 1249 } 1250 owner_error = nfs_idmap_uid_str( 1251 va.va_uid, &owner, TRUE); 1252 if (!owner_error) { 1253 lastuid = va.va_uid; 1254 } else { 1255 lu_set = FALSE; 1256 } 1257 } 1258 if (!owner_error) { 1259 if ((ptr + 1260 (owner.utf8string_len / 1261 BYTES_PER_XDR_UNIT) 1262 + 2) > ptr_redzone) { 1263 no_space = TRUE; 1264 break; 1265 } 1266 /* encode the LENGTH of owner string */ 1267 IXDR_PUT_U_INT32(ptr, 1268 owner.utf8string_len); 1269 /* encode the RNDUP FILL first */ 1270 rndup = RNDUP(owner.utf8string_len) / 1271 BYTES_PER_XDR_UNIT; 1272 ptr[rndup - 1] = 0; 1273 /* encode the OWNER */ 1274 bcopy(owner.utf8string_val, ptr, 1275 owner.utf8string_len); 1276 ptr += rndup; 1277 } 1278 } 1279 /* 1280 * Redzone check is done before the encoding of the 1281 * group string since the length is indeterminate. 1282 */ 1283 if (ae & FATTR4_OWNER_GROUP_MASK) { 1284 if (!lg_set) { 1285 group_error = 1286 nfs_idmap_gid_str(va.va_gid, 1287 &group, TRUE); 1288 if (!group_error) { 1289 lg_set = TRUE; 1290 lastgid = va.va_gid; 1291 } 1292 } else if (va.va_gid != lastgid) { 1293 if (group.utf8string_len != 0) { 1294 kmem_free( 1295 group.utf8string_val, 1296 group.utf8string_len); 1297 group.utf8string_len = 0; 1298 group.utf8string_val = NULL; 1299 } 1300 group_error = 1301 nfs_idmap_gid_str(va.va_gid, 1302 &group, TRUE); 1303 if (!group_error) 1304 lastgid = va.va_gid; 1305 else 1306 lg_set = FALSE; 1307 } 1308 if (!group_error) { 1309 if ((ptr + 1310 (group.utf8string_len / 1311 BYTES_PER_XDR_UNIT) 1312 + 2) > ptr_redzone) { 1313 no_space = TRUE; 1314 break; 1315 } 1316 /* encode the LENGTH of owner string */ 1317 IXDR_PUT_U_INT32(ptr, 1318 group.utf8string_len); 1319 /* encode the RNDUP FILL first */ 1320 rndup = RNDUP(group.utf8string_len) / 1321 BYTES_PER_XDR_UNIT; 1322 ptr[rndup - 1] = 0; 1323 /* encode the OWNER */ 1324 bcopy(group.utf8string_val, ptr, 1325 group.utf8string_len); 1326 ptr += rndup; 1327 } 1328 } 1329 if (ae & 1330 (FATTR4_QUOTA_AVAIL_HARD_MASK | 1331 FATTR4_QUOTA_AVAIL_SOFT_MASK | 1332 FATTR4_QUOTA_USED_MASK)) { 1333 if (ae & FATTR4_QUOTA_AVAIL_HARD_MASK) { 1334 ASSERT(0); 1335 } 1336 if (ae & FATTR4_QUOTA_AVAIL_SOFT_MASK) { 1337 ASSERT(0); 1338 } 1339 if (ae & FATTR4_QUOTA_USED_MASK) { 1340 ASSERT(0); 1341 } 1342 } 1343 /* 1344 * Redzone check is done at the end of this section. 1345 * This particular section will encode a maximum of 1346 * 10 * BYTES_PER_XDR_UNIT of data. 1347 */ 1348 if (ae & 1349 (FATTR4_RAWDEV_MASK | 1350 FATTR4_SPACE_AVAIL_MASK | 1351 FATTR4_SPACE_FREE_MASK | 1352 FATTR4_SPACE_TOTAL_MASK | 1353 FATTR4_SPACE_USED_MASK | 1354 FATTR4_SYSTEM_MASK)) { 1355 1356 if (ae & FATTR4_RAWDEV_MASK) { 1357 fattr4_rawdev rd; 1358 rd.specdata1 = 1359 (uint32)getmajor(va.va_rdev); 1360 rd.specdata2 = 1361 (uint32)getminor(va.va_rdev); 1362 IXDR_PUT_U_INT32(ptr, rd.specdata1); 1363 IXDR_PUT_U_INT32(ptr, rd.specdata2); 1364 } 1365 if (ae & FATTR4_SPACE_AVAIL_MASK) { 1366 IXDR_PUT_HYPER(ptr, sbe.space_avail); 1367 } 1368 if (ae & FATTR4_SPACE_FREE_MASK) { 1369 IXDR_PUT_HYPER(ptr, sbe.space_free); 1370 } 1371 if (ae & FATTR4_SPACE_TOTAL_MASK) { 1372 IXDR_PUT_HYPER(ptr, sbe.space_total); 1373 } 1374 if (ae & FATTR4_SPACE_USED_MASK) { 1375 u_longlong_t su; 1376 su = (fattr4_space_used) DEV_BSIZE * 1377 (fattr4_space_used) va.va_nblocks; 1378 IXDR_PUT_HYPER(ptr, su); 1379 } 1380 if (ae & FATTR4_SYSTEM_MASK) { 1381 ASSERT(0); 1382 } 1383 /* Check the redzone boundary */ 1384 if (ptr > ptr_redzone) { 1385 no_space = TRUE; 1386 break; 1387 } 1388 } 1389 /* 1390 * Redzone check is done at the end of this section. 1391 * This particular section will encode a maximum of 1392 * 14 * BYTES_PER_XDR_UNIT of data. 1393 */ 1394 if (ae & 1395 (FATTR4_TIME_ACCESS_MASK | 1396 FATTR4_TIME_ACCESS_SET_MASK | 1397 FATTR4_TIME_BACKUP_MASK | 1398 FATTR4_TIME_CREATE_MASK | 1399 FATTR4_TIME_DELTA_MASK | 1400 FATTR4_TIME_METADATA_MASK | 1401 FATTR4_TIME_MODIFY_MASK | 1402 FATTR4_TIME_MODIFY_SET_MASK | 1403 FATTR4_MOUNTED_ON_FILEID_MASK)) { 1404 1405 if (ae & FATTR4_TIME_ACCESS_MASK) { 1406 u_longlong_t sec = 1407 (u_longlong_t)va.va_atime.tv_sec; 1408 uint_t nsec = 1409 (uint_t)va.va_atime.tv_nsec; 1410 IXDR_PUT_HYPER(ptr, sec); 1411 IXDR_PUT_INT32(ptr, nsec); 1412 } 1413 if (ae & FATTR4_TIME_ACCESS_SET_MASK) { 1414 ASSERT(0); 1415 } 1416 if (ae & FATTR4_TIME_BACKUP_MASK) { 1417 ASSERT(0); 1418 } 1419 if (ae & FATTR4_TIME_CREATE_MASK) { 1420 ASSERT(0); 1421 } 1422 if (ae & FATTR4_TIME_DELTA_MASK) { 1423 u_longlong_t sec = 0; 1424 uint_t nsec = 1000; 1425 IXDR_PUT_HYPER(ptr, sec); 1426 IXDR_PUT_INT32(ptr, nsec); 1427 } 1428 if (ae & FATTR4_TIME_METADATA_MASK) { 1429 u_longlong_t sec = 1430 (u_longlong_t)va.va_ctime.tv_sec; 1431 uint_t nsec = 1432 (uint_t)va.va_ctime.tv_nsec; 1433 IXDR_PUT_HYPER(ptr, sec); 1434 IXDR_PUT_INT32(ptr, nsec); 1435 } 1436 if (ae & FATTR4_TIME_MODIFY_MASK) { 1437 u_longlong_t sec = 1438 (u_longlong_t)va.va_mtime.tv_sec; 1439 uint_t nsec = 1440 (uint_t)va.va_mtime.tv_nsec; 1441 IXDR_PUT_HYPER(ptr, sec); 1442 IXDR_PUT_INT32(ptr, nsec); 1443 } 1444 if (ae & FATTR4_TIME_MODIFY_SET_MASK) { 1445 ASSERT(0); 1446 } 1447 if (ae & FATTR4_MOUNTED_ON_FILEID_MASK) { 1448 IXDR_PUT_HYPER(ptr, dp->d_ino); 1449 } 1450 /* Check the redzone boundary */ 1451 if (ptr > ptr_redzone) { 1452 no_space = TRUE; 1453 break; 1454 } 1455 } 1456 } 1457 1458 /* Reset to directory's vfs info when encoding complete */ 1459 if (vfs_different) { 1460 dsbe = sbe; 1461 dpce = pce; 1462 vfs_different = 0; 1463 } 1464 1465 /* "go back" and encode the attributes' length */ 1466 attr_length = 1467 (char *)ptr - 1468 (char *)attr_offset_ptr - 1469 BYTES_PER_XDR_UNIT; 1470 IXDR_PUT_U_INT32(attr_offset_ptr, attr_length); 1471 1472 /* 1473 * If there was trouble obtaining a mapping for either 1474 * the owner or group attributes, then remove them from 1475 * bitmap4 for this entry and reset the bitmap value 1476 * in the data stream. 1477 */ 1478 if (owner_error || group_error) { 1479 if (owner_error) 1480 ae &= ~FATTR4_OWNER_MASK; 1481 if (group_error) 1482 ae &= ~FATTR4_OWNER_GROUP_MASK; 1483 IXDR_PUT_HYPER(attrmask_ptr, ae); 1484 } 1485 1486 /* END OF ATTRIBUTE ENCODING */ 1487 1488 lastentry_ptr = ptr; 1489 nents++; 1490 rddir_next_offset = dp->d_off; 1491 } 1492 1493 /* 1494 * Check for the case that another VOP_READDIR() has to be done. 1495 * - no space encoding error 1496 * - no entry successfully encoded 1497 * - still more directory to read 1498 */ 1499 if (!no_space && nents == 0 && !iseofdir) 1500 goto readagain; 1501 1502 /* 1503 * If no_space is set then we terminated prematurely, 1504 * rewind to the last entry and this can never be EOF. 1505 */ 1506 if (no_space) { 1507 ptr = lastentry_ptr; 1508 eof = FALSE; /* ended encoded prematurely */ 1509 } else { 1510 eof = (iseofdir ? TRUE : FALSE); 1511 } 1512 1513 /* 1514 * If we have entries, always return them, otherwise only error 1515 * if we ran out of space. 1516 */ 1517 if (nents || !no_space) { 1518 ASSERT(ptr != NULL); 1519 /* encode the BOOLEAN marking no further entries */ 1520 IXDR_PUT_U_INT32(ptr, false); 1521 /* encode the BOOLEAN signifying end of directory */ 1522 IXDR_PUT_U_INT32(ptr, eof); 1523 1524 resp->data_len = (char *)ptr - (char *)beginning_ptr; 1525 resp->mblk->b_wptr += resp->data_len; 1526 } else { 1527 status = NFS4ERR_TOOSMALL; 1528 } 1529 1530 out_free: 1531 if (status != NFS4_OK) { 1532 freeb(mp); 1533 resp->mblk = NULL; 1534 resp->data_len = 0; 1535 } 1536 1537 *cs->statusp = resp->status = status; 1538 1539 kmem_free((caddr_t)rddir_data, rddir_data_len); 1540 if (vp) 1541 VN_RELE(vp); 1542 if (owner.utf8string_len != 0) 1543 kmem_free(owner.utf8string_val, owner.utf8string_len); 1544 if (group.utf8string_len != 0) 1545 kmem_free(group.utf8string_val, group.utf8string_len); 1546 1547 out: 1548 DTRACE_NFSV4_2(op__readdir__done, struct compound_state *, cs, 1549 READDIR4res *, resp); 1550 } 1551