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