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 2010 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * Copyright 2018 Nexenta Systems, Inc.
29  */
30 
31 #include <sys/systm.h>
32 #include <sys/cmn_err.h>
33 #include <nfs/nfs.h>
34 #include <nfs/export.h>
35 #include <nfs/nfs4.h>
36 #include <sys/ddi.h>
37 #include <sys/door.h>
38 #include <sys/sdt.h>
39 #include <nfs/nfssys.h>
40 
41 void	rfs4_init_compound_state(struct compound_state *);
42 
43 bitmap4 rfs4_supported_attrs;
44 int MSG_PRT_DEBUG = FALSE;
45 
46 /* If building with DEBUG enabled, enable mandattr tunable by default */
47 #ifdef DEBUG
48 #ifndef RFS4_SUPPORT_MANDATTR_ONLY
49 #define	RFS4_SUPPORT_MANDATTR_ONLY
50 #endif
51 #endif
52 
53 /*
54  * If building with mandattr only code, disable it by default.
55  * To enable, set rfs4_mandattr_only in /etc/system and reboot.
56  * When building without mandattr ifdef, the compiler should
57  * optimize away the the comparisons because RFS4_MANDATTR_ONLY
58  * is defined to be 0.
59  */
60 #ifdef RFS4_SUPPORT_MANDATTR_ONLY
61 #define	NFS4_LAST_MANDATTR FATTR4_RDATTR_ERROR
62 #define	RFS4_MANDATTR_ONLY rfs4_mandattr_only
63 int rfs4_mandattr_only = 0;
64 #else
65 #define	RFS4_MANDATTR_ONLY 0
66 #endif
67 
68 
69 static void rfs4_ntov_init(void);
70 static int rfs4_fattr4_supported_attrs();
71 static int rfs4_fattr4_type();
72 static int rfs4_fattr4_fh_expire_type();
73 static int rfs4_fattr4_change();
74 static int rfs4_fattr4_size();
75 static int rfs4_fattr4_link_support();
76 static int rfs4_fattr4_symlink_support();
77 static int rfs4_fattr4_named_attr();
78 static int rfs4_fattr4_fsid();
79 static int rfs4_fattr4_unique_handles();
80 static int rfs4_fattr4_lease_time();
81 static int rfs4_fattr4_rdattr_error();
82 static int rfs4_fattr4_acl();
83 static int rfs4_fattr4_aclsupport();
84 static int rfs4_fattr4_archive();
85 static int rfs4_fattr4_cansettime();
86 static int rfs4_fattr4_case_insensitive();
87 static int rfs4_fattr4_case_preserving();
88 static int rfs4_fattr4_chown_restricted();
89 static int rfs4_fattr4_filehandle();
90 static int rfs4_fattr4_fileid();
91 static int rfs4_fattr4_files_avail();
92 static int rfs4_fattr4_files_free();
93 static int rfs4_fattr4_files_total();
94 static int rfs4_fattr4_fs_locations();
95 static int rfs4_fattr4_hidden();
96 static int rfs4_fattr4_homogeneous();
97 static int rfs4_fattr4_maxfilesize();
98 static int rfs4_fattr4_maxlink();
99 static int rfs4_fattr4_maxname();
100 static int rfs4_fattr4_maxread();
101 static int rfs4_fattr4_maxwrite();
102 static int rfs4_fattr4_mimetype();
103 static int rfs4_fattr4_mode();
104 static int rfs4_fattr4_no_trunc();
105 static int rfs4_fattr4_numlinks();
106 static int rfs4_fattr4_owner();
107 static int rfs4_fattr4_owner_group();
108 static int rfs4_fattr4_quota_avail_hard();
109 static int rfs4_fattr4_quota_avail_soft();
110 static int rfs4_fattr4_quota_used();
111 static int rfs4_fattr4_rawdev();
112 static int rfs4_fattr4_space_avail();
113 static int rfs4_fattr4_space_free();
114 static int rfs4_fattr4_space_total();
115 static int rfs4_fattr4_space_used();
116 static int rfs4_fattr4_system();
117 static int rfs4_fattr4_time_access();
118 static int rfs4_fattr4_time_access_set();
119 static int rfs4_fattr4_time_backup();
120 static int rfs4_fattr4_time_create();
121 static int rfs4_fattr4_time_delta();
122 static int rfs4_fattr4_time_metadata();
123 static int rfs4_fattr4_time_modify();
124 static int rfs4_fattr4_time_modify_set();
125 
126 /*
127  * Initialize the supported attributes
128  */
129 void
rfs4_attr_init()130 rfs4_attr_init()
131 {
132 	int i;
133 	struct nfs4_svgetit_arg sarg;
134 	struct compound_state cs;
135 	struct statvfs64 sb;
136 
137 	rfs4_init_compound_state(&cs);
138 	/*
139 	 * This is global state checking, called once. We might be in
140 	 * non-global-zone context here (say a modload happens from a zone
141 	 * process) so in this case, we want the global-zone root vnode.
142 	 */
143 	cs.vp = rootvp;
144 	cs.fh.nfs_fh4_val = NULL;
145 	cs.cr = kcred;
146 
147 	/*
148 	 * Get all the supported attributes
149 	 */
150 	sarg.op = NFS4ATTR_SUPPORTED;
151 	sarg.cs = &cs;
152 	sarg.vap->va_mask = AT_ALL;
153 	sarg.sbp = &sb;
154 	sarg.flag = 0;
155 	sarg.rdattr_error = NFS4_OK;
156 	sarg.rdattr_error_req = FALSE;
157 	sarg.is_referral = B_FALSE;
158 
159 	rfs4_ntov_init();
160 
161 	rfs4_supported_attrs = 0;
162 	for (i = 0; i < NFS4_MAXNUM_ATTRS; i++) {
163 #ifdef RFS4_SUPPORT_MANDATTR_ONLY
164 		if (rfs4_mandattr_only == TRUE && i > NFS4_LAST_MANDATTR)
165 			continue;
166 #endif
167 		if ((*nfs4_ntov_map[i].sv_getit)(NFS4ATTR_SUPPORTED,
168 		    &sarg, NULL) == 0) {
169 			rfs4_supported_attrs |= nfs4_ntov_map[i].fbit;
170 		}
171 	}
172 }
173 
174 /*
175  * The following rfs4_fattr4_* functions convert between the fattr4
176  * arguments/attributes and the system (e.g. vattr) values. The following
177  * commands are currently in use:
178  *
179  * NFS4ATTR_SUPPORTED: checks if the attribute in question is supported:
180  *	sarg.op = SUPPORTED - all supported attrs
181  *	sarg.op = GETIT - only supported readable attrs
182  *	sarg.op = SETIT - only supported writable attrs
183  *
184  * NFS4ATTR_GETIT: getattr type conversion - convert system values
185  * (e.g. vattr struct) to fattr4 type values to be returned to the
186  * user - usually in response to nfsv4 getattr request.
187  *
188  * NFS4ATTR_SETIT: convert fattr4 type values to system values to use by
189  * setattr. Allows only read/write and write attributes,
190  * even if not supported by the filesystem. Note that ufs only allows setattr
191  * of owner/group, mode, size, atime/mtime.
192  *
193  * NFS4ATTR_VERIT: convert fattr4 type values to system values to use by
194  * verify/nverify. Implemented to allow
195  * almost everything that can be returned by getattr into known structs
196  * (like vfsstat64 or vattr_t), that is, both read only and read/write attrs.
197  * The function will return -1 if it found that the arguments don't match.
198  * This applies to system-wide values that don't require a VOP_GETATTR
199  * or other further checks to verify. It will return no error if they
200  * either match or were retrieved successfully for later checking.
201  *
202  * NFS4ATTR_FREEIT: free up any space allocated by either of the above.
203  * The sargp->op should be either NFS4ATTR_GETIT or NFS4ATTR_SETIT
204  * to indicate which op was used to allocate the space.
205  *
206  * XXX Note: these functions are currently used by the server only. A
207  * XXX different method of conversion is used on the client side.
208  * XXX Eventually combining the two (possibly by adding NFS4ATTR_CLNT_GETIT
209  * XXX and SETIT) may be a cleaner approach.
210  */
211 
212 /*
213  * Mandatory attributes
214  */
215 
216 /* ARGSUSED */
217 static int
rfs4_fattr4_supported_attrs(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)218 rfs4_fattr4_supported_attrs(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
219     union nfs4_attr_u *na)
220 {
221 	int	error = 0;
222 
223 	switch (cmd) {
224 	case NFS4ATTR_SUPPORTED:
225 		if (sarg->op == NFS4ATTR_SETIT)
226 			error = EINVAL;
227 		break;		/* this attr is supported */
228 	case NFS4ATTR_GETIT:
229 		na->supported_attrs = rfs4_supported_attrs;
230 		break;
231 	case NFS4ATTR_SETIT:
232 		/*
233 		 * read-only attr
234 		 */
235 		error = EINVAL;
236 		break;
237 	case NFS4ATTR_VERIT:
238 		/*
239 		 * Compare the input bitmap to the server's bitmap
240 		 */
241 		if (na->supported_attrs != rfs4_supported_attrs) {
242 			error = -1;	/* no match */
243 		}
244 		break;
245 	case NFS4ATTR_FREEIT:
246 		break;
247 	}
248 	return (error);
249 }
250 
251 /*
252  * Translate vnode vtype to nfsv4_ftype.
253  */
254 static nfs_ftype4 vt_to_nf4[] = {
255 	0, NF4REG, NF4DIR, NF4BLK, NF4CHR, NF4LNK, NF4FIFO, 0, 0, NF4SOCK, 0
256 };
257 
258 /* ARGSUSED */
259 static int
rfs4_fattr4_type(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)260 rfs4_fattr4_type(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
261     union nfs4_attr_u *na)
262 {
263 	int		error = 0;
264 
265 	switch (cmd) {
266 	case NFS4ATTR_SUPPORTED:
267 		if (sarg->op == NFS4ATTR_SETIT)
268 			error = EINVAL;
269 		break;		/* this attr is supported */
270 	case NFS4ATTR_GETIT:
271 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_TYPE)) {
272 			error = -1;	/* may be okay if rdattr_error */
273 			break;
274 		}
275 		ASSERT(sarg->vap->va_mask & AT_TYPE);
276 
277 		/*
278 		 * if xattr flag not set, use v4_to_nf4 mapping;
279 		 * otherwise verify xattr flag is in sync with va_type
280 		 * and set xattr types.
281 		 */
282 		if (! (sarg->xattr & (FH4_NAMEDATTR | FH4_ATTRDIR)))
283 			na->type = vt_to_nf4[sarg->vap->va_type];
284 		else {
285 			/*
286 			 * FH4 flag was set.  Dir type maps to attrdir,
287 			 * and all other types map to namedattr.
288 			 */
289 			if (sarg->vap->va_type == VDIR)
290 				na->type = NF4ATTRDIR;
291 			else
292 				na->type = NF4NAMEDATTR;
293 		}
294 		break;
295 	case NFS4ATTR_SETIT:
296 		/*
297 		 * read-only attr
298 		 */
299 		error = EINVAL;
300 		break;
301 	case NFS4ATTR_VERIT:
302 		/*
303 		 * Compare the input type to the object type on server
304 		 */
305 		ASSERT(sarg->vap->va_mask & AT_TYPE);
306 		if (sarg->vap->va_type != nf4_to_vt[na->type])
307 			error = -1;	/* no match */
308 		break;
309 	case NFS4ATTR_FREEIT:
310 		break;
311 	}
312 	return (error);
313 }
314 
315 /* ARGSUSED */
316 static int
fattr4_get_fh_expire_type(struct exportinfo * exi,uint32_t * fh_expire_typep)317 fattr4_get_fh_expire_type(struct exportinfo *exi, uint32_t *fh_expire_typep)
318 {
319 #ifdef	VOLATILE_FH_TEST
320 	int	ex_flags;
321 
322 	if (exi == NULL)
323 		return (ESTALE);
324 	ex_flags = exi->exi_export.ex_flags;
325 	if ((ex_flags & (EX_VOLFH | EX_VOLRNM | EX_VOLMIG | EX_NOEXPOPEN))
326 	    == 0) {
327 		*fh_expire_typep = FH4_PERSISTENT;
328 		return (0);
329 	}
330 	*fh_expire_typep = 0;
331 
332 	if (ex_flags & EX_NOEXPOPEN) {
333 		/* file handles should not expire with open - not used */
334 		*fh_expire_typep = FH4_NOEXPIRE_WITH_OPEN;
335 	}
336 	if (ex_flags & EX_VOLFH) {
337 		/*
338 		 * file handles may expire any time - on share here.
339 		 * If volatile any, no need to check other flags.
340 		 */
341 		*fh_expire_typep |= FH4_VOLATILE_ANY;
342 		return (0);
343 	}
344 	if (ex_flags & EX_VOLRNM) {
345 		/* file handles may expire on rename */
346 		*fh_expire_typep |= FH4_VOL_RENAME;
347 	}
348 	if (ex_flags & EX_VOLMIG) {
349 		/* file handles may expire on migration - not used */
350 		*fh_expire_typep |= FH4_VOL_MIGRATION;
351 	}
352 #else	/* not VOLATILE_FH_TEST */
353 	*fh_expire_typep = FH4_PERSISTENT;
354 #endif	/* VOLATILE_FH_TEST */
355 
356 	return (0);
357 }
358 
359 /*
360  * At this point the only volatile filehandles we allow (for test purposes
361  * only) are either fh's that expire when the filesystem is shared (reshared),
362  * fh's that expire on a rename and persistent ones.
363  */
364 /* ARGSUSED */
365 static int
rfs4_fattr4_fh_expire_type(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)366 rfs4_fattr4_fh_expire_type(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
367     union nfs4_attr_u *na)
368 {
369 	uint32_t fh_expire_type;
370 	int error = 0;
371 
372 	switch (cmd) {
373 	case NFS4ATTR_SUPPORTED:
374 		if (sarg->op == NFS4ATTR_SETIT)
375 			error = EINVAL;
376 		break;		/* this attr is supported */
377 	case NFS4ATTR_GETIT:
378 		error = fattr4_get_fh_expire_type(sarg->cs->exi,
379 		    &na->fh_expire_type);
380 		break;
381 	case NFS4ATTR_SETIT:
382 		/*
383 		 * read-only attr
384 		 */
385 		error = EINVAL;
386 		break;
387 	case NFS4ATTR_VERIT:
388 		error = fattr4_get_fh_expire_type(sarg->cs->exi,
389 		    &fh_expire_type);
390 		if (!error && (na->fh_expire_type != fh_expire_type))
391 			error = -1;	/* no match */
392 		break;
393 	case NFS4ATTR_FREEIT:
394 		break;
395 	}
396 	return (error);
397 }
398 
399 static int
fattr4_get_change(struct nfs4_svgetit_arg * sarg,fattr4_change * changep)400 fattr4_get_change(struct nfs4_svgetit_arg *sarg, fattr4_change *changep)
401 {
402 	vattr_t vap2[1], *vap = sarg->vap;
403 	struct compound_state *cs = sarg->cs;
404 	vnode_t *vp = cs->vp;
405 	nfsstat4 status;
406 	timespec_t vis_change;
407 
408 	if ((vap->va_mask & AT_CTIME) == 0) {
409 		if (sarg->rdattr_error && (vp == NULL)) {
410 			return (-1);	/* may be okay if rdattr_error */
411 		}
412 		ASSERT(vp != NULL);
413 		vap = vap2;
414 		vap->va_mask = AT_CTIME;
415 		status = rfs4_vop_getattr(vp, vap, 0, cs->cr);
416 		if (status != NFS4_OK)
417 			return (geterrno4(status));
418 	}
419 	NFS4_SET_FATTR4_CHANGE(*changep, vap->va_ctime);
420 
421 	if (nfs_visible_change(cs->exi, vp, &vis_change)) {
422 		fattr4_change visch;
423 		NFS4_SET_FATTR4_CHANGE(visch, vis_change);
424 		if (visch > *changep)
425 			*changep = visch;
426 	}
427 
428 	return (0);
429 }
430 
431 /* ARGSUSED */
432 static int
rfs4_fattr4_change(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)433 rfs4_fattr4_change(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
434     union nfs4_attr_u *na)
435 {
436 	int error = 0;
437 	fattr4_change change;
438 	uint_t mask;
439 	vattr_t *vap = sarg->vap;
440 
441 	switch (cmd) {
442 	case NFS4ATTR_SUPPORTED:
443 		if (sarg->op == NFS4ATTR_SETIT)
444 			error = EINVAL;
445 		break;		/* this attr is supported */
446 	case NFS4ATTR_GETIT:
447 		error = fattr4_get_change(sarg, &na->change);
448 		break;
449 	case NFS4ATTR_SETIT:
450 		/*
451 		 * read-only attr
452 		 */
453 		error = EINVAL;
454 		break;
455 	case NFS4ATTR_VERIT:
456 		mask = vap->va_mask;
457 		vap->va_mask &= ~AT_CTIME;	/* force a VOP_GETATTR */
458 		error = fattr4_get_change(sarg, &change);
459 		vap->va_mask = mask;
460 		if (!error && (na->change != change))
461 			error = -1;
462 		break;
463 	case NFS4ATTR_FREEIT:
464 		break;
465 	}
466 	return (error);
467 }
468 
469 /* ARGSUSED */
470 static int
rfs4_fattr4_size(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)471 rfs4_fattr4_size(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
472     union nfs4_attr_u *na)
473 {
474 	int	error = 0;
475 
476 	switch (cmd) {
477 	case NFS4ATTR_SUPPORTED:
478 		break;		/* this attr is supported */
479 	case NFS4ATTR_GETIT:
480 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_SIZE)) {
481 			error = -1;	/* may be okay if rdattr_error */
482 			break;
483 		}
484 		ASSERT(sarg->vap->va_mask & AT_SIZE);
485 		na->size = sarg->vap->va_size;
486 		break;
487 	case NFS4ATTR_SETIT:
488 		ASSERT(sarg->vap->va_mask & AT_SIZE);
489 		sarg->vap->va_size = na->size;
490 		break;
491 	case NFS4ATTR_VERIT:
492 		ASSERT(sarg->vap->va_mask & AT_SIZE);
493 		if (sarg->vap->va_size != na->size)
494 			error = -1;	/* no match */
495 		break;
496 	case NFS4ATTR_FREEIT:
497 		break;
498 	}
499 	return (error);
500 }
501 
502 /*
503  * XXX - need VOP extension to ask file system (e.g. pcfs) if it supports
504  * hard links.
505  */
506 /* ARGSUSED */
507 static int
rfs4_fattr4_link_support(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)508 rfs4_fattr4_link_support(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
509     union nfs4_attr_u *na)
510 {
511 	int error = 0;
512 
513 	switch (cmd) {
514 	case NFS4ATTR_SUPPORTED:
515 		if (sarg->op == NFS4ATTR_SETIT)
516 			error = EINVAL;
517 		break;		/* this attr is supported */
518 	case NFS4ATTR_GETIT:
519 		na->link_support = TRUE;
520 		break;
521 	case NFS4ATTR_SETIT:
522 		/*
523 		 * read-only attr
524 		 */
525 		error = EINVAL;
526 		break;
527 	case NFS4ATTR_VERIT:
528 		if (!na->link_support)
529 			error = -1;	/* no match */
530 		break;
531 	case NFS4ATTR_FREEIT:
532 		break;
533 	}
534 	return (error);
535 }
536 
537 /*
538  * XXX - need VOP extension to ask file system (e.g. pcfs) if it supports
539  * sym links.
540  */
541 /* ARGSUSED */
542 static int
rfs4_fattr4_symlink_support(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)543 rfs4_fattr4_symlink_support(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
544     union nfs4_attr_u *na)
545 {
546 	int error = 0;
547 
548 	switch (cmd) {
549 	case NFS4ATTR_SUPPORTED:
550 		if (sarg->op == NFS4ATTR_SETIT)
551 			error = EINVAL;
552 		break;		/* this attr is supported */
553 	case NFS4ATTR_GETIT:
554 		na->symlink_support = TRUE;
555 		break;
556 	case NFS4ATTR_SETIT:
557 		/*
558 		 * read-only attr
559 		 */
560 		error = EINVAL;
561 		break;
562 	case NFS4ATTR_VERIT:
563 		if (!na->symlink_support)
564 			error = -1;	/* no match */
565 		break;
566 	case NFS4ATTR_FREEIT:
567 		break;
568 	}
569 	return (error);
570 }
571 
572 /* ARGSUSED */
573 static int
rfs4_fattr4_named_attr(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)574 rfs4_fattr4_named_attr(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
575     union nfs4_attr_u *na)
576 {
577 	int error = 0;
578 	ulong_t val;
579 
580 	switch (cmd) {
581 	case NFS4ATTR_SUPPORTED:
582 		if (sarg->op == NFS4ATTR_SETIT)
583 			error = EINVAL;
584 		break;		/* this attr is supported */
585 	case NFS4ATTR_GETIT:
586 		if (sarg->rdattr_error && (sarg->cs->vp == NULL)) {
587 			error = -1;	/* may be okay if rdattr_error */
588 			break;
589 		}
590 		ASSERT(sarg->cs->vp != NULL);
591 
592 		/*
593 		 * Solaris xattr model requires that VFS_XATTR is set
594 		 * in file systems enabled for generic xattr.  If VFS_XATTR
595 		 * not set, no need to call pathconf for _PC_XATTR_EXISTS..
596 		 *
597 		 * However the VFS_XATTR flag doesn't indicate sysattr support
598 		 * so always check for sysattrs and then only do the
599 		 * _PC_XATTR_EXISTS pathconf if needed.
600 		 */
601 
602 		val = 0;
603 		error = VOP_PATHCONF(sarg->cs->vp, _PC_SATTR_EXISTS,
604 		    &val, sarg->cs->cr, NULL);
605 		if ((error || val == 0) &&
606 		    sarg->cs->vp->v_vfsp->vfs_flag & VFS_XATTR) {
607 			error = VOP_PATHCONF(sarg->cs->vp,
608 			    _PC_XATTR_EXISTS, &val, sarg->cs->cr, NULL);
609 			if (error)
610 				break;
611 		}
612 		na->named_attr = (val ? TRUE : FALSE);
613 		break;
614 	case NFS4ATTR_SETIT:
615 		/*
616 		 * read-only attr
617 		 */
618 		error = EINVAL;
619 		break;
620 	case NFS4ATTR_VERIT:
621 		ASSERT(sarg->cs->vp != NULL);
622 		if (sarg->cs->vp->v_vfsp->vfs_flag & VFS_XATTR) {
623 			error = VOP_PATHCONF(sarg->cs->vp, _PC_SATTR_EXISTS,
624 			    &val, sarg->cs->cr, NULL);
625 			if (error || val == 0)
626 				error = VOP_PATHCONF(sarg->cs->vp,
627 				    _PC_XATTR_EXISTS, &val,
628 				    sarg->cs->cr, NULL);
629 			if (error)
630 				break;
631 		} else
632 			val = 0;
633 		if (na->named_attr != (val ? TRUE : FALSE))
634 			error = -1;	/* no match */
635 		break;
636 	case NFS4ATTR_FREEIT:
637 		break;
638 	}
639 	return (error);
640 }
641 
642 /* ARGSUSED */
643 static int
rfs4_fattr4_fsid(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)644 rfs4_fattr4_fsid(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
645     union nfs4_attr_u *na)
646 {
647 	int error = 0;
648 	int *pmaj = (int *)&na->fsid.major;
649 
650 	/*
651 	 * fsid_t is 64bits so it fits completely in fattr4_fsid.major.
652 	 * fattr4_fsid.minor is always set to 0 since it isn't needed (yet).
653 	 */
654 	switch (cmd) {
655 	case NFS4ATTR_SUPPORTED:
656 		if (sarg->op == NFS4ATTR_SETIT)
657 			error = EINVAL;
658 		break;		/* this attr is supported */
659 	case NFS4ATTR_GETIT:
660 		if (sarg->is_referral) {
661 			na->fsid.major = 1;
662 			na->fsid.minor = 0;
663 		} else if (sarg->cs->exi->exi_volatile_dev) {
664 			pmaj[0] = sarg->cs->exi->exi_fsid.val[0];
665 			pmaj[1] = sarg->cs->exi->exi_fsid.val[1];
666 			na->fsid.minor = 0;
667 		} else {
668 			na->fsid.major = getmajor(sarg->vap->va_fsid);
669 			na->fsid.minor = getminor(sarg->vap->va_fsid);
670 		}
671 		break;
672 	case NFS4ATTR_SETIT:
673 		error = EINVAL;
674 		break;
675 	case NFS4ATTR_VERIT:
676 		if (sarg->is_referral) {
677 			if (na->fsid.major != 1 ||
678 			    na->fsid.minor != 0)
679 				error = -1;
680 		} else if (sarg->cs->exi->exi_volatile_dev) {
681 			if (pmaj[0] != sarg->cs->exi->exi_fsid.val[0] ||
682 			    pmaj[1] != sarg->cs->exi->exi_fsid.val[1] ||
683 			    na->fsid.minor != 0)
684 				error = -1;
685 		} else {
686 			if (na->fsid.major != getmajor(sarg->vap->va_fsid) ||
687 			    na->fsid.minor != getminor(sarg->vap->va_fsid))
688 				error = -1;
689 		}
690 		break;
691 	case NFS4ATTR_FREEIT:
692 		break;
693 	}
694 	return (error);
695 }
696 
697 /* ARGSUSED */
698 static int
rfs4_fattr4_unique_handles(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)699 rfs4_fattr4_unique_handles(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
700     union nfs4_attr_u *na)
701 {
702 	/*
703 	 * XXX
704 	 * For now, we can't support this. Problem of /export, beinging
705 	 * a file system, /export/a and /export/b shared separately,
706 	 * and /export/a/l and /export/b/l are ahrd links of each other.
707 	 */
708 	int error = 0;
709 
710 	switch (cmd) {
711 	case NFS4ATTR_SUPPORTED:
712 		if (sarg->op == NFS4ATTR_SETIT)
713 			error = EINVAL;
714 		break;		/* this attr is supported */
715 	case NFS4ATTR_GETIT:
716 		na->unique_handles = FALSE;
717 		break;
718 	case NFS4ATTR_SETIT:
719 		/*
720 		 * read-only attr
721 		 */
722 		error = EINVAL;
723 		break;
724 	case NFS4ATTR_VERIT:
725 		if (na->unique_handles)
726 			error = -1;	/* no match */
727 		break;
728 	case NFS4ATTR_FREEIT:
729 		break;
730 	}
731 	return (error);
732 }
733 
734 /* ARGSUSED */
735 static int
rfs4_fattr4_lease_time(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)736 rfs4_fattr4_lease_time(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
737     union nfs4_attr_u *na)
738 {
739 	int error = 0;
740 
741 	switch (cmd) {
742 	case NFS4ATTR_SUPPORTED:
743 		if (sarg->op == NFS4ATTR_SETIT)
744 			error = EINVAL;
745 		break;		/* this attr is supported */
746 	case NFS4ATTR_GETIT:
747 		na->lease_time = rfs4_lease_time;
748 		break;
749 	case NFS4ATTR_SETIT:
750 		/*
751 		 * read-only attr
752 		 */
753 		error = EINVAL;
754 		break;
755 	case NFS4ATTR_VERIT:
756 		if (na->lease_time != rfs4_lease_time)
757 			error = -1;	/* no match */
758 		break;
759 	case NFS4ATTR_FREEIT:
760 		break;
761 	}
762 	return (error);
763 }
764 
765 /* ARGSUSED */
766 static int
rfs4_fattr4_rdattr_error(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)767 rfs4_fattr4_rdattr_error(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
768     union nfs4_attr_u *na)
769 {
770 	int error = 0;
771 
772 	switch (cmd) {
773 	case NFS4ATTR_SUPPORTED:
774 		if ((sarg->op == NFS4ATTR_SETIT) ||
775 		    (sarg->op == NFS4ATTR_VERIT))
776 			error = EINVAL;
777 		break;		/* this attr is supported */
778 	case NFS4ATTR_GETIT:
779 		ASSERT(sarg->rdattr_error_req);
780 		na->rdattr_error = sarg->rdattr_error;
781 		break;
782 	case NFS4ATTR_SETIT:
783 	case NFS4ATTR_VERIT:
784 		/*
785 		 * read-only attr
786 		 */
787 		error = EINVAL;
788 		break;
789 	case NFS4ATTR_FREEIT:
790 		break;
791 	}
792 	return (error);
793 }
794 
795 /*
796  * Server side compare of a filehandle from the wire to a native
797  * server filehandle.
798  */
799 static int
rfs4fhcmp(nfs_fh4 * wirefh,nfs_fh4 * srvfh)800 rfs4fhcmp(nfs_fh4 *wirefh, nfs_fh4 *srvfh)
801 {
802 	nfs_fh4_fmt_t fh;
803 
804 	ASSERT(IS_P2ALIGNED(wirefh->nfs_fh4_val, sizeof (uint32_t)));
805 
806 	bzero(&fh, sizeof (nfs_fh4_fmt_t));
807 	if (!xdr_inline_decode_nfs_fh4((uint32_t *)wirefh->nfs_fh4_val, &fh,
808 	    wirefh->nfs_fh4_len))
809 		return (1);
810 
811 	return (bcmp(srvfh->nfs_fh4_val, &fh, srvfh->nfs_fh4_len));
812 }
813 
814 /* ARGSUSED */
815 static int
rfs4_fattr4_filehandle(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)816 rfs4_fattr4_filehandle(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
817     union nfs4_attr_u *na)
818 {
819 	nfs_fh4 *fh;
820 
821 	switch (cmd) {
822 	case NFS4ATTR_SUPPORTED:
823 		if (sarg->op == NFS4ATTR_SETIT)
824 			return (EINVAL);
825 		return (0);	/* this attr is supported */
826 	case NFS4ATTR_GETIT:
827 		/*
828 		 * If sarg->cs->fh is all zeros then should makefh a new
829 		 * one, otherwise, copy that one over.
830 		 */
831 		fh = &sarg->cs->fh;
832 		if (sarg->cs->fh.nfs_fh4_len == 0) {
833 			if (sarg->rdattr_error && (sarg->cs->vp == NULL))
834 				return (-1);	/* okay if rdattr_error */
835 			ASSERT(sarg->cs->vp != NULL);
836 			na->filehandle.nfs_fh4_val =
837 			    kmem_alloc(NFS_FH4_LEN, KM_SLEEP);
838 			return (makefh4(&na->filehandle, sarg->cs->vp,
839 			    sarg->cs->exi));
840 		}
841 		na->filehandle.nfs_fh4_val =
842 		    kmem_alloc(fh->nfs_fh4_len, KM_SLEEP);
843 		nfs_fh4_copy(fh, &na->filehandle);
844 		return (0);
845 	case NFS4ATTR_SETIT:
846 		/*
847 		 * read-only attr
848 		 */
849 		return (EINVAL);
850 	case NFS4ATTR_VERIT:
851 		/*
852 		 * A verify of a filehandle will have the client sending
853 		 * the raw format which needs to be compared to the
854 		 * native format.
855 		 */
856 		if (rfs4fhcmp(&na->filehandle, &sarg->cs->fh) == 1)
857 			return (-1);	/* no match */
858 		return (0);
859 	case NFS4ATTR_FREEIT:
860 		if (sarg->op != NFS4ATTR_GETIT)
861 			return (0);
862 		if (na->filehandle.nfs_fh4_val == NULL)
863 			return (0);
864 		kmem_free(na->filehandle.nfs_fh4_val,
865 		    na->filehandle.nfs_fh4_len);
866 		na->filehandle.nfs_fh4_val = NULL;
867 		na->filehandle.nfs_fh4_len = 0;
868 		return (0);
869 	}
870 	return (0);
871 }
872 
873 /*
874  * Recommended attributes
875  */
876 
877 /* ARGSUSED */
878 static int
rfs4_fattr4_acl(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)879 rfs4_fattr4_acl(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
880     union nfs4_attr_u *na)
881 {
882 	int error = 0;
883 	vsecattr_t vs_native, vs_ace4;
884 	ulong_t whichacl;
885 	nfsstat4 status;
886 	vattr_t va, *vap = sarg->vap;
887 	vnode_t *vp = sarg->cs->vp;
888 
889 	if (RFS4_MANDATTR_ONLY)
890 		return (ENOTSUP);
891 
892 	switch (cmd) {
893 	case NFS4ATTR_SUPPORTED:
894 		break;
895 
896 	case NFS4ATTR_VERIT:
897 	case NFS4ATTR_GETIT:
898 		if (sarg->rdattr_error && (vp == NULL)) {
899 			return (-1);
900 		}
901 		ASSERT(vp != NULL);
902 		bzero(&vs_native, sizeof (vs_native));
903 
904 		/* see which ACLs fs supports */
905 		error = VOP_PATHCONF(vp, _PC_ACL_ENABLED, &whichacl,
906 		    sarg->cs->cr, NULL);
907 		if (error != 0) {
908 			/*
909 			 * If we got an error, then the filesystem
910 			 * likely does not understand the _PC_ACL_ENABLED
911 			 * pathconf.  In this case, we fall back to trying
912 			 * POSIX-draft (aka UFS-style) ACLs, since that's
913 			 * the behavior used by earlier version of NFS.
914 			 */
915 			error = 0;
916 			whichacl = _ACL_ACLENT_ENABLED;
917 		}
918 
919 		if (!(whichacl & (_ACL_ACE_ENABLED | _ACL_ACLENT_ENABLED))) {
920 			/*
921 			 * If the file system supports neither ACE nor
922 			 * ACLENT ACLs we will fall back to UFS-style ACLs
923 			 * like we did above if there was an error upon
924 			 * calling VOP_PATHCONF.
925 			 *
926 			 * ACE and ACLENT type ACLs are the only interfaces
927 			 * supported thus far.  If any other bits are set on
928 			 * 'whichacl' upon return from VOP_PATHCONF, we will
929 			 * ignore them.
930 			 */
931 			whichacl = _ACL_ACLENT_ENABLED;
932 		}
933 
934 		if (whichacl & _ACL_ACE_ENABLED)
935 			vs_native.vsa_mask = VSA_ACE | VSA_ACECNT;
936 		else if (whichacl & _ACL_ACLENT_ENABLED)
937 			vs_native.vsa_mask = VSA_ACL | VSA_ACLCNT |
938 			    VSA_DFACL | VSA_DFACLCNT;
939 
940 		if (error != 0)
941 			break;
942 
943 		/* get the ACL, and translate it into nfsace4 style */
944 		error = VOP_GETSECATTR(vp, &vs_native,
945 		    0, sarg->cs->cr, NULL);
946 		if (error != 0)
947 			break;
948 		if (whichacl & _ACL_ACE_ENABLED) {
949 			error = vs_acet_to_ace4(&vs_native, &vs_ace4, TRUE);
950 			vs_acet_destroy(&vs_native);
951 		} else {
952 			error = vs_aent_to_ace4(&vs_native, &vs_ace4,
953 			    vp->v_type == VDIR, TRUE);
954 			vs_aent_destroy(&vs_native);
955 		}
956 		if (error != 0)
957 			break;
958 
959 		if (cmd == NFS4ATTR_GETIT) {
960 			na->acl.fattr4_acl_len = vs_ace4.vsa_aclcnt;
961 			/* see case NFS4ATTR_FREEIT for this being freed */
962 			na->acl.fattr4_acl_val = vs_ace4.vsa_aclentp;
963 		} else {
964 			if (na->acl.fattr4_acl_len != vs_ace4.vsa_aclcnt)
965 				error = -1; /* no match */
966 			else if (ln_ace4_cmp(na->acl.fattr4_acl_val,
967 			    vs_ace4.vsa_aclentp,
968 			    vs_ace4.vsa_aclcnt) != 0)
969 				error = -1; /* no match */
970 		}
971 
972 		break;
973 
974 	case NFS4ATTR_SETIT:
975 		if (sarg->rdattr_error && (vp == NULL)) {
976 			return (-1);
977 		}
978 		ASSERT(vp != NULL);
979 
980 		/* prepare vs_ace4 from fattr4 data */
981 		bzero(&vs_ace4, sizeof (vs_ace4));
982 		vs_ace4.vsa_mask = VSA_ACE | VSA_ACECNT;
983 		vs_ace4.vsa_aclcnt = na->acl.fattr4_acl_len;
984 		vs_ace4.vsa_aclentp = na->acl.fattr4_acl_val;
985 		vs_ace4.vsa_aclentsz = vs_ace4.vsa_aclcnt * sizeof (ace_t);
986 		/* make sure we have correct owner/group */
987 		if ((vap->va_mask & (AT_UID | AT_GID)) !=
988 		    (AT_UID | AT_GID)) {
989 			vap = &va;
990 			vap->va_mask = AT_UID | AT_GID;
991 			status = rfs4_vop_getattr(vp,
992 			    vap, 0, sarg->cs->cr);
993 			if (status != NFS4_OK)
994 				return (geterrno4(status));
995 		}
996 
997 		/* see which ACLs the fs supports */
998 		error = VOP_PATHCONF(vp, _PC_ACL_ENABLED, &whichacl,
999 		    sarg->cs->cr, NULL);
1000 		if (error != 0) {
1001 			/*
1002 			 * If we got an error, then the filesystem
1003 			 * likely does not understand the _PC_ACL_ENABLED
1004 			 * pathconf.  In this case, we fall back to trying
1005 			 * POSIX-draft (aka UFS-style) ACLs, since that's
1006 			 * the behavior used by earlier version of NFS.
1007 			 */
1008 			error = 0;
1009 			whichacl = _ACL_ACLENT_ENABLED;
1010 		}
1011 
1012 		if (!(whichacl & (_ACL_ACLENT_ENABLED | _ACL_ACE_ENABLED))) {
1013 			/*
1014 			 * If the file system supports neither ACE nor
1015 			 * ACLENT ACLs we will fall back to UFS-style ACLs
1016 			 * like we did above if there was an error upon
1017 			 * calling VOP_PATHCONF.
1018 			 *
1019 			 * ACE and ACLENT type ACLs are the only interfaces
1020 			 * supported thus far.  If any other bits are set on
1021 			 * 'whichacl' upon return from VOP_PATHCONF, we will
1022 			 * ignore them.
1023 			 */
1024 			whichacl = _ACL_ACLENT_ENABLED;
1025 		}
1026 
1027 		if (whichacl & _ACL_ACE_ENABLED) {
1028 			error = vs_ace4_to_acet(&vs_ace4, &vs_native,
1029 			    vap->va_uid, vap->va_gid, TRUE);
1030 			if (error != 0)
1031 				break;
1032 			(void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL);
1033 			error = VOP_SETSECATTR(vp, &vs_native,
1034 			    0, sarg->cs->cr, NULL);
1035 			VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL);
1036 			vs_acet_destroy(&vs_native);
1037 		} else if (whichacl & _ACL_ACLENT_ENABLED) {
1038 			error = vs_ace4_to_aent(&vs_ace4, &vs_native,
1039 			    vap->va_uid, vap->va_gid, vp->v_type == VDIR, TRUE);
1040 			if (error != 0)
1041 				break;
1042 			(void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL);
1043 			error = VOP_SETSECATTR(vp, &vs_native,
1044 			    0, sarg->cs->cr, NULL);
1045 			VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL);
1046 			vs_aent_destroy(&vs_native);
1047 		}
1048 		break;
1049 
1050 	case NFS4ATTR_FREEIT:
1051 		if (sarg->op == NFS4ATTR_GETIT) {
1052 			vs_ace4.vsa_mask = VSA_ACE | VSA_ACECNT;
1053 			vs_ace4.vsa_aclcnt = na->acl.fattr4_acl_len;
1054 			vs_ace4.vsa_aclentp = na->acl.fattr4_acl_val;
1055 			vs_ace4_destroy(&vs_ace4);
1056 		}
1057 		break;
1058 	}
1059 
1060 	return (error);
1061 }
1062 
1063 /* ARGSUSED */
1064 static int
rfs4_fattr4_aclsupport(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1065 rfs4_fattr4_aclsupport(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1066     union nfs4_attr_u *na)
1067 {
1068 	int error = 0;
1069 
1070 	if (RFS4_MANDATTR_ONLY)
1071 		return (ENOTSUP);
1072 
1073 	switch (cmd) {
1074 	case NFS4ATTR_SUPPORTED:
1075 		if (sarg->op == NFS4ATTR_SETIT)
1076 			error = EINVAL;
1077 		break;	/* supported */
1078 	case NFS4ATTR_GETIT:
1079 		na->aclsupport = ACL4_SUPPORT_ALLOW_ACL |
1080 		    ACL4_SUPPORT_DENY_ACL;
1081 		break;
1082 	case NFS4ATTR_SETIT:
1083 		error = EINVAL;
1084 		break;
1085 	case NFS4ATTR_VERIT:
1086 		if (na->aclsupport != (ACL4_SUPPORT_ALLOW_ACL |
1087 		    ACL4_SUPPORT_DENY_ACL))
1088 			error = -1;	/* no match */
1089 		break;
1090 	}
1091 
1092 	return (error);
1093 }
1094 
1095 /* ARGSUSED */
1096 static int
rfs4_fattr4_archive(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1097 rfs4_fattr4_archive(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1098     union nfs4_attr_u *na)
1099 {
1100 	return (ENOTSUP);
1101 }
1102 
1103 /* ARGSUSED */
1104 static int
rfs4_fattr4_cansettime(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1105 rfs4_fattr4_cansettime(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1106     union nfs4_attr_u *na)
1107 {
1108 	int error = 0;
1109 
1110 	if (RFS4_MANDATTR_ONLY)
1111 		return (ENOTSUP);
1112 
1113 	switch (cmd) {
1114 	case NFS4ATTR_SUPPORTED:
1115 		if (sarg->op == NFS4ATTR_SETIT)
1116 			error = EINVAL;
1117 		break;		/* this attr is supported */
1118 	case NFS4ATTR_GETIT:
1119 		na->cansettime = TRUE;
1120 		break;
1121 	case NFS4ATTR_SETIT:
1122 		/*
1123 		 * read-only attr
1124 		 */
1125 		error = EINVAL;
1126 		break;
1127 	case NFS4ATTR_VERIT:
1128 		if (!na->cansettime)
1129 			error = -1;	/* no match */
1130 		break;
1131 	case NFS4ATTR_FREEIT:
1132 		break;
1133 	}
1134 	return (error);
1135 }
1136 
1137 /*
1138  * XXX - need VOP extension to ask file system (e.g. pcfs) if it supports
1139  * case insensitive.
1140  */
1141 /* ARGSUSED */
1142 static int
rfs4_fattr4_case_insensitive(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1143 rfs4_fattr4_case_insensitive(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1144     union nfs4_attr_u *na)
1145 {
1146 	int error = 0;
1147 
1148 	if (RFS4_MANDATTR_ONLY)
1149 		return (ENOTSUP);
1150 
1151 	switch (cmd) {
1152 	case NFS4ATTR_SUPPORTED:
1153 		if (sarg->op == NFS4ATTR_SETIT)
1154 			error = EINVAL;
1155 		break;		/* this attr is supported */
1156 	case NFS4ATTR_GETIT:
1157 		na->case_insensitive = FALSE;
1158 		break;
1159 	case NFS4ATTR_SETIT:
1160 		/*
1161 		 * read-only attr
1162 		 */
1163 		error = EINVAL;
1164 		break;
1165 	case NFS4ATTR_VERIT:
1166 		if (!na->case_insensitive)
1167 			error = -1;	/* no match */
1168 		break;
1169 	case NFS4ATTR_FREEIT:
1170 		break;
1171 	}
1172 	return (error);
1173 }
1174 
1175 /* ARGSUSED */
1176 static int
rfs4_fattr4_case_preserving(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1177 rfs4_fattr4_case_preserving(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1178     union nfs4_attr_u *na)
1179 {
1180 	int error = 0;
1181 
1182 	if (RFS4_MANDATTR_ONLY)
1183 		return (ENOTSUP);
1184 
1185 	switch (cmd) {
1186 	case NFS4ATTR_SUPPORTED:
1187 		if (sarg->op == NFS4ATTR_SETIT)
1188 			error = EINVAL;
1189 		break;		/* this attr is supported */
1190 	case NFS4ATTR_GETIT:
1191 		na->case_preserving = TRUE;
1192 		break;
1193 	case NFS4ATTR_SETIT:
1194 		/*
1195 		 * read-only attr
1196 		 */
1197 		error = EINVAL;
1198 		break;
1199 	case NFS4ATTR_VERIT:
1200 		if (!na->case_preserving)
1201 			error = -1;	/* no match */
1202 		break;
1203 	case NFS4ATTR_FREEIT:
1204 		break;
1205 	}
1206 	return (error);
1207 }
1208 
1209 /* fattr4_chown_restricted should reall be fattr4_chown_allowed */
1210 /* ARGSUSED */
1211 static int
rfs4_fattr4_chown_restricted(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1212 rfs4_fattr4_chown_restricted(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1213     union nfs4_attr_u *na)
1214 {
1215 	int error = 0;
1216 	ulong_t val;
1217 
1218 	if (RFS4_MANDATTR_ONLY)
1219 		return (ENOTSUP);
1220 
1221 	switch (cmd) {
1222 	case NFS4ATTR_SUPPORTED:
1223 		if (sarg->op == NFS4ATTR_SETIT)
1224 			error = EINVAL;
1225 		break;		/* this attr is supported */
1226 	case NFS4ATTR_GETIT:
1227 		if (sarg->rdattr_error && (sarg->cs->vp == NULL)) {
1228 			error = -1;	/* may be okay if rdattr_error */
1229 			break;
1230 		}
1231 		ASSERT(sarg->cs->vp != NULL);
1232 		error = VOP_PATHCONF(sarg->cs->vp,
1233 		    _PC_CHOWN_RESTRICTED, &val, sarg->cs->cr, NULL);
1234 		if (error)
1235 			break;
1236 
1237 		na->chown_restricted = (val == 1);
1238 		break;
1239 	case NFS4ATTR_SETIT:
1240 		/*
1241 		 * read-only attr
1242 		 */
1243 		error = EINVAL;
1244 		break;
1245 	case NFS4ATTR_VERIT:
1246 		ASSERT(sarg->cs->vp != NULL);
1247 		error = VOP_PATHCONF(sarg->cs->vp,
1248 		    _PC_CHOWN_RESTRICTED, &val, sarg->cs->cr, NULL);
1249 		if (error)
1250 			break;
1251 		if (na->chown_restricted != (val == 1))
1252 			error = -1;	/* no match */
1253 		break;
1254 	case NFS4ATTR_FREEIT:
1255 		break;
1256 	}
1257 	return (error);
1258 }
1259 
1260 /* ARGSUSED */
1261 static int
rfs4_fattr4_fileid(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1262 rfs4_fattr4_fileid(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1263     union nfs4_attr_u *na)
1264 {
1265 	int	error = 0;
1266 
1267 	if (RFS4_MANDATTR_ONLY)
1268 		return (ENOTSUP);
1269 
1270 	switch (cmd) {
1271 	case NFS4ATTR_SUPPORTED:
1272 		if (sarg->op == NFS4ATTR_SETIT)
1273 			error = EINVAL;
1274 		break;		/* this attr is supported */
1275 	case NFS4ATTR_GETIT:
1276 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_NODEID)) {
1277 			error = -1;	/* may be okay if rdattr_error */
1278 			break;
1279 		}
1280 		ASSERT(sarg->vap->va_mask & AT_NODEID);
1281 		na->fileid = sarg->vap->va_nodeid;
1282 		break;
1283 	case NFS4ATTR_SETIT:
1284 		/*
1285 		 * read-only attr
1286 		 */
1287 		error = EINVAL;
1288 		break;
1289 	case NFS4ATTR_VERIT:
1290 		ASSERT(sarg->vap->va_mask & AT_NODEID);
1291 		if (sarg->vap->va_nodeid != na->fileid)
1292 			error = -1;	/* no match */
1293 		break;
1294 	case NFS4ATTR_FREEIT:
1295 		break;
1296 	}
1297 	return (error);
1298 }
1299 
1300 /* ARGSUSED */
1301 static int
rfs4_get_mntdfileid(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg)1302 rfs4_get_mntdfileid(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg)
1303 {
1304 	int error = 0;
1305 	vattr_t	*vap, va;
1306 	vnode_t *stubvp = NULL, *vp;
1307 
1308 	vp = sarg->cs->vp;
1309 	sarg->mntdfid_set = FALSE;
1310 
1311 	/*
1312 	 * VROOT object or zone's root, must untraverse.
1313 	 *
1314 	 * NOTE: Not doing reality checks on curzone vs. compound
1315 	 * state vnode because it will mismatch once at initialization
1316 	 * if a non-global-zone triggers the module load, BUT in that case
1317 	 * the vp is literally "/" which has VROOT set.
1318 	 */
1319 	if ((vp->v_flag & VROOT) || VN_IS_CURZONEROOT(vp)) {
1320 
1321 		/* extra hold for vp since untraverse might rele */
1322 		VN_HOLD(vp);
1323 		stubvp = untraverse(vp, ZONE_ROOTVP());
1324 
1325 		/*
1326 		 * If vp/stubvp are same, we must be at system-or-zone
1327 		 * root because untraverse returned same vp
1328 		 * for a VROOT object.  sarg->vap was setup
1329 		 * before we got here, so there's no need to do
1330 		 * another getattr -- just use the one in sarg.
1331 		 */
1332 		if (VN_CMP(vp, stubvp)) {
1333 			ASSERT(VN_IS_CURZONEROOT(vp));
1334 			vap = sarg->vap;
1335 		} else {
1336 			va.va_mask = AT_NODEID;
1337 			vap = &va;
1338 			error = rfs4_vop_getattr(stubvp, vap, 0, sarg->cs->cr);
1339 		}
1340 
1341 		/*
1342 		 * Done with stub, time to rele.  If vp and stubvp
1343 		 * were the same, then we need to rele either vp or
1344 		 * stubvp.  If they weren't the same, then untraverse()
1345 		 * already took case of the extra hold on vp, and only
1346 		 * the stub needs to be rele'd.  Both cases are handled
1347 		 * by unconditionally rele'ing the stub.
1348 		 */
1349 		VN_RELE(stubvp);
1350 	} else
1351 		vap = sarg->vap;
1352 
1353 	/*
1354 	 * At this point, vap should contain "correct" AT_NODEID --
1355 	 * (for V_ROOT case, nodeid of stub, for non-VROOT case,
1356 	 * nodeid of vp).  If error or AT_NODEID not available, then
1357 	 * make the obligatory (yet mysterious) rdattr_error
1358 	 * check that is so common in the attr code.
1359 	 */
1360 	if (!error && (vap->va_mask & AT_NODEID)) {
1361 		sarg->mounted_on_fileid = vap->va_nodeid;
1362 		sarg->mntdfid_set = TRUE;
1363 	} else if (sarg->rdattr_error)
1364 		error = -1;
1365 
1366 	/*
1367 	 * error describes these cases:
1368 	 *	0 : success
1369 	 *	-1: failure due to previous attr processing error (rddir only).
1370 	 *	* : new attr failure  (if rddir, caller will set rdattr_error)
1371 	 */
1372 	return (error);
1373 }
1374 
1375 /* ARGSUSED */
1376 static int
rfs4_fattr4_mounted_on_fileid(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1377 rfs4_fattr4_mounted_on_fileid(nfs4_attr_cmd_t cmd,
1378     struct nfs4_svgetit_arg *sarg, union nfs4_attr_u *na)
1379 {
1380 	int	error = 0;
1381 
1382 	if (RFS4_MANDATTR_ONLY)
1383 		return (ENOTSUP);
1384 
1385 	switch (cmd) {
1386 	case NFS4ATTR_SUPPORTED:
1387 		if (sarg->op == NFS4ATTR_SETIT)
1388 			error = EINVAL;
1389 		break;		/* this attr is supported */
1390 	case NFS4ATTR_GETIT:
1391 	case NFS4ATTR_VERIT:
1392 		if (!sarg->mntdfid_set)
1393 			error = rfs4_get_mntdfileid(cmd, sarg);
1394 
1395 		if (!error && sarg->mntdfid_set) {
1396 			if (cmd == NFS4ATTR_GETIT)
1397 				na->mounted_on_fileid = sarg->mounted_on_fileid;
1398 			else
1399 				if (na->mounted_on_fileid !=
1400 				    sarg->mounted_on_fileid)
1401 					error = -1;
1402 		}
1403 		break;
1404 	case NFS4ATTR_SETIT:
1405 		/* read-only attr */
1406 		error = EINVAL;
1407 		break;
1408 	case NFS4ATTR_FREEIT:
1409 		break;
1410 	}
1411 	return (error);
1412 }
1413 
1414 /* ARGSUSED */
1415 static int
rfs4_fattr4_files_avail(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1416 rfs4_fattr4_files_avail(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1417     union nfs4_attr_u *na)
1418 {
1419 	int	error = 0;
1420 
1421 	if (RFS4_MANDATTR_ONLY)
1422 		return (ENOTSUP);
1423 
1424 	switch (cmd) {
1425 	case NFS4ATTR_SUPPORTED:
1426 		if (sarg->op == NFS4ATTR_SETIT)
1427 			error = EINVAL;
1428 		break;		/* this attr is supported */
1429 	case NFS4ATTR_GETIT:
1430 		if (sarg->rdattr_error && (sarg->sbp == NULL)) {
1431 			error = -1;	/* may be okay if rdattr_error */
1432 			break;
1433 		}
1434 		ASSERT(sarg->sbp != NULL);
1435 		na->files_avail = sarg->sbp->f_favail;
1436 		break;
1437 	case NFS4ATTR_SETIT:
1438 		/*
1439 		 * read-only attr
1440 		 */
1441 		error = EINVAL;
1442 		break;
1443 	case NFS4ATTR_VERIT:
1444 		ASSERT(sarg->sbp != NULL);
1445 		if (sarg->sbp->f_favail != na->files_avail)
1446 			error = -1;	/* no match */
1447 		break;
1448 	case NFS4ATTR_FREEIT:
1449 		break;
1450 	}
1451 	return (error);
1452 }
1453 
1454 /* ARGSUSED */
1455 static int
rfs4_fattr4_files_free(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1456 rfs4_fattr4_files_free(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1457     union nfs4_attr_u *na)
1458 {
1459 	int	error = 0;
1460 
1461 	if (RFS4_MANDATTR_ONLY)
1462 		return (ENOTSUP);
1463 
1464 	switch (cmd) {
1465 	case NFS4ATTR_SUPPORTED:
1466 		if (sarg->op == NFS4ATTR_SETIT)
1467 			error = EINVAL;
1468 		break;		/* this attr is supported */
1469 	case NFS4ATTR_GETIT:
1470 		if (sarg->rdattr_error && (sarg->sbp == NULL)) {
1471 			error = -1;	/* may be okay if rdattr_error */
1472 			break;
1473 		}
1474 		ASSERT(sarg->sbp != NULL);
1475 		na->files_free = sarg->sbp->f_ffree;
1476 		break;
1477 	case NFS4ATTR_SETIT:
1478 		/*
1479 		 * read-only attr
1480 		 */
1481 		error = EINVAL;
1482 		break;
1483 	case NFS4ATTR_VERIT:
1484 		ASSERT(sarg->sbp != NULL);
1485 		if (sarg->sbp->f_ffree != na->files_free)
1486 			error = -1;	/* no match */
1487 		break;
1488 	case NFS4ATTR_FREEIT:
1489 		break;
1490 	}
1491 	return (error);
1492 }
1493 
1494 /* ARGSUSED */
1495 static int
rfs4_fattr4_files_total(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1496 rfs4_fattr4_files_total(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1497     union nfs4_attr_u *na)
1498 {
1499 	int	error = 0;
1500 
1501 	if (RFS4_MANDATTR_ONLY)
1502 		return (ENOTSUP);
1503 
1504 	switch (cmd) {
1505 	case NFS4ATTR_SUPPORTED:
1506 		if (sarg->op == NFS4ATTR_SETIT)
1507 			error = EINVAL;
1508 		break;		/* this attr is supported */
1509 	case NFS4ATTR_GETIT:
1510 		if (sarg->rdattr_error && (sarg->sbp == NULL)) {
1511 			error = -1;	/* may be okay if rdattr_error */
1512 			break;
1513 		}
1514 		ASSERT(sarg->sbp != NULL);
1515 		na->files_total = sarg->sbp->f_files;
1516 		break;
1517 	case NFS4ATTR_SETIT:
1518 		/*
1519 		 * read-only attr
1520 		 */
1521 		error = EINVAL;
1522 		break;
1523 	case NFS4ATTR_VERIT:
1524 		ASSERT(sarg->sbp != NULL);
1525 		if (sarg->sbp->f_files != na->files_total)
1526 			error = -1;	/* no match */
1527 		break;
1528 	case NFS4ATTR_FREEIT:
1529 		break;
1530 	}
1531 	return (error);
1532 }
1533 
1534 static void
rfs4_free_pathname4(pathname4 * pn4)1535 rfs4_free_pathname4(pathname4 *pn4)
1536 {
1537 	int i, len;
1538 	utf8string *utf8s;
1539 
1540 	if (pn4 == NULL || (len = pn4->pathname4_len) == 0 ||
1541 	    (utf8s = pn4->pathname4_val) == NULL)
1542 		return;
1543 
1544 	for (i = 0; i < len; i++, utf8s++) {
1545 		if (utf8s->utf8string_val == NULL ||
1546 		    utf8s->utf8string_len == 0)
1547 			continue;
1548 
1549 		kmem_free(utf8s->utf8string_val, utf8s->utf8string_len);
1550 		utf8s->utf8string_val = NULL;
1551 	}
1552 
1553 	kmem_free(pn4->pathname4_val,
1554 	    sizeof (utf8string) * pn4->pathname4_len);
1555 	pn4->pathname4_val = 0;
1556 }
1557 
1558 static void
rfs4_free_fs_location4(fs_location4 * fsl4)1559 rfs4_free_fs_location4(fs_location4 *fsl4)
1560 {
1561 	if (fsl4 == NULL)
1562 		return;
1563 
1564 	rfs4_free_pathname4((pathname4 *)&fsl4->server_len);
1565 	rfs4_free_pathname4(&fsl4->rootpath);
1566 }
1567 
1568 void
rfs4_free_fs_locations4(fs_locations4 * fsls4)1569 rfs4_free_fs_locations4(fs_locations4 *fsls4)
1570 {
1571 	int i, len;
1572 	fs_location4 *fsl4;
1573 
1574 	if (fsls4 == NULL)
1575 		return;
1576 
1577 	/* free fs_root */
1578 	rfs4_free_pathname4(&fsls4->fs_root);
1579 
1580 	if ((len = fsls4->locations_len) == 0 ||
1581 	    (fsl4 = fsls4->locations_val) == NULL)
1582 		return;
1583 
1584 	/* free fs_location4 */
1585 	for (i = 0; i < len; i++) {
1586 		rfs4_free_fs_location4(fsl4);
1587 		fsl4++;
1588 	}
1589 
1590 	kmem_free(fsls4->locations_val, sizeof (fs_location4) * len);
1591 	fsls4->locations_val = NULL;
1592 }
1593 
1594 /* ARGSUSED */
1595 static int
rfs4_fattr4_fs_locations(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1596 rfs4_fattr4_fs_locations(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1597     union nfs4_attr_u *na)
1598 {
1599 	int error = 0;
1600 	fs_locations4 *fsl;
1601 
1602 	if (RFS4_MANDATTR_ONLY)
1603 		return (ENOTSUP);
1604 
1605 	switch (cmd) {
1606 	case NFS4ATTR_SUPPORTED:
1607 		if (sarg->op == NFS4ATTR_SETIT || sarg->op == NFS4ATTR_VERIT)
1608 			error = EINVAL;
1609 		break;  /* this attr is supported */
1610 
1611 	case NFS4ATTR_GETIT:
1612 	{
1613 		kstat_named_t *stat =
1614 		    sarg->cs->exi->exi_ne->ne_globals->svstat[NFS_V4];
1615 
1616 		fsl = fetch_referral(sarg->cs->vp, sarg->cs->cr);
1617 		if (fsl == NULL)
1618 			(void) memset(&(na->fs_locations), 0,
1619 			    sizeof (fs_locations4));
1620 		else {
1621 			na->fs_locations = *fsl;
1622 			kmem_free(fsl, sizeof (fs_locations4));
1623 		}
1624 		stat[NFS_REFERRALS].value.ui64++;
1625 		break;
1626 	}
1627 	case NFS4ATTR_FREEIT:
1628 		if (sarg->op == NFS4ATTR_SETIT || sarg->op == NFS4ATTR_VERIT)
1629 			error = EINVAL;
1630 		rfs4_free_fs_locations4(&na->fs_locations);
1631 		break;
1632 
1633 	case NFS4ATTR_SETIT:
1634 	case NFS4ATTR_VERIT:
1635 		/*
1636 		 * read-only attr
1637 		 */
1638 		error = EINVAL;
1639 		break;
1640 	}
1641 	return (error);
1642 }
1643 
1644 /* ARGSUSED */
1645 static int
rfs4_fattr4_hidden(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1646 rfs4_fattr4_hidden(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1647     union nfs4_attr_u *na)
1648 {
1649 	return (ENOTSUP);
1650 }
1651 
1652 /* ARGSUSED */
1653 static int
rfs4_fattr4_homogeneous(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1654 rfs4_fattr4_homogeneous(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1655     union nfs4_attr_u *na)
1656 {
1657 	int error = 0;
1658 
1659 	if (RFS4_MANDATTR_ONLY)
1660 		return (ENOTSUP);
1661 
1662 	switch (cmd) {
1663 	case NFS4ATTR_SUPPORTED:
1664 		if (sarg->op == NFS4ATTR_SETIT)
1665 			error = EINVAL;
1666 		break;		/* this attr is supported */
1667 	case NFS4ATTR_GETIT:
1668 		na->homogeneous = TRUE; /* XXX - need a VOP extension */
1669 		break;
1670 	case NFS4ATTR_SETIT:
1671 		/*
1672 		 * read-only attr
1673 		 */
1674 		error = EINVAL;
1675 		break;
1676 	case NFS4ATTR_VERIT:
1677 		if (!na->homogeneous)
1678 			error = -1;	/* no match */
1679 		break;
1680 	case NFS4ATTR_FREEIT:
1681 		break;
1682 	}
1683 	return (error);
1684 }
1685 
1686 /* ARGSUSED */
1687 static int
rfs4_fattr4_maxfilesize(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1688 rfs4_fattr4_maxfilesize(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1689     union nfs4_attr_u *na)
1690 {
1691 	int error = 0;
1692 	ulong_t val;
1693 	fattr4_maxfilesize maxfilesize;
1694 
1695 	if (RFS4_MANDATTR_ONLY)
1696 		return (ENOTSUP);
1697 
1698 	switch (cmd) {
1699 	case NFS4ATTR_SUPPORTED:
1700 		if (sarg->op == NFS4ATTR_SETIT)
1701 			error = EINVAL;
1702 		break;		/* this attr is supported */
1703 	case NFS4ATTR_GETIT:
1704 		if (sarg->rdattr_error && (sarg->cs->vp == NULL)) {
1705 			error = -1;	/* may be okay if rdattr_error */
1706 			break;
1707 		}
1708 		ASSERT(sarg->cs->vp != NULL);
1709 		error = VOP_PATHCONF(sarg->cs->vp, _PC_FILESIZEBITS, &val,
1710 		    sarg->cs->cr, NULL);
1711 		if (error)
1712 			break;
1713 
1714 		/*
1715 		 * If the underlying file system does not support
1716 		 * _PC_FILESIZEBITS, return a reasonable default. Note that
1717 		 * error code on VOP_PATHCONF will be 0, even if the underlying
1718 		 * file system does not support _PC_FILESIZEBITS.
1719 		 */
1720 		if (val == (ulong_t)-1) {
1721 			na->maxfilesize = MAXOFF32_T;
1722 		} else {
1723 			if (val >= (sizeof (uint64_t) * 8))
1724 				na->maxfilesize = INT64_MAX;
1725 			else
1726 				na->maxfilesize = ((1LL << (val - 1)) - 1);
1727 		}
1728 		break;
1729 	case NFS4ATTR_SETIT:
1730 		/*
1731 		 * read-only attr
1732 		 */
1733 		error = EINVAL;
1734 		break;
1735 	case NFS4ATTR_VERIT:
1736 		ASSERT(sarg->cs->vp != NULL);
1737 		error = VOP_PATHCONF(sarg->cs->vp, _PC_FILESIZEBITS, &val,
1738 		    sarg->cs->cr, NULL);
1739 		if (error)
1740 			break;
1741 		/*
1742 		 * If the underlying file system does not support
1743 		 * _PC_FILESIZEBITS, return a reasonable default. Note that
1744 		 * error code on VOP_PATHCONF will be 0, even if the underlying
1745 		 * file system does not support _PC_FILESIZEBITS.
1746 		 */
1747 		if (val == (ulong_t)-1) {
1748 			maxfilesize = MAXOFF32_T;
1749 		} else {
1750 			if (val >= (sizeof (uint64_t) * 8))
1751 				maxfilesize = INT64_MAX;
1752 			else
1753 				maxfilesize = ((1LL << (val - 1)) - 1);
1754 		}
1755 		if (na->maxfilesize != maxfilesize)
1756 			error = -1;	/* no match */
1757 		break;
1758 	case NFS4ATTR_FREEIT:
1759 		break;
1760 	}
1761 	return (error);
1762 }
1763 
1764 /* ARGSUSED */
1765 static int
rfs4_fattr4_maxlink(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1766 rfs4_fattr4_maxlink(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1767     union nfs4_attr_u *na)
1768 {
1769 	int error = 0;
1770 	ulong_t val;
1771 
1772 	if (RFS4_MANDATTR_ONLY)
1773 		return (ENOTSUP);
1774 
1775 	switch (cmd) {
1776 	case NFS4ATTR_SUPPORTED:
1777 		if (sarg->op == NFS4ATTR_SETIT)
1778 			error = EINVAL;
1779 		break;		/* this attr is supported */
1780 	case NFS4ATTR_GETIT:
1781 		if (sarg->rdattr_error && (sarg->cs->vp == NULL)) {
1782 			error = -1;	/* may be okay if rdattr_error */
1783 			break;
1784 		}
1785 		ASSERT(sarg->cs->vp != NULL);
1786 		error = VOP_PATHCONF(sarg->cs->vp, _PC_LINK_MAX, &val,
1787 		    sarg->cs->cr, NULL);
1788 		if (error == 0) {
1789 			na->maxlink = val;
1790 		}
1791 		break;
1792 	case NFS4ATTR_SETIT:
1793 		/*
1794 		 * read-only attr
1795 		 */
1796 		error = EINVAL;
1797 		break;
1798 	case NFS4ATTR_VERIT:
1799 		ASSERT(sarg->cs->vp != NULL);
1800 		error = VOP_PATHCONF(sarg->cs->vp, _PC_LINK_MAX, &val,
1801 		    sarg->cs->cr, NULL);
1802 		if (!error && (na->maxlink != (uint32_t)val))
1803 			error = -1;	/* no match */
1804 		break;
1805 	case NFS4ATTR_FREEIT:
1806 		break;
1807 	}
1808 	return (error);
1809 }
1810 
1811 /* ARGSUSED */
1812 static int
rfs4_fattr4_maxname(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1813 rfs4_fattr4_maxname(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1814     union nfs4_attr_u *na)
1815 {
1816 	int error = 0;
1817 	ulong_t val;
1818 
1819 	if (RFS4_MANDATTR_ONLY)
1820 		return (ENOTSUP);
1821 
1822 	switch (cmd) {
1823 	case NFS4ATTR_SUPPORTED:
1824 		if (sarg->op == NFS4ATTR_SETIT)
1825 			error = EINVAL;
1826 		break;		/* this attr is supported */
1827 	case NFS4ATTR_GETIT:
1828 		if (sarg->rdattr_error && (sarg->cs->vp == NULL)) {
1829 			error = -1;	/* may be okay if rdattr_error */
1830 			break;
1831 		}
1832 		ASSERT(sarg->cs->vp != NULL);
1833 		error = VOP_PATHCONF(sarg->cs->vp, _PC_NAME_MAX, &val,
1834 		    sarg->cs->cr, NULL);
1835 		if (error == 0) {
1836 			na->maxname = val;
1837 		}
1838 		break;
1839 	case NFS4ATTR_SETIT:
1840 		/*
1841 		 * read-only attr
1842 		 */
1843 		error = EINVAL;
1844 		break;
1845 	case NFS4ATTR_VERIT:
1846 		ASSERT(sarg->cs->vp != NULL);
1847 		error = VOP_PATHCONF(sarg->cs->vp, _PC_NAME_MAX, &val,
1848 		    sarg->cs->cr, NULL);
1849 		if (!error && (na->maxname != val))
1850 			error = -1;	/* no match */
1851 		break;
1852 	case NFS4ATTR_FREEIT:
1853 		break;
1854 	}
1855 	return (error);
1856 }
1857 
1858 /* ARGSUSED */
1859 static int
rfs4_fattr4_maxread(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1860 rfs4_fattr4_maxread(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1861     union nfs4_attr_u *na)
1862 {
1863 	int error = 0;
1864 
1865 	if (RFS4_MANDATTR_ONLY)
1866 		return (ENOTSUP);
1867 
1868 	switch (cmd) {
1869 	case NFS4ATTR_SUPPORTED:
1870 		if (sarg->op == NFS4ATTR_SETIT)
1871 			error = EINVAL;
1872 		break;		/* this attr is supported */
1873 	case NFS4ATTR_GETIT:
1874 		na->maxread = rfs4_tsize(sarg->cs->req);
1875 		break;
1876 	case NFS4ATTR_SETIT:
1877 		/*
1878 		 * read-only attr
1879 		 */
1880 		error = EINVAL;
1881 		break;
1882 	case NFS4ATTR_VERIT:
1883 		if (na->maxread != rfs4_tsize(sarg->cs->req))
1884 			error = -1;	/* no match */
1885 		break;
1886 	case NFS4ATTR_FREEIT:
1887 		break;
1888 	}
1889 	return (error);
1890 }
1891 
1892 /* ARGSUSED */
1893 static int
rfs4_fattr4_maxwrite(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1894 rfs4_fattr4_maxwrite(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1895     union nfs4_attr_u *na)
1896 {
1897 	int error = 0;
1898 
1899 	if (RFS4_MANDATTR_ONLY)
1900 		return (ENOTSUP);
1901 
1902 	switch (cmd) {
1903 	case NFS4ATTR_SUPPORTED:
1904 		if (sarg->op == NFS4ATTR_SETIT)
1905 			error = EINVAL;
1906 		break;		/* this attr is supported */
1907 	case NFS4ATTR_GETIT:
1908 		na->maxwrite = rfs4_tsize(sarg->cs->req);
1909 		break;
1910 	case NFS4ATTR_SETIT:
1911 		/*
1912 		 * read-only attr
1913 		 */
1914 		error = EINVAL;
1915 		break;
1916 	case NFS4ATTR_VERIT:
1917 		if (na->maxwrite != rfs4_tsize(sarg->cs->req))
1918 			error = -1;	/* no match */
1919 		break;
1920 	case NFS4ATTR_FREEIT:
1921 		break;
1922 	}
1923 	return (error);
1924 }
1925 
1926 /* ARGSUSED */
1927 static int
rfs4_fattr4_mimetype(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1928 rfs4_fattr4_mimetype(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1929     union nfs4_attr_u *na)
1930 {
1931 	return (ENOTSUP);
1932 }
1933 
1934 /* ARGSUSED */
1935 static int
rfs4_fattr4_mode(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1936 rfs4_fattr4_mode(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1937     union nfs4_attr_u *na)
1938 {
1939 	int	error = 0;
1940 
1941 	if (RFS4_MANDATTR_ONLY)
1942 		return (ENOTSUP);
1943 
1944 	switch (cmd) {
1945 	case NFS4ATTR_SUPPORTED:
1946 		break;		/* this attr is supported */
1947 	case NFS4ATTR_GETIT:
1948 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_MODE)) {
1949 			error = -1;	/* may be okay if rdattr_error */
1950 			break;
1951 		}
1952 		ASSERT(sarg->vap->va_mask & AT_MODE);
1953 		na->mode = sarg->vap->va_mode;
1954 		break;
1955 	case NFS4ATTR_SETIT:
1956 		ASSERT(sarg->vap->va_mask & AT_MODE);
1957 		sarg->vap->va_mode = na->mode;
1958 		/*
1959 		 * If the filesystem is exported with nosuid, then mask off
1960 		 * the setuid and setgid bits.
1961 		 */
1962 		if (sarg->cs->vp->v_type == VREG &&
1963 		    (sarg->cs->exi->exi_export.ex_flags & EX_NOSUID))
1964 			sarg->vap->va_mode &= ~(VSUID | VSGID);
1965 		break;
1966 	case NFS4ATTR_VERIT:
1967 		ASSERT(sarg->vap->va_mask & AT_MODE);
1968 		if (sarg->vap->va_mode != na->mode)
1969 			error = -1;	/* no match */
1970 		break;
1971 	case NFS4ATTR_FREEIT:
1972 		break;
1973 	}
1974 	return (error);
1975 }
1976 
1977 /* ARGSUSED */
1978 static int
rfs4_fattr4_no_trunc(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)1979 rfs4_fattr4_no_trunc(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
1980     union nfs4_attr_u *na)
1981 {
1982 	int error = 0;
1983 
1984 	if (RFS4_MANDATTR_ONLY)
1985 		return (ENOTSUP);
1986 
1987 	switch (cmd) {
1988 	case NFS4ATTR_SUPPORTED:
1989 		if (sarg->op == NFS4ATTR_SETIT)
1990 			error = EINVAL;
1991 		break;		/* this attr is supported */
1992 	case NFS4ATTR_GETIT:
1993 		na->no_trunc = TRUE;
1994 		break;
1995 	case NFS4ATTR_SETIT:
1996 		/*
1997 		 * read-only attr
1998 		 */
1999 		error = EINVAL;
2000 		break;
2001 	case NFS4ATTR_VERIT:
2002 		if (!na->no_trunc)
2003 			error = -1;	/* no match */
2004 		break;
2005 	case NFS4ATTR_FREEIT:
2006 		break;
2007 	}
2008 	return (error);
2009 }
2010 
2011 /* ARGSUSED */
2012 static int
rfs4_fattr4_numlinks(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2013 rfs4_fattr4_numlinks(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2014     union nfs4_attr_u *na)
2015 {
2016 	int	error = 0;
2017 
2018 	if (RFS4_MANDATTR_ONLY)
2019 		return (ENOTSUP);
2020 
2021 	switch (cmd) {
2022 	case NFS4ATTR_SUPPORTED:
2023 		if (sarg->op == NFS4ATTR_SETIT)
2024 			error = EINVAL;
2025 		break;		/* this attr is supported */
2026 	case NFS4ATTR_GETIT:
2027 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_NLINK)) {
2028 			error = -1;	/* may be okay if rdattr_error */
2029 			break;
2030 		}
2031 		ASSERT(sarg->vap->va_mask & AT_NLINK);
2032 		na->numlinks = sarg->vap->va_nlink;
2033 		break;
2034 	case NFS4ATTR_SETIT:
2035 		/*
2036 		 * read-only attr
2037 		 */
2038 		error = EINVAL;
2039 		break;
2040 	case NFS4ATTR_VERIT:
2041 		ASSERT(sarg->vap->va_mask & AT_NLINK);
2042 		if (sarg->vap->va_nlink != na->numlinks)
2043 			error = -1;	/* no match */
2044 		break;
2045 	case NFS4ATTR_FREEIT:
2046 		break;
2047 	}
2048 	return (error);
2049 }
2050 
2051 /* ARGSUSED */
2052 static int
rfs4_fattr4_owner(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2053 rfs4_fattr4_owner(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2054     union nfs4_attr_u *na)
2055 {
2056 	int	error = 0;
2057 	uid_t	uid;
2058 
2059 	if (RFS4_MANDATTR_ONLY)
2060 		return (ENOTSUP);
2061 
2062 	switch (cmd) {
2063 	case NFS4ATTR_SUPPORTED:
2064 		break;		/* this attr is supported */
2065 	case NFS4ATTR_GETIT:
2066 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_UID)) {
2067 			error = -1;	/* may be okay if rdattr_error */
2068 			break;
2069 		}
2070 		ASSERT(sarg->vap->va_mask & AT_UID);
2071 
2072 		/*
2073 		 * There are well defined polices for what happens on server-
2074 		 * side GETATTR when uid to attribute string conversion cannot
2075 		 * occur. Please refer to nfs4_idmap.c for details.
2076 		 */
2077 		error = nfs_idmap_uid_str(sarg->vap->va_uid, &na->owner, TRUE);
2078 		switch (error) {
2079 		case ECONNREFUSED:
2080 			error = NFS4ERR_DELAY;
2081 			break;
2082 		default:
2083 			break;
2084 		}
2085 		break;
2086 
2087 	case NFS4ATTR_SETIT:
2088 		ASSERT(sarg->vap->va_mask & AT_UID);
2089 
2090 		/*
2091 		 * There are well defined policies for what happens on server-
2092 		 * side SETATTR of 'owner' when a "user@domain" mapping cannot
2093 		 * occur. Please refer to nfs4_idmap.c for details.
2094 		 *
2095 		 * Any other errors, such as the mapping not being found by
2096 		 * nfsmapid(8), and interrupted clnt_call, etc, will result
2097 		 * in NFS4ERR_BADOWNER.
2098 		 *
2099 		 * XXX need to return consistent errors, perhaps all
2100 		 * server side attribute routines should return NFS4ERR*.
2101 		 */
2102 		error = nfs_idmap_str_uid(&na->owner, &sarg->vap->va_uid, TRUE);
2103 		switch (error) {
2104 		case NFS4_OK:
2105 		case ENOTSUP:
2106 			/*
2107 			 * Ignore warning that we are the
2108 			 * nfsmapid (can't happen on srv)
2109 			 */
2110 			error = 0;
2111 			MSG_PRT_DEBUG = FALSE;
2112 			break;
2113 
2114 		case ECOMM:
2115 		case ECONNREFUSED:
2116 			if (!MSG_PRT_DEBUG) {
2117 				/*
2118 				 * printed just once per daemon death,
2119 				 * inform the user and then stay silent
2120 				 */
2121 				cmn_err(CE_WARN, "!Unable to contact "
2122 				    "nfsmapid");
2123 				MSG_PRT_DEBUG = TRUE;
2124 			}
2125 			error = NFS4ERR_DELAY;
2126 			break;
2127 
2128 		case EINVAL:
2129 			error = NFS4ERR_INVAL;
2130 			break;
2131 
2132 		default:
2133 			error = NFS4ERR_BADOWNER;
2134 			break;
2135 		}
2136 		break;
2137 
2138 	case NFS4ATTR_VERIT:
2139 		ASSERT(sarg->vap->va_mask & AT_UID);
2140 		error = nfs_idmap_str_uid(&na->owner, &uid, TRUE);
2141 		/*
2142 		 * Ignore warning that we are the nfsmapid (can't happen on srv)
2143 		 */
2144 		if (error == ENOTSUP)
2145 			error = 0;
2146 		if (error)
2147 			error = -1;	/* no match */
2148 		else if (sarg->vap->va_uid != uid)
2149 			error = -1;	/* no match */
2150 		break;
2151 	case NFS4ATTR_FREEIT:
2152 		if (sarg->op == NFS4ATTR_GETIT) {
2153 			if (na->owner.utf8string_val) {
2154 				UTF8STRING_FREE(na->owner)
2155 				bzero(&na->owner, sizeof (na->owner));
2156 			}
2157 		}
2158 		break;
2159 	}
2160 	return (error);
2161 }
2162 
2163 /* ARGSUSED */
2164 static int
rfs4_fattr4_owner_group(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2165 rfs4_fattr4_owner_group(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2166     union nfs4_attr_u *na)
2167 {
2168 	int	error = 0;
2169 	gid_t	gid;
2170 
2171 	if (RFS4_MANDATTR_ONLY)
2172 		return (ENOTSUP);
2173 
2174 	switch (cmd) {
2175 	case NFS4ATTR_SUPPORTED:
2176 		break;		/* this attr is supported */
2177 	case NFS4ATTR_GETIT:
2178 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_GID)) {
2179 			error = -1;	/* may be okay if rdattr_error */
2180 			break;
2181 		}
2182 		ASSERT(sarg->vap->va_mask & AT_GID);
2183 
2184 		/*
2185 		 * There are well defined polices for what happens on server-
2186 		 * side GETATTR when gid to attribute string conversion cannot
2187 		 * occur. Please refer to nfs4_idmap.c for details.
2188 		 */
2189 		error = nfs_idmap_gid_str(sarg->vap->va_gid, &na->owner_group,
2190 		    TRUE);
2191 		switch (error) {
2192 		case ECONNREFUSED:
2193 			error = NFS4ERR_DELAY;
2194 			break;
2195 		default:
2196 			break;
2197 		}
2198 		break;
2199 
2200 	case NFS4ATTR_SETIT:
2201 		ASSERT(sarg->vap->va_mask & AT_GID);
2202 
2203 		/*
2204 		 * There are well defined policies for what happens on server-
2205 		 * side SETATTR of 'owner_group' when a "group@domain" mapping
2206 		 * cannot occur. Please refer to nfs4_idmap.c for details.
2207 		 *
2208 		 * Any other errors, such as the mapping not being found by
2209 		 * nfsmapid(8), and interrupted clnt_call, etc, will result
2210 		 * in NFS4ERR_BADOWNER.
2211 		 *
2212 		 * XXX need to return consistent errors, perhaps all
2213 		 * server side attribute routines should return NFS4ERR*.
2214 		 */
2215 		error = nfs_idmap_str_gid(&na->owner_group, &sarg->vap->va_gid,
2216 		    TRUE);
2217 		switch (error) {
2218 		case NFS4_OK:
2219 		case ENOTSUP:
2220 			/*
2221 			 * Ignore warning that we are the
2222 			 * nfsmapid (can't happen on srv)
2223 			 */
2224 			error = 0;
2225 			MSG_PRT_DEBUG = FALSE;
2226 			break;
2227 
2228 		case ECOMM:
2229 		case ECONNREFUSED:
2230 			if (!MSG_PRT_DEBUG) {
2231 				/*
2232 				 * printed just once per daemon death,
2233 				 * inform the user and then stay silent
2234 				 */
2235 				cmn_err(CE_WARN, "!Unable to contact "
2236 				    "nfsmapid");
2237 				MSG_PRT_DEBUG = TRUE;
2238 			}
2239 			error = NFS4ERR_DELAY;
2240 			break;
2241 
2242 		case EINVAL:
2243 			error = NFS4ERR_INVAL;
2244 			break;
2245 
2246 		default:
2247 			error = NFS4ERR_BADOWNER;
2248 			break;
2249 		}
2250 		break;
2251 
2252 	case NFS4ATTR_VERIT:
2253 		ASSERT(sarg->vap->va_mask & AT_GID);
2254 		error = nfs_idmap_str_gid(&na->owner_group, &gid, TRUE);
2255 		/*
2256 		 * Ignore warning that we are the nfsmapid (can't happen on srv)
2257 		 */
2258 		if (error == ENOTSUP)
2259 			error = 0;
2260 		if (error)
2261 			error = -1;	/* no match */
2262 		else if (sarg->vap->va_gid != gid)
2263 			error = -1;	/* no match */
2264 		break;
2265 	case NFS4ATTR_FREEIT:
2266 		if (sarg->op == NFS4ATTR_GETIT) {
2267 			if (na->owner_group.utf8string_val) {
2268 				UTF8STRING_FREE(na->owner_group)
2269 				bzero(&na->owner_group,
2270 				    sizeof (na->owner_group));
2271 			}
2272 		}
2273 		break;
2274 	}
2275 	return (error);
2276 }
2277 
2278 /* XXX - quota attributes should be supportable on Solaris 2 */
2279 /* ARGSUSED */
2280 static int
rfs4_fattr4_quota_avail_hard(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2281 rfs4_fattr4_quota_avail_hard(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2282     union nfs4_attr_u *na)
2283 {
2284 	return (ENOTSUP);
2285 }
2286 
2287 /* ARGSUSED */
2288 static int
rfs4_fattr4_quota_avail_soft(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2289 rfs4_fattr4_quota_avail_soft(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2290     union nfs4_attr_u *na)
2291 {
2292 	return (ENOTSUP);
2293 }
2294 
2295 /* ARGSUSED */
2296 static int
rfs4_fattr4_quota_used(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2297 rfs4_fattr4_quota_used(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2298     union nfs4_attr_u *na)
2299 {
2300 	return (ENOTSUP);
2301 }
2302 
2303 /* ARGSUSED */
2304 static int
rfs4_fattr4_rawdev(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2305 rfs4_fattr4_rawdev(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2306     union nfs4_attr_u *na)
2307 {
2308 	int	error = 0;
2309 
2310 	if (RFS4_MANDATTR_ONLY)
2311 		return (ENOTSUP);
2312 
2313 	switch (cmd) {
2314 	case NFS4ATTR_SUPPORTED:
2315 		if (sarg->op == NFS4ATTR_SETIT)
2316 			error = EINVAL;
2317 		break;		/* this attr is supported */
2318 	case NFS4ATTR_GETIT:
2319 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_RDEV)) {
2320 			error = -1;	/* may be okay if rdattr_error */
2321 			break;
2322 		}
2323 		ASSERT(sarg->vap->va_mask & AT_RDEV);
2324 		na->rawdev.specdata1 =  (uint32)getmajor(sarg->vap->va_rdev);
2325 		na->rawdev.specdata2 =  (uint32)getminor(sarg->vap->va_rdev);
2326 		break;
2327 	case NFS4ATTR_SETIT:
2328 		/*
2329 		 * read-only attr
2330 		 */
2331 		error = EINVAL;
2332 		break;
2333 	case NFS4ATTR_VERIT:
2334 		ASSERT(sarg->vap->va_mask & AT_RDEV);
2335 		if ((na->rawdev.specdata1 !=
2336 		    (uint32)getmajor(sarg->vap->va_rdev)) ||
2337 		    (na->rawdev.specdata2 !=
2338 		    (uint32)getminor(sarg->vap->va_rdev)))
2339 			error = -1;	/* no match */
2340 		break;
2341 	case NFS4ATTR_FREEIT:
2342 		break;
2343 	}
2344 	return (error);
2345 }
2346 
2347 /* ARGSUSED */
2348 static int
rfs4_fattr4_space_avail(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2349 rfs4_fattr4_space_avail(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2350     union nfs4_attr_u *na)
2351 {
2352 	int	error = 0;
2353 
2354 	if (RFS4_MANDATTR_ONLY)
2355 		return (ENOTSUP);
2356 
2357 	switch (cmd) {
2358 	case NFS4ATTR_SUPPORTED:
2359 		if (sarg->op == NFS4ATTR_SETIT)
2360 			error = EINVAL;
2361 		break;		/* this attr is supported */
2362 	case NFS4ATTR_GETIT:
2363 		if (sarg->rdattr_error && (sarg->sbp == NULL)) {
2364 			error = -1;	/* may be okay if rdattr_error */
2365 			break;
2366 		}
2367 		ASSERT(sarg->sbp != NULL);
2368 		if (sarg->sbp->f_bavail != (fsblkcnt64_t)-1) {
2369 			na->space_avail =
2370 			    (fattr4_space_avail) sarg->sbp->f_frsize *
2371 			    (fattr4_space_avail) sarg->sbp->f_bavail;
2372 		} else {
2373 			na->space_avail =
2374 			    (fattr4_space_avail) sarg->sbp->f_bavail;
2375 		}
2376 		break;
2377 	case NFS4ATTR_SETIT:
2378 		/*
2379 		 * read-only attr
2380 		 */
2381 		error = EINVAL;
2382 		break;
2383 	case NFS4ATTR_VERIT:
2384 		ASSERT(sarg->sbp != NULL);
2385 		if (sarg->sbp->f_bavail != na->space_avail)
2386 			error = -1;	/* no match */
2387 		break;
2388 	case NFS4ATTR_FREEIT:
2389 		break;
2390 	}
2391 	return (error);
2392 }
2393 
2394 /* ARGSUSED */
2395 static int
rfs4_fattr4_space_free(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2396 rfs4_fattr4_space_free(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2397     union nfs4_attr_u *na)
2398 {
2399 	int	error = 0;
2400 
2401 	if (RFS4_MANDATTR_ONLY)
2402 		return (ENOTSUP);
2403 
2404 	switch (cmd) {
2405 	case NFS4ATTR_SUPPORTED:
2406 		if (sarg->op == NFS4ATTR_SETIT)
2407 			error = EINVAL;
2408 		break;		/* this attr is supported */
2409 	case NFS4ATTR_GETIT:
2410 		if (sarg->rdattr_error && (sarg->sbp == NULL)) {
2411 			error = -1;	/* may be okay if rdattr_error */
2412 			break;
2413 		}
2414 		ASSERT(sarg->sbp != NULL);
2415 		if (sarg->sbp->f_bfree != (fsblkcnt64_t)-1) {
2416 			na->space_free =
2417 			    (fattr4_space_free) sarg->sbp->f_frsize *
2418 			    (fattr4_space_free) sarg->sbp->f_bfree;
2419 		} else {
2420 			na->space_free =
2421 			    (fattr4_space_free) sarg->sbp->f_bfree;
2422 		}
2423 		break;
2424 	case NFS4ATTR_SETIT:
2425 		/*
2426 		 * read-only attr
2427 		 */
2428 		error = EINVAL;
2429 		break;
2430 	case NFS4ATTR_VERIT:
2431 		ASSERT(sarg->sbp != NULL);
2432 		if (sarg->sbp->f_bfree != na->space_free)
2433 			error = -1;	/* no match */
2434 		break;
2435 	case NFS4ATTR_FREEIT:
2436 		break;
2437 	}
2438 	return (error);
2439 }
2440 
2441 /* ARGSUSED */
2442 static int
rfs4_fattr4_space_total(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2443 rfs4_fattr4_space_total(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2444     union nfs4_attr_u *na)
2445 {
2446 	int	error = 0;
2447 
2448 	if (RFS4_MANDATTR_ONLY)
2449 		return (ENOTSUP);
2450 
2451 	switch (cmd) {
2452 	case NFS4ATTR_SUPPORTED:
2453 		if (sarg->op == NFS4ATTR_SETIT)
2454 			error = EINVAL;
2455 		break;		/* this attr is supported */
2456 	case NFS4ATTR_GETIT:
2457 		if (sarg->rdattr_error_req && (sarg->sbp == NULL)) {
2458 			error = -1;	/* may be okay if rdattr_error */
2459 			break;
2460 		}
2461 		ASSERT(sarg->sbp != NULL);
2462 		if (sarg->sbp->f_blocks != (fsblkcnt64_t)-1) {
2463 			na->space_total =
2464 			    (fattr4_space_total) sarg->sbp->f_frsize *
2465 			    (fattr4_space_total) sarg->sbp->f_blocks;
2466 		} else {
2467 			na->space_total =
2468 			    (fattr4_space_total) sarg->sbp->f_blocks;
2469 		}
2470 		break;
2471 	case NFS4ATTR_SETIT:
2472 		/*
2473 		 * read-only attr
2474 		 */
2475 		error = EINVAL;
2476 		break;
2477 	case NFS4ATTR_VERIT:
2478 		ASSERT(sarg->sbp != NULL);
2479 		if (sarg->sbp->f_blocks != na->space_total)
2480 			error = -1;	/* no match */
2481 		break;
2482 	case NFS4ATTR_FREEIT:
2483 		break;
2484 	}
2485 	return (error);
2486 }
2487 
2488 /* ARGSUSED */
2489 static int
rfs4_fattr4_space_used(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2490 rfs4_fattr4_space_used(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2491     union nfs4_attr_u *na)
2492 {
2493 	int	error = 0;
2494 
2495 	if (RFS4_MANDATTR_ONLY)
2496 		return (ENOTSUP);
2497 
2498 	switch (cmd) {
2499 	case NFS4ATTR_SUPPORTED:
2500 		if (sarg->op == NFS4ATTR_SETIT)
2501 			error = EINVAL;
2502 		break;		/* this attr is supported */
2503 	case NFS4ATTR_GETIT:
2504 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_NBLOCKS)) {
2505 			error = -1;	/* may be okay if rdattr_error */
2506 			break;
2507 		}
2508 		ASSERT(sarg->vap->va_mask & AT_NBLOCKS);
2509 		na->space_used =  (fattr4_space_used) DEV_BSIZE *
2510 		    (fattr4_space_used) sarg->vap->va_nblocks;
2511 		break;
2512 	case NFS4ATTR_SETIT:
2513 		/*
2514 		 * read-only attr
2515 		 */
2516 		error = EINVAL;
2517 		break;
2518 	case NFS4ATTR_VERIT:
2519 		ASSERT(sarg->vap->va_mask & AT_NBLOCKS);
2520 		if (sarg->vap->va_nblocks != na->space_used)
2521 			error = -1;	/* no match */
2522 		break;
2523 	case NFS4ATTR_FREEIT:
2524 		break;
2525 	}
2526 	return (error);
2527 }
2528 
2529 /* ARGSUSED */
2530 static int
rfs4_fattr4_system(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2531 rfs4_fattr4_system(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2532     union nfs4_attr_u *na)
2533 {
2534 	return (ENOTSUP);
2535 }
2536 
2537 /* ARGSUSED */
2538 static int
rfs4_fattr4_time_access(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2539 rfs4_fattr4_time_access(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2540     union nfs4_attr_u *na)
2541 {
2542 	int	error = 0;
2543 	timestruc_t atime;
2544 
2545 	if (RFS4_MANDATTR_ONLY)
2546 		return (ENOTSUP);
2547 
2548 	switch (cmd) {
2549 	case NFS4ATTR_SUPPORTED:
2550 		if (sarg->op == NFS4ATTR_SETIT)
2551 			error = EINVAL;
2552 		break;		/* this attr is supported */
2553 	case NFS4ATTR_GETIT:
2554 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_ATIME)) {
2555 			error = -1;	/* may be okay if rdattr_error */
2556 			break;
2557 		}
2558 		ASSERT(sarg->vap->va_mask & AT_ATIME);
2559 		error = nfs4_time_vton(&sarg->vap->va_atime, &na->time_access);
2560 		break;
2561 	case NFS4ATTR_SETIT:
2562 		/*
2563 		 * read-only attr
2564 		 */
2565 		error = EINVAL;
2566 		break;
2567 	case NFS4ATTR_VERIT:
2568 		ASSERT(sarg->vap->va_mask & AT_ATIME);
2569 		error = nfs4_time_ntov(&na->time_access, &atime);
2570 		if (error)
2571 			break;
2572 		if (bcmp(&atime, &sarg->vap->va_atime, sizeof (atime)))
2573 			error = -1;	/* no match */
2574 		break;
2575 	case NFS4ATTR_FREEIT:
2576 		break;
2577 	}
2578 	return (error);
2579 }
2580 
2581 /*
2582  * XXX - need to support the setting of access time
2583  */
2584 /* ARGSUSED */
2585 static int
rfs4_fattr4_time_access_set(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2586 rfs4_fattr4_time_access_set(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2587     union nfs4_attr_u *na)
2588 {
2589 	int	error = 0;
2590 	settime4 *ta;
2591 
2592 	if (RFS4_MANDATTR_ONLY)
2593 		return (ENOTSUP);
2594 
2595 	switch (cmd) {
2596 	case NFS4ATTR_SUPPORTED:
2597 		if ((sarg->op == NFS4ATTR_GETIT) ||
2598 		    (sarg->op == NFS4ATTR_VERIT))
2599 			error = EINVAL;
2600 		break;		/* this attr is supported */
2601 	case NFS4ATTR_GETIT:
2602 	case NFS4ATTR_VERIT:
2603 		/*
2604 		 * write only attr
2605 		 */
2606 		error = EINVAL;
2607 		break;
2608 	case NFS4ATTR_SETIT:
2609 		ASSERT(sarg->vap->va_mask & AT_ATIME);
2610 		/*
2611 		 * Set access time (by server or by client)
2612 		 */
2613 		ta = &na->time_access_set;
2614 		if (ta->set_it == SET_TO_CLIENT_TIME4) {
2615 			error = nfs4_time_ntov(&ta->time, &sarg->vap->va_atime);
2616 		} else if (ta->set_it == SET_TO_SERVER_TIME4) {
2617 			gethrestime(&sarg->vap->va_atime);
2618 		} else {
2619 			error = EINVAL;
2620 		}
2621 		break;
2622 	case NFS4ATTR_FREEIT:
2623 		break;
2624 	}
2625 	return (error);
2626 }
2627 
2628 /* ARGSUSED */
2629 static int
rfs4_fattr4_time_backup(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2630 rfs4_fattr4_time_backup(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2631     union nfs4_attr_u *na)
2632 {
2633 	return (ENOTSUP);
2634 }
2635 
2636 /* ARGSUSED */
2637 static int
rfs4_fattr4_time_create(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2638 rfs4_fattr4_time_create(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2639     union nfs4_attr_u *na)
2640 {
2641 	return (ENOTSUP);
2642 }
2643 
2644 /* ARGSUSED */
2645 static int
rfs4_fattr4_time_delta(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2646 rfs4_fattr4_time_delta(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2647     union nfs4_attr_u *na)
2648 {
2649 	int error = 0;
2650 
2651 	if (RFS4_MANDATTR_ONLY)
2652 		return (ENOTSUP);
2653 
2654 	switch (cmd) {
2655 	case NFS4ATTR_SUPPORTED:
2656 		if (sarg->op == NFS4ATTR_SETIT)
2657 			error = EINVAL;
2658 		break;		/* this attr is supported */
2659 	case NFS4ATTR_GETIT:
2660 		na->time_delta.seconds = 0;
2661 		na->time_delta.nseconds = 1000;
2662 		break;
2663 	case NFS4ATTR_SETIT:
2664 		/*
2665 		 * write only attr
2666 		 */
2667 		error = EINVAL;
2668 		break;
2669 	case NFS4ATTR_VERIT:
2670 		if ((na->time_delta.seconds != 0) ||
2671 		    (na->time_delta.nseconds != 1000))
2672 			error = -1;	/* no match */
2673 		break;
2674 	case NFS4ATTR_FREEIT:
2675 		break;
2676 	}
2677 	return (error);
2678 }
2679 
2680 /* ARGSUSED */
2681 static int
rfs4_fattr4_time_metadata(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2682 rfs4_fattr4_time_metadata(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2683     union nfs4_attr_u *na)
2684 {
2685 	int	error = 0;
2686 	timestruc_t ctime;
2687 
2688 	if (RFS4_MANDATTR_ONLY)
2689 		return (ENOTSUP);
2690 
2691 	switch (cmd) {
2692 	case NFS4ATTR_SUPPORTED:
2693 		if (sarg->op == NFS4ATTR_SETIT)
2694 			error = EINVAL;
2695 		break;		/* this attr is supported */
2696 	case NFS4ATTR_GETIT:
2697 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_CTIME)) {
2698 			error = -1;	/* may be okay if rdattr_error */
2699 			break;
2700 		}
2701 		ASSERT(sarg->vap->va_mask & AT_CTIME);
2702 		error = nfs4_time_vton(&sarg->vap->va_ctime,
2703 		    &na->time_metadata);
2704 		break;
2705 	case NFS4ATTR_SETIT:
2706 		/*
2707 		 * read-only attr
2708 		 */
2709 		error = EINVAL;
2710 		break;
2711 	case NFS4ATTR_VERIT:
2712 		ASSERT(sarg->vap->va_mask & AT_CTIME);
2713 		error = nfs4_time_ntov(&na->time_metadata, &ctime);
2714 		if (error)
2715 			break;
2716 		if (bcmp(&ctime, &sarg->vap->va_ctime, sizeof (ctime)))
2717 			error = -1;	/* no match */
2718 		break;
2719 	case NFS4ATTR_FREEIT:
2720 		break;
2721 	}
2722 	return (error);
2723 }
2724 
2725 /* ARGSUSED */
2726 static int
rfs4_fattr4_time_modify(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2727 rfs4_fattr4_time_modify(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2728     union nfs4_attr_u *na)
2729 {
2730 	int	error = 0;
2731 	timestruc_t mtime;
2732 
2733 	if (RFS4_MANDATTR_ONLY)
2734 		return (ENOTSUP);
2735 
2736 	switch (cmd) {
2737 	case NFS4ATTR_SUPPORTED:
2738 		if (sarg->op == NFS4ATTR_SETIT)
2739 			error = EINVAL;
2740 		break;		/* this attr is supported */
2741 	case NFS4ATTR_GETIT:
2742 		if (sarg->rdattr_error && !(sarg->vap->va_mask & AT_MTIME)) {
2743 			error = -1;	/* may be okay if rdattr_error */
2744 			break;
2745 		}
2746 		ASSERT(sarg->vap->va_mask & AT_MTIME);
2747 		error = nfs4_time_vton(&sarg->vap->va_mtime, &na->time_modify);
2748 		break;
2749 	case NFS4ATTR_SETIT:
2750 		/*
2751 		 * read-only attr
2752 		 */
2753 		error = EINVAL;
2754 		break;
2755 	case NFS4ATTR_VERIT:
2756 		ASSERT(sarg->vap->va_mask & AT_MTIME);
2757 		error = nfs4_time_ntov(&na->time_modify, &mtime);
2758 		if (error)
2759 			break;
2760 		if (bcmp(&mtime, &sarg->vap->va_mtime, sizeof (mtime)))
2761 			error = -1;	/* no match */
2762 		break;
2763 	case NFS4ATTR_FREEIT:
2764 		break;
2765 	}
2766 	return (error);
2767 }
2768 
2769 /*
2770  * XXX - need to add support for setting modify time
2771  */
2772 /* ARGSUSED */
2773 static int
rfs4_fattr4_time_modify_set(nfs4_attr_cmd_t cmd,struct nfs4_svgetit_arg * sarg,union nfs4_attr_u * na)2774 rfs4_fattr4_time_modify_set(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sarg,
2775     union nfs4_attr_u *na)
2776 {
2777 	int	error = 0;
2778 	settime4 *tm;
2779 
2780 	if (RFS4_MANDATTR_ONLY)
2781 		return (ENOTSUP);
2782 
2783 	switch (cmd) {
2784 	case NFS4ATTR_SUPPORTED:
2785 		if ((sarg->op == NFS4ATTR_GETIT) ||
2786 		    (sarg->op == NFS4ATTR_VERIT))
2787 			error = EINVAL;
2788 		break;		/* this attr is supported */
2789 	case NFS4ATTR_GETIT:
2790 	case NFS4ATTR_VERIT:
2791 		/*
2792 		 * write only attr
2793 		 */
2794 		error = EINVAL;
2795 		break;
2796 	case NFS4ATTR_SETIT:
2797 		ASSERT(sarg->vap->va_mask & AT_MTIME);
2798 		/*
2799 		 * Set modify time (by server or by client)
2800 		 */
2801 		tm = &na->time_modify_set;
2802 		if (tm->set_it == SET_TO_CLIENT_TIME4) {
2803 			error = nfs4_time_ntov(&tm->time, &sarg->vap->va_mtime);
2804 			sarg->flag = ATTR_UTIME;
2805 		} else if (tm->set_it == SET_TO_SERVER_TIME4) {
2806 			gethrestime(&sarg->vap->va_mtime);
2807 		} else {
2808 			error = EINVAL;
2809 		}
2810 		break;
2811 	case NFS4ATTR_FREEIT:
2812 		break;
2813 	}
2814 	return (error);
2815 }
2816 
2817 
2818 static void
rfs4_ntov_init(void)2819 rfs4_ntov_init(void)
2820 {
2821 	/* index must be same as corresponding FATTR4_* define */
2822 	nfs4_ntov_map[0].sv_getit = rfs4_fattr4_supported_attrs;
2823 	nfs4_ntov_map[1].sv_getit = rfs4_fattr4_type;
2824 	nfs4_ntov_map[2].sv_getit = rfs4_fattr4_fh_expire_type;
2825 	nfs4_ntov_map[3].sv_getit = rfs4_fattr4_change;
2826 	nfs4_ntov_map[4].sv_getit = rfs4_fattr4_size;
2827 	nfs4_ntov_map[5].sv_getit = rfs4_fattr4_link_support;
2828 	nfs4_ntov_map[6].sv_getit = rfs4_fattr4_symlink_support;
2829 	nfs4_ntov_map[7].sv_getit = rfs4_fattr4_named_attr;
2830 	nfs4_ntov_map[8].sv_getit = rfs4_fattr4_fsid;
2831 	nfs4_ntov_map[9].sv_getit = rfs4_fattr4_unique_handles;
2832 	nfs4_ntov_map[10].sv_getit = rfs4_fattr4_lease_time;
2833 	nfs4_ntov_map[11].sv_getit = rfs4_fattr4_rdattr_error;
2834 	nfs4_ntov_map[12].sv_getit = rfs4_fattr4_acl;
2835 	nfs4_ntov_map[13].sv_getit = rfs4_fattr4_aclsupport;
2836 	nfs4_ntov_map[14].sv_getit = rfs4_fattr4_archive;
2837 	nfs4_ntov_map[15].sv_getit = rfs4_fattr4_cansettime;
2838 	nfs4_ntov_map[16].sv_getit = rfs4_fattr4_case_insensitive;
2839 	nfs4_ntov_map[17].sv_getit = rfs4_fattr4_case_preserving;
2840 	nfs4_ntov_map[18].sv_getit = rfs4_fattr4_chown_restricted;
2841 	nfs4_ntov_map[19].sv_getit = rfs4_fattr4_filehandle;
2842 	nfs4_ntov_map[20].sv_getit = rfs4_fattr4_fileid;
2843 	nfs4_ntov_map[21].sv_getit = rfs4_fattr4_files_avail;
2844 	nfs4_ntov_map[22].sv_getit = rfs4_fattr4_files_free;
2845 	nfs4_ntov_map[23].sv_getit = rfs4_fattr4_files_total;
2846 	nfs4_ntov_map[24].sv_getit = rfs4_fattr4_fs_locations;
2847 	nfs4_ntov_map[25].sv_getit = rfs4_fattr4_hidden;
2848 	nfs4_ntov_map[26].sv_getit = rfs4_fattr4_homogeneous;
2849 	nfs4_ntov_map[27].sv_getit = rfs4_fattr4_maxfilesize;
2850 	nfs4_ntov_map[28].sv_getit = rfs4_fattr4_maxlink;
2851 	nfs4_ntov_map[29].sv_getit = rfs4_fattr4_maxname;
2852 	nfs4_ntov_map[30].sv_getit = rfs4_fattr4_maxread;
2853 	nfs4_ntov_map[31].sv_getit = rfs4_fattr4_maxwrite;
2854 	nfs4_ntov_map[32].sv_getit = rfs4_fattr4_mimetype;
2855 	nfs4_ntov_map[33].sv_getit = rfs4_fattr4_mode;
2856 	nfs4_ntov_map[34].sv_getit = rfs4_fattr4_no_trunc;
2857 	nfs4_ntov_map[35].sv_getit = rfs4_fattr4_numlinks;
2858 	nfs4_ntov_map[36].sv_getit = rfs4_fattr4_owner;
2859 	nfs4_ntov_map[37].sv_getit = rfs4_fattr4_owner_group;
2860 	nfs4_ntov_map[38].sv_getit = rfs4_fattr4_quota_avail_hard;
2861 	nfs4_ntov_map[39].sv_getit = rfs4_fattr4_quota_avail_soft;
2862 	nfs4_ntov_map[40].sv_getit = rfs4_fattr4_quota_used;
2863 	nfs4_ntov_map[41].sv_getit = rfs4_fattr4_rawdev;
2864 	nfs4_ntov_map[42].sv_getit = rfs4_fattr4_space_avail;
2865 	nfs4_ntov_map[43].sv_getit = rfs4_fattr4_space_free;
2866 	nfs4_ntov_map[44].sv_getit = rfs4_fattr4_space_total;
2867 	nfs4_ntov_map[45].sv_getit = rfs4_fattr4_space_used;
2868 	nfs4_ntov_map[46].sv_getit = rfs4_fattr4_system;
2869 	nfs4_ntov_map[47].sv_getit = rfs4_fattr4_time_access;
2870 	nfs4_ntov_map[48].sv_getit = rfs4_fattr4_time_access_set;
2871 	nfs4_ntov_map[49].sv_getit = rfs4_fattr4_time_backup;
2872 	nfs4_ntov_map[50].sv_getit = rfs4_fattr4_time_create;
2873 	nfs4_ntov_map[51].sv_getit = rfs4_fattr4_time_delta;
2874 	nfs4_ntov_map[52].sv_getit = rfs4_fattr4_time_metadata;
2875 	nfs4_ntov_map[53].sv_getit = rfs4_fattr4_time_modify;
2876 	nfs4_ntov_map[54].sv_getit = rfs4_fattr4_time_modify_set;
2877 	nfs4_ntov_map[55].sv_getit = rfs4_fattr4_mounted_on_fileid;
2878 }
2879