?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
6747 xdr_READDIR4res() bypass the XDR mblk API
[unleashed.git] / usr / src / uts / common / fs / nfs / nfs4_xdr.c
blobf71717ea5bb225a7161dbe74a5606c68cfdca813
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 2016 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, ug_cache_t *pug)
1548 {
1549 int truefalse;
1550 struct nfs4_ga_ext_res ges, *gesp;
1551 vattr_t *vap = &garp->n4g_va;
1552
1553 if (garp->n4g_ext_res)
1554 gesp = garp->n4g_ext_res;
1555 else
1556 gesp = &ges;
1557
1558 vap->va_mask = 0;
1559
1560 /* Check to see if the vattr should be pre-filled */
1561 if (argbmap & NFS4_VATTR_MASK)
1562 xdr_ga_prefill_vattr(garp, mi);
1563
1564 if (argbmap & NFS4_STATFS_ATTR_MASK)
1565 xdr_ga_prefill_statvfs(gesp, mi);
1566
1567 if (resbmap &
1568 (FATTR4_SUPPORTED_ATTRS_MASK |
1569 FATTR4_TYPE_MASK |
1570 FATTR4_FH_EXPIRE_TYPE_MASK |
1571 FATTR4_CHANGE_MASK |
1572 FATTR4_SIZE_MASK |
1573 FATTR4_LINK_SUPPORT_MASK |
1574 FATTR4_SYMLINK_SUPPORT_MASK |
1575 FATTR4_NAMED_ATTR_MASK)) {
1576
1577 if (resbmap & FATTR4_SUPPORTED_ATTRS_MASK) {
1578 gesp->n4g_suppattrs = xdr_get_bitmap4_inline(&ptr);
1579 }
1580 if (resbmap & FATTR4_TYPE_MASK) {
1581 vap->va_type = IXDR_GET_U_INT32(ptr);
1582
1583 if ((nfs_ftype4)vap->va_type < NF4REG ||
1584 (nfs_ftype4)vap->va_type > NF4NAMEDATTR)
1585 vap->va_type = VBAD;
1586 else
1587 vap->va_type = nf4_to_vt[vap->va_type];
1588 if (vap->va_type == VBLK)
1589 vap->va_blksize = DEV_BSIZE;
1590
1591 vap->va_mask |= AT_TYPE;
1592 }
1593 if (resbmap & FATTR4_FH_EXPIRE_TYPE_MASK) {
1594 gesp->n4g_fet = IXDR_GET_U_INT32(ptr);
1595 }
1596 if (resbmap & FATTR4_CHANGE_MASK) {
1597 IXDR_GET_U_HYPER(ptr, garp->n4g_change);
1598 garp->n4g_change_valid = 1;
1599 }
1600 if (resbmap & FATTR4_SIZE_MASK) {
1601 IXDR_GET_U_HYPER(ptr, vap->va_size);
1602
1603 if (!NFS4_SIZE_OK(vap->va_size)) {
1604 garp->n4g_attrerr = EFBIG;
1605 garp->n4g_attrwhy = NFS4_GETATTR_ATSIZE_ERR;
1606 } else {
1607 vap->va_mask |= AT_SIZE;
1608 }
1609 }
1610 if (resbmap & FATTR4_LINK_SUPPORT_MASK) {
1611 truefalse = IXDR_GET_U_INT32(ptr);
1612 gesp->n4g_pc4.pc4_link_support =
1613 (truefalse ? TRUE : FALSE);
1614 }
1615 if (resbmap & FATTR4_SYMLINK_SUPPORT_MASK) {
1616 truefalse = IXDR_GET_U_INT32(ptr);
1617 gesp->n4g_pc4.pc4_symlink_support =
1618 (truefalse ? TRUE : FALSE);
1619 }
1620 if (resbmap & FATTR4_NAMED_ATTR_MASK) {
1621 truefalse = IXDR_GET_U_INT32(ptr);
1622 gesp->n4g_pc4.pc4_xattr_exists = TRUE;
1623 gesp->n4g_pc4.pc4_xattr_exists =
1624 (truefalse ? TRUE : FALSE);
1625 }
1626 }
1627 if (resbmap &
1628 (FATTR4_FSID_MASK |
1629 FATTR4_UNIQUE_HANDLES_MASK |
1630 FATTR4_LEASE_TIME_MASK |
1631 FATTR4_RDATTR_ERROR_MASK)) {
1632
1633 if (resbmap & FATTR4_FSID_MASK) {
1634 IXDR_GET_U_HYPER(ptr, garp->n4g_fsid.major);
1635 IXDR_GET_U_HYPER(ptr, garp->n4g_fsid.minor);
1636 garp->n4g_fsid_valid = 1;
1637 }
1638 if (resbmap & FATTR4_UNIQUE_HANDLES_MASK) {
1639 truefalse = IXDR_GET_U_INT32(ptr);
1640 gesp->n4g_pc4.pc4_unique_handles =
1641 (truefalse ? TRUE : FALSE);
1642 }
1643 if (resbmap & FATTR4_LEASE_TIME_MASK) {
1644 gesp->n4g_leasetime = IXDR_GET_U_INT32(ptr);
1645 }
1646 if (resbmap & FATTR4_RDATTR_ERROR_MASK) {
1647 gesp->n4g_rdattr_error = IXDR_GET_U_INT32(ptr);
1648 }
1649 }
1650 if (resbmap &
1651 (FATTR4_ACL_MASK |
1652 FATTR4_ACLSUPPORT_MASK |
1653 FATTR4_ARCHIVE_MASK |
1654 FATTR4_CANSETTIME_MASK)) {
1655
1656 if (resbmap & FATTR4_ACL_MASK) {
1657 ASSERT(0);
1658 }
1659 if (resbmap & FATTR4_ACLSUPPORT_MASK) {
1660 gesp->n4g_aclsupport = IXDR_GET_U_INT32(ptr);
1661 }
1662 if (resbmap & FATTR4_ARCHIVE_MASK) {
1663 ASSERT(0);
1664 }
1665 if (resbmap & FATTR4_CANSETTIME_MASK) {
1666 truefalse = IXDR_GET_U_INT32(ptr);
1667 gesp->n4g_pc4.pc4_cansettime =
1668 (truefalse ? TRUE : FALSE);
1669 }
1670 }
1671 if (resbmap &
1672 (FATTR4_CASE_INSENSITIVE_MASK |
1673 FATTR4_CASE_PRESERVING_MASK |
1674 FATTR4_CHOWN_RESTRICTED_MASK |
1675 FATTR4_FILEHANDLE_MASK |
1676 FATTR4_FILEID_MASK |
1677 FATTR4_FILES_AVAIL_MASK |
1678 FATTR4_FILES_FREE_MASK |
1679 FATTR4_FILES_TOTAL_MASK)) {
1680
1681 if (resbmap & FATTR4_CASE_INSENSITIVE_MASK) {
1682 truefalse = IXDR_GET_U_INT32(ptr);
1683 gesp->n4g_pc4.pc4_case_insensitive =
1684 (truefalse ? TRUE : FALSE);
1685 }
1686 if (resbmap & FATTR4_CASE_PRESERVING_MASK) {
1687 truefalse = IXDR_GET_U_INT32(ptr);
1688 gesp->n4g_pc4.pc4_case_preserving =
1689 (truefalse ? TRUE : FALSE);
1690 }
1691 if (resbmap & FATTR4_CHOWN_RESTRICTED_MASK) {
1692 truefalse = IXDR_GET_U_INT32(ptr);
1693 gesp->n4g_pc4.pc4_chown_restricted =
1694 (truefalse ? TRUE : FALSE);
1695 }
1696 if (resbmap & FATTR4_FILEHANDLE_MASK) {
1697 int len = IXDR_GET_U_INT32(ptr);
1698
1699 gesp->n4g_fh_u.nfs_fh4_alt.len = 0;
1700 gesp->n4g_fh_u.nfs_fh4_alt.val =
1701 gesp->n4g_fh_u.nfs_fh4_alt.data;
1702 gesp->n4g_fh_u.n4g_fh.nfs_fh4_len = len;
1703
1704 bcopy(ptr, gesp->n4g_fh_u.n4g_fh.nfs_fh4_val, len);
1705
1706 ptr += RNDUP(len) / BYTES_PER_XDR_UNIT;
1707 }
1708 if (resbmap & FATTR4_FILEID_MASK) {
1709 IXDR_GET_U_HYPER(ptr, vap->va_nodeid);
1710 vap->va_mask |= AT_NODEID;
1711 }
1712 if (resbmap & FATTR4_FILES_AVAIL_MASK) {
1713 IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_favail);
1714 }
1715 if (resbmap & FATTR4_FILES_FREE_MASK) {
1716 IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_ffree);
1717 }
1718 if (resbmap & FATTR4_FILES_TOTAL_MASK) {
1719 IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_files);
1720 }
1721 }
1722 if (resbmap &
1723 (FATTR4_FS_LOCATIONS_MASK |
1724 FATTR4_HIDDEN_MASK |
1725 FATTR4_HOMOGENEOUS_MASK)) {
1726
1727 if (resbmap & FATTR4_FS_LOCATIONS_MASK) {
1728 ASSERT(0);
1729 }
1730 if (resbmap & FATTR4_HIDDEN_MASK) {
1731 ASSERT(0);
1732 }
1733 if (resbmap & FATTR4_HOMOGENEOUS_MASK) {
1734 truefalse = IXDR_GET_U_INT32(ptr);
1735 gesp->n4g_pc4.pc4_homogeneous =
1736 (truefalse ? TRUE : FALSE);
1737 }
1738 }
1739 if (resbmap &
1740 (FATTR4_MAXFILESIZE_MASK |
1741 FATTR4_MAXLINK_MASK |
1742 FATTR4_MAXNAME_MASK |
1743 FATTR4_MAXREAD_MASK |
1744 FATTR4_MAXWRITE_MASK)) {
1745
1746 if (resbmap & FATTR4_MAXFILESIZE_MASK) {
1747 IXDR_GET_U_HYPER(ptr, gesp->n4g_maxfilesize);
1748 }
1749 if (resbmap & FATTR4_MAXLINK_MASK) {
1750 gesp->n4g_pc4.pc4_link_max = IXDR_GET_U_INT32(ptr);
1751 }
1752 if (resbmap & FATTR4_MAXNAME_MASK) {
1753 gesp->n4g_pc4.pc4_name_max = IXDR_GET_U_INT32(ptr);
1754 gesp->n4g_sb.f_namemax = gesp->n4g_pc4.pc4_name_max;
1755 }
1756 if (resbmap & FATTR4_MAXREAD_MASK) {
1757 IXDR_GET_U_HYPER(ptr, gesp->n4g_maxread);
1758 }
1759 if (resbmap & FATTR4_MAXWRITE_MASK) {
1760 IXDR_GET_U_HYPER(ptr, gesp->n4g_maxwrite);
1761 }
1762 }
1763 if (resbmap &
1764 (FATTR4_MIMETYPE_MASK |
1765 FATTR4_MODE_MASK |
1766 FATTR4_NO_TRUNC_MASK |
1767 FATTR4_NUMLINKS_MASK)) {
1768
1769 if (resbmap & FATTR4_MIMETYPE_MASK) {
1770 ASSERT(0);
1771 }
1772 if (resbmap & FATTR4_MODE_MASK) {
1773 vap->va_mode = IXDR_GET_U_INT32(ptr);
1774 vap->va_mask |= AT_MODE;
1775 }
1776 if (resbmap & FATTR4_NO_TRUNC_MASK) {
1777 truefalse = IXDR_GET_U_INT32(ptr);
1778 gesp->n4g_pc4.pc4_no_trunc =
1779 (truefalse ? TRUE : FALSE);
1780 }
1781 if (resbmap & FATTR4_NUMLINKS_MASK) {
1782 vap->va_nlink = IXDR_GET_U_INT32(ptr);
1783 vap->va_mask |= AT_NLINK;
1784 }
1785 }
1786 if (resbmap &
1787 (FATTR4_OWNER_MASK |
1788 FATTR4_OWNER_GROUP_MASK |
1789 FATTR4_QUOTA_AVAIL_HARD_MASK |
1790 FATTR4_QUOTA_AVAIL_SOFT_MASK)) {
1791
1792 if (resbmap & FATTR4_OWNER_MASK) {
1793 uint_t *owner_length, ol;
1794 char *owner_val = NULL;
1795 utf8string ov;
1796 int error;
1797
1798 /* get the OWNER_LENGTH */
1799 ol = IXDR_GET_U_INT32(ptr);
1800
1801 /* Manage the owner length location */
1802 if (pug && ol <= MAX_OG_NAME) {
1803 owner_length = &pug->u_curr.utf8string_len;
1804 *owner_length = ol;
1805 } else {
1806 owner_length = &ol;
1807 }
1808
1809 /* find memory to store the decode */
1810 if (*owner_length > MAX_OG_NAME || pug == NULL)
1811 owner_val = (char *)ptr;
1812 else
1813 owner_val = (char *)ptr;
1814
1815 /* Optimize for matching if called for */
1816 if (pug &&
1817 *owner_length == pug->u_last.utf8string_len &&
1818 bcmp(owner_val, pug->u_last.utf8string_val,
1819 *owner_length) == 0) {
1820 vap->va_uid = pug->uid;
1821 vap->va_mask |= AT_UID;
1822 } else {
1823 uid_t uid;
1824
1825 ov.utf8string_len = *owner_length;
1826 ov.utf8string_val = owner_val;
1827 error = nfs_idmap_str_uid(&ov, &uid, FALSE);
1828 /*
1829 * String was mapped, but to nobody because
1830 * we are nfsmapid, indicate it should not
1831 * be cached.
1832 */
1833 if (error == ENOTSUP) {
1834 error = 0;
1835 garp->n4g_attrwhy =
1836 NFS4_GETATTR_NOCACHE_OK;
1837 }
1838
1839 if (error) {
1840 garp->n4g_attrerr = error;
1841 garp->n4g_attrwhy =
1842 NFS4_GETATTR_ATUID_ERR;
1843 } else {
1844 vap->va_uid = uid;
1845 vap->va_mask |= AT_UID;
1846 /* save the results for next time */
1847 if (pug && ol <= MAX_OG_NAME) {
1848 pug->uid = uid;
1849 pug->u_curr.utf8string_len =
1850 ov.utf8string_len;
1851 bcopy(owner_val,
1852 pug->u_curr.utf8string_val,
1853 ol);
1854 U_SWAP_CURR_LAST(pug);
1855 }
1856 }
1857 }
1858 ptr += RNDUP(ol) / BYTES_PER_XDR_UNIT;
1859 }
1860 if (resbmap & FATTR4_OWNER_GROUP_MASK) {
1861 uint_t *group_length, gl;
1862 char *group_val = NULL;
1863 utf8string gv;
1864 int error;
1865
1866 /* get the OWNER_GROUP_LENGTH */
1867 gl = IXDR_GET_U_INT32(ptr);
1868
1869 /* Manage the group length location */
1870 if (pug && gl <= MAX_OG_NAME) {
1871 group_length = &pug->g_curr.utf8string_len;
1872 *group_length = gl;
1873 } else {
1874 group_length = &gl;
1875 }
1876
1877 /* find memory to store the decode */
1878 if (*group_length > MAX_OG_NAME || pug == NULL)
1879 group_val = (char *)ptr;
1880 else
1881 group_val = (char *)ptr;
1882
1883 /* Optimize for matching if called for */
1884 if (pug &&
1885 *group_length == pug->g_last.utf8string_len &&
1886 bcmp(group_val, pug->g_last.utf8string_val,
1887 *group_length) == 0) {
1888 vap->va_gid = pug->gid;
1889 vap->va_mask |= AT_GID;
1890 } else {
1891 uid_t gid;
1892
1893 gv.utf8string_len = *group_length;
1894 gv.utf8string_val = group_val;
1895 error = nfs_idmap_str_gid(&gv, &gid, FALSE);
1896 /*
1897 * String was mapped, but to nobody because
1898 * we are nfsmapid, indicate it should not
1899 * be cached.
1900 */
1901 if (error == ENOTSUP) {
1902 error = 0;
1903 garp->n4g_attrwhy =
1904 NFS4_GETATTR_NOCACHE_OK;
1905 }
1906
1907 if (error) {
1908 garp->n4g_attrerr = error;
1909 garp->n4g_attrwhy =
1910 NFS4_GETATTR_ATGID_ERR;
1911 } else {
1912 vap->va_gid = gid;
1913 vap->va_mask |= AT_GID;
1914 if (pug && gl <= MAX_OG_NAME) {
1915 pug->gid = gid;
1916 pug->g_curr.utf8string_len =
1917 gv.utf8string_len;
1918 bcopy(group_val,
1919 pug->g_curr.utf8string_val,
1920 gl);
1921 G_SWAP_CURR_LAST(pug);
1922 }
1923 }
1924 }
1925 ptr += RNDUP(gl) / BYTES_PER_XDR_UNIT;
1926 }
1927 if (resbmap & FATTR4_QUOTA_AVAIL_HARD_MASK) {
1928 ASSERT(0);
1929 }
1930 if (resbmap & FATTR4_QUOTA_AVAIL_SOFT_MASK) {
1931 ASSERT(0);
1932 }
1933 }
1934 if (resbmap &
1935 (FATTR4_QUOTA_USED_MASK |
1936 FATTR4_SPACE_AVAIL_MASK |
1937 FATTR4_SPACE_FREE_MASK |
1938 FATTR4_SPACE_TOTAL_MASK |
1939 FATTR4_SPACE_USED_MASK |
1940 FATTR4_SYSTEM_MASK)) {
1941
1942 if (resbmap & FATTR4_QUOTA_USED_MASK) {
1943 ASSERT(0);
1944 }
1945 if (resbmap & FATTR4_RAWDEV_MASK) {
1946 fattr4_rawdev rawdev;
1947
1948 rawdev.specdata1 = IXDR_GET_U_INT32(ptr);
1949 rawdev.specdata2 = IXDR_GET_U_INT32(ptr);
1950
1951 if (vap->va_type == VCHR || vap->va_type == VBLK) {
1952 vap->va_rdev = makedevice(rawdev.specdata1,
1953 rawdev.specdata2);
1954 } else {
1955 vap->va_rdev = 0;
1956 }
1957 vap->va_mask |= AT_RDEV;
1958 }
1959 if (resbmap & FATTR4_SPACE_AVAIL_MASK) {
1960 IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_bavail);
1961 gesp->n4g_sb.f_bavail /= DEV_BSIZE;
1962 }
1963 if (resbmap & FATTR4_SPACE_FREE_MASK) {
1964 IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_bfree);
1965 gesp->n4g_sb.f_bfree /= DEV_BSIZE;
1966 }
1967 if (resbmap & FATTR4_SPACE_TOTAL_MASK) {
1968 IXDR_GET_U_HYPER(ptr, gesp->n4g_sb.f_blocks);
1969 gesp->n4g_sb.f_blocks /= DEV_BSIZE;
1970 }
1971 if (resbmap & FATTR4_SPACE_USED_MASK) {
1972 uint64_t space_used;
1973 IXDR_GET_U_HYPER(ptr, space_used);
1974
1975 /* Compute space depending on device type */
1976 ASSERT((vap->va_mask & AT_TYPE));
1977 if (vap->va_type == VREG || vap->va_type == VDIR ||
1978 vap->va_type == VLNK) {
1979 vap->va_nblocks = (u_longlong_t)
1980 ((space_used + (offset4)DEV_BSIZE -
1981 (offset4)1) / (offset4)DEV_BSIZE);
1982 } else {
1983 vap->va_nblocks = 0;
1984 }
1985 vap->va_mask |= AT_NBLOCKS;
1986 }
1987 if (resbmap & FATTR4_SYSTEM_MASK) {
1988 ASSERT(0);
1989 }
1990 }
1991 if (resbmap &
1992 (FATTR4_TIME_ACCESS_MASK |
1993 FATTR4_TIME_ACCESS_SET_MASK |
1994 FATTR4_TIME_BACKUP_MASK |
1995 FATTR4_TIME_CREATE_MASK |
1996 FATTR4_TIME_DELTA_MASK |
1997 FATTR4_TIME_METADATA_MASK |
1998 FATTR4_TIME_MODIFY_MASK |
1999 FATTR4_TIME_MODIFY_SET_MASK |
2000 FATTR4_MOUNTED_ON_FILEID_MASK)) {
2001
2002 if (resbmap & FATTR4_TIME_ACCESS_MASK) {
2003 nfstime4 atime;
2004 int error;
2005
2006 IXDR_GET_U_HYPER(ptr, atime.seconds);
2007 atime.nseconds = IXDR_GET_U_INT32(ptr);
2008
2009 error = nfs4_time_ntov(&atime, &vap->va_atime);
2010 if (error) {
2011 garp->n4g_attrerr = error;
2012 garp->n4g_attrwhy = NFS4_GETATTR_ATATIME_ERR;
2013 }
2014 vap->va_mask |= AT_ATIME;
2015 }
2016 if (resbmap & FATTR4_TIME_ACCESS_SET_MASK) {
2017 ASSERT(0);
2018 }
2019 if (resbmap & FATTR4_TIME_BACKUP_MASK) {
2020 ASSERT(0);
2021 }
2022 if (resbmap & FATTR4_TIME_CREATE_MASK) {
2023 ASSERT(0);
2024 }
2025 if (resbmap & FATTR4_TIME_DELTA_MASK) {
2026 IXDR_GET_U_HYPER(ptr, gesp->n4g_delta.seconds);
2027 gesp->n4g_delta.nseconds = IXDR_GET_U_INT32(ptr);
2028 }
2029 if (resbmap & FATTR4_TIME_METADATA_MASK) {
2030 nfstime4 mdt;
2031 int error;
2032
2033 IXDR_GET_U_HYPER(ptr, mdt.seconds);
2034 mdt.nseconds = IXDR_GET_U_INT32(ptr);
2035
2036 error = nfs4_time_ntov(&mdt, &vap->va_ctime);
2037 if (error) {
2038 garp->n4g_attrerr = error;
2039 garp->n4g_attrwhy = NFS4_GETATTR_ATCTIME_ERR;
2040 }
2041 vap->va_mask |= AT_CTIME;
2042 }
2043 if (resbmap & FATTR4_TIME_MODIFY_MASK) {
2044 nfstime4 mtime;
2045 int error;
2046
2047 IXDR_GET_U_HYPER(ptr, mtime.seconds);
2048 mtime.nseconds = IXDR_GET_U_INT32(ptr);
2049
2050 error = nfs4_time_ntov(&mtime, &vap->va_mtime);
2051 if (error) {
2052 garp->n4g_attrerr = error;
2053 garp->n4g_attrwhy = NFS4_GETATTR_ATMTIME_ERR;
2054 }
2055 vap->va_mask |= AT_MTIME;
2056 }
2057 if (resbmap & FATTR4_TIME_MODIFY_SET_MASK) {
2058 ASSERT(0);
2059 }
2060 if (resbmap & FATTR4_MOUNTED_ON_FILEID_MASK) {
2061 IXDR_GET_U_HYPER(ptr, garp->n4g_mon_fid);
2062 garp->n4g_mon_fid_valid = 1;
2063 }
2064 }
2065
2066 /*
2067 * FATTR4_ACL_MASK is not yet supported by this function, but
2068 * we check against it anyway, in case it ever is.
2069 */
2070 if (resbmap & ~(NFS4_VATTR_MASK | FATTR4_ACL_MASK)) {
2071 /* copy only if not provided */
2072 if (garp->n4g_ext_res == NULL) {
2073 garp->n4g_ext_res = kmem_alloc(sizeof (ges), KM_SLEEP);
2074 bcopy(&ges, garp->n4g_ext_res, sizeof (ges));
2075 }
2076 }
2077
2078 return (TRUE);
2079 }
2080
2081
2082 /*
2083 * "." and ".." buffers for filling in on read and readdir
2084 * calls. Intialize the first time and fill in on every
2085 * call to to readdir.
2086 */
2087 char *nfs4_dot_entries;
2088 char *nfs4_dot_dot_entry;
2089
2090 /*
2091 * Create the "." or ".." and pad the buffer once so they are
2092 * copied out as required into the user supplied buffer everytime.
2093 * DIRENT64_RECLEN(sizeof (".") - 1) = DIRENT64_RECLEN(1)
2094 * DIRENT64_RECLEN(sizeof ("..") - 1) = DIRENT64_RECLEN(2)
2095 */
2096 void
2097 nfs4_init_dot_entries()
2098 {
2099 struct dirent64 *odp;
2100
2101 /*
2102 * zalloc it so it zeros the buffer out. Need
2103 * to just do it once.
2104 */
2105 nfs4_dot_entries = kmem_zalloc(DIRENT64_RECLEN(1) + DIRENT64_RECLEN(2),
2106 KM_SLEEP);
2107
2108 odp = (struct dirent64 *)nfs4_dot_entries;
2109 odp->d_off = 1; /* magic cookie for "." entry */
2110 odp->d_reclen = DIRENT64_RECLEN(1);
2111 odp->d_name[0] = '.';
2112 odp->d_name[1] = '\0';
2113
2114 nfs4_dot_dot_entry = nfs4_dot_entries + DIRENT64_RECLEN(1);
2115 odp = (struct dirent64 *)nfs4_dot_dot_entry;
2116
2117 odp->d_off = 2;
2118 odp->d_reclen = DIRENT64_RECLEN(2);
2119 odp->d_name[0] = '.';
2120 odp->d_name[1] = '.';
2121 odp->d_name[2] = '\0';
2122 }
2123
2124 void
2125 nfs4_destroy_dot_entries()
2126 {
2127 if (nfs4_dot_entries)
2128 kmem_free(nfs4_dot_entries, DIRENT64_RECLEN(1) +
2129 DIRENT64_RECLEN(2));
2130
2131 nfs4_dot_entries = nfs4_dot_dot_entry = NULL;
2132 }
2133
2134 bool_t
2135 xdr_READDIR4res_clnt(XDR *xdrs, READDIR4res_clnt *objp, READDIR4args *aobjp)
2136 {
2137 bool_t more_data;
2138 rddir4_cache *rdc = aobjp->rdc;
2139 dirent64_t *dp = NULL;
2140 int entry_length = 0;
2141 int space_left = 0;
2142 bitmap4 resbmap;
2143 uint32_t attrlen;
2144 nfs4_ga_res_t gar;
2145 struct nfs4_ga_ext_res ges;
2146 uint64_t last_cookie = 0;
2147 int skip_to_end;
2148 ug_cache_t *pug = NULL;
2149
2150 ASSERT(xdrs->x_op == XDR_DECODE);
2151 ASSERT(rdc->entries == NULL);
2152 ASSERT(aobjp->dircount > 0);
2153
2154 if (!xdr_int(xdrs, (int32_t *)&objp->status))
2155 return (FALSE);
2156 if (objp->status != NFS4_OK)
2157 return (TRUE);
2158
2159 gar.n4g_va.va_mask = 0;
2160 gar.n4g_change_valid = 0;
2161 gar.n4g_mon_fid_valid = 0;
2162 gar.n4g_fsid_valid = 0;
2163 gar.n4g_vsa.vsa_mask = 0;
2164 gar.n4g_attrwhy = NFS4_GETATTR_OP_OK;
2165 ges.n4g_pc4.pc4_cache_valid = 0;
2166 ges.n4g_pc4.pc4_xattr_valid = 0;
2167 gar.n4g_ext_res = &ges;
2168
2169 /* READDIR4res_clnt_free needs to kmem_free this buffer */
2170 rdc->entries = kmem_alloc(aobjp->dircount, KM_SLEEP);
2171
2172 dp = (dirent64_t *)rdc->entries;
2173 rdc->entlen = rdc->buflen = space_left = aobjp->dircount;
2174
2175 /* Fill in dot and dot-dot if needed */
2176 if (rdc->nfs4_cookie == (nfs_cookie4) 0 ||
2177 rdc->nfs4_cookie == (nfs_cookie4) 1) {
2178
2179 if (rdc->nfs4_cookie == (nfs_cookie4)0) {
2180 bcopy(nfs4_dot_entries, rdc->entries,
2181 DIRENT64_RECLEN(1) + DIRENT64_RECLEN(2));
2182 objp->dotp = dp;
2183 dp = (struct dirent64 *)(((char *)dp) +
2184 DIRENT64_RECLEN(1));
2185 objp->dotdotp = dp;
2186 dp = (struct dirent64 *)(((char *)dp) +
2187 DIRENT64_RECLEN(2));
2188 space_left -= DIRENT64_RECLEN(1) + DIRENT64_RECLEN(2);
2189
2190 } else { /* for ".." entry */
2191 bcopy(nfs4_dot_dot_entry, rdc->entries,
2192 DIRENT64_RECLEN(2));
2193 objp->dotp = NULL;
2194 objp->dotdotp = dp;
2195 dp = (struct dirent64 *)(((char *)dp) +
2196 DIRENT64_RECLEN(2));
2197 space_left -= DIRENT64_RECLEN(2);
2198 }
2199 /* Magic NFSv4 number for entry after start */
2200 last_cookie = 2;
2201 }
2202
2203 /* Get the cookie VERIFIER */
2204 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cookieverf))
2205 goto noentries;
2206
2207 /* Get the do-we-have-a-next-entry BOOL */
2208 if (!xdr_bool(xdrs, &more_data))
2209 goto noentries;
2210
2211 if (aobjp->attr_request & (FATTR4_OWNER_MASK | FATTR4_OWNER_GROUP_MASK))
2212 pug = alloc_ugcache();
2213
2214 skip_to_end = 0;
2215 while (more_data) {
2216 uint_t namelen;
2217 uint64_t cookie;
2218
2219 /* Get the COOKIE */
2220 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&cookie))
2221 goto noentries;
2222
2223 /* Get the LENGTH of the entry name */
2224 if (!xdr_u_int(xdrs, &namelen))
2225 goto noentries;
2226
2227 if (!skip_to_end) {
2228 /*
2229 * With the length of the directory entry name
2230 * in hand, figure out if there is room left
2231 * to encode it for the requestor. If not,
2232 * that is okay, but the rest of the readdir
2233 * operation result must be decoded in the
2234 * case there are following operations
2235 * in the compound request. Therefore, mark
2236 * the rest of the response as "skip" and
2237 * decode or skip the remaining data
2238 */
2239 entry_length = DIRENT64_RECLEN(namelen);
2240 if (space_left < entry_length)
2241 skip_to_end = 1;
2242 }
2243
2244 /* Get the NAME of the entry */
2245 if (!skip_to_end) {
2246 if (!xdr_opaque(xdrs, dp->d_name, namelen))
2247 goto noentries;
2248 bzero(&dp->d_name[namelen],
2249 DIRENT64_NAMELEN(entry_length) - namelen);
2250 dp->d_off = last_cookie = cookie;
2251 dp->d_reclen = entry_length;
2252 } else {
2253 if (!XDR_CONTROL(xdrs, XDR_SKIPBYTES, &namelen))
2254 goto noentries;
2255 }
2256
2257 /* Get the attribute BITMAP */
2258 if (!xdr_bitmap4(xdrs, &resbmap))
2259 goto noentries;
2260 /* Get the LENGTH of the attributes */
2261 if (!xdr_u_int(xdrs, (uint_t *)&attrlen))
2262 goto noentries;
2263
2264 /* Get the ATTRIBUTES */
2265 if (!skip_to_end) {
2266 uint32_t *ptr;
2267
2268 if (!(resbmap & FATTR4_ACL_MASK) &&
2269 (ptr = (uint32_t *)XDR_INLINE(xdrs, attrlen))
2270 != NULL) {
2271 if (!xdr_ga_fattr_res_inline(ptr, &gar, resbmap,
2272 aobjp->attr_request, aobjp->mi, pug))
2273 goto noentries;
2274 } else {
2275 if (!xdr_ga_fattr_res(xdrs, &gar, resbmap,
2276 aobjp->attr_request, aobjp->mi, pug))
2277 goto noentries;
2278 }
2279
2280 /* Fill in the d_ino per the server's fid values */
2281 /*
2282 * Important to note that the mounted on fileid
2283 * is returned in d_ino if supported. This is
2284 * expected, readdir returns the mounted on fileid
2285 * while stat() returns the fileid of the object
2286 * on "top" of the mount.
2287 */
2288 if (gar.n4g_mon_fid_valid)
2289 dp->d_ino = gar.n4g_mon_fid;
2290 else if (gar.n4g_va.va_mask & AT_NODEID)
2291 dp->d_ino = gar.n4g_va.va_nodeid;
2292 else
2293 dp->d_ino = 0;
2294
2295 /* See about creating an rnode for this entry */
2296 if ((resbmap &
2297 (NFS4_VATTR_MASK | FATTR4_FILEHANDLE_MASK)) ==
2298 (NFS4_VATTR_MASK | FATTR4_FILEHANDLE_MASK)) {
2299 nfs4_sharedfh_t *sfhp;
2300 vnode_t *vp;
2301
2302 sfhp = sfh4_put(&ges.n4g_fh_u.n4g_fh,
2303 aobjp->mi, NULL);
2304 vp = makenfs4node(sfhp, &gar,
2305 aobjp->dvp->v_vfsp,
2306 aobjp->t,
2307 aobjp->cr,
2308 aobjp->dvp,
2309 fn_get(VTOSV(aobjp->dvp)->sv_name,
2310 dp->d_name, sfhp));
2311 sfh4_rele(&sfhp);
2312 dnlc_update(aobjp->dvp, dp->d_name, vp);
2313 VN_RELE(vp);
2314 }
2315
2316 dp = (struct dirent64 *)(((caddr_t)dp) + dp->d_reclen);
2317
2318 space_left -= entry_length;
2319
2320 } else {
2321 if (!XDR_CONTROL(xdrs, XDR_SKIPBYTES, &attrlen))
2322 goto noentries;
2323 }
2324
2325 /* Get the do-we-have-a-next-entry BOOL */
2326 if (!xdr_bool(xdrs, &more_data))
2327 goto noentries;
2328 }
2329
2330 if (pug) {
2331 kmem_free(pug, sizeof (ug_cache_t));
2332 pug = NULL;
2333 }
2334
2335 /*
2336 * Finish up the rddir cache
2337 * If no entries were returned, free up buffer &
2338 * set ncookie to the starting cookie for this
2339 * readdir request so that the direof caching
2340 * will work properly.
2341 */
2342 ASSERT(rdc->entries);
2343 if (last_cookie == 0) {
2344 kmem_free(rdc->entries, rdc->entlen);
2345 rdc->entries = NULL;
2346 last_cookie = rdc->nfs4_cookie;
2347 }
2348
2349 rdc->actlen = rdc->entlen - space_left;
2350 rdc->nfs4_ncookie = last_cookie;
2351
2352 /* Get the EOF marker */
2353 if (!xdr_bool(xdrs, &objp->eof))
2354 goto noentries;
2355
2356 /*
2357 * If the server returns eof and there were no
2358 * skipped entries, set eof
2359 */
2360 rdc->eof = (objp->eof && !skip_to_end) ? TRUE : FALSE;
2361
2362 /*
2363 * If we encoded entries we are done
2364 */
2365 if (rdc->entries) {
2366 rdc->error = 0;
2367 return (TRUE);
2368 }
2369
2370 /*
2371 * If there were no entries and we skipped because
2372 * there was not enough space, return EINVAL
2373 */
2374 if (skip_to_end) {
2375 rdc->error = EINVAL;
2376 return (TRUE);
2377 }
2378
2379 /*
2380 * No entries, nothing skipped, and EOF, return OK.
2381 */
2382 if (objp->eof == TRUE) {
2383 rdc->error = 0;
2384 return (TRUE);
2385 }
2386
2387 /*
2388 * No entries, nothing skipped, and not EOF
2389 * probably a bad cookie, return ENOENT.
2390 */
2391 rdc->error = ENOENT;
2392 return (TRUE);
2393
2394 noentries:
2395 if (rdc->entries) {
2396 kmem_free(rdc->entries, rdc->entlen);
2397 rdc->entries = NULL;
2398 }
2399 if (pug)
2400 kmem_free(pug, sizeof (ug_cache_t));
2401 rdc->error = EIO;
2402 return (FALSE);
2403 }
2404
2405 /*
2406 * xdr_ga_res
2407 *
2408 * Returns: FALSE on raw data processing errors, TRUE otherwise.
2409 *
2410 * This function pre-processes the OP_GETATTR response, and then
2411 * calls common routines to process the GETATTR fattr4 results into
2412 * vnode attributes and other components that the client is interested
2413 * in. If an error other than an RPC error is encountered, the details
2414 * of the error are filled into objp, although the result of the
2415 * processing is set to TRUE.
2416 */
2417 static bool_t
2418 xdr_ga_res(XDR *xdrs, GETATTR4res *objp, GETATTR4args *aobjp)
2419 {
2420 #ifdef INLINE
2421 uint32_t *ptr;
2422 #endif
2423 bitmap4 resbmap;
2424 uint32_t attrlen;
2425
2426 ASSERT(xdrs->x_op == XDR_DECODE);
2427
2428 /* Initialize objp attribute error values */
2429 objp->ga_res.n4g_attrerr =
2430 objp->ga_res.n4g_attrwhy = NFS4_GETATTR_OP_OK;
2431
2432 if (!xdr_bitmap4(xdrs, &resbmap))
2433 return (FALSE);
2434
2435 /* save the response bitmap for the caller */
2436 objp->ga_res.n4g_resbmap = resbmap;
2437
2438 /* attrlen */
2439 if (!XDR_GETINT32(xdrs, (int32_t *)&attrlen))
2440 return (FALSE);
2441
2442 /*
2443 * Handle case where request and response bitmaps don't match.
2444 */
2445 if (aobjp->attr_request && aobjp->attr_request != resbmap) {
2446 bitmap4 deltabmap;
2447
2448 /*
2449 * Return error for case where server sent extra attributes
2450 * because the "unknown" attributes may be anywhere in the
2451 * xdr stream and can't be properly processed.
2452 */
2453 deltabmap = ((aobjp->attr_request ^ resbmap) & resbmap);
2454 if (deltabmap) {
2455 objp->ga_res.n4g_attrerr = EINVAL;
2456 objp->ga_res.n4g_attrwhy = NFS4_GETATTR_BITMAP_ERR;
2457 return (TRUE);
2458 }
2459
2460 /*
2461 * Return error for case where there is a mandatory
2462 * attribute missing in the server response. Note that
2463 * missing recommended attributes are evaluated in the
2464 * specific routines that decode the server response.
2465 */
2466 deltabmap = ((aobjp->attr_request ^ resbmap)
2467 & aobjp->attr_request);
2468 if ((deltabmap & FATTR4_MANDATTR_MASK)) {
2469 objp->ga_res.n4g_attrerr = EINVAL;
2470 objp->ga_res.n4g_attrwhy = NFS4_GETATTR_MANDATTR_ERR;
2471 return (TRUE);
2472 }
2473 }
2474
2475 /* Check to see if the attrs can be inlined and go for it if so */
2476 #ifdef INLINE
2477 if (!(resbmap & FATTR4_ACL_MASK) &&
2478 (ptr = (uint32_t *)XDR_INLINE(xdrs, attrlen)) != NULL)
2479 return (xdr_ga_fattr_res_inline(ptr, &objp->ga_res,
2480 resbmap, aobjp->attr_request, aobjp->mi, NULL));
2481 else
2482 #endif
2483 return (xdr_ga_fattr_res(xdrs, &objp->ga_res,
2484 resbmap, aobjp->attr_request, aobjp->mi, NULL));
2485 }
2486
2487 #if defined(DEBUG) && !defined(lint)
2488 /*
2489 * We assume that an enum is a 32-bit value, check it once
2490 */
2491 static enum szchk { SZVAL } szchkvar;
2492 #endif
2493
2494 bool_t
2495 xdr_settime4(XDR *xdrs, settime4 *objp)
2496 {
2497 #if defined(DEBUG) && !defined(lint)
2498 ASSERT(sizeof (szchkvar) == sizeof (int32_t));
2499 #endif
2500 if (xdrs->x_op == XDR_FREE)
2501 return (TRUE);
2502
2503 if (!xdr_int(xdrs, (int *)&objp->set_it))
2504 return (FALSE);
2505 if (objp->set_it != SET_TO_CLIENT_TIME4)
2506 return (TRUE);
2507 /* xdr_nfstime4 */
2508 if (!xdr_longlong_t(xdrs, (longlong_t *)&objp->time.seconds))
2509 return (FALSE);
2510 return (xdr_u_int(xdrs, &objp->time.nseconds));
2511 }
2512
2513 static bool_t
2514 xdr_fattr4(XDR *xdrs, fattr4 *objp)
2515 {
2516 if (xdrs->x_op != XDR_FREE) {
2517 if (!xdr_bitmap4(xdrs, &objp->attrmask))
2518 return (FALSE);
2519 return (xdr_bytes(xdrs, (char **)&objp->attrlist4,
2520 (uint_t *)&objp->attrlist4_len, NFS4_FATTR4_LIMIT));
2521 }
2522
2523 /*
2524 * Optimized free case
2525 */
2526 if (objp->attrlist4 != NULL)
2527 kmem_free(objp->attrlist4, objp->attrlist4_len);
2528 return (TRUE);
2529 }
2530
2531 static bool_t
2532 xdr_ACCESS4res(XDR *xdrs, ACCESS4res *objp)
2533 {
2534 if (!xdr_int(xdrs, (int32_t *)&objp->status))
2535 return (FALSE);
2536 if (objp->status != NFS4_OK)
2537 return (TRUE);
2538 if (!xdr_u_int(xdrs, &objp->supported))
2539 return (FALSE);
2540 return (xdr_u_int(xdrs, &objp->access));
2541 }
2542
2543 static bool_t
2544 xdr_CLOSE4args(XDR *xdrs, CLOSE4args *objp)
2545 {
2546 if (!xdr_u_int(xdrs, &objp->seqid))
2547 return (FALSE);
2548 if (!xdr_u_int(xdrs, &objp->open_stateid.seqid))
2549 return (FALSE);
2550 return (xdr_opaque(xdrs, objp->open_stateid.other, NFS4_OTHER_SIZE));
2551 }
2552
2553 static bool_t
2554 xdr_CLOSE4res(XDR *xdrs, CLOSE4res *objp)
2555 {
2556 if (!xdr_int(xdrs, (int32_t *)&objp->status))
2557 return (FALSE);
2558 if (objp->status != NFS4_OK)
2559 return (TRUE);
2560 if (!xdr_u_int(xdrs, &objp->open_stateid.seqid))
2561 return (FALSE);
2562 return (xdr_opaque(xdrs, objp->open_stateid.other, NFS4_OTHER_SIZE));
2563 }
2564
2565 static bool_t
2566 xdr_CREATE4args(XDR *xdrs, CREATE4args *objp)
2567 {
2568 if (xdrs->x_op != XDR_FREE) {
2569 if (!xdr_int(xdrs, (int32_t *)&objp->type))
2570 return (FALSE);
2571 switch (objp->type) {
2572 case NF4LNK:
2573 if (!xdr_bytes(xdrs,
2574 (char **)&objp->ftype4_u.linkdata.linktext4_val,
2575 (uint_t *)&objp->ftype4_u.linkdata.linktext4_len,
2576 NFS4_MAX_UTF8STRING))
2577 return (FALSE);
2578 break;
2579 case NF4BLK:
2580 case NF4CHR:
2581 if (!xdr_u_int(xdrs, &objp->ftype4_u.devdata.specdata1))
2582 return (FALSE);
2583 if (!xdr_u_int(xdrs, &objp->ftype4_u.devdata.specdata2))
2584 return (FALSE);
2585 break;
2586 case NF4SOCK:
2587 case NF4FIFO:
2588 case NF4DIR:
2589 default:
2590 break; /* server should return NFS4ERR_BADTYPE */
2591 }
2592 if (!xdr_bytes(xdrs, (char **)&objp->objname.utf8string_val,
2593 (uint_t *)&objp->objname.utf8string_len,
2594 NFS4_MAX_UTF8STRING))
2595 return (FALSE);
2596 return (xdr_fattr4(xdrs, &objp->createattrs));
2597 }
2598
2599 /*
2600 * Optimized free case
2601 */
2602 if (objp->type == NF4LNK) {
2603 if (objp->ftype4_u.linkdata.linktext4_val != NULL)
2604 kmem_free(objp->ftype4_u.linkdata.linktext4_val,
2605 objp->ftype4_u.linkdata.linktext4_len);
2606 }
2607 if (objp->objname.utf8string_val != NULL)
2608 kmem_free(objp->objname.utf8string_val,
2609 objp->objname.utf8string_len);
2610 return (xdr_fattr4(xdrs, &objp->createattrs));
2611 }
2612
2613 static bool_t
2614 xdr_CREATE4cargs(XDR *xdrs, CREATE4cargs *objp)
2615 {
2616 int len;
2617
2618 ASSERT(xdrs->x_op == XDR_ENCODE);
2619
2620 if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->type))
2621 return (FALSE);
2622 switch (objp->type) {
2623 case NF4LNK:
2624 len = strlen(objp->ftype4_u.clinkdata);
2625 if (len > NFS4_MAX_UTF8STRING)
2626 return (FALSE);
2627 if (!XDR_PUTINT32(xdrs, &len))
2628 return (FALSE);
2629 if (!xdr_opaque(xdrs, objp->ftype4_u.clinkdata, len))
2630 return (FALSE);
2631 break;
2632 case NF4BLK:
2633 case NF4CHR:
2634 if (!XDR_PUTINT32(xdrs,
2635 (int32_t *)&objp->ftype4_u.devdata.specdata1))
2636 return (FALSE);
2637 if (!XDR_PUTINT32(xdrs,
2638 (int32_t *)&objp->ftype4_u.devdata.specdata2))
2639 return (FALSE);
2640 break;
2641 case NF4SOCK:
2642 case NF4FIFO:
2643 case NF4DIR:
2644 default:
2645 break; /* server should return NFS4ERR_BADTYPE */
2646 }
2647
2648 len = strlen(objp->cname);
2649 if (len > NFS4_MAX_UTF8STRING)
2650 return (FALSE);
2651 if (!XDR_PUTINT32(xdrs, &len))
2652 return (FALSE);
2653 if (!xdr_opaque(xdrs, objp->cname, len))
2654 return (FALSE);
2655
2656 return (xdr_fattr4(xdrs, &objp->createattrs));
2657 }
2658
2659 static bool_t
2660 xdr_CREATE4res(XDR *xdrs, CREATE4res *objp)
2661 {
2662 if (!xdr_int(xdrs, (int32_t *)&objp->status))
2663 return (FALSE);
2664 if (objp->status != NFS4_OK)
2665 return (TRUE);
2666 if (!xdr_bool(xdrs, &objp->cinfo.atomic))
2667 return (FALSE);
2668 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.before))
2669 return (FALSE);
2670 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.after))
2671 return (FALSE);
2672 return (xdr_bitmap4(xdrs, &objp->attrset));
2673 }
2674
2675 static bool_t
2676 xdr_LINK4res(XDR *xdrs, LINK4res *objp)
2677 {
2678 if (!xdr_int(xdrs, (int32_t *)&objp->status))
2679 return (FALSE);
2680 if (objp->status != NFS4_OK)
2681 return (TRUE);
2682 if (!xdr_bool(xdrs, &objp->cinfo.atomic))
2683 return (FALSE);
2684 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.before))
2685 return (FALSE);
2686 return (xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.after));
2687 }
2688
2689 static bool_t
2690 xdr_LOCK4args(XDR *xdrs, LOCK4args *objp)
2691 {
2692 if (xdrs->x_op != XDR_FREE) {
2693 if (!xdr_int(xdrs, (int *)&objp->locktype))
2694 return (FALSE);
2695 if (!xdr_bool(xdrs, &objp->reclaim))
2696 return (FALSE);
2697 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->offset))
2698 return (FALSE);
2699 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->length))
2700 return (FALSE);
2701 if (!xdr_bool(xdrs, &objp->locker.new_lock_owner))
2702 return (FALSE);
2703 if (objp->locker.new_lock_owner == TRUE) {
2704 if (!xdr_u_int(xdrs, &objp->locker.locker4_u.open_owner.
2705 open_seqid))
2706 return (FALSE);
2707 if (!xdr_u_int(xdrs, &objp->locker.locker4_u.open_owner.
2708 open_stateid.seqid))
2709 return (FALSE);
2710 if (!xdr_opaque(xdrs, objp->locker.locker4_u.open_owner.
2711 open_stateid.other, NFS4_OTHER_SIZE))
2712 return (FALSE);
2713 if (!xdr_u_int(xdrs, &objp->locker.locker4_u.open_owner.
2714 lock_seqid))
2715 return (FALSE);
2716 if (!xdr_u_longlong_t(xdrs,
2717 (u_longlong_t *)&objp->locker.locker4_u.
2718 open_owner.lock_owner.clientid))
2719 return (FALSE);
2720 return (xdr_bytes(xdrs,
2721 (char **)&objp->locker.locker4_u.open_owner.
2722 lock_owner.owner_val,
2723 (uint_t *)&objp->locker.locker4_u.open_owner.
2724 lock_owner.owner_len,
2725 NFS4_OPAQUE_LIMIT));
2726 }
2727
2728 if (objp->locker.new_lock_owner != FALSE)
2729 return (FALSE);
2730
2731 if (!xdr_u_int(xdrs, &objp->locker.locker4_u.lock_owner.
2732 lock_stateid.seqid))
2733 return (FALSE);
2734 if (!xdr_opaque(xdrs, objp->locker.locker4_u.lock_owner.
2735 lock_stateid.other, NFS4_OTHER_SIZE))
2736 return (FALSE);
2737 return (xdr_u_int(xdrs, &objp->locker.locker4_u.lock_owner.
2738 lock_seqid));
2739 }
2740
2741 /*
2742 * Optimized free case
2743 */
2744 if (objp->locker.new_lock_owner == TRUE) {
2745 if (objp->locker.locker4_u.open_owner.lock_owner.owner_val !=
2746 NULL) {
2747 kmem_free(objp->locker.locker4_u.open_owner.lock_owner.
2748 owner_val,
2749 objp->locker.locker4_u.open_owner.lock_owner.
2750 owner_len);
2751 }
2752 }
2753
2754 return (TRUE);
2755 }
2756
2757 static bool_t
2758 xdr_LOCK4res(XDR *xdrs, LOCK4res *objp)
2759 {
2760 if (xdrs->x_op != XDR_FREE) {
2761 if (!xdr_int(xdrs, (int32_t *)&objp->status))
2762 return (FALSE);
2763 if (objp->status == NFS4_OK) {
2764 if (!xdr_u_int(xdrs,
2765 &objp->LOCK4res_u.lock_stateid.seqid))
2766 return (FALSE);
2767 return (xdr_opaque(xdrs,
2768 objp->LOCK4res_u.lock_stateid.other,
2769 NFS4_OTHER_SIZE));
2770 }
2771 if (objp->status != NFS4ERR_DENIED)
2772 return (TRUE);
2773
2774 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->LOCK4res_u.
2775 denied.offset))
2776 return (FALSE);
2777 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->LOCK4res_u.
2778 denied.length))
2779 return (FALSE);
2780 if (!xdr_int(xdrs, (int *)&objp->LOCK4res_u.denied.locktype))
2781 return (FALSE);
2782 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->LOCK4res_u.
2783 denied.owner.clientid))
2784 return (FALSE);
2785 return (xdr_bytes(xdrs,
2786 (char **)&objp->LOCK4res_u.denied.owner.owner_val,
2787 (uint_t *)&objp->LOCK4res_u.denied.owner.owner_len,
2788 NFS4_OPAQUE_LIMIT));
2789 }
2790
2791 /*
2792 * Optimized free case
2793 */
2794 if (objp->status == NFS4_OK || objp->status != NFS4ERR_DENIED)
2795 return (TRUE);
2796
2797 if (objp->LOCK4res_u.denied.owner.owner_val != NULL)
2798 kmem_free(objp->LOCK4res_u.denied.owner.owner_val,
2799 objp->LOCK4res_u.denied.owner.owner_len);
2800 return (TRUE);
2801 }
2802
2803 static bool_t
2804 xdr_LOCKT4args(XDR *xdrs, LOCKT4args *objp)
2805 {
2806 if (xdrs->x_op != XDR_FREE) {
2807 if (!xdr_int(xdrs, (int *)&objp->locktype))
2808 return (FALSE);
2809 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->offset))
2810 return (FALSE);
2811 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->length))
2812 return (FALSE);
2813 if (!xdr_u_longlong_t(xdrs,
2814 (u_longlong_t *)&objp->owner.clientid))
2815 return (FALSE);
2816 return (xdr_bytes(xdrs, (char **)&objp->owner.owner_val,
2817 (uint_t *)&objp->owner.owner_len,
2818 NFS4_OPAQUE_LIMIT));
2819 }
2820
2821 /*
2822 * Optimized free case
2823 */
2824 if (objp->owner.owner_val != NULL)
2825 kmem_free(objp->owner.owner_val, objp->owner.owner_len);
2826 return (TRUE);
2827 }
2828
2829 static bool_t
2830 xdr_LOCKT4res(XDR *xdrs, LOCKT4res *objp)
2831 {
2832 if (xdrs->x_op != XDR_FREE) {
2833 if (!xdr_int(xdrs, (int32_t *)&objp->status))
2834 return (FALSE);
2835 if (objp->status == NFS4_OK)
2836 return (TRUE);
2837 if (objp->status != NFS4ERR_DENIED)
2838 return (TRUE);
2839 /* xdr_LOCK4denied */
2840 if (!xdr_u_longlong_t(xdrs,
2841 (u_longlong_t *)&objp->denied.offset))
2842 return (FALSE);
2843 if (!xdr_u_longlong_t(xdrs,
2844 (u_longlong_t *)&objp->denied.length))
2845 return (FALSE);
2846 if (!xdr_int(xdrs, (int *)&objp->denied.locktype))
2847 return (FALSE);
2848 if (!xdr_u_longlong_t(xdrs,
2849 (u_longlong_t *)&objp->denied.owner.clientid))
2850 return (FALSE);
2851 return (xdr_bytes(xdrs,
2852 (char **)&objp->denied.owner.owner_val,
2853 (uint_t *)&objp->denied.owner.owner_len,
2854 NFS4_OPAQUE_LIMIT));
2855 }
2856
2857 /*
2858 * Optimized free case
2859 */
2860 if (objp->status == NFS4_OK || objp->status != NFS4ERR_DENIED)
2861 return (TRUE);
2862 if (objp->denied.owner.owner_val != NULL)
2863 kmem_free(objp->denied.owner.owner_val,
2864 objp->denied.owner.owner_len);
2865 return (TRUE);
2866 }
2867
2868 static bool_t
2869 xdr_LOCKU4args(XDR *xdrs, LOCKU4args *objp)
2870 {
2871 if (!xdr_int(xdrs, (int *)&objp->locktype))
2872 return (FALSE);
2873 if (!xdr_u_int(xdrs, &objp->seqid))
2874 return (FALSE);
2875 if (!xdr_u_int(xdrs, &objp->lock_stateid.seqid))
2876 return (FALSE);
2877 if (!xdr_opaque(xdrs, objp->lock_stateid.other, NFS4_OTHER_SIZE))
2878 return (FALSE);
2879 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->offset))
2880 return (FALSE);
2881 return (xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->length));
2882 }
2883
2884 static bool_t
2885 xdr_OPEN4args(XDR *xdrs, OPEN4args *objp)
2886 {
2887 if (xdrs->x_op != XDR_FREE) {
2888 if (!xdr_u_int(xdrs, &objp->seqid))
2889 return (FALSE);
2890 if (!xdr_u_int(xdrs, &objp->share_access))
2891 return (FALSE);
2892 if (!xdr_u_int(xdrs, &objp->share_deny))
2893 return (FALSE);
2894
2895 /* xdr_open_owner4 */
2896 if (!xdr_u_longlong_t(xdrs,
2897 (u_longlong_t *)&objp->owner.clientid))
2898 return (FALSE);
2899 if (!xdr_bytes(xdrs, (char **)&objp->owner.owner_val,
2900 (uint_t *)&objp->owner.owner_len,
2901 NFS4_OPAQUE_LIMIT))
2902 return (FALSE);
2903
2904 /* xdr_openflag4 */
2905 if (!xdr_int(xdrs, (int *)&objp->opentype))
2906 return (FALSE);
2907 if (objp->opentype == OPEN4_CREATE) {
2908
2909 /* xdr_createhow4 */
2910 if (!xdr_int(xdrs, (int *)&objp->mode))
2911 return (FALSE);
2912 switch (objp->mode) {
2913 case UNCHECKED4:
2914 case GUARDED4:
2915 if (!xdr_fattr4(xdrs,
2916 &objp->createhow4_u.createattrs))
2917 return (FALSE);
2918 break;
2919 case EXCLUSIVE4:
2920 if (!xdr_u_longlong_t(xdrs,
2921 (u_longlong_t *)&objp->createhow4_u.
2922 createverf))
2923 return (FALSE);
2924 break;
2925 default:
2926 return (FALSE);
2927 }
2928 }
2929
2930 /* xdr_open_claim4 */
2931 if (!xdr_int(xdrs, (int *)&objp->claim))
2932 return (FALSE);
2933
2934 switch (objp->claim) {
2935 case CLAIM_NULL:
2936 return (xdr_bytes(xdrs, (char **)&objp->open_claim4_u.
2937 file.utf8string_val,
2938 (uint_t *)&objp->open_claim4_u.file.
2939 utf8string_len,
2940 NFS4_MAX_UTF8STRING));
2941 case CLAIM_PREVIOUS:
2942 return (xdr_int(xdrs,
2943 (int *)&objp->open_claim4_u.delegate_type));
2944 case CLAIM_DELEGATE_CUR:
2945 if (!xdr_u_int(xdrs, (uint_t *)&objp->open_claim4_u.
2946 delegate_cur_info.delegate_stateid.seqid))
2947 return (FALSE);
2948 if (!xdr_opaque(xdrs, objp->open_claim4_u.
2949 delegate_cur_info.delegate_stateid.other,
2950 NFS4_OTHER_SIZE))
2951 return (FALSE);
2952 return (xdr_bytes(xdrs, (char **)&objp->open_claim4_u.
2953 delegate_cur_info.file.utf8string_val,
2954 (uint_t *)&objp->open_claim4_u.
2955 delegate_cur_info.file.utf8string_len,
2956 NFS4_MAX_UTF8STRING));
2957 case CLAIM_DELEGATE_PREV:
2958 return (xdr_bytes(xdrs, (char **)&objp->open_claim4_u.
2959 file_delegate_prev.utf8string_val,
2960 (uint_t *)&objp->open_claim4_u.
2961 file_delegate_prev.utf8string_len,
2962 NFS4_MAX_UTF8STRING));
2963 default:
2964 return (FALSE);
2965 }
2966 }
2967
2968 /*
2969 * Optimized free case
2970 */
2971 if (objp->owner.owner_val != NULL)
2972 kmem_free(objp->owner.owner_val, objp->owner.owner_len);
2973
2974 if (objp->opentype == OPEN4_CREATE) {
2975 switch (objp->mode) {
2976 case UNCHECKED4:
2977 case GUARDED4:
2978 (void) xdr_fattr4(xdrs,
2979 &objp->createhow4_u.createattrs);
2980 break;
2981 case EXCLUSIVE4:
2982 default:
2983 break;
2984 }
2985 }
2986
2987 switch (objp->claim) {
2988 case CLAIM_NULL:
2989 if (objp->open_claim4_u.file.utf8string_val != NULL)
2990 kmem_free(objp->open_claim4_u.file.utf8string_val,
2991 objp->open_claim4_u.file.utf8string_len);
2992 return (TRUE);
2993 case CLAIM_PREVIOUS:
2994 return (TRUE);
2995 case CLAIM_DELEGATE_CUR:
2996 if (objp->open_claim4_u.delegate_cur_info.file.utf8string_val !=
2997 NULL) {
2998 kmem_free(objp->open_claim4_u.delegate_cur_info.file.
2999 utf8string_val,
3000 objp->open_claim4_u.delegate_cur_info.file.
3001 utf8string_len);
3002 }
3003 return (TRUE);
3004 case CLAIM_DELEGATE_PREV:
3005 if (objp->open_claim4_u.file_delegate_prev.utf8string_val !=
3006 NULL) {
3007 kmem_free(objp->open_claim4_u.file_delegate_prev.
3008 utf8string_val,
3009 objp->open_claim4_u.file_delegate_prev.
3010 utf8string_len);
3011 }
3012 return (TRUE);
3013 default:
3014 return (TRUE);
3015 }
3016 }
3017
3018 static bool_t
3019 xdr_OPEN4cargs(XDR *xdrs, OPEN4cargs *objp)
3020 {
3021 int op;
3022 int len;
3023 rpc_inline_t *ptr;
3024
3025 ASSERT(xdrs->x_op == XDR_ENCODE);
3026
3027 /*
3028 * We must always define the client's open_owner to be
3029 * 4 byte aligned and sized.
3030 */
3031 ASSERT(objp->owner.owner_len <= NFS4_OPAQUE_LIMIT);
3032 ASSERT(!(objp->owner.owner_len % BYTES_PER_XDR_UNIT));
3033
3034 len = objp->owner.owner_len;
3035 if ((ptr = XDR_INLINE(xdrs, 8 * BYTES_PER_XDR_UNIT + len)) != NULL) {
3036 int i;
3037 int32_t *ip;
3038
3039 IXDR_PUT_U_INT32(ptr, OP_OPEN);
3040 IXDR_PUT_U_INT32(ptr, objp->seqid);
3041 IXDR_PUT_U_INT32(ptr, objp->share_access);
3042 IXDR_PUT_U_INT32(ptr, objp->share_deny);
3043
3044 /* xdr_open_owner4 */
3045 IXDR_PUT_HYPER(ptr, objp->owner.clientid);
3046 IXDR_PUT_U_INT32(ptr, objp->owner.owner_len);
3047 /* We know this is very short so don't bcopy */
3048 ip = (int32_t *)objp->owner.owner_val;
3049 len /= BYTES_PER_XDR_UNIT;
3050 for (i = 0; i < len; i++)
3051 *ptr++ = *ip++;
3052
3053 /* xdr_openflag4 */
3054 IXDR_PUT_U_INT32(ptr, objp->opentype);
3055 } else {
3056 op = OP_OPEN;
3057 if (!XDR_PUTINT32(xdrs, (int32_t *)&op))
3058 return (FALSE);
3059 if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->seqid))
3060 return (FALSE);
3061 if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->share_access))
3062 return (FALSE);
3063 if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->share_deny))
3064 return (FALSE);
3065
3066 /* xdr_open_owner4 */
3067 if (!xdr_u_longlong_t(xdrs,
3068 (u_longlong_t *)&objp->owner.clientid))
3069 return (FALSE);
3070 if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->owner.owner_len))
3071 return (FALSE);
3072 if (!xdr_opaque(xdrs, objp->owner.owner_val,
3073 objp->owner.owner_len))
3074 return (FALSE);
3075
3076 /* xdr_openflag4 */
3077 if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->opentype))
3078 return (FALSE);
3079 }
3080
3081 if (objp->opentype == OPEN4_CREATE) {
3082 /* xdr_createhow4 */
3083 if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->mode))
3084 return (FALSE);
3085 switch (objp->mode) {
3086 case UNCHECKED4:
3087 case GUARDED4:
3088 if (!xdr_fattr4(xdrs,
3089 &objp->createhow4_u.createattrs))
3090 return (FALSE);
3091 break;
3092 case EXCLUSIVE4:
3093 if (!xdr_u_longlong_t(xdrs,
3094 (u_longlong_t *)&objp->createhow4_u.
3095 createverf))
3096 return (FALSE);
3097 break;
3098 default:
3099 return (FALSE);
3100 }
3101 }
3102
3103 /* xdr_open_claim4 */
3104 if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->claim))
3105 return (FALSE);
3106
3107 switch (objp->claim) {
3108 case CLAIM_NULL:
3109 len = strlen(objp->open_claim4_u.cfile);
3110 if (len > NFS4_MAX_UTF8STRING)
3111 return (FALSE);
3112 if (XDR_PUTINT32(xdrs, &len)) {
3113 return (xdr_opaque(xdrs,
3114 objp->open_claim4_u.cfile, len));
3115 }
3116 return (FALSE);
3117 case CLAIM_PREVIOUS:
3118 return (XDR_PUTINT32(xdrs,
3119 (int32_t *)&objp->open_claim4_u.delegate_type));
3120 case CLAIM_DELEGATE_CUR:
3121 if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->open_claim4_u.
3122 delegate_cur_info.delegate_stateid.seqid))
3123 return (FALSE);
3124 if (!xdr_opaque(xdrs, objp->open_claim4_u.
3125 delegate_cur_info.delegate_stateid.other,
3126 NFS4_OTHER_SIZE))
3127 return (FALSE);
3128 len = strlen(objp->open_claim4_u.delegate_cur_info.cfile);
3129 if (len > NFS4_MAX_UTF8STRING)
3130 return (FALSE);
3131 if (XDR_PUTINT32(xdrs, &len)) {
3132 return (xdr_opaque(xdrs,
3133 objp->open_claim4_u.delegate_cur_info.cfile,
3134 len));
3135 }
3136 return (FALSE);
3137 case CLAIM_DELEGATE_PREV:
3138 len = strlen(objp->open_claim4_u.cfile_delegate_prev);
3139 if (len > NFS4_MAX_UTF8STRING)
3140 return (FALSE);
3141 if (XDR_PUTINT32(xdrs, &len)) {
3142 return (xdr_opaque(xdrs,
3143 objp->open_claim4_u.cfile_delegate_prev, len));
3144 }
3145 return (FALSE);
3146 default:
3147 return (FALSE);
3148 }
3149 }
3150
3151 static bool_t
3152 xdr_OPEN4res(XDR *xdrs, OPEN4res *objp)
3153 {
3154 if (xdrs->x_op != XDR_FREE) {
3155 if (!xdr_int(xdrs, (int32_t *)&objp->status))
3156 return (FALSE);
3157 if (objp->status != NFS4_OK)
3158 return (TRUE);
3159 if (!xdr_u_int(xdrs, &objp->stateid.seqid))
3160 return (FALSE);
3161 if (!xdr_opaque(xdrs, objp->stateid.other, NFS4_OTHER_SIZE))
3162 return (FALSE);
3163 if (!xdr_bool(xdrs, &objp->cinfo.atomic))
3164 return (FALSE);
3165 if (!xdr_u_longlong_t(xdrs,
3166 (u_longlong_t *)&objp->cinfo.before))
3167 return (FALSE);
3168 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.after))
3169 return (FALSE);
3170 if (!xdr_u_int(xdrs, &objp->rflags))
3171 return (FALSE);
3172 if (!xdr_bitmap4(xdrs, &objp->attrset))
3173 return (FALSE);
3174 if (!xdr_int(xdrs,
3175 (int *)&objp->delegation.delegation_type))
3176 return (FALSE);
3177 switch (objp->delegation.delegation_type) {
3178 case OPEN_DELEGATE_NONE:
3179 return (TRUE);
3180 case OPEN_DELEGATE_READ:
3181 if (!xdr_u_int(xdrs, &objp->delegation.
3182 open_delegation4_u.read.stateid.seqid))
3183 return (FALSE);
3184 if (!xdr_opaque(xdrs, objp->delegation.
3185 open_delegation4_u.read.stateid.other,
3186 NFS4_OTHER_SIZE))
3187 return (FALSE);
3188 if (!xdr_bool(xdrs, &objp->delegation.
3189 open_delegation4_u.read.recall))
3190 return (FALSE);
3191 return (xdr_nfsace4(xdrs, &objp->delegation.
3192 open_delegation4_u.read.permissions));
3193 case OPEN_DELEGATE_WRITE:
3194 if (!xdr_u_int(xdrs, &objp->delegation.
3195 open_delegation4_u.write.stateid.seqid))
3196 return (FALSE);
3197 if (!xdr_opaque(xdrs, objp->delegation.
3198 open_delegation4_u.write.stateid.other,
3199 NFS4_OTHER_SIZE))
3200 return (FALSE);
3201 if (!xdr_bool(xdrs, &objp->delegation.
3202 open_delegation4_u.write.recall))
3203 return (FALSE);
3204 if (!xdr_int(xdrs, (int *)&objp->delegation.
3205 open_delegation4_u.write.space_limit.
3206 limitby))
3207 return (FALSE);
3208 switch (objp->delegation.
3209 open_delegation4_u.write.space_limit.
3210 limitby) {
3211 case NFS_LIMIT_SIZE:
3212 if (!xdr_u_longlong_t(xdrs,
3213 (u_longlong_t *)&objp->delegation.
3214 open_delegation4_u.write.space_limit.
3215 nfs_space_limit4_u.filesize))
3216 return (FALSE);
3217 break;
3218 case NFS_LIMIT_BLOCKS:
3219 if (!xdr_u_int(xdrs,
3220 &objp->delegation.open_delegation4_u.write.
3221 space_limit.nfs_space_limit4_u.
3222 mod_blocks.num_blocks))
3223 return (FALSE);
3224 if (!xdr_u_int(xdrs, &objp->delegation.
3225 open_delegation4_u.write.space_limit.
3226 nfs_space_limit4_u.mod_blocks.
3227 bytes_per_block))
3228 return (FALSE);
3229 break;
3230 default:
3231 return (FALSE);
3232 }
3233 return (xdr_nfsace4(xdrs, &objp->delegation.
3234 open_delegation4_u.write.permissions));
3235 }
3236 return (FALSE);
3237 }
3238
3239 /*
3240 * Optimized free case
3241 */
3242 if (objp->status != NFS4_OK)
3243 return (TRUE);
3244
3245 switch (objp->delegation.delegation_type) {
3246 case OPEN_DELEGATE_NONE:
3247 return (TRUE);
3248 case OPEN_DELEGATE_READ:
3249 return (xdr_nfsace4(xdrs, &objp->delegation.
3250 open_delegation4_u.read.permissions));
3251 case OPEN_DELEGATE_WRITE:
3252 switch (objp->delegation.
3253 open_delegation4_u.write.space_limit.limitby) {
3254 case NFS_LIMIT_SIZE:
3255 case NFS_LIMIT_BLOCKS:
3256 break;
3257 default:
3258 return (FALSE);
3259 }
3260 return (xdr_nfsace4(xdrs, &objp->delegation.
3261 open_delegation4_u.write.permissions));
3262 }
3263 return (FALSE);
3264 }
3265
3266 static bool_t
3267 xdr_OPEN_CONFIRM4res(XDR *xdrs, OPEN_CONFIRM4res *objp)
3268 {
3269 if (!xdr_int(xdrs, (int32_t *)&objp->status))
3270 return (FALSE);
3271 if (objp->status != NFS4_OK)
3272 return (TRUE);
3273 if (!xdr_u_int(xdrs, &objp->open_stateid.seqid))
3274 return (FALSE);
3275 return (xdr_opaque(xdrs, objp->open_stateid.other, NFS4_OTHER_SIZE));
3276 }
3277
3278 static bool_t
3279 xdr_OPEN_DOWNGRADE4args(XDR *xdrs, OPEN_DOWNGRADE4args *objp)
3280 {
3281 if (!xdr_u_int(xdrs, &objp->open_stateid.seqid))
3282 return (FALSE);
3283 if (!xdr_opaque(xdrs, objp->open_stateid.other, NFS4_OTHER_SIZE))
3284 return (FALSE);
3285 if (!xdr_u_int(xdrs, &objp->seqid))
3286 return (FALSE);
3287 if (!xdr_u_int(xdrs, &objp->share_access))
3288 return (FALSE);
3289 return (xdr_u_int(xdrs, &objp->share_deny));
3290 }
3291
3292 static bool_t
3293 xdr_OPEN_DOWNGRADE4res(XDR *xdrs, OPEN_DOWNGRADE4res *objp)
3294 {
3295 if (!xdr_int(xdrs, (int32_t *)&objp->status))
3296 return (FALSE);
3297 if (objp->status != NFS4_OK)
3298 return (TRUE);
3299 if (!xdr_u_int(xdrs, &objp->open_stateid.seqid))
3300 return (FALSE);
3301 return (xdr_opaque(xdrs, objp->open_stateid.other, NFS4_OTHER_SIZE));
3302 }
3303
3304 static bool_t
3305 xdr_READ4args(XDR *xdrs, READ4args *objp)
3306 {
3307 rdma_chunkinfo_t rci;
3308 rdma_wlist_conn_info_t rwci;
3309 struct xdr_ops *xops = xdrrdma_xops();
3310
3311 if (!xdr_u_int(xdrs, &objp->stateid.seqid))
3312 return (FALSE);
3313 if (!xdr_opaque(xdrs, objp->stateid.other, NFS4_OTHER_SIZE))
3314 return (FALSE);
3315 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->offset))
3316 return (FALSE);
3317 if (!xdr_u_int(xdrs, &objp->count))
3318 return (FALSE);
3319
3320 DTRACE_PROBE1(xdr__i__read4args_buf_len,
3321 int, objp->count);
3322
3323 objp->wlist = NULL;
3324
3325 if (xdrs->x_ops == xops && xdrs->x_op == XDR_ENCODE) {
3326 rci.rci_type = RCI_WRITE_ADDR_CHUNK;
3327 rci.rci_len = objp->count;
3328 (void) XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
3329 }
3330
3331 if (xdrs->x_ops != &xdrrdma_ops || xdrs->x_op == XDR_FREE)
3332 return (TRUE);
3333
3334 if (xdrs->x_op == XDR_ENCODE) {
3335 if (objp->res_uiop != NULL) {
3336 rci.rci_type = RCI_WRITE_UIO_CHUNK;
3337 rci.rci_a.rci_uiop = objp->res_uiop;
3338 rci.rci_len = objp->count;
3339 rci.rci_clpp = &objp->wlist;
3340 } else {
3341 rci.rci_type = RCI_WRITE_ADDR_CHUNK;
3342 rci.rci_a.rci_addr = objp->res_data_val_alt;
3343 rci.rci_len = objp->count;
3344 rci.rci_clpp = &objp->wlist;
3345 }
3346
3347 return (XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci));
3348 }
3349
3350 /* XDR_DECODE case */
3351 (void) XDR_CONTROL(xdrs, XDR_RDMA_GET_WCINFO, &rwci);
3352 objp->wlist = rwci.rwci_wlist;
3353 objp->conn = rwci.rwci_conn;
3354
3355 return (TRUE);
3356 }
3357
3358 static bool_t
3359 xdr_READ4res(XDR *xdrs, READ4res *objp)
3360 {
3361 mblk_t *mp;
3362
3363 if (xdrs->x_op == XDR_DECODE)
3364 return (FALSE);
3365
3366 if (xdrs->x_op == XDR_FREE) {
3367 /*
3368 * Optimized free case
3369 */
3370 if (objp->status != NFS4_OK)
3371 return (TRUE);
3372 if (objp->data_val != NULL)
3373 kmem_free(objp->data_val, objp->data_len);
3374 return (TRUE);
3375 }
3376
3377 /* on with ENCODE paths */
3378 if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->status))
3379 return (FALSE);
3380 if (objp->status != NFS4_OK)
3381 return (TRUE);
3382
3383 if (!XDR_PUTINT32(xdrs, &objp->eof))
3384 return (FALSE);
3385
3386 mp = objp->mblk;
3387 if (mp != NULL) {
3388 if (xdrs->x_ops == &xdrmblk_ops) {
3389 if (xdrmblk_putmblk(xdrs, mp, objp->data_len)) {
3390 objp->mblk = NULL;
3391 return (TRUE);
3392 } else {
3393 return (FALSE);
3394 }
3395 } else if (mp->b_cont != NULL) {
3396 /*
3397 * See xdr_READ3res() for an explanation of why we need
3398 * to do a pullup here.
3399 */
3400 if (pullupmsg(mp, -1) == 0)
3401 return (FALSE);
3402 objp->data_val = (caddr_t)mp->b_rptr;
3403 }
3404 } else {
3405 if (xdr_u_int(xdrs, &objp->data_len) == FALSE) {
3406 return (FALSE);
3407 }
3408 /*
3409 * If read data sent by wlist (RDMA_WRITE), don't do
3410 * xdr_bytes() below. RDMA_WRITE transfers the data.
3411 * Note: this is encode-only because the client code
3412 * uses xdr_READ4res_clnt to decode results.
3413 */
3414 if (objp->wlist) {
3415 if (objp->data_len != 0) {
3416 return (xdrrdma_send_read_data(
3417 xdrs, objp->data_len, objp->wlist));
3418 }
3419 return (TRUE);
3420 }
3421 }
3422
3423 return (xdr_bytes(xdrs, (char **)&objp->data_val,
3424 (uint_t *)&objp->data_len,
3425 objp->data_len));
3426 }
3427
3428 static bool_t
3429 xdr_READ4res_clnt(XDR *xdrs, READ4res *objp, READ4args *aobjp)
3430 {
3431 mblk_t *mp;
3432 size_t n;
3433 int error;
3434 uint_t size = aobjp->res_maxsize;
3435 count4 ocount;
3436
3437 if (xdrs->x_op == XDR_ENCODE)
3438 return (FALSE);
3439
3440 if (xdrs->x_op == XDR_FREE) {
3441 /*
3442 * Optimized free case
3443 */
3444 if (objp->status != NFS4_OK)
3445 return (TRUE);
3446 if (objp->data_val != NULL)
3447 kmem_free(objp->data_val, objp->data_len);
3448 return (TRUE);
3449 }
3450
3451 if (!XDR_GETINT32(xdrs, (int32_t *)&objp->status))
3452 return (FALSE);
3453 if (objp->status != NFS4_OK)
3454 return (TRUE);
3455
3456 if (!XDR_GETINT32(xdrs, &objp->eof))
3457 return (FALSE);
3458
3459
3460 /*
3461 * This is a special case such that the caller is providing a
3462 * uio as a guide to eventual data location; this is used for
3463 * handling DIRECTIO reads.
3464 */
3465 if (aobjp->res_uiop != NULL) {
3466 struct uio *uiop = aobjp->res_uiop;
3467 int32_t *ptr;
3468
3469 if (xdrs->x_ops == &xdrmblk_ops) {
3470 if (!xdrmblk_getmblk(xdrs, &mp, &objp->data_len))
3471 return (FALSE);
3472
3473 if (objp->data_len == 0)
3474 return (TRUE);
3475
3476 if (objp->data_len > size)
3477 return (FALSE);
3478
3479 size = objp->data_len;
3480 do {
3481 n = MIN(size, mp->b_wptr - mp->b_rptr);
3482 if ((n = MIN(uiop->uio_resid, n)) != 0) {
3483
3484 error = uiomove((char *)mp->b_rptr, n,
3485 UIO_READ, uiop);
3486 if (error)
3487 return (FALSE);
3488 mp->b_rptr += n;
3489 size -= n;
3490 }
3491
3492 while (mp && (mp->b_rptr >= mp->b_wptr))
3493 mp = mp->b_cont;
3494 } while (mp && size > 0 && uiop->uio_resid > 0);
3495
3496 return (TRUE);
3497 }
3498
3499 if (xdrs->x_ops == &xdrrdma_ops) {
3500 struct clist *cl;
3501
3502 XDR_CONTROL(xdrs, XDR_RDMA_GET_WLIST, &cl);
3503
3504 objp->wlist = cl;
3505
3506 if (objp->wlist) {
3507 /* opaque count */
3508 if (!xdr_u_int(xdrs, &ocount)) {
3509 objp->wlist = NULL;
3510 return (FALSE);
3511 }
3512
3513 objp->wlist_len = clist_len(cl);
3514 objp->data_len = ocount;
3515
3516 if (objp->wlist_len !=
3517 roundup(
3518 objp->data_len, BYTES_PER_XDR_UNIT)) {
3519 DTRACE_PROBE2(
3520 xdr__e__read4resuio_clnt_fail,
3521 int, ocount,
3522 int, objp->data_len);
3523 objp->wlist = NULL;
3524 return (FALSE);
3525 }
3526
3527 uiop->uio_resid -= objp->data_len;
3528 uiop->uio_iov->iov_len -= objp->data_len;
3529 uiop->uio_iov->iov_base += objp->data_len;
3530 uiop->uio_loffset += objp->data_len;
3531
3532 objp->wlist = NULL;
3533 return (TRUE);
3534 }
3535 }
3536
3537 /*
3538 * This isn't an xdrmblk stream nor RDMA.
3539 * Handle the likely case that it can be
3540 * inlined (ex. xdrmem).
3541 */
3542 if (!XDR_GETINT32(xdrs, (int32_t *)&objp->data_len))
3543 return (FALSE);
3544
3545 if (objp->data_len == 0)
3546 return (TRUE);
3547
3548 if (objp->data_len > size)
3549 return (FALSE);
3550
3551 size = (int)objp->data_len;
3552 if ((ptr = XDR_INLINE(xdrs, size)) != NULL)
3553 return (uiomove(ptr, size, UIO_READ, uiop) ?
3554 FALSE : TRUE);
3555
3556 /*
3557 * Handle some other (unlikely) stream type that will
3558 * need a copy.
3559 */
3560 if ((ptr = kmem_alloc(size, KM_NOSLEEP)) == NULL)
3561 return (FALSE);
3562
3563 if (!XDR_GETBYTES(xdrs, (caddr_t)ptr, size)) {
3564 kmem_free(ptr, size);
3565 return (FALSE);
3566 }
3567 error = uiomove(ptr, size, UIO_READ, uiop);
3568 kmem_free(ptr, size);
3569
3570 return (error ? FALSE : TRUE);
3571 }
3572
3573 /*
3574 * Check for the other special case of the caller providing
3575 * the target area for the data.
3576 */
3577 if (aobjp->res_data_val_alt == NULL)
3578 return (FALSE);
3579
3580 /*
3581 * If read data received via RDMA_WRITE, don't do xdr_bytes().
3582 * RDMA_WRITE already moved the data so decode length of
3583 * RDMA_WRITE.
3584 */
3585 if (xdrs->x_ops == &xdrrdma_ops) {
3586 struct clist *cl;
3587
3588 XDR_CONTROL(xdrs, XDR_RDMA_GET_WLIST, &cl);
3589
3590 objp->wlist = cl;
3591
3592 /*
3593 * Data transferred through inline if
3594 * objp->wlist == NULL
3595 */
3596 if (objp->wlist) {
3597 /* opaque count */
3598 if (!xdr_u_int(xdrs, &ocount)) {
3599 objp->wlist = NULL;
3600 return (FALSE);
3601 }
3602
3603 objp->wlist_len = clist_len(cl);
3604 objp->data_len = ocount;
3605
3606 if (objp->wlist_len !=
3607 roundup(
3608 objp->data_len, BYTES_PER_XDR_UNIT)) {
3609 DTRACE_PROBE2(
3610 xdr__e__read4res_clnt_fail,
3611 int, ocount,
3612 int, objp->data_len);
3613 objp->wlist = NULL;
3614 return (FALSE);
3615 }
3616
3617 objp->wlist = NULL;
3618 return (TRUE);
3619 }
3620 }
3621
3622 return (xdr_bytes(xdrs, (char **)&aobjp->res_data_val_alt,
3623 (uint_t *)&objp->data_len,
3624 aobjp->res_maxsize));
3625 }
3626
3627 static bool_t
3628 xdr_READDIR4args(XDR *xdrs, READDIR4args *objp)
3629 {
3630 rdma_chunkinfo_t rci;
3631 struct xdr_ops *xops = xdrrdma_xops();
3632
3633 if ((xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) &&
3634 xdrs->x_op == XDR_ENCODE) {
3635 rci.rci_type = RCI_REPLY_CHUNK;
3636 rci.rci_len = objp->maxcount;
3637 XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
3638 }
3639
3640 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cookie))
3641 return (FALSE);
3642 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cookieverf))
3643 return (FALSE);
3644 if (!xdr_u_int(xdrs, &objp->dircount))
3645 return (FALSE);
3646 if (!xdr_u_int(xdrs, &objp->maxcount))
3647 return (FALSE);
3648 return (xdr_bitmap4(xdrs, &objp->attr_request));
3649 }
3650
3651 bool_t
3652 xdr_READDIR4res(XDR *xdrs, READDIR4res *objp)
3653 {
3654 mblk_t *mp = objp->mblk;
3655 bool_t ret_val;
3656 uint_t flags = 0;
3657
3658 ASSERT(xdrs->x_op == XDR_ENCODE);
3659
3660 if (!xdr_int(xdrs, (int32_t *)&objp->status))
3661 return (FALSE);
3662 if (objp->status != NFS4_OK)
3663 return (TRUE);
3664 if (mp == NULL)
3665 return (FALSE);
3666
3667 if (xdrs->x_ops == &xdrmblk_ops) {
3668 if (xdrmblk_putmblk_raw(xdrs, mp)
3669 == TRUE) {
3670 /* mblk successfully inserted into outgoing chain */
3671 objp->mblk = NULL;
3672 return (TRUE);
3673 }
3674 }
3675
3676 ASSERT(mp->b_cont == NULL);
3677
3678 /*
3679 * If transport is RDMA, the pre-encoded m_blk needs to be moved
3680 * without being chunked.
3681 * Check if chunking is enabled for the xdr stream.
3682 * If it is enabled, disable it temporarily for this op,
3683 * then re-enable.
3684 */
3685 XDR_CONTROL(xdrs, XDR_RDMA_GET_FLAGS, &flags);
3686
3687 if (!(flags & XDR_RDMA_CHUNK))
3688 return (xdr_opaque(xdrs, (char *)mp->b_rptr, objp->data_len));
3689
3690 flags &= ~XDR_RDMA_CHUNK;
3691
3692 (void) XDR_CONTROL(xdrs, XDR_RDMA_SET_FLAGS, &flags);
3693
3694 ret_val = xdr_opaque(xdrs, (char *)mp->b_rptr, objp->data_len);
3695
3696 flags |= XDR_RDMA_CHUNK;
3697
3698 (void) XDR_CONTROL(xdrs, XDR_RDMA_SET_FLAGS, &flags);
3699
3700 return (ret_val);
3701 }
3702
3703 static bool_t
3704 xdr_READLINK4res(XDR *xdrs, READLINK4res *objp)
3705 {
3706 if (xdrs->x_op != XDR_FREE) {
3707 if (!xdr_int(xdrs, (int32_t *)&objp->status))
3708 return (FALSE);
3709 if (objp->status != NFS4_OK)
3710 return (TRUE);
3711 return (xdr_bytes(xdrs, (char **)&objp->link.linktext4_val,
3712 (uint_t *)&objp->link.linktext4_len,
3713 NFS4_MAX_UTF8STRING));
3714 }
3715
3716 /*
3717 * Optimized free case
3718 */
3719 if (objp->status != NFS4_OK)
3720 return (TRUE);
3721 if (objp->link.linktext4_val != NULL)
3722 kmem_free(objp->link.linktext4_val, objp->link.linktext4_len);
3723 return (TRUE);
3724 }
3725
3726 static bool_t
3727 xdr_REMOVE4res(XDR *xdrs, REMOVE4res *objp)
3728 {
3729 if (!xdr_int(xdrs, (int32_t *)&objp->status))
3730 return (FALSE);
3731 if (objp->status != NFS4_OK)
3732 return (TRUE);
3733 if (!xdr_bool(xdrs, &objp->cinfo.atomic))
3734 return (FALSE);
3735 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->cinfo.before))
3736 return (FALSE);
3737 return (xdr_u_longlong_t(xdrs,
3738 (u_longlong_t *)&objp->cinfo.after));
3739 }
3740
3741 static bool_t
3742 xdr_RENAME4res(XDR *xdrs, RENAME4res *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->source_cinfo.atomic))
3749 return (FALSE);
3750 if (!xdr_u_longlong_t(xdrs,
3751 (u_longlong_t *)&objp->source_cinfo.before))
3752 return (FALSE);
3753 if (!xdr_u_longlong_t(xdrs,
3754 (u_longlong_t *)&objp->source_cinfo.after))
3755 return (FALSE);
3756 if (!xdr_bool(xdrs, &objp->target_cinfo.atomic))
3757 return (FALSE);
3758 if (!xdr_u_longlong_t(xdrs,
3759 (u_longlong_t *)&objp->target_cinfo.before))
3760 return (FALSE);
3761 return (xdr_u_longlong_t(xdrs,
3762 (u_longlong_t *)&objp->target_cinfo.after));
3763 }
3764
3765 static bool_t
3766 xdr_secinfo4(XDR *xdrs, secinfo4 *objp)
3767 {
3768 if (xdrs->x_op != XDR_FREE) {
3769 if (!xdr_u_int(xdrs, &objp->flavor))
3770 return (FALSE);
3771 if (objp->flavor != RPCSEC_GSS)
3772 return (TRUE);
3773 if (!xdr_bytes(xdrs,
3774 (char **)&objp->flavor_info.oid.sec_oid4_val,
3775 (uint_t *)&objp->flavor_info.oid.sec_oid4_len,
3776 NFS4_MAX_SECOID4))
3777 return (FALSE);
3778 if (!xdr_u_int(xdrs, &objp->flavor_info.qop))
3779 return (FALSE);
3780 return (xdr_int(xdrs, (int *)&objp->flavor_info.service));
3781 }
3782
3783 /*
3784 * Optimized free path
3785 */
3786 if (objp->flavor != RPCSEC_GSS)
3787 return (TRUE);
3788
3789 if (objp->flavor_info.oid.sec_oid4_val != NULL)
3790 kmem_free(objp->flavor_info.oid.sec_oid4_val,
3791 objp->flavor_info.oid.sec_oid4_len);
3792 return (TRUE);
3793 }
3794
3795 static bool_t
3796 xdr_SETCLIENTID4args(XDR *xdrs, SETCLIENTID4args *objp)
3797 {
3798 if (xdrs->x_op != XDR_FREE) {
3799 if (!xdr_u_longlong_t(xdrs,
3800 (u_longlong_t *)&objp->client.verifier))
3801 return (FALSE);
3802 if (!xdr_bytes(xdrs, (char **)&objp->client.id_val,
3803 (uint_t *)&objp->client.id_len, NFS4_OPAQUE_LIMIT))
3804 return (FALSE);
3805 if (!xdr_u_int(xdrs, &objp->callback.cb_program))
3806 return (FALSE);
3807 if (!xdr_string(xdrs, &objp->callback.cb_location.r_netid,
3808 NFS4_OPAQUE_LIMIT))
3809 return (FALSE);
3810 if (!xdr_string(xdrs, &objp->callback.cb_location.r_addr,
3811 NFS4_OPAQUE_LIMIT))
3812 return (FALSE);
3813 return (xdr_u_int(xdrs, &objp->callback_ident));
3814 }
3815
3816 /*
3817 * Optimized free case
3818 */
3819 if (objp->client.id_val != NULL)
3820 kmem_free(objp->client.id_val, objp->client.id_len);
3821 (void) xdr_string(xdrs, &objp->callback.cb_location.r_netid,
3822 NFS4_OPAQUE_LIMIT);
3823 return (xdr_string(xdrs, &objp->callback.cb_location.r_addr,
3824 NFS4_OPAQUE_LIMIT));
3825 }
3826
3827 static bool_t
3828 xdr_SETCLIENTID4res(XDR *xdrs, SETCLIENTID4res *objp)
3829 {
3830 if (xdrs->x_op != XDR_FREE) {
3831 if (!xdr_int(xdrs, (int32_t *)&objp->status))
3832 return (FALSE);
3833 switch (objp->status) {
3834 case NFS4_OK:
3835 if (!xdr_u_longlong_t(xdrs,
3836 (u_longlong_t *)&objp->SETCLIENTID4res_u.resok4.
3837 clientid))
3838 return (FALSE);
3839 return (xdr_u_longlong_t(xdrs,
3840 (u_longlong_t *)&objp->SETCLIENTID4res_u.
3841 resok4.setclientid_confirm));
3842 case NFS4ERR_CLID_INUSE:
3843 if (!xdr_string(xdrs,
3844 &objp->SETCLIENTID4res_u.client_using.
3845 r_netid, NFS4_OPAQUE_LIMIT))
3846 return (FALSE);
3847 return (xdr_string(xdrs,
3848 &objp->SETCLIENTID4res_u.client_using.
3849 r_addr, NFS4_OPAQUE_LIMIT));
3850 }
3851 return (TRUE);
3852 }
3853
3854 /*
3855 * Optimized free case
3856 */
3857 if (objp->status != NFS4ERR_CLID_INUSE)
3858 return (TRUE);
3859
3860 if (!xdr_string(xdrs, &objp->SETCLIENTID4res_u.client_using.r_netid,
3861 NFS4_OPAQUE_LIMIT))
3862 return (FALSE);
3863 return (xdr_string(xdrs, &objp->SETCLIENTID4res_u.client_using.r_addr,
3864 NFS4_OPAQUE_LIMIT));
3865 }
3866
3867 static bool_t
3868 xdr_WRITE4args(XDR *xdrs, WRITE4args *objp)
3869 {
3870 if (xdrs->x_op != XDR_FREE) {
3871 if (!xdr_u_int(xdrs, &objp->stateid.seqid))
3872 return (FALSE);
3873 if (!xdr_opaque(xdrs, objp->stateid.other, NFS4_OTHER_SIZE))
3874 return (FALSE);
3875 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->offset))
3876 return (FALSE);
3877 if (!xdr_int(xdrs, (int *)&objp->stable))
3878 return (FALSE);
3879 if (xdrs->x_op == XDR_DECODE) {
3880 if (xdrs->x_ops == &xdrmblk_ops) {
3881 objp->data_val = NULL;
3882 return (xdrmblk_getmblk(xdrs, &objp->mblk,
3883 &objp->data_len));
3884 }
3885 objp->mblk = NULL;
3886 if (xdrs->x_ops == &xdrrdmablk_ops) {
3887 int retval;
3888 retval = xdrrdma_getrdmablk(xdrs,
3889 &objp->rlist,
3890 &objp->data_len,
3891 &objp->conn, NFS4_DATA_LIMIT);
3892 if (retval == FALSE)
3893 return (FALSE);
3894 return (xdrrdma_read_from_client(objp->rlist,
3895 &objp->conn, objp->data_len));
3896 }
3897 }
3898 /* Else fall thru for the xdr_bytes(). */
3899 return (xdr_bytes(xdrs, (char **)&objp->data_val,
3900 (uint_t *)&objp->data_len, NFS4_DATA_LIMIT));
3901 }
3902 if (objp->rlist != NULL) {
3903 (void) xdrrdma_free_clist(objp->conn, objp->rlist);
3904 objp->rlist = NULL;
3905 objp->data_val = NULL;
3906
3907 return (TRUE);
3908 }
3909
3910 /*
3911 * Optimized free case
3912 */
3913 if (objp->data_val != NULL)
3914 kmem_free(objp->data_val, objp->data_len);
3915 return (TRUE);
3916 }
3917
3918 static bool_t
3919 xdr_WRITE4res(XDR *xdrs, WRITE4res *objp)
3920 {
3921 if (!xdr_int(xdrs, (int32_t *)&objp->status))
3922 return (FALSE);
3923 if (objp->status != NFS4_OK)
3924 return (TRUE);
3925 if (!xdr_u_int(xdrs, &objp->count))
3926 return (FALSE);
3927 if (!xdr_int(xdrs, (int *)&objp->committed))
3928 return (FALSE);
3929 return (xdr_u_longlong_t(xdrs,
3930 (u_longlong_t *)&objp->writeverf));
3931 }
3932
3933 static bool_t
3934 xdr_snfs_argop4_free(XDR *xdrs, nfs_argop4 **arrayp, int len)
3935 {
3936 int i;
3937 nfs_argop4 *array = *arrayp;
3938
3939 /*
3940 * Optimized XDR_FREE only args array
3941 */
3942 ASSERT(xdrs->x_op == XDR_FREE);
3943
3944 /*
3945 * Nothing to do?
3946 */
3947 if (array == NULL)
3948 return (TRUE);
3949
3950 for (i = 0; i < len; i++) {
3951 /*
3952 * These should be ordered by frequency of use
3953 */
3954 switch (array[i].argop) {
3955 case OP_PUTFH: {
3956 nfs_fh4 *objp = &array[i].nfs_argop4_u.opputfh.object;
3957
3958 if (objp->nfs_fh4_val != NULL) {
3959 kmem_free(objp->nfs_fh4_val, objp->nfs_fh4_len);
3960 }
3961 continue;
3962 }
3963 case OP_GETATTR:
3964 case OP_GETFH:
3965 continue;
3966 case OP_LOOKUP:
3967 if (array[i].nfs_argop4_u.oplookup.objname.
3968 utf8string_val != NULL) {
3969 kmem_free(array[i].nfs_argop4_u.oplookup.
3970 objname.utf8string_val,
3971 array[i].nfs_argop4_u.oplookup.
3972 objname.utf8string_len);
3973 }
3974 continue;
3975 case OP_OPEN:
3976 (void) xdr_OPEN4args(xdrs,
3977 &array[i].nfs_argop4_u.opopen);
3978 continue;
3979 case OP_CLOSE:
3980 case OP_ACCESS:
3981 case OP_READ:
3982 continue;
3983 case OP_WRITE:
3984 (void) xdr_WRITE4args(xdrs,
3985 &array[i].nfs_argop4_u.opwrite);
3986 continue;
3987 case OP_DELEGRETURN:
3988 case OP_LOOKUPP:
3989 case OP_READDIR:
3990 continue;
3991 case OP_REMOVE:
3992 if (array[i].nfs_argop4_u.opremove.target.
3993 utf8string_val != NULL) {
3994 kmem_free(array[i].nfs_argop4_u.opremove.target.
3995 utf8string_val,
3996 array[i].nfs_argop4_u.opremove.target.
3997 utf8string_len);
3998 }
3999 continue;
4000 case OP_COMMIT:
4001 continue;
4002 case OP_CREATE:
4003 (void) xdr_CREATE4args(xdrs,
4004 &array[i].nfs_argop4_u.opcreate);
4005 continue;
4006 case OP_DELEGPURGE:
4007 continue;
4008 case OP_LINK:
4009 if (array[i].nfs_argop4_u.oplink.newname.
4010 utf8string_val != NULL) {
4011 kmem_free(array[i].nfs_argop4_u.oplink.newname.
4012 utf8string_val,
4013 array[i].nfs_argop4_u.oplink.newname.
4014 utf8string_len);
4015 }
4016 continue;
4017 case OP_LOCK:
4018 (void) xdr_LOCK4args(xdrs,
4019 &array[i].nfs_argop4_u.oplock);
4020 continue;
4021 case OP_LOCKT:
4022 (void) xdr_LOCKT4args(xdrs,
4023 &array[i].nfs_argop4_u.oplockt);
4024 continue;
4025 case OP_LOCKU:
4026 continue;
4027 case OP_NVERIFY:
4028 (void) xdr_fattr4(xdrs,
4029 &array[i].nfs_argop4_u.opnverify.obj_attributes);
4030 continue;
4031 case OP_OPENATTR:
4032 case OP_OPEN_CONFIRM:
4033 case OP_OPEN_DOWNGRADE:
4034 case OP_PUTPUBFH:
4035 case OP_PUTROOTFH:
4036 case OP_READLINK:
4037 continue;
4038 case OP_RENAME:
4039 if (array[i].nfs_argop4_u.oprename.oldname.
4040 utf8string_val != NULL) {
4041 kmem_free(array[i].nfs_argop4_u.oprename.
4042 oldname.utf8string_val,
4043 array[i].nfs_argop4_u.oprename.
4044 oldname.utf8string_len);
4045 }
4046 if (array[i].nfs_argop4_u.oprename.newname.
4047 utf8string_val != NULL) {
4048 kmem_free(array[i].nfs_argop4_u.oprename.
4049 newname.utf8string_val,
4050 array[i].nfs_argop4_u.oprename.
4051 newname.utf8string_len);
4052 }
4053 continue;
4054 case OP_RENEW:
4055 case OP_RESTOREFH:
4056 case OP_SAVEFH:
4057 continue;
4058 case OP_SECINFO:
4059 if (array[i].nfs_argop4_u.opsecinfo.name.
4060 utf8string_val != NULL) {
4061 kmem_free(array[i].nfs_argop4_u.opsecinfo.name.
4062 utf8string_val,
4063 array[i].nfs_argop4_u.opsecinfo.name.
4064 utf8string_len);
4065 }
4066 continue;
4067 case OP_SETATTR:
4068 (void) xdr_fattr4(xdrs,
4069 &array[i].nfs_argop4_u.opsetattr.obj_attributes);
4070 continue;
4071 case OP_SETCLIENTID:
4072 (void) xdr_SETCLIENTID4args(xdrs,
4073 &array[i].nfs_argop4_u.opsetclientid);
4074 continue;
4075 case OP_SETCLIENTID_CONFIRM:
4076 continue;
4077 case OP_VERIFY:
4078 (void) xdr_fattr4(xdrs,
4079 &array[i].nfs_argop4_u.opverify.obj_attributes);
4080 continue;
4081 case OP_RELEASE_LOCKOWNER:
4082 if (array[i].nfs_argop4_u.oprelease_lockowner.
4083 lock_owner.owner_val != NULL) {
4084 kmem_free(array[i].nfs_argop4_u.
4085 oprelease_lockowner.lock_owner.owner_val,
4086 array[i].nfs_argop4_u.
4087 oprelease_lockowner.lock_owner.owner_len);
4088 }
4089 continue;
4090 case OP_ILLEGAL:
4091 continue;
4092 default:
4093 /*
4094 * An invalid op is a coding error, it should never
4095 * have been decoded.
4096 * Don't error because the caller cannot finish
4097 * freeing the residual memory of the array.
4098 */
4099 continue;
4100 }
4101 }
4102
4103 kmem_free(*arrayp, len * sizeof (nfs_argop4));
4104 *arrayp = NULL;
4105 return (TRUE);
4106 }
4107
4108 static bool_t
4109 xdr_nfs_argop4(XDR *xdrs, nfs_argop4 *objp)
4110 {
4111 rdma_chunkinfo_t rci;
4112 struct xdr_ops *xops = xdrrdma_xops();
4113
4114 /*
4115 * These should be ordered by frequency of use
4116 */
4117 switch (objp->argop) {
4118 case OP_PUTFH:
4119 return (xdr_bytes(xdrs,
4120 (char **)&objp->nfs_argop4_u.opputfh.object.nfs_fh4_val,
4121 (uint_t *)&objp->nfs_argop4_u.opputfh.object.nfs_fh4_len,
4122 NFS4_FHSIZE));
4123 case OP_GETATTR:
4124 /*
4125 * ACLs can become relatively large ( > 8K) and the default
4126 * 8K reply chunk of RDMA may not suffice. Check for
4127 * get ACL bit and if it's RDMA, add a chunk equal the size
4128 * of the transfer size to the reply chunk list.
4129 */
4130 if ((xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) &&
4131 (xdrs->x_op == XDR_ENCODE) &&
4132 (objp->nfs_argop4_u.opgetattr.attr_request &
4133 FATTR4_ACL_MASK)) {
4134 rci.rci_type = RCI_REPLY_CHUNK;
4135 rci.rci_len = objp->nfs_argop4_u.opgetattr.mi->mi_tsize;
4136 XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
4137
4138 DTRACE_PROBE1(xdr__i__argop4__getattr, int,
4139 rci.rci_len);
4140 }
4141 return (xdr_bitmap4(xdrs,
4142 &objp->nfs_argop4_u.opgetattr.attr_request));
4143 case OP_GETFH:
4144 return (TRUE);
4145 case OP_LOOKUP:
4146 return (xdr_bytes(xdrs, (char **)&objp->nfs_argop4_u.oplookup.
4147 objname.utf8string_val,
4148 (uint_t *)&objp->nfs_argop4_u.oplookup.
4149 objname.utf8string_len,
4150 NFS4_MAX_UTF8STRING));
4151 case OP_OPEN:
4152 return (xdr_OPEN4args(xdrs, &objp->nfs_argop4_u.opopen));
4153 case OP_CLOSE:
4154 return (xdr_CLOSE4args(xdrs, &objp->nfs_argop4_u.opclose));
4155 case OP_ACCESS:
4156 return (xdr_u_int(xdrs,
4157 &objp->nfs_argop4_u.opaccess.access));
4158 case OP_READ:
4159 return (xdr_READ4args(xdrs, &objp->nfs_argop4_u.opread));
4160 case OP_WRITE:
4161 return (xdr_WRITE4args(xdrs, &objp->nfs_argop4_u.opwrite));
4162 case OP_DELEGRETURN:
4163 if (!xdr_u_int(xdrs,
4164 &objp->nfs_argop4_u.opdelegreturn.deleg_stateid.seqid))
4165 return (FALSE);
4166 return (xdr_opaque(xdrs,
4167 objp->nfs_argop4_u.opdelegreturn.deleg_stateid.other,
4168 NFS4_OTHER_SIZE));
4169 case OP_LOOKUPP:
4170 return (TRUE);
4171 case OP_READDIR:
4172 return (xdr_READDIR4args(xdrs, &objp->nfs_argop4_u.opreaddir));
4173 case OP_REMOVE:
4174 return (xdr_bytes(xdrs, (char **)&objp->nfs_argop4_u.opremove.
4175 target.utf8string_val,
4176 (uint_t *)&objp->nfs_argop4_u.opremove.
4177 target.utf8string_len,
4178 NFS4_MAX_UTF8STRING));
4179 case OP_COMMIT:
4180 if (!xdr_u_longlong_t(xdrs,
4181 (u_longlong_t *)&objp->nfs_argop4_u.opcommit.offset))
4182 return (FALSE);
4183 return (xdr_u_int(xdrs, &objp->nfs_argop4_u.opcommit.count));
4184 case OP_CREATE:
4185 return (xdr_CREATE4args(xdrs, &objp->nfs_argop4_u.opcreate));
4186 case OP_DELEGPURGE:
4187 return (xdr_u_longlong_t(xdrs,
4188 (u_longlong_t *)&objp->nfs_argop4_u.opdelegpurge.clientid));
4189 case OP_LINK:
4190 return (xdr_bytes(xdrs,
4191 (char **)&objp->nfs_argop4_u.oplink.newname.utf8string_val,
4192 (uint_t *)&objp->nfs_argop4_u.oplink.newname.utf8string_len,
4193 NFS4_MAX_UTF8STRING));
4194 case OP_LOCK:
4195 return (xdr_LOCK4args(xdrs, &objp->nfs_argop4_u.oplock));
4196 case OP_LOCKT:
4197 return (xdr_LOCKT4args(xdrs, &objp->nfs_argop4_u.oplockt));
4198 case OP_LOCKU:
4199 return (xdr_LOCKU4args(xdrs, &objp->nfs_argop4_u.oplocku));
4200 case OP_NVERIFY:
4201 return (xdr_fattr4(xdrs,
4202 &objp->nfs_argop4_u.opnverify.obj_attributes));
4203 case OP_OPENATTR:
4204 return (xdr_bool(xdrs,
4205 &objp->nfs_argop4_u.opopenattr.createdir));
4206 case OP_OPEN_CONFIRM:
4207 if (!xdr_u_int(xdrs, &objp->nfs_argop4_u.opopen_confirm.
4208 open_stateid.seqid))
4209 return (FALSE);
4210 if (!xdr_opaque(xdrs, objp->nfs_argop4_u.opopen_confirm.
4211 open_stateid.other, NFS4_OTHER_SIZE))
4212 return (FALSE);
4213 return (xdr_u_int(xdrs, &objp->nfs_argop4_u.opopen_confirm.
4214 seqid));
4215 case OP_OPEN_DOWNGRADE:
4216 return (xdr_OPEN_DOWNGRADE4args(xdrs,
4217 &objp->nfs_argop4_u.opopen_downgrade));
4218 case OP_PUTPUBFH:
4219 return (TRUE);
4220 case OP_PUTROOTFH:
4221 return (TRUE);
4222 case OP_READLINK:
4223 if ((xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) &&
4224 xdrs->x_op == XDR_ENCODE) {
4225 rci.rci_type = RCI_REPLY_CHUNK;
4226 rci.rci_len = MAXPATHLEN;
4227 XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
4228 }
4229 return (TRUE);
4230 case OP_RENAME:
4231 if (!xdr_bytes(xdrs, (char **)&objp->nfs_argop4_u.oprename.
4232 oldname.utf8string_val,
4233 (uint_t *)&objp->nfs_argop4_u.oprename.
4234 oldname.utf8string_len,
4235 NFS4_MAX_UTF8STRING))
4236 return (FALSE);
4237 return (xdr_bytes(xdrs, (char **)&objp->nfs_argop4_u.oprename.
4238 newname.utf8string_val,
4239 (uint_t *)&objp->nfs_argop4_u.oprename.
4240 newname.utf8string_len,
4241 NFS4_MAX_UTF8STRING));
4242 case OP_RENEW:
4243 return (xdr_u_longlong_t(xdrs,
4244 (u_longlong_t *)&objp->nfs_argop4_u.oprenew.clientid));
4245 case OP_RESTOREFH:
4246 return (TRUE);
4247 case OP_SAVEFH:
4248 return (TRUE);
4249 case OP_SECINFO:
4250 return (xdr_bytes(xdrs,
4251 (char **)&objp->nfs_argop4_u.opsecinfo.name.utf8string_val,
4252 (uint_t *)&objp->nfs_argop4_u.opsecinfo.name.utf8string_len,
4253 NFS4_MAX_UTF8STRING));
4254 case OP_SETATTR:
4255 if (!xdr_u_int(xdrs, &objp->nfs_argop4_u.opsetattr.
4256 stateid.seqid))
4257 return (FALSE);
4258 if (!xdr_opaque(xdrs, objp->nfs_argop4_u.opsetattr.
4259 stateid.other, NFS4_OTHER_SIZE))
4260 return (FALSE);
4261 return (xdr_fattr4(xdrs, &objp->nfs_argop4_u.opsetattr.
4262 obj_attributes));
4263 case OP_SETCLIENTID:
4264 return (xdr_SETCLIENTID4args(xdrs,
4265 &objp->nfs_argop4_u.opsetclientid));
4266 case OP_SETCLIENTID_CONFIRM:
4267 if (!xdr_u_longlong_t(xdrs, (u_longlong_t *)&objp->nfs_argop4_u.
4268 opsetclientid_confirm.clientid))
4269 return (FALSE);
4270 return (xdr_u_longlong_t(xdrs,
4271 (u_longlong_t *)&objp->nfs_argop4_u.
4272 opsetclientid_confirm.setclientid_confirm));
4273 case OP_VERIFY:
4274 return (xdr_fattr4(xdrs,
4275 &objp->nfs_argop4_u.opverify.obj_attributes));
4276 case OP_RELEASE_LOCKOWNER:
4277 if (!xdr_u_longlong_t(xdrs,
4278 (u_longlong_t *)&objp->nfs_argop4_u.
4279 oprelease_lockowner.lock_owner.clientid))
4280 return (FALSE);
4281 return (xdr_bytes(xdrs,
4282 (char **)&objp->nfs_argop4_u.oprelease_lockowner.
4283 lock_owner.owner_val,
4284 (uint_t *)&objp->nfs_argop4_u.oprelease_lockowner.
4285 lock_owner.owner_len, NFS4_OPAQUE_LIMIT));
4286 case OP_ILLEGAL:
4287 return (TRUE);
4288 }
4289 return (FALSE);
4290 }
4291
4292 static bool_t
4293 xdr_cnfs_argop4_wrap(XDR *xdrs, nfs_argop4 *objp)
4294 {
4295 if (!xdr_int(xdrs, (int *)&objp->argop))
4296 return (FALSE);
4297
4298 return (xdr_nfs_argop4(xdrs, objp));
4299 }
4300
4301 static bool_t
4302 xdr_snfs_argop4(XDR *xdrs, nfs_argop4 *objp)
4303 {
4304 uint_t pos;
4305 bool_t ret;
4306
4307 if (xdrs->x_op == XDR_DECODE)
4308 pos = XDR_GETPOS(xdrs);
4309
4310 if (!xdr_int(xdrs, (int *)&objp->argop))
4311 return (FALSE);
4312
4313 switch (objp->argop) {
4314 case OP_PUTFH:
4315 ret = xdr_decode_nfs_fh4(xdrs,
4316 &objp->nfs_argop4_u.opputfh.object);
4317 break;
4318 default:
4319 ret = xdr_nfs_argop4(xdrs, objp);
4320 break;
4321 }
4322
4323 if (ret && xdrs->x_op == XDR_DECODE)
4324 objp->opsize = XDR_GETPOS(xdrs) - pos;
4325
4326 return (ret);
4327 }
4328
4329 /*
4330 * Client side encode only arg op processing
4331 */
4332 static bool_t
4333 xdr_cnfs_argop4(XDR *xdrs, nfs_argop4 *objp)
4334 {
4335 int len;
4336 int op;
4337 nfs4_sharedfh_t *sfh;
4338 mntinfo4_t *mi;
4339 rpc_inline_t *ptr;
4340
4341 ASSERT(xdrs->x_op == XDR_ENCODE);
4342
4343 /*
4344 * Special case the private pseudo ops
4345 */
4346 if (!(objp->argop & SUNW_PRIVATE_OP))
4347 return (xdr_cnfs_argop4_wrap(xdrs, objp));
4348
4349 /*
4350 * These should be ordered by frequency of use
4351 */
4352 switch (objp->argop) {
4353 case OP_CPUTFH:
4354 /*
4355 * We are passed in the file handle as a nfs4_sharedfh_t *
4356 * We need to acquire the correct locks so we can copy it out.
4357 */
4358 sfh = (nfs4_sharedfh_t *)objp->nfs_argop4_u.opcputfh.sfh;
4359 mi = sfh->sfh_mi;
4360 (void) nfs_rw_enter_sig(&mi->mi_fh_lock, RW_READER, 0);
4361
4362 len = sfh->sfh_fh.nfs_fh4_len;
4363 ASSERT(len <= NFS4_FHSIZE);
4364
4365 /*
4366 * First try and inline the copy
4367 * Must first be a multiple of BYTES_PER_XDR_UNIT
4368 */
4369 if (!(len % BYTES_PER_XDR_UNIT) &&
4370 (ptr = XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT + len)) !=
4371 NULL) {
4372 IXDR_PUT_U_INT32(ptr, OP_PUTFH);
4373 IXDR_PUT_U_INT32(ptr, len);
4374 bcopy(sfh->sfh_fh.nfs_fh4_val, ptr, len);
4375 nfs_rw_exit(&mi->mi_fh_lock);
4376 return (TRUE);
4377 }
4378
4379 op = OP_PUTFH;
4380 if (!XDR_PUTINT32(xdrs, &op)) {
4381 nfs_rw_exit(&mi->mi_fh_lock);
4382 return (FALSE);
4383 }
4384 if (!XDR_PUTINT32(xdrs, &len)) {
4385 nfs_rw_exit(&mi->mi_fh_lock);
4386 return (FALSE);
4387 }
4388 if (!(len % BYTES_PER_XDR_UNIT)) {
4389 if (XDR_PUTBYTES(xdrs, sfh->sfh_fh.nfs_fh4_val, len)) {
4390 nfs_rw_exit(&mi->mi_fh_lock);
4391 return (TRUE);
4392 }
4393 } else if (xdr_opaque(xdrs, sfh->sfh_fh.nfs_fh4_val, len)) {
4394 nfs_rw_exit(&mi->mi_fh_lock);
4395 return (TRUE);
4396 }
4397 nfs_rw_exit(&mi->mi_fh_lock);
4398 return (FALSE);
4399 case OP_CLOOKUP:
4400 len = strlen(objp->nfs_argop4_u.opclookup.cname);
4401 if (len > NFS4_MAX_UTF8STRING)
4402 return (FALSE);
4403 op = OP_LOOKUP;
4404 if (XDR_PUTINT32(xdrs, &op)) {
4405 if (XDR_PUTINT32(xdrs, &len)) {
4406 return (xdr_opaque(xdrs,
4407 objp->nfs_argop4_u.opclookup.cname,
4408 len));
4409 }
4410 }
4411 return (FALSE);
4412 case OP_COPEN:
4413 /* op processing inlined in xdr_OPEN4cargs */
4414 return (xdr_OPEN4cargs(xdrs, &objp->nfs_argop4_u.opcopen));
4415 case OP_CREMOVE:
4416 len = strlen(objp->nfs_argop4_u.opcremove.ctarget);
4417 if (len > NFS4_MAX_UTF8STRING)
4418 return (FALSE);
4419 op = OP_REMOVE;
4420 if (XDR_PUTINT32(xdrs, &op)) {
4421 if (XDR_PUTINT32(xdrs, &len)) {
4422 return (xdr_opaque(xdrs,
4423 objp->nfs_argop4_u.opcremove.ctarget,
4424 len));
4425 }
4426 }
4427 return (FALSE);
4428 case OP_CCREATE:
4429 op = OP_CREATE;
4430 if (!XDR_PUTINT32(xdrs, &op))
4431 return (FALSE);
4432 return (xdr_CREATE4cargs(xdrs, &objp->nfs_argop4_u.opccreate));
4433 case OP_CLINK:
4434 len = strlen(objp->nfs_argop4_u.opclink.cnewname);
4435 if (len > NFS4_MAX_UTF8STRING)
4436 return (FALSE);
4437 op = OP_LINK;
4438 if (XDR_PUTINT32(xdrs, &op)) {
4439 if (XDR_PUTINT32(xdrs, &len)) {
4440 return (xdr_opaque(xdrs,
4441 objp->nfs_argop4_u.opclink.cnewname,
4442 len));
4443 }
4444 }
4445 return (FALSE);
4446 case OP_CRENAME:
4447 len = strlen(objp->nfs_argop4_u.opcrename.coldname);
4448 if (len > NFS4_MAX_UTF8STRING)
4449 return (FALSE);
4450 op = OP_RENAME;
4451 if (!XDR_PUTINT32(xdrs, &op))
4452 return (FALSE);
4453 if (!XDR_PUTINT32(xdrs, &len))
4454 return (FALSE);
4455 if (!xdr_opaque(xdrs,
4456 objp->nfs_argop4_u.opcrename.coldname, len))
4457 return (FALSE);
4458 len = strlen(objp->nfs_argop4_u.opcrename.cnewname);
4459 if (len > NFS4_MAX_UTF8STRING)
4460 return (FALSE);
4461 if (XDR_PUTINT32(xdrs, &len)) {
4462 return (xdr_opaque(xdrs,
4463 objp->nfs_argop4_u.opcrename.cnewname, len));
4464 }
4465 return (FALSE);
4466 case OP_CSECINFO:
4467 len = strlen(objp->nfs_argop4_u.opcsecinfo.cname);
4468 if (len > NFS4_MAX_UTF8STRING)
4469 return (FALSE);
4470 op = OP_SECINFO;
4471 if (XDR_PUTINT32(xdrs, &op)) {
4472 if (XDR_PUTINT32(xdrs, &len)) {
4473 return (xdr_opaque(xdrs,
4474 objp->nfs_argop4_u.opcsecinfo.cname,
4475 len));
4476 }
4477 }
4478 return (FALSE);
4479 }
4480 return (FALSE);
4481 }
4482
4483 /*
4484 * Note that the len and decode_len will only be different in the case
4485 * of the client's use of this free function. If the server is
4486 * freeing results, then the len/decode_len will always match.
4487 */
4488 static bool_t
4489 xdr_nfs_resop4_free(XDR *xdrs, nfs_resop4 **arrayp, int len, int decode_len)
4490 {
4491 int i;
4492 nfs_resop4 *array = *arrayp;
4493 nfs4_ga_res_t *gr;
4494
4495 /*
4496 * Optimized XDR_FREE only results array
4497 */
4498 ASSERT(xdrs->x_op == XDR_FREE);
4499
4500 if (array == NULL)
4501 return (TRUE);
4502
4503 for (i = 0; i < decode_len; i++) {
4504 /*
4505 * These should be ordered by frequency of use
4506 */
4507 switch (array[i].resop) {
4508 case OP_PUTFH:
4509 continue;
4510 case OP_GETATTR:
4511 if (array[i].nfs_resop4_u.opgetattr.status != NFS4_OK)
4512 continue;
4513
4514 gr = &array[i].nfs_resop4_u.opgetattr.ga_res;
4515 if (gr->n4g_ext_res) {
4516 if (gr->n4g_resbmap & FATTR4_FS_LOCATIONS_MASK)
4517 (void) xdr_fattr4_fs_locations(xdrs,
4518 &gr->n4g_ext_res->n4g_fslocations);
4519 kmem_free(gr->n4g_ext_res,
4520 sizeof (struct nfs4_ga_ext_res));
4521 }
4522 continue;
4523 case OP_GETFH:
4524 if (array[i].nfs_resop4_u.opgetfh.status != NFS4_OK)
4525 continue;
4526 if (array[i].nfs_resop4_u.opgetfh.object.nfs_fh4_val !=
4527 NULL) {
4528 kmem_free(array[i].nfs_resop4_u.opgetfh.object.
4529 nfs_fh4_val,
4530 array[i].nfs_resop4_u.opgetfh.object.
4531 nfs_fh4_len);
4532 }
4533 continue;
4534 case OP_LOOKUP:
4535 continue;
4536 case OP_OPEN:
4537 (void) xdr_OPEN4res(xdrs, &array[i].nfs_resop4_u.
4538 opopen);
4539 continue;
4540 case OP_CLOSE:
4541 case OP_ACCESS:
4542 continue;
4543 case OP_READ:
4544 (void) xdr_READ4res(xdrs,
4545 &array[i].nfs_resop4_u.opread);
4546 continue;
4547 case OP_WRITE:
4548 case OP_DELEGRETURN:
4549 case OP_LOOKUPP:
4550 case OP_READDIR:
4551 case OP_REMOVE:
4552 case OP_COMMIT:
4553 case OP_CREATE:
4554 case OP_DELEGPURGE:
4555 case OP_LINK:
4556 continue;
4557 case OP_LOCK:
4558 (void) xdr_LOCK4res(xdrs, &array[i].nfs_resop4_u.
4559 oplock);
4560 continue;
4561 case OP_LOCKT:
4562 (void) xdr_LOCKT4res(xdrs, &array[i].nfs_resop4_u.
4563 oplockt);
4564 continue;
4565 case OP_LOCKU:
4566 case OP_NVERIFY:
4567 case OP_OPENATTR:
4568 case OP_OPEN_CONFIRM:
4569 case OP_OPEN_DOWNGRADE:
4570 case OP_PUTPUBFH:
4571 case OP_PUTROOTFH:
4572 case OP_RENAME:
4573 case OP_RENEW:
4574 case OP_RESTOREFH:
4575 case OP_SAVEFH:
4576 continue;
4577 case OP_READLINK:
4578 (void) xdr_READLINK4res(xdrs, &array[i].nfs_resop4_u.
4579 opreadlink);
4580 continue;
4581 case OP_SECINFO:
4582 (void) xdr_array(xdrs,
4583 (char **)&array[i].nfs_resop4_u.opsecinfo.
4584 SECINFO4resok_val,
4585 (uint_t *)&array[i].nfs_resop4_u.opsecinfo.
4586 SECINFO4resok_len,
4587 NFS4_SECINFO_LIMIT, sizeof (secinfo4),
4588 (xdrproc_t)xdr_secinfo4);
4589 continue;
4590 case OP_SETCLIENTID:
4591 (void) xdr_SETCLIENTID4res(xdrs,
4592 &array[i].nfs_resop4_u.opsetclientid);
4593 continue;
4594 case OP_SETATTR:
4595 case OP_SETCLIENTID_CONFIRM:
4596 case OP_VERIFY:
4597 case OP_RELEASE_LOCKOWNER:
4598 case OP_ILLEGAL:
4599 continue;
4600 default:
4601 /*
4602 * An invalid op is a coding error, it should never
4603 * have been decoded.
4604 * Don't error because the caller cannot finish
4605 * freeing the residual memory of the array.
4606 */
4607 continue;
4608 }
4609 }
4610
4611 kmem_free(*arrayp, len * sizeof (nfs_resop4));
4612 *arrayp = NULL;
4613 return (TRUE);
4614 }
4615
4616 static bool_t
4617 xdr_snfs_resop4_free(XDR *xdrs, nfs_resop4 **arrayp, int len, int decode_len)
4618 {
4619 return (xdr_nfs_resop4_free(xdrs, arrayp, len, decode_len));
4620 }
4621
4622 static bool_t
4623 xdr_nfs_resop4(XDR *xdrs, nfs_resop4 *objp)
4624 {
4625 /*
4626 * These should be ordered by frequency of use
4627 */
4628 switch (objp->resop) {
4629 case OP_PUTFH:
4630 return (xdr_int(xdrs,
4631 (int32_t *)&objp->nfs_resop4_u.opputfh.status));
4632 case OP_GETATTR:
4633 if (!xdr_int(xdrs,
4634 (int32_t *)&objp->nfs_resop4_u.opgetattr.status))
4635 return (FALSE);
4636 if (objp->nfs_resop4_u.opgetattr.status != NFS4_OK)
4637 return (TRUE);
4638 return (xdr_fattr4(xdrs,
4639 &objp->nfs_resop4_u.opgetattr.obj_attributes));
4640 case OP_GETFH:
4641 if (!xdr_int(xdrs,
4642 (int32_t *)&objp->nfs_resop4_u.opgetfh.status))
4643 return (FALSE);
4644 if (objp->nfs_resop4_u.opgetfh.status != NFS4_OK)
4645 return (TRUE);
4646 return (xdr_bytes(xdrs,
4647 (char **)&objp->nfs_resop4_u.opgetfh.object.nfs_fh4_val,
4648 (uint_t *)&objp->nfs_resop4_u.opgetfh.object.nfs_fh4_len,
4649 NFS4_FHSIZE));
4650 case OP_LOOKUP:
4651 return (xdr_int(xdrs,
4652 (int32_t *)&objp->nfs_resop4_u.oplookup.status));
4653 case OP_OPEN:
4654 return (xdr_OPEN4res(xdrs, &objp->nfs_resop4_u.opopen));
4655 case OP_CLOSE:
4656 return (xdr_CLOSE4res(xdrs, &objp->nfs_resop4_u.opclose));
4657 case OP_ACCESS:
4658 return (xdr_ACCESS4res(xdrs, &objp->nfs_resop4_u.opaccess));
4659 case OP_READ:
4660 return (xdr_READ4res(xdrs, &objp->nfs_resop4_u.opread));
4661 case OP_WRITE:
4662 return (xdr_WRITE4res(xdrs, &objp->nfs_resop4_u.opwrite));
4663 case OP_DELEGRETURN:
4664 return (xdr_int(xdrs,
4665 (int32_t *)&objp->nfs_resop4_u.opdelegreturn.status));
4666 case OP_LOOKUPP:
4667 return (xdr_int(xdrs,
4668 (int32_t *)&objp->nfs_resop4_u.oplookupp.status));
4669 case OP_READDIR:
4670 return (xdr_READDIR4res(xdrs, &objp->nfs_resop4_u.opreaddir));
4671 case OP_REMOVE:
4672 return (xdr_REMOVE4res(xdrs, &objp->nfs_resop4_u.opremove));
4673
4674 case OP_COMMIT:
4675 if (!xdr_int(xdrs,
4676 (int32_t *)&objp->nfs_resop4_u.opcommit.status))
4677 return (FALSE);
4678 if (objp->nfs_resop4_u.opcommit.status != NFS4_OK)
4679 return (TRUE);
4680 return (xdr_u_longlong_t(xdrs,
4681 (u_longlong_t *)&objp->nfs_resop4_u.opcommit.
4682 writeverf));
4683 case OP_CREATE:
4684 return (xdr_CREATE4res(xdrs, &objp->nfs_resop4_u.opcreate));
4685 case OP_DELEGPURGE:
4686 return (xdr_int(xdrs,
4687 (int32_t *)&objp->nfs_resop4_u.opdelegpurge.status));
4688 case OP_LINK:
4689 return (xdr_LINK4res(xdrs, &objp->nfs_resop4_u.oplink));
4690 case OP_LOCK:
4691 return (xdr_LOCK4res(xdrs, &objp->nfs_resop4_u.oplock));
4692 case OP_LOCKT:
4693 return (xdr_LOCKT4res(xdrs, &objp->nfs_resop4_u.oplockt));
4694 case OP_LOCKU:
4695 if (!xdr_int(xdrs,
4696 (int32_t *)&objp->nfs_resop4_u.oplocku.status))
4697 return (FALSE);
4698 if (objp->nfs_resop4_u.oplocku.status != NFS4_OK)
4699 return (TRUE);
4700 if (!xdr_u_int(xdrs,
4701 &objp->nfs_resop4_u.oplocku.lock_stateid.seqid))
4702 return (FALSE);
4703 return (xdr_opaque(xdrs,
4704 objp->nfs_resop4_u.oplocku.lock_stateid.other,
4705 NFS4_OTHER_SIZE));
4706 case OP_NVERIFY:
4707 return (xdr_int(xdrs,
4708 (int32_t *)&objp->nfs_resop4_u.opnverify.status));
4709 case OP_OPENATTR:
4710 return (xdr_int(xdrs,
4711 (int32_t *)&objp->nfs_resop4_u.opopenattr.status));
4712 case OP_OPEN_CONFIRM:
4713 return (xdr_OPEN_CONFIRM4res(xdrs,
4714 &objp->nfs_resop4_u.opopen_confirm));
4715 case OP_OPEN_DOWNGRADE:
4716 return (xdr_OPEN_DOWNGRADE4res(xdrs,
4717 &objp->nfs_resop4_u.opopen_downgrade));
4718 case OP_PUTPUBFH:
4719 return (xdr_int(xdrs,
4720 (int32_t *)&objp->nfs_resop4_u.opputpubfh.status));
4721 case OP_PUTROOTFH:
4722 return (xdr_int(xdrs,
4723 (int32_t *)&objp->nfs_resop4_u.opputrootfh.status));
4724 case OP_READLINK:
4725 return (xdr_READLINK4res(xdrs, &objp->nfs_resop4_u.opreadlink));
4726 case OP_RENAME:
4727 return (xdr_RENAME4res(xdrs, &objp->nfs_resop4_u.oprename));
4728 case OP_RENEW:
4729 return (xdr_int(xdrs,
4730 (int32_t *)&objp->nfs_resop4_u.oprenew.status));
4731 case OP_RESTOREFH:
4732 return (xdr_int(xdrs,
4733 (int32_t *)&objp->nfs_resop4_u.oprestorefh.status));
4734 case OP_SAVEFH:
4735 return (xdr_int(xdrs,
4736 (int32_t *)&objp->nfs_resop4_u.opsavefh.status));
4737 case OP_SECINFO:
4738 if (!xdr_int(xdrs, (int32_t *)&objp->nfs_resop4_u.opsecinfo.
4739 status))
4740 return (FALSE);
4741 if (objp->nfs_resop4_u.opsecinfo.status != NFS4_OK)
4742 return (TRUE);
4743 return (xdr_array(xdrs, (char **)&objp->nfs_resop4_u.opsecinfo.
4744 SECINFO4resok_val,
4745 (uint_t *)&objp->nfs_resop4_u.opsecinfo.
4746 SECINFO4resok_len,
4747 NFS4_SECINFO_LIMIT, sizeof (secinfo4),
4748 (xdrproc_t)xdr_secinfo4));
4749 case OP_SETATTR:
4750 if (!xdr_int(xdrs, (int32_t *)&objp->nfs_resop4_u.opsetattr.
4751 status))
4752 return (FALSE);
4753 return (xdr_bitmap4(xdrs,
4754 &objp->nfs_resop4_u.opsetattr.attrsset));
4755 case OP_SETCLIENTID:
4756 return (xdr_SETCLIENTID4res(xdrs,
4757 &objp->nfs_resop4_u.opsetclientid));
4758 case OP_SETCLIENTID_CONFIRM:
4759 return (xdr_int(xdrs,
4760 (int32_t *)&objp->nfs_resop4_u.opsetclientid_confirm.
4761 status));
4762 case OP_VERIFY:
4763 return (xdr_int(xdrs,
4764 (int32_t *)&objp->nfs_resop4_u.opverify.status));
4765 case OP_RELEASE_LOCKOWNER:
4766 return (xdr_int(xdrs,
4767 (int32_t *)&objp->nfs_resop4_u.oprelease_lockowner.status));
4768 case OP_ILLEGAL:
4769 return (xdr_int(xdrs,
4770 (int32_t *)&objp->nfs_resop4_u.opillegal.status));
4771 }
4772 return (FALSE);
4773 }
4774
4775 static bool_t
4776 xdr_snfs_resop4(XDR *xdrs, nfs_resop4 *objp)
4777 {
4778 uint_t pos;
4779 bool_t ret;
4780
4781 if (xdrs->x_op == XDR_ENCODE)
4782 pos = XDR_GETPOS(xdrs);
4783
4784 if (!xdr_int(xdrs, (int *)&objp->resop))
4785 return (FALSE);
4786
4787 switch (objp->resop) {
4788 case OP_GETFH:
4789 if (!XDR_PUTINT32(xdrs,
4790 (int32_t *)&objp->nfs_resop4_u.opgetfh.status))
4791 return (FALSE);
4792 if (objp->nfs_resop4_u.opgetfh.status != NFS4_OK)
4793 ret = TRUE;
4794 else
4795 ret = xdr_encode_nfs_fh4(xdrs,
4796 &objp->nfs_resop4_u.opgetfh.object);
4797 break;
4798 default:
4799 ret = xdr_nfs_resop4(xdrs, objp);
4800 break;
4801 }
4802
4803 if (ret && xdrs->x_op == XDR_ENCODE)
4804 objp->opsize = XDR_GETPOS(xdrs) - pos;
4805
4806 return (ret);
4807 }
4808
4809 static bool_t
4810 xdr_nfs_resop4_clnt(XDR *xdrs, nfs_resop4 *objp, nfs_argop4 *aobjp)
4811 {
4812 if (!xdr_int(xdrs, (int *)&objp->resop))
4813 return (FALSE);
4814 /*
4815 * These should be ordered by frequency of use
4816 */
4817 switch (objp->resop) {
4818 case OP_PUTFH:
4819 return (xdr_int(xdrs,
4820 (int32_t *)&objp->nfs_resop4_u.opputfh.status));
4821 case OP_GETATTR:
4822 if (!xdr_int(xdrs,
4823 (int32_t *)&objp->nfs_resop4_u.opgetattr.status))
4824 return (FALSE);
4825 if (objp->nfs_resop4_u.opgetattr.status != NFS4_OK)
4826 return (TRUE);
4827 return (xdr_ga_res(xdrs,
4828 (GETATTR4res *)&objp->nfs_resop4_u.opgetattr,
4829 &aobjp->nfs_argop4_u.opgetattr));
4830 case OP_GETFH:
4831 if (!xdr_int(xdrs,
4832 (int32_t *)&objp->nfs_resop4_u.opgetfh.status))
4833 return (FALSE);
4834 if (objp->nfs_resop4_u.opgetfh.status != NFS4_OK)
4835 return (TRUE);
4836 return (xdr_bytes(xdrs,
4837 (char **)&objp->nfs_resop4_u.opgetfh.object.nfs_fh4_val,
4838 (uint_t *)&objp->nfs_resop4_u.opgetfh.object.nfs_fh4_len,
4839 NFS4_FHSIZE));
4840 case OP_LOOKUP:
4841 return (xdr_int(xdrs,
4842 (int32_t *)&objp->nfs_resop4_u.oplookup.status));
4843 case OP_NVERIFY:
4844 return (xdr_int(xdrs,
4845 (int32_t *)&objp->nfs_resop4_u.opnverify.status));
4846 case OP_OPEN:
4847 return (xdr_OPEN4res(xdrs, &objp->nfs_resop4_u.opopen));
4848 case OP_CLOSE:
4849 return (xdr_CLOSE4res(xdrs, &objp->nfs_resop4_u.opclose));
4850 case OP_ACCESS:
4851 return (xdr_ACCESS4res(xdrs, &objp->nfs_resop4_u.opaccess));
4852 case OP_READ:
4853 return (xdr_READ4res_clnt(xdrs, &objp->nfs_resop4_u.opread,
4854 &aobjp->nfs_argop4_u.opread));
4855 case OP_WRITE:
4856 return (xdr_WRITE4res(xdrs, &objp->nfs_resop4_u.opwrite));
4857 case OP_DELEGRETURN:
4858 return (xdr_int(xdrs,
4859 (int32_t *)&objp->nfs_resop4_u.opdelegreturn.status));
4860 case OP_LOOKUPP:
4861 return (xdr_int(xdrs,
4862 (int32_t *)&objp->nfs_resop4_u.oplookupp.status));
4863 case OP_READDIR:
4864 return (xdr_READDIR4res_clnt(xdrs,
4865 &objp->nfs_resop4_u.opreaddirclnt,
4866 &aobjp->nfs_argop4_u.opreaddir));
4867 case OP_REMOVE:
4868 return (xdr_REMOVE4res(xdrs, &objp->nfs_resop4_u.opremove));
4869
4870 case OP_COMMIT:
4871 if (!xdr_int(xdrs,
4872 (int32_t *)&objp->nfs_resop4_u.opcommit.status))
4873 return (FALSE);
4874 if (objp->nfs_resop4_u.opcommit.status != NFS4_OK)
4875 return (TRUE);
4876 return (xdr_u_longlong_t(xdrs,
4877 (u_longlong_t *)&objp->nfs_resop4_u.opcommit.
4878 writeverf));
4879 case OP_CREATE:
4880 return (xdr_CREATE4res(xdrs, &objp->nfs_resop4_u.opcreate));
4881 case OP_DELEGPURGE:
4882 return (xdr_int(xdrs,
4883 (int32_t *)&objp->nfs_resop4_u.opdelegpurge.status));
4884 case OP_LINK:
4885 return (xdr_LINK4res(xdrs, &objp->nfs_resop4_u.oplink));
4886 case OP_LOCK:
4887 return (xdr_LOCK4res(xdrs, &objp->nfs_resop4_u.oplock));
4888 case OP_LOCKT:
4889 return (xdr_LOCKT4res(xdrs, &objp->nfs_resop4_u.oplockt));
4890 case OP_LOCKU:
4891 if (!xdr_int(xdrs,
4892 (int32_t *)&objp->nfs_resop4_u.oplocku.status))
4893 return (FALSE);
4894 if (objp->nfs_resop4_u.oplocku.status != NFS4_OK)
4895 return (TRUE);
4896 if (!xdr_u_int(xdrs,
4897 &objp->nfs_resop4_u.oplocku.lock_stateid.seqid))
4898 return (FALSE);
4899 return (xdr_opaque(xdrs,
4900 objp->nfs_resop4_u.oplocku.lock_stateid.other,
4901 NFS4_OTHER_SIZE));
4902 case OP_OPENATTR:
4903 return (xdr_int(xdrs,
4904 (int32_t *)&objp->nfs_resop4_u.opopenattr.status));
4905 case OP_OPEN_CONFIRM:
4906 return (xdr_OPEN_CONFIRM4res(xdrs,
4907 &objp->nfs_resop4_u.opopen_confirm));
4908 case OP_OPEN_DOWNGRADE:
4909 return (xdr_OPEN_DOWNGRADE4res(xdrs,
4910 &objp->nfs_resop4_u.opopen_downgrade));
4911 case OP_PUTPUBFH:
4912 return (xdr_int(xdrs,
4913 (int32_t *)&objp->nfs_resop4_u.opputpubfh.status));
4914 case OP_PUTROOTFH:
4915 return (xdr_int(xdrs,
4916 (int32_t *)&objp->nfs_resop4_u.opputrootfh.status));
4917 case OP_READLINK:
4918 return (xdr_READLINK4res(xdrs, &objp->nfs_resop4_u.opreadlink));
4919 case OP_RENAME:
4920 return (xdr_RENAME4res(xdrs, &objp->nfs_resop4_u.oprename));
4921 case OP_RENEW:
4922 return (xdr_int(xdrs,
4923 (int32_t *)&objp->nfs_resop4_u.oprenew.status));
4924 case OP_RESTOREFH:
4925 return (xdr_int(xdrs,
4926 (int32_t *)&objp->nfs_resop4_u.oprestorefh.status));
4927 case OP_SAVEFH:
4928 return (xdr_int(xdrs,
4929 (int32_t *)&objp->nfs_resop4_u.opsavefh.status));
4930 case OP_SECINFO:
4931 if (!xdr_int(xdrs, (int32_t *)&objp->nfs_resop4_u.opsecinfo.
4932 status))
4933 return (FALSE);
4934 if (objp->nfs_resop4_u.opsecinfo.status != NFS4_OK)
4935 return (TRUE);
4936 return (xdr_array(xdrs, (char **)&objp->nfs_resop4_u.opsecinfo.
4937 SECINFO4resok_val,
4938 (uint_t *)&objp->nfs_resop4_u.opsecinfo.
4939 SECINFO4resok_len,
4940 ~0, sizeof (secinfo4), (xdrproc_t)xdr_secinfo4));
4941 case OP_SETATTR:
4942 if (!xdr_int(xdrs, (int32_t *)&objp->nfs_resop4_u.opsetattr.
4943 status))
4944 return (FALSE);
4945 return (xdr_bitmap4(xdrs,
4946 &objp->nfs_resop4_u.opsetattr.attrsset));
4947 case OP_SETCLIENTID:
4948 return (xdr_SETCLIENTID4res(xdrs,
4949 &objp->nfs_resop4_u.opsetclientid));
4950 case OP_SETCLIENTID_CONFIRM:
4951 return (xdr_int(xdrs,
4952 (int32_t *)&objp->nfs_resop4_u.opsetclientid_confirm.
4953 status));
4954 case OP_VERIFY:
4955 return (xdr_int(xdrs,
4956 (int32_t *)&objp->nfs_resop4_u.opverify.status));
4957 case OP_RELEASE_LOCKOWNER:
4958 return (xdr_int(xdrs,
4959 (int32_t *)&objp->nfs_resop4_u.oprelease_lockowner.status));
4960 case OP_ILLEGAL:
4961 return (xdr_int(xdrs,
4962 (int32_t *)&objp->nfs_resop4_u.opillegal.status));
4963 }
4964 return (FALSE);
4965 }
4966
4967 bool_t
4968 xdr_COMPOUND4args_clnt(XDR *xdrs, COMPOUND4args_clnt *objp)
4969 {
4970 static int32_t twelve = 12;
4971 static int32_t minorversion = NFS4_MINORVERSION;
4972 uint32_t *ctagp;
4973 rpc_inline_t *ptr;
4974 rdma_chunkinfo_t rci;
4975 struct xdr_ops *xops = xdrrdma_xops();
4976
4977 /*
4978 * XDR_ENCODE only
4979 */
4980 if (xdrs->x_op == XDR_FREE)
4981 return (TRUE);
4982 if (xdrs->x_op == XDR_DECODE)
4983 return (FALSE);
4984
4985 ctagp = (uint32_t *)&nfs4_ctags[objp->ctag].ct_tag;
4986
4987 if ((ptr = XDR_INLINE(xdrs, 5 * BYTES_PER_XDR_UNIT)) != NULL) {
4988 /*
4989 * Efficiently encode fixed length tags, could be longlongs
4990 * but 8 byte XDR alignment not assured
4991 */
4992 IXDR_PUT_U_INT32(ptr, 12);
4993 IXDR_PUT_U_INT32(ptr, ctagp[0]);
4994 IXDR_PUT_U_INT32(ptr, ctagp[1]);
4995 IXDR_PUT_U_INT32(ptr, ctagp[2]);
4996
4997 /*
4998 * Fixed minor version for now
4999 */
5000 IXDR_PUT_U_INT32(ptr, NFS4_MINORVERSION);
5001 } else {
5002 if (!XDR_PUTINT32(xdrs, &twelve))
5003 return (FALSE);
5004 if (!XDR_PUTINT32(xdrs, (int32_t *)&ctagp[0]))
5005 return (FALSE);
5006 if (!XDR_PUTINT32(xdrs, (int32_t *)&ctagp[1]))
5007 return (FALSE);
5008 if (!XDR_PUTINT32(xdrs, (int32_t *)&ctagp[2]))
5009 return (FALSE);
5010 if (!XDR_PUTINT32(xdrs, (int32_t *)&minorversion))
5011 return (FALSE);
5012 }
5013 if (xdrs->x_ops == &xdrrdma_ops || xdrs->x_ops == xops) {
5014 rci.rci_type = RCI_REPLY_CHUNK;
5015 rci.rci_len = MAXPATHLEN * 2;
5016 XDR_CONTROL(xdrs, XDR_RDMA_ADD_CHUNK, &rci);
5017 }
5018
5019 return (xdr_array(xdrs, (char **)&objp->array,
5020 (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5021 sizeof (nfs_argop4), (xdrproc_t)xdr_cnfs_argop4));
5022 }
5023
5024 bool_t
5025 xdr_COMPOUND4args_srv(XDR *xdrs, COMPOUND4args *objp)
5026 {
5027 if (!xdr_bytes(xdrs, (char **)&objp->tag.utf8string_val,
5028 (uint_t *)&objp->tag.utf8string_len,
5029 NFS4_MAX_UTF8STRING))
5030 return (FALSE);
5031 if (!xdr_u_int(xdrs, &objp->minorversion))
5032 return (FALSE);
5033 if (xdrs->x_op != XDR_FREE)
5034 return (xdr_array(xdrs, (char **)&objp->array,
5035 (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5036 sizeof (nfs_argop4), (xdrproc_t)xdr_snfs_argop4));
5037
5038 return (xdr_snfs_argop4_free(xdrs, &objp->array, objp->array_len));
5039 }
5040
5041 bool_t
5042 xdr_COMPOUND4res_clnt(XDR *xdrs, COMPOUND4res_clnt *objp)
5043 {
5044 uint32_t len;
5045 int32_t *ptr;
5046 nfs_argop4 *argop;
5047 nfs_resop4 *resop;
5048
5049 /*
5050 * No XDR_ENCODE
5051 */
5052 if (xdrs->x_op == XDR_ENCODE)
5053 return (FALSE);
5054
5055 if (xdrs->x_op != XDR_FREE) {
5056 if ((ptr = XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT)) != NULL) {
5057 objp->status = IXDR_GET_U_INT32(ptr);
5058 len = IXDR_GET_U_INT32(ptr);
5059 } else {
5060 if (!xdr_int(xdrs, (int32_t *)&objp->status))
5061 return (FALSE);
5062 if (!xdr_u_int(xdrs, (uint32_t *)&len))
5063 return (FALSE);
5064 }
5065 if (len > NFS4_MAX_UTF8STRING)
5066 return (FALSE);
5067 /*
5068 * Ignore the tag
5069 */
5070 if (!XDR_CONTROL(xdrs, XDR_SKIPBYTES, &len))
5071 return (FALSE);
5072
5073 if (!xdr_int(xdrs, (int32_t *)&objp->array_len))
5074 return (FALSE);
5075
5076 if (objp->array_len > objp->argsp->array_len)
5077 return (FALSE);
5078
5079 if (objp->status == NFS4_OK &&
5080 objp->array_len != objp->argsp->array_len)
5081 return (FALSE);
5082
5083 /* Alloc the results array */
5084 argop = objp->argsp->array;
5085 len = objp->array_len * sizeof (nfs_resop4);
5086 objp->decode_len = 0;
5087 objp->array = resop = kmem_zalloc(len, KM_SLEEP);
5088
5089 for (len = 0; len < objp->array_len;
5090 len++, resop++, argop++, objp->decode_len++) {
5091 if (!xdr_nfs_resop4_clnt(xdrs, resop, argop)) {
5092 /*
5093 * Make sure to free anything that may
5094 * have been allocated along the way.
5095 */
5096 xdrs->x_op = XDR_FREE;
5097 (void) xdr_nfs_resop4_free(xdrs, &objp->array,
5098 objp->array_len,
5099 objp->decode_len);
5100 return (FALSE);
5101 }
5102 }
5103 return (TRUE);
5104 }
5105 return (xdr_nfs_resop4_free(xdrs, &objp->array,
5106 objp->array_len, objp->decode_len));
5107 }
5108
5109 bool_t
5110 xdr_COMPOUND4res_srv(XDR *xdrs, COMPOUND4res *objp)
5111 {
5112 if (!xdr_int(xdrs, (int32_t *)&objp->status))
5113 return (FALSE);
5114 if (!xdr_bytes(xdrs, (char **)&objp->tag.utf8string_val,
5115 (uint_t *)&objp->tag.utf8string_len,
5116 NFS4_MAX_UTF8STRING))
5117 return (FALSE);
5118
5119 if (xdrs->x_op != XDR_FREE)
5120 return (xdr_array(xdrs, (char **)&objp->array,
5121 (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5122 sizeof (nfs_resop4), (xdrproc_t)xdr_snfs_resop4));
5123
5124 return (xdr_snfs_resop4_free(xdrs, &objp->array,
5125 objp->array_len, objp->array_len));
5126 }
5127
5128 /*
5129 * NFS server side callback, initiating the callback request so it
5130 * is the RPC client. Must convert from server's internal filehandle
5131 * format to wire format.
5132 */
5133 static bool_t
5134 xdr_snfs_cb_argop4(XDR *xdrs, nfs_cb_argop4 *objp)
5135 {
5136 CB_GETATTR4args *gargs;
5137 CB_RECALL4args *rargs;
5138
5139 ASSERT(xdrs->x_op == XDR_ENCODE);
5140
5141 if (!XDR_PUTINT32(xdrs, (int32_t *)&objp->argop))
5142 return (FALSE);
5143
5144 switch (objp->argop) {
5145 case OP_CB_GETATTR:
5146 gargs = &objp->nfs_cb_argop4_u.opcbgetattr;
5147
5148 if (!xdr_encode_nfs_fh4(xdrs, &gargs->fh))
5149 return (FALSE);
5150 return (xdr_bitmap4(xdrs, &gargs->attr_request));
5151 case OP_CB_RECALL:
5152 rargs = &objp->nfs_cb_argop4_u.opcbrecall;
5153
5154 if (!XDR_PUTINT32(xdrs, (int32_t *)&rargs->stateid.seqid))
5155 return (FALSE);
5156 if (!xdr_opaque(xdrs, rargs->stateid.other, NFS4_OTHER_SIZE))
5157 return (FALSE);
5158 if (!XDR_PUTINT32(xdrs, (int32_t *)&rargs->truncate))
5159 return (FALSE);
5160 return (xdr_encode_nfs_fh4(xdrs, &rargs->fh));
5161 case OP_CB_ILLEGAL:
5162 return (TRUE);
5163 }
5164 return (FALSE);
5165 }
5166
5167 /*
5168 * NFS client side callback, receiving the callback request so it
5169 * is the RPC server. Must treat the file handles as opaque.
5170 */
5171 static bool_t
5172 xdr_cnfs_cb_argop4(XDR *xdrs, nfs_cb_argop4 *objp)
5173 {
5174 CB_GETATTR4args *gargs;
5175 CB_RECALL4args *rargs;
5176
5177 ASSERT(xdrs->x_op != XDR_ENCODE);
5178
5179 if (!xdr_u_int(xdrs, &objp->argop))
5180 return (FALSE);
5181 switch (objp->argop) {
5182 case OP_CB_GETATTR:
5183 gargs = &objp->nfs_cb_argop4_u.opcbgetattr;
5184
5185 if (!xdr_bytes(xdrs, (char **)&gargs->fh.nfs_fh4_val,
5186 (uint_t *)&gargs->fh.nfs_fh4_len, NFS4_FHSIZE))
5187 return (FALSE);
5188 return (xdr_bitmap4(xdrs, &gargs->attr_request));
5189 case OP_CB_RECALL:
5190 rargs = &objp->nfs_cb_argop4_u.opcbrecall;
5191
5192 if (!xdr_u_int(xdrs, &rargs->stateid.seqid))
5193 return (FALSE);
5194 if (!xdr_opaque(xdrs, rargs->stateid.other, NFS4_OTHER_SIZE))
5195 return (FALSE);
5196 if (!xdr_bool(xdrs, &rargs->truncate))
5197 return (FALSE);
5198 return (xdr_bytes(xdrs, (char **)&rargs->fh.nfs_fh4_val,
5199 (uint_t *)&rargs->fh.nfs_fh4_len, NFS4_FHSIZE));
5200 case OP_CB_ILLEGAL:
5201 return (TRUE);
5202 }
5203 return (FALSE);
5204 }
5205
5206 static bool_t
5207 xdr_nfs_cb_resop4(XDR *xdrs, nfs_cb_resop4 *objp)
5208 {
5209 if (!xdr_u_int(xdrs, &objp->resop))
5210 return (FALSE);
5211 switch (objp->resop) {
5212 case OP_CB_GETATTR:
5213 if (!xdr_int(xdrs,
5214 (int32_t *)&objp->nfs_cb_resop4_u.opcbgetattr.
5215 status))
5216 return (FALSE);
5217 if (objp->nfs_cb_resop4_u.opcbgetattr.status != NFS4_OK)
5218 return (TRUE);
5219 return (xdr_fattr4(xdrs,
5220 &objp->nfs_cb_resop4_u.opcbgetattr.
5221 obj_attributes));
5222 case OP_CB_RECALL:
5223 return (xdr_int(xdrs,
5224 (int32_t *)&objp->nfs_cb_resop4_u.opcbrecall.status));
5225 case OP_CB_ILLEGAL:
5226 return (xdr_int(xdrs,
5227 (int32_t *)&objp->nfs_cb_resop4_u.opcbillegal.status));
5228 }
5229 return (FALSE);
5230 }
5231
5232 /*
5233 * The NFS client side callback, RPC server
5234 */
5235 bool_t
5236 xdr_CB_COMPOUND4args_clnt(XDR *xdrs, CB_COMPOUND4args *objp)
5237 {
5238 if (!xdr_bytes(xdrs, (char **)&objp->tag.utf8string_val,
5239 (uint_t *)&objp->tag.utf8string_len,
5240 NFS4_MAX_UTF8STRING))
5241 return (FALSE);
5242 if (!xdr_u_int(xdrs, &objp->minorversion))
5243 return (FALSE);
5244 if (!xdr_u_int(xdrs, &objp->callback_ident))
5245 return (FALSE);
5246 return (xdr_array(xdrs, (char **)&objp->array,
5247 (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5248 sizeof (nfs_cb_argop4), (xdrproc_t)xdr_cnfs_cb_argop4));
5249 }
5250
5251 /*
5252 * The NFS server side callback, RPC client
5253 */
5254 bool_t
5255 xdr_CB_COMPOUND4args_srv(XDR *xdrs, CB_COMPOUND4args *objp)
5256 {
5257 if (!xdr_bytes(xdrs, (char **)&objp->tag.utf8string_val,
5258 (uint_t *)&objp->tag.utf8string_len,
5259 NFS4_MAX_UTF8STRING))
5260 return (FALSE);
5261 if (!xdr_u_int(xdrs, &objp->minorversion))
5262 return (FALSE);
5263 if (!xdr_u_int(xdrs, &objp->callback_ident))
5264 return (FALSE);
5265 return (xdr_array(xdrs, (char **)&objp->array,
5266 (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5267 sizeof (nfs_cb_argop4), (xdrproc_t)xdr_snfs_cb_argop4));
5268 }
5269
5270 bool_t
5271 xdr_CB_COMPOUND4res(XDR *xdrs, CB_COMPOUND4res *objp)
5272 {
5273 if (!xdr_int(xdrs, (int32_t *)&objp->status))
5274 return (FALSE);
5275 if (!xdr_bytes(xdrs, (char **)&objp->tag.utf8string_val,
5276 (uint_t *)&objp->tag.utf8string_len,
5277 NFS4_MAX_UTF8STRING))
5278 return (FALSE);
5279 return (xdr_array(xdrs, (char **)&objp->array,
5280 (uint_t *)&objp->array_len, NFS4_COMPOUND_LIMIT,
5281 sizeof (nfs_cb_resop4), (xdrproc_t)xdr_nfs_cb_resop4));
5282 }
Unleashed OS