xref: /titanic_50/usr/src/uts/common/fs/nfs/nfs4_xdr.c (revision 52244c0958bdf281ca42932b449f644b4decfdc2)
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 2010 Sun Microsystems, Inc.  All rights reserved.
28  * Use is subject to license terms.
29  */
30 /*
31  * Copyright (c) 2013 by Delphix. All rights reserved.
32  */
33 
34 /*
35  * A handcoded version based on the original rpcgen code.
36  *
37  * Note: All future NFS4 protocol changes should be added by hand
38  * to this file.
39  *
40  * CAUTION: All protocol changes must also be propagated to:
41  *     usr/src/cmd/cmd-inet/usr.sbin/snoop/nfs4_xdr.c
42  */
43 
44 #include <sys/types.h>
45 #include <sys/sunddi.h>
46 #include <sys/dnlc.h>
47 #include <nfs/nfs.h>
48 #include <nfs/nfs4_kprot.h>
49 #include <nfs/rnode4.h>
50 #include <nfs/nfs4.h>
51 #include <nfs/nfs4_clnt.h>
52 #include <sys/sdt.h>
53 #include <sys/mkdev.h>
54 #include <rpc/rpc_rdma.h>
55 #include <rpc/xdr.h>
56 
57 #define	xdr_dev_t xdr_u_int
58 
59 extern bool_t xdr_netbuf(XDR *, struct netbuf *);
60 extern bool_t xdr_vector(XDR *, char *, const uint_t, const uint_t,
61 	const xdrproc_t);
62 bool_t xdr_knetconfig(XDR *, struct knetconfig *);
63 
64 bool_t
65 xdr_bitmap4(XDR *xdrs, bitmap4 *objp)
66 {
67 	int32_t len, size;
68 
69 	if (xdrs->x_op == XDR_FREE)
70 		return (TRUE);
71 
72 	/*
73 	 * Simplified bitmap4 processing, always encode from uint64_t
74 	 * to 2 uint32_t's, always decode first 2 uint32_t's into a
75 	 * uint64_t and ignore all of the rest.
76 	 */
77 	if (xdrs->x_op == XDR_ENCODE) {
78 		len = 2;
79 
80 		if (!XDR_PUTINT32(xdrs, &len))
81 			return (FALSE);
82 
83 #if defined(_LITTLE_ENDIAN)
84 		if (XDR_PUTINT32(xdrs, (int32_t *)((char *)objp +
85 		    BYTES_PER_XDR_UNIT)) == TRUE) {
86 			return (XDR_PUTINT32(xdrs, (int32_t *)objp));
87 		}
88 #elif defined(_BIG_ENDIAN)
89 		if (XDR_PUTINT32(xdrs, (int32_t *)objp) == TRUE) {
90 			return (XDR_PUTINT32(xdrs, (int32_t *)((char *)objp +
91 			    BYTES_PER_XDR_UNIT)));
92 		}
93 #endif
94 		return (FALSE);
95 	}
96 
97 	if (!XDR_GETINT32(xdrs, &len))
98 		return (FALSE);
99 
100 	/*
101 	 * Common fast DECODE cases
102 	 */
103 	if (len == 2) {
104 #if defined(_LITTLE_ENDIAN)
105 		if (XDR_GETINT32(xdrs, (int32_t *)((char *)objp +
106 		    BYTES_PER_XDR_UNIT)) == TRUE) {
107 			return (XDR_GETINT32(xdrs, (int32_t *)objp));
108 		}
109 #elif defined(_BIG_ENDIAN)
110 		if (XDR_GETINT32(xdrs, (int32_t *)objp) == TRUE) {
111 			return (XDR_GETINT32(xdrs, (int32_t *)((char *)objp +
112 			    BYTES_PER_XDR_UNIT)));
113 		}
114 #endif
115 		return (FALSE);
116 	}
117 
118 	*objp = 0;
119 	if (len == 0)
120 		return (TRUE);
121 
122 	/*
123 	 * The not so common DECODE cases, len == 1 || len > 2
124 	 */
125 #if defined(_LITTLE_ENDIAN)
126 	if (!XDR_GETINT32(xdrs, (int32_t *)((char *)objp + BYTES_PER_XDR_UNIT)))
127 		return (FALSE);
128 	if (--len == 0)
129 		return (TRUE);
130 	if (!XDR_GETINT32(xdrs, (int32_t *)objp))
131 		return (FALSE);
132 #elif defined(_BIG_ENDIAN)
133 	if (!XDR_GETINT32(xdrs, (int32_t *)objp))
134 		return (FALSE);
135 	if (--len == 0)
136 		return (TRUE);
137 	if (!XDR_GETINT32(xdrs, (int32_t *)((char *)objp + BYTES_PER_XDR_UNIT)))
138 		return (FALSE);
139 #else
140 	return (FALSE);
141 #endif
142 
143 	if (--len == 0)
144 		return (TRUE);
145 
146 	size = len * BYTES_PER_XDR_UNIT;
147 	return (XDR_CONTROL(xdrs, XDR_SKIPBYTES, &size));
148 }
149 
150 /* Called by xdr_array, nfsid_map_xdr */
151 bool_t
152 xdr_utf8string(XDR *xdrs, utf8string *objp)
153 {
154 	if (xdrs->x_op != XDR_FREE)
155 		return (xdr_bytes(xdrs, (char **)&objp->utf8string_val,
156 		    (uint_t *)&objp->utf8string_len, NFS4_MAX_UTF8STRING));
157 
158 	if (objp->utf8string_val != NULL) {
159 		kmem_free(objp->utf8string_val, objp->utf8string_len);
160 		objp->utf8string_val = NULL;
161 	}
162 	return (TRUE);
163 }
164 
165 /*
166  * used by NFSv4 referrals to get info needed for NFSv4 referral mount.
167  */
168 bool_t
169 xdr_nfs_fsl_info(XDR *xdrs, struct nfs_fsl_info *objp)
170 {
171 
172 	if (!xdr_u_int(xdrs, &objp->netbuf_len))
173 		return (FALSE);
174 	if (!xdr_u_int(xdrs, &objp->netnm_len))
175 		return (FALSE);
176 	if (!xdr_u_int(xdrs, &objp->knconf_len))
177 		return (FALSE);
178 
179 #if defined(_LP64)
180 	/*
181 	 * The object can come from a 32-bit binary; nfsmapid.
182 	 * To be safe we double the size of the knetconfig to
183 	 * allow some buffering for decoding.
184 	 */
185 	if (xdrs->x_op == XDR_DECODE)
186 		objp->knconf_len += sizeof (struct knetconfig);
187 #endif
188 
189 	if (!xdr_string(xdrs, &objp->netname, ~0))
190 		return (FALSE);
191 	if (!xdr_pointer(xdrs, (char **)&objp->addr, objp->netbuf_len,
192 	    (xdrproc_t)xdr_netbuf))
193 		return (FALSE);
194 	if (!xdr_pointer(xdrs, (char **)&objp->knconf,
195 	    objp->knconf_len, (xdrproc_t)xdr_knetconfig))
196 		return (FALSE);
197 	return (TRUE);
198 }
199 
200 bool_t
201 xdr_knetconfig(XDR *xdrs, struct knetconfig *objp)
202 {
203 	rpc_inline_t *buf;
204 	u_longlong_t dev64;
205 #if !defined(_LP64)
206 	uint32_t major, minor;
207 #endif
208 	int i;
209 
210 	if (!xdr_u_int(xdrs, &objp->knc_semantics))
211 		return (FALSE);
212 	if (xdrs->x_op == XDR_DECODE) {
213 		objp->knc_protofmly = (((char *)objp) +
214 		    sizeof (struct knetconfig));
215 		objp->knc_proto = objp->knc_protofmly + KNC_STRSIZE;
216 	}
217 	if (!xdr_opaque(xdrs, objp->knc_protofmly, KNC_STRSIZE))
218 		return (FALSE);
219 	if (!xdr_opaque(xdrs, objp->knc_proto, KNC_STRSIZE))
220 		return (FALSE);
221 
222 	/*
223 	 * For interoperability between 32-bit daemon and 64-bit kernel,
224 	 * we always treat dev_t as 64-bit number and do the expanding
225 	 * or compression of dev_t as needed.
226 	 * We have to hand craft the conversion since there is no available
227 	 * function in ddi.c. Besides ddi.c is available only in the kernel
228 	 * and we want to keep both user and kernel of xdr_knetconfig() the
229 	 * same for consistency.
230 	 */
231 	if (xdrs->x_op == XDR_ENCODE) {
232 #if defined(_LP64)
233 		dev64 = objp->knc_rdev;
234 #else
235 		major = (objp->knc_rdev >> NBITSMINOR32) & MAXMAJ32;
236 		minor = objp->knc_rdev & MAXMIN32;
237 		dev64 = (((unsigned long long)major) << NBITSMINOR64) | minor;
238 #endif
239 		if (!xdr_u_longlong_t(xdrs, &dev64))
240 			return (FALSE);
241 	}
242 	if (xdrs->x_op == XDR_DECODE) {
243 #if defined(_LP64)
244 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->knc_rdev))
245 			return (FALSE);
246 #else
247 		if (!xdr_u_longlong_t(xdrs, &dev64))
248 			return (FALSE);
249 
250 		major = (dev64 >> NBITSMINOR64) & L_MAXMAJ32;
251 		minor = dev64 & L_MAXMIN32;
252 		objp->knc_rdev = (major << L_BITSMINOR32) | minor;
253 #endif
254 	}
255 
256 	if (xdrs->x_op == XDR_ENCODE) {
257 		buf = XDR_INLINE(xdrs, (8) * BYTES_PER_XDR_UNIT);
258 		if (buf == NULL) {
259 			if (!xdr_vector(xdrs, (char *)objp->knc_unused, 8,
260 			    sizeof (uint_t), (xdrproc_t)xdr_u_int))
261 				return (FALSE);
262 		} else {
263 			uint_t *genp;
264 
265 			for (i = 0, genp = objp->knc_unused;
266 			    i < 8; i++) {
267 #if defined(_LP64) || defined(_KERNEL)
268 				IXDR_PUT_U_INT32(buf, *genp++);
269 #else
270 				IXDR_PUT_U_LONG(buf, *genp++);
271 #endif
272 			}
273 		}
274 		return (TRUE);
275 	} else if (xdrs->x_op == XDR_DECODE) {
276 		buf = XDR_INLINE(xdrs, (8) * BYTES_PER_XDR_UNIT);
277 		if (buf == NULL) {
278 			if (!xdr_vector(xdrs, (char *)objp->knc_unused, 8,
279 			    sizeof (uint_t), (xdrproc_t)xdr_u_int))
280 				return (FALSE);
281 		} else {
282 			uint_t *genp;
283 
284 			for (i = 0, genp = objp->knc_unused;
285 			    i < 8; i++) {
286 #if defined(_LP64) || defined(_KERNEL)
287 					*genp++ = IXDR_GET_U_INT32(buf);
288 #else
289 					*genp++ = IXDR_GET_U_LONG(buf);
290 #endif
291 			}
292 		}
293 		return (TRUE);
294 	}
295 
296 	if (!xdr_vector(xdrs, (char *)objp->knc_unused, 8,
297 	    sizeof (uint_t), (xdrproc_t)xdr_u_int))
298 		return (FALSE);
299 	return (TRUE);
300 }
301 
302 /*
303  * XDR_INLINE decode a filehandle.
304  */
305 bool_t
306 xdr_inline_decode_nfs_fh4(uint32_t *ptr, nfs_fh4_fmt_t *fhp, uint32_t fhsize)
307 {
308 	uchar_t *bp = (uchar_t *)ptr;
309 	uchar_t *cp;
310 	uint32_t dsize;
311 	uintptr_t resid;
312 
313 	/*
314 	 * Check to see if what the client sent us is bigger or smaller
315 	 * than what we can ever possibly send out. NFS_FHMAXDATA is
316 	 * unfortunately badly named as it is no longer the max and is
317 	 * really the min of what is sent over the wire.
318 	 */
319 	if (fhsize > sizeof (nfs_fh4_fmt_t) || fhsize < (sizeof (fsid_t) +
320 	    sizeof (ushort_t) + NFS_FHMAXDATA +
321 	    sizeof (ushort_t) + NFS_FHMAXDATA)) {
322 		return (FALSE);
323 	}
324 
325 	/*
326 	 * All internal parts of a filehandle are in native byte order.
327 	 *
328 	 * Decode what should be fh4_fsid, it is aligned.
329 	 */
330 	fhp->fh4_fsid.val[0] = *(uint32_t *)bp;
331 	bp += BYTES_PER_XDR_UNIT;
332 	fhp->fh4_fsid.val[1] = *(uint32_t *)bp;
333 	bp += BYTES_PER_XDR_UNIT;
334 
335 	/*
336 	 * Decode what should be fh4_len.  fh4_len is two bytes, so we're
337 	 * unaligned now.
338 	 */
339 	cp = (uchar_t *)&fhp->fh4_len;
340 	*cp++ = *bp++;
341 	*cp++ = *bp++;
342 	fhsize -= 2 * BYTES_PER_XDR_UNIT + sizeof (ushort_t);
343 
344 	/*
345 	 * For backwards compatibility, the fid length may be less than
346 	 * NFS_FHMAXDATA, but it was always encoded as NFS_FHMAXDATA bytes.
347 	 */
348 	dsize = fhp->fh4_len < NFS_FHMAXDATA ? NFS_FHMAXDATA : fhp->fh4_len;
349 
350 	/*
351 	 * Make sure the client isn't sending us a bogus length for fh4_data.
352 	 */
353 	if (fhsize < dsize)
354 		return (FALSE);
355 	bcopy(bp, fhp->fh4_data, dsize);
356 	bp += dsize;
357 	fhsize -= dsize;
358 
359 	if (fhsize < sizeof (ushort_t))
360 		return (FALSE);
361 	cp = (uchar_t *)&fhp->fh4_xlen;
362 	*cp++ = *bp++;
363 	*cp++ = *bp++;
364 	fhsize -= sizeof (ushort_t);
365 
366 	dsize = fhp->fh4_xlen < NFS_FHMAXDATA ? NFS_FHMAXDATA : fhp->fh4_xlen;
367 
368 	/*
369 	 * Make sure the client isn't sending us a bogus length for fh4_xdata.
370 	 */
371 	if (fhsize < dsize)
372 		return (FALSE);
373 	bcopy(bp, fhp->fh4_xdata, dsize);
374 	fhsize -= dsize;
375 	bp += dsize;
376 
377 	/*
378 	 * We realign things on purpose, so skip any padding
379 	 */
380 	resid = (uintptr_t)bp % BYTES_PER_XDR_UNIT;
381 	if (resid != 0) {
382 		if (fhsize < (BYTES_PER_XDR_UNIT - resid))
383 			return (FALSE);
384 		bp += BYTES_PER_XDR_UNIT - resid;
385 		fhsize -= BYTES_PER_XDR_UNIT - resid;
386 	}
387 
388 	if (fhsize < BYTES_PER_XDR_UNIT)
389 		return (FALSE);
390 	fhp->fh4_flag = *(uint32_t *)bp;
391 	bp += BYTES_PER_XDR_UNIT;
392 	fhsize -= BYTES_PER_XDR_UNIT;
393 
394 #ifdef VOLATILE_FH_TEST
395 	if (fhsize < BYTES_PER_XDR_UNIT)
396 		return (FALSE);
397 	fhp->fh4_volatile_id = *(uint32_t *)bp;
398 	bp += BYTES_PER_XDR_UNIT;
399 	fhsize -= BYTES_PER_XDR_UNIT;
400 #endif
401 	/*
402 	 * Make sure client didn't send extra bytes
403 	 */
404 	if (fhsize != 0)
405 		return (FALSE);
406 	return (TRUE);
407 }
408 
409 static bool_t
410 xdr_decode_nfs_fh4(XDR *xdrs, nfs_fh4 *objp)
411 {
412 	uint32_t fhsize;		/* filehandle size */
413 	uint32_t bufsize;
414 	rpc_inline_t *ptr;
415 	uchar_t *bp;
416 
417 	ASSERT(xdrs->x_op == XDR_DECODE);
418 
419 	/*
420 	 * Retrieve the filehandle length.
421 	 */
422 	if (!XDR_GETINT32(xdrs, (int32_t *)&fhsize))
423 		return (FALSE);
424 
425 	objp->nfs_fh4_val = NULL;
426 	objp->nfs_fh4_len = 0;
427 
428 	/*
429 	 * Check to see if what the client sent us is bigger or smaller
430 	 * than what we can ever possibly send out. NFS_FHMAXDATA is
431 	 * unfortunately badly named as it is no longer the max and is
432 	 * really the min of what is sent over the wire.
433 	 */
434 	if (fhsize > sizeof (nfs_fh4_fmt_t) || fhsize < (sizeof (fsid_t) +
435 	    sizeof (ushort_t) + NFS_FHMAXDATA +
436 	    sizeof (ushort_t) + NFS_FHMAXDATA)) {
437 		if (!XDR_CONTROL(xdrs, XDR_SKIPBYTES, &fhsize))
438 			return (FALSE);
439 		return (TRUE);
440 	}
441 
442 	/*
443 	 * bring in fhsize plus any padding
444 	 */
445 	bufsize = RNDUP(fhsize);
446 	ptr = XDR_INLINE(xdrs, bufsize);
447 	bp = (uchar_t *)ptr;
448 	if (ptr == NULL) {
449 		bp = kmem_alloc(bufsize, KM_SLEEP);
450 		if (!xdr_opaque(xdrs, (char *)bp, bufsize)) {
451 			kmem_free(bp, bufsize);
452 			return (FALSE);
453 		}
454 	}
455 
456 	objp->nfs_fh4_val = kmem_zalloc(sizeof (nfs_fh4_fmt_t), KM_SLEEP);
457 	objp->nfs_fh4_len = sizeof (nfs_fh4_fmt_t);
458 
459 	if (xdr_inline_decode_nfs_fh4((uint32_t *)bp,
460 	    (nfs_fh4_fmt_t *)objp->nfs_fh4_val, fhsize) == FALSE) {
461 		/*
462 		 * If in the process of decoding we find the file handle
463 		 * is not correctly formed, we need to continue decoding
464 		 * and trigger an NFS layer error. Set the nfs_fh4_len to
465 		 * zero so it gets caught as a bad length.
466 		 */
467 		kmem_free(objp->nfs_fh4_val, objp->nfs_fh4_len);
468 		objp->nfs_fh4_val = NULL;
469 		objp->nfs_fh4_len = 0;
470 	}
471 
472 	if (ptr == NULL)
473 		kmem_free(bp, bufsize);
474 	return (TRUE);
475 }
476 
477 /*
478  * XDR_INLINE encode a filehandle.
479  */
480 bool_t
481 xdr_inline_encode_nfs_fh4(uint32_t **ptrp, uint32_t *ptr_redzone,
482 	nfs_fh4_fmt_t *fhp)
483 {
484 	uint32_t *ptr = *ptrp;
485 	uchar_t *cp;
486 	uint_t otw_len, fsize, xsize;   /* otw, file, and export sizes */
487 	uint32_t padword;
488 
489 	fsize = fhp->fh4_len < NFS_FHMAXDATA ? NFS_FHMAXDATA : fhp->fh4_len;
490 	xsize = fhp->fh4_xlen < NFS_FHMAXDATA ? NFS_FHMAXDATA : fhp->fh4_xlen;
491 
492 	/*
493 	 * First get the initial and variable sized part of the filehandle.
494 	 */
495 	otw_len = sizeof (fhp->fh4_fsid) +
496 	    sizeof (fhp->fh4_len) + fsize +
497 	    sizeof (fhp->fh4_xlen) + xsize;
498 
499 	/*
500 	 * Round out to a full word.
501 	 */
502 	otw_len = RNDUP(otw_len);
503 	padword = (otw_len / BYTES_PER_XDR_UNIT);	/* includes fhlen */
504 
505 	/*
506 	 * Add in the fixed sized pieces.
507 	 */
508 	otw_len += sizeof (fhp->fh4_flag);
509 #ifdef VOLATILE_FH_TEST
510 	otw_len += sizeof (fhp->fh4_volatile_id);
511 #endif
512 
513 	/*
514 	 * Make sure we don't exceed our buffer.
515 	 */
516 	if ((ptr + (otw_len / BYTES_PER_XDR_UNIT) + 1) > ptr_redzone)
517 		return (FALSE);
518 
519 	/*
520 	 * Zero out the padding.
521 	 */
522 	ptr[padword] = 0;
523 
524 	IXDR_PUT_U_INT32(ptr, otw_len);
525 
526 	/*
527 	 * The rest of the filehandle is in native byteorder
528 	 */
529 	/* fh4_fsid */
530 	*ptr++ = (uint32_t)fhp->fh4_fsid.val[0];
531 	*ptr++ = (uint32_t)fhp->fh4_fsid.val[1];
532 
533 	/*
534 	 * Since the next pieces are unaligned, we need to
535 	 * do bytewise copies.
536 	 */
537 	cp = (uchar_t *)ptr;
538 
539 	/* fh4_len + fh4_data */
540 	bcopy(&fhp->fh4_len, cp, sizeof (fhp->fh4_len) + fsize);
541 	cp += sizeof (fhp->fh4_len) + fsize;
542 
543 	/* fh4_xlen + fh4_xdata */
544 	bcopy(&fhp->fh4_xlen, cp, sizeof (fhp->fh4_xlen) + xsize);
545 	cp += sizeof (fhp->fh4_xlen) + xsize;
546 
547 	/* do necessary rounding/padding */
548 	cp = (uchar_t *)RNDUP((uintptr_t)cp);
549 	ptr = (uint32_t *)cp;
550 
551 	/*
552 	 * With the above padding, we're word aligned again.
553 	 */
554 	ASSERT(((uintptr_t)ptr % BYTES_PER_XDR_UNIT) == 0);
555 
556 	/* fh4_flag */
557 	*ptr++ = (uint32_t)fhp->fh4_flag;
558 
559 #ifdef VOLATILE_FH_TEST
560 	/* fh4_volatile_id */
561 	*ptr++ = (uint32_t)fhp->fh4_volatile_id;
562 #endif
563 	*ptrp = ptr;
564 
565 	return (TRUE);
566 }
567 
568 static bool_t
569 xdr_encode_nfs_fh4(XDR *xdrs, nfs_fh4 *objp)
570 {
571 	uint_t otw_len, fsize, xsize;   /* otw, file, and export sizes */
572 	bool_t ret;
573 	rpc_inline_t *ptr;
574 	rpc_inline_t *buf = NULL;
575 	uint32_t *ptr_redzone;
576 	nfs_fh4_fmt_t *fhp;
577 
578 	ASSERT(xdrs->x_op == XDR_ENCODE);
579 
580 	fhp = (nfs_fh4_fmt_t *)objp->nfs_fh4_val;
581 	fsize = fhp->fh4_len < NFS_FHMAXDATA ? NFS_FHMAXDATA : fhp->fh4_len;
582 	xsize = fhp->fh4_xlen < NFS_FHMAXDATA ? NFS_FHMAXDATA : fhp->fh4_xlen;
583 
584 	/*
585 	 * First get the over the wire size, it is the 4 bytes
586 	 * for the length, plus the combined size of the
587 	 * file handle components.
588 	 */
589 	otw_len = BYTES_PER_XDR_UNIT + sizeof (fhp->fh4_fsid) +
590 	    sizeof (fhp->fh4_len) + fsize +
591 	    sizeof (fhp->fh4_xlen) + xsize +
592 	    sizeof (fhp->fh4_flag);
593 #ifdef VOLATILE_FH_TEST
594 	otw_len += sizeof (fhp->fh4_volatile_id);
595 #endif
596 	/*
597 	 * Round out to a full word.
598 	 */
599 	otw_len = RNDUP(otw_len);
600 
601 	/*
602 	 * Next try to inline the XDR stream, if that fails (rare)
603 	 * allocate a buffer to encode the file handle and then
604 	 * copy it using xdr_opaque and free the buffer.
605 	 */
606 	ptr = XDR_INLINE(xdrs, otw_len);
607 	if (ptr == NULL)
608 		ptr = buf = kmem_alloc(otw_len, KM_SLEEP);
609 
610 	ptr_redzone = (uint32_t *)(ptr + (otw_len / BYTES_PER_XDR_UNIT));
611 	ret = xdr_inline_encode_nfs_fh4((uint32_t **)&ptr, ptr_redzone, fhp);
612 
613 	if (buf != NULL) {
614 		if (ret == TRUE)
615 			ret = xdr_opaque(xdrs, (char *)buf, otw_len);
616 		kmem_free(buf, otw_len);
617 	}
618 	return (ret);
619 }
620 
621 /*
622  * XDR a NFSv4 filehandle.
623  * Encoding interprets the contents (server).
624  * Decoding the contents are opaque (client).
625  */
626 bool_t
627 xdr_nfs_fh4(XDR *xdrs, nfs_fh4 *objp)
628 {
629 	switch (xdrs->x_op) {
630 	case XDR_ENCODE:
631 		return (xdr_encode_nfs_fh4(xdrs, objp));
632 	case XDR_DECODE:
633 		return (xdr_bytes(xdrs, (char **)&objp->nfs_fh4_val,
634 		    (uint_t *)&objp->nfs_fh4_len, NFS4_FHSIZE));
635 	case XDR_FREE:
636 		if (objp->nfs_fh4_val != NULL) {
637 			kmem_free(objp->nfs_fh4_val, objp->nfs_fh4_len);
638 			objp->nfs_fh4_val = NULL;
639 		}
640 		return (TRUE);
641 	}
642 	return (FALSE);
643 }
644 
645 /* Called by xdr_array */
646 static bool_t
647 xdr_fs_location4(XDR *xdrs, fs_location4 *objp)
648 {
649 	if (xdrs->x_op == XDR_DECODE) {
650 		objp->server_val = NULL;
651 		objp->rootpath.pathname4_val = NULL;
652 	}
653 	if (!xdr_array(xdrs, (char **)&objp->server_val,
654 	    (uint_t *)&objp->server_len, NFS4_MAX_UTF8STRING,
655 	    sizeof (utf8string), (xdrproc_t)xdr_utf8string))
656 		return (FALSE);
657 	return (xdr_array(xdrs, (char **)&objp->rootpath.pathname4_val,
658 	    (uint_t *)&objp->rootpath.pathname4_len,
659 	    NFS4_MAX_PATHNAME4,
660 	    sizeof (utf8string), (xdrproc_t)xdr_utf8string));
661 }
662 
663 /* Called by xdr_array */
664 static bool_t
665 xdr_nfsace4(XDR *xdrs, nfsace4 *objp)
666 {
667 	if (xdrs->x_op != XDR_FREE) {
668 		if (!xdr_u_int(xdrs, &objp->type))
669 			return (FALSE);
670 		if (!xdr_u_int(xdrs, &objp->flag))
671 			return (FALSE);
672 		if (!xdr_u_int(xdrs, &objp->access_mask))
673 			return (FALSE);
674 
675 		if (xdrs->x_op == XDR_DECODE) {
676 			objp->who.utf8string_val = NULL;
677 			objp->who.utf8string_len = 0;
678 		}
679 
680 		return (xdr_bytes(xdrs, (char **)&objp->who.utf8string_val,
681 		    (uint_t *)&objp->who.utf8string_len,
682 		    NFS4_MAX_UTF8STRING));
683 	}
684 
685 	/*
686 	 * Optimized free case
687 	 */
688 	if (objp->who.utf8string_val != NULL) {
689 		kmem_free(objp->who.utf8string_val, objp->who.utf8string_len);
690 		objp->who.utf8string_val = NULL;
691 	}
692 	return (TRUE);
693 }
694 
695 /*
696  * These functions are called out of nfs4_attr.c
697  */
698 bool_t
699 xdr_fattr4_fsid(XDR *xdrs, fattr4_fsid *objp)
700 {
701 	if (xdrs->x_op == XDR_FREE)
702 		return (TRUE);
703 
704 	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->major))
705 		return (FALSE);
706 	return (xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->minor));
707 }
708 
709 
710 bool_t
711 xdr_fattr4_acl(XDR *xdrs, fattr4_acl *objp)
712 {
713 	return (xdr_array(xdrs, (char **)&objp->fattr4_acl_val,
714 	    (uint_t *)&objp->fattr4_acl_len, NFS4_ACL_LIMIT,
715 	    sizeof (nfsace4), (xdrproc_t)xdr_nfsace4));
716 }
717 
718 bool_t
719 xdr_fattr4_fs_locations(XDR *xdrs, fattr4_fs_locations *objp)
720 {
721 	if (xdrs->x_op == XDR_DECODE) {
722 		objp->fs_root.pathname4_len = 0;
723 		objp->fs_root.pathname4_val = NULL;
724 		objp->locations_val = NULL;
725 	}
726 	if (!xdr_array(xdrs, (char **)&objp->fs_root.pathname4_val,
727 	    (uint_t *)&objp->fs_root.pathname4_len,
728 	    NFS4_MAX_PATHNAME4,
729 	    sizeof (utf8string), (xdrproc_t)xdr_utf8string))
730 		return (FALSE);
731 	return (xdr_array(xdrs, (char **)&objp->locations_val,
732 	    (uint_t *)&objp->locations_len, NFS4_FS_LOCATIONS_LIMIT,
733 	    sizeof (fs_location4), (xdrproc_t)xdr_fs_location4));
734 }
735 
736 bool_t
737 xdr_fattr4_rawdev(XDR *xdrs, fattr4_rawdev *objp)
738 {
739 	if (xdrs->x_op == XDR_FREE)
740 		return (TRUE);
741 
742 	if (!xdr_u_int(xdrs, &objp->specdata1))
743 		return (FALSE);
744 	return (xdr_u_int(xdrs, &objp->specdata2));
745 }
746 
747 bool_t
748 xdr_nfstime4(XDR *xdrs, nfstime4 *objp)
749 {
750 	if (xdrs->x_op == XDR_FREE)
751 		return (TRUE);
752 
753 	if (!xdr_longlong_t(xdrs, (longlong_t *)&objp->seconds))
754 		return (FALSE);
755 	return (xdr_u_int(xdrs, &objp->nseconds));
756 }
757 
758 
759 /*
760  * structured used for calls into xdr_ga_fattr_res() as a means
761  * to do an immediate/short-term cache of owner/group strings
762  * for callers like the readdir processing.  In the case of readdir,
763  * it is likely that the directory objects will be owned by the same
764  * owner/group and if so there is no need to call into the uid/gid
765  * mapping code.  While the uid/gid interfaces have their own cache
766  * having one here will reduct pathlength further.
767  */
768 #define	MAX_OG_NAME 100
769 typedef struct ug_cache
770 {
771 	uid_t	uid;
772 	gid_t	gid;
773 	utf8string u_curr, u_last;
774 	utf8string g_curr, g_last;
775 	char	u_buf1[MAX_OG_NAME];
776 	char	u_buf2[MAX_OG_NAME];
777 	char	g_buf1[MAX_OG_NAME];
778 	char	g_buf2[MAX_OG_NAME];
779 } ug_cache_t;
780 
781 #define	U_SWAP_CURR_LAST(ug) \
782 	(ug)->u_last.utf8string_len = (ug)->u_curr.utf8string_len;	\
783 	if ((ug)->u_last.utf8string_val == (ug)->u_buf1) {		\
784 		(ug)->u_last.utf8string_val = (ug)->u_buf2;		\
785 		(ug)->u_curr.utf8string_val = (ug)->u_buf1;		\
786 	} else {							\
787 		(ug)->u_last.utf8string_val = (ug)->u_buf1;		\
788 		(ug)->u_curr.utf8string_val = (ug)->u_buf2;		\
789 	}
790 
791 #define	G_SWAP_CURR_LAST(ug) \
792 	(ug)->g_last.utf8string_len = (ug)->g_curr.utf8string_len;	\
793 	if ((ug)->g_last.utf8string_val == (ug)->g_buf1) {		\
794 		(ug)->g_last.utf8string_val = (ug)->g_buf2;		\
795 		(ug)->g_curr.utf8string_val = (ug)->g_buf1;		\
796 	} else {							\
797 		(ug)->g_last.utf8string_val = (ug)->g_buf1;		\
798 		(ug)->g_curr.utf8string_val = (ug)->g_buf2;		\
799 	}
800 
801 static ug_cache_t *
802 alloc_ugcache()
803 {
804 	ug_cache_t *pug = kmem_alloc(sizeof (ug_cache_t), KM_SLEEP);
805 
806 	pug->uid = pug->gid = 0;
807 	pug->u_curr.utf8string_len = 0;
808 	pug->u_last.utf8string_len = 0;
809 	pug->g_curr.utf8string_len = 0;
810 	pug->g_last.utf8string_len = 0;
811 	pug->u_curr.utf8string_val = pug->u_buf1;
812 	pug->u_last.utf8string_val = pug->u_buf2;
813 	pug->g_curr.utf8string_val = pug->g_buf1;
814 	pug->g_last.utf8string_val = pug->g_buf2;
815 
816 	return (pug);
817 }
818 
819 static void
820 xdr_ga_prefill_vattr(struct nfs4_ga_res *garp, struct mntinfo4 *mi)
821 {
822 	static vattr_t s_vattr = {
823 		AT_ALL,		/* va_mask */
824 		VNON,		/* va_type */
825 		0777,		/* va_mode */
826 		UID_NOBODY,	/* va_uid */
827 		GID_NOBODY,	/* va_gid */
828 		0,		/* va_fsid */
829 		0,		/* va_nodeid */
830 		1,		/* va_nlink */
831 		0,		/* va_size */
832 		{0, 0},		/* va_atime */
833 		{0, 0},		/* va_mtime */
834 		{0, 0},		/* va_ctime */
835 		0,		/* va_rdev */
836 		MAXBSIZE,	/* va_blksize */
837 		0,		/* va_nblocks */
838 		0		/* va_seq */
839 	};
840 
841 
842 	garp->n4g_va = s_vattr;
843 	garp->n4g_va.va_fsid = mi->mi_vfsp->vfs_dev;
844 	hrt2ts(gethrtime(), &garp->n4g_va.va_atime);
845 	garp->n4g_va.va_mtime = garp->n4g_va.va_ctime = garp->n4g_va.va_atime;
846 }
847 
848 static void
849 xdr_ga_prefill_statvfs(struct nfs4_ga_ext_res *gesp, struct mntinfo4 *mi)
850 {
851 	static statvfs64_t s_sb = {
852 		MAXBSIZE,	/* f_bsize */
853 		DEV_BSIZE,	/* f_frsize */
854 		(fsfilcnt64_t)-1, /* f_blocks */
855 		(fsfilcnt64_t)-1, /* f_bfree */
856 		(fsfilcnt64_t)-1, /* f_bavail */
857 		(fsfilcnt64_t)-1, /* f_files */
858 		(fsfilcnt64_t)-1, /* f_ffree */
859 		(fsfilcnt64_t)-1, /* f_favail */
860 		0,		/* f_fsid */
861 		"\0",		/* f_basetype */
862 		0,		/* f_flag */
863 		MAXNAMELEN,	/* f_namemax */
864 		"\0",		/* f_fstr */
865 	};
866 
867 	gesp->n4g_sb = s_sb;
868 	gesp->n4g_sb.f_fsid = mi->mi_vfsp->vfs_fsid.val[0];
869 }
870 
871 static bool_t
872 xdr_ga_fattr_res(XDR *xdrs, struct nfs4_ga_res *garp, bitmap4 resbmap,
873 		bitmap4 argbmap, struct mntinfo4 *mi, ug_cache_t *pug)
874 {
875 	int truefalse;
876 	struct nfs4_ga_ext_res ges, *gesp;
877 	vattr_t *vap = &garp->n4g_va;
878 	vsecattr_t *vsap = &garp->n4g_vsa;
879 
880 	ASSERT(xdrs->x_op == XDR_DECODE);
881 
882 	if (garp->n4g_ext_res)
883 		gesp = garp->n4g_ext_res;
884 	else
885 		gesp = &ges;
886 
887 	vap->va_mask = 0;
888 
889 	/* Check to see if the vattr should be pre-filled */
890 	if (argbmap & NFS4_VATTR_MASK)
891 		xdr_ga_prefill_vattr(garp, mi);
892 
893 	if (argbmap & NFS4_STATFS_ATTR_MASK)
894 		xdr_ga_prefill_statvfs(gesp, mi);
895 
896 	if (resbmap &
897 	    (FATTR4_SUPPORTED_ATTRS_MASK |
898 	    FATTR4_TYPE_MASK |
899 	    FATTR4_FH_EXPIRE_TYPE_MASK |
900 	    FATTR4_CHANGE_MASK |
901 	    FATTR4_SIZE_MASK |
902 	    FATTR4_LINK_SUPPORT_MASK |
903 	    FATTR4_SYMLINK_SUPPORT_MASK |
904 	    FATTR4_NAMED_ATTR_MASK)) {
905 
906 		if (resbmap & FATTR4_SUPPORTED_ATTRS_MASK) {
907 			if (!xdr_bitmap4(xdrs, &gesp->n4g_suppattrs))
908 				return (FALSE);
909 		}
910 		if (resbmap & FATTR4_TYPE_MASK) {
911 			if (!XDR_GETINT32(xdrs, (int *)&vap->va_type))
912 				return (FALSE);
913 
914 			if ((nfs_ftype4)vap->va_type < NF4REG ||
915 			    (nfs_ftype4)vap->va_type > NF4NAMEDATTR)
916 				vap->va_type = VBAD;
917 			else
918 				vap->va_type = nf4_to_vt[vap->va_type];
919 			if (vap->va_type == VBLK)
920 				vap->va_blksize = DEV_BSIZE;
921 
922 			vap->va_mask |= AT_TYPE;
923 		}
924 		if (resbmap & FATTR4_FH_EXPIRE_TYPE_MASK) {
925 			if (!XDR_GETINT32(xdrs, (int *)&gesp->n4g_fet))
926 				return (FALSE);
927 		}
928 		if (resbmap & FATTR4_CHANGE_MASK) {
929 			if (!xdr_u_longlong_t(xdrs,
930 			    (u_longlong_t *)&garp->n4g_change))
931 				return (FALSE);
932 			garp->n4g_change_valid = 1;
933 		}
934 		if (resbmap & FATTR4_SIZE_MASK) {
935 			if (!xdr_u_longlong_t(xdrs,
936 			    (u_longlong_t *)&vap->va_size))
937 				return (FALSE);
938 			if (!NFS4_SIZE_OK(vap->va_size)) {
939 				garp->n4g_attrerr = EFBIG;
940 				garp->n4g_attrwhy = NFS4_GETATTR_ATSIZE_ERR;
941 			} else {
942 				vap->va_mask |= AT_SIZE;
943 			}
944 		}
945 		if (resbmap & FATTR4_LINK_SUPPORT_MASK) {
946 			if (!XDR_GETINT32(xdrs, (int *)&truefalse))
947 				return (FALSE);
948 			gesp->n4g_pc4.pc4_link_support =
949 			    (truefalse ? TRUE : FALSE);
950 		}
951 		if (resbmap & FATTR4_SYMLINK_SUPPORT_MASK) {
952 			if (!XDR_GETINT32(xdrs, (int *)&truefalse))
953 				return (FALSE);
954 			gesp->n4g_pc4.pc4_symlink_support =
955 			    (truefalse ? TRUE : FALSE);
956 		}
957 		if (resbmap & FATTR4_NAMED_ATTR_MASK) {
958 			if (!XDR_GETINT32(xdrs, (int *)&truefalse))
959 				return (FALSE);
960 			gesp->n4g_pc4.pc4_xattr_exists = TRUE;
961 			gesp->n4g_pc4.pc4_xattr_exists =
962 			    (truefalse ? TRUE : FALSE);
963 		}
964 	}
965 	if (resbmap &
966 	    (FATTR4_FSID_MASK |
967 	    FATTR4_UNIQUE_HANDLES_MASK |
968 	    FATTR4_LEASE_TIME_MASK |
969 	    FATTR4_RDATTR_ERROR_MASK)) {
970 
971 		if (resbmap & FATTR4_FSID_MASK) {
972 			if ((!xdr_u_longlong_t(xdrs,
973 			    (u_longlong_t *)&garp->n4g_fsid.major)) ||
974 			    (!xdr_u_longlong_t(xdrs,
975 			    (u_longlong_t *)&garp->n4g_fsid.minor)))
976 				return (FALSE);
977 			garp->n4g_fsid_valid = 1;
978 		}
979 		if (resbmap & FATTR4_UNIQUE_HANDLES_MASK) {
980 			if (!XDR_GETINT32(xdrs, (int *)&truefalse))
981 				return (FALSE);
982 			gesp->n4g_pc4.pc4_unique_handles =
983 			    (truefalse ? TRUE : FALSE);
984 		}
985 		if (resbmap & FATTR4_LEASE_TIME_MASK) {
986 			if (!XDR_GETINT32(xdrs, (int *)&gesp->n4g_leasetime))
987 				return (FALSE);
988 		}
989 		if (resbmap & FATTR4_RDATTR_ERROR_MASK) {
990 			if (!XDR_GETINT32(xdrs,
991 			    (int *)&gesp->n4g_rdattr_error))
992 				return (FALSE);
993 		}
994 	}
995 	if (resbmap &
996 	    (FATTR4_ACL_MASK |
997 	    FATTR4_ACLSUPPORT_MASK |
998 	    FATTR4_ARCHIVE_MASK |
999 	    FATTR4_CANSETTIME_MASK)) {
1000 
1001 		if (resbmap & FATTR4_ACL_MASK) {
1002 			fattr4_acl	acl;
1003 
1004 			acl.fattr4_acl_val = NULL;
1005 			acl.fattr4_acl_len = 0;
1006 
1007 			if (!xdr_fattr4_acl(xdrs, &acl))
1008 				return (FALSE);
1009 
1010 			vsap->vsa_aclcnt = acl.fattr4_acl_len;
1011 			vsap->vsa_aclentp = acl.fattr4_acl_val;
1012 			vsap->vsa_mask = VSA_ACE | VSA_ACECNT;
1013 			vsap->vsa_aclentsz = vsap->vsa_aclcnt * sizeof (ace_t);
1014 
1015 		}
1016 		if (resbmap & FATTR4_ACLSUPPORT_MASK) {
1017 			if (!XDR_GETINT32(xdrs, (int *)&gesp->n4g_aclsupport))
1018 				return (FALSE);
1019 		}
1020 		if (resbmap & FATTR4_ARCHIVE_MASK) {
1021 			ASSERT(0);
1022 		}
1023 		if (resbmap & FATTR4_CANSETTIME_MASK) {
1024 			if (!XDR_GETINT32(xdrs, (int *)&truefalse))
1025 				return (FALSE);
1026 			gesp->n4g_pc4.pc4_cansettime =
1027 			    (truefalse ? TRUE : FALSE);
1028 		}
1029 	}
1030 	if (resbmap &
1031 	    (FATTR4_CASE_INSENSITIVE_MASK |
1032 	    FATTR4_CASE_PRESERVING_MASK |
1033 	    FATTR4_CHOWN_RESTRICTED_MASK |
1034 	    FATTR4_FILEHANDLE_MASK |
1035 	    FATTR4_FILEID_MASK |
1036 	    FATTR4_FILES_AVAIL_MASK |
1037 	    FATTR4_FILES_FREE_MASK |
1038 	    FATTR4_FILES_TOTAL_MASK)) {
1039 
1040 		if (resbmap & FATTR4_CASE_INSENSITIVE_MASK) {
1041 			if (!XDR_GETINT32(xdrs, (int *)&truefalse))
1042 				return (FALSE);
1043 			gesp->n4g_pc4.pc4_case_insensitive =
1044 			    (truefalse ? TRUE : FALSE);
1045 		}
1046 		if (resbmap & FATTR4_CASE_PRESERVING_MASK) {
1047 			if (!XDR_GETINT32(xdrs, (int *)&truefalse))
1048 				return (FALSE);
1049 			gesp->n4g_pc4.pc4_case_preserving =
1050 			    (truefalse ? TRUE : FALSE);
1051 		}
1052 		if (resbmap & FATTR4_CHOWN_RESTRICTED_MASK) {
1053 			if (!XDR_GETINT32(xdrs, (int *)&truefalse))
1054 				return (FALSE);
1055 			gesp->n4g_pc4.pc4_chown_restricted =
1056 			    (truefalse ? TRUE : FALSE);
1057 		}
1058 		if (resbmap & FATTR4_FILEHANDLE_MASK) {
1059 			gesp->n4g_fh_u.nfs_fh4_alt.len = 0;
1060 			gesp->n4g_fh_u.nfs_fh4_alt.val =
1061 			    gesp->n4g_fh_u.nfs_fh4_alt.data;
1062 			if (!xdr_bytes(xdrs,
1063 			    (char **)&gesp->n4g_fh_u.n4g_fh.nfs_fh4_val,
1064 			    (uint_t *)&gesp->n4g_fh_u.n4g_fh.nfs_fh4_len,
1065 			    NFS4_FHSIZE))
1066 				return (FALSE);
1067 		}
1068 		if (resbmap & FATTR4_FILEID_MASK) {
1069 			if (!xdr_u_longlong_t(xdrs,
1070 			    (u_longlong_t *)&vap->va_nodeid))
1071 				return (FALSE);
1072 			vap->va_mask |= AT_NODEID;
1073 		}
1074 		if (resbmap & FATTR4_FILES_AVAIL_MASK) {
1075 			if (!xdr_u_longlong_t(xdrs,
1076 			    (u_longlong_t *)&gesp->n4g_sb.f_favail))
1077 				return (FALSE);
1078 		}
1079 		if (resbmap & FATTR4_FILES_FREE_MASK) {
1080 			if (!xdr_u_longlong_t(xdrs,
1081 			    (u_longlong_t *)&gesp->n4g_sb.f_ffree))
1082 				return (FALSE);
1083 		}
1084 		if (resbmap & FATTR4_FILES_TOTAL_MASK) {
1085 			if (!xdr_u_longlong_t(xdrs,
1086 			    (u_longlong_t *)&gesp->n4g_sb.f_files))
1087 				return (FALSE);
1088 		}
1089 	}
1090 	if (resbmap &
1091 	    (FATTR4_FS_LOCATIONS_MASK |
1092 	    FATTR4_HIDDEN_MASK |
1093 	    FATTR4_HOMOGENEOUS_MASK)) {
1094 
1095 		if (resbmap & FATTR4_FS_LOCATIONS_MASK) {
1096 			if (!xdr_fattr4_fs_locations(xdrs,
1097 			    &gesp->n4g_fslocations))
1098 				return (FALSE);
1099 		}
1100 		if (resbmap & FATTR4_HIDDEN_MASK) {
1101 			ASSERT(0);
1102 		}
1103 		if (resbmap & FATTR4_HOMOGENEOUS_MASK) {
1104 			if (!XDR_GETINT32(xdrs, (int *)&truefalse))
1105 				return (FALSE);
1106 			gesp->n4g_pc4.pc4_homogeneous =
1107 			    (truefalse ? TRUE : FALSE);
1108 		}
1109 	}
1110 	if (resbmap &
1111 	    (FATTR4_MAXFILESIZE_MASK |
1112 	    FATTR4_MAXLINK_MASK |
1113 	    FATTR4_MAXNAME_MASK |
1114 	    FATTR4_MAXREAD_MASK |
1115 	    FATTR4_MAXWRITE_MASK)) {
1116 
1117 		if (resbmap & FATTR4_MAXFILESIZE_MASK) {
1118 			if (!xdr_u_longlong_t(xdrs,
1119 			    (u_longlong_t *)&gesp->n4g_maxfilesize))
1120 				return (FALSE);
1121 		}
1122 		if (resbmap & FATTR4_MAXLINK_MASK) {
1123 			if (!XDR_GETINT32(xdrs,
1124 			    (int *)&gesp->n4g_pc4.pc4_link_max))
1125 				return (FALSE);
1126 		}
1127 		if (resbmap & FATTR4_MAXNAME_MASK) {
1128 			if (!XDR_GETINT32(xdrs,
1129 			    (int *)&gesp->n4g_pc4.pc4_name_max))
1130 				return (FALSE);
1131 			gesp->n4g_sb.f_namemax = gesp->n4g_pc4.pc4_name_max;
1132 		}
1133 		if (resbmap & FATTR4_MAXREAD_MASK) {
1134 			if (!xdr_u_longlong_t(xdrs,
1135 			    (u_longlong_t *)&gesp->n4g_maxread))
1136 				return (FALSE);
1137 		}
1138 		if (resbmap & FATTR4_MAXWRITE_MASK) {
1139 			if (!xdr_u_longlong_t(xdrs,
1140 			    (u_longlong_t *)&gesp->n4g_maxwrite))
1141 				return (FALSE);
1142 		}
1143 	}
1144 	if (resbmap &
1145 	    (FATTR4_MIMETYPE_MASK |
1146 	    FATTR4_MODE_MASK |
1147 	    FATTR4_NO_TRUNC_MASK |
1148 	    FATTR4_NUMLINKS_MASK)) {
1149 
1150 		if (resbmap & FATTR4_MIMETYPE_MASK) {
1151 			ASSERT(0);
1152 		}
1153 		if (resbmap & FATTR4_MODE_MASK) {
1154 			if (!XDR_GETINT32(xdrs, (int *)&vap->va_mode))
1155 				return (FALSE);
1156 			vap->va_mask |= AT_MODE;
1157 		}
1158 		if (resbmap & FATTR4_NO_TRUNC_MASK) {
1159 			if (!XDR_GETINT32(xdrs, (int *)&truefalse))
1160 				return (FALSE);
1161 			gesp->n4g_pc4.pc4_no_trunc =
1162 			    (truefalse ? TRUE : FALSE);
1163 		}
1164 		if (resbmap & FATTR4_NUMLINKS_MASK) {
1165 			if (!XDR_GETINT32(xdrs, (int *)&vap->va_nlink))
1166 				return (FALSE);
1167 			vap->va_mask |= AT_NLINK;
1168 		}
1169 	}
1170 	if (resbmap &
1171 	    (FATTR4_OWNER_MASK |
1172 	    FATTR4_OWNER_GROUP_MASK |
1173 	    FATTR4_QUOTA_AVAIL_HARD_MASK |
1174 	    FATTR4_QUOTA_AVAIL_SOFT_MASK)) {
1175 
1176 		if (resbmap & FATTR4_OWNER_MASK) {
1177 			uint_t *owner_length, ol;
1178 			char *owner_val = NULL;
1179 			char *owner_alloc = NULL;
1180 			utf8string ov;
1181 			int error;
1182 
1183 			/* get the OWNER_LENGTH */
1184 			if (!xdr_u_int(xdrs, &ol))
1185 				return (FALSE);
1186 
1187 			/* Manage the owner length location */
1188 			if (pug && ol <= MAX_OG_NAME) {
1189 				owner_length = &pug->u_curr.utf8string_len;
1190 				*owner_length = ol;
1191 			} else {
1192 				owner_length = &ol;
1193 			}
1194 
1195 			/* find memory to store the decode */
1196 			if (*owner_length > MAX_OG_NAME || pug == NULL)
1197 				owner_val = owner_alloc =
1198 				    kmem_alloc(*owner_length, KM_SLEEP);
1199 			else
1200 				owner_val = pug->u_curr.utf8string_val;
1201 
1202 			/* get the OWNER string */
1203 			if (!xdr_opaque(xdrs, owner_val, *owner_length)) {
1204 				if (owner_alloc)
1205 					kmem_free(owner_alloc, *owner_length);
1206 				return (FALSE);
1207 			}
1208 
1209 			/* Optimize for matching if called for */
1210 			if (pug &&
1211 			    *owner_length == pug->u_last.utf8string_len &&
1212 			    bcmp(owner_val, pug->u_last.utf8string_val,
1213 			    *owner_length) == 0) {
1214 				vap->va_uid = pug->uid;
1215 				vap->va_mask |= AT_UID;
1216 			} else {
1217 				uid_t uid;
1218 
1219 				ov.utf8string_len = *owner_length;
1220 				ov.utf8string_val = owner_val;
1221 				error = nfs_idmap_str_uid(&ov, &uid, FALSE);
1222 				/*
1223 				 * String was mapped, but to nobody because
1224 				 * we are nfsmapid, indicate it should not
1225 				 * be cached.
1226 				 */
1227 				if (error == ENOTSUP) {
1228 					error = 0;
1229 					garp->n4g_attrwhy =
1230 					    NFS4_GETATTR_NOCACHE_OK;
1231 				}
1232 
1233 				if (error) {
1234 					garp->n4g_attrerr = error;
1235 					garp->n4g_attrwhy =
1236 					    NFS4_GETATTR_ATUID_ERR;
1237 				} else {
1238 					vap->va_uid = uid;
1239 					vap->va_mask |= AT_UID;
1240 					if (pug && ol <= MAX_OG_NAME) {
1241 						pug->uid = uid;
1242 						U_SWAP_CURR_LAST(pug);
1243 					}
1244 				}
1245 				if (owner_alloc)
1246 					kmem_free(owner_alloc, *owner_length);
1247 			}
1248 		}
1249 		if (resbmap & FATTR4_OWNER_GROUP_MASK) {
1250 			uint_t *group_length, gl;
1251 			char *group_val = NULL;
1252 			char *group_alloc = NULL;
1253 			utf8string gv;
1254 			int error;
1255 
1256 			/* get the OWNER_GROUP_LENGTH */
1257 			if (!xdr_u_int(xdrs, &gl))
1258 				return (FALSE);
1259 
1260 			/* Manage the group length location */
1261 			if (pug && gl <= MAX_OG_NAME) {
1262 				group_length = &pug->g_curr.utf8string_len;
1263 				*group_length = gl;
1264 			} else {
1265 				group_length = &gl;
1266 			}
1267 
1268 			/* find memory to store the decode */
1269 			if (*group_length > MAX_OG_NAME || pug == NULL)
1270 				group_val = group_alloc =
1271 				    kmem_alloc(*group_length, KM_SLEEP);
1272 			else
1273 				group_val = pug->g_curr.utf8string_val;
1274 
1275 			/* get the OWNER_GROUP string */
1276 			if (!xdr_opaque(xdrs, group_val, *group_length)) {
1277 				if (group_alloc)
1278 					kmem_free(group_alloc, *group_length);
1279 				return (FALSE);
1280 			}
1281 
1282 			/* Optimize for matching if called for */
1283 			if (pug &&
1284 			    *group_length == pug->g_last.utf8string_len &&
1285 			    bcmp(group_val, pug->g_last.utf8string_val,
1286 			    *group_length) == 0) {
1287 				vap->va_gid = pug->gid;
1288 				vap->va_mask |= AT_GID;
1289 			} else {
1290 				uid_t gid;
1291 
1292 				gv.utf8string_len = *group_length;
1293 				gv.utf8string_val = group_val;
1294 				error = nfs_idmap_str_gid(&gv, &gid, FALSE);
1295 				/*
1296 				 * String was mapped, but to nobody because
1297 				 * we are nfsmapid, indicate it should not
1298 				 * be cached.
1299 				 */
1300 				if (error == ENOTSUP) {
1301 					error = 0;
1302 					garp->n4g_attrwhy =
1303 					    NFS4_GETATTR_NOCACHE_OK;
1304 				}
1305 
1306 				if (error) {
1307 					garp->n4g_attrerr = error;
1308 					garp->n4g_attrwhy =
1309 					    NFS4_GETATTR_ATGID_ERR;
1310 				} else {
1311 					vap->va_gid = gid;
1312 					vap->va_mask |= AT_GID;
1313 					if (pug && gl <= MAX_OG_NAME) {
1314 						pug->gid = gid;
1315 						G_SWAP_CURR_LAST(pug);
1316 					}
1317 				}
1318 				if (group_alloc) {
1319 					kmem_free(group_alloc, *group_length);
1320 				}
1321 			}
1322 		}
1323 		if (resbmap & FATTR4_QUOTA_AVAIL_HARD_MASK) {
1324 			ASSERT(0);
1325 		}
1326 		if (resbmap & FATTR4_QUOTA_AVAIL_SOFT_MASK) {
1327 			ASSERT(0);
1328 		}
1329 	}
1330 	if (resbmap &
1331 	    (FATTR4_QUOTA_USED_MASK |
1332 	    FATTR4_SPACE_AVAIL_MASK |
1333 	    FATTR4_SPACE_FREE_MASK |
1334 	    FATTR4_SPACE_TOTAL_MASK |
1335 	    FATTR4_SPACE_USED_MASK |
1336 	    FATTR4_SYSTEM_MASK)) {
1337 
1338 		if (resbmap & FATTR4_QUOTA_USED_MASK) {
1339 			ASSERT(0);
1340 		}
1341 		if (resbmap & FATTR4_RAWDEV_MASK) {
1342 			fattr4_rawdev rawdev;
1343 			if (!xdr_fattr4_rawdev(xdrs, &rawdev))
1344 				return (FALSE);
1345 
1346 			if (vap->va_type == VCHR || vap->va_type == VBLK) {
1347 				vap->va_rdev = makedevice(rawdev.specdata1,
1348 				    rawdev.specdata2);
1349 			} else {
1350 				vap->va_rdev = 0;
1351 			}
1352 			vap->va_mask |= AT_RDEV;
1353 		}
1354 		if (resbmap & FATTR4_SPACE_AVAIL_MASK) {
1355 			if (!xdr_u_longlong_t(xdrs,
1356 			    (u_longlong_t *)&gesp->n4g_sb.f_bavail))
1357 				return (FALSE);
1358 			gesp->n4g_sb.f_bavail /= DEV_BSIZE;
1359 		}
1360 		if (resbmap & FATTR4_SPACE_FREE_MASK) {
1361 			if (!xdr_u_longlong_t(xdrs,
1362 			    (u_longlong_t *)&gesp->n4g_sb.f_bfree))
1363 				return (FALSE);
1364 			gesp->n4g_sb.f_bfree /= DEV_BSIZE;
1365 		}
1366 		if (resbmap & FATTR4_SPACE_TOTAL_MASK) {
1367 			if (!xdr_u_longlong_t(xdrs,
1368 			    (u_longlong_t *)&gesp->n4g_sb.f_blocks))
1369 				return (FALSE);
1370 			gesp->n4g_sb.f_blocks /= DEV_BSIZE;
1371 		}
1372 		if (resbmap & FATTR4_SPACE_USED_MASK) {
1373 			uint64_t space_used;
1374 			if (!xdr_u_longlong_t(xdrs,
1375 			    (u_longlong_t *)&space_used))
1376 				return (FALSE);
1377 
1378 			/* Compute space depending on device type */
1379 			ASSERT((vap->va_mask & AT_TYPE));
1380 			if (vap->va_type == VREG || vap->va_type == VDIR ||
1381 			    vap->va_type == VLNK) {
1382 				vap->va_nblocks = (u_longlong_t)
1383 				    ((space_used + (offset4)DEV_BSIZE -
1384 				    (offset4)1) / (offset4)DEV_BSIZE);
1385 			} else {
1386 				vap->va_nblocks = 0;
1387 			}
1388 			vap->va_mask |= AT_NBLOCKS;
1389 		}
1390 		if (resbmap & FATTR4_SYSTEM_MASK) {
1391 			ASSERT(0);
1392 		}
1393 	}
1394 	if (resbmap &
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 (resbmap & FATTR4_TIME_ACCESS_MASK) {
1406 			nfstime4 atime;
1407 			int error;
1408 
1409 			if (!xdr_longlong_t(xdrs,
1410 			    (longlong_t *)&atime.seconds))
1411 				return (FALSE);
1412 			if (!XDR_GETINT32(xdrs, (int *)&atime.nseconds))
1413 				return (FALSE);
1414 			error = nfs4_time_ntov(&atime, &vap->va_atime);
1415 			if (error) {
1416 				garp->n4g_attrerr = error;
1417 				garp->n4g_attrwhy = NFS4_GETATTR_ATATIME_ERR;
1418 			}
1419 			vap->va_mask |= AT_ATIME;
1420 		}
1421 		if (resbmap & FATTR4_TIME_ACCESS_SET_MASK) {
1422 			ASSERT(0);
1423 		}
1424 		if (resbmap & FATTR4_TIME_BACKUP_MASK) {
1425 			ASSERT(0);
1426 		}
1427 		if (resbmap & FATTR4_TIME_CREATE_MASK) {
1428 			ASSERT(0);
1429 		}
1430 		if (resbmap & FATTR4_TIME_DELTA_MASK) {
1431 			if ((!xdr_u_longlong_t(xdrs,
1432 			    (u_longlong_t *)&gesp->n4g_delta.seconds)) ||
1433 			    (!xdr_u_int(xdrs, &gesp->n4g_delta.nseconds)))
1434 				return (FALSE);
1435 		}
1436 		if (resbmap & FATTR4_TIME_METADATA_MASK) {
1437 			nfstime4 mdt;
1438 			int error;
1439 
1440 			if (!xdr_longlong_t(xdrs, (longlong_t *)&mdt.seconds))
1441 				return (FALSE);
1442 			if (!XDR_GETINT32(xdrs, (int32_t *)&mdt.nseconds))
1443 				return (FALSE);
1444 			error = nfs4_time_ntov(&mdt, &vap->va_ctime);
1445 			if (error) {
1446 				garp->n4g_attrerr = error;
1447 				garp->n4g_attrwhy = NFS4_GETATTR_ATCTIME_ERR;
1448 			}
1449 			vap->va_mask |= AT_CTIME;
1450 		}
1451 		if (resbmap & FATTR4_TIME_MODIFY_MASK) {
1452 			nfstime4 mtime;
1453 			int error;
1454 
1455 			if (!xdr_longlong_t(xdrs,
1456 			    (longlong_t *)&mtime.seconds))
1457 				return (FALSE);
1458 			if (!XDR_GETINT32(xdrs, (int32_t *)&mtime.nseconds))
1459 				return (FALSE);
1460 			error = nfs4_time_ntov(&mtime, &vap->va_mtime);
1461 			if (error) {
1462 				garp->n4g_attrerr = error;
1463 				garp->n4g_attrwhy = NFS4_GETATTR_ATMTIME_ERR;
1464 			}
1465 			vap->va_mask |= AT_MTIME;
1466 		}
1467 		if (resbmap & FATTR4_TIME_MODIFY_SET_MASK) {
1468 			ASSERT(0);
1469 		}
1470 		if (resbmap & FATTR4_MOUNTED_ON_FILEID_MASK) {
1471 			if (!xdr_u_longlong_t(xdrs,
1472 			    (u_longlong_t *)&garp->n4g_mon_fid))
1473 				return (FALSE);
1474 			garp->n4g_mon_fid_valid = 1;
1475 		}
1476 	}
1477 
1478 	if (resbmap & ~(NFS4_VATTR_MASK | FATTR4_ACL_MASK)) {
1479 		/* copy only if not provided */
1480 		if (garp->n4g_ext_res == NULL) {
1481 			garp->n4g_ext_res = kmem_alloc(sizeof (ges), KM_SLEEP);
1482 			bcopy(&ges, garp->n4g_ext_res, sizeof (ges));
1483 		}
1484 	}
1485 
1486 	return (TRUE);
1487 }
1488 
1489 /*
1490  * Inlined version of get_bitmap4 processing
1491  */
1492 bitmap4
1493 xdr_get_bitmap4_inline(uint32_t **iptr)
1494 {
1495 	uint32_t resbmaplen;
1496 	bitmap4 bm;
1497 	uint32_t *ptr = *iptr;
1498 
1499 	/* bitmap LENGTH */
1500 	resbmaplen = IXDR_GET_U_INT32(ptr);
1501 
1502 	/* Inline the bitmap and attrlen for common case of two word map */
1503 	if (resbmaplen == 2) {
1504 		IXDR_GET_HYPER(ptr, bm);
1505 		*iptr = ptr;
1506 		return (bm);
1507 	}
1508 
1509 #if defined(_LITTLE_ENDIAN)
1510 	bm = IXDR_GET_U_INT32(ptr);
1511 	if (--resbmaplen == 0) {
1512 		*iptr = ptr;
1513 		return (bm);
1514 	}
1515 	*((uint32_t *)&bm) |= IXDR_GET_U_INT32(ptr);
1516 	if (--resbmaplen == 0) {
1517 		*iptr = ptr;
1518 		return (bm);
1519 	}
1520 	ptr += resbmaplen;
1521 	*iptr = ptr;
1522 	return (bm);
1523 #elif defined(_BIG_ENDIAN)
1524 	*((uint32_t *)&bm) = IXDR_GET_U_INT32(ptr);
1525 	if (--resbmaplen == 0) {
1526 		*iptr = ptr;
1527 		return (bm);
1528 	}
1529 	bm |= IXDR_GET_U_INT32(ptr);
1530 	if (--resbmaplen == 0) {
1531 		*iptr = ptr;
1532 		return (bm);
1533 	}
1534 	ptr += resbmaplen;
1535 	*iptr = ptr;
1536 	return (bm);
1537 #else
1538 	ASSERT(0);
1539 	ptr += resbmaplen;
1540 	*iptr = ptr;
1541 	return (0);
1542 #endif
1543 }
1544 
1545 static bool_t
1546 xdr_ga_fattr_res_inline(uint32_t *ptr, struct nfs4_ga_res *garp,
1547 			bitmap4 resbmap, bitmap4 argbmap, struct mntinfo4 *mi,
1548 			ug_cache_t *pug)
1549 {
1550 	int truefalse;
1551 	struct nfs4_ga_ext_res ges, *gesp;
1552 	vattr_t *vap = &garp->n4g_va;
1553 
1554 	if (garp->n4g_ext_res)
1555 		gesp = garp->n4g_ext_res;
1556 	else
1557 		gesp = &ges;
1558 
1559 	vap->va_mask = 0;
1560 
1561 	/* Check to see if the vattr should be pre-filled */
1562 	if (argbmap & NFS4_VATTR_MASK)
1563 		xdr_ga_prefill_vattr(garp, mi);
1564 
1565 	if (argbmap & NFS4_STATFS_ATTR_MASK)
1566 		xdr_ga_prefill_statvfs(gesp, mi);
1567 
1568 	if (resbmap &
1569 	    (FATTR4_SUPPORTED_ATTRS_MASK |
1570 	    FATTR4_TYPE_MASK |
1571 	    FATTR4_FH_EXPIRE_TYPE_MASK |
1572 	    FATTR4_CHANGE_MASK |
1573 	    FATTR4_SIZE_MASK |
1574 	    FATTR4_LINK_SUPPORT_MASK |
1575 	    FATTR4_SYMLINK_SUPPORT_MASK |
1576 	    FATTR4_NAMED_ATTR_MASK)) {
1577 
1578 		if (resbmap & FATTR4_SUPPORTED_ATTRS_MASK) {
1579 			gesp->n4g_suppattrs = xdr_get_bitmap4_inline(&ptr);
1580 		}
1581 		if (resbmap & FATTR4_TYPE_MASK) {
1582 			vap->va_type = IXDR_GET_U_INT32(ptr);
1583 
1584 			if ((nfs_ftype4)vap->va_type < NF4REG ||
1585 			    (nfs_ftype4)vap->va_type > NF4NAMEDATTR)
1586 				vap->va_type = VBAD;
1587 			else
1588 				vap->va_type = nf4_to_vt[vap->va_type];
1589 			if (vap->va_type == VBLK)
1590 				vap->va_blksize = DEV_BSIZE;
1591 
1592 			vap->va_mask |= AT_TYPE;
1593 		}
1594 		if (resbmap & FATTR4_FH_EXPIRE_TYPE_MASK) {
1595 			gesp->n4g_fet = IXDR_GET_U_INT32(ptr);
1596 		}
1597 		if (resbmap & FATTR4_CHANGE_MASK) {
1598 			IXDR_GET_U_HYPER(ptr, garp->n4g_change);
1599 			garp->n4g_change_valid = 1;
1600 		}
1601 		if (resbmap & FATTR4_SIZE_MASK) {
1602 			IXDR_GET_U_HYPER(ptr, vap->va_size);
1603 
1604 			if (!NFS4_SIZE_OK(vap->va_size)) {
1605 				garp->n4g_attrerr = EFBIG;
1606 				garp->n4g_attrwhy = NFS4_GETATTR_ATSIZE_ERR;
1607 			} else {
1608 				vap->va_mask |= AT_SIZE;
1609 			}
1610 		}
1611 		if (resbmap & FATTR4_LINK_SUPPORT_MASK) {
1612 			truefalse = IXDR_GET_U_INT32(ptr);
1613 			gesp->n4g_pc4.pc4_link_support =
1614 			    (truefalse ? TRUE : FALSE);
1615 		}
1616 		if (resbmap & FATTR4_SYMLINK_SUPPORT_MASK) {
1617 			truefalse = IXDR_GET_U_INT32(ptr);
1618 			gesp->n4g_pc4.pc4_symlink_support =
1619 			    (truefalse ? TRUE : FALSE);
1620 		}
1621 		if (resbmap & FATTR4_NAMED_ATTR_MASK) {
1622 			truefalse = IXDR_GET_U_INT32(ptr);
1623 			gesp->n4g_pc4.pc4_xattr_exists = TRUE;
1624 			gesp->n4g_pc4.pc4_xattr_exists =
1625 			    (truefalse ? TRUE : FALSE);
1626 		}
1627 	}
1628 	if (resbmap &
1629 	    (FATTR4_FSID_MASK |
1630 	    FATTR4_UNIQUE_HANDLES_MASK |
1631 	    FATTR4_LEASE_TIME_MASK |
1632 	    FATTR4_RDATTR_ERROR_MASK)) {
1633 
1634 		if (resbmap & FATTR4_FSID_MASK) {
1635 			IXDR_GET_U_HYPER(ptr, garp->n4g_fsid.major);
1636 			IXDR_GET_U_HYPER(ptr, garp->n4g_fsid.minor);
1637 			garp->n4g_fsid_valid = 1;
1638 		}
1639 		if (resbmap & FATTR4_UNIQUE_HANDLES_MASK) {
1640 			truefalse = IXDR_GET_U_INT32(ptr);
1641 			gesp->n4g_pc4.pc4_unique_handles =
1642 			    (truefalse ? TRUE : FALSE);
1643 		}
1644 		if (resbmap & FATTR4_LEASE_TIME_MASK) {
1645 			gesp->n4g_leasetime = IXDR_GET_U_INT32(ptr);
1646 		}
1647 		if (resbmap & FATTR4_RDATTR_ERROR_MASK) {
1648 			gesp->n4g_rdattr_error = IXDR_GET_U_INT32(ptr);
1649 		}
1650 	}
1651 	if (resbmap &
1652 	    (FATTR4_ACL_MASK |
1653 	    FATTR4_ACLSUPPORT_MASK |
1654 	    FATTR4_ARCHIVE_MASK |
1655 	    FATTR4_CANSETTIME_MASK)) {
1656 
1657 		if (resbmap & FATTR4_ACL_MASK) {
1658 			ASSERT(0);
1659 		}
1660 		if (resbmap & FATTR4_ACLSUPPORT_MASK) {
1661 			gesp->n4g_aclsupport = IXDR_GET_U_INT32(ptr);
1662 		}
1663 		if (resbmap & FATTR4_ARCHIVE_MASK) {
1664 			ASSERT(0);
1665 		}
1666 		if (resbmap & FATTR4_CANSETTIME_MASK) {
1667 			truefalse = IXDR_GET_U_INT32(ptr);
1668 			gesp->n4g_pc4.pc4_cansettime =
1669 			    (truefalse ? TRUE : FALSE);
1670 		}
1671 	}
1672 	if (resbmap &
1673 	    (FATTR4_CASE_INSENSITIVE_MASK |
1674 	    FATTR4_CASE_PRESERVING_MASK |
1675 	    FATTR4_CHOWN_RESTRICTED_MASK |
1676 	    FATTR4_FILEHANDLE_MASK |
1677 	    FATTR4_FILEID_MASK |
1678 	    FATTR4_FILES_AVAIL_MASK |
1679 	    FATTR4_FILES_FREE_MASK |
1680 	    FATTR4_FILES_TOTAL_MASK)) {
1681 
1682 		if (resbmap & FATTR4_CASE_INSENSITIVE_MASK) {
1683 			truefalse = IXDR_GET_U_INT32(ptr);
1684 			gesp->n4g_pc4.pc4_case_insensitive =
1685 			    (truefalse ? TRUE : FALSE);
1686 		}
1687 		if (resbmap & FATTR4_CASE_PRESERVING_MASK) {
1688 			truefalse = IXDR_GET_U_INT32(ptr);
1689 			gesp->n4g_pc4.pc4_case_preserving =
1690 			    (truefalse ? TRUE : FALSE);
1691 		}
1692 		if (resbmap & FATTR4_CHOWN_RESTRICTED_MASK) {
1693 			truefalse = IXDR_GET_U_INT32(ptr);
1694 			gesp->n4g_pc4.pc4_chown_restricted =
1695 			    (truefalse ? TRUE : FALSE);
1696 		}
1697 		if (resbmap & FATTR4_FILEHANDLE_MASK) {
1698 			int len = IXDR_GET_U_INT32(ptr);
1699 
1700 			gesp->n4g_fh_u.nfs_fh4_alt.len = 0;
1701 			gesp->n4g_fh_u.nfs_fh4_alt.val =
1702 			    gesp->n4g_fh_u.nfs_fh4_alt.data;
1703 			gesp->n4g_fh_u.n4g_fh.nfs_fh4_len = len;
1704 
1705 			bcopy(ptr, gesp->n4g_fh_u.n4g_fh.nfs_fh4_val, len);
1706 
1707 			ptr += RNDUP(len) / BYTES_PER_XDR_UNIT;
1708 		}
1709 		if (resbmap & FATTR4_FILEID_MASK) {
1710 			IXDR_GET_U_HYPER(ptr, vap->va_nodeid);
1711 			vap->va_mask |= AT_NODEID;
1712 		}
1713 		if (resbmap & FATTR4_FILES_AVAIL_MASK) {
1714 			IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_favail);
1715 		}
1716 		if (resbmap & FATTR4_FILES_FREE_MASK) {
1717 			IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_ffree);
1718 		}
1719 		if (resbmap & FATTR4_FILES_TOTAL_MASK) {
1720 			IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_files);
1721 		}
1722 	}
1723 	if (resbmap &
1724 	    (FATTR4_FS_LOCATIONS_MASK |
1725 	    FATTR4_HIDDEN_MASK |
1726 	    FATTR4_HOMOGENEOUS_MASK)) {
1727 
1728 		if (resbmap & FATTR4_FS_LOCATIONS_MASK) {
1729 			ASSERT(0);
1730 		}
1731 		if (resbmap & FATTR4_HIDDEN_MASK) {
1732 			ASSERT(0);
1733 		}
1734 		if (resbmap & FATTR4_HOMOGENEOUS_MASK) {
1735 			truefalse = IXDR_GET_U_INT32(ptr);
1736 			gesp->n4g_pc4.pc4_homogeneous =
1737 			    (truefalse ? TRUE : FALSE);
1738 		}
1739 	}
1740 	if (resbmap &
1741 	    (FATTR4_MAXFILESIZE_MASK |
1742 	    FATTR4_MAXLINK_MASK |
1743 	    FATTR4_MAXNAME_MASK |
1744 	    FATTR4_MAXREAD_MASK |
1745 	    FATTR4_MAXWRITE_MASK)) {
1746 
1747 		if (resbmap & FATTR4_MAXFILESIZE_MASK) {
1748 			IXDR_GET_U_HYPER(ptr, gesp->n4g_maxfilesize);
1749 		}
1750 		if (resbmap & FATTR4_MAXLINK_MASK) {
1751 			gesp->n4g_pc4.pc4_link_max = IXDR_GET_U_INT32(ptr);
1752 		}
1753 		if (resbmap & FATTR4_MAXNAME_MASK) {
1754 			gesp->n4g_pc4.pc4_name_max = IXDR_GET_U_INT32(ptr);
1755 			gesp->n4g_sb.f_namemax = gesp->n4g_pc4.pc4_name_max;
1756 		}
1757 		if (resbmap & FATTR4_MAXREAD_MASK) {
1758 			IXDR_GET_U_HYPER(ptr, gesp->n4g_maxread);
1759 		}
1760 		if (resbmap & FATTR4_MAXWRITE_MASK) {
1761 			IXDR_GET_U_HYPER(ptr, gesp->n4g_maxwrite);
1762 		}
1763 	}
1764 	if (resbmap &
1765 	    (FATTR4_MIMETYPE_MASK |
1766 	    FATTR4_MODE_MASK |
1767 	    FATTR4_NO_TRUNC_MASK |
1768 	    FATTR4_NUMLINKS_MASK)) {
1769 
1770 		if (resbmap & FATTR4_MIMETYPE_MASK) {
1771 			ASSERT(0);
1772 		}
1773 		if (resbmap & FATTR4_MODE_MASK) {
1774 			vap->va_mode = IXDR_GET_U_INT32(ptr);
1775 			vap->va_mask |= AT_MODE;
1776 		}
1777 		if (resbmap & FATTR4_NO_TRUNC_MASK) {
1778 			truefalse = IXDR_GET_U_INT32(ptr);
1779 			gesp->n4g_pc4.pc4_no_trunc =
1780 			    (truefalse ? TRUE : FALSE);
1781 		}
1782 		if (resbmap & FATTR4_NUMLINKS_MASK) {
1783 			vap->va_nlink = IXDR_GET_U_INT32(ptr);
1784 			vap->va_mask |= AT_NLINK;
1785 		}
1786 	}
1787 	if (resbmap &
1788 	    (FATTR4_OWNER_MASK |
1789 	    FATTR4_OWNER_GROUP_MASK |
1790 	    FATTR4_QUOTA_AVAIL_HARD_MASK |
1791 	    FATTR4_QUOTA_AVAIL_SOFT_MASK)) {
1792 
1793 		if (resbmap & FATTR4_OWNER_MASK) {
1794 			uint_t *owner_length, ol;
1795 			char *owner_val = NULL;
1796 			utf8string ov;
1797 			int error;
1798 
1799 			/* get the OWNER_LENGTH */
1800 			ol = IXDR_GET_U_INT32(ptr);
1801 
1802 			/* Manage the owner length location */
1803 			if (pug && ol <= MAX_OG_NAME) {
1804 				owner_length = &pug->u_curr.utf8string_len;
1805 				*owner_length = ol;
1806 			} else {
1807 				owner_length = &ol;
1808 			}
1809 
1810 			/* find memory to store the decode */
1811 			if (*owner_length > MAX_OG_NAME || pug == NULL)
1812 				owner_val = (char *)ptr;
1813 			else
1814 				owner_val = (char *)ptr;
1815 
1816 			/* Optimize for matching if called for */
1817 			if (pug &&
1818 			    *owner_length == pug->u_last.utf8string_len &&
1819 			    bcmp(owner_val, pug->u_last.utf8string_val,
1820 			    *owner_length) == 0) {
1821 				vap->va_uid = pug->uid;
1822 				vap->va_mask |= AT_UID;
1823 			} else {
1824 				uid_t uid;
1825 
1826 				ov.utf8string_len = *owner_length;
1827 				ov.utf8string_val = owner_val;
1828 				error = nfs_idmap_str_uid(&ov, &uid, FALSE);
1829 				/*
1830 				 * String was mapped, but to nobody because
1831 				 * we are nfsmapid, indicate it should not
1832 				 * be cached.
1833 				 */
1834 				if (error == ENOTSUP) {
1835 					error = 0;
1836 					garp->n4g_attrwhy =
1837 					    NFS4_GETATTR_NOCACHE_OK;
1838 				}
1839 
1840 				if (error) {
1841 					garp->n4g_attrerr = error;
1842 					garp->n4g_attrwhy =
1843 					    NFS4_GETATTR_ATUID_ERR;
1844 				} else {
1845 					vap->va_uid = uid;
1846 					vap->va_mask |= AT_UID;
1847 					/* save the results for next time */
1848 					if (pug && ol <= MAX_OG_NAME) {
1849 						pug->uid = uid;
1850 						pug->u_curr.utf8string_len =
1851 						    ov.utf8string_len;
1852 						bcopy(owner_val,
1853 						    pug->u_curr.utf8string_val,
1854 						    ol);
1855 						U_SWAP_CURR_LAST(pug);
1856 					}
1857 				}
1858 			}
1859 			ptr += RNDUP(ol) / BYTES_PER_XDR_UNIT;
1860 		}
1861 		if (resbmap & FATTR4_OWNER_GROUP_MASK) {
1862 			uint_t *group_length, gl;
1863 			char *group_val = NULL;
1864 			utf8string gv;
1865 			int error;
1866 
1867 			/* get the OWNER_GROUP_LENGTH */
1868 			gl = IXDR_GET_U_INT32(ptr);
1869 
1870 			/* Manage the group length location */
1871 			if (pug && gl <= MAX_OG_NAME) {
1872 				group_length = &pug->g_curr.utf8string_len;
1873 				*group_length = gl;
1874 			} else {
1875 				group_length = &gl;
1876 			}
1877 
1878 			/* find memory to store the decode */
1879 			if (*group_length > MAX_OG_NAME || pug == NULL)
1880 				group_val = (char *)ptr;
1881 			else
1882 				group_val = (char *)ptr;
1883 
1884 			/* Optimize for matching if called for */
1885 			if (pug &&
1886 			    *group_length == pug->g_last.utf8string_len &&
1887 			    bcmp(group_val, pug->g_last.utf8string_val,
1888 			    *group_length) == 0) {
1889 				vap->va_gid = pug->gid;
1890 				vap->va_mask |= AT_GID;
1891 			} else {
1892 				uid_t gid;
1893 
1894 				gv.utf8string_len = *group_length;
1895 				gv.utf8string_val = group_val;
1896 				error = nfs_idmap_str_gid(&gv, &gid, FALSE);
1897 				/*
1898 				 * String was mapped, but to nobody because
1899 				 * we are nfsmapid, indicate it should not
1900 				 * be cached.
1901 				 */
1902 				if (error == ENOTSUP) {
1903 					error = 0;
1904 					garp->n4g_attrwhy =
1905 					    NFS4_GETATTR_NOCACHE_OK;
1906 				}
1907 
1908 				if (error) {
1909 					garp->n4g_attrerr = error;
1910 					garp->n4g_attrwhy =
1911 					    NFS4_GETATTR_ATGID_ERR;
1912 				} else {
1913 					vap->va_gid = gid;
1914 					vap->va_mask |= AT_GID;
1915 					if (pug && gl <= MAX_OG_NAME) {
1916 						pug->gid = gid;
1917 						pug->g_curr.utf8string_len =
1918 						    gv.utf8string_len;
1919 						bcopy(group_val,
1920 						    pug->g_curr.utf8string_val,
1921 						    gl);
1922 						G_SWAP_CURR_LAST(pug);
1923 					}
1924 				}
1925 			}
1926 			ptr += RNDUP(gl) / BYTES_PER_XDR_UNIT;
1927 		}
1928 		if (resbmap & FATTR4_QUOTA_AVAIL_HARD_MASK) {
1929 			ASSERT(0);
1930 		}
1931 		if (resbmap & FATTR4_QUOTA_AVAIL_SOFT_MASK) {
1932 			ASSERT(0);
1933 		}
1934 	}
1935 	if (resbmap &
1936 	    (FATTR4_QUOTA_USED_MASK |
1937 	    FATTR4_SPACE_AVAIL_MASK |
1938 	    FATTR4_SPACE_FREE_MASK |
1939 	    FATTR4_SPACE_TOTAL_MASK |
1940 	    FATTR4_SPACE_USED_MASK |
1941 	    FATTR4_SYSTEM_MASK)) {
1942 
1943 		if (resbmap & FATTR4_QUOTA_USED_MASK) {
1944 			ASSERT(0);
1945 		}
1946 		if (resbmap & FATTR4_RAWDEV_MASK) {
1947 			fattr4_rawdev rawdev;
1948 
1949 			rawdev.specdata1 = IXDR_GET_U_INT32(ptr);
1950 			rawdev.specdata2 = IXDR_GET_U_INT32(ptr);
1951 
1952 			if (vap->va_type == VCHR || vap->va_type == VBLK) {
1953 				vap->va_rdev = makedevice(rawdev.specdata1,
1954 				    rawdev.specdata2);
1955 			} else {
1956 				vap->va_rdev = 0;
1957 			}
1958 			vap->va_mask |= AT_RDEV;
1959 		}
1960 		if (resbmap & FATTR4_SPACE_AVAIL_MASK) {
1961 			IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_bavail);
1962 			gesp->n4g_sb.f_bavail /= DEV_BSIZE;
1963 		}
1964 		if (resbmap & FATTR4_SPACE_FREE_MASK) {
1965 			IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_bfree);
1966 			gesp->n4g_sb.f_bfree /= DEV_BSIZE;
1967 		}
1968 		if (resbmap & FATTR4_SPACE_TOTAL_MASK) {
1969 			IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_blocks);
1970 			gesp->n4g_sb.f_blocks /= DEV_BSIZE;
1971 		}
1972 		if (resbmap & FATTR4_SPACE_USED_MASK) {
1973 			uint64_t space_used;
1974 			IXDR_GET_U_HYPER(ptr, space_used);
1975 
1976 			/* Compute space depending on device type */
1977 			ASSERT((vap->va_mask & AT_TYPE));
1978 			if (vap->va_type == VREG || vap->va_type == VDIR ||
1979 			    vap->va_type == VLNK) {
1980 				vap->va_nblocks = (u_longlong_t)
1981 				    ((space_used + (offset4)DEV_BSIZE -
1982 				    (offset4)1) / (offset4)DEV_BSIZE);
1983 			} else {
1984 				vap->va_nblocks = 0;
1985 			}
1986 			vap->va_mask |= AT_NBLOCKS;
1987 		}
1988 		if (resbmap & FATTR4_SYSTEM_MASK) {
1989 			ASSERT(0);
1990 		}
1991 	}
1992 	if (resbmap &
1993 	    (FATTR4_TIME_ACCESS_MASK |
1994 	    FATTR4_TIME_ACCESS_SET_MASK |
1995 	    FATTR4_TIME_BACKUP_MASK |
1996 	    FATTR4_TIME_CREATE_MASK |
1997 	    FATTR4_TIME_DELTA_MASK |
1998 	    FATTR4_TIME_METADATA_MASK |
1999 	    FATTR4_TIME_MODIFY_MASK |
2000 	    FATTR4_TIME_MODIFY_SET_MASK |
2001 	    FATTR4_MOUNTED_ON_FILEID_MASK)) {
2002 
2003 		if (resbmap & FATTR4_TIME_ACCESS_MASK) {
2004 			nfstime4 atime;
2005 			int error;
2006 
2007 			IXDR_GET_U_HYPER(ptr, atime.seconds);
2008 			atime.nseconds = IXDR_GET_U_INT32(ptr);
2009 
2010 			error = nfs4_time_ntov(&atime, &vap->va_atime);
2011 			if (error) {
2012 				garp->n4g_attrerr = error;
2013 				garp->n4g_attrwhy = NFS4_GETATTR_ATATIME_ERR;
2014 			}
2015 			vap->va_mask |= AT_ATIME;
2016 		}
2017 		if (resbmap & FATTR4_TIME_ACCESS_SET_MASK) {
2018 			ASSERT(0);
2019 		}
2020 		if (resbmap & FATTR4_TIME_BACKUP_MASK) {
2021 			ASSERT(0);
2022 		}
2023 		if (resbmap & FATTR4_TIME_CREATE_MASK) {
2024 			ASSERT(0);
2025 		}
2026 		if (resbmap & FATTR4_TIME_DELTA_MASK) {
2027 			IXDR_GET_U_HYPER(ptr, gesp->n4g_delta.seconds);
2028 			gesp->n4g_delta.nseconds = IXDR_GET_U_INT32(ptr);
2029 		}
2030 		if (resbmap & FATTR4_TIME_METADATA_MASK) {
2031 			nfstime4 mdt;
2032 			int error;
2033 
2034 			IXDR_GET_U_HYPER(ptr, mdt.seconds);
2035 			mdt.nseconds = IXDR_GET_U_INT32(ptr);
2036 
2037 			error = nfs4_time_ntov(&mdt, &vap->va_ctime);
2038 			if (error) {
2039 				garp->n4g_attrerr = error;
2040 				garp->n4g_attrwhy = NFS4_GETATTR_ATCTIME_ERR;
2041 			}
2042 			vap->va_mask |= AT_CTIME;
2043 		}
2044 		if (resbmap & FATTR4_TIME_MODIFY_MASK) {
2045 			nfstime4 mtime;
2046 			int error;
2047 
2048 			IXDR_GET_U_HYPER(ptr, mtime.seconds);
2049 			mtime.nseconds = IXDR_GET_U_INT32(ptr);
2050 
2051 			error = nfs4_time_ntov(&mtime, &vap->va_mtime);
2052 			if (error) {
2053 				garp->n4g_attrerr = error;
2054 				garp->n4g_attrwhy = NFS4_GETATTR_ATMTIME_ERR;
2055 			}
2056 			vap->va_mask |= AT_MTIME;
2057 		}
2058 		if (resbmap & FATTR4_TIME_MODIFY_SET_MASK) {
2059 			ASSERT(0);
2060 		}
2061 		if (resbmap & FATTR4_MOUNTED_ON_FILEID_MASK) {
2062 			IXDR_GET_U_HYPER(ptr, garp->n4g_mon_fid);
2063 			garp->n4g_mon_fid_valid = 1;
2064 		}
2065 	}
2066 
2067 	/*
2068 	 * FATTR4_ACL_MASK is not yet supported by this function, but
2069 	 * we check against it anyway, in case it ever is.
2070 	 */
2071 	if (resbmap & ~(NFS4_VATTR_MASK | FATTR4_ACL_MASK)) {
2072 		/* copy only if not provided */
2073 		if (garp->n4g_ext_res == NULL) {
2074 			garp->n4g_ext_res = kmem_alloc(sizeof (ges), KM_SLEEP);
2075 			bcopy(&ges, garp->n4g_ext_res, sizeof (ges));
2076 		}
2077 	}
2078 
2079 	return (TRUE);
2080 }
2081 
2082 
2083 /*
2084  * "." and ".." buffers for filling in on read and readdir
2085  * calls. Intialize the first time and fill in on every
2086  * call to to readdir.
2087  */
2088 char	*nfs4_dot_entries;
2089 char	*nfs4_dot_dot_entry;
2090 
2091 /*
2092  * Create the "." or ".." and pad the buffer once so they are
2093  * copied out as required into the user supplied buffer everytime.
2094  * DIRENT64_RECLEN(sizeof (".") - 1) = DIRENT64_RECLEN(1)
2095  * DIRENT64_RECLEN(sizeof ("..") - 1) = DIRENT64_RECLEN(2)
2096  */
2097 void
2098 nfs4_init_dot_entries()
2099 {
2100 	struct dirent64 *odp;
2101 
2102 	/*
2103 	 * zalloc it so it zeros the buffer out. Need
2104 	 * to just do it once.
2105 	 */
2106 	nfs4_dot_entries = kmem_zalloc(DIRENT64_RECLEN(1) + DIRENT64_RECLEN(2),
2107 	    KM_SLEEP);
2108 
2109 	odp = (struct dirent64 *)nfs4_dot_entries;
2110 	odp->d_off = 1; /* magic cookie for "." entry */
2111 	odp->d_reclen = DIRENT64_RECLEN(1);
2112 	odp->d_name[0] = '.';
2113 	odp->d_name[1] = '\0';
2114 
2115 	nfs4_dot_dot_entry = nfs4_dot_entries + DIRENT64_RECLEN(1);
2116 	odp = (struct dirent64 *)nfs4_dot_dot_entry;
2117 
2118 	odp->d_off = 2;
2119 	odp->d_reclen = DIRENT64_RECLEN(2);
2120 	odp->d_name[0] = '.';
2121 	odp->d_name[1] = '.';
2122 	odp->d_name[2] = '\0';
2123 }
2124 
2125 void
2126 nfs4_destroy_dot_entries()
2127 {
2128 	if (nfs4_dot_entries)
2129 		kmem_free(nfs4_dot_entries, DIRENT64_RECLEN(1) +
2130 		    DIRENT64_RECLEN(2));
2131 
2132 	nfs4_dot_entries = nfs4_dot_dot_entry = NULL;
2133 }
2134 
2135 bool_t
2136 xdr_READDIR4res_clnt(XDR *xdrs, READDIR4res_clnt *objp, READDIR4args *aobjp)
2137 {
2138 	bool_t more_data;
2139 	rddir4_cache *rdc = aobjp->rdc;
2140 	dirent64_t *dp = NULL;
2141 	int entry_length = 0;
2142 	int space_left = 0;
2143 	bitmap4 resbmap;
2144 	uint32_t attrlen;
2145 	nfs4_ga_res_t gar;
2146 	struct nfs4_ga_ext_res ges;
2147 	uint64_t last_cookie = 0;
2148 	int skip_to_end;
2149 	ug_cache_t *pug = NULL;
2150 
2151 	ASSERT(xdrs->x_op == XDR_DECODE);
2152 	ASSERT(rdc->entries == NULL);
2153 	ASSERT(aobjp->dircount > 0);
2154 
2155 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
2156 		return (FALSE);
2157 	if (objp->status != NFS4_OK)
2158 		return (TRUE);
2159 
2160 	gar.n4g_va.va_mask = 0;
2161 	gar.n4g_change_valid = 0;
2162 	gar.n4g_mon_fid_valid = 0;
2163 	gar.n4g_fsid_valid = 0;
2164 	gar.n4g_vsa.vsa_mask = 0;
2165 	gar.n4g_attrwhy = NFS4_GETATTR_OP_OK;
2166 	ges.n4g_pc4.pc4_cache_valid = 0;
2167 	ges.n4g_pc4.pc4_xattr_valid = 0;
2168 	gar.n4g_ext_res = &ges;
2169 
2170 	/* READDIR4res_clnt_free needs to kmem_free this buffer */
2171 	rdc->entries = kmem_alloc(aobjp->dircount, KM_SLEEP);
2172 
2173 	dp = (dirent64_t *)rdc->entries;
2174 	rdc->entlen = rdc->buflen = space_left = aobjp->dircount;
2175 
2176 	/* Fill in dot and dot-dot if needed */
2177 	if (rdc->nfs4_cookie == (nfs_cookie4) 0 ||
2178 	    rdc->nfs4_cookie == (nfs_cookie4) 1) {
2179 
2180 		if (rdc->nfs4_cookie == (nfs_cookie4)0) {
2181 			bcopy(nfs4_dot_entries, rdc->entries,
2182 			    DIRENT64_RECLEN(1) + DIRENT64_RECLEN(2));
2183 			objp->dotp = dp;
2184 			dp = (struct dirent64 *)(((char *)dp) +
2185 			    DIRENT64_RECLEN(1));
2186 			objp->dotdotp = dp;
2187 			dp = (struct dirent64 *)(((char *)dp) +
2188 			    DIRENT64_RECLEN(2));
2189 			space_left -= DIRENT64_RECLEN(1) + DIRENT64_RECLEN(2);
2190 
2191 		} else	{	/* for ".." entry */
2192 			bcopy(nfs4_dot_dot_entry, rdc->entries,
2193 			    DIRENT64_RECLEN(2));
2194 			objp->dotp = NULL;
2195 			objp->dotdotp = dp;
2196 			dp = (struct dirent64 *)(((char *)dp) +
2197 			    DIRENT64_RECLEN(2));
2198 			space_left -= DIRENT64_RECLEN(2);
2199 		}
2200 		/* Magic NFSv4 number for entry after start */
2201 		last_cookie = 2;
2202 	}
2203 
2204 	/* Get the cookie VERIFIER */
2205 	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cookieverf))
2206 		goto noentries;
2207 
2208 	/* Get the do-we-have-a-next-entry BOOL */
2209 	if (!xdr_bool(xdrs, &more_data))
2210 		goto noentries;
2211 
2212 	if (aobjp->attr_request & (FATTR4_OWNER_MASK | FATTR4_OWNER_GROUP_MASK))
2213 		pug = alloc_ugcache();
2214 
2215 	skip_to_end = 0;
2216 	while (more_data) {
2217 		uint_t namelen;
2218 		uint64_t cookie;
2219 
2220 		/* Get the COOKIE */
2221 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&cookie))
2222 			goto noentries;
2223 
2224 		/* Get the LENGTH of the entry name */
2225 		if (!xdr_u_int(xdrs, &namelen))
2226 			goto noentries;
2227 
2228 		if (!skip_to_end) {
2229 			/*
2230 			 * With the length of the directory entry name
2231 			 * in hand, figure out if there is room left
2232 			 * to encode it for the requestor.  If not,
2233 			 * that is okay, but the rest of the readdir
2234 			 * operation result must be decoded in the
2235 			 * case there are following operations
2236 			 * in the compound request.  Therefore, mark
2237 			 * the rest of the response as "skip" and
2238 			 * decode or skip the remaining data
2239 			 */
2240 			entry_length = DIRENT64_RECLEN(namelen);
2241 			if (space_left < entry_length)
2242 				skip_to_end = 1;
2243 		}
2244 
2245 		/* Get the NAME of the entry */
2246 		if (!skip_to_end) {
2247 			if (!xdr_opaque(xdrs, dp->d_name, namelen))
2248 				goto noentries;
2249 			bzero(&dp->d_name[namelen],
2250 			    DIRENT64_NAMELEN(entry_length) - namelen);
2251 			dp->d_off = last_cookie = cookie;
2252 			dp->d_reclen = entry_length;
2253 		} else {
2254 			if (!XDR_CONTROL(xdrs, XDR_SKIPBYTES, &namelen))
2255 				goto noentries;
2256 		}
2257 
2258 		/* Get the attribute BITMAP */
2259 		if (!xdr_bitmap4(xdrs, &resbmap))
2260 			goto noentries;
2261 		/* Get the LENGTH of the attributes */
2262 		if (!xdr_u_int(xdrs, (uint_t *)&attrlen))
2263 			goto noentries;
2264 
2265 		/* Get the ATTRIBUTES */
2266 		if (!skip_to_end) {
2267 			uint32_t *ptr;
2268 
2269 			if (!(resbmap & FATTR4_ACL_MASK) &&
2270 			    (ptr = (uint32_t *)XDR_INLINE(xdrs, attrlen))
2271 			    != NULL) {
2272 				if (!xdr_ga_fattr_res_inline(ptr, &gar, resbmap,
2273 				    aobjp->attr_request, aobjp->mi, pug))
2274 					goto noentries;
2275 			} else {
2276 				if (!xdr_ga_fattr_res(xdrs, &gar, resbmap,
2277 				    aobjp->attr_request, aobjp->mi, pug))
2278 					goto noentries;
2279 			}
2280 
2281 			/* Fill in the d_ino per the server's fid values */
2282 			/*
2283 			 * Important to note that the mounted on fileid
2284 			 * is returned in d_ino if supported.  This is
2285 			 * expected, readdir returns the mounted on fileid
2286 			 * while stat() returns the fileid of the object
2287 			 * on "top" of the mount.
2288 			 */
2289 			if (gar.n4g_mon_fid_valid)
2290 				dp->d_ino = gar.n4g_mon_fid;
2291 			else if (gar.n4g_va.va_mask & AT_NODEID)
2292 				dp->d_ino = gar.n4g_va.va_nodeid;
2293 			else
2294 				dp->d_ino = 0;
2295 
2296 			/* See about creating an rnode for this entry */
2297 			if ((resbmap &
2298 			    (NFS4_VATTR_MASK | FATTR4_FILEHANDLE_MASK)) ==
2299 			    (NFS4_VATTR_MASK | FATTR4_FILEHANDLE_MASK)) {
2300 				nfs4_sharedfh_t *sfhp;
2301 				vnode_t *vp;
2302 
2303 				sfhp = sfh4_put(&ges.n4g_fh_u.n4g_fh,
2304 				    aobjp->mi, NULL);
2305 				vp = makenfs4node(sfhp, &gar,
2306 				    aobjp->dvp->v_vfsp,
2307 				    aobjp->t,
2308 				    aobjp->cr,
2309 				    aobjp->dvp,
2310 				    fn_get(VTOSV(aobjp->dvp)->sv_name,
2311 				    dp->d_name, sfhp));
2312 				sfh4_rele(&sfhp);
2313 				dnlc_update(aobjp->dvp, dp->d_name, vp);
2314 				VN_RELE(vp);
2315 			}
2316 
2317 			dp = (struct dirent64 *)(((caddr_t)dp) + dp->d_reclen);
2318 
2319 			space_left -= entry_length;
2320 
2321 		} else {
2322 			if (!XDR_CONTROL(xdrs, XDR_SKIPBYTES, &attrlen))
2323 				goto noentries;
2324 		}
2325 
2326 		/* Get the do-we-have-a-next-entry BOOL */
2327 		if (!xdr_bool(xdrs, &more_data))
2328 			goto noentries;
2329 	}
2330 
2331 	if (pug) {
2332 		kmem_free(pug, sizeof (ug_cache_t));
2333 		pug = NULL;
2334 	}
2335 
2336 	/*
2337 	 * Finish up the rddir cache
2338 	 * If no entries were returned, free up buffer &
2339 	 * set ncookie to the starting cookie for this
2340 	 * readdir request so that the direof caching
2341 	 * will work properly.
2342 	 */
2343 	ASSERT(rdc->entries);
2344 	if (last_cookie == 0) {
2345 		kmem_free(rdc->entries, rdc->entlen);
2346 		rdc->entries = NULL;
2347 		last_cookie = rdc->nfs4_cookie;
2348 	}
2349 
2350 	rdc->actlen = rdc->entlen - space_left;
2351 	rdc->nfs4_ncookie = last_cookie;
2352 
2353 	/* Get the EOF marker */
2354 	if (!xdr_bool(xdrs, &objp->eof))
2355 		goto noentries;
2356 
2357 	/*
2358 	 * If the server returns eof and there were no
2359 	 * skipped entries, set eof
2360 	 */
2361 	rdc->eof = (objp->eof && !skip_to_end) ? TRUE : FALSE;
2362 
2363 	/*
2364 	 * If we encoded entries we are done
2365 	 */
2366 	if (rdc->entries) {
2367 		rdc->error = 0;
2368 		return (TRUE);
2369 	}
2370 
2371 	/*
2372 	 * If there were no entries and we skipped because
2373 	 * there was not enough space, return EINVAL
2374 	 */
2375 	if (skip_to_end) {
2376 		rdc->error = EINVAL;
2377 		return (TRUE);
2378 	}
2379 
2380 	/*
2381 	 * No entries, nothing skipped, and EOF, return OK.
2382 	 */
2383 	if (objp->eof == TRUE) {
2384 		rdc->error = 0;
2385 		return (TRUE);
2386 	}
2387 
2388 	/*
2389 	 * No entries, nothing skipped, and not EOF
2390 	 * probably a bad cookie, return ENOENT.
2391 	 */
2392 	rdc->error = ENOENT;
2393 	return (TRUE);
2394 
2395 noentries:
2396 	if (rdc->entries) {
2397 		kmem_free(rdc->entries, rdc->entlen);
2398 		rdc->entries = NULL;
2399 	}
2400 	if (pug)
2401 		kmem_free(pug, sizeof (ug_cache_t));
2402 	rdc->error = EIO;
2403 	return (FALSE);
2404 }
2405 
2406 /*
2407  * xdr_ga_res
2408  *
2409  * Returns: FALSE on raw data processing errors, TRUE otherwise.
2410  *
2411  * This function pre-processes the OP_GETATTR response, and then
2412  * calls common routines to process the GETATTR fattr4 results into
2413  * vnode attributes and other components that the client is interested
2414  * in. If an error other than an RPC error is encountered, the details
2415  * of the error are filled into objp, although the result of the
2416  * processing is set to TRUE.
2417  */
2418 static bool_t
2419 xdr_ga_res(XDR *xdrs, GETATTR4res *objp, GETATTR4args *aobjp)
2420 {
2421 #ifdef INLINE
2422 	uint32_t *ptr;
2423 #endif
2424 	bitmap4 resbmap;
2425 	uint32_t attrlen;
2426 
2427 	ASSERT(xdrs->x_op == XDR_DECODE);
2428 
2429 	/* Initialize objp attribute error values */
2430 	objp->ga_res.n4g_attrerr =
2431 	    objp->ga_res.n4g_attrwhy = NFS4_GETATTR_OP_OK;
2432 
2433 	if (!xdr_bitmap4(xdrs, &resbmap))
2434 		return (FALSE);
2435 
2436 	/* save the response bitmap for the caller */
2437 	objp->ga_res.n4g_resbmap = resbmap;
2438 
2439 	/* attrlen */
2440 	if (!XDR_GETINT32(xdrs, (int32_t *)&attrlen))
2441 		return (FALSE);
2442 
2443 	/*
2444 	 * Handle case where request and response bitmaps don't match.
2445 	 */
2446 	if (aobjp->attr_request && aobjp->attr_request != resbmap) {
2447 		bitmap4 deltabmap;
2448 
2449 		/*
2450 		 * Return error for case where server sent extra attributes
2451 		 * because the "unknown" attributes may be anywhere in the
2452 		 * xdr stream and can't be properly processed.
2453 		 */
2454 		deltabmap = ((aobjp->attr_request ^ resbmap) & resbmap);
2455 		if (deltabmap) {
2456 			objp->ga_res.n4g_attrerr = EINVAL;
2457 			objp->ga_res.n4g_attrwhy = NFS4_GETATTR_BITMAP_ERR;
2458 			return (TRUE);
2459 		}
2460 
2461 		/*
2462 		 * Return error for case where there is a mandatory
2463 		 * attribute missing in the server response. Note that
2464 		 * missing recommended attributes are evaluated in the
2465 		 * specific routines that decode the server response.
2466 		 */
2467 		deltabmap = ((aobjp->attr_request ^ resbmap)
2468 		    & aobjp->attr_request);
2469 		if ((deltabmap & FATTR4_MANDATTR_MASK)) {
2470 			objp->ga_res.n4g_attrerr = EINVAL;
2471 			objp->ga_res.n4g_attrwhy = NFS4_GETATTR_MANDATTR_ERR;
2472 			return (TRUE);
2473 		}
2474 	}
2475 
2476 	/* Check to see if the attrs can be inlined and go for it if so */
2477 #ifdef INLINE
2478 	if (!(resbmap & FATTR4_ACL_MASK) &&
2479 	    (ptr = (uint32_t *)XDR_INLINE(xdrs, attrlen)) != NULL)
2480 		return (xdr_ga_fattr_res_inline(ptr, &objp->ga_res,
2481 		    resbmap, aobjp->attr_request, aobjp->mi, NULL));
2482 	else
2483 #endif
2484 		return (xdr_ga_fattr_res(xdrs, &objp->ga_res,
2485 		    resbmap, aobjp->attr_request, aobjp->mi, NULL));
2486 }
2487 
2488 #if defined(DEBUG) && !defined(lint)
2489 /*
2490  * We assume that an enum is a 32-bit value, check it once
2491  */
2492 static enum szchk { SZVAL } szchkvar;
2493 #endif
2494 
2495 bool_t
2496 xdr_settime4(XDR *xdrs, settime4 *objp)
2497 {
2498 #if defined(DEBUG) && !defined(lint)
2499 	ASSERT(sizeof (szchkvar) == sizeof (int32_t));
2500 #endif
2501 	if (xdrs->x_op == XDR_FREE)
2502 		return (TRUE);
2503 
2504 	if (!xdr_int(xdrs, (int *)&objp->set_it))
2505 		return (FALSE);
2506 	if (objp->set_it != SET_TO_CLIENT_TIME4)
2507 		return (TRUE);
2508 	/* xdr_nfstime4 */
2509 	if (!xdr_longlong_t(xdrs, (longlong_t *)&objp->time.seconds))
2510 		return (FALSE);
2511 	return (xdr_u_int(xdrs, &objp->time.nseconds));
2512 }
2513 
2514 static bool_t
2515 xdr_fattr4(XDR *xdrs, fattr4 *objp)
2516 {
2517 	if (xdrs->x_op != XDR_FREE) {
2518 		if (!xdr_bitmap4(xdrs, &objp->attrmask))
2519 			return (FALSE);
2520 		return (xdr_bytes(xdrs, (char **)&objp->attrlist4,
2521 		    (uint_t *)&objp->attrlist4_len, NFS4_FATTR4_LIMIT));
2522 	}
2523 
2524 	/*
2525 	 * Optimized free case
2526 	 */
2527 	if (objp->attrlist4 != NULL)
2528 		kmem_free(objp->attrlist4, objp->attrlist4_len);
2529 	return (TRUE);
2530 }
2531 
2532 static bool_t
2533 xdr_ACCESS4res(XDR *xdrs, ACCESS4res *objp)
2534 {
2535 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
2536 		return (FALSE);
2537 	if (objp->status != NFS4_OK)
2538 		return (TRUE);
2539 	if (!xdr_u_int(xdrs, &objp->supported))
2540 		return (FALSE);
2541 	return (xdr_u_int(xdrs, &objp->access));
2542 }
2543 
2544 static bool_t
2545 xdr_CLOSE4args(XDR *xdrs, CLOSE4args *objp)
2546 {
2547 	if (!xdr_u_int(xdrs, &objp->seqid))
2548 		return (FALSE);
2549 	if (!xdr_u_int(xdrs, &objp->open_stateid.seqid))
2550 		return (FALSE);
2551 	return (xdr_opaque(xdrs, objp->open_stateid.other, NFS4_OTHER_SIZE));
2552 }
2553 
2554 static bool_t
2555 xdr_CLOSE4res(XDR *xdrs, CLOSE4res *objp)
2556 {
2557 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
2558 		return (FALSE);
2559 	if (objp->status != NFS4_OK)
2560 		return (TRUE);
2561 	if (!xdr_u_int(xdrs, &objp->open_stateid.seqid))
2562 		return (FALSE);
2563 	return (xdr_opaque(xdrs, objp->open_stateid.other, NFS4_OTHER_SIZE));
2564 }
2565 
2566 static bool_t
2567 xdr_CREATE4args(XDR *xdrs, CREATE4args *objp)
2568 {
2569 	if (xdrs->x_op != XDR_FREE) {
2570 		if (!xdr_int(xdrs, (int32_t *)&objp->type))
2571 			return (FALSE);
2572 		switch (objp->type) {
2573 		case NF4LNK:
2574 			if (!xdr_bytes(xdrs,
2575 			    (char **)&objp->ftype4_u.linkdata.linktext4_val,
2576 			    (uint_t *)&objp->ftype4_u.linkdata.linktext4_len,
2577 			    NFS4_MAX_UTF8STRING))
2578 				return (FALSE);
2579 			break;
2580 		case NF4BLK:
2581 		case NF4CHR:
2582 			if (!xdr_u_int(xdrs, &objp->ftype4_u.devdata.specdata1))
2583 				return (FALSE);
2584 			if (!xdr_u_int(xdrs, &objp->ftype4_u.devdata.specdata2))
2585 				return (FALSE);
2586 			break;
2587 		case NF4SOCK:
2588 		case NF4FIFO:
2589 		case NF4DIR:
2590 		default:
2591 			break;	/* server should return NFS4ERR_BADTYPE */
2592 		}
2593 		if (!xdr_bytes(xdrs, (char **)&objp->objname.utf8string_val,
2594 		    (uint_t *)&objp->objname.utf8string_len,
2595 		    NFS4_MAX_UTF8STRING))
2596 			return (FALSE);
2597 		return (xdr_fattr4(xdrs, &objp->createattrs));
2598 	}
2599 
2600 	/*
2601 	 * Optimized free case
2602 	 */
2603 	if (objp->type == NF4LNK) {
2604 		if (objp->ftype4_u.linkdata.linktext4_val != NULL)
2605 			kmem_free(objp->ftype4_u.linkdata.linktext4_val,
2606 			    objp->ftype4_u.linkdata.linktext4_len);
2607 	}
2608 	if (objp->objname.utf8string_val != NULL)
2609 		kmem_free(objp->objname.utf8string_val,
2610 		    objp->objname.utf8string_len);
2611 	return (xdr_fattr4(xdrs, &objp->createattrs));
2612 }
2613 
2614 static bool_t
2615 xdr_CREATE4cargs(XDR *xdrs, CREATE4cargs *objp)
2616 {
2617 	int len;
2618 
2619 	ASSERT(xdrs->x_op == XDR_ENCODE);
2620 
2621 	if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->type))
2622 		return (FALSE);
2623 	switch (objp->type) {
2624 	case NF4LNK:
2625 		len = strlen(objp->ftype4_u.clinkdata);
2626 		if (len > NFS4_MAX_UTF8STRING)
2627 			return (FALSE);
2628 		if (!XDR_PUTINT32(xdrs, &len))
2629 			return (FALSE);
2630 		if (!xdr_opaque(xdrs, objp->ftype4_u.clinkdata, len))
2631 			return (FALSE);
2632 		break;
2633 	case NF4BLK:
2634 	case NF4CHR:
2635 		if (!XDR_PUTINT32(xdrs,
2636 		    (int32_t *)&objp->ftype4_u.devdata.specdata1))
2637 			return (FALSE);
2638 		if (!XDR_PUTINT32(xdrs,
2639 		    (int32_t *)&objp->ftype4_u.devdata.specdata2))
2640 			return (FALSE);
2641 		break;
2642 	case NF4SOCK:
2643 	case NF4FIFO:
2644 	case NF4DIR:
2645 	default:
2646 		break;	/* server should return NFS4ERR_BADTYPE */
2647 	}
2648 
2649 	len = strlen(objp->cname);
2650 	if (len > NFS4_MAX_UTF8STRING)
2651 		return (FALSE);
2652 	if (!XDR_PUTINT32(xdrs, &len))
2653 		return (FALSE);
2654 	if (!xdr_opaque(xdrs, objp->cname, len))
2655 		return (FALSE);
2656 
2657 	return (xdr_fattr4(xdrs, &objp->createattrs));
2658 }
2659 
2660 static bool_t
2661 xdr_CREATE4res(XDR *xdrs, CREATE4res *objp)
2662 {
2663 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
2664 		return (FALSE);
2665 	if (objp->status != NFS4_OK)
2666 		return (TRUE);
2667 	if (!xdr_bool(xdrs, &objp->cinfo.atomic))
2668 		return (FALSE);
2669 	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.before))
2670 		return (FALSE);
2671 	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.after))
2672 		return (FALSE);
2673 	return (xdr_bitmap4(xdrs, &objp->attrset));
2674 }
2675 
2676 static bool_t
2677 xdr_LINK4res(XDR *xdrs, LINK4res *objp)
2678 {
2679 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
2680 		return (FALSE);
2681 	if (objp->status != NFS4_OK)
2682 		return (TRUE);
2683 	if (!xdr_bool(xdrs, &objp->cinfo.atomic))
2684 		return (FALSE);
2685 	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.before))
2686 		return (FALSE);
2687 	return (xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.after));
2688 }
2689 
2690 static bool_t
2691 xdr_LOCK4args(XDR *xdrs, LOCK4args *objp)
2692 {
2693 	if (xdrs->x_op != XDR_FREE) {
2694 		if (!xdr_int(xdrs, (int *)&objp->locktype))
2695 			return (FALSE);
2696 		if (!xdr_bool(xdrs, &objp->reclaim))
2697 			return (FALSE);
2698 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->offset))
2699 			return (FALSE);
2700 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->length))
2701 			return (FALSE);
2702 		if (!xdr_bool(xdrs, &objp->locker.new_lock_owner))
2703 			return (FALSE);
2704 		if (objp->locker.new_lock_owner == TRUE) {
2705 			if (!xdr_u_int(xdrs, &objp->locker.locker4_u.open_owner.
2706 			    open_seqid))
2707 				return (FALSE);
2708 			if (!xdr_u_int(xdrs, &objp->locker.locker4_u.open_owner.
2709 			    open_stateid.seqid))
2710 				return (FALSE);
2711 			if (!xdr_opaque(xdrs, objp->locker.locker4_u.open_owner.
2712 			    open_stateid.other, NFS4_OTHER_SIZE))
2713 				return (FALSE);
2714 			if (!xdr_u_int(xdrs, &objp->locker.locker4_u.open_owner.
2715 			    lock_seqid))
2716 				return (FALSE);
2717 			if (!xdr_u_longlong_t(xdrs,
2718 			    (u_longlong_t *)&objp->locker.locker4_u.
2719 			    open_owner.lock_owner.clientid))
2720 				return (FALSE);
2721 			return (xdr_bytes(xdrs,
2722 			    (char **)&objp->locker.locker4_u.open_owner.
2723 			    lock_owner.owner_val,
2724 			    (uint_t *)&objp->locker.locker4_u.open_owner.
2725 			    lock_owner.owner_len,
2726 			    NFS4_OPAQUE_LIMIT));
2727 		}
2728 
2729 		if (objp->locker.new_lock_owner != FALSE)
2730 			return (FALSE);
2731 
2732 		if (!xdr_u_int(xdrs, &objp->locker.locker4_u.lock_owner.
2733 		    lock_stateid.seqid))
2734 			return (FALSE);
2735 		if (!xdr_opaque(xdrs, objp->locker.locker4_u.lock_owner.
2736 		    lock_stateid.other, NFS4_OTHER_SIZE))
2737 			return (FALSE);
2738 		return (xdr_u_int(xdrs, &objp->locker.locker4_u.lock_owner.
2739 		    lock_seqid));
2740 	}
2741 
2742 	/*
2743 	 * Optimized free case
2744 	 */
2745 	if (objp->locker.new_lock_owner == TRUE) {
2746 		if (objp->locker.locker4_u.open_owner.lock_owner.owner_val !=
2747 		    NULL) {
2748 			kmem_free(objp->locker.locker4_u.open_owner.lock_owner.
2749 			    owner_val,
2750 			    objp->locker.locker4_u.open_owner.lock_owner.
2751 			    owner_len);
2752 		}
2753 	}
2754 
2755 	return (TRUE);
2756 }
2757 
2758 static bool_t
2759 xdr_LOCK4res(XDR *xdrs, LOCK4res *objp)
2760 {
2761 	if (xdrs->x_op != XDR_FREE) {
2762 		if (!xdr_int(xdrs, (int32_t *)&objp->status))
2763 			return (FALSE);
2764 		if (objp->status == NFS4_OK) {
2765 			if (!xdr_u_int(xdrs,
2766 			    &objp->LOCK4res_u.lock_stateid.seqid))
2767 				return (FALSE);
2768 			return (xdr_opaque(xdrs,
2769 			    objp->LOCK4res_u.lock_stateid.other,
2770 			    NFS4_OTHER_SIZE));
2771 		}
2772 		if (objp->status != NFS4ERR_DENIED)
2773 			return (TRUE);
2774 
2775 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->LOCK4res_u.
2776 		    denied.offset))
2777 			return (FALSE);
2778 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->LOCK4res_u.
2779 		    denied.length))
2780 			return (FALSE);
2781 		if (!xdr_int(xdrs, (int *)&objp->LOCK4res_u.denied.locktype))
2782 			return (FALSE);
2783 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->LOCK4res_u.
2784 		    denied.owner.clientid))
2785 			return (FALSE);
2786 		return (xdr_bytes(xdrs,
2787 		    (char **)&objp->LOCK4res_u.denied.owner.owner_val,
2788 		    (uint_t *)&objp->LOCK4res_u.denied.owner.owner_len,
2789 		    NFS4_OPAQUE_LIMIT));
2790 	}
2791 
2792 	/*
2793 	 * Optimized free case
2794 	 */
2795 	if (objp->status == NFS4_OK || objp->status != NFS4ERR_DENIED)
2796 		return (TRUE);
2797 
2798 	if (objp->LOCK4res_u.denied.owner.owner_val != NULL)
2799 		kmem_free(objp->LOCK4res_u.denied.owner.owner_val,
2800 		    objp->LOCK4res_u.denied.owner.owner_len);
2801 	return (TRUE);
2802 }
2803 
2804 static bool_t
2805 xdr_LOCKT4args(XDR *xdrs, LOCKT4args *objp)
2806 {
2807 	if (xdrs->x_op != XDR_FREE) {
2808 		if (!xdr_int(xdrs, (int *)&objp->locktype))
2809 			return (FALSE);
2810 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->offset))
2811 			return (FALSE);
2812 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->length))
2813 			return (FALSE);
2814 		if (!xdr_u_longlong_t(xdrs,
2815 		    (u_longlong_t *)&objp->owner.clientid))
2816 			return (FALSE);
2817 		return (xdr_bytes(xdrs, (char **)&objp->owner.owner_val,
2818 		    (uint_t *)&objp->owner.owner_len,
2819 		    NFS4_OPAQUE_LIMIT));
2820 	}
2821 
2822 	/*
2823 	 * Optimized free case
2824 	 */
2825 	if (objp->owner.owner_val != NULL)
2826 		kmem_free(objp->owner.owner_val, objp->owner.owner_len);
2827 	return (TRUE);
2828 }
2829 
2830 static bool_t
2831 xdr_LOCKT4res(XDR *xdrs, LOCKT4res *objp)
2832 {
2833 	if (xdrs->x_op != XDR_FREE) {
2834 		if (!xdr_int(xdrs, (int32_t *)&objp->status))
2835 			return (FALSE);
2836 		if (objp->status == NFS4_OK)
2837 			return (TRUE);
2838 		if (objp->status != NFS4ERR_DENIED)
2839 			return (TRUE);
2840 		/* xdr_LOCK4denied */
2841 		if (!xdr_u_longlong_t(xdrs,
2842 		    (u_longlong_t *)&objp->denied.offset))
2843 			return (FALSE);
2844 		if (!xdr_u_longlong_t(xdrs,
2845 		    (u_longlong_t *)&objp->denied.length))
2846 			return (FALSE);
2847 		if (!xdr_int(xdrs, (int *)&objp->denied.locktype))
2848 			return (FALSE);
2849 		if (!xdr_u_longlong_t(xdrs,
2850 		    (u_longlong_t *)&objp->denied.owner.clientid))
2851 			return (FALSE);
2852 		return (xdr_bytes(xdrs,
2853 		    (char **)&objp->denied.owner.owner_val,
2854 		    (uint_t *)&objp->denied.owner.owner_len,
2855 		    NFS4_OPAQUE_LIMIT));
2856 	}
2857 
2858 	/*
2859 	 * Optimized free case
2860 	 */
2861 	if (objp->status == NFS4_OK || objp->status != NFS4ERR_DENIED)
2862 		return (TRUE);
2863 	if (objp->denied.owner.owner_val != NULL)
2864 		kmem_free(objp->denied.owner.owner_val,
2865 		    objp->denied.owner.owner_len);
2866 	return (TRUE);
2867 }
2868 
2869 static bool_t
2870 xdr_LOCKU4args(XDR *xdrs, LOCKU4args *objp)
2871 {
2872 	if (!xdr_int(xdrs, (int *)&objp->locktype))
2873 		return (FALSE);
2874 	if (!xdr_u_int(xdrs, &objp->seqid))
2875 		return (FALSE);
2876 	if (!xdr_u_int(xdrs, &objp->lock_stateid.seqid))
2877 		return (FALSE);
2878 	if (!xdr_opaque(xdrs, objp->lock_stateid.other, NFS4_OTHER_SIZE))
2879 		return (FALSE);
2880 	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->offset))
2881 		return (FALSE);
2882 	return (xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->length));
2883 }
2884 
2885 static bool_t
2886 xdr_OPEN4args(XDR *xdrs, OPEN4args *objp)
2887 {
2888 	if (xdrs->x_op != XDR_FREE) {
2889 		if (!xdr_u_int(xdrs, &objp->seqid))
2890 			return (FALSE);
2891 		if (!xdr_u_int(xdrs, &objp->share_access))
2892 			return (FALSE);
2893 		if (!xdr_u_int(xdrs, &objp->share_deny))
2894 			return (FALSE);
2895 
2896 		/* xdr_open_owner4 */
2897 		if (!xdr_u_longlong_t(xdrs,
2898 		    (u_longlong_t *)&objp->owner.clientid))
2899 			return (FALSE);
2900 		if (!xdr_bytes(xdrs, (char **)&objp->owner.owner_val,
2901 		    (uint_t *)&objp->owner.owner_len,
2902 		    NFS4_OPAQUE_LIMIT))
2903 			return (FALSE);
2904 
2905 		/* xdr_openflag4 */
2906 		if (!xdr_int(xdrs, (int *)&objp->opentype))
2907 			return (FALSE);
2908 		if (objp->opentype == OPEN4_CREATE) {
2909 
2910 			/* xdr_createhow4 */
2911 			if (!xdr_int(xdrs, (int *)&objp->mode))
2912 				return (FALSE);
2913 			switch (objp->mode) {
2914 			case UNCHECKED4:
2915 			case GUARDED4:
2916 				if (!xdr_fattr4(xdrs,
2917 				    &objp->createhow4_u.createattrs))
2918 					return (FALSE);
2919 				break;
2920 			case EXCLUSIVE4:
2921 				if (!xdr_u_longlong_t(xdrs,
2922 				    (u_longlong_t *)&objp->createhow4_u.
2923 				    createverf))
2924 					return (FALSE);
2925 				break;
2926 			default:
2927 				return (FALSE);
2928 			}
2929 		}
2930 
2931 		/* xdr_open_claim4 */
2932 		if (!xdr_int(xdrs, (int *)&objp->claim))
2933 			return (FALSE);
2934 
2935 		switch (objp->claim) {
2936 		case CLAIM_NULL:
2937 			return (xdr_bytes(xdrs, (char **)&objp->open_claim4_u.
2938 			    file.utf8string_val,
2939 			    (uint_t *)&objp->open_claim4_u.file.
2940 			    utf8string_len,
2941 			    NFS4_MAX_UTF8STRING));
2942 		case CLAIM_PREVIOUS:
2943 			return (xdr_int(xdrs,
2944 			    (int *)&objp->open_claim4_u.delegate_type));
2945 		case CLAIM_DELEGATE_CUR:
2946 			if (!xdr_u_int(xdrs, (uint_t *)&objp->open_claim4_u.
2947 			    delegate_cur_info.delegate_stateid.seqid))
2948 				return (FALSE);
2949 			if (!xdr_opaque(xdrs, objp->open_claim4_u.
2950 			    delegate_cur_info.delegate_stateid.other,
2951 			    NFS4_OTHER_SIZE))
2952 				return (FALSE);
2953 			return (xdr_bytes(xdrs, (char **)&objp->open_claim4_u.
2954 			    delegate_cur_info.file.utf8string_val,
2955 			    (uint_t *)&objp->open_claim4_u.
2956 			    delegate_cur_info.file.utf8string_len,
2957 			    NFS4_MAX_UTF8STRING));
2958 		case CLAIM_DELEGATE_PREV:
2959 			return (xdr_bytes(xdrs, (char **)&objp->open_claim4_u.
2960 			    file_delegate_prev.utf8string_val,
2961 			    (uint_t *)&objp->open_claim4_u.
2962 			    file_delegate_prev.utf8string_len,
2963 			    NFS4_MAX_UTF8STRING));
2964 		default:
2965 			return (FALSE);
2966 		}
2967 	}
2968 
2969 	/*
2970 	 * Optimized free case
2971 	 */
2972 	if (objp->owner.owner_val != NULL)
2973 		kmem_free(objp->owner.owner_val, objp->owner.owner_len);
2974 
2975 	if (objp->opentype == OPEN4_CREATE) {
2976 		switch (objp->mode) {
2977 		case UNCHECKED4:
2978 		case GUARDED4:
2979 			(void) xdr_fattr4(xdrs,
2980 			    &objp->createhow4_u.createattrs);
2981 			break;
2982 		case EXCLUSIVE4:
2983 		default:
2984 			break;
2985 		}
2986 	}
2987 
2988 	switch (objp->claim) {
2989 	case CLAIM_NULL:
2990 		if (objp->open_claim4_u.file.utf8string_val != NULL)
2991 			kmem_free(objp->open_claim4_u.file.utf8string_val,
2992 			    objp->open_claim4_u.file.utf8string_len);
2993 		return (TRUE);
2994 	case CLAIM_PREVIOUS:
2995 		return (TRUE);
2996 	case CLAIM_DELEGATE_CUR:
2997 		if (objp->open_claim4_u.delegate_cur_info.file.utf8string_val !=
2998 		    NULL) {
2999 			kmem_free(objp->open_claim4_u.delegate_cur_info.file.
3000 			    utf8string_val,
3001 			    objp->open_claim4_u.delegate_cur_info.file.
3002 			    utf8string_len);
3003 		}
3004 		return (TRUE);
3005 	case CLAIM_DELEGATE_PREV:
3006 		if (objp->open_claim4_u.file_delegate_prev.utf8string_val !=
3007 		    NULL) {
3008 			kmem_free(objp->open_claim4_u.file_delegate_prev.
3009 			    utf8string_val,
3010 			    objp->open_claim4_u.file_delegate_prev.
3011 			    utf8string_len);
3012 		}
3013 		return (TRUE);
3014 	default:
3015 		return (TRUE);
3016 	}
3017 }
3018 
3019 static bool_t
3020 xdr_OPEN4cargs(XDR *xdrs, OPEN4cargs *objp)
3021 {
3022 	int op;
3023 	int len;
3024 	rpc_inline_t *ptr;
3025 
3026 	ASSERT(xdrs->x_op == XDR_ENCODE);
3027 
3028 	/*
3029 	 * We must always define the client's open_owner to be
3030 	 * 4 byte aligned and sized.
3031 	 */
3032 	ASSERT(objp->owner.owner_len <= NFS4_OPAQUE_LIMIT);
3033 	ASSERT(!(objp->owner.owner_len % BYTES_PER_XDR_UNIT));
3034 
3035 	len = objp->owner.owner_len;
3036 	if ((ptr = XDR_INLINE(xdrs, 8 * BYTES_PER_XDR_UNIT + len)) != NULL) {
3037 		int i;
3038 		int32_t *ip;
3039 
3040 		IXDR_PUT_U_INT32(ptr, OP_OPEN);
3041 		IXDR_PUT_U_INT32(ptr, objp->seqid);
3042 		IXDR_PUT_U_INT32(ptr, objp->share_access);
3043 		IXDR_PUT_U_INT32(ptr, objp->share_deny);
3044 
3045 		/* xdr_open_owner4 */
3046 		IXDR_PUT_HYPER(ptr, objp->owner.clientid);
3047 		IXDR_PUT_U_INT32(ptr, objp->owner.owner_len);
3048 		/* We know this is very short so don't bcopy */
3049 		ip = (int32_t *)objp->owner.owner_val;
3050 		len /= BYTES_PER_XDR_UNIT;
3051 		for (i = 0; i < len; i++)
3052 			*ptr++ = *ip++;
3053 
3054 		/* xdr_openflag4 */
3055 		IXDR_PUT_U_INT32(ptr, objp->opentype);
3056 	} else {
3057 		op = OP_OPEN;
3058 		if (!XDR_PUTINT32(xdrs, (int32_t *)&op))
3059 			return (FALSE);
3060 		if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->seqid))
3061 			return (FALSE);
3062 		if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->share_access))
3063 			return (FALSE);
3064 		if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->share_deny))
3065 			return (FALSE);
3066 
3067 		/* xdr_open_owner4 */
3068 		if (!xdr_u_longlong_t(xdrs,
3069 		    (u_longlong_t *)&objp->owner.clientid))
3070 			return (FALSE);
3071 		if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->owner.owner_len))
3072 			return (FALSE);
3073 		if (!xdr_opaque(xdrs, objp->owner.owner_val,
3074 		    objp->owner.owner_len))
3075 			return (FALSE);
3076 
3077 		/* xdr_openflag4 */
3078 		if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->opentype))
3079 			return (FALSE);
3080 	}
3081 
3082 	if (objp->opentype == OPEN4_CREATE) {
3083 		/* xdr_createhow4 */
3084 		if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->mode))
3085 			return (FALSE);
3086 		switch (objp->mode) {
3087 		case UNCHECKED4:
3088 		case GUARDED4:
3089 			if (!xdr_fattr4(xdrs,
3090 			    &objp->createhow4_u.createattrs))
3091 				return (FALSE);
3092 			break;
3093 		case EXCLUSIVE4:
3094 			if (!xdr_u_longlong_t(xdrs,
3095 			    (u_longlong_t *)&objp->createhow4_u.
3096 			    createverf))
3097 				return (FALSE);
3098 			break;
3099 		default:
3100 			return (FALSE);
3101 		}
3102 	}
3103 
3104 	/* xdr_open_claim4 */
3105 	if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->claim))
3106 		return (FALSE);
3107 
3108 	switch (objp->claim) {
3109 	case CLAIM_NULL:
3110 		len = strlen(objp->open_claim4_u.cfile);
3111 		if (len > NFS4_MAX_UTF8STRING)
3112 			return (FALSE);
3113 		if (XDR_PUTINT32(xdrs, &len)) {
3114 			return (xdr_opaque(xdrs,
3115 			    objp->open_claim4_u.cfile, len));
3116 		}
3117 		return (FALSE);
3118 	case CLAIM_PREVIOUS:
3119 		return (XDR_PUTINT32(xdrs,
3120 		    (int32_t *)&objp->open_claim4_u.delegate_type));
3121 	case CLAIM_DELEGATE_CUR:
3122 		if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->open_claim4_u.
3123 		    delegate_cur_info.delegate_stateid.seqid))
3124 			return (FALSE);
3125 		if (!xdr_opaque(xdrs, objp->open_claim4_u.
3126 		    delegate_cur_info.delegate_stateid.other,
3127 		    NFS4_OTHER_SIZE))
3128 			return (FALSE);
3129 		len = strlen(objp->open_claim4_u.delegate_cur_info.cfile);
3130 		if (len > NFS4_MAX_UTF8STRING)
3131 			return (FALSE);
3132 		if (XDR_PUTINT32(xdrs, &len)) {
3133 			return (xdr_opaque(xdrs,
3134 			    objp->open_claim4_u.delegate_cur_info.cfile,
3135 			    len));
3136 		}
3137 		return (FALSE);
3138 	case CLAIM_DELEGATE_PREV:
3139 		len = strlen(objp->open_claim4_u.cfile_delegate_prev);
3140 		if (len > NFS4_MAX_UTF8STRING)
3141 			return (FALSE);
3142 		if (XDR_PUTINT32(xdrs, &len)) {
3143 			return (xdr_opaque(xdrs,
3144 			    objp->open_claim4_u.cfile_delegate_prev, len));
3145 		}
3146 		return (FALSE);
3147 	default:
3148 		return (FALSE);
3149 	}
3150 }
3151 
3152 static bool_t
3153 xdr_OPEN4res(XDR *xdrs, OPEN4res *objp)
3154 {
3155 	if (xdrs->x_op != XDR_FREE) {
3156 		if (!xdr_int(xdrs, (int32_t *)&objp->status))
3157 			return (FALSE);
3158 		if (objp->status != NFS4_OK)
3159 			return (TRUE);
3160 		if (!xdr_u_int(xdrs, &objp->stateid.seqid))
3161 			return (FALSE);
3162 		if (!xdr_opaque(xdrs, objp->stateid.other, NFS4_OTHER_SIZE))
3163 			return (FALSE);
3164 		if (!xdr_bool(xdrs, &objp->cinfo.atomic))
3165 			return (FALSE);
3166 		if (!xdr_u_longlong_t(xdrs,
3167 		    (u_longlong_t *)&objp->cinfo.before))
3168 			return (FALSE);
3169 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.after))
3170 			return (FALSE);
3171 		if (!xdr_u_int(xdrs, &objp->rflags))
3172 			return (FALSE);
3173 		if (!xdr_bitmap4(xdrs, &objp->attrset))
3174 			return (FALSE);
3175 		if (!xdr_int(xdrs,
3176 		    (int *)&objp->delegation.delegation_type))
3177 			return (FALSE);
3178 		switch (objp->delegation.delegation_type) {
3179 		case OPEN_DELEGATE_NONE:
3180 			return (TRUE);
3181 		case OPEN_DELEGATE_READ:
3182 			if (!xdr_u_int(xdrs, &objp->delegation.
3183 			    open_delegation4_u.read.stateid.seqid))
3184 				return (FALSE);
3185 			if (!xdr_opaque(xdrs, objp->delegation.
3186 			    open_delegation4_u.read.stateid.other,
3187 			    NFS4_OTHER_SIZE))
3188 				return (FALSE);
3189 			if (!xdr_bool(xdrs, &objp->delegation.
3190 			    open_delegation4_u.read.recall))
3191 				return (FALSE);
3192 			return (xdr_nfsace4(xdrs, &objp->delegation.
3193 			    open_delegation4_u.read.permissions));
3194 		case OPEN_DELEGATE_WRITE:
3195 			if (!xdr_u_int(xdrs, &objp->delegation.
3196 			    open_delegation4_u.write.stateid.seqid))
3197 				return (FALSE);
3198 			if (!xdr_opaque(xdrs, objp->delegation.
3199 			    open_delegation4_u.write.stateid.other,
3200 			    NFS4_OTHER_SIZE))
3201 				return (FALSE);
3202 			if (!xdr_bool(xdrs, &objp->delegation.
3203 			    open_delegation4_u.write.recall))
3204 				return (FALSE);
3205 			if (!xdr_int(xdrs, (int *)&objp->delegation.
3206 			    open_delegation4_u.write.space_limit.
3207 			    limitby))
3208 				return (FALSE);
3209 			switch (objp->delegation.
3210 			    open_delegation4_u.write.space_limit.
3211 			    limitby) {
3212 			case NFS_LIMIT_SIZE:
3213 				if (!xdr_u_longlong_t(xdrs,
3214 				    (u_longlong_t *)&objp->delegation.
3215 				    open_delegation4_u.write.space_limit.
3216 				    nfs_space_limit4_u.filesize))
3217 					return (FALSE);
3218 				break;
3219 			case NFS_LIMIT_BLOCKS:
3220 				if (!xdr_u_int(xdrs,
3221 				    &objp->delegation.open_delegation4_u.write.
3222 				    space_limit.nfs_space_limit4_u.
3223 				    mod_blocks.num_blocks))
3224 					return (FALSE);
3225 				if (!xdr_u_int(xdrs, &objp->delegation.
3226 				    open_delegation4_u.write.space_limit.
3227 				    nfs_space_limit4_u.mod_blocks.
3228 				    bytes_per_block))
3229 					return (FALSE);
3230 				break;
3231 			default:
3232 				return (FALSE);
3233 			}
3234 			return (xdr_nfsace4(xdrs, &objp->delegation.
3235 			    open_delegation4_u.write.permissions));
3236 		}
3237 		return (FALSE);
3238 	}
3239 
3240 	/*
3241 	 * Optimized free case
3242 	 */
3243 	if (objp->status != NFS4_OK)
3244 		return (TRUE);
3245 
3246 	switch (objp->delegation.delegation_type) {
3247 	case OPEN_DELEGATE_NONE:
3248 		return (TRUE);
3249 	case OPEN_DELEGATE_READ:
3250 		return (xdr_nfsace4(xdrs, &objp->delegation.
3251 		    open_delegation4_u.read.permissions));
3252 	case OPEN_DELEGATE_WRITE:
3253 		switch (objp->delegation.
3254 		    open_delegation4_u.write.space_limit.limitby) {
3255 		case NFS_LIMIT_SIZE:
3256 		case NFS_LIMIT_BLOCKS:
3257 			break;
3258 		default:
3259 			return (FALSE);
3260 		}
3261 		return (xdr_nfsace4(xdrs, &objp->delegation.
3262 		    open_delegation4_u.write.permissions));
3263 	}
3264 	return (FALSE);
3265 }
3266 
3267 static bool_t
3268 xdr_OPEN_CONFIRM4res(XDR *xdrs, OPEN_CONFIRM4res *objp)
3269 {
3270 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
3271 		return (FALSE);
3272 	if (objp->status != NFS4_OK)
3273 		return (TRUE);
3274 	if (!xdr_u_int(xdrs, &objp->open_stateid.seqid))
3275 		return (FALSE);
3276 	return (xdr_opaque(xdrs, objp->open_stateid.other, NFS4_OTHER_SIZE));
3277 }
3278 
3279 static bool_t
3280 xdr_OPEN_DOWNGRADE4args(XDR *xdrs, OPEN_DOWNGRADE4args *objp)
3281 {
3282 	if (!xdr_u_int(xdrs, &objp->open_stateid.seqid))
3283 		return (FALSE);
3284 	if (!xdr_opaque(xdrs, objp->open_stateid.other, NFS4_OTHER_SIZE))
3285 		return (FALSE);
3286 	if (!xdr_u_int(xdrs, &objp->seqid))
3287 		return (FALSE);
3288 	if (!xdr_u_int(xdrs, &objp->share_access))
3289 		return (FALSE);
3290 	return (xdr_u_int(xdrs, &objp->share_deny));
3291 }
3292 
3293 static bool_t
3294 xdr_OPEN_DOWNGRADE4res(XDR *xdrs, OPEN_DOWNGRADE4res *objp)
3295 {
3296 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
3297 		return (FALSE);
3298 	if (objp->status != NFS4_OK)
3299 		return (TRUE);
3300 	if (!xdr_u_int(xdrs, &objp->open_stateid.seqid))
3301 		return (FALSE);
3302 	return (xdr_opaque(xdrs, objp->open_stateid.other, NFS4_OTHER_SIZE));
3303 }
3304 
3305 static bool_t
3306 xdr_READ4args(XDR *xdrs, READ4args *objp)
3307 {
3308 	rdma_chunkinfo_t rci;
3309 	rdma_wlist_conn_info_t rwci;
3310 	struct xdr_ops *xops = xdrrdma_xops();
3311 
3312 	if (!xdr_u_int(xdrs, &objp->stateid.seqid))
3313 		return (FALSE);
3314 	if (!xdr_opaque(xdrs, objp->stateid.other, NFS4_OTHER_SIZE))
3315 		return (FALSE);
3316 	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->offset))
3317 		return (FALSE);
3318 	if (!xdr_u_int(xdrs, &objp->count))
3319 		return (FALSE);
3320 
3321 	DTRACE_PROBE1(xdr__i__read4args_buf_len,
3322 	    int, objp->count);
3323 
3324 	objp->wlist = NULL;
3325 
3326 	if (xdrs->x_ops == xops && xdrs->x_op == XDR_ENCODE) {
3327 		rci.rci_type = RCI_WRITE_ADDR_CHUNK;
3328 		rci.rci_len = objp->count;
3329 		(void) XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
3330 	}
3331 
3332 	if (xdrs->x_ops != &xdrrdma_ops || xdrs->x_op == XDR_FREE)
3333 		return (TRUE);
3334 
3335 	if (xdrs->x_op == XDR_ENCODE) {
3336 		if (objp->res_uiop != NULL) {
3337 			rci.rci_type = RCI_WRITE_UIO_CHUNK;
3338 			rci.rci_a.rci_uiop = objp->res_uiop;
3339 			rci.rci_len = objp->count;
3340 			rci.rci_clpp = &objp->wlist;
3341 		} else {
3342 			rci.rci_type = RCI_WRITE_ADDR_CHUNK;
3343 			rci.rci_a.rci_addr = objp->res_data_val_alt;
3344 			rci.rci_len = objp->count;
3345 			rci.rci_clpp = &objp->wlist;
3346 		}
3347 
3348 		return (XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci));
3349 	}
3350 
3351 	/* XDR_DECODE case */
3352 	(void) XDR_CONTROL(xdrs, XDR_RDMA_GET_WCINFO, &rwci);
3353 	objp->wlist = rwci.rwci_wlist;
3354 	objp->conn = rwci.rwci_conn;
3355 
3356 	return (TRUE);
3357 }
3358 
3359 static bool_t
3360 xdr_READ4res(XDR *xdrs, READ4res *objp)
3361 {
3362 	mblk_t *mp;
3363 
3364 	if (xdrs->x_op == XDR_DECODE)
3365 		return (FALSE);
3366 
3367 	if (xdrs->x_op == XDR_FREE) {
3368 		/*
3369 		 * Optimized free case
3370 		 */
3371 		if (objp->status != NFS4_OK)
3372 			return (TRUE);
3373 		if (objp->data_val != NULL)
3374 			kmem_free(objp->data_val, objp->data_len);
3375 		return (TRUE);
3376 	}
3377 
3378 	/* on with ENCODE paths */
3379 	if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->status))
3380 		return (FALSE);
3381 	if (objp->status != NFS4_OK)
3382 		return (TRUE);
3383 
3384 	if (!XDR_PUTINT32(xdrs, &objp->eof))
3385 		return (FALSE);
3386 
3387 	mp = objp->mblk;
3388 	if (mp != NULL) {
3389 		if (xdrs->x_ops == &xdrmblk_ops) {
3390 			if (xdrmblk_putmblk(xdrs, mp, objp->data_len)) {
3391 				objp->mblk = NULL;
3392 				return (TRUE);
3393 			} else {
3394 				return (FALSE);
3395 			}
3396 		} else if (mp->b_cont != NULL) {
3397 			/*
3398 			 * See xdr_READ3res() for an explanation of why we need
3399 			 * to do a pullup here.
3400 			 */
3401 			if (pullupmsg(mp, -1) == 0)
3402 				return (FALSE);
3403 			objp->data_val = (caddr_t)mp->b_rptr;
3404 		}
3405 	} else {
3406 		if (xdr_u_int(xdrs, &objp->data_len) == FALSE) {
3407 			return (FALSE);
3408 		}
3409 		/*
3410 		 * If read data sent by wlist (RDMA_WRITE), don't do
3411 		 * xdr_bytes() below.   RDMA_WRITE transfers the data.
3412 		 * Note: this is encode-only because the client code
3413 		 * uses xdr_READ4res_clnt to decode results.
3414 		 */
3415 		if (objp->wlist) {
3416 			if (objp->data_len != 0) {
3417 				return (xdrrdma_send_read_data(
3418 				    xdrs, objp->data_len, objp->wlist));
3419 			}
3420 			return (TRUE);
3421 		}
3422 	}
3423 
3424 	return (xdr_bytes(xdrs, (char **)&objp->data_val,
3425 	    (uint_t *)&objp->data_len,
3426 	    objp->data_len));
3427 }
3428 
3429 static bool_t
3430 xdr_READ4res_clnt(XDR *xdrs, READ4res *objp, READ4args *aobjp)
3431 {
3432 	mblk_t *mp;
3433 	size_t n;
3434 	int error;
3435 	uint_t size = aobjp->res_maxsize;
3436 	count4 ocount;
3437 
3438 	if (xdrs->x_op == XDR_ENCODE)
3439 		return (FALSE);
3440 
3441 	if (xdrs->x_op == XDR_FREE) {
3442 		/*
3443 		 * Optimized free case
3444 		 */
3445 		if (objp->status != NFS4_OK)
3446 			return (TRUE);
3447 		if (objp->data_val != NULL)
3448 			kmem_free(objp->data_val, objp->data_len);
3449 		return (TRUE);
3450 	}
3451 
3452 	if (!XDR_GETINT32(xdrs, (int32_t *)&objp->status))
3453 		return (FALSE);
3454 	if (objp->status != NFS4_OK)
3455 		return (TRUE);
3456 
3457 	if (!XDR_GETINT32(xdrs, &objp->eof))
3458 		return (FALSE);
3459 
3460 
3461 	/*
3462 	 * This is a special case such that the caller is providing a
3463 	 * uio as a guide to eventual data location; this is used for
3464 	 * handling DIRECTIO reads.
3465 	 */
3466 	if (aobjp->res_uiop != NULL) {
3467 		struct uio *uiop = aobjp->res_uiop;
3468 		int32_t *ptr;
3469 
3470 		if (xdrs->x_ops == &xdrmblk_ops) {
3471 			if (!xdrmblk_getmblk(xdrs, &mp, &objp->data_len))
3472 				return (FALSE);
3473 
3474 			if (objp->data_len == 0)
3475 				return (TRUE);
3476 
3477 			if (objp->data_len > size)
3478 				return (FALSE);
3479 
3480 			size = objp->data_len;
3481 			do {
3482 				n = MIN(size, mp->b_wptr - mp->b_rptr);
3483 				if ((n = MIN(uiop->uio_resid, n)) != 0) {
3484 
3485 					error =	uiomove((char *)mp->b_rptr, n,
3486 					    UIO_READ, uiop);
3487 					if (error)
3488 						return (FALSE);
3489 					mp->b_rptr += n;
3490 					size -= n;
3491 				}
3492 
3493 				while (mp && (mp->b_rptr >= mp->b_wptr))
3494 					mp = mp->b_cont;
3495 			} while (mp && size > 0 && uiop->uio_resid > 0);
3496 
3497 			return (TRUE);
3498 		}
3499 
3500 		if (xdrs->x_ops == &xdrrdma_ops) {
3501 			struct clist *cl;
3502 
3503 			XDR_CONTROL(xdrs, XDR_RDMA_GET_WLIST, &cl);
3504 
3505 			objp->wlist = cl;
3506 
3507 			if (objp->wlist) {
3508 				/* opaque count */
3509 				if (!xdr_u_int(xdrs, &ocount)) {
3510 					objp->wlist = NULL;
3511 					return (FALSE);
3512 				}
3513 
3514 				objp->wlist_len = clist_len(cl);
3515 				objp->data_len = ocount;
3516 
3517 				if (objp->wlist_len !=
3518 				    roundup(
3519 				    objp->data_len, BYTES_PER_XDR_UNIT)) {
3520 					DTRACE_PROBE2(
3521 					    xdr__e__read4resuio_clnt_fail,
3522 					    int, ocount,
3523 					    int, objp->data_len);
3524 					objp->wlist = NULL;
3525 					return (FALSE);
3526 				}
3527 
3528 				uiop->uio_resid -= objp->data_len;
3529 				uiop->uio_iov->iov_len -= objp->data_len;
3530 				uiop->uio_iov->iov_base += objp->data_len;
3531 				uiop->uio_loffset += objp->data_len;
3532 
3533 				objp->wlist = NULL;
3534 				return (TRUE);
3535 			}
3536 		}
3537 
3538 		/*
3539 		 * This isn't an xdrmblk stream nor RDMA.
3540 		 * Handle the likely case that it can be
3541 		 * inlined (ex. xdrmem).
3542 		 */
3543 		if (!XDR_GETINT32(xdrs, (int32_t *)&objp->data_len))
3544 			return (FALSE);
3545 
3546 		if (objp->data_len == 0)
3547 			return (TRUE);
3548 
3549 		if (objp->data_len > size)
3550 			return (FALSE);
3551 
3552 		size = (int)objp->data_len;
3553 		if ((ptr = XDR_INLINE(xdrs, size)) != NULL)
3554 			return (uiomove(ptr, size, UIO_READ, uiop) ?
3555 			    FALSE : TRUE);
3556 
3557 		/*
3558 		 * Handle some other (unlikely) stream type that will
3559 		 * need a copy.
3560 		 */
3561 		if ((ptr = kmem_alloc(size, KM_NOSLEEP)) == NULL)
3562 			return (FALSE);
3563 
3564 		if (!XDR_GETBYTES(xdrs, (caddr_t)ptr, size)) {
3565 			kmem_free(ptr, size);
3566 			return (FALSE);
3567 		}
3568 		error = uiomove(ptr, size, UIO_READ, uiop);
3569 		kmem_free(ptr, size);
3570 
3571 		return (error ? FALSE : TRUE);
3572 	}
3573 
3574 	/*
3575 	 * Check for the other special case of the caller providing
3576 	 * the target area for the data.
3577 	 */
3578 	if (aobjp->res_data_val_alt == NULL)
3579 		return (FALSE);
3580 
3581 	/*
3582 	 * If read data received via RDMA_WRITE, don't do xdr_bytes().
3583 	 * RDMA_WRITE already moved the data so decode length of
3584 	 * RDMA_WRITE.
3585 	 */
3586 	if (xdrs->x_ops == &xdrrdma_ops) {
3587 		struct clist *cl;
3588 
3589 		XDR_CONTROL(xdrs, XDR_RDMA_GET_WLIST, &cl);
3590 
3591 		objp->wlist = cl;
3592 
3593 		/*
3594 		 * Data transferred through inline if
3595 		 * objp->wlist == NULL
3596 		 */
3597 		if (objp->wlist) {
3598 			/* opaque count */
3599 			if (!xdr_u_int(xdrs, &ocount)) {
3600 				objp->wlist = NULL;
3601 				return (FALSE);
3602 			}
3603 
3604 			objp->wlist_len = clist_len(cl);
3605 			objp->data_len = ocount;
3606 
3607 			if (objp->wlist_len !=
3608 			    roundup(
3609 			    objp->data_len, BYTES_PER_XDR_UNIT)) {
3610 				DTRACE_PROBE2(
3611 				    xdr__e__read4res_clnt_fail,
3612 				    int, ocount,
3613 				    int, objp->data_len);
3614 				objp->wlist = NULL;
3615 				return (FALSE);
3616 			}
3617 
3618 			objp->wlist = NULL;
3619 			return (TRUE);
3620 		}
3621 	}
3622 
3623 	return (xdr_bytes(xdrs, (char **)&aobjp->res_data_val_alt,
3624 	    (uint_t *)&objp->data_len,
3625 	    aobjp->res_maxsize));
3626 }
3627 
3628 static bool_t
3629 xdr_READDIR4args(XDR *xdrs, READDIR4args *objp)
3630 {
3631 	rdma_chunkinfo_t rci;
3632 	struct xdr_ops *xops = xdrrdma_xops();
3633 
3634 	if ((xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) &&
3635 	    xdrs->x_op == XDR_ENCODE) {
3636 		rci.rci_type = RCI_REPLY_CHUNK;
3637 		rci.rci_len = objp->maxcount;
3638 		XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
3639 	}
3640 
3641 	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cookie))
3642 		return (FALSE);
3643 	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cookieverf))
3644 		return (FALSE);
3645 	if (!xdr_u_int(xdrs, &objp->dircount))
3646 		return (FALSE);
3647 	if (!xdr_u_int(xdrs, &objp->maxcount))
3648 		return (FALSE);
3649 	return (xdr_bitmap4(xdrs, &objp->attr_request));
3650 }
3651 
3652 /* ARGSUSED */
3653 static bool_t
3654 xdrmblk_putmblk_rd(XDR *xdrs, mblk_t *m)
3655 {
3656 	if (((m->b_wptr - m->b_rptr) % BYTES_PER_XDR_UNIT) != 0)
3657 		return (FALSE);
3658 
3659 	/* LINTED pointer alignment */
3660 	((mblk_t *)xdrs->x_base)->b_cont = m;
3661 	xdrs->x_base = (caddr_t)m;
3662 	xdrs->x_handy = 0;
3663 	return (TRUE);
3664 }
3665 
3666 bool_t
3667 xdr_READDIR4res(XDR *xdrs, READDIR4res *objp)
3668 {
3669 	mblk_t *mp = objp->mblk;
3670 	bool_t ret_val;
3671 	uint_t flags = 0;
3672 
3673 	ASSERT(xdrs->x_op == XDR_ENCODE);
3674 
3675 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
3676 		return (FALSE);
3677 	if (objp->status != NFS4_OK)
3678 		return (TRUE);
3679 	if (mp == NULL)
3680 		return (FALSE);
3681 
3682 	if (xdrs->x_ops == &xdrmblk_ops) {
3683 		if (xdrmblk_putmblk_rd(xdrs, mp)
3684 		    == TRUE) {
3685 			/* mblk successfully inserted into outgoing chain */
3686 			objp->mblk = NULL;
3687 			return (TRUE);
3688 		}
3689 	}
3690 
3691 	ASSERT(mp->b_cont == NULL);
3692 
3693 	/*
3694 	 * If transport is RDMA, the pre-encoded m_blk needs to be moved
3695 	 * without being chunked.
3696 	 * Check if chunking is enabled for the xdr stream.
3697 	 * If it is enabled, disable it temporarily for this op,
3698 	 * then re-enable.
3699 	 */
3700 	XDR_CONTROL(xdrs, XDR_RDMA_GET_FLAGS, &flags);
3701 
3702 	if (!(flags & XDR_RDMA_CHUNK))
3703 		return (xdr_opaque(xdrs, (char *)mp->b_rptr, objp->data_len));
3704 
3705 	flags &= ~XDR_RDMA_CHUNK;
3706 
3707 	(void) XDR_CONTROL(xdrs, XDR_RDMA_SET_FLAGS, &flags);
3708 
3709 	ret_val = xdr_opaque(xdrs, (char *)mp->b_rptr, objp->data_len);
3710 
3711 	flags |= XDR_RDMA_CHUNK;
3712 
3713 	(void) XDR_CONTROL(xdrs, XDR_RDMA_SET_FLAGS, &flags);
3714 
3715 	return (ret_val);
3716 }
3717 
3718 static bool_t
3719 xdr_READLINK4res(XDR *xdrs, READLINK4res *objp)
3720 {
3721 	if (xdrs->x_op != XDR_FREE) {
3722 		if (!xdr_int(xdrs, (int32_t *)&objp->status))
3723 			return (FALSE);
3724 		if (objp->status != NFS4_OK)
3725 			return (TRUE);
3726 		return (xdr_bytes(xdrs, (char **)&objp->link.linktext4_val,
3727 		    (uint_t *)&objp->link.linktext4_len,
3728 		    NFS4_MAX_UTF8STRING));
3729 	}
3730 
3731 	/*
3732 	 * Optimized free case
3733 	 */
3734 	if (objp->status != NFS4_OK)
3735 		return (TRUE);
3736 	if (objp->link.linktext4_val != NULL)
3737 		kmem_free(objp->link.linktext4_val, objp->link.linktext4_len);
3738 	return (TRUE);
3739 }
3740 
3741 static bool_t
3742 xdr_REMOVE4res(XDR *xdrs, REMOVE4res *objp)
3743 {
3744 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
3745 		return (FALSE);
3746 	if (objp->status != NFS4_OK)
3747 		return (TRUE);
3748 	if (!xdr_bool(xdrs, &objp->cinfo.atomic))
3749 		return (FALSE);
3750 	if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.before))
3751 		return (FALSE);
3752 	return (xdr_u_longlong_t(xdrs,
3753 	    (u_longlong_t *)&objp->cinfo.after));
3754 }
3755 
3756 static bool_t
3757 xdr_RENAME4res(XDR *xdrs, RENAME4res *objp)
3758 {
3759 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
3760 		return (FALSE);
3761 	if (objp->status != NFS4_OK)
3762 		return (TRUE);
3763 	if (!xdr_bool(xdrs, &objp->source_cinfo.atomic))
3764 		return (FALSE);
3765 	if (!xdr_u_longlong_t(xdrs,
3766 	    (u_longlong_t *)&objp->source_cinfo.before))
3767 		return (FALSE);
3768 	if (!xdr_u_longlong_t(xdrs,
3769 	    (u_longlong_t *)&objp->source_cinfo.after))
3770 		return (FALSE);
3771 	if (!xdr_bool(xdrs, &objp->target_cinfo.atomic))
3772 		return (FALSE);
3773 	if (!xdr_u_longlong_t(xdrs,
3774 	    (u_longlong_t *)&objp->target_cinfo.before))
3775 		return (FALSE);
3776 	return (xdr_u_longlong_t(xdrs,
3777 	    (u_longlong_t *)&objp->target_cinfo.after));
3778 }
3779 
3780 static bool_t
3781 xdr_secinfo4(XDR *xdrs, secinfo4 *objp)
3782 {
3783 	if (xdrs->x_op != XDR_FREE) {
3784 		if (!xdr_u_int(xdrs, &objp->flavor))
3785 			return (FALSE);
3786 		if (objp->flavor != RPCSEC_GSS)
3787 			return (TRUE);
3788 		if (!xdr_bytes(xdrs,
3789 		    (char **)&objp->flavor_info.oid.sec_oid4_val,
3790 		    (uint_t *)&objp->flavor_info.oid.sec_oid4_len,
3791 		    NFS4_MAX_SECOID4))
3792 			return (FALSE);
3793 		if (!xdr_u_int(xdrs, &objp->flavor_info.qop))
3794 			return (FALSE);
3795 		return (xdr_int(xdrs, (int *)&objp->flavor_info.service));
3796 	}
3797 
3798 	/*
3799 	 * Optimized free path
3800 	 */
3801 	if (objp->flavor != RPCSEC_GSS)
3802 		return (TRUE);
3803 
3804 	if (objp->flavor_info.oid.sec_oid4_val != NULL)
3805 		kmem_free(objp->flavor_info.oid.sec_oid4_val,
3806 		    objp->flavor_info.oid.sec_oid4_len);
3807 	return (TRUE);
3808 }
3809 
3810 static bool_t
3811 xdr_SETCLIENTID4args(XDR *xdrs, SETCLIENTID4args *objp)
3812 {
3813 	if (xdrs->x_op != XDR_FREE) {
3814 		if (!xdr_u_longlong_t(xdrs,
3815 		    (u_longlong_t *)&objp->client.verifier))
3816 			return (FALSE);
3817 		if (!xdr_bytes(xdrs, (char **)&objp->client.id_val,
3818 		    (uint_t *)&objp->client.id_len, NFS4_OPAQUE_LIMIT))
3819 			return (FALSE);
3820 		if (!xdr_u_int(xdrs, &objp->callback.cb_program))
3821 			return (FALSE);
3822 		if (!xdr_string(xdrs, &objp->callback.cb_location.r_netid,
3823 		    NFS4_OPAQUE_LIMIT))
3824 			return (FALSE);
3825 		if (!xdr_string(xdrs, &objp->callback.cb_location.r_addr,
3826 		    NFS4_OPAQUE_LIMIT))
3827 			return (FALSE);
3828 		return (xdr_u_int(xdrs, &objp->callback_ident));
3829 	}
3830 
3831 	/*
3832 	 * Optimized free case
3833 	 */
3834 	if (objp->client.id_val != NULL)
3835 		kmem_free(objp->client.id_val, objp->client.id_len);
3836 	(void) xdr_string(xdrs, &objp->callback.cb_location.r_netid,
3837 	    NFS4_OPAQUE_LIMIT);
3838 	return (xdr_string(xdrs, &objp->callback.cb_location.r_addr,
3839 	    NFS4_OPAQUE_LIMIT));
3840 }
3841 
3842 static bool_t
3843 xdr_SETCLIENTID4res(XDR *xdrs, SETCLIENTID4res *objp)
3844 {
3845 	if (xdrs->x_op != XDR_FREE) {
3846 		if (!xdr_int(xdrs, (int32_t *)&objp->status))
3847 			return (FALSE);
3848 		switch (objp->status) {
3849 		case NFS4_OK:
3850 			if (!xdr_u_longlong_t(xdrs,
3851 			    (u_longlong_t *)&objp->SETCLIENTID4res_u.resok4.
3852 			    clientid))
3853 				return (FALSE);
3854 			return (xdr_u_longlong_t(xdrs,
3855 			    (u_longlong_t *)&objp->SETCLIENTID4res_u.
3856 			    resok4.setclientid_confirm));
3857 		case NFS4ERR_CLID_INUSE:
3858 			if (!xdr_string(xdrs,
3859 			    &objp->SETCLIENTID4res_u.client_using.
3860 			    r_netid, NFS4_OPAQUE_LIMIT))
3861 				return (FALSE);
3862 			return (xdr_string(xdrs,
3863 			    &objp->SETCLIENTID4res_u.client_using.
3864 			    r_addr, NFS4_OPAQUE_LIMIT));
3865 		}
3866 		return (TRUE);
3867 	}
3868 
3869 	/*
3870 	 * Optimized free case
3871 	 */
3872 	if (objp->status != NFS4ERR_CLID_INUSE)
3873 		return (TRUE);
3874 
3875 	if (!xdr_string(xdrs, &objp->SETCLIENTID4res_u.client_using.r_netid,
3876 	    NFS4_OPAQUE_LIMIT))
3877 		return (FALSE);
3878 	return (xdr_string(xdrs, &objp->SETCLIENTID4res_u.client_using.r_addr,
3879 	    NFS4_OPAQUE_LIMIT));
3880 }
3881 
3882 static bool_t
3883 xdr_WRITE4args(XDR *xdrs, WRITE4args *objp)
3884 {
3885 	if (xdrs->x_op != XDR_FREE) {
3886 		if (!xdr_u_int(xdrs, &objp->stateid.seqid))
3887 			return (FALSE);
3888 		if (!xdr_opaque(xdrs, objp->stateid.other, NFS4_OTHER_SIZE))
3889 			return (FALSE);
3890 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->offset))
3891 			return (FALSE);
3892 		if (!xdr_int(xdrs, (int *)&objp->stable))
3893 			return (FALSE);
3894 		if (xdrs->x_op == XDR_DECODE) {
3895 			if (xdrs->x_ops == &xdrmblk_ops) {
3896 				objp->data_val = NULL;
3897 				return (xdrmblk_getmblk(xdrs, &objp->mblk,
3898 				    &objp->data_len));
3899 			}
3900 			objp->mblk = NULL;
3901 			if (xdrs->x_ops == &xdrrdmablk_ops) {
3902 				int retval;
3903 				retval = xdrrdma_getrdmablk(xdrs,
3904 				    &objp->rlist,
3905 				    &objp->data_len,
3906 				    &objp->conn, NFS4_DATA_LIMIT);
3907 				if (retval == FALSE)
3908 					return (FALSE);
3909 				return (xdrrdma_read_from_client(objp->rlist,
3910 				    &objp->conn, objp->data_len));
3911 			}
3912 		}
3913 		/* Else fall thru for the xdr_bytes(). */
3914 		return (xdr_bytes(xdrs, (char **)&objp->data_val,
3915 		    (uint_t *)&objp->data_len, NFS4_DATA_LIMIT));
3916 	}
3917 	if (objp->rlist != NULL) {
3918 		(void) xdrrdma_free_clist(objp->conn, objp->rlist);
3919 		objp->rlist = NULL;
3920 		objp->data_val = NULL;
3921 
3922 		return (TRUE);
3923 	}
3924 
3925 	/*
3926 	 * Optimized free case
3927 	 */
3928 	if (objp->data_val != NULL)
3929 		kmem_free(objp->data_val, objp->data_len);
3930 	return (TRUE);
3931 }
3932 
3933 static bool_t
3934 xdr_WRITE4res(XDR *xdrs, WRITE4res *objp)
3935 {
3936 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
3937 		return (FALSE);
3938 	if (objp->status != NFS4_OK)
3939 		return (TRUE);
3940 	if (!xdr_u_int(xdrs, &objp->count))
3941 		return (FALSE);
3942 	if (!xdr_int(xdrs, (int *)&objp->committed))
3943 		return (FALSE);
3944 	return (xdr_u_longlong_t(xdrs,
3945 	    (u_longlong_t *)&objp->writeverf));
3946 }
3947 
3948 static bool_t
3949 xdr_snfs_argop4_free(XDR *xdrs, nfs_argop4 **arrayp, int len)
3950 {
3951 	int i;
3952 	nfs_argop4 *array = *arrayp;
3953 
3954 	/*
3955 	 * Optimized XDR_FREE only args array
3956 	 */
3957 	ASSERT(xdrs->x_op == XDR_FREE);
3958 
3959 	/*
3960 	 * Nothing to do?
3961 	 */
3962 	if (array == NULL)
3963 		return (TRUE);
3964 
3965 	for (i = 0; i < len; i++) {
3966 		/*
3967 		 * These should be ordered by frequency of use
3968 		 */
3969 		switch (array[i].argop) {
3970 		case OP_PUTFH: {
3971 			nfs_fh4 *objp = &array[i].nfs_argop4_u.opputfh.object;
3972 
3973 			if (objp->nfs_fh4_val != NULL) {
3974 				kmem_free(objp->nfs_fh4_val, objp->nfs_fh4_len);
3975 			}
3976 			continue;
3977 		}
3978 		case OP_GETATTR:
3979 		case OP_GETFH:
3980 			continue;
3981 		case OP_LOOKUP:
3982 			if (array[i].nfs_argop4_u.oplookup.objname.
3983 			    utf8string_val != NULL) {
3984 				kmem_free(array[i].nfs_argop4_u.oplookup.
3985 				    objname.utf8string_val,
3986 				    array[i].nfs_argop4_u.oplookup.
3987 				    objname.utf8string_len);
3988 			}
3989 			continue;
3990 		case OP_OPEN:
3991 			(void) xdr_OPEN4args(xdrs,
3992 			    &array[i].nfs_argop4_u.opopen);
3993 			continue;
3994 		case OP_CLOSE:
3995 		case OP_ACCESS:
3996 		case OP_READ:
3997 			continue;
3998 		case OP_WRITE:
3999 			(void) xdr_WRITE4args(xdrs,
4000 			    &array[i].nfs_argop4_u.opwrite);
4001 			continue;
4002 		case OP_DELEGRETURN:
4003 		case OP_LOOKUPP:
4004 		case OP_READDIR:
4005 			continue;
4006 		case OP_REMOVE:
4007 			if (array[i].nfs_argop4_u.opremove.target.
4008 			    utf8string_val != NULL) {
4009 				kmem_free(array[i].nfs_argop4_u.opremove.target.
4010 				    utf8string_val,
4011 				    array[i].nfs_argop4_u.opremove.target.
4012 				    utf8string_len);
4013 			}
4014 			continue;
4015 		case OP_COMMIT:
4016 			continue;
4017 		case OP_CREATE:
4018 			(void) xdr_CREATE4args(xdrs,
4019 			    &array[i].nfs_argop4_u.opcreate);
4020 			continue;
4021 		case OP_DELEGPURGE:
4022 			continue;
4023 		case OP_LINK:
4024 			if (array[i].nfs_argop4_u.oplink.newname.
4025 			    utf8string_val != NULL) {
4026 				kmem_free(array[i].nfs_argop4_u.oplink.newname.
4027 				    utf8string_val,
4028 				    array[i].nfs_argop4_u.oplink.newname.
4029 				    utf8string_len);
4030 			}
4031 			continue;
4032 		case OP_LOCK:
4033 			(void) xdr_LOCK4args(xdrs,
4034 			    &array[i].nfs_argop4_u.oplock);
4035 			continue;
4036 		case OP_LOCKT:
4037 			(void) xdr_LOCKT4args(xdrs,
4038 			    &array[i].nfs_argop4_u.oplockt);
4039 			continue;
4040 		case OP_LOCKU:
4041 			continue;
4042 		case OP_NVERIFY:
4043 			(void) xdr_fattr4(xdrs,
4044 			    &array[i].nfs_argop4_u.opnverify.obj_attributes);
4045 			continue;
4046 		case OP_OPENATTR:
4047 		case OP_OPEN_CONFIRM:
4048 		case OP_OPEN_DOWNGRADE:
4049 		case OP_PUTPUBFH:
4050 		case OP_PUTROOTFH:
4051 		case OP_READLINK:
4052 			continue;
4053 		case OP_RENAME:
4054 			if (array[i].nfs_argop4_u.oprename.oldname.
4055 			    utf8string_val != NULL) {
4056 				kmem_free(array[i].nfs_argop4_u.oprename.
4057 				    oldname.utf8string_val,
4058 				    array[i].nfs_argop4_u.oprename.
4059 				    oldname.utf8string_len);
4060 			}
4061 			if (array[i].nfs_argop4_u.oprename.newname.
4062 			    utf8string_val != NULL) {
4063 				kmem_free(array[i].nfs_argop4_u.oprename.
4064 				    newname.utf8string_val,
4065 				    array[i].nfs_argop4_u.oprename.
4066 				    newname.utf8string_len);
4067 			}
4068 			continue;
4069 		case OP_RENEW:
4070 		case OP_RESTOREFH:
4071 		case OP_SAVEFH:
4072 			continue;
4073 		case OP_SECINFO:
4074 			if (array[i].nfs_argop4_u.opsecinfo.name.
4075 			    utf8string_val != NULL) {
4076 				kmem_free(array[i].nfs_argop4_u.opsecinfo.name.
4077 				    utf8string_val,
4078 				    array[i].nfs_argop4_u.opsecinfo.name.
4079 				    utf8string_len);
4080 			}
4081 			continue;
4082 		case OP_SETATTR:
4083 			(void) xdr_fattr4(xdrs,
4084 			    &array[i].nfs_argop4_u.opsetattr.obj_attributes);
4085 			continue;
4086 		case OP_SETCLIENTID:
4087 			(void) xdr_SETCLIENTID4args(xdrs,
4088 			    &array[i].nfs_argop4_u.opsetclientid);
4089 			continue;
4090 		case OP_SETCLIENTID_CONFIRM:
4091 			continue;
4092 		case OP_VERIFY:
4093 			(void) xdr_fattr4(xdrs,
4094 			    &array[i].nfs_argop4_u.opverify.obj_attributes);
4095 			continue;
4096 		case OP_RELEASE_LOCKOWNER:
4097 			if (array[i].nfs_argop4_u.oprelease_lockowner.
4098 			    lock_owner.owner_val != NULL) {
4099 				kmem_free(array[i].nfs_argop4_u.
4100 				    oprelease_lockowner.lock_owner.owner_val,
4101 				    array[i].nfs_argop4_u.
4102 				    oprelease_lockowner.lock_owner.owner_len);
4103 			}
4104 			continue;
4105 		case OP_ILLEGAL:
4106 			continue;
4107 		default:
4108 			/*
4109 			 * An invalid op is a coding error, it should never
4110 			 * have been decoded.
4111 			 * Don't error because the caller cannot finish
4112 			 * freeing the residual memory of the array.
4113 			 */
4114 			continue;
4115 		}
4116 	}
4117 
4118 	kmem_free(*arrayp, len * sizeof (nfs_argop4));
4119 	*arrayp = NULL;
4120 	return (TRUE);
4121 }
4122 
4123 static bool_t
4124 xdr_nfs_argop4(XDR *xdrs, nfs_argop4 *objp)
4125 {
4126 	rdma_chunkinfo_t rci;
4127 	struct xdr_ops *xops = xdrrdma_xops();
4128 
4129 	/*
4130 	 * These should be ordered by frequency of use
4131 	 */
4132 	switch (objp->argop) {
4133 	case OP_PUTFH:
4134 		return (xdr_bytes(xdrs,
4135 		    (char **)&objp->nfs_argop4_u.opputfh.object.nfs_fh4_val,
4136 		    (uint_t *)&objp->nfs_argop4_u.opputfh.object.nfs_fh4_len,
4137 		    NFS4_FHSIZE));
4138 	case OP_GETATTR:
4139 		/*
4140 		 * ACLs can become relatively large ( > 8K) and the default
4141 		 * 8K reply chunk of RDMA may not suffice. Check for
4142 		 * get ACL bit and if it's RDMA, add a chunk equal the size
4143 		 * of the transfer size to the reply chunk list.
4144 		 */
4145 		if ((xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) &&
4146 		    (xdrs->x_op == XDR_ENCODE) &&
4147 		    (objp->nfs_argop4_u.opgetattr.attr_request &
4148 		    FATTR4_ACL_MASK)) {
4149 			rci.rci_type = RCI_REPLY_CHUNK;
4150 			rci.rci_len = objp->nfs_argop4_u.opgetattr.mi->mi_tsize;
4151 			XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
4152 
4153 			DTRACE_PROBE1(xdr__i__argop4__getattr, int,
4154 			    rci.rci_len);
4155 		}
4156 		return (xdr_bitmap4(xdrs,
4157 		    &objp->nfs_argop4_u.opgetattr.attr_request));
4158 	case OP_GETFH:
4159 		return (TRUE);
4160 	case OP_LOOKUP:
4161 		return (xdr_bytes(xdrs, (char **)&objp->nfs_argop4_u.oplookup.
4162 		    objname.utf8string_val,
4163 		    (uint_t *)&objp->nfs_argop4_u.oplookup.
4164 		    objname.utf8string_len,
4165 		    NFS4_MAX_UTF8STRING));
4166 	case OP_OPEN:
4167 		return (xdr_OPEN4args(xdrs, &objp->nfs_argop4_u.opopen));
4168 	case OP_CLOSE:
4169 		return (xdr_CLOSE4args(xdrs, &objp->nfs_argop4_u.opclose));
4170 	case OP_ACCESS:
4171 		return (xdr_u_int(xdrs,
4172 		    &objp->nfs_argop4_u.opaccess.access));
4173 	case OP_READ:
4174 		return (xdr_READ4args(xdrs, &objp->nfs_argop4_u.opread));
4175 	case OP_WRITE:
4176 		return (xdr_WRITE4args(xdrs, &objp->nfs_argop4_u.opwrite));
4177 	case OP_DELEGRETURN:
4178 		if (!xdr_u_int(xdrs,
4179 		    &objp->nfs_argop4_u.opdelegreturn.deleg_stateid.seqid))
4180 			return (FALSE);
4181 		return (xdr_opaque(xdrs,
4182 		    objp->nfs_argop4_u.opdelegreturn.deleg_stateid.other,
4183 		    NFS4_OTHER_SIZE));
4184 	case OP_LOOKUPP:
4185 		return (TRUE);
4186 	case OP_READDIR:
4187 		return (xdr_READDIR4args(xdrs, &objp->nfs_argop4_u.opreaddir));
4188 	case OP_REMOVE:
4189 		return (xdr_bytes(xdrs, (char **)&objp->nfs_argop4_u.opremove.
4190 		    target.utf8string_val,
4191 		    (uint_t *)&objp->nfs_argop4_u.opremove.
4192 		    target.utf8string_len,
4193 		    NFS4_MAX_UTF8STRING));
4194 	case OP_COMMIT:
4195 		if (!xdr_u_longlong_t(xdrs,
4196 		    (u_longlong_t *)&objp->nfs_argop4_u.opcommit.offset))
4197 			return (FALSE);
4198 		return (xdr_u_int(xdrs, &objp->nfs_argop4_u.opcommit.count));
4199 	case OP_CREATE:
4200 		return (xdr_CREATE4args(xdrs, &objp->nfs_argop4_u.opcreate));
4201 	case OP_DELEGPURGE:
4202 		return (xdr_u_longlong_t(xdrs,
4203 		    (u_longlong_t *)&objp->nfs_argop4_u.opdelegpurge.clientid));
4204 	case OP_LINK:
4205 		return (xdr_bytes(xdrs,
4206 		    (char **)&objp->nfs_argop4_u.oplink.newname.utf8string_val,
4207 		    (uint_t *)&objp->nfs_argop4_u.oplink.newname.utf8string_len,
4208 		    NFS4_MAX_UTF8STRING));
4209 	case OP_LOCK:
4210 		return (xdr_LOCK4args(xdrs, &objp->nfs_argop4_u.oplock));
4211 	case OP_LOCKT:
4212 		return (xdr_LOCKT4args(xdrs, &objp->nfs_argop4_u.oplockt));
4213 	case OP_LOCKU:
4214 		return (xdr_LOCKU4args(xdrs, &objp->nfs_argop4_u.oplocku));
4215 	case OP_NVERIFY:
4216 		return (xdr_fattr4(xdrs,
4217 		    &objp->nfs_argop4_u.opnverify.obj_attributes));
4218 	case OP_OPENATTR:
4219 		return (xdr_bool(xdrs,
4220 		    &objp->nfs_argop4_u.opopenattr.createdir));
4221 	case OP_OPEN_CONFIRM:
4222 		if (!xdr_u_int(xdrs, &objp->nfs_argop4_u.opopen_confirm.
4223 		    open_stateid.seqid))
4224 			return (FALSE);
4225 		if (!xdr_opaque(xdrs, objp->nfs_argop4_u.opopen_confirm.
4226 		    open_stateid.other, NFS4_OTHER_SIZE))
4227 			return (FALSE);
4228 		return (xdr_u_int(xdrs, &objp->nfs_argop4_u.opopen_confirm.
4229 		    seqid));
4230 	case OP_OPEN_DOWNGRADE:
4231 		return (xdr_OPEN_DOWNGRADE4args(xdrs,
4232 		    &objp->nfs_argop4_u.opopen_downgrade));
4233 	case OP_PUTPUBFH:
4234 		return (TRUE);
4235 	case OP_PUTROOTFH:
4236 		return (TRUE);
4237 	case OP_READLINK:
4238 		if ((xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) &&
4239 		    xdrs->x_op == XDR_ENCODE) {
4240 			rci.rci_type = RCI_REPLY_CHUNK;
4241 			rci.rci_len = MAXPATHLEN;
4242 			XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
4243 		}
4244 		return (TRUE);
4245 	case OP_RENAME:
4246 		if (!xdr_bytes(xdrs, (char **)&objp->nfs_argop4_u.oprename.
4247 		    oldname.utf8string_val,
4248 		    (uint_t *)&objp->nfs_argop4_u.oprename.
4249 		    oldname.utf8string_len,
4250 		    NFS4_MAX_UTF8STRING))
4251 			return (FALSE);
4252 		return (xdr_bytes(xdrs, (char **)&objp->nfs_argop4_u.oprename.
4253 		    newname.utf8string_val,
4254 		    (uint_t *)&objp->nfs_argop4_u.oprename.
4255 		    newname.utf8string_len,
4256 		    NFS4_MAX_UTF8STRING));
4257 	case OP_RENEW:
4258 		return (xdr_u_longlong_t(xdrs,
4259 		    (u_longlong_t *)&objp->nfs_argop4_u.oprenew.clientid));
4260 	case OP_RESTOREFH:
4261 		return (TRUE);
4262 	case OP_SAVEFH:
4263 		return (TRUE);
4264 	case OP_SECINFO:
4265 		return (xdr_bytes(xdrs,
4266 		    (char **)&objp->nfs_argop4_u.opsecinfo.name.utf8string_val,
4267 		    (uint_t *)&objp->nfs_argop4_u.opsecinfo.name.utf8string_len,
4268 		    NFS4_MAX_UTF8STRING));
4269 	case OP_SETATTR:
4270 		if (!xdr_u_int(xdrs, &objp->nfs_argop4_u.opsetattr.
4271 		    stateid.seqid))
4272 			return (FALSE);
4273 		if (!xdr_opaque(xdrs, objp->nfs_argop4_u.opsetattr.
4274 		    stateid.other, NFS4_OTHER_SIZE))
4275 			return (FALSE);
4276 		return (xdr_fattr4(xdrs, &objp->nfs_argop4_u.opsetattr.
4277 		    obj_attributes));
4278 	case OP_SETCLIENTID:
4279 		return (xdr_SETCLIENTID4args(xdrs,
4280 		    &objp->nfs_argop4_u.opsetclientid));
4281 	case OP_SETCLIENTID_CONFIRM:
4282 		if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->nfs_argop4_u.
4283 		    opsetclientid_confirm.clientid))
4284 			return (FALSE);
4285 		return (xdr_u_longlong_t(xdrs,
4286 		    (u_longlong_t *)&objp->nfs_argop4_u.
4287 		    opsetclientid_confirm.setclientid_confirm));
4288 	case OP_VERIFY:
4289 		return (xdr_fattr4(xdrs,
4290 		    &objp->nfs_argop4_u.opverify.obj_attributes));
4291 	case OP_RELEASE_LOCKOWNER:
4292 		if (!xdr_u_longlong_t(xdrs,
4293 		    (u_longlong_t *)&objp->nfs_argop4_u.
4294 		    oprelease_lockowner.lock_owner.clientid))
4295 			return (FALSE);
4296 		return (xdr_bytes(xdrs,
4297 		    (char **)&objp->nfs_argop4_u.oprelease_lockowner.
4298 		    lock_owner.owner_val,
4299 		    (uint_t *)&objp->nfs_argop4_u.oprelease_lockowner.
4300 		    lock_owner.owner_len, NFS4_OPAQUE_LIMIT));
4301 	case OP_ILLEGAL:
4302 		return (TRUE);
4303 	}
4304 	return (FALSE);
4305 }
4306 
4307 static bool_t
4308 xdr_cnfs_argop4_wrap(XDR *xdrs, nfs_argop4 *objp)
4309 {
4310 	if (!xdr_int(xdrs, (int *)&objp->argop))
4311 		return (FALSE);
4312 
4313 	return (xdr_nfs_argop4(xdrs, objp));
4314 }
4315 
4316 static bool_t
4317 xdr_snfs_argop4(XDR *xdrs, nfs_argop4 *objp)
4318 {
4319 	if (!xdr_int(xdrs, (int *)&objp->argop))
4320 		return (FALSE);
4321 
4322 	switch (objp->argop) {
4323 	case OP_PUTFH:
4324 		return (xdr_decode_nfs_fh4(xdrs,
4325 		    &objp->nfs_argop4_u.opputfh.object));
4326 	default:
4327 		return (xdr_nfs_argop4(xdrs, objp));
4328 	}
4329 }
4330 
4331 /*
4332  * Client side encode only arg op processing
4333  */
4334 static bool_t
4335 xdr_cnfs_argop4(XDR *xdrs, nfs_argop4 *objp)
4336 {
4337 	int len;
4338 	int op;
4339 	nfs4_sharedfh_t *sfh;
4340 	mntinfo4_t *mi;
4341 	rpc_inline_t *ptr;
4342 
4343 	ASSERT(xdrs->x_op == XDR_ENCODE);
4344 
4345 	/*
4346 	 * Special case the private pseudo ops
4347 	 */
4348 	if (!(objp->argop & SUNW_PRIVATE_OP))
4349 		return (xdr_cnfs_argop4_wrap(xdrs, objp));
4350 
4351 	/*
4352 	 * These should be ordered by frequency of use
4353 	 */
4354 	switch (objp->argop) {
4355 	case OP_CPUTFH:
4356 		/*
4357 		 * We are passed in the file handle as a nfs4_sharedfh_t *
4358 		 * We need to acquire the correct locks so we can copy it out.
4359 		 */
4360 		sfh = (nfs4_sharedfh_t *)objp->nfs_argop4_u.opcputfh.sfh;
4361 		mi = sfh->sfh_mi;
4362 		(void) nfs_rw_enter_sig(&mi->mi_fh_lock, RW_READER, 0);
4363 
4364 		len = sfh->sfh_fh.nfs_fh4_len;
4365 		ASSERT(len <= NFS4_FHSIZE);
4366 
4367 		/*
4368 		 * First try and inline the copy
4369 		 * Must first be a multiple of BYTES_PER_XDR_UNIT
4370 		 */
4371 		if (!(len % BYTES_PER_XDR_UNIT) &&
4372 		    (ptr = XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT + len)) !=
4373 		    NULL) {
4374 			IXDR_PUT_U_INT32(ptr, OP_PUTFH);
4375 			IXDR_PUT_U_INT32(ptr, len);
4376 			bcopy(sfh->sfh_fh.nfs_fh4_val, ptr, len);
4377 			nfs_rw_exit(&mi->mi_fh_lock);
4378 			return (TRUE);
4379 		}
4380 
4381 		op = OP_PUTFH;
4382 		if (!XDR_PUTINT32(xdrs, &op)) {
4383 			nfs_rw_exit(&mi->mi_fh_lock);
4384 			return (FALSE);
4385 		}
4386 		if (!XDR_PUTINT32(xdrs, &len)) {
4387 			nfs_rw_exit(&mi->mi_fh_lock);
4388 			return (FALSE);
4389 		}
4390 		if (!(len % BYTES_PER_XDR_UNIT)) {
4391 			if (XDR_PUTBYTES(xdrs, sfh->sfh_fh.nfs_fh4_val, len)) {
4392 				nfs_rw_exit(&mi->mi_fh_lock);
4393 				return (TRUE);
4394 			}
4395 		} else if (xdr_opaque(xdrs, sfh->sfh_fh.nfs_fh4_val, len)) {
4396 			nfs_rw_exit(&mi->mi_fh_lock);
4397 			return (TRUE);
4398 		}
4399 		nfs_rw_exit(&mi->mi_fh_lock);
4400 		return (FALSE);
4401 	case OP_CLOOKUP:
4402 		len = strlen(objp->nfs_argop4_u.opclookup.cname);
4403 		if (len > NFS4_MAX_UTF8STRING)
4404 			return (FALSE);
4405 		op = OP_LOOKUP;
4406 		if (XDR_PUTINT32(xdrs, &op)) {
4407 			if (XDR_PUTINT32(xdrs, &len)) {
4408 				return (xdr_opaque(xdrs,
4409 				    objp->nfs_argop4_u.opclookup.cname,
4410 				    len));
4411 			}
4412 		}
4413 		return (FALSE);
4414 	case OP_COPEN:
4415 		/* op processing inlined in xdr_OPEN4cargs */
4416 		return (xdr_OPEN4cargs(xdrs, &objp->nfs_argop4_u.opcopen));
4417 	case OP_CREMOVE:
4418 		len = strlen(objp->nfs_argop4_u.opcremove.ctarget);
4419 		if (len > NFS4_MAX_UTF8STRING)
4420 			return (FALSE);
4421 		op = OP_REMOVE;
4422 		if (XDR_PUTINT32(xdrs, &op)) {
4423 			if (XDR_PUTINT32(xdrs, &len)) {
4424 				return (xdr_opaque(xdrs,
4425 				    objp->nfs_argop4_u.opcremove.ctarget,
4426 				    len));
4427 			}
4428 		}
4429 		return (FALSE);
4430 	case OP_CCREATE:
4431 		op = OP_CREATE;
4432 		if (!XDR_PUTINT32(xdrs, &op))
4433 			return (FALSE);
4434 		return (xdr_CREATE4cargs(xdrs, &objp->nfs_argop4_u.opccreate));
4435 	case OP_CLINK:
4436 		len = strlen(objp->nfs_argop4_u.opclink.cnewname);
4437 		if (len > NFS4_MAX_UTF8STRING)
4438 			return (FALSE);
4439 		op = OP_LINK;
4440 		if (XDR_PUTINT32(xdrs, &op)) {
4441 			if (XDR_PUTINT32(xdrs, &len)) {
4442 				return (xdr_opaque(xdrs,
4443 				    objp->nfs_argop4_u.opclink.cnewname,
4444 				    len));
4445 			}
4446 		}
4447 		return (FALSE);
4448 	case OP_CRENAME:
4449 		len = strlen(objp->nfs_argop4_u.opcrename.coldname);
4450 		if (len > NFS4_MAX_UTF8STRING)
4451 			return (FALSE);
4452 		op = OP_RENAME;
4453 		if (!XDR_PUTINT32(xdrs, &op))
4454 			return (FALSE);
4455 		if (!XDR_PUTINT32(xdrs, &len))
4456 			return (FALSE);
4457 		if (!xdr_opaque(xdrs,
4458 		    objp->nfs_argop4_u.opcrename.coldname, len))
4459 			return (FALSE);
4460 		len = strlen(objp->nfs_argop4_u.opcrename.cnewname);
4461 		if (len > NFS4_MAX_UTF8STRING)
4462 			return (FALSE);
4463 		if (XDR_PUTINT32(xdrs, &len)) {
4464 			return (xdr_opaque(xdrs,
4465 			    objp->nfs_argop4_u.opcrename.cnewname, len));
4466 		}
4467 		return (FALSE);
4468 	case OP_CSECINFO:
4469 		len = strlen(objp->nfs_argop4_u.opcsecinfo.cname);
4470 		if (len > NFS4_MAX_UTF8STRING)
4471 			return (FALSE);
4472 		op = OP_SECINFO;
4473 		if (XDR_PUTINT32(xdrs, &op)) {
4474 			if (XDR_PUTINT32(xdrs, &len)) {
4475 				return (xdr_opaque(xdrs,
4476 				    objp->nfs_argop4_u.opcsecinfo.cname,
4477 				    len));
4478 			}
4479 		}
4480 		return (FALSE);
4481 	}
4482 	return (FALSE);
4483 }
4484 
4485 /*
4486  * Note that the len and decode_len will only be different in the case
4487  * of the client's use of this free function.  If the server is
4488  * freeing results, then the len/decode_len will always match.
4489  */
4490 static bool_t
4491 xdr_nfs_resop4_free(XDR *xdrs, nfs_resop4 **arrayp, int len, int decode_len)
4492 {
4493 	int i;
4494 	nfs_resop4 *array = *arrayp;
4495 	nfs4_ga_res_t *gr;
4496 
4497 	/*
4498 	 * Optimized XDR_FREE only results array
4499 	 */
4500 	ASSERT(xdrs->x_op == XDR_FREE);
4501 
4502 	if (array == NULL)
4503 		return (TRUE);
4504 
4505 	for (i = 0; i < decode_len; i++) {
4506 		/*
4507 		 * These should be ordered by frequency of use
4508 		 */
4509 		switch (array[i].resop) {
4510 		case OP_PUTFH:
4511 			continue;
4512 		case OP_GETATTR:
4513 			if (array[i].nfs_resop4_u.opgetattr.status != NFS4_OK)
4514 				continue;
4515 
4516 			gr = &array[i].nfs_resop4_u.opgetattr.ga_res;
4517 			if (gr->n4g_ext_res) {
4518 				if (gr->n4g_resbmap & FATTR4_FS_LOCATIONS_MASK)
4519 					(void) xdr_fattr4_fs_locations(xdrs,
4520 					    &gr->n4g_ext_res->n4g_fslocations);
4521 				kmem_free(gr->n4g_ext_res,
4522 				    sizeof (struct nfs4_ga_ext_res));
4523 			}
4524 			continue;
4525 		case OP_GETFH:
4526 			if (array[i].nfs_resop4_u.opgetfh.status != NFS4_OK)
4527 				continue;
4528 			if (array[i].nfs_resop4_u.opgetfh.object.nfs_fh4_val !=
4529 			    NULL) {
4530 				kmem_free(array[i].nfs_resop4_u.opgetfh.object.
4531 				    nfs_fh4_val,
4532 				    array[i].nfs_resop4_u.opgetfh.object.
4533 				    nfs_fh4_len);
4534 			}
4535 			continue;
4536 		case OP_LOOKUP:
4537 			continue;
4538 		case OP_OPEN:
4539 			(void) xdr_OPEN4res(xdrs, &array[i].nfs_resop4_u.
4540 			    opopen);
4541 			continue;
4542 		case OP_CLOSE:
4543 		case OP_ACCESS:
4544 			continue;
4545 		case OP_READ:
4546 			(void) xdr_READ4res(xdrs,
4547 			    &array[i].nfs_resop4_u.opread);
4548 			continue;
4549 		case OP_WRITE:
4550 		case OP_DELEGRETURN:
4551 		case OP_LOOKUPP:
4552 		case OP_READDIR:
4553 		case OP_REMOVE:
4554 		case OP_COMMIT:
4555 		case OP_CREATE:
4556 		case OP_DELEGPURGE:
4557 		case OP_LINK:
4558 			continue;
4559 		case OP_LOCK:
4560 			(void) xdr_LOCK4res(xdrs, &array[i].nfs_resop4_u.
4561 			    oplock);
4562 			continue;
4563 		case OP_LOCKT:
4564 			(void) xdr_LOCKT4res(xdrs, &array[i].nfs_resop4_u.
4565 			    oplockt);
4566 			continue;
4567 		case OP_LOCKU:
4568 		case OP_NVERIFY:
4569 		case OP_OPENATTR:
4570 		case OP_OPEN_CONFIRM:
4571 		case OP_OPEN_DOWNGRADE:
4572 		case OP_PUTPUBFH:
4573 		case OP_PUTROOTFH:
4574 		case OP_RENAME:
4575 		case OP_RENEW:
4576 		case OP_RESTOREFH:
4577 		case OP_SAVEFH:
4578 			continue;
4579 		case OP_READLINK:
4580 			(void) xdr_READLINK4res(xdrs, &array[i].nfs_resop4_u.
4581 			    opreadlink);
4582 			continue;
4583 		case OP_SECINFO:
4584 			(void) xdr_array(xdrs,
4585 			    (char **)&array[i].nfs_resop4_u.opsecinfo.
4586 			    SECINFO4resok_val,
4587 			    (uint_t *)&array[i].nfs_resop4_u.opsecinfo.
4588 			    SECINFO4resok_len,
4589 			    NFS4_SECINFO_LIMIT, sizeof (secinfo4),
4590 			    (xdrproc_t)xdr_secinfo4);
4591 			continue;
4592 		case OP_SETCLIENTID:
4593 			(void) xdr_SETCLIENTID4res(xdrs,
4594 			    &array[i].nfs_resop4_u.opsetclientid);
4595 			continue;
4596 		case OP_SETATTR:
4597 		case OP_SETCLIENTID_CONFIRM:
4598 		case OP_VERIFY:
4599 		case OP_RELEASE_LOCKOWNER:
4600 		case OP_ILLEGAL:
4601 			continue;
4602 		default:
4603 			/*
4604 			 * An invalid op is a coding error, it should never
4605 			 * have been decoded.
4606 			 * Don't error because the caller cannot finish
4607 			 * freeing the residual memory of the array.
4608 			 */
4609 			continue;
4610 		}
4611 	}
4612 
4613 	kmem_free(*arrayp, len * sizeof (nfs_resop4));
4614 	*arrayp = NULL;
4615 	return (TRUE);
4616 }
4617 
4618 static bool_t
4619 xdr_snfs_resop4_free(XDR *xdrs, nfs_resop4 **arrayp, int len, int decode_len)
4620 {
4621 	return (xdr_nfs_resop4_free(xdrs, arrayp, len, decode_len));
4622 }
4623 
4624 static bool_t
4625 xdr_nfs_resop4(XDR *xdrs, nfs_resop4 *objp)
4626 {
4627 	/*
4628 	 * These should be ordered by frequency of use
4629 	 */
4630 	switch (objp->resop) {
4631 	case OP_PUTFH:
4632 		return (xdr_int(xdrs,
4633 		    (int32_t *)&objp->nfs_resop4_u.opputfh.status));
4634 	case OP_GETATTR:
4635 		if (!xdr_int(xdrs,
4636 		    (int32_t *)&objp->nfs_resop4_u.opgetattr.status))
4637 			return (FALSE);
4638 		if (objp->nfs_resop4_u.opgetattr.status != NFS4_OK)
4639 			return (TRUE);
4640 		return (xdr_fattr4(xdrs,
4641 		    &objp->nfs_resop4_u.opgetattr.obj_attributes));
4642 	case OP_GETFH:
4643 		if (!xdr_int(xdrs,
4644 		    (int32_t *)&objp->nfs_resop4_u.opgetfh.status))
4645 			return (FALSE);
4646 		if (objp->nfs_resop4_u.opgetfh.status != NFS4_OK)
4647 			return (TRUE);
4648 		return (xdr_bytes(xdrs,
4649 		    (char **)&objp->nfs_resop4_u.opgetfh.object.nfs_fh4_val,
4650 		    (uint_t *)&objp->nfs_resop4_u.opgetfh.object.nfs_fh4_len,
4651 		    NFS4_FHSIZE));
4652 	case OP_LOOKUP:
4653 		return (xdr_int(xdrs,
4654 		    (int32_t *)&objp->nfs_resop4_u.oplookup.status));
4655 	case OP_OPEN:
4656 		return (xdr_OPEN4res(xdrs, &objp->nfs_resop4_u.opopen));
4657 	case OP_CLOSE:
4658 		return (xdr_CLOSE4res(xdrs, &objp->nfs_resop4_u.opclose));
4659 	case OP_ACCESS:
4660 		return (xdr_ACCESS4res(xdrs, &objp->nfs_resop4_u.opaccess));
4661 	case OP_READ:
4662 		return (xdr_READ4res(xdrs, &objp->nfs_resop4_u.opread));
4663 	case OP_WRITE:
4664 		return (xdr_WRITE4res(xdrs, &objp->nfs_resop4_u.opwrite));
4665 	case OP_DELEGRETURN:
4666 		return (xdr_int(xdrs,
4667 		    (int32_t *)&objp->nfs_resop4_u.opdelegreturn.status));
4668 	case OP_LOOKUPP:
4669 		return (xdr_int(xdrs,
4670 		    (int32_t *)&objp->nfs_resop4_u.oplookupp.status));
4671 	case OP_READDIR:
4672 		return (xdr_READDIR4res(xdrs, &objp->nfs_resop4_u.opreaddir));
4673 	case OP_REMOVE:
4674 		return (xdr_REMOVE4res(xdrs, &objp->nfs_resop4_u.opremove));
4675 
4676 	case OP_COMMIT:
4677 		if (!xdr_int(xdrs,
4678 		    (int32_t *)&objp->nfs_resop4_u.opcommit.status))
4679 			return (FALSE);
4680 		if (objp->nfs_resop4_u.opcommit.status != NFS4_OK)
4681 			return (TRUE);
4682 		return (xdr_u_longlong_t(xdrs,
4683 		    (u_longlong_t *)&objp->nfs_resop4_u.opcommit.
4684 		    writeverf));
4685 	case OP_CREATE:
4686 		return (xdr_CREATE4res(xdrs, &objp->nfs_resop4_u.opcreate));
4687 	case OP_DELEGPURGE:
4688 		return (xdr_int(xdrs,
4689 		    (int32_t *)&objp->nfs_resop4_u.opdelegpurge.status));
4690 	case OP_LINK:
4691 		return (xdr_LINK4res(xdrs, &objp->nfs_resop4_u.oplink));
4692 	case OP_LOCK:
4693 		return (xdr_LOCK4res(xdrs, &objp->nfs_resop4_u.oplock));
4694 	case OP_LOCKT:
4695 		return (xdr_LOCKT4res(xdrs, &objp->nfs_resop4_u.oplockt));
4696 	case OP_LOCKU:
4697 		if (!xdr_int(xdrs,
4698 		    (int32_t *)&objp->nfs_resop4_u.oplocku.status))
4699 			return (FALSE);
4700 		if (objp->nfs_resop4_u.oplocku.status != NFS4_OK)
4701 			return (TRUE);
4702 		if (!xdr_u_int(xdrs,
4703 		    &objp->nfs_resop4_u.oplocku.lock_stateid.seqid))
4704 			return (FALSE);
4705 		return (xdr_opaque(xdrs,
4706 		    objp->nfs_resop4_u.oplocku.lock_stateid.other,
4707 		    NFS4_OTHER_SIZE));
4708 	case OP_NVERIFY:
4709 		return (xdr_int(xdrs,
4710 		    (int32_t *)&objp->nfs_resop4_u.opnverify.status));
4711 	case OP_OPENATTR:
4712 		return (xdr_int(xdrs,
4713 		    (int32_t *)&objp->nfs_resop4_u.opopenattr.status));
4714 	case OP_OPEN_CONFIRM:
4715 		return (xdr_OPEN_CONFIRM4res(xdrs,
4716 		    &objp->nfs_resop4_u.opopen_confirm));
4717 	case OP_OPEN_DOWNGRADE:
4718 		return (xdr_OPEN_DOWNGRADE4res(xdrs,
4719 		    &objp->nfs_resop4_u.opopen_downgrade));
4720 	case OP_PUTPUBFH:
4721 		return (xdr_int(xdrs,
4722 		    (int32_t *)&objp->nfs_resop4_u.opputpubfh.status));
4723 	case OP_PUTROOTFH:
4724 		return (xdr_int(xdrs,
4725 		    (int32_t *)&objp->nfs_resop4_u.opputrootfh.status));
4726 	case OP_READLINK:
4727 		return (xdr_READLINK4res(xdrs, &objp->nfs_resop4_u.opreadlink));
4728 	case OP_RENAME:
4729 		return (xdr_RENAME4res(xdrs, &objp->nfs_resop4_u.oprename));
4730 	case OP_RENEW:
4731 		return (xdr_int(xdrs,
4732 		    (int32_t *)&objp->nfs_resop4_u.oprenew.status));
4733 	case OP_RESTOREFH:
4734 		return (xdr_int(xdrs,
4735 		    (int32_t *)&objp->nfs_resop4_u.oprestorefh.status));
4736 	case OP_SAVEFH:
4737 		return (xdr_int(xdrs,
4738 		    (int32_t *)&objp->nfs_resop4_u.opsavefh.status));
4739 	case OP_SECINFO:
4740 		if (!xdr_int(xdrs, (int32_t *)&objp->nfs_resop4_u.opsecinfo.
4741 		    status))
4742 			return (FALSE);
4743 		if (objp->nfs_resop4_u.opsecinfo.status != NFS4_OK)
4744 			return (TRUE);
4745 		return (xdr_array(xdrs, (char **)&objp->nfs_resop4_u.opsecinfo.
4746 		    SECINFO4resok_val,
4747 		    (uint_t *)&objp->nfs_resop4_u.opsecinfo.
4748 		    SECINFO4resok_len,
4749 		    NFS4_SECINFO_LIMIT, sizeof (secinfo4),
4750 		    (xdrproc_t)xdr_secinfo4));
4751 	case OP_SETATTR:
4752 		if (!xdr_int(xdrs, (int32_t *)&objp->nfs_resop4_u.opsetattr.
4753 		    status))
4754 			return (FALSE);
4755 		return (xdr_bitmap4(xdrs,
4756 		    &objp->nfs_resop4_u.opsetattr.attrsset));
4757 	case OP_SETCLIENTID:
4758 		return (xdr_SETCLIENTID4res(xdrs,
4759 		    &objp->nfs_resop4_u.opsetclientid));
4760 	case OP_SETCLIENTID_CONFIRM:
4761 		return (xdr_int(xdrs,
4762 		    (int32_t *)&objp->nfs_resop4_u.opsetclientid_confirm.
4763 		    status));
4764 	case OP_VERIFY:
4765 		return (xdr_int(xdrs,
4766 		    (int32_t *)&objp->nfs_resop4_u.opverify.status));
4767 	case OP_RELEASE_LOCKOWNER:
4768 		return (xdr_int(xdrs,
4769 		    (int32_t *)&objp->nfs_resop4_u.oprelease_lockowner.status));
4770 	case OP_ILLEGAL:
4771 		return (xdr_int(xdrs,
4772 		    (int32_t *)&objp->nfs_resop4_u.opillegal.status));
4773 	}
4774 	return (FALSE);
4775 }
4776 
4777 static bool_t
4778 xdr_snfs_resop4(XDR *xdrs, nfs_resop4 *objp)
4779 {
4780 	if (!xdr_int(xdrs, (int *)&objp->resop))
4781 		return (FALSE);
4782 
4783 	switch (objp->resop) {
4784 	case OP_GETFH:
4785 		if (!XDR_PUTINT32(xdrs,
4786 		    (int32_t *)&objp->nfs_resop4_u.opgetfh.status))
4787 			return (FALSE);
4788 		if (objp->nfs_resop4_u.opgetfh.status != NFS4_OK)
4789 			return (TRUE);
4790 		return (xdr_encode_nfs_fh4(xdrs,
4791 		    &objp->nfs_resop4_u.opgetfh.object));
4792 	default:
4793 		return (xdr_nfs_resop4(xdrs, objp));
4794 	}
4795 }
4796 
4797 static bool_t
4798 xdr_nfs_resop4_clnt(XDR *xdrs, nfs_resop4 *objp, nfs_argop4 *aobjp)
4799 {
4800 	if (!xdr_int(xdrs, (int *)&objp->resop))
4801 		return (FALSE);
4802 	/*
4803 	 * These should be ordered by frequency of use
4804 	 */
4805 	switch (objp->resop) {
4806 	case OP_PUTFH:
4807 		return (xdr_int(xdrs,
4808 		    (int32_t *)&objp->nfs_resop4_u.opputfh.status));
4809 	case OP_GETATTR:
4810 		if (!xdr_int(xdrs,
4811 		    (int32_t *)&objp->nfs_resop4_u.opgetattr.status))
4812 			return (FALSE);
4813 		if (objp->nfs_resop4_u.opgetattr.status != NFS4_OK)
4814 			return (TRUE);
4815 		return (xdr_ga_res(xdrs,
4816 		    (GETATTR4res *)&objp->nfs_resop4_u.opgetattr,
4817 		    &aobjp->nfs_argop4_u.opgetattr));
4818 	case OP_GETFH:
4819 		if (!xdr_int(xdrs,
4820 		    (int32_t *)&objp->nfs_resop4_u.opgetfh.status))
4821 			return (FALSE);
4822 		if (objp->nfs_resop4_u.opgetfh.status != NFS4_OK)
4823 			return (TRUE);
4824 		return (xdr_bytes(xdrs,
4825 		    (char **)&objp->nfs_resop4_u.opgetfh.object.nfs_fh4_val,
4826 		    (uint_t *)&objp->nfs_resop4_u.opgetfh.object.nfs_fh4_len,
4827 		    NFS4_FHSIZE));
4828 	case OP_LOOKUP:
4829 		return (xdr_int(xdrs,
4830 		    (int32_t *)&objp->nfs_resop4_u.oplookup.status));
4831 	case OP_NVERIFY:
4832 		return (xdr_int(xdrs,
4833 		    (int32_t *)&objp->nfs_resop4_u.opnverify.status));
4834 	case OP_OPEN:
4835 		return (xdr_OPEN4res(xdrs, &objp->nfs_resop4_u.opopen));
4836 	case OP_CLOSE:
4837 		return (xdr_CLOSE4res(xdrs, &objp->nfs_resop4_u.opclose));
4838 	case OP_ACCESS:
4839 		return (xdr_ACCESS4res(xdrs, &objp->nfs_resop4_u.opaccess));
4840 	case OP_READ:
4841 		return (xdr_READ4res_clnt(xdrs, &objp->nfs_resop4_u.opread,
4842 		    &aobjp->nfs_argop4_u.opread));
4843 	case OP_WRITE:
4844 		return (xdr_WRITE4res(xdrs, &objp->nfs_resop4_u.opwrite));
4845 	case OP_DELEGRETURN:
4846 		return (xdr_int(xdrs,
4847 		    (int32_t *)&objp->nfs_resop4_u.opdelegreturn.status));
4848 	case OP_LOOKUPP:
4849 		return (xdr_int(xdrs,
4850 		    (int32_t *)&objp->nfs_resop4_u.oplookupp.status));
4851 	case OP_READDIR:
4852 		return (xdr_READDIR4res_clnt(xdrs,
4853 		    &objp->nfs_resop4_u.opreaddirclnt,
4854 		    &aobjp->nfs_argop4_u.opreaddir));
4855 	case OP_REMOVE:
4856 		return (xdr_REMOVE4res(xdrs, &objp->nfs_resop4_u.opremove));
4857 
4858 	case OP_COMMIT:
4859 		if (!xdr_int(xdrs,
4860 		    (int32_t *)&objp->nfs_resop4_u.opcommit.status))
4861 			return (FALSE);
4862 		if (objp->nfs_resop4_u.opcommit.status != NFS4_OK)
4863 			return (TRUE);
4864 		return (xdr_u_longlong_t(xdrs,
4865 		    (u_longlong_t *)&objp->nfs_resop4_u.opcommit.
4866 		    writeverf));
4867 	case OP_CREATE:
4868 		return (xdr_CREATE4res(xdrs, &objp->nfs_resop4_u.opcreate));
4869 	case OP_DELEGPURGE:
4870 		return (xdr_int(xdrs,
4871 		    (int32_t *)&objp->nfs_resop4_u.opdelegpurge.status));
4872 	case OP_LINK:
4873 		return (xdr_LINK4res(xdrs, &objp->nfs_resop4_u.oplink));
4874 	case OP_LOCK:
4875 		return (xdr_LOCK4res(xdrs, &objp->nfs_resop4_u.oplock));
4876 	case OP_LOCKT:
4877 		return (xdr_LOCKT4res(xdrs, &objp->nfs_resop4_u.oplockt));
4878 	case OP_LOCKU:
4879 		if (!xdr_int(xdrs,
4880 		    (int32_t *)&objp->nfs_resop4_u.oplocku.status))
4881 			return (FALSE);
4882 		if (objp->nfs_resop4_u.oplocku.status != NFS4_OK)
4883 			return (TRUE);
4884 		if (!xdr_u_int(xdrs,
4885 		    &objp->nfs_resop4_u.oplocku.lock_stateid.seqid))
4886 			return (FALSE);
4887 		return (xdr_opaque(xdrs,
4888 		    objp->nfs_resop4_u.oplocku.lock_stateid.other,
4889 		    NFS4_OTHER_SIZE));
4890 	case OP_OPENATTR:
4891 		return (xdr_int(xdrs,
4892 		    (int32_t *)&objp->nfs_resop4_u.opopenattr.status));
4893 	case OP_OPEN_CONFIRM:
4894 		return (xdr_OPEN_CONFIRM4res(xdrs,
4895 		    &objp->nfs_resop4_u.opopen_confirm));
4896 	case OP_OPEN_DOWNGRADE:
4897 		return (xdr_OPEN_DOWNGRADE4res(xdrs,
4898 		    &objp->nfs_resop4_u.opopen_downgrade));
4899 	case OP_PUTPUBFH:
4900 		return (xdr_int(xdrs,
4901 		    (int32_t *)&objp->nfs_resop4_u.opputpubfh.status));
4902 	case OP_PUTROOTFH:
4903 		return (xdr_int(xdrs,
4904 		    (int32_t *)&objp->nfs_resop4_u.opputrootfh.status));
4905 	case OP_READLINK:
4906 		return (xdr_READLINK4res(xdrs, &objp->nfs_resop4_u.opreadlink));
4907 	case OP_RENAME:
4908 		return (xdr_RENAME4res(xdrs, &objp->nfs_resop4_u.oprename));
4909 	case OP_RENEW:
4910 		return (xdr_int(xdrs,
4911 		    (int32_t *)&objp->nfs_resop4_u.oprenew.status));
4912 	case OP_RESTOREFH:
4913 		return (xdr_int(xdrs,
4914 		    (int32_t *)&objp->nfs_resop4_u.oprestorefh.status));
4915 	case OP_SAVEFH:
4916 		return (xdr_int(xdrs,
4917 		    (int32_t *)&objp->nfs_resop4_u.opsavefh.status));
4918 	case OP_SECINFO:
4919 		if (!xdr_int(xdrs, (int32_t *)&objp->nfs_resop4_u.opsecinfo.
4920 		    status))
4921 			return (FALSE);
4922 		if (objp->nfs_resop4_u.opsecinfo.status != NFS4_OK)
4923 			return (TRUE);
4924 		return (xdr_array(xdrs, (char **)&objp->nfs_resop4_u.opsecinfo.
4925 		    SECINFO4resok_val,
4926 		    (uint_t *)&objp->nfs_resop4_u.opsecinfo.
4927 		    SECINFO4resok_len,
4928 		    ~0, sizeof (secinfo4), (xdrproc_t)xdr_secinfo4));
4929 	case OP_SETATTR:
4930 		if (!xdr_int(xdrs, (int32_t *)&objp->nfs_resop4_u.opsetattr.
4931 		    status))
4932 			return (FALSE);
4933 		return (xdr_bitmap4(xdrs,
4934 		    &objp->nfs_resop4_u.opsetattr.attrsset));
4935 	case OP_SETCLIENTID:
4936 		return (xdr_SETCLIENTID4res(xdrs,
4937 		    &objp->nfs_resop4_u.opsetclientid));
4938 	case OP_SETCLIENTID_CONFIRM:
4939 		return (xdr_int(xdrs,
4940 		    (int32_t *)&objp->nfs_resop4_u.opsetclientid_confirm.
4941 		    status));
4942 	case OP_VERIFY:
4943 		return (xdr_int(xdrs,
4944 		    (int32_t *)&objp->nfs_resop4_u.opverify.status));
4945 	case OP_RELEASE_LOCKOWNER:
4946 		return (xdr_int(xdrs,
4947 		    (int32_t *)&objp->nfs_resop4_u.oprelease_lockowner.status));
4948 	case OP_ILLEGAL:
4949 		return (xdr_int(xdrs,
4950 		    (int32_t *)&objp->nfs_resop4_u.opillegal.status));
4951 	}
4952 	return (FALSE);
4953 }
4954 
4955 bool_t
4956 xdr_COMPOUND4args_clnt(XDR *xdrs, COMPOUND4args_clnt *objp)
4957 {
4958 	static int32_t twelve = 12;
4959 	static int32_t minorversion = NFS4_MINORVERSION;
4960 	uint32_t *ctagp;
4961 	rpc_inline_t *ptr;
4962 	rdma_chunkinfo_t rci;
4963 	struct xdr_ops *xops = xdrrdma_xops();
4964 
4965 	/*
4966 	 * XDR_ENCODE only
4967 	 */
4968 	if (xdrs->x_op == XDR_FREE)
4969 		return (TRUE);
4970 	if (xdrs->x_op == XDR_DECODE)
4971 		return (FALSE);
4972 
4973 	ctagp = (uint32_t *)&nfs4_ctags[objp->ctag].ct_tag;
4974 
4975 	if ((ptr = XDR_INLINE(xdrs, 5 * BYTES_PER_XDR_UNIT)) != NULL) {
4976 		/*
4977 		 * Efficiently encode fixed length tags, could be longlongs
4978 		 * but 8 byte XDR alignment not assured
4979 		 */
4980 		IXDR_PUT_U_INT32(ptr, 12);
4981 		IXDR_PUT_U_INT32(ptr, ctagp[0]);
4982 		IXDR_PUT_U_INT32(ptr, ctagp[1]);
4983 		IXDR_PUT_U_INT32(ptr, ctagp[2]);
4984 
4985 		/*
4986 		 * Fixed minor version for now
4987 		 */
4988 		IXDR_PUT_U_INT32(ptr, NFS4_MINORVERSION);
4989 	} else {
4990 		if (!XDR_PUTINT32(xdrs, &twelve))
4991 			return (FALSE);
4992 		if (!XDR_PUTINT32(xdrs, (int32_t *)&ctagp[0]))
4993 			return (FALSE);
4994 		if (!XDR_PUTINT32(xdrs, (int32_t *)&ctagp[1]))
4995 			return (FALSE);
4996 		if (!XDR_PUTINT32(xdrs, (int32_t *)&ctagp[2]))
4997 			return (FALSE);
4998 		if (!XDR_PUTINT32(xdrs, (int32_t *)&minorversion))
4999 			return (FALSE);
5000 	}
5001 	if (xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) {
5002 		rci.rci_type = RCI_REPLY_CHUNK;
5003 		rci.rci_len = MAXPATHLEN * 2;
5004 		XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
5005 	}
5006 
5007 	return (xdr_array(xdrs, (char **)&objp->array,
5008 	    (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5009 	    sizeof (nfs_argop4), (xdrproc_t)xdr_cnfs_argop4));
5010 }
5011 
5012 bool_t
5013 xdr_COMPOUND4args_srv(XDR *xdrs, COMPOUND4args *objp)
5014 {
5015 	if (!xdr_bytes(xdrs, (char **)&objp->tag.utf8string_val,
5016 	    (uint_t *)&objp->tag.utf8string_len,
5017 	    NFS4_MAX_UTF8STRING))
5018 		return (FALSE);
5019 	if (!xdr_u_int(xdrs, &objp->minorversion))
5020 		return (FALSE);
5021 	if (xdrs->x_op != XDR_FREE)
5022 		return (xdr_array(xdrs, (char **)&objp->array,
5023 		    (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5024 		    sizeof (nfs_argop4), (xdrproc_t)xdr_snfs_argop4));
5025 
5026 	return (xdr_snfs_argop4_free(xdrs, &objp->array, objp->array_len));
5027 }
5028 
5029 bool_t
5030 xdr_COMPOUND4res_clnt(XDR *xdrs, COMPOUND4res_clnt *objp)
5031 {
5032 	uint32_t len;
5033 	int32_t *ptr;
5034 	nfs_argop4 *argop;
5035 	nfs_resop4 *resop;
5036 
5037 	/*
5038 	 * No XDR_ENCODE
5039 	 */
5040 	if (xdrs->x_op == XDR_ENCODE)
5041 		return (FALSE);
5042 
5043 	if (xdrs->x_op != XDR_FREE) {
5044 		if ((ptr = XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT)) != NULL) {
5045 			objp->status = IXDR_GET_U_INT32(ptr);
5046 			len = IXDR_GET_U_INT32(ptr);
5047 		} else {
5048 			if (!xdr_int(xdrs, (int32_t *)&objp->status))
5049 				return (FALSE);
5050 			if (!xdr_u_int(xdrs, (uint32_t *)&len))
5051 				return (FALSE);
5052 		}
5053 		if (len > NFS4_MAX_UTF8STRING)
5054 			return (FALSE);
5055 		/*
5056 		 * Ignore the tag
5057 		 */
5058 		if (!XDR_CONTROL(xdrs, XDR_SKIPBYTES, &len))
5059 			return (FALSE);
5060 
5061 		if (!xdr_int(xdrs, (int32_t *)&objp->array_len))
5062 			return (FALSE);
5063 
5064 		if (objp->array_len > objp->argsp->array_len)
5065 			return (FALSE);
5066 
5067 		if (objp->status == NFS4_OK &&
5068 		    objp->array_len != objp->argsp->array_len)
5069 			return (FALSE);
5070 
5071 		/* Alloc the results array */
5072 		argop = objp->argsp->array;
5073 		len = objp->array_len * sizeof (nfs_resop4);
5074 		objp->decode_len = 0;
5075 		objp->array = resop = kmem_zalloc(len, KM_SLEEP);
5076 
5077 		for (len = 0; len < objp->array_len;
5078 		    len++, resop++, argop++, objp->decode_len++) {
5079 			if (!xdr_nfs_resop4_clnt(xdrs, resop, argop)) {
5080 				/*
5081 				 * Make sure to free anything that may
5082 				 * have been allocated along the way.
5083 				 */
5084 				xdrs->x_op = XDR_FREE;
5085 				(void) xdr_nfs_resop4_free(xdrs, &objp->array,
5086 				    objp->array_len,
5087 				    objp->decode_len);
5088 				return (FALSE);
5089 			}
5090 		}
5091 		return (TRUE);
5092 	}
5093 	return (xdr_nfs_resop4_free(xdrs, &objp->array,
5094 	    objp->array_len, objp->decode_len));
5095 }
5096 
5097 bool_t
5098 xdr_COMPOUND4res_srv(XDR *xdrs, COMPOUND4res *objp)
5099 {
5100 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
5101 		return (FALSE);
5102 	if (!xdr_bytes(xdrs, (char **)&objp->tag.utf8string_val,
5103 	    (uint_t *)&objp->tag.utf8string_len,
5104 	    NFS4_MAX_UTF8STRING))
5105 		return (FALSE);
5106 
5107 	if (xdrs->x_op != XDR_FREE)
5108 		return (xdr_array(xdrs, (char **)&objp->array,
5109 		    (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5110 		    sizeof (nfs_resop4), (xdrproc_t)xdr_snfs_resop4));
5111 
5112 	return (xdr_snfs_resop4_free(xdrs, &objp->array,
5113 	    objp->array_len, objp->array_len));
5114 }
5115 
5116 /*
5117  * NFS server side callback, initiating the callback request so it
5118  * is the RPC client. Must convert from server's internal filehandle
5119  * format to wire format.
5120  */
5121 static bool_t
5122 xdr_snfs_cb_argop4(XDR *xdrs, nfs_cb_argop4 *objp)
5123 {
5124 	CB_GETATTR4args *gargs;
5125 	CB_RECALL4args *rargs;
5126 
5127 	ASSERT(xdrs->x_op == XDR_ENCODE);
5128 
5129 	if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->argop))
5130 		return (FALSE);
5131 
5132 	switch (objp->argop) {
5133 	case OP_CB_GETATTR:
5134 		gargs = &objp->nfs_cb_argop4_u.opcbgetattr;
5135 
5136 		if (!xdr_encode_nfs_fh4(xdrs, &gargs->fh))
5137 			return (FALSE);
5138 		return (xdr_bitmap4(xdrs, &gargs->attr_request));
5139 	case OP_CB_RECALL:
5140 		rargs = &objp->nfs_cb_argop4_u.opcbrecall;
5141 
5142 		if (!XDR_PUTINT32(xdrs, (int32_t *)&rargs->stateid.seqid))
5143 			return (FALSE);
5144 		if (!xdr_opaque(xdrs, rargs->stateid.other, NFS4_OTHER_SIZE))
5145 			return (FALSE);
5146 		if (!XDR_PUTINT32(xdrs, (int32_t *)&rargs->truncate))
5147 			return (FALSE);
5148 		return (xdr_encode_nfs_fh4(xdrs, &rargs->fh));
5149 	case OP_CB_ILLEGAL:
5150 		return (TRUE);
5151 	}
5152 	return (FALSE);
5153 }
5154 
5155 /*
5156  * NFS client side callback, receiving the callback request so it
5157  * is the RPC server. Must treat the file handles as opaque.
5158  */
5159 static bool_t
5160 xdr_cnfs_cb_argop4(XDR *xdrs, nfs_cb_argop4 *objp)
5161 {
5162 	CB_GETATTR4args *gargs;
5163 	CB_RECALL4args *rargs;
5164 
5165 	ASSERT(xdrs->x_op != XDR_ENCODE);
5166 
5167 	if (!xdr_u_int(xdrs, &objp->argop))
5168 		return (FALSE);
5169 	switch (objp->argop) {
5170 	case OP_CB_GETATTR:
5171 		gargs = &objp->nfs_cb_argop4_u.opcbgetattr;
5172 
5173 		if (!xdr_bytes(xdrs, (char **)&gargs->fh.nfs_fh4_val,
5174 		    (uint_t *)&gargs->fh.nfs_fh4_len, NFS4_FHSIZE))
5175 			return (FALSE);
5176 		return (xdr_bitmap4(xdrs, &gargs->attr_request));
5177 	case OP_CB_RECALL:
5178 		rargs = &objp->nfs_cb_argop4_u.opcbrecall;
5179 
5180 		if (!xdr_u_int(xdrs, &rargs->stateid.seqid))
5181 			return (FALSE);
5182 		if (!xdr_opaque(xdrs, rargs->stateid.other, NFS4_OTHER_SIZE))
5183 			return (FALSE);
5184 		if (!xdr_bool(xdrs, &rargs->truncate))
5185 			return (FALSE);
5186 		return (xdr_bytes(xdrs, (char **)&rargs->fh.nfs_fh4_val,
5187 		    (uint_t *)&rargs->fh.nfs_fh4_len, NFS4_FHSIZE));
5188 	case OP_CB_ILLEGAL:
5189 		return (TRUE);
5190 	}
5191 	return (FALSE);
5192 }
5193 
5194 static bool_t
5195 xdr_nfs_cb_resop4(XDR *xdrs, nfs_cb_resop4 *objp)
5196 {
5197 	if (!xdr_u_int(xdrs, &objp->resop))
5198 		return (FALSE);
5199 	switch (objp->resop) {
5200 	case OP_CB_GETATTR:
5201 		if (!xdr_int(xdrs,
5202 		    (int32_t *)&objp->nfs_cb_resop4_u.opcbgetattr.
5203 		    status))
5204 			return (FALSE);
5205 		if (objp->nfs_cb_resop4_u.opcbgetattr.status != NFS4_OK)
5206 			return (TRUE);
5207 		return (xdr_fattr4(xdrs,
5208 		    &objp->nfs_cb_resop4_u.opcbgetattr.
5209 		    obj_attributes));
5210 	case OP_CB_RECALL:
5211 		return (xdr_int(xdrs,
5212 		    (int32_t *)&objp->nfs_cb_resop4_u.opcbrecall.status));
5213 	case OP_CB_ILLEGAL:
5214 		return (xdr_int(xdrs,
5215 		    (int32_t *)&objp->nfs_cb_resop4_u.opcbillegal.status));
5216 	}
5217 	return (FALSE);
5218 }
5219 
5220 /*
5221  * The NFS client side callback, RPC server
5222  */
5223 bool_t
5224 xdr_CB_COMPOUND4args_clnt(XDR *xdrs, CB_COMPOUND4args *objp)
5225 {
5226 	if (!xdr_bytes(xdrs, (char **)&objp->tag.utf8string_val,
5227 	    (uint_t *)&objp->tag.utf8string_len,
5228 	    NFS4_MAX_UTF8STRING))
5229 		return (FALSE);
5230 	if (!xdr_u_int(xdrs, &objp->minorversion))
5231 		return (FALSE);
5232 	if (!xdr_u_int(xdrs, &objp->callback_ident))
5233 		return (FALSE);
5234 	return (xdr_array(xdrs, (char **)&objp->array,
5235 	    (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5236 	    sizeof (nfs_cb_argop4), (xdrproc_t)xdr_cnfs_cb_argop4));
5237 }
5238 
5239 /*
5240  * The NFS server side callback, RPC client
5241  */
5242 bool_t
5243 xdr_CB_COMPOUND4args_srv(XDR *xdrs, CB_COMPOUND4args *objp)
5244 {
5245 	if (!xdr_bytes(xdrs, (char **)&objp->tag.utf8string_val,
5246 	    (uint_t *)&objp->tag.utf8string_len,
5247 	    NFS4_MAX_UTF8STRING))
5248 		return (FALSE);
5249 	if (!xdr_u_int(xdrs, &objp->minorversion))
5250 		return (FALSE);
5251 	if (!xdr_u_int(xdrs, &objp->callback_ident))
5252 		return (FALSE);
5253 	return (xdr_array(xdrs, (char **)&objp->array,
5254 	    (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5255 	    sizeof (nfs_cb_argop4), (xdrproc_t)xdr_snfs_cb_argop4));
5256 }
5257 
5258 bool_t
5259 xdr_CB_COMPOUND4res(XDR *xdrs, CB_COMPOUND4res *objp)
5260 {
5261 	if (!xdr_int(xdrs, (int32_t *)&objp->status))
5262 		return (FALSE);
5263 	if (!xdr_bytes(xdrs, (char **)&objp->tag.utf8string_val,
5264 	    (uint_t *)&objp->tag.utf8string_len,
5265 	    NFS4_MAX_UTF8STRING))
5266 		return (FALSE);
5267 	return (xdr_array(xdrs, (char **)&objp->array,
5268 	    (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5269 	    sizeof (nfs_cb_resop4), (xdrproc_t)xdr_nfs_cb_resop4));
5270 }
5271