nfs_vfsops.c source code [codebrowser/bsd/nfs/nfs_vfsops.c]

1	/*
2	* Copyright (c) 2000-2017 Apple Inc. All rights reserved.
3	*
4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5	*
6	* This file contains Original Code and/or Modifications of Original Code
7	* as defined in and that are subject to the Apple Public Source License
8	* Version 2.0 (the 'License'). You may not use this file except in
9	* compliance with the License. The rights granted to you under the License
10	* may not be used to create, or enable the creation or redistribution of,
11	* unlawful or unlicensed copies of an Apple operating system, or to
12	* circumvent, violate, or enable the circumvention or violation of, any
13	* terms of an Apple operating system software license agreement.
14	*
15	* Please obtain a copy of the License at
16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
17	*
18	* The Original Code and all software distributed under the License are
19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23	* Please see the License for the specific language governing rights and
24	* limitations under the License.
25	*
26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27	*/
28	/ Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved /
29	/*
30	* Copyright (c) 1989, 1993, 1995
31	* The Regents of the University of California. All rights reserved.
32	*
33	* This code is derived from software contributed to Berkeley by
34	* Rick Macklem at The University of Guelph.
35	*
36	* Redistribution and use in source and binary forms, with or without
37	* modification, are permitted provided that the following conditions
38	* are met:
39	* 1. Redistributions of source code must retain the above copyright
40	* notice, this list of conditions and the following disclaimer.
41	* 2. Redistributions in binary form must reproduce the above copyright
42	* notice, this list of conditions and the following disclaimer in the
43	* documentation and/or other materials provided with the distribution.
44	* 3. All advertising materials mentioning features or use of this software
45	* must display the following acknowledgement:
46	* This product includes software developed by the University of
47	* California, Berkeley and its contributors.
48	* 4. Neither the name of the University nor the names of its contributors
49	* may be used to endorse or promote products derived from this software
50	* without specific prior written permission.
51	*
52	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
53	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
56	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62	* SUCH DAMAGE.
63	*
64	* @(#)nfs_vfsops.c 8.12 (Berkeley) 5/20/95
65	* FreeBSD-Id: nfs_vfsops.c,v 1.52 1997/11/12 05:42:21 julian Exp $
66	*/
67	/*
68	* NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
69	* support for mandatory and extensible security protections. This notice
70	* is included in support of clause 2.2 (b) of the Apple Public License,
71	* Version 2.0.
72	*/
73
74	#include <sys/param.h>
75	#include <sys/systm.h>
76	#include <sys/conf.h>
77	#include <sys/ioctl.h>
78	#include <sys/signal.h>
79	#include <sys/proc_internal.h> /* for fs rooting to update rootdir in fdp */
80	#include <sys/kauth.h>
81	#include <sys/vnode_internal.h>
82	#include <sys/malloc.h>
83	#include <sys/kernel.h>
84	#include <sys/sysctl.h>
85	#include <sys/mount_internal.h>
86	#include <sys/kpi_mbuf.h>
87	#include <sys/socket.h>
88	#include <sys/socketvar.h>
89	#include <sys/fcntl.h>
90	#include <sys/quota.h>
91	#include <sys/priv.h>
92	#include <libkern/OSAtomic.h>
93
94	#include <sys/vm.h>
95	#include <sys/vmparam.h>
96
97	#if !defined(NO_MOUNT_PRIVATE)
98	#include <sys/filedesc.h>
99	#endif /* NO_MOUNT_PRIVATE */
100
101	#include <net/if.h>
102	#include <net/route.h>
103	#include <netinet/in.h>
104
105	#include <nfs/rpcv2.h>
106	#include <nfs/krpc.h>
107	#include <nfs/nfsproto.h>
108	#include <nfs/nfs.h>
109	#include <nfs/nfsnode.h>
110	#include <nfs/nfs_gss.h>
111	#include <nfs/nfsmount.h>
112	#include <nfs/xdr_subs.h>
113	#include <nfs/nfsm_subs.h>
114	#include <nfs/nfsdiskless.h>
115	#include <nfs/nfs_lock.h>
116	#if CONFIG_MACF
117	#include <security/mac_framework.h>
118	#endif
119
120	#include <pexpert/pexpert.h>
121
122	#define NFS_VFS_DBG(...) NFS_DBG(NFS_FAC_VFS, 7, ## __VA_ARGS__)
123
124	/*
125	* NFS client globals
126	*/
127
128	int nfs_ticks;
129	static lck_grp_t nfs_global_grp, nfs_mount_grp;
130	lck_mtx_t *nfs_global_mutex;
131	uint32_t nfs_fs_attr_bitmap[NFS_ATTR_BITMAP_LEN];
132	uint32_t nfs_object_attr_bitmap[NFS_ATTR_BITMAP_LEN];
133	uint32_t nfs_getattr_bitmap[NFS_ATTR_BITMAP_LEN];
134	struct nfsclientidlist nfsclientids;
135
136	/ NFS requests /
137	struct nfs_reqqhead nfs_reqq;
138	lck_grp_t *nfs_request_grp;
139	lck_mtx_t *nfs_request_mutex;
140	thread_call_t nfs_request_timer_call;
141	int nfs_request_timer_on;
142	u_int32_t nfs_xid = `0`;
143	u_int32_t nfs_xidwrap = `0`; / to build a (non-wrapping) 64 bit xid /
144
145	thread_call_t nfs_buf_timer_call;
146
147	/ NFSv4 /
148	lck_grp_t *nfs_open_grp;
149	uint32_t nfs_open_owner_seqnum = `0`;
150	uint32_t nfs_lock_owner_seqnum = `0`;
151	thread_call_t nfs4_callback_timer_call;
152	int nfs4_callback_timer_on = `0`;
153	char nfs4_default_domain[MAXPATHLEN];
154
155	/ nfsiod /
156	lck_grp_t *nfsiod_lck_grp;
157	lck_mtx_t *nfsiod_mutex;
158	struct nfsiodlist nfsiodfree, nfsiodwork;
159	struct nfsiodmountlist nfsiodmounts;
160	int nfsiod_thread_count = `0`;
161	int nfsiod_thread_max = NFS_DEFASYNCTHREAD;
162	int nfs_max_async_writes = NFS_DEFMAXASYNCWRITES;
163
164	int nfs_iosize = NFS_IOSIZE;
165	int nfs_access_cache_timeout = NFS_MAXATTRTIMO;
166	int nfs_access_delete = `1`; / too many servers get this wrong - workaround on by default /
167	int nfs_access_dotzfs = `1`;
168	int nfs_access_for_getattr = `0`;
169	int nfs_allow_async = `0`;
170	int nfs_statfs_rate_limit = NFS_DEFSTATFSRATELIMIT;
171	int nfs_lockd_mounts = `0`;
172	int nfs_lockd_request_sent = `0`;
173	int nfs_idmap_ctrl = NFS_IDMAP_CTRL_USE_IDMAP_SERVICE;
174	int nfs_callback_port = `0`;
175
176	int nfs_tprintf_initial_delay = NFS_TPRINTF_INITIAL_DELAY;
177	int nfs_tprintf_delay = NFS_TPRINTF_DELAY;
178
179
180	int mountnfs(char , mount_t, vfs_context_t, vnode_t );
181	static int nfs_mount_diskless(struct nfs_dlmount , const* char , int, vnode_t , mount_t *, vfs_context_t);
182	#if !defined(NO_MOUNT_PRIVATE)
183	static int nfs_mount_diskless_private(struct nfs_dlmount , const* char , int, vnode_t , mount_t *, vfs_context_t);
184	#endif /* NO_MOUNT_PRIVATE */
185	int nfs_mount_connect(struct nfsmount *);
186	void nfs_mount_drain_and_cleanup(struct nfsmount *);
187	void nfs_mount_cleanup(struct nfsmount *);
188	int nfs_mountinfo_assemble(struct nfsmount , struct* xdrbuf *);
189	int nfs4_mount_update_path_with_symlink(struct nfsmount , struct* nfs_fs_path , uint32_t, fhandle_t , int , fhandle_t , vfs_context_t);
190
191	/*
192	* NFS VFS operations.
193	*/
194	int nfs_vfs_mount(mount_t, vnode_t, user_addr_t, vfs_context_t);
195	int nfs_vfs_start(mount_t, int, vfs_context_t);
196	int nfs_vfs_unmount(mount_t, int, vfs_context_t);
197	int nfs_vfs_root(mount_t, vnode_t *, vfs_context_t);
198	int nfs_vfs_quotactl(mount_t, int, uid_t, caddr_t, vfs_context_t);
199	int nfs_vfs_getattr(mount_t, struct vfs_attr *, vfs_context_t);
200	int nfs_vfs_sync(mount_t, int, vfs_context_t);
201	int nfs_vfs_vget(mount_t, ino64_t, vnode_t *, vfs_context_t);
202	int nfs_vfs_vptofh(vnode_t, int , unsigned* char *, vfs_context_t);
203	int nfs_vfs_fhtovp(mount_t, int, unsigned char , vnode_t , vfs_context_t);
204	int nfs_vfs_init(struct vfsconf *);
205	int nfs_vfs_sysctl(int , u_int, user_addr_t, size_t , user_addr_t, size_t, vfs_context_t);
206
207	const struct vfsops nfs_vfsops = {
208	.vfs_mount = nfs_vfs_mount,
209	.vfs_start = nfs_vfs_start,
210	.vfs_unmount = nfs_vfs_unmount,
211	.vfs_root = nfs_vfs_root,
212	.vfs_quotactl = nfs_vfs_quotactl,
213	.vfs_getattr = nfs_vfs_getattr,
214	.vfs_sync = nfs_vfs_sync,
215	.vfs_vget = nfs_vfs_vget,
216	.vfs_fhtovp = nfs_vfs_fhtovp,
217	.vfs_vptofh = nfs_vfs_vptofh,
218	.vfs_init = nfs_vfs_init,
219	.vfs_sysctl = nfs_vfs_sysctl,
220	// We do not support the remaining VFS ops
221	};
222
223
224	/*
225	* version-specific NFS functions
226	*/
227	int nfs3_mount(struct nfsmount , vfs_context_t, nfsnode_t );
228	int nfs4_mount(struct nfsmount , vfs_context_t, nfsnode_t );
229	int nfs3_fsinfo(struct nfsmount *, nfsnode_t, vfs_context_t);
230	int nfs3_update_statfs(struct nfsmount *, vfs_context_t);
231	int nfs4_update_statfs(struct nfsmount *, vfs_context_t);
232	#if !QUOTA
233	#define nfs3_getquota NULL
234	#define nfs4_getquota NULL
235	#else
236	int nfs3_getquota(struct nfsmount , vfs_context_t, uid_t, int, struct* dqblk *);
237	int nfs4_getquota(struct nfsmount , vfs_context_t, uid_t, int, struct* dqblk *);
238	#endif
239
240	const struct nfs_funcs nfs3_funcs = {
241	nfs3_mount,
242	nfs3_update_statfs,
243	nfs3_getquota,
244	nfs3_access_rpc,
245	nfs3_getattr_rpc,
246	nfs3_setattr_rpc,
247	nfs3_read_rpc_async,
248	nfs3_read_rpc_async_finish,
249	nfs3_readlink_rpc,
250	nfs3_write_rpc_async,
251	nfs3_write_rpc_async_finish,
252	nfs3_commit_rpc,
253	nfs3_lookup_rpc_async,
254	nfs3_lookup_rpc_async_finish,
255	nfs3_remove_rpc,
256	nfs3_rename_rpc,
257	nfs3_setlock_rpc,
258	nfs3_unlock_rpc,
259	nfs3_getlock_rpc
260	};
261	const struct nfs_funcs nfs4_funcs = {
262	nfs4_mount,
263	nfs4_update_statfs,
264	nfs4_getquota,
265	nfs4_access_rpc,
266	nfs4_getattr_rpc,
267	nfs4_setattr_rpc,
268	nfs4_read_rpc_async,
269	nfs4_read_rpc_async_finish,
270	nfs4_readlink_rpc,
271	nfs4_write_rpc_async,
272	nfs4_write_rpc_async_finish,
273	nfs4_commit_rpc,
274	nfs4_lookup_rpc_async,
275	nfs4_lookup_rpc_async_finish,
276	nfs4_remove_rpc,
277	nfs4_rename_rpc,
278	nfs4_setlock_rpc,
279	nfs4_unlock_rpc,
280	nfs4_getlock_rpc
281	};
282
283	/*
284	* Called once to initialize data structures...
285	*/
286	int
287	nfs_vfs_init(__unused struct vfsconf *vfsp)
288	{
289	int i;
290
291	/*
292	* Check to see if major data structures haven't bloated.
293	*/
294	if (sizeof (struct nfsnode) > NFS_NODEALLOC) {
295	printf("struct nfsnode bloated (> %dbytes)\n", NFS_NODEALLOC);
296	printf("Try reducing NFS_SMALLFH\n");
297	}
298	if (sizeof (struct nfsmount) > NFS_MNTALLOC)
299	printf("struct nfsmount bloated (> %dbytes)\n", NFS_MNTALLOC);
300
301	nfs_ticks = (hz * NFS_TICKINTVL + `500`) / `1000`;
302	if (nfs_ticks < `1`)
303	nfs_ticks = `1`;
304
305	/ init async I/O thread pool state /
306	TAILQ_INIT(&nfsiodfree);
307	TAILQ_INIT(&nfsiodwork);
308	TAILQ_INIT(&nfsiodmounts);
309	nfsiod_lck_grp = lck_grp_alloc_init("nfsiod", LCK_GRP_ATTR_NULL);
310	nfsiod_mutex = lck_mtx_alloc_init(nfsiod_lck_grp, LCK_ATTR_NULL);
311
312	/ init lock groups, etc. /
313	nfs_mount_grp = lck_grp_alloc_init("nfs_mount", LCK_GRP_ATTR_NULL);
314	nfs_open_grp = lck_grp_alloc_init("nfs_open", LCK_GRP_ATTR_NULL);
315	nfs_global_grp = lck_grp_alloc_init("nfs_global", LCK_GRP_ATTR_NULL);
316
317	nfs_global_mutex = lck_mtx_alloc_init(nfs_global_grp, LCK_ATTR_NULL);
318
319	/ init request list mutex /
320	nfs_request_grp = lck_grp_alloc_init("nfs_request", LCK_GRP_ATTR_NULL);
321	nfs_request_mutex = lck_mtx_alloc_init(nfs_request_grp, LCK_ATTR_NULL);
322
323	/ initialize NFS request list /
324	TAILQ_INIT(&nfs_reqq);
325
326	nfs_nbinit(); / Init the nfsbuf table /
327	nfs_nhinit(); / Init the nfsnode table /
328	nfs_lockinit(); / Init the nfs lock state /
329	nfs_gss_init(); / Init RPCSEC_GSS security /
330
331	/ NFSv4 stuff /
332	NFS4_PER_FS_ATTRIBUTES(nfs_fs_attr_bitmap);
333	NFS4_PER_OBJECT_ATTRIBUTES(nfs_object_attr_bitmap);
334	NFS4_DEFAULT_ATTRIBUTES(nfs_getattr_bitmap);
335	for (i=`0`; i < NFS_ATTR_BITMAP_LEN; i++)
336	nfs_getattr_bitmap[i] &= nfs_object_attr_bitmap[i];
337	TAILQ_INIT(&nfsclientids);
338
339	/ initialize NFS timer callouts /
340	nfs_request_timer_call = thread_call_allocate(nfs_request_timer, NULL);
341	nfs_buf_timer_call = thread_call_allocate(nfs_buf_timer, NULL);
342	nfs4_callback_timer_call = thread_call_allocate(nfs4_callback_timer, NULL);
343
344	return (`0`);
345	}
346
347	/*
348	* nfs statfs call
349	*/
350	int
351	nfs3_update_statfs(struct nfsmount *nmp, vfs_context_t ctx)
352	{
353	nfsnode_t np;
354	int error = `0`, lockerror, status, nfsvers;
355	u_int64_t xid;
356	struct nfsm_chain nmreq, nmrep;
357	uint32_t val = `0`;
358
359	nfsvers = nmp->nm_vers;
360	np = nmp->nm_dnp;
361	if (!np)
362	return (ENXIO);
363	if ((error = vnode_get(NFSTOV(np))))
364	return (error);
365
366	nfsm_chain_null(&nmreq);
367	nfsm_chain_null(&nmrep);
368
369	nfsm_chain_build_alloc_init(error, &nmreq, NFSX_FH(nfsvers));
370	nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
371	nfsm_chain_build_done(error, &nmreq);
372	nfsmout_if(error);
373	error = nfs_request2(np, NULL, &nmreq, NFSPROC_FSSTAT, vfs_context_thread(ctx),
374	vfs_context_ucred(ctx), NULL, R_SOFT, &nmrep, &xid, &status);
375	if (error == ETIMEDOUT)
376	goto nfsmout;
377	if ((lockerror = nfs_node_lock(np)))
378	error = lockerror;
379	if (nfsvers == NFS_VER3)
380	nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
381	if (!lockerror)
382	nfs_node_unlock(np);
383	if (!error)
384	error = status;
385	nfsm_assert(error, NFSTONMP(np), ENXIO);
386	nfsmout_if(error);
387	lck_mtx_lock(&nmp->nm_lock);
388	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_TOTAL);
389	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_FREE);
390	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_AVAIL);
391	if (nfsvers == NFS_VER3) {
392	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_FILES_AVAIL);
393	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_FILES_TOTAL);
394	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_FILES_FREE);
395	nmp->nm_fsattr.nfsa_bsize = NFS_FABLKSIZE;
396	nfsm_chain_get_64(error, &nmrep, nmp->nm_fsattr.nfsa_space_total);
397	nfsm_chain_get_64(error, &nmrep, nmp->nm_fsattr.nfsa_space_free);
398	nfsm_chain_get_64(error, &nmrep, nmp->nm_fsattr.nfsa_space_avail);
399	nfsm_chain_get_64(error, &nmrep, nmp->nm_fsattr.nfsa_files_total);
400	nfsm_chain_get_64(error, &nmrep, nmp->nm_fsattr.nfsa_files_free);
401	nfsm_chain_get_64(error, &nmrep, nmp->nm_fsattr.nfsa_files_avail);
402	// skip invarsec
403	} else {
404	nfsm_chain_adv(error, &nmrep, NFSX_UNSIGNED); // skip tsize?
405	nfsm_chain_get_32(error, &nmrep, nmp->nm_fsattr.nfsa_bsize);
406	nfsm_chain_get_32(error, &nmrep, val);
407	nfsmout_if(error);
408	if (nmp->nm_fsattr.nfsa_bsize <= `0`)
409	nmp->nm_fsattr.nfsa_bsize = NFS_FABLKSIZE;
410	nmp->nm_fsattr.nfsa_space_total = (uint64_t)val * nmp->nm_fsattr.nfsa_bsize;
411	nfsm_chain_get_32(error, &nmrep, val);
412	nfsmout_if(error);
413	nmp->nm_fsattr.nfsa_space_free = (uint64_t)val * nmp->nm_fsattr.nfsa_bsize;
414	nfsm_chain_get_32(error, &nmrep, val);
415	nfsmout_if(error);
416	nmp->nm_fsattr.nfsa_space_avail = (uint64_t)val * nmp->nm_fsattr.nfsa_bsize;
417	}
418	lck_mtx_unlock(&nmp->nm_lock);
419	nfsmout:
420	nfsm_chain_cleanup(&nmreq);
421	nfsm_chain_cleanup(&nmrep);
422	vnode_put(NFSTOV(np));
423	return (error);
424	}
425
426	int
427	nfs4_update_statfs(struct nfsmount *nmp, vfs_context_t ctx)
428	{
429	nfsnode_t np;
430	int error = `0`, lockerror, status, nfsvers, numops;
431	u_int64_t xid;
432	struct nfsm_chain nmreq, nmrep;
433	uint32_t bitmap[NFS_ATTR_BITMAP_LEN];
434	struct nfs_vattr nvattr;
435	struct nfsreq_secinfo_args si;
436
437	nfsvers = nmp->nm_vers;
438	np = nmp->nm_dnp;
439	if (!np)
440	return (ENXIO);
441	if ((error = vnode_get(NFSTOV(np))))
442	return (error);
443
444	NFSREQ_SECINFO_SET(&si, np, NULL, `0`, NULL, `0`);
445	NVATTR_INIT(&nvattr);
446	nfsm_chain_null(&nmreq);
447	nfsm_chain_null(&nmrep);
448
449	// PUTFH + GETATTR
450	numops = `2`;
451	nfsm_chain_build_alloc_init(error, &nmreq, `15` * NFSX_UNSIGNED);
452	nfsm_chain_add_compound_header(error, &nmreq, "statfs", nmp->nm_minor_vers, numops);
453	numops--;
454	nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
455	nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
456	numops--;
457	nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
458	NFS_COPY_ATTRIBUTES(nfs_getattr_bitmap, bitmap);
459	NFS4_STATFS_ATTRIBUTES(bitmap);
460	nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, np);
461	nfsm_chain_build_done(error, &nmreq);
462	nfsm_assert(error, (numops == `0`), EPROTO);
463	nfsmout_if(error);
464	error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND,
465	vfs_context_thread(ctx), vfs_context_ucred(ctx),
466	NULL, R_SOFT, &nmrep, &xid, &status);
467	nfsm_chain_skip_tag(error, &nmrep);
468	nfsm_chain_get_32(error, &nmrep, numops);
469	nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
470	nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
471	nfsm_assert(error, NFSTONMP(np), ENXIO);
472	nfsmout_if(error);
473	lck_mtx_lock(&nmp->nm_lock);
474	error = nfs4_parsefattr(&nmrep, &nmp->nm_fsattr, &nvattr, NULL, NULL, NULL);
475	lck_mtx_unlock(&nmp->nm_lock);
476	nfsmout_if(error);
477	if ((lockerror = nfs_node_lock(np)))
478	error = lockerror;
479	if (!error)
480	nfs_loadattrcache(np, &nvattr, &xid, `0`);
481	if (!lockerror)
482	nfs_node_unlock(np);
483	nfsm_assert(error, NFSTONMP(np), ENXIO);
484	nfsmout_if(error);
485	nmp->nm_fsattr.nfsa_bsize = NFS_FABLKSIZE;
486	nfsmout:
487	NVATTR_CLEANUP(&nvattr);
488	nfsm_chain_cleanup(&nmreq);
489	nfsm_chain_cleanup(&nmrep);
490	vnode_put(NFSTOV(np));
491	return (error);
492	}
493
494	/*
495	* Return an NFS volume name from the mntfrom name.
496	*/
497	static void
498	nfs_get_volname(struct mount mp, char* *volname, size_t len)
499	{
500	const char ptr, cptr;
501	const char *mntfrom = mp->mnt_vfsstat.f_mntfromname;
502	size_t mflen = strnlen(mntfrom, MAXPATHLEN+`1`);
503
504	if (mflen > MAXPATHLEN \|\| mflen == `0`) {
505	strlcpy(volname, "Bad volname", len);
506	return;
507	}
508
509	/ Move back over trailing slashes /
510	for (ptr = &mntfrom[mflen-`1`]; ptr != mntfrom && *ptr == `'/'`; ptr--) {
511	mflen--;
512	}
513
514	/ Find first character after the last slash /
515	cptr = ptr = NULL;
516	for(size_t i = `0`; i < mflen; i++) {
517	if (mntfrom[i] == `'/'`)
518	ptr = &mntfrom[i+`1`];
519	/ And the first character after the first colon /
520	else if (cptr == NULL && mntfrom[i] == `':'`)
521	cptr = &mntfrom[i+`1`];
522	}
523
524	/*
525	* No slash or nothing after the last slash
526	* use everything past the first colon
527	*/
528	if (ptr == NULL \|\| *ptr == `'\0'`)
529	ptr = cptr;
530	/ Otherwise use the mntfrom name /
531	if (ptr == NULL)
532	ptr = mntfrom;
533
534	mflen = &mntfrom[mflen] - ptr;
535	len = mflen+`1` < len ? mflen+`1` : len;
536
537	strlcpy(volname, ptr, len);
538	}
539
540	/*
541	* The NFS VFS_GETATTR function: "statfs"-type information is retrieved
542	* using the nf_update_statfs() function, and other attributes are cobbled
543	* together from whatever sources we can (getattr, fsinfo, pathconf).
544	*/
545	int
546	nfs_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t ctx)
547	{
548	struct nfsmount *nmp;
549	uint32_t bsize;
550	int error = `0`, nfsvers;
551
552	nmp = VFSTONFS(mp);
553	if (nfs_mount_gone(nmp))
554	return (ENXIO);
555	nfsvers = nmp->nm_vers;
556
557	if (VFSATTR_IS_ACTIVE(fsap, f_bsize) \|\|
558	VFSATTR_IS_ACTIVE(fsap, f_iosize) \|\|
559	VFSATTR_IS_ACTIVE(fsap, f_blocks) \|\|
560	VFSATTR_IS_ACTIVE(fsap, f_bfree) \|\|
561	VFSATTR_IS_ACTIVE(fsap, f_bavail) \|\|
562	VFSATTR_IS_ACTIVE(fsap, f_bused) \|\|
563	VFSATTR_IS_ACTIVE(fsap, f_files) \|\|
564	VFSATTR_IS_ACTIVE(fsap, f_ffree)) {
565	int statfsrate = nfs_statfs_rate_limit;
566	int refresh = `1`;
567
568	/*
569	* Are we rate-limiting statfs RPCs?
570	* (Treat values less than 1 or greater than 1,000,000 as no limit.)
571	*/
572	if ((statfsrate > `0`) && (statfsrate < `1000000`)) {
573	struct timeval now;
574	uint32_t stamp;
575
576	microuptime(&now);
577	lck_mtx_lock(&nmp->nm_lock);
578	stamp = (now.tv_sec * statfsrate) + (now.tv_usec / (`1000000`/statfsrate));
579	if (stamp != nmp->nm_fsattrstamp) {
580	refresh = `1`;
581	nmp->nm_fsattrstamp = stamp;
582	} else {
583	refresh = `0`;
584	}
585	lck_mtx_unlock(&nmp->nm_lock);
586	}
587
588	if (refresh && !nfs_use_cache(nmp))
589	error = nmp->nm_funcs->nf_update_statfs(nmp, ctx);
590	if ((error == ESTALE) \|\| (error == ETIMEDOUT))
591	error = `0`;
592	if (error)
593	return (error);
594
595	lck_mtx_lock(&nmp->nm_lock);
596	VFSATTR_RETURN(fsap, f_iosize, nfs_iosize);
597	VFSATTR_RETURN(fsap, f_bsize, nmp->nm_fsattr.nfsa_bsize);
598	bsize = nmp->nm_fsattr.nfsa_bsize;
599	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_TOTAL))
600	VFSATTR_RETURN(fsap, f_blocks, nmp->nm_fsattr.nfsa_space_total / bsize);
601	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_FREE))
602	VFSATTR_RETURN(fsap, f_bfree, nmp->nm_fsattr.nfsa_space_free / bsize);
603	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_AVAIL))
604	VFSATTR_RETURN(fsap, f_bavail, nmp->nm_fsattr.nfsa_space_avail / bsize);
605	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_TOTAL) &&
606	NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SPACE_FREE))
607	VFSATTR_RETURN(fsap, f_bused,
608	(nmp->nm_fsattr.nfsa_space_total / bsize) -
609	(nmp->nm_fsattr.nfsa_space_free / bsize));
610	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_FILES_TOTAL))
611	VFSATTR_RETURN(fsap, f_files, nmp->nm_fsattr.nfsa_files_total);
612	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_FILES_FREE))
613	VFSATTR_RETURN(fsap, f_ffree, nmp->nm_fsattr.nfsa_files_free);
614	lck_mtx_unlock(&nmp->nm_lock);
615	}
616
617	if (VFSATTR_IS_ACTIVE(fsap, f_vol_name)) {
618	/%%% IF fail over support is implemented we may need to take nm_lock /
619	nfs_get_volname(mp, fsap->f_vol_name, MAXPATHLEN);
620	VFSATTR_SET_SUPPORTED(fsap, f_vol_name);
621	}
622	if (VFSATTR_IS_ACTIVE(fsap, f_capabilities)) {
623	u_int32_t caps, valid;
624	nfsnode_t np = nmp->nm_dnp;
625
626	nfsm_assert(error, VFSTONFS(mp) && np, ENXIO);
627	if (error)
628	return (error);
629	lck_mtx_lock(&nmp->nm_lock);
630
631	/*
632	* The capabilities[] array defines what this volume supports.
633	*
634	* The valid[] array defines which bits this code understands
635	* the meaning of (whether the volume has that capability or not).
636	* Any zero bits here means "I don't know what you're asking about"
637	* and the caller cannot tell whether that capability is
638	* present or not.
639	*/
640	caps = valid = `0`;
641	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SYMLINK_SUPPORT)) {
642	valid \|= VOL_CAP_FMT_SYMBOLICLINKS;
643	if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_SYMLINK)
644	caps \|= VOL_CAP_FMT_SYMBOLICLINKS;
645	}
646	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_LINK_SUPPORT)) {
647	valid \|= VOL_CAP_FMT_HARDLINKS;
648	if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_LINK)
649	caps \|= VOL_CAP_FMT_HARDLINKS;
650	}
651	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_CASE_INSENSITIVE)) {
652	valid \|= VOL_CAP_FMT_CASE_SENSITIVE;
653	if (!(nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_CASE_INSENSITIVE))
654	caps \|= VOL_CAP_FMT_CASE_SENSITIVE;
655	}
656	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_CASE_PRESERVING)) {
657	valid \|= VOL_CAP_FMT_CASE_PRESERVING;
658	if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_CASE_PRESERVING)
659	caps \|= VOL_CAP_FMT_CASE_PRESERVING;
660	}
661	/ Note: VOL_CAP_FMT_2TB_FILESIZE is actually used to test for "large file support" /
662	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXFILESIZE)) {
663	/ Is server's max file size at least 4GB? /
664	if (nmp->nm_fsattr.nfsa_maxfilesize >= `0x100000000ULL`)
665	caps \|= VOL_CAP_FMT_2TB_FILESIZE;
666	} else if (nfsvers >= NFS_VER3) {
667	/*
668	* NFSv3 and up supports 64 bits of file size.
669	* So, we'll just assume maxfilesize >= 4GB
670	*/
671	caps \|= VOL_CAP_FMT_2TB_FILESIZE;
672	}
673	if (nfsvers >= NFS_VER4) {
674	caps \|= VOL_CAP_FMT_HIDDEN_FILES;
675	valid \|= VOL_CAP_FMT_HIDDEN_FILES;
676	// VOL_CAP_FMT_OPENDENYMODES
677	// caps \|= VOL_CAP_FMT_OPENDENYMODES;
678	// valid \|= VOL_CAP_FMT_OPENDENYMODES;
679	}
680	// no version of nfs supports immutable files
681	caps \|= VOL_CAP_FMT_NO_IMMUTABLE_FILES;
682	valid \|= VOL_CAP_FMT_NO_IMMUTABLE_FILES;
683
684	fsap->f_capabilities.capabilities[VOL_CAPABILITIES_FORMAT] =
685	// VOL_CAP_FMT_PERSISTENTOBJECTIDS \|
686	// VOL_CAP_FMT_SYMBOLICLINKS \|
687	// VOL_CAP_FMT_HARDLINKS \|
688	// VOL_CAP_FMT_JOURNAL \|
689	// VOL_CAP_FMT_JOURNAL_ACTIVE \|
690	// VOL_CAP_FMT_NO_ROOT_TIMES \|
691	// VOL_CAP_FMT_SPARSE_FILES \|
692	// VOL_CAP_FMT_ZERO_RUNS \|
693	// VOL_CAP_FMT_CASE_SENSITIVE \|
694	// VOL_CAP_FMT_CASE_PRESERVING \|
695	// VOL_CAP_FMT_FAST_STATFS \|
696	// VOL_CAP_FMT_2TB_FILESIZE \|
697	// VOL_CAP_FMT_OPENDENYMODES \|
698	// VOL_CAP_FMT_HIDDEN_FILES \|
699	caps;
700	fsap->f_capabilities.valid[VOL_CAPABILITIES_FORMAT] =
701	VOL_CAP_FMT_PERSISTENTOBJECTIDS \|
702	// VOL_CAP_FMT_SYMBOLICLINKS \|
703	// VOL_CAP_FMT_HARDLINKS \|
704	// VOL_CAP_FMT_JOURNAL \|
705	// VOL_CAP_FMT_JOURNAL_ACTIVE \|
706	// VOL_CAP_FMT_NO_ROOT_TIMES \|
707	// VOL_CAP_FMT_SPARSE_FILES \|
708	// VOL_CAP_FMT_ZERO_RUNS \|
709	// VOL_CAP_FMT_CASE_SENSITIVE \|
710	// VOL_CAP_FMT_CASE_PRESERVING \|
711	VOL_CAP_FMT_FAST_STATFS \|
712	VOL_CAP_FMT_2TB_FILESIZE \|
713	// VOL_CAP_FMT_OPENDENYMODES \|
714	// VOL_CAP_FMT_HIDDEN_FILES \|
715	valid;
716
717	/*
718	* We don't support most of the interfaces.
719	*
720	* We MAY support locking, but we don't have any easy way of probing.
721	* We can tell if there's no lockd running or if locks have been
722	* disabled for a mount, so we can definitely answer NO in that case.
723	* Any attempt to send a request to lockd to test for locking support
724	* may cause the lazily-launched locking daemons to be started
725	* unnecessarily. So we avoid that. However, we do record if we ever
726	* successfully perform a lock operation on a mount point, so if it
727	* looks like lock ops have worked, we do report that we support them.
728	*/
729	caps = valid = `0`;
730	if (nfsvers >= NFS_VER4) {
731	caps = VOL_CAP_INT_ADVLOCK \| VOL_CAP_INT_FLOCK;
732	valid = VOL_CAP_INT_ADVLOCK \| VOL_CAP_INT_FLOCK;
733	if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_ACL)
734	caps \|= VOL_CAP_INT_EXTENDED_SECURITY;
735	valid \|= VOL_CAP_INT_EXTENDED_SECURITY;
736	if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_NAMED_ATTR)
737	caps \|= VOL_CAP_INT_EXTENDED_ATTR;
738	valid \|= VOL_CAP_INT_EXTENDED_ATTR;
739	#if NAMEDSTREAMS
740	if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_NAMED_ATTR)
741	caps \|= VOL_CAP_INT_NAMEDSTREAMS;
742	valid \|= VOL_CAP_INT_NAMEDSTREAMS;
743	#endif
744	} else if (nmp->nm_lockmode == NFS_LOCK_MODE_DISABLED) {
745	/ locks disabled on this mount, so they definitely won't work /
746	valid = VOL_CAP_INT_ADVLOCK \| VOL_CAP_INT_FLOCK;
747	} else if (nmp->nm_state & NFSSTA_LOCKSWORK) {
748	caps = VOL_CAP_INT_ADVLOCK \| VOL_CAP_INT_FLOCK;
749	valid = VOL_CAP_INT_ADVLOCK \| VOL_CAP_INT_FLOCK;
750	}
751	fsap->f_capabilities.capabilities[VOL_CAPABILITIES_INTERFACES] =
752	// VOL_CAP_INT_SEARCHFS \|
753	// VOL_CAP_INT_ATTRLIST \|
754	// VOL_CAP_INT_NFSEXPORT \|
755	// VOL_CAP_INT_READDIRATTR \|
756	// VOL_CAP_INT_EXCHANGEDATA \|
757	// VOL_CAP_INT_COPYFILE \|
758	// VOL_CAP_INT_ALLOCATE \|
759	// VOL_CAP_INT_VOL_RENAME \|
760	// VOL_CAP_INT_ADVLOCK \|
761	// VOL_CAP_INT_FLOCK \|
762	// VOL_CAP_INT_EXTENDED_SECURITY \|
763	// VOL_CAP_INT_USERACCESS \|
764	// VOL_CAP_INT_MANLOCK \|
765	// VOL_CAP_INT_NAMEDSTREAMS \|
766	// VOL_CAP_INT_EXTENDED_ATTR \|
767	VOL_CAP_INT_REMOTE_EVENT \|
768	caps;
769	fsap->f_capabilities.valid[VOL_CAPABILITIES_INTERFACES] =
770	VOL_CAP_INT_SEARCHFS \|
771	VOL_CAP_INT_ATTRLIST \|
772	VOL_CAP_INT_NFSEXPORT \|
773	VOL_CAP_INT_READDIRATTR \|
774	VOL_CAP_INT_EXCHANGEDATA \|
775	VOL_CAP_INT_COPYFILE \|
776	VOL_CAP_INT_ALLOCATE \|
777	VOL_CAP_INT_VOL_RENAME \|
778	// VOL_CAP_INT_ADVLOCK \|
779	// VOL_CAP_INT_FLOCK \|
780	// VOL_CAP_INT_EXTENDED_SECURITY \|
781	// VOL_CAP_INT_USERACCESS \|
782	// VOL_CAP_INT_MANLOCK \|
783	// VOL_CAP_INT_NAMEDSTREAMS \|
784	// VOL_CAP_INT_EXTENDED_ATTR \|
785	VOL_CAP_INT_REMOTE_EVENT \|
786	valid;
787
788	fsap->f_capabilities.capabilities[VOL_CAPABILITIES_RESERVED1] = `0`;
789	fsap->f_capabilities.valid[VOL_CAPABILITIES_RESERVED1] = `0`;
790
791	fsap->f_capabilities.capabilities[VOL_CAPABILITIES_RESERVED2] = `0`;
792	fsap->f_capabilities.valid[VOL_CAPABILITIES_RESERVED2] = `0`;
793
794	VFSATTR_SET_SUPPORTED(fsap, f_capabilities);
795	lck_mtx_unlock(&nmp->nm_lock);
796	}
797
798	if (VFSATTR_IS_ACTIVE(fsap, f_attributes)) {
799	fsap->f_attributes.validattr.commonattr = `0`;
800	fsap->f_attributes.validattr.volattr =
801	ATTR_VOL_NAME \| ATTR_VOL_CAPABILITIES \| ATTR_VOL_ATTRIBUTES;
802	fsap->f_attributes.validattr.dirattr = `0`;
803	fsap->f_attributes.validattr.fileattr = `0`;
804	fsap->f_attributes.validattr.forkattr = `0`;
805
806	fsap->f_attributes.nativeattr.commonattr = `0`;
807	fsap->f_attributes.nativeattr.volattr =
808	ATTR_VOL_NAME \| ATTR_VOL_CAPABILITIES \| ATTR_VOL_ATTRIBUTES;
809	fsap->f_attributes.nativeattr.dirattr = `0`;
810	fsap->f_attributes.nativeattr.fileattr = `0`;
811	fsap->f_attributes.nativeattr.forkattr = `0`;
812
813	VFSATTR_SET_SUPPORTED(fsap, f_attributes);
814	}
815
816	return (error);
817	}
818
819	/*
820	* nfs version 3 fsinfo rpc call
821	*/
822	int
823	nfs3_fsinfo(struct nfsmount *nmp, nfsnode_t np, vfs_context_t ctx)
824	{
825	int error = `0`, lockerror, status, nmlocked = `0`;
826	u_int64_t xid;
827	uint32_t val, prefsize, maxsize;
828	struct nfsm_chain nmreq, nmrep;
829
830	nfsm_chain_null(&nmreq);
831	nfsm_chain_null(&nmrep);
832
833	nfsm_chain_build_alloc_init(error, &nmreq, NFSX_FH(nmp->nm_vers));
834	nfsm_chain_add_fh(error, &nmreq, nmp->nm_vers, np->n_fhp, np->n_fhsize);
835	nfsm_chain_build_done(error, &nmreq);
836	nfsmout_if(error);
837	error = nfs_request(np, NULL, &nmreq, NFSPROC_FSINFO, ctx, NULL, &nmrep, &xid, &status);
838	if ((lockerror = nfs_node_lock(np)))
839	error = lockerror;
840	nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
841	if (!lockerror)
842	nfs_node_unlock(np);
843	if (!error)
844	error = status;
845	nfsmout_if(error);
846
847	lck_mtx_lock(&nmp->nm_lock);
848	nmlocked = `1`;
849
850	nfsm_chain_get_32(error, &nmrep, maxsize);
851	nfsm_chain_get_32(error, &nmrep, prefsize);
852	nfsmout_if(error);
853	nmp->nm_fsattr.nfsa_maxread = maxsize;
854	if (prefsize < nmp->nm_rsize)
855	nmp->nm_rsize = (prefsize + NFS_FABLKSIZE - `1`) &
856	~(NFS_FABLKSIZE - `1`);
857	if ((maxsize > `0`) && (maxsize < nmp->nm_rsize)) {
858	nmp->nm_rsize = maxsize & ~(NFS_FABLKSIZE - `1`);
859	if (nmp->nm_rsize == `0`)
860	nmp->nm_rsize = maxsize;
861	}
862	nfsm_chain_adv(error, &nmrep, NFSX_UNSIGNED); // skip rtmult
863
864	nfsm_chain_get_32(error, &nmrep, maxsize);
865	nfsm_chain_get_32(error, &nmrep, prefsize);
866	nfsmout_if(error);
867	nmp->nm_fsattr.nfsa_maxwrite = maxsize;
868	if (prefsize < nmp->nm_wsize)
869	nmp->nm_wsize = (prefsize + NFS_FABLKSIZE - `1`) &
870	~(NFS_FABLKSIZE - `1`);
871	if ((maxsize > `0`) && (maxsize < nmp->nm_wsize)) {
872	nmp->nm_wsize = maxsize & ~(NFS_FABLKSIZE - `1`);
873	if (nmp->nm_wsize == `0`)
874	nmp->nm_wsize = maxsize;
875	}
876	nfsm_chain_adv(error, &nmrep, NFSX_UNSIGNED); // skip wtmult
877
878	nfsm_chain_get_32(error, &nmrep, prefsize);
879	nfsmout_if(error);
880	if ((prefsize > `0`) && (prefsize < nmp->nm_readdirsize))
881	nmp->nm_readdirsize = prefsize;
882	if ((nmp->nm_fsattr.nfsa_maxread > `0`) &&
883	(nmp->nm_fsattr.nfsa_maxread < nmp->nm_readdirsize))
884	nmp->nm_readdirsize = nmp->nm_fsattr.nfsa_maxread;
885
886	nfsm_chain_get_64(error, &nmrep, nmp->nm_fsattr.nfsa_maxfilesize);
887
888	nfsm_chain_adv(error, &nmrep, `2` * NFSX_UNSIGNED); // skip time_delta
889
890	/ convert FS properties to our own flags /
891	nfsm_chain_get_32(error, &nmrep, val);
892	nfsmout_if(error);
893	if (val & NFSV3FSINFO_LINK)
894	nmp->nm_fsattr.nfsa_flags \|= NFS_FSFLAG_LINK;
895	if (val & NFSV3FSINFO_SYMLINK)
896	nmp->nm_fsattr.nfsa_flags \|= NFS_FSFLAG_SYMLINK;
897	if (val & NFSV3FSINFO_HOMOGENEOUS)
898	nmp->nm_fsattr.nfsa_flags \|= NFS_FSFLAG_HOMOGENEOUS;
899	if (val & NFSV3FSINFO_CANSETTIME)
900	nmp->nm_fsattr.nfsa_flags \|= NFS_FSFLAG_SET_TIME;
901	nmp->nm_state \|= NFSSTA_GOTFSINFO;
902	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXREAD);
903	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXWRITE);
904	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXFILESIZE);
905	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_LINK_SUPPORT);
906	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_SYMLINK_SUPPORT);
907	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_HOMOGENEOUS);
908	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_CANSETTIME);
909	nfsmout:
910	if (nmlocked)
911	lck_mtx_unlock(&nmp->nm_lock);
912	nfsm_chain_cleanup(&nmreq);
913	nfsm_chain_cleanup(&nmrep);
914	return (error);
915	}
916
917	/*
918	* Mount a remote root fs via. nfs. This depends on the info in the
919	* nfs_diskless structure that has been filled in properly by some primary
920	* bootstrap.
921	* It goes something like this:
922	* - do enough of "ifconfig" by calling ifioctl() so that the system
923	* can talk to the server
924	* - If nfs_diskless.mygateway is filled in, use that address as
925	* a default gateway.
926	* - hand craft the swap nfs vnode hanging off a fake mount point
927	* if swdevt[0].sw_dev == NODEV
928	* - build the rootfs mount point and call mountnfs() to do the rest.
929	*/
930	int
931	nfs_mountroot(void)
932	{
933	struct nfs_diskless nd;
934	mount_t mp = NULL;
935	vnode_t vp = NULL;
936	vfs_context_t ctx;
937	int error;
938	#if !defined(NO_MOUNT_PRIVATE)
939	mount_t mppriv = NULL;
940	vnode_t vppriv = NULL;
941	#endif /* NO_MOUNT_PRIVATE */
942	int v3, sotype;
943
944	/*
945	* Call nfs_boot_init() to fill in the nfs_diskless struct.
946	* Note: networking must already have been configured before
947	* we're called.
948	*/
949	bzero((caddr_t) &nd, sizeof(nd));
950	error = nfs_boot_init(&nd);
951	if (error)
952	panic("nfs_boot_init: unable to initialize NFS root system information, "
953	"error %d, check configuration: %s\n", error, PE_boot_args());
954
955	/*
956	* Try NFSv3 first, then fallback to NFSv2.
957	* Likewise, try TCP first, then fall back to UDP.
958	*/
959	v3 = `1`;
960	sotype = SOCK_STREAM;
961
962	tryagain:
963	error = nfs_boot_getfh(&nd, v3, sotype);
964	if (error) {
965	if (error == EHOSTDOWN \|\| error == EHOSTUNREACH) {
966	if (nd.nd_root.ndm_mntfrom)
967	FREE_ZONE(nd.nd_root.ndm_mntfrom,
968	MAXPATHLEN, M_NAMEI);
969	if (nd.nd_root.ndm_path)
970	FREE_ZONE(nd.nd_root.ndm_path,
971	MAXPATHLEN, M_NAMEI);
972	if (nd.nd_private.ndm_mntfrom)
973	FREE_ZONE(nd.nd_private.ndm_mntfrom,
974	MAXPATHLEN, M_NAMEI);
975	if (nd.nd_private.ndm_path)
976	FREE_ZONE(nd.nd_private.ndm_path,
977	MAXPATHLEN, M_NAMEI);
978	return (error);
979	}
980	if (v3) {
981	if (sotype == SOCK_STREAM) {
982	printf("NFS mount (v3,TCP) failed with error %d, trying UDP...\n", error);
983	sotype = SOCK_DGRAM;
984	goto tryagain;
985	}
986	printf("NFS mount (v3,UDP) failed with error %d, trying v2...\n", error);
987	v3 = `0`;
988	sotype = SOCK_STREAM;
989	goto tryagain;
990	} else if (sotype == SOCK_STREAM) {
991	printf("NFS mount (v2,TCP) failed with error %d, trying UDP...\n", error);
992	sotype = SOCK_DGRAM;
993	goto tryagain;
994	} else {
995	printf("NFS mount (v2,UDP) failed with error %d, giving up...\n", error);
996	}
997	switch(error) {
998	case EPROGUNAVAIL:
999	panic("NFS mount failed: NFS server mountd not responding, check server configuration: %s", PE_boot_args());
1000	case EACCES:
1001	case EPERM:
1002	panic("NFS mount failed: NFS server refused mount, check server configuration: %s", PE_boot_args());
1003	default:
1004	panic("NFS mount failed with error %d, check configuration: %s", error, PE_boot_args());
1005	}
1006	}
1007
1008	ctx = vfs_context_kernel();
1009
1010	/*
1011	* Create the root mount point.
1012	*/
1013	#if !defined(NO_MOUNT_PRIVATE)
1014	{
1015	//PWC hack until we have a real "mount" tool to remount root rw
1016	int rw_root=`0`;
1017	int flags = MNT_ROOTFS\|MNT_RDONLY;
1018	PE_parse_boot_argn("-rwroot_hack", &rw_root, sizeof (rw_root));
1019	if(rw_root)
1020	{
1021	flags = MNT_ROOTFS;
1022	kprintf("-rwroot_hack in effect: mounting root fs read/write\n");
1023	}
1024
1025	if ((error = nfs_mount_diskless(&nd.nd_root, "/", flags, &vp, &mp, ctx)))
1026	#else
1027	if ((error = nfs_mount_diskless(&nd.nd_root, "/", MNT_ROOTFS, &vp, &mp, ctx)))
1028	#endif /* NO_MOUNT_PRIVATE */
1029	{
1030	if (v3) {
1031	if (sotype == SOCK_STREAM) {
1032	printf("NFS root mount (v3,TCP) failed with %d, trying UDP...\n", error);
1033	sotype = SOCK_DGRAM;
1034	goto tryagain;
1035	}
1036	printf("NFS root mount (v3,UDP) failed with %d, trying v2...\n", error);
1037	v3 = `0`;
1038	sotype = SOCK_STREAM;
1039	goto tryagain;
1040	} else if (sotype == SOCK_STREAM) {
1041	printf("NFS root mount (v2,TCP) failed with %d, trying UDP...\n", error);
1042	sotype = SOCK_DGRAM;
1043	goto tryagain;
1044	} else {
1045	printf("NFS root mount (v2,UDP) failed with error %d, giving up...\n", error);
1046	}
1047	panic("NFS root mount failed with error %d, check configuration: %s\n", error, PE_boot_args());
1048	}
1049	}
1050	printf("root on %s\n", nd.nd_root.ndm_mntfrom);
1051
1052	vfs_unbusy(mp);
1053	mount_list_add(mp);
1054	rootvp = vp;
1055
1056	#if !defined(NO_MOUNT_PRIVATE)
1057	if (nd.nd_private.ndm_saddr.sin_addr.s_addr) {
1058	error = nfs_mount_diskless_private(&nd.nd_private, "/private",
1059	`0`, &vppriv, &mppriv, ctx);
1060	if (error)
1061	panic("NFS /private mount failed with error %d, check configuration: %s\n", error, PE_boot_args());
1062	printf("private on %s\n", nd.nd_private.ndm_mntfrom);
1063
1064	vfs_unbusy(mppriv);
1065	mount_list_add(mppriv);
1066	}
1067
1068	#endif /* NO_MOUNT_PRIVATE */
1069
1070	if (nd.nd_root.ndm_mntfrom)
1071	FREE_ZONE(nd.nd_root.ndm_mntfrom, MAXPATHLEN, M_NAMEI);
1072	if (nd.nd_root.ndm_path)
1073	FREE_ZONE(nd.nd_root.ndm_path, MAXPATHLEN, M_NAMEI);
1074	if (nd.nd_private.ndm_mntfrom)
1075	FREE_ZONE(nd.nd_private.ndm_mntfrom, MAXPATHLEN, M_NAMEI);
1076	if (nd.nd_private.ndm_path)
1077	FREE_ZONE(nd.nd_private.ndm_path, MAXPATHLEN, M_NAMEI);
1078
1079	/ Get root attributes (for the time). /
1080	error = nfs_getattr(VTONFS(vp), NULL, ctx, NGA_UNCACHED);
1081	if (error)
1082	panic("NFS mount: failed to get attributes for root directory, error %d, check server", error);
1083	return (`0`);
1084	}
1085
1086	/*
1087	* Internal version of mount system call for diskless setup.
1088	*/
1089	static int
1090	nfs_mount_diskless(
1091	struct nfs_dlmount *ndmntp,
1092	const char *mntname,
1093	int mntflag,
1094	vnode_t *vpp,
1095	mount_t *mpp,
1096	vfs_context_t ctx)
1097	{
1098	mount_t mp;
1099	int error, numcomps;
1100	char xdrbuf, p, cp, frompath, *endserverp;
1101	char uaddr[MAX_IPv4_STR_LEN];
1102	struct xdrbuf xb;
1103	uint32_t mattrs[NFS_MATTR_BITMAP_LEN];
1104	uint32_t mflags_mask[NFS_MFLAG_BITMAP_LEN];
1105	uint32_t mflags[NFS_MFLAG_BITMAP_LEN];
1106	uint32_t argslength_offset, attrslength_offset, end_offset;
1107
1108	if ((error = vfs_rootmountalloc("nfs", ndmntp->ndm_mntfrom, &mp))) {
1109	printf("nfs_mount_diskless: NFS not configured\n");
1110	return (error);
1111	}
1112
1113	mp->mnt_flag \|= mntflag;
1114	if (!(mntflag & MNT_RDONLY))
1115	mp->mnt_flag &= ~MNT_RDONLY;
1116
1117	/ find the server-side path being mounted /
1118	frompath = ndmntp->ndm_mntfrom;
1119	if (frompath == `'['`) { /* skip IPv6 literal address /
1120	while (frompath && (frompath != `']'`))
1121	frompath++;
1122	if (*frompath == `']'`)
1123	frompath++;
1124	}
1125	while (frompath && (frompath != `':'`))
1126	frompath++;
1127	endserverp = frompath;
1128	while (frompath && (frompath == `':'`))
1129	frompath++;
1130	/ count fs location path components /
1131	p = frompath;
1132	while (p && (p == `'/'`))
1133	p++;
1134	numcomps = `0`;
1135	while (*p) {
1136	numcomps++;
1137	while (p && (p != `'/'`))
1138	p++;
1139	while (p && (p == `'/'`))
1140	p++;
1141	}
1142
1143	/ convert address to universal address string /
1144	if (inet_ntop(AF_INET, &ndmntp->ndm_saddr.sin_addr, uaddr, sizeof(uaddr)) != uaddr) {
1145	printf("nfs_mount_diskless: bad address\n");
1146	return (EINVAL);
1147	}
1148
1149	/ prepare mount attributes /
1150	NFS_BITMAP_ZERO(mattrs, NFS_MATTR_BITMAP_LEN);
1151	NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_VERSION);
1152	NFS_BITMAP_SET(mattrs, NFS_MATTR_SOCKET_TYPE);
1153	NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_PORT);
1154	NFS_BITMAP_SET(mattrs, NFS_MATTR_FH);
1155	NFS_BITMAP_SET(mattrs, NFS_MATTR_FS_LOCATIONS);
1156	NFS_BITMAP_SET(mattrs, NFS_MATTR_MNTFLAGS);
1157
1158	/ prepare mount flags /
1159	NFS_BITMAP_ZERO(mflags_mask, NFS_MFLAG_BITMAP_LEN);
1160	NFS_BITMAP_ZERO(mflags, NFS_MFLAG_BITMAP_LEN);
1161	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_RESVPORT);
1162	NFS_BITMAP_SET(mflags, NFS_MFLAG_RESVPORT);
1163
1164	/ build xdr buffer /
1165	xb_init_buffer(&xb, NULL, `0`);
1166	xb_add_32(error, &xb, NFS_ARGSVERSION_XDR);
1167	argslength_offset = xb_offset(&xb);
1168	xb_add_32(error, &xb, `0`); // args length
1169	xb_add_32(error, &xb, NFS_XDRARGS_VERSION_0);
1170	xb_add_bitmap(error, &xb, mattrs, NFS_MATTR_BITMAP_LEN);
1171	attrslength_offset = xb_offset(&xb);
1172	xb_add_32(error, &xb, `0`); // attrs length
1173	xb_add_32(error, &xb, ndmntp->ndm_nfsv3 ? `3` : `2`); // NFS version
1174	xb_add_string(error, &xb, ((ndmntp->ndm_sotype == SOCK_DGRAM) ? "udp" : "tcp"), `3`);
1175	xb_add_32(error, &xb, ntohs(ndmntp->ndm_saddr.sin_port)); // NFS port
1176	xb_add_fh(error, &xb, &ndmntp->ndm_fh[`0`], ndmntp->ndm_fhlen);
1177	/ fs location /
1178	xb_add_32(error, &xb, `1`); / fs location count /
1179	xb_add_32(error, &xb, `1`); / server count /
1180	xb_add_string(error, &xb, ndmntp->ndm_mntfrom, (endserverp - ndmntp->ndm_mntfrom)); / server name /
1181	xb_add_32(error, &xb, `1`); / address count /
1182	xb_add_string(error, &xb, uaddr, strlen(uaddr)); / address /
1183	xb_add_32(error, &xb, `0`); / empty server info /
1184	xb_add_32(error, &xb, numcomps); / pathname component count /
1185	p = frompath;
1186	while (p && (p == `'/'`))
1187	p++;
1188	while (*p) {
1189	cp = p;
1190	while (p && (p != `'/'`))
1191	p++;
1192	xb_add_string(error, &xb, cp, (p - cp)); / component /
1193	if (error)
1194	break;
1195	while (p && (p == `'/'`))
1196	p++;
1197	}
1198	xb_add_32(error, &xb, `0`); / empty fsl info /
1199	xb_add_32(error, &xb, mntflag); / MNT flags /
1200	xb_build_done(error, &xb);
1201
1202	/ update opaque counts /
1203	end_offset = xb_offset(&xb);
1204	if (!error) {
1205	error = xb_seek(&xb, argslength_offset);
1206	xb_add_32(error, &xb, end_offset - argslength_offset + XDRWORD/version/);
1207	}
1208	if (!error) {
1209	error = xb_seek(&xb, attrslength_offset);
1210	xb_add_32(error, &xb, end_offset - attrslength_offset - XDRWORD/don't include length field/);
1211	}
1212	if (error) {
1213	printf("nfs_mount_diskless: error %d assembling mount args\n", error);
1214	xb_cleanup(&xb);
1215	return (error);
1216	}
1217	/ grab the assembled buffer /
1218	xdrbuf = xb_buffer_base(&xb);
1219	xb.xb_flags &= ~XB_CLEANUP;
1220
1221	/ do the mount /
1222	if ((error = mountnfs(xdrbuf, mp, ctx, vpp))) {
1223	printf("nfs_mountroot: mount %s failed: %d\n", mntname, error);
1224	// XXX vfs_rootmountfailed(mp);
1225	mount_list_lock();
1226	mp->mnt_vtable->vfc_refcount--;
1227	mount_list_unlock();
1228	vfs_unbusy(mp);
1229	mount_lock_destroy(mp);
1230	#if CONFIG_MACF
1231	mac_mount_label_destroy(mp);
1232	#endif
1233	FREE_ZONE(mp, sizeof(struct mount), M_MOUNT);
1234	} else {
1235	*mpp = mp;
1236	}
1237	xb_cleanup(&xb);
1238	return (error);
1239	}
1240
1241	#if !defined(NO_MOUNT_PRIVATE)
1242	/*
1243	* Internal version of mount system call to mount "/private"
1244	* separately in diskless setup
1245	*/
1246	static int
1247	nfs_mount_diskless_private(
1248	struct nfs_dlmount *ndmntp,
1249	const char *mntname,
1250	int mntflag,
1251	vnode_t *vpp,
1252	mount_t *mpp,
1253	vfs_context_t ctx)
1254	{
1255	mount_t mp;
1256	int error, numcomps;
1257	proc_t procp;
1258	struct vfstable *vfsp;
1259	struct nameidata nd;
1260	vnode_t vp;
1261	char xdrbuf = NULL, p, cp, frompath, *endserverp;
1262	char uaddr[MAX_IPv4_STR_LEN];
1263	struct xdrbuf xb;
1264	uint32_t mattrs[NFS_MATTR_BITMAP_LEN];
1265	uint32_t mflags_mask[NFS_MFLAG_BITMAP_LEN], mflags[NFS_MFLAG_BITMAP_LEN];
1266	uint32_t argslength_offset, attrslength_offset, end_offset;
1267
1268	procp = current_proc(); / XXX /
1269	xb_init(&xb, `0`);
1270
1271	{
1272	/*
1273	* mimic main()!. Temporarily set up rootvnode and other stuff so
1274	* that namei works. Need to undo this because main() does it, too
1275	*/
1276	struct filedesc fdp; /* pointer to file descriptor state /
1277	fdp = procp->p_fd;
1278	mountlist.tqh_first->mnt_flag \|= MNT_ROOTFS;
1279
1280	/ Get the vnode for '/'. Set fdp->fd_cdir to reference it. /
1281	if (VFS_ROOT(mountlist.tqh_first, &rootvnode, NULL))
1282	panic("cannot find root vnode");
1283	error = vnode_ref(rootvnode);
1284	if (error) {
1285	printf("nfs_mountroot: vnode_ref() failed on root vnode!\n");
1286	goto out;
1287	}
1288	fdp->fd_cdir = rootvnode;
1289	fdp->fd_rdir = NULL;
1290	}
1291
1292	/*
1293	* Get vnode to be covered
1294	*/
1295	NDINIT(&nd, LOOKUP, OP_LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE,
1296	CAST_USER_ADDR_T(mntname), ctx);
1297	if ((error = namei(&nd))) {
1298	printf("nfs_mountroot: private namei failed!\n");
1299	goto out;
1300	}
1301	{
1302	/ undo vnode_ref() in mimic main()! /
1303	vnode_rele(rootvnode);
1304	}
1305	nameidone(&nd);
1306	vp = nd.ni_vp;
1307
1308	if ((error = VNOP_FSYNC(vp, MNT_WAIT, ctx)) \|\|
1309	(error = buf_invalidateblks(vp, BUF_WRITE_DATA, `0`, `0`))) {
1310	vnode_put(vp);
1311	goto out;
1312	}
1313	if (vnode_vtype(vp) != VDIR) {
1314	vnode_put(vp);
1315	error = ENOTDIR;
1316	goto out;
1317	}
1318	for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
1319	if (!strncmp(vfsp->vfc_name, "nfs", sizeof(vfsp->vfc_name)))
1320	break;
1321	if (vfsp == NULL) {
1322	printf("nfs_mountroot: private NFS not configured\n");
1323	vnode_put(vp);
1324	error = ENODEV;
1325	goto out;
1326	}
1327	if (vnode_mountedhere(vp) != NULL) {
1328	vnode_put(vp);
1329	error = EBUSY;
1330	goto out;
1331	}
1332
1333	/*
1334	* Allocate and initialize the filesystem.
1335	*/
1336	mp = _MALLOC_ZONE((u_int32_t)sizeof(struct mount), M_MOUNT, M_WAITOK);
1337	if (!mp) {
1338	printf("nfs_mountroot: unable to allocate mount structure\n");
1339	vnode_put(vp);
1340	error = ENOMEM;
1341	goto out;
1342	}
1343	bzero((char )mp, sizeof(struct* mount));
1344
1345	/ Initialize the default IO constraints /
1346	mp->mnt_maxreadcnt = mp->mnt_maxwritecnt = MAXPHYS;
1347	mp->mnt_segreadcnt = mp->mnt_segwritecnt = `32`;
1348	mp->mnt_ioflags = `0`;
1349	mp->mnt_realrootvp = NULLVP;
1350	mp->mnt_authcache_ttl = `0`; / Allways go to our lookup /
1351
1352	mount_lock_init(mp);
1353	TAILQ_INIT(&mp->mnt_vnodelist);
1354	TAILQ_INIT(&mp->mnt_workerqueue);
1355	TAILQ_INIT(&mp->mnt_newvnodes);
1356	(void)vfs_busy(mp, LK_NOWAIT);
1357	TAILQ_INIT(&mp->mnt_vnodelist);
1358	mount_list_lock();
1359	vfsp->vfc_refcount++;
1360	mount_list_unlock();
1361	mp->mnt_vtable = vfsp;
1362	mp->mnt_op = vfsp->vfc_vfsops;
1363	// mp->mnt_stat.f_type = vfsp->vfc_typenum;
1364	mp->mnt_flag = mntflag;
1365	mp->mnt_flag \|= vfsp->vfc_flags & MNT_VISFLAGMASK;
1366	strncpy(mp->mnt_vfsstat.f_fstypename, vfsp->vfc_name, MFSNAMELEN-`1`);
1367	vp->v_mountedhere = mp;
1368	mp->mnt_vnodecovered = vp;
1369	vp = NULLVP;
1370	mp->mnt_vfsstat.f_owner = kauth_cred_getuid(kauth_cred_get());
1371	(void) copystr(mntname, mp->mnt_vfsstat.f_mntonname, MAXPATHLEN - `1`, `0`);
1372	(void) copystr(ndmntp->ndm_mntfrom, mp->mnt_vfsstat.f_mntfromname, MAXPATHLEN - `1`, `0`);
1373	#if CONFIG_MACF
1374	mac_mount_label_init(mp);
1375	mac_mount_label_associate(ctx, mp);
1376	#endif
1377
1378	/ find the server-side path being mounted /
1379	frompath = ndmntp->ndm_mntfrom;
1380	if (frompath == `'['`) { /* skip IPv6 literal address /
1381	while (frompath && (frompath != `']'`))
1382	frompath++;
1383	if (*frompath == `']'`)
1384	frompath++;
1385	}
1386	while (frompath && (frompath != `':'`))
1387	frompath++;
1388	endserverp = frompath;
1389	while (frompath && (frompath == `':'`))
1390	frompath++;
1391	/ count fs location path components /
1392	p = frompath;
1393	while (p && (p == `'/'`))
1394	p++;
1395	numcomps = `0`;
1396	while (*p) {
1397	numcomps++;
1398	while (p && (p != `'/'`))
1399	p++;
1400	while (p && (p == `'/'`))
1401	p++;
1402	}
1403
1404	/ convert address to universal address string /
1405	if (inet_ntop(AF_INET, &ndmntp->ndm_saddr.sin_addr, uaddr, sizeof(uaddr)) != uaddr) {
1406	printf("nfs_mountroot: bad address\n");
1407	error = EINVAL;
1408	goto out;
1409	}
1410
1411	/ prepare mount attributes /
1412	NFS_BITMAP_ZERO(mattrs, NFS_MATTR_BITMAP_LEN);
1413	NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_VERSION);
1414	NFS_BITMAP_SET(mattrs, NFS_MATTR_SOCKET_TYPE);
1415	NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_PORT);
1416	NFS_BITMAP_SET(mattrs, NFS_MATTR_FH);
1417	NFS_BITMAP_SET(mattrs, NFS_MATTR_FS_LOCATIONS);
1418	NFS_BITMAP_SET(mattrs, NFS_MATTR_MNTFLAGS);
1419
1420	/ prepare mount flags /
1421	NFS_BITMAP_ZERO(mflags_mask, NFS_MFLAG_BITMAP_LEN);
1422	NFS_BITMAP_ZERO(mflags, NFS_MFLAG_BITMAP_LEN);
1423	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_RESVPORT);
1424	NFS_BITMAP_SET(mflags, NFS_MFLAG_RESVPORT);
1425
1426	/ build xdr buffer /
1427	xb_init_buffer(&xb, NULL, `0`);
1428	xb_add_32(error, &xb, NFS_ARGSVERSION_XDR);
1429	argslength_offset = xb_offset(&xb);
1430	xb_add_32(error, &xb, `0`); // args length
1431	xb_add_32(error, &xb, NFS_XDRARGS_VERSION_0);
1432	xb_add_bitmap(error, &xb, mattrs, NFS_MATTR_BITMAP_LEN);
1433	attrslength_offset = xb_offset(&xb);
1434	xb_add_32(error, &xb, `0`); // attrs length
1435	xb_add_32(error, &xb, ndmntp->ndm_nfsv3 ? `3` : `2`); // NFS version
1436	xb_add_string(error, &xb, ((ndmntp->ndm_sotype == SOCK_DGRAM) ? "udp" : "tcp"), `3`);
1437	xb_add_32(error, &xb, ntohs(ndmntp->ndm_saddr.sin_port)); // NFS port
1438	xb_add_fh(error, &xb, &ndmntp->ndm_fh[`0`], ndmntp->ndm_fhlen);
1439	/ fs location /
1440	xb_add_32(error, &xb, `1`); / fs location count /
1441	xb_add_32(error, &xb, `1`); / server count /
1442	xb_add_string(error, &xb, ndmntp->ndm_mntfrom, (endserverp - ndmntp->ndm_mntfrom)); / server name /
1443	xb_add_32(error, &xb, `1`); / address count /
1444	xb_add_string(error, &xb, uaddr, strlen(uaddr)); / address /
1445	xb_add_32(error, &xb, `0`); / empty server info /
1446	xb_add_32(error, &xb, numcomps); / pathname component count /
1447	p = frompath;
1448	while (p && (p == `'/'`))
1449	p++;
1450	while (*p) {
1451	cp = p;
1452	while (p && (p != `'/'`))
1453	p++;
1454	xb_add_string(error, &xb, cp, (p - cp)); / component /
1455	if (error)
1456	break;
1457	while (p && (p == `'/'`))
1458	p++;
1459	}
1460	xb_add_32(error, &xb, `0`); / empty fsl info /
1461	xb_add_32(error, &xb, mntflag); / MNT flags /
1462	xb_build_done(error, &xb);
1463
1464	/ update opaque counts /
1465	end_offset = xb_offset(&xb);
1466	if (!error) {
1467	error = xb_seek(&xb, argslength_offset);
1468	xb_add_32(error, &xb, end_offset - argslength_offset + XDRWORD/version/);
1469	}
1470	if (!error) {
1471	error = xb_seek(&xb, attrslength_offset);
1472	xb_add_32(error, &xb, end_offset - attrslength_offset - XDRWORD/don't include length field/);
1473	}
1474	if (error) {
1475	printf("nfs_mountroot: error %d assembling mount args\n", error);
1476	goto out;
1477	}
1478	/ grab the assembled buffer /
1479	xdrbuf = xb_buffer_base(&xb);
1480	xb.xb_flags &= ~XB_CLEANUP;
1481
1482	/ do the mount /
1483	if ((error = mountnfs(xdrbuf, mp, ctx, &vp))) {
1484	printf("nfs_mountroot: mount %s failed: %d\n", mntname, error);
1485	vnode_put(mp->mnt_vnodecovered);
1486	mount_list_lock();
1487	vfsp->vfc_refcount--;
1488	mount_list_unlock();
1489	vfs_unbusy(mp);
1490	mount_lock_destroy(mp);
1491	#if CONFIG_MACF
1492	mac_mount_label_destroy(mp);
1493	#endif
1494	FREE_ZONE(mp, sizeof (struct mount), M_MOUNT);
1495	goto out;
1496	}
1497
1498	*mpp = mp;
1499	*vpp = vp;
1500	out:
1501	xb_cleanup(&xb);
1502	return (error);
1503	}
1504	#endif /* NO_MOUNT_PRIVATE */
1505
1506	/*
1507	* Convert old style NFS mount args to XDR.
1508	*/
1509	static int
1510	nfs_convert_old_nfs_args(mount_t mp, user_addr_t data, vfs_context_t ctx, int argsversion, int inkernel, char **xdrbufp)
1511	{
1512	int error = `0`, args64bit, argsize, numcomps;
1513	struct user_nfs_args args;
1514	struct nfs_args tempargs;
1515	caddr_t argsp;
1516	size_t len;
1517	u_char nfh[NFS4_FHSIZE];
1518	char mntfrom, endserverp, frompath, p, *cp;
1519	struct sockaddr_storage ss;
1520	void *sinaddr;
1521	char uaddr[MAX_IPv6_STR_LEN];
1522	uint32_t mattrs[NFS_MATTR_BITMAP_LEN];
1523	uint32_t mflags_mask[NFS_MFLAG_BITMAP_LEN], mflags[NFS_MFLAG_BITMAP_LEN];
1524	uint32_t nfsvers, nfslockmode = `0`, argslength_offset, attrslength_offset, end_offset;
1525	struct xdrbuf xb;
1526
1527	*xdrbufp = NULL;
1528
1529	/ allocate a temporary buffer for mntfrom /
1530	MALLOC_ZONE(mntfrom, char*, MAXPATHLEN, M_NAMEI, M_WAITOK);
1531	if (!mntfrom)
1532	return (ENOMEM);
1533
1534	args64bit = (inkernel \|\| vfs_context_is64bit(ctx));
1535	argsp = args64bit ? (void)&args : (void**)&tempargs;
1536
1537	argsize = args64bit ? sizeof(args) : sizeof(tempargs);
1538	switch (argsversion) {
1539	case `3`:
1540	argsize -= NFS_ARGSVERSION4_INCSIZE;
1541	case `4`:
1542	argsize -= NFS_ARGSVERSION5_INCSIZE;
1543	case `5`:
1544	argsize -= NFS_ARGSVERSION6_INCSIZE;
1545	case `6`:
1546	break;
1547	default:
1548	error = EPROGMISMATCH;
1549	goto nfsmout;
1550	}
1551
1552	/ read in the structure /
1553	if (inkernel)
1554	bcopy(CAST_DOWN(void *, data), argsp, argsize);
1555	else
1556	error = copyin(data, argsp, argsize);
1557	nfsmout_if(error);
1558
1559	if (!args64bit) {
1560	args.addrlen = tempargs.addrlen;
1561	args.sotype = tempargs.sotype;
1562	args.proto = tempargs.proto;
1563	args.fhsize = tempargs.fhsize;
1564	args.flags = tempargs.flags;
1565	args.wsize = tempargs.wsize;
1566	args.rsize = tempargs.rsize;
1567	args.readdirsize = tempargs.readdirsize;
1568	args.timeo = tempargs.timeo;
1569	args.retrans = tempargs.retrans;
1570	args.maxgrouplist = tempargs.maxgrouplist;
1571	args.readahead = tempargs.readahead;
1572	args.leaseterm = tempargs.leaseterm;
1573	args.deadthresh = tempargs.deadthresh;
1574	args.addr = CAST_USER_ADDR_T(tempargs.addr);
1575	args.fh = CAST_USER_ADDR_T(tempargs.fh);
1576	args.hostname = CAST_USER_ADDR_T(tempargs.hostname);
1577	if (args.version >= `4`) {
1578	args.acregmin = tempargs.acregmin;
1579	args.acregmax = tempargs.acregmax;
1580	args.acdirmin = tempargs.acdirmin;
1581	args.acdirmax = tempargs.acdirmax;
1582	}
1583	if (args.version >= `5`)
1584	args.auth = tempargs.auth;
1585	if (args.version >= `6`)
1586	args.deadtimeout = tempargs.deadtimeout;
1587	}
1588
1589	if ((args.fhsize < `0`) \|\| (args.fhsize > NFS4_FHSIZE)) {
1590	error = EINVAL;
1591	goto nfsmout;
1592	}
1593	if (args.fhsize > `0`) {
1594	if (inkernel)
1595	bcopy(CAST_DOWN(void *, args.fh), (caddr_t)nfh, args.fhsize);
1596	else
1597	error = copyin(args.fh, (caddr_t)nfh, args.fhsize);
1598	nfsmout_if(error);
1599	}
1600
1601	if (inkernel)
1602	error = copystr(CAST_DOWN(void *, args.hostname), mntfrom, MAXPATHLEN-`1`, &len);
1603	else
1604	error = copyinstr(args.hostname, mntfrom, MAXPATHLEN-`1`, &len);
1605	nfsmout_if(error);
1606	bzero(&mntfrom[len], MAXPATHLEN - len);
1607
1608	/ find the server-side path being mounted /
1609	frompath = mntfrom;
1610	if (frompath == `'['`) { /* skip IPv6 literal address /
1611	while (frompath && (frompath != `']'`))
1612	frompath++;
1613	if (*frompath == `']'`)
1614	frompath++;
1615	}
1616	while (frompath && (frompath != `':'`))
1617	frompath++;
1618	endserverp = frompath;
1619	while (frompath && (frompath == `':'`))
1620	frompath++;
1621	/ count fs location path components /
1622	p = frompath;
1623	while (p && (p == `'/'`))
1624	p++;
1625	numcomps = `0`;
1626	while (*p) {
1627	numcomps++;
1628	while (p && (p != `'/'`))
1629	p++;
1630	while (p && (p == `'/'`))
1631	p++;
1632	}
1633
1634	/ copy socket address /
1635	if (inkernel)
1636	bcopy(CAST_DOWN(void *, args.addr), &ss, args.addrlen);
1637	else {
1638	if ((size_t)args.addrlen > sizeof (struct sockaddr_storage))
1639	error = EINVAL;
1640	else
1641	error = copyin(args.addr, &ss, args.addrlen);
1642	}
1643	nfsmout_if(error);
1644	ss.ss_len = args.addrlen;
1645
1646	/ convert address to universal address string /
1647	if (ss.ss_family == AF_INET)
1648	sinaddr = &((struct sockaddr_in*)&ss)->sin_addr;
1649	else if (ss.ss_family == AF_INET6)
1650	sinaddr = &((struct sockaddr_in6*)&ss)->sin6_addr;
1651	else
1652	sinaddr = NULL;
1653	if (!sinaddr \|\| (inet_ntop(ss.ss_family, sinaddr, uaddr, sizeof(uaddr)) != uaddr)) {
1654	error = EINVAL;
1655	goto nfsmout;
1656	}
1657
1658	/ prepare mount flags /
1659	NFS_BITMAP_ZERO(mflags_mask, NFS_MFLAG_BITMAP_LEN);
1660	NFS_BITMAP_ZERO(mflags, NFS_MFLAG_BITMAP_LEN);
1661	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_SOFT);
1662	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_INTR);
1663	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_RESVPORT);
1664	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NOCONNECT);
1665	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_DUMBTIMER);
1666	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_CALLUMNT);
1667	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_RDIRPLUS);
1668	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NONEGNAMECACHE);
1669	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_MUTEJUKEBOX);
1670	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NOQUOTA);
1671	if (args.flags & NFSMNT_SOFT)
1672	NFS_BITMAP_SET(mflags, NFS_MFLAG_SOFT);
1673	if (args.flags & NFSMNT_INT)
1674	NFS_BITMAP_SET(mflags, NFS_MFLAG_INTR);
1675	if (args.flags & NFSMNT_RESVPORT)
1676	NFS_BITMAP_SET(mflags, NFS_MFLAG_RESVPORT);
1677	if (args.flags & NFSMNT_NOCONN)
1678	NFS_BITMAP_SET(mflags, NFS_MFLAG_NOCONNECT);
1679	if (args.flags & NFSMNT_DUMBTIMR)
1680	NFS_BITMAP_SET(mflags, NFS_MFLAG_DUMBTIMER);
1681	if (args.flags & NFSMNT_CALLUMNT)
1682	NFS_BITMAP_SET(mflags, NFS_MFLAG_CALLUMNT);
1683	if (args.flags & NFSMNT_RDIRPLUS)
1684	NFS_BITMAP_SET(mflags, NFS_MFLAG_RDIRPLUS);
1685	if (args.flags & NFSMNT_NONEGNAMECACHE)
1686	NFS_BITMAP_SET(mflags, NFS_MFLAG_NONEGNAMECACHE);
1687	if (args.flags & NFSMNT_MUTEJUKEBOX)
1688	NFS_BITMAP_SET(mflags, NFS_MFLAG_MUTEJUKEBOX);
1689	if (args.flags & NFSMNT_NOQUOTA)
1690	NFS_BITMAP_SET(mflags, NFS_MFLAG_NOQUOTA);
1691
1692	/ prepare mount attributes /
1693	NFS_BITMAP_ZERO(mattrs, NFS_MATTR_BITMAP_LEN);
1694	NFS_BITMAP_SET(mattrs, NFS_MATTR_FLAGS);
1695	NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_VERSION);
1696	NFS_BITMAP_SET(mattrs, NFS_MATTR_SOCKET_TYPE);
1697	NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_PORT);
1698	NFS_BITMAP_SET(mattrs, NFS_MATTR_FH);
1699	NFS_BITMAP_SET(mattrs, NFS_MATTR_FS_LOCATIONS);
1700	NFS_BITMAP_SET(mattrs, NFS_MATTR_MNTFLAGS);
1701	NFS_BITMAP_SET(mattrs, NFS_MATTR_MNTFROM);
1702	if (args.flags & NFSMNT_NFSV4)
1703	nfsvers = `4`;
1704	else if (args.flags & NFSMNT_NFSV3)
1705	nfsvers = `3`;
1706	else
1707	nfsvers = `2`;
1708	if ((args.flags & NFSMNT_RSIZE) && (args.rsize > `0`))
1709	NFS_BITMAP_SET(mattrs, NFS_MATTR_READ_SIZE);
1710	if ((args.flags & NFSMNT_WSIZE) && (args.wsize > `0`))
1711	NFS_BITMAP_SET(mattrs, NFS_MATTR_WRITE_SIZE);
1712	if ((args.flags & NFSMNT_TIMEO) && (args.timeo > `0`))
1713	NFS_BITMAP_SET(mattrs, NFS_MATTR_REQUEST_TIMEOUT);
1714	if ((args.flags & NFSMNT_RETRANS) && (args.retrans > `0`))
1715	NFS_BITMAP_SET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT);
1716	if ((args.flags & NFSMNT_MAXGRPS) && (args.maxgrouplist > `0`))
1717	NFS_BITMAP_SET(mattrs, NFS_MATTR_MAX_GROUP_LIST);
1718	if ((args.flags & NFSMNT_READAHEAD) && (args.readahead > `0`))
1719	NFS_BITMAP_SET(mattrs, NFS_MATTR_READAHEAD);
1720	if ((args.flags & NFSMNT_READDIRSIZE) && (args.readdirsize > `0`))
1721	NFS_BITMAP_SET(mattrs, NFS_MATTR_READDIR_SIZE);
1722	if ((args.flags & NFSMNT_NOLOCKS) \|\|
1723	(args.flags & NFSMNT_LOCALLOCKS)) {
1724	NFS_BITMAP_SET(mattrs, NFS_MATTR_LOCK_MODE);
1725	if (args.flags & NFSMNT_NOLOCKS)
1726	nfslockmode = NFS_LOCK_MODE_DISABLED;
1727	else if (args.flags & NFSMNT_LOCALLOCKS)
1728	nfslockmode = NFS_LOCK_MODE_LOCAL;
1729	else
1730	nfslockmode = NFS_LOCK_MODE_ENABLED;
1731	}
1732	if (args.version >= `4`) {
1733	if ((args.flags & NFSMNT_ACREGMIN) && (args.acregmin > `0`))
1734	NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_REG_MIN);
1735	if ((args.flags & NFSMNT_ACREGMAX) && (args.acregmax > `0`))
1736	NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_REG_MAX);
1737	if ((args.flags & NFSMNT_ACDIRMIN) && (args.acdirmin > `0`))
1738	NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MIN);
1739	if ((args.flags & NFSMNT_ACDIRMAX) && (args.acdirmax > `0`))
1740	NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MAX);
1741	}
1742	if (args.version >= `5`) {
1743	if ((args.flags & NFSMNT_SECFLAVOR) \|\| (args.flags & NFSMNT_SECSYSOK))
1744	NFS_BITMAP_SET(mattrs, NFS_MATTR_SECURITY);
1745	}
1746	if (args.version >= `6`) {
1747	if ((args.flags & NFSMNT_DEADTIMEOUT) && (args.deadtimeout > `0`))
1748	NFS_BITMAP_SET(mattrs, NFS_MATTR_DEAD_TIMEOUT);
1749	}
1750
1751	/ build xdr buffer /
1752	xb_init_buffer(&xb, NULL, `0`);
1753	xb_add_32(error, &xb, args.version);
1754	argslength_offset = xb_offset(&xb);
1755	xb_add_32(error, &xb, `0`); // args length
1756	xb_add_32(error, &xb, NFS_XDRARGS_VERSION_0);
1757	xb_add_bitmap(error, &xb, mattrs, NFS_MATTR_BITMAP_LEN);
1758	attrslength_offset = xb_offset(&xb);
1759	xb_add_32(error, &xb, `0`); // attrs length
1760	xb_add_bitmap(error, &xb, mflags_mask, NFS_MFLAG_BITMAP_LEN); / mask /
1761	xb_add_bitmap(error, &xb, mflags, NFS_MFLAG_BITMAP_LEN); / value /
1762	xb_add_32(error, &xb, nfsvers);
1763	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE))
1764	xb_add_32(error, &xb, args.rsize);
1765	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE))
1766	xb_add_32(error, &xb, args.wsize);
1767	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READDIR_SIZE))
1768	xb_add_32(error, &xb, args.readdirsize);
1769	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READAHEAD))
1770	xb_add_32(error, &xb, args.readahead);
1771	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_REG_MIN)) {
1772	xb_add_32(error, &xb, args.acregmin);
1773	xb_add_32(error, &xb, `0`);
1774	}
1775	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_REG_MAX)) {
1776	xb_add_32(error, &xb, args.acregmax);
1777	xb_add_32(error, &xb, `0`);
1778	}
1779	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MIN)) {
1780	xb_add_32(error, &xb, args.acdirmin);
1781	xb_add_32(error, &xb, `0`);
1782	}
1783	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MAX)) {
1784	xb_add_32(error, &xb, args.acdirmax);
1785	xb_add_32(error, &xb, `0`);
1786	}
1787	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCK_MODE))
1788	xb_add_32(error, &xb, nfslockmode);
1789	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SECURITY)) {
1790	uint32_t flavors[`2`], i=`0`;
1791	if (args.flags & NFSMNT_SECFLAVOR)
1792	flavors[i++] = args.auth;
1793	if ((args.flags & NFSMNT_SECSYSOK) && ((i == `0`) \|\| (flavors[`0`] != RPCAUTH_SYS)))
1794	flavors[i++] = RPCAUTH_SYS;
1795	xb_add_word_array(error, &xb, flavors, i);
1796	}
1797	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MAX_GROUP_LIST))
1798	xb_add_32(error, &xb, args.maxgrouplist);
1799	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOCKET_TYPE))
1800	xb_add_string(error, &xb, ((args.sotype == SOCK_DGRAM) ? "udp" : "tcp"), `3`);
1801	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_PORT))
1802	xb_add_32(error, &xb, ((ss.ss_family == AF_INET) ?
1803	ntohs(((struct sockaddr_in*)&ss)->sin_port) :
1804	ntohs(((struct sockaddr_in6*)&ss)->sin6_port)));
1805	/ NFS_MATTR_MOUNT_PORT (not available in old args) /
1806	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_REQUEST_TIMEOUT)) {
1807	/ convert from .1s increments to time /
1808	xb_add_32(error, &xb, args.timeo/`10`);
1809	xb_add_32(error, &xb, (args.timeo%`10`)*`100000000`);
1810	}
1811	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT))
1812	xb_add_32(error, &xb, args.retrans);
1813	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_DEAD_TIMEOUT)) {
1814	xb_add_32(error, &xb, args.deadtimeout);
1815	xb_add_32(error, &xb, `0`);
1816	}
1817	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FH))
1818	xb_add_fh(error, &xb, &nfh[`0`], args.fhsize);
1819	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FS_LOCATIONS)) {
1820	xb_add_32(error, &xb, `1`); / fs location count /
1821	xb_add_32(error, &xb, `1`); / server count /
1822	xb_add_string(error, &xb, mntfrom, (endserverp - mntfrom)); / server name /
1823	xb_add_32(error, &xb, `1`); / address count /
1824	xb_add_string(error, &xb, uaddr, strlen(uaddr)); / address /
1825	xb_add_32(error, &xb, `0`); / empty server info /
1826	xb_add_32(error, &xb, numcomps); / pathname component count /
1827	nfsmout_if(error);
1828	p = frompath;
1829	while (p && (p == `'/'`))
1830	p++;
1831	while (*p) {
1832	cp = p;
1833	while (p && (p != `'/'`))
1834	p++;
1835	xb_add_string(error, &xb, cp, (p - cp)); / component /
1836	nfsmout_if(error);
1837	while (p && (p == `'/'`))
1838	p++;
1839	}
1840	xb_add_32(error, &xb, `0`); / empty fsl info /
1841	}
1842	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFLAGS))
1843	xb_add_32(error, &xb, (vfs_flags(mp) & MNT_VISFLAGMASK)); / VFS MNT_* flags /
1844	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFROM))
1845	xb_add_string(error, &xb, mntfrom, strlen(mntfrom)); / fixed f_mntfromname /
1846	xb_build_done(error, &xb);
1847
1848	/ update opaque counts /
1849	end_offset = xb_offset(&xb);
1850	error = xb_seek(&xb, argslength_offset);
1851	xb_add_32(error, &xb, end_offset - argslength_offset + XDRWORD/version/);
1852	nfsmout_if(error);
1853	error = xb_seek(&xb, attrslength_offset);
1854	xb_add_32(error, &xb, end_offset - attrslength_offset - XDRWORD/don't include length field/);
1855
1856	if (!error) {
1857	/ grab the assembled buffer /
1858	*xdrbufp = xb_buffer_base(&xb);
1859	xb.xb_flags &= ~XB_CLEANUP;
1860	}
1861	nfsmout:
1862	xb_cleanup(&xb);
1863	FREE_ZONE(mntfrom, MAXPATHLEN, M_NAMEI);
1864	return (error);
1865	}
1866
1867	/*
1868	* VFS Operations.
1869	*
1870	* mount system call
1871	*/
1872	int
1873	nfs_vfs_mount(mount_t mp, vnode_t vp, user_addr_t data, vfs_context_t ctx)
1874	{
1875	int error = `0`, inkernel = vfs_iskernelmount(mp);
1876	uint32_t argsversion, argslength;
1877	char *xdrbuf = NULL;
1878
1879	/ read in version /
1880	if (inkernel)
1881	bcopy(CAST_DOWN(void , data), &argsversion, sizeof*(argsversion));
1882	else if ((error = copyin(data, &argsversion, sizeof(argsversion))))
1883	return (error);
1884
1885	/ If we have XDR args, then all values in the buffer are in network order /
1886	if (argsversion == htonl(NFS_ARGSVERSION_XDR))
1887	argsversion = NFS_ARGSVERSION_XDR;
1888
1889	switch (argsversion) {
1890	case `3`:
1891	case `4`:
1892	case `5`:
1893	case `6`:
1894	/ convert old-style args to xdr /
1895	error = nfs_convert_old_nfs_args(mp, data, ctx, argsversion, inkernel, &xdrbuf);
1896	break;
1897	case NFS_ARGSVERSION_XDR:
1898	/ copy in xdr buffer /
1899	if (inkernel)
1900	bcopy(CAST_DOWN(void *, (data + XDRWORD)), &argslength, XDRWORD);
1901	else
1902	error = copyin((data + XDRWORD), &argslength, XDRWORD);
1903	if (error)
1904	break;
1905	argslength = ntohl(argslength);
1906	/ put a reasonable limit on the size of the XDR args /
1907	if (argslength > `16`*`1024`) {
1908	error = E2BIG;
1909	break;
1910	}
1911	/ allocate xdr buffer /
1912	xdrbuf = xb_malloc(xdr_rndup(argslength));
1913	if (!xdrbuf) {
1914	error = ENOMEM;
1915	break;
1916	}
1917	if (inkernel)
1918	bcopy(CAST_DOWN(void *, data), xdrbuf, argslength);
1919	else
1920	error = copyin(data, xdrbuf, argslength);
1921	break;
1922	default:
1923	error = EPROGMISMATCH;
1924	}
1925
1926	if (error) {
1927	if (xdrbuf)
1928	xb_free(xdrbuf);
1929	return (error);
1930	}
1931	error = mountnfs(xdrbuf, mp, ctx, &vp);
1932	return (error);
1933	}
1934
1935	/*
1936	* Common code for mount and mountroot
1937	*/
1938
1939	/ Set up an NFSv2/v3 mount /
1940	int
1941	nfs3_mount(
1942	struct nfsmount *nmp,
1943	vfs_context_t ctx,
1944	nfsnode_t *npp)
1945	{
1946	int error = `0`;
1947	struct nfs_vattr nvattr;
1948	u_int64_t xid;
1949
1950	*npp = NULL;
1951
1952	if (!nmp->nm_fh)
1953	return (EINVAL);
1954
1955	/*
1956	* Get file attributes for the mountpoint. These are needed
1957	* in order to properly create the root vnode.
1958	*/
1959	error = nfs3_getattr_rpc(NULL, nmp->nm_mountp, nmp->nm_fh->fh_data, nmp->nm_fh->fh_len, `0`,
1960	ctx, &nvattr, &xid);
1961	if (error)
1962	goto out;
1963
1964	error = nfs_nget(nmp->nm_mountp, NULL, NULL, nmp->nm_fh->fh_data, nmp->nm_fh->fh_len,
1965	&nvattr, &xid, RPCAUTH_UNKNOWN, NG_MARKROOT, npp);
1966	if (*npp)
1967	nfs_node_unlock(*npp);
1968	if (error)
1969	goto out;
1970
1971	/*
1972	* Try to make sure we have all the general info from the server.
1973	*/
1974	if (nmp->nm_vers == NFS_VER2) {
1975	NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXNAME);
1976	nmp->nm_fsattr.nfsa_maxname = NFS_MAXNAMLEN;
1977	} else if (nmp->nm_vers == NFS_VER3) {
1978	/ get the NFSv3 FSINFO /
1979	error = nfs3_fsinfo(nmp, *npp, ctx);
1980	if (error)
1981	goto out;
1982	/ If the server indicates all pathconf info is /
1983	/ the same, grab a copy of that info now /
1984	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_HOMOGENEOUS) &&
1985	(nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_HOMOGENEOUS)) {
1986	struct nfs_fsattr nfsa;
1987	if (!nfs3_pathconf_rpc(*npp, &nfsa, ctx)) {
1988	/ cache a copy of the results /
1989	lck_mtx_lock(&nmp->nm_lock);
1990	nfs3_pathconf_cache(nmp, &nfsa);
1991	lck_mtx_unlock(&nmp->nm_lock);
1992	}
1993	}
1994	}
1995	out:
1996	if (*npp && error) {
1997	vnode_put(NFSTOV(*npp));
1998	vnode_recycle(NFSTOV(*npp));
1999	*npp = NULL;
2000	}
2001	return (error);
2002	}
2003
2004	/*
2005	* Update an NFSv4 mount path with the contents of the symlink.
2006	*
2007	* Read the link for the given file handle.
2008	* Insert the link's components into the path.
2009	*/
2010	int
2011	nfs4_mount_update_path_with_symlink(struct nfsmount nmp, struct* nfs_fs_path nfsp, uint32_t curcomp, fhandle_t dirfhp, int depthp, fhandle_t fhp, vfs_context_t ctx)
2012	{
2013	int error = `0`, status, numops;
2014	uint32_t len = `0`, comp, newcomp, linkcompcount;
2015	u_int64_t xid;
2016	struct nfsm_chain nmreq, nmrep;
2017	struct nfsreq rq, *req = &rq;
2018	struct nfsreq_secinfo_args si;
2019	char link = NULL, p, *q, ch;
2020	struct nfs_fs_path nfsp2;
2021
2022	bzero(&nfsp2, sizeof(nfsp2));
2023	if (dirfhp->fh_len)
2024	NFSREQ_SECINFO_SET(&si, NULL, dirfhp->fh_data, dirfhp->fh_len, nfsp->np_components[curcomp], `0`);
2025	else
2026	NFSREQ_SECINFO_SET(&si, NULL, NULL, `0`, nfsp->np_components[curcomp], `0`);
2027	nfsm_chain_null(&nmreq);
2028	nfsm_chain_null(&nmrep);
2029
2030	MALLOC_ZONE(link, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
2031	if (!link)
2032	error = ENOMEM;
2033
2034	// PUTFH, READLINK
2035	numops = `2`;
2036	nfsm_chain_build_alloc_init(error, &nmreq, `12` * NFSX_UNSIGNED);
2037	nfsm_chain_add_compound_header(error, &nmreq, "readlink", nmp->nm_minor_vers, numops);
2038	numops--;
2039	nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
2040	nfsm_chain_add_fh(error, &nmreq, NFS_VER4, fhp->fh_data, fhp->fh_len);
2041	numops--;
2042	nfsm_chain_add_32(error, &nmreq, NFS_OP_READLINK);
2043	nfsm_chain_build_done(error, &nmreq);
2044	nfsm_assert(error, (numops == `0`), EPROTO);
2045	nfsmout_if(error);
2046
2047	error = nfs_request_async(NULL, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND,
2048	vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, `0`, NULL, &req);
2049	if (!error)
2050	error = nfs_request_async_finish(req, &nmrep, &xid, &status);
2051
2052	nfsm_chain_skip_tag(error, &nmrep);
2053	nfsm_chain_get_32(error, &nmrep, numops);
2054	nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
2055	nfsm_chain_op_check(error, &nmrep, NFS_OP_READLINK);
2056	nfsm_chain_get_32(error, &nmrep, len);
2057	nfsmout_if(error);
2058	if (len == `0`)
2059	error = ENOENT;
2060	else if (len >= MAXPATHLEN)
2061	len = MAXPATHLEN - `1`;
2062	nfsm_chain_get_opaque(error, &nmrep, len, link);
2063	nfsmout_if(error);
2064	/ make sure link string is terminated properly /
2065	link[len] = `'\0'`;
2066
2067	/ count the number of components in link /
2068	p = link;
2069	while (p && (p == `'/'`))
2070	p++;
2071	linkcompcount = `0`;
2072	while (*p) {
2073	linkcompcount++;
2074	while (p && (p != `'/'`))
2075	p++;
2076	while (p && (p == `'/'`))
2077	p++;
2078	}
2079
2080	/ free up used components /
2081	for (comp=`0`; comp <= curcomp; comp++) {
2082	if (nfsp->np_components[comp]) {
2083	FREE(nfsp->np_components[comp], M_TEMP);
2084	nfsp->np_components[comp] = NULL;
2085	}
2086	}
2087
2088	/ set up new path /
2089	nfsp2.np_compcount = nfsp->np_compcount - curcomp - `1` + linkcompcount;
2090	MALLOC(nfsp2.np_components, char , nfsp2.np_compcountsizeof(char**), M_TEMP, M_WAITOK\|M_ZERO);
2091	if (!nfsp2.np_components) {
2092	error = ENOMEM;
2093	goto nfsmout;
2094	}
2095
2096	/ add link components /
2097	p = link;
2098	while (p && (p == `'/'`))
2099	p++;
2100	for (newcomp=`0`; newcomp < linkcompcount; newcomp++) {
2101	/ find end of component /
2102	q = p;
2103	while (q && (q != `'/'`))
2104	q++;
2105	MALLOC(nfsp2.np_components[newcomp], char *, q-p+`1`, M_TEMP, M_WAITOK\|M_ZERO);
2106	if (!nfsp2.np_components[newcomp]) {
2107	error = ENOMEM;
2108	break;
2109	}
2110	ch = *q;
2111	*q = `'\0'`;
2112	strlcpy(nfsp2.np_components[newcomp], p, q-p+`1`);
2113	*q = ch;
2114	p = q;
2115	while (p && (p == `'/'`))
2116	p++;
2117	}
2118	nfsmout_if(error);
2119
2120	/ add remaining components /
2121	for(comp = curcomp + `1`; comp < nfsp->np_compcount; comp++,newcomp++) {
2122	nfsp2.np_components[newcomp] = nfsp->np_components[comp];
2123	nfsp->np_components[comp] = NULL;
2124	}
2125
2126	/ move new path into place /
2127	FREE(nfsp->np_components, M_TEMP);
2128	nfsp->np_components = nfsp2.np_components;
2129	nfsp->np_compcount = nfsp2.np_compcount;
2130	nfsp2.np_components = NULL;
2131
2132	/ for absolute link, let the caller now that the next dirfh is root /
2133	if (link[`0`] == `'/'`) {
2134	dirfhp->fh_len = `0`;
2135	*depthp = `0`;
2136	}
2137	nfsmout:
2138	if (link)
2139	FREE_ZONE(link, MAXPATHLEN, M_NAMEI);
2140	if (nfsp2.np_components) {
2141	for (comp=`0`; comp < nfsp2.np_compcount; comp++)
2142	if (nfsp2.np_components[comp])
2143	FREE(nfsp2.np_components[comp], M_TEMP);
2144	FREE(nfsp2.np_components, M_TEMP);
2145	}
2146	nfsm_chain_cleanup(&nmreq);
2147	nfsm_chain_cleanup(&nmrep);
2148	return (error);
2149	}
2150
2151	/ Set up an NFSv4 mount /
2152	int
2153	nfs4_mount(
2154	struct nfsmount *nmp,
2155	vfs_context_t ctx,
2156	nfsnode_t *npp)
2157	{
2158	struct nfsm_chain nmreq, nmrep;
2159	int error = `0`, numops, status, interval, isdotdot, loopcnt = `0`, depth = `0`;
2160	struct nfs_fs_path fspath, *nfsp, fspath2;
2161	uint32_t bitmap[NFS_ATTR_BITMAP_LEN], comp, comp2;
2162	fhandle_t fh, dirfh;
2163	struct nfs_vattr nvattr;
2164	u_int64_t xid;
2165	struct nfsreq rq, *req = &rq;
2166	struct nfsreq_secinfo_args si;
2167	struct nfs_sec sec;
2168	struct nfs_fs_locations nfsls;
2169
2170	*npp = NULL;
2171	fh.fh_len = dirfh.fh_len = `0`;
2172	TAILQ_INIT(&nmp->nm_open_owners);
2173	TAILQ_INIT(&nmp->nm_delegations);
2174	TAILQ_INIT(&nmp->nm_dreturnq);
2175	nmp->nm_stategenid = `1`;
2176	NVATTR_INIT(&nvattr);
2177	bzero(&nfsls, sizeof(nfsls));
2178	nfsm_chain_null(&nmreq);
2179	nfsm_chain_null(&nmrep);
2180
2181	/*
2182	* If no security flavors were specified we'll want to default to the server's
2183	* preferred flavor. For NFSv4.0 we need a file handle and name to get that via
2184	* SECINFO, so we'll do that on the last component of the server path we are
2185	* mounting. If we are mounting the server's root, we'll need to defer the
2186	* SECINFO call to the first successful LOOKUP request.
2187	*/
2188	if (!nmp->nm_sec.count)
2189	nmp->nm_state \|= NFSSTA_NEEDSECINFO;
2190
2191	/ make a copy of the current location's path /
2192	nfsp = &nmp->nm_locations.nl_locations[nmp->nm_locations.nl_current.nli_loc]->nl_path;
2193	bzero(&fspath, sizeof(fspath));
2194	fspath.np_compcount = nfsp->np_compcount;
2195	if (fspath.np_compcount > `0`) {
2196	MALLOC(fspath.np_components, char , fspath.np_compcountsizeof(char**), M_TEMP, M_WAITOK\|M_ZERO);
2197	if (!fspath.np_components) {
2198	error = ENOMEM;
2199	goto nfsmout;
2200	}
2201	for (comp=`0`; comp < nfsp->np_compcount; comp++) {
2202	int slen = strlen(nfsp->np_components[comp]);
2203	MALLOC(fspath.np_components[comp], char *, slen+`1`, M_TEMP, M_WAITOK\|M_ZERO);
2204	if (!fspath.np_components[comp]) {
2205	error = ENOMEM;
2206	break;
2207	}
2208	strlcpy(fspath.np_components[comp], nfsp->np_components[comp], slen+`1`);
2209	}
2210	if (error)
2211	goto nfsmout;
2212	}
2213
2214	/ for mirror mounts, we can just use the file handle passed in /
2215	if (nmp->nm_fh) {
2216	dirfh.fh_len = nmp->nm_fh->fh_len;
2217	bcopy(nmp->nm_fh->fh_data, dirfh.fh_data, dirfh.fh_len);
2218	NFSREQ_SECINFO_SET(&si, NULL, dirfh.fh_data, dirfh.fh_len, NULL, `0`);
2219	goto gotfh;
2220	}
2221
2222	/ otherwise, we need to get the fh for the directory we are mounting /
2223
2224	/ if no components, just get root /
2225	if (fspath.np_compcount == `0`) {
2226	nocomponents:
2227	// PUTROOTFH + GETATTR(FH)
2228	NFSREQ_SECINFO_SET(&si, NULL, NULL, `0`, NULL, `0`);
2229	numops = `2`;
2230	nfsm_chain_build_alloc_init(error, &nmreq, `9` * NFSX_UNSIGNED);
2231	nfsm_chain_add_compound_header(error, &nmreq, "mount", nmp->nm_minor_vers, numops);
2232	numops--;
2233	nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTROOTFH);
2234	numops--;
2235	nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
2236	NFS_CLEAR_ATTRIBUTES(bitmap);
2237	NFS4_DEFAULT_ATTRIBUTES(bitmap);
2238	NFS_BITMAP_SET(bitmap, NFS_FATTR_FILEHANDLE);
2239	nfsm_chain_add_bitmap(error, &nmreq, bitmap, NFS_ATTR_BITMAP_LEN);
2240	nfsm_chain_build_done(error, &nmreq);
2241	nfsm_assert(error, (numops == `0`), EPROTO);
2242	nfsmout_if(error);
2243	error = nfs_request_async(NULL, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND,
2244	vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, `0`, NULL, &req);
2245	if (!error)
2246	error = nfs_request_async_finish(req, &nmrep, &xid, &status);
2247	nfsm_chain_skip_tag(error, &nmrep);
2248	nfsm_chain_get_32(error, &nmrep, numops);
2249	nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTROOTFH);
2250	nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
2251	nfsmout_if(error);
2252	NFS_CLEAR_ATTRIBUTES(nmp->nm_fsattr.nfsa_bitmap);
2253	error = nfs4_parsefattr(&nmrep, &nmp->nm_fsattr, &nvattr, &dirfh, NULL, NULL);
2254	if (!error && !NFS_BITMAP_ISSET(&nvattr.nva_bitmap, NFS_FATTR_FILEHANDLE)) {
2255	printf("nfs: mount didn't return filehandle?\n");
2256	error = EBADRPC;
2257	}
2258	nfsmout_if(error);
2259	nfsm_chain_cleanup(&nmrep);
2260	nfsm_chain_null(&nmreq);
2261	NVATTR_CLEANUP(&nvattr);
2262	goto gotfh;
2263	}
2264
2265	/ look up each path component /
2266	for (comp=`0`; comp < fspath.np_compcount; ) {
2267	isdotdot = `0`;
2268	if (fspath.np_components[comp][`0`] == `'.'`) {
2269	if (fspath.np_components[comp][`1`] == `'\0'`) {
2270	/ skip "." /
2271	comp++;
2272	continue;
2273	}
2274	/ treat ".." specially /
2275	if ((fspath.np_components[comp][`1`] == `'.'`) &&
2276	(fspath.np_components[comp][`2`] == `'\0'`))
2277	isdotdot = `1`;
2278	if (isdotdot && (dirfh.fh_len == `0`)) {
2279	/ ".." in root directory is same as "." /
2280	comp++;
2281	continue;
2282	}
2283	}
2284	// PUT(ROOT)FH + LOOKUP(P) + GETFH + GETATTR
2285	if (dirfh.fh_len == `0`)
2286	NFSREQ_SECINFO_SET(&si, NULL, NULL, `0`, isdotdot ? NULL : fspath.np_components[comp], `0`);
2287	else
2288	NFSREQ_SECINFO_SET(&si, NULL, dirfh.fh_data, dirfh.fh_len, isdotdot ? NULL : fspath.np_components[comp], `0`);
2289	numops = `4`;
2290	nfsm_chain_build_alloc_init(error, &nmreq, `18` * NFSX_UNSIGNED);
2291	nfsm_chain_add_compound_header(error, &nmreq, "mount", nmp->nm_minor_vers, numops);
2292	numops--;
2293	if (dirfh.fh_len) {
2294	nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
2295	nfsm_chain_add_fh(error, &nmreq, NFS_VER4, dirfh.fh_data, dirfh.fh_len);
2296	} else {
2297	nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTROOTFH);
2298	}
2299	numops--;
2300	if (isdotdot) {
2301	nfsm_chain_add_32(error, &nmreq, NFS_OP_LOOKUPP);
2302	} else {
2303	nfsm_chain_add_32(error, &nmreq, NFS_OP_LOOKUP);
2304	nfsm_chain_add_name(error, &nmreq,
2305	fspath.np_components[comp], strlen(fspath.np_components[comp]), nmp);
2306	}
2307	numops--;
2308	nfsm_chain_add_32(error, &nmreq, NFS_OP_GETFH);
2309	numops--;
2310	nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
2311	NFS_CLEAR_ATTRIBUTES(bitmap);
2312	NFS4_DEFAULT_ATTRIBUTES(bitmap);
2313	/ if no namedattr support or component is ".zfs", clear NFS_FATTR_NAMED_ATTR /
2314	if (!NMFLAG(nmp, NAMEDATTR) \|\| !strcmp(fspath.np_components[comp], ".zfs"))
2315	NFS_BITMAP_CLR(bitmap, NFS_FATTR_NAMED_ATTR);
2316	nfsm_chain_add_bitmap(error, &nmreq, bitmap, NFS_ATTR_BITMAP_LEN);
2317	nfsm_chain_build_done(error, &nmreq);
2318	nfsm_assert(error, (numops == `0`), EPROTO);
2319	nfsmout_if(error);
2320	error = nfs_request_async(NULL, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND,
2321	vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, `0`, NULL, &req);
2322	if (!error)
2323	error = nfs_request_async_finish(req, &nmrep, &xid, &status);
2324	nfsm_chain_skip_tag(error, &nmrep);
2325	nfsm_chain_get_32(error, &nmrep, numops);
2326	nfsm_chain_op_check(error, &nmrep, dirfh.fh_len ? NFS_OP_PUTFH : NFS_OP_PUTROOTFH);
2327	nfsm_chain_op_check(error, &nmrep, isdotdot ? NFS_OP_LOOKUPP : NFS_OP_LOOKUP);
2328	nfsmout_if(error);
2329	nfsm_chain_op_check(error, &nmrep, NFS_OP_GETFH);
2330	nfsm_chain_get_32(error, &nmrep, fh.fh_len);
2331	if (fh.fh_len > sizeof(fh.fh_data))
2332	error = EBADRPC;
2333	nfsmout_if(error);
2334	nfsm_chain_get_opaque(error, &nmrep, fh.fh_len, fh.fh_data);
2335	nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
2336	if (!error) {
2337	NFS_CLEAR_ATTRIBUTES(nmp->nm_fsattr.nfsa_bitmap);
2338	error = nfs4_parsefattr(&nmrep, &nmp->nm_fsattr, &nvattr, NULL, NULL, &nfsls);
2339	}
2340	nfsm_chain_cleanup(&nmrep);
2341	nfsm_chain_null(&nmreq);
2342	if (error) {
2343	/ LOOKUP succeeded but GETATTR failed? This could be a referral. /
2344	/ Try the lookup again with a getattr for fs_locations. /
2345	nfs_fs_locations_cleanup(&nfsls);
2346	error = nfs4_get_fs_locations(nmp, NULL, dirfh.fh_data, dirfh.fh_len, fspath.np_components[comp], ctx, &nfsls);
2347	if (!error && (nfsls.nl_numlocs < `1`))
2348	error = ENOENT;
2349	nfsmout_if(error);
2350	if (++loopcnt > MAXSYMLINKS) {
2351	/ too many symlink/referral redirections /
2352	error = ELOOP;
2353	goto nfsmout;
2354	}
2355	/ tear down the current connection /
2356	nfs_disconnect(nmp);
2357	/ replace fs locations /
2358	nfs_fs_locations_cleanup(&nmp->nm_locations);
2359	nmp->nm_locations = nfsls;
2360	bzero(&nfsls, sizeof(nfsls));
2361	/ initiate a connection using the new fs locations /
2362	error = nfs_mount_connect(nmp);
2363	if (!error && !(nmp->nm_locations.nl_current.nli_flags & NLI_VALID))
2364	error = EIO;
2365	nfsmout_if(error);
2366	/ add new server's remote path to beginning of our path and continue /
2367	nfsp = &nmp->nm_locations.nl_locations[nmp->nm_locations.nl_current.nli_loc]->nl_path;
2368	bzero(&fspath2, sizeof(fspath2));
2369	fspath2.np_compcount = (fspath.np_compcount - comp - `1`) + nfsp->np_compcount;
2370	if (fspath2.np_compcount > `0`) {
2371	MALLOC(fspath2.np_components, char , fspath2.np_compcountsizeof(char**), M_TEMP, M_WAITOK\|M_ZERO);
2372	if (!fspath2.np_components) {
2373	error = ENOMEM;
2374	goto nfsmout;
2375	}
2376	for (comp2=`0`; comp2 < nfsp->np_compcount; comp2++) {
2377	int slen = strlen(nfsp->np_components[comp2]);
2378	MALLOC(fspath2.np_components[comp2], char *, slen+`1`, M_TEMP, M_WAITOK\|M_ZERO);
2379	if (!fspath2.np_components[comp2]) {
2380	/ clean up fspath2, then error out /
2381	while (comp2 > `0`) {
2382	comp2--;
2383	FREE(fspath2.np_components[comp2], M_TEMP);
2384	}
2385	FREE(fspath2.np_components, M_TEMP);
2386	error = ENOMEM;
2387	goto nfsmout;
2388	}
2389	strlcpy(fspath2.np_components[comp2], nfsp->np_components[comp2], slen+`1`);
2390	}
2391	if ((fspath.np_compcount - comp - `1`) > `0`)
2392	bcopy(&fspath.np_components[comp+`1`], &fspath2.np_components[nfsp->np_compcount], (fspath.np_compcount - comp - `1`)*sizeof(char*));
2393	/ free up unused parts of old path (prior components and component array) /
2394	do {
2395	FREE(fspath.np_components[comp], M_TEMP);
2396	} while (comp-- > `0`);
2397	FREE(fspath.np_components, M_TEMP);
2398	/ put new path in place /
2399	fspath = fspath2;
2400	}
2401	/ reset dirfh and component index /
2402	dirfh.fh_len = `0`;
2403	comp = `0`;
2404	NVATTR_CLEANUP(&nvattr);
2405	if (fspath.np_compcount == `0`)
2406	goto nocomponents;
2407	continue;
2408	}
2409	nfsmout_if(error);
2410	/ if file handle is for a symlink, then update the path with the symlink contents /
2411	if (NFS_BITMAP_ISSET(&nvattr.nva_bitmap, NFS_FATTR_TYPE) && (nvattr.nva_type == VLNK)) {
2412	if (++loopcnt > MAXSYMLINKS)
2413	error = ELOOP;
2414	else
2415	error = nfs4_mount_update_path_with_symlink(nmp, &fspath, comp, &dirfh, &depth, &fh, ctx);
2416	nfsmout_if(error);
2417	/ directory file handle is either left the same or reset to root (if link was absolute) /
2418	/ path traversal starts at beginning of the path again /
2419	comp = `0`;
2420	NVATTR_CLEANUP(&nvattr);
2421	nfs_fs_locations_cleanup(&nfsls);
2422	continue;
2423	}
2424	NVATTR_CLEANUP(&nvattr);
2425	nfs_fs_locations_cleanup(&nfsls);
2426	/ not a symlink... /
2427	if ((nmp->nm_state & NFSSTA_NEEDSECINFO) && (comp == (fspath.np_compcount-`1`)) && !isdotdot) {
2428	/ need to get SECINFO for the directory being mounted /
2429	if (dirfh.fh_len == `0`)
2430	NFSREQ_SECINFO_SET(&si, NULL, NULL, `0`, isdotdot ? NULL : fspath.np_components[comp], `0`);
2431	else
2432	NFSREQ_SECINFO_SET(&si, NULL, dirfh.fh_data, dirfh.fh_len, isdotdot ? NULL : fspath.np_components[comp], `0`);
2433	sec.count = NX_MAX_SEC_FLAVORS;
2434	error = nfs4_secinfo_rpc(nmp, &si, vfs_context_ucred(ctx), sec.flavors, &sec.count);
2435	/ [sigh] some implementations return "illegal" error for unsupported ops /
2436	if (error == NFSERR_OP_ILLEGAL)
2437	error = `0`;
2438	nfsmout_if(error);
2439	/ set our default security flavor to the first in the list /
2440	if (sec.count)
2441	nmp->nm_auth = sec.flavors[`0`];
2442	nmp->nm_state &= ~NFSSTA_NEEDSECINFO;
2443	}
2444	/ advance directory file handle, component index, & update depth /
2445	dirfh = fh;
2446	comp++;
2447	if (!isdotdot) / going down the hierarchy /
2448	depth++;
2449	else if (--depth <= `0`) / going up the hierarchy /
2450	dirfh.fh_len = `0`; / clear dirfh when we hit root /
2451	}
2452
2453	gotfh:
2454	/ get attrs for mount point root /
2455	numops = NMFLAG(nmp, NAMEDATTR) ? `3` : `2`; // PUTFH + GETATTR + OPENATTR
2456	nfsm_chain_build_alloc_init(error, &nmreq, `25` * NFSX_UNSIGNED);
2457	nfsm_chain_add_compound_header(error, &nmreq, "mount", nmp->nm_minor_vers, numops);
2458	numops--;
2459	nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
2460	nfsm_chain_add_fh(error, &nmreq, NFS_VER4, dirfh.fh_data, dirfh.fh_len);
2461	numops--;
2462	nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
2463	NFS_CLEAR_ATTRIBUTES(bitmap);
2464	NFS4_DEFAULT_ATTRIBUTES(bitmap);
2465	/ if no namedattr support or last component is ".zfs", clear NFS_FATTR_NAMED_ATTR /
2466	if (!NMFLAG(nmp, NAMEDATTR) \|\| ((fspath.np_compcount > `0`) && !strcmp(fspath.np_components[fspath.np_compcount-`1`], ".zfs")))
2467	NFS_BITMAP_CLR(bitmap, NFS_FATTR_NAMED_ATTR);
2468	nfsm_chain_add_bitmap(error, &nmreq, bitmap, NFS_ATTR_BITMAP_LEN);
2469	if (NMFLAG(nmp, NAMEDATTR)) {
2470	numops--;
2471	nfsm_chain_add_32(error, &nmreq, NFS_OP_OPENATTR);
2472	nfsm_chain_add_32(error, &nmreq, `0`);
2473	}
2474	nfsm_chain_build_done(error, &nmreq);
2475	nfsm_assert(error, (numops == `0`), EPROTO);
2476	nfsmout_if(error);
2477	error = nfs_request_async(NULL, nmp->nm_mountp, &nmreq, NFSPROC4_COMPOUND,
2478	vfs_context_thread(ctx), vfs_context_ucred(ctx), &si, `0`, NULL, &req);
2479	if (!error)
2480	error = nfs_request_async_finish(req, &nmrep, &xid, &status);
2481	nfsm_chain_skip_tag(error, &nmrep);
2482	nfsm_chain_get_32(error, &nmrep, numops);
2483	nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
2484	nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
2485	nfsmout_if(error);
2486	NFS_CLEAR_ATTRIBUTES(nmp->nm_fsattr.nfsa_bitmap);
2487	error = nfs4_parsefattr(&nmrep, &nmp->nm_fsattr, &nvattr, NULL, NULL, NULL);
2488	nfsmout_if(error);
2489	if (NMFLAG(nmp, NAMEDATTR)) {
2490	nfsm_chain_op_check(error, &nmrep, NFS_OP_OPENATTR);
2491	if (error == ENOENT)
2492	error = `0`;
2493	/ [sigh] some implementations return "illegal" error for unsupported ops /
2494	if (error \|\| !NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_NAMED_ATTR)) {
2495	nmp->nm_fsattr.nfsa_flags &= ~NFS_FSFLAG_NAMED_ATTR;
2496	} else {
2497	nmp->nm_fsattr.nfsa_flags \|= NFS_FSFLAG_NAMED_ATTR;
2498	}
2499	} else {
2500	nmp->nm_fsattr.nfsa_flags &= ~NFS_FSFLAG_NAMED_ATTR;
2501	}
2502	if (NMFLAG(nmp, NOACL)) / make sure ACL support is turned off /
2503	nmp->nm_fsattr.nfsa_flags &= ~NFS_FSFLAG_ACL;
2504	if (NMFLAG(nmp, ACLONLY) && !(nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_ACL))
2505	NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_ACLONLY);
2506	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_FH_EXPIRE_TYPE)) {
2507	uint32_t fhtype = ((nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_FHTYPE_MASK) >> NFS_FSFLAG_FHTYPE_SHIFT);
2508	if (fhtype != NFS_FH_PERSISTENT)
2509	printf("nfs: warning: non-persistent file handles! for %s\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname);
2510	}
2511
2512	/ make sure it's a directory /
2513	if (!NFS_BITMAP_ISSET(&nvattr.nva_bitmap, NFS_FATTR_TYPE) \|\| (nvattr.nva_type != VDIR)) {
2514	error = ENOTDIR;
2515	goto nfsmout;
2516	}
2517
2518	/ save the NFS fsid /
2519	nmp->nm_fsid = nvattr.nva_fsid;
2520
2521	/ create the root node /
2522	error = nfs_nget(nmp->nm_mountp, NULL, NULL, dirfh.fh_data, dirfh.fh_len, &nvattr, &xid, rq.r_auth, NG_MARKROOT, npp);
2523	nfsmout_if(error);
2524
2525	if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_ACL)
2526	vfs_setextendedsecurity(nmp->nm_mountp);
2527
2528	/ adjust I/O sizes to server limits /
2529	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXREAD) && (nmp->nm_fsattr.nfsa_maxread > `0`)) {
2530	if (nmp->nm_fsattr.nfsa_maxread < (uint64_t)nmp->nm_rsize) {
2531	nmp->nm_rsize = nmp->nm_fsattr.nfsa_maxread & ~(NFS_FABLKSIZE - `1`);
2532	if (nmp->nm_rsize == `0`)
2533	nmp->nm_rsize = nmp->nm_fsattr.nfsa_maxread;
2534	}
2535	}
2536	if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXWRITE) && (nmp->nm_fsattr.nfsa_maxwrite > `0`)) {
2537	if (nmp->nm_fsattr.nfsa_maxwrite < (uint64_t)nmp->nm_wsize) {
2538	nmp->nm_wsize = nmp->nm_fsattr.nfsa_maxwrite & ~(NFS_FABLKSIZE - `1`);
2539	if (nmp->nm_wsize == `0`)
2540	nmp->nm_wsize = nmp->nm_fsattr.nfsa_maxwrite;
2541	}
2542	}
2543
2544	/ set up lease renew timer /
2545	nmp->nm_renew_timer = thread_call_allocate(nfs4_renew_timer, nmp);
2546	interval = nmp->nm_fsattr.nfsa_lease / `2`;
2547	if (interval < `1`)
2548	interval = `1`;
2549	nfs_interval_timer_start(nmp->nm_renew_timer, interval * `1000`);
2550
2551	nfsmout:
2552	if (fspath.np_components) {
2553	for (comp=`0`; comp < fspath.np_compcount; comp++)
2554	if (fspath.np_components[comp])
2555	FREE(fspath.np_components[comp], M_TEMP);
2556	FREE(fspath.np_components, M_TEMP);
2557	}
2558	NVATTR_CLEANUP(&nvattr);
2559	nfs_fs_locations_cleanup(&nfsls);
2560	if (*npp)
2561	nfs_node_unlock(*npp);
2562	nfsm_chain_cleanup(&nmreq);
2563	nfsm_chain_cleanup(&nmrep);
2564	return (error);
2565	}
2566
2567	/*
2568	* Thread to handle initial NFS mount connection.
2569	*/
2570	void
2571	nfs_mount_connect_thread(void *arg, __unused wait_result_t wr)
2572	{
2573	struct nfsmount *nmp = arg;
2574	int error = `0`, savederror = `0`, slpflag = (NMFLAG(nmp, INTR) ? PCATCH : `0`);
2575	int done = `0`, timeo, tries, maxtries;
2576
2577	if (NM_OMFLAG(nmp, MNTQUICK)) {
2578	timeo = `8`;
2579	maxtries = `1`;
2580	} else {
2581	timeo = `30`;
2582	maxtries = `2`;
2583	}
2584
2585	for (tries = `0`; tries < maxtries; tries++) {
2586	error = nfs_connect(nmp, `1`, timeo);
2587	switch (error) {
2588	case ETIMEDOUT:
2589	case EAGAIN:
2590	case EPIPE:
2591	case EADDRNOTAVAIL:
2592	case ENETDOWN:
2593	case ENETUNREACH:
2594	case ENETRESET:
2595	case ECONNABORTED:
2596	case ECONNRESET:
2597	case EISCONN:
2598	case ENOTCONN:
2599	case ESHUTDOWN:
2600	case ECONNREFUSED:
2601	case EHOSTDOWN:
2602	case EHOSTUNREACH:
2603	/ just keep retrying on any of these errors /
2604	break;
2605	case `0`:
2606	default:
2607	/ looks like we got an answer... /
2608	done = `1`;
2609	break;
2610	}
2611
2612	/ save the best error /
2613	if (nfs_connect_error_class(error) >= nfs_connect_error_class(savederror))
2614	savederror = error;
2615	if (done) {
2616	error = savederror;
2617	break;
2618	}
2619
2620	/ pause before next attempt /
2621	if ((error = nfs_sigintr(nmp, NULL, current_thread(), `0`)))
2622	break;
2623	error = tsleep(nmp, PSOCK\|slpflag, "nfs_mount_connect_retry", `2`*hz);
2624	if (error && (error != EWOULDBLOCK))
2625	break;
2626	error = savederror;
2627	}
2628
2629	/ update status of mount connect /
2630	lck_mtx_lock(&nmp->nm_lock);
2631	if (!nmp->nm_mounterror)
2632	nmp->nm_mounterror = error;
2633	nmp->nm_state &= ~NFSSTA_MOUNT_THREAD;
2634	lck_mtx_unlock(&nmp->nm_lock);
2635	wakeup(&nmp->nm_nss);
2636	}
2637
2638	int
2639	nfs_mount_connect(struct nfsmount *nmp)
2640	{
2641	int error = `0`, slpflag;
2642	thread_t thd;
2643	struct timespec ts = { `2`, `0` };
2644
2645	/*
2646	* Set up the socket. Perform initial search for a location/server/address to
2647	* connect to and negotiate any unspecified mount parameters. This work is
2648	* done on a kernel thread to satisfy reserved port usage needs.
2649	*/
2650	slpflag = NMFLAG(nmp, INTR) ? PCATCH : `0`;
2651	lck_mtx_lock(&nmp->nm_lock);
2652	/ set flag that the thread is running /
2653	nmp->nm_state \|= NFSSTA_MOUNT_THREAD;
2654	if (kernel_thread_start(nfs_mount_connect_thread, nmp, &thd) != KERN_SUCCESS) {
2655	nmp->nm_state &= ~NFSSTA_MOUNT_THREAD;
2656	nmp->nm_mounterror = EIO;
2657	printf("nfs mount %s start socket connect thread failed\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname);
2658	} else {
2659	thread_deallocate(thd);
2660	}
2661
2662	/ wait until mount connect thread is finished/gone /
2663	while (nmp->nm_state & NFSSTA_MOUNT_THREAD) {
2664	error = msleep(&nmp->nm_nss, &nmp->nm_lock, slpflag\|PSOCK, "nfsconnectthread", &ts);
2665	if ((error && (error != EWOULDBLOCK)) \|\| ((error = nfs_sigintr(nmp, NULL, current_thread(), `1`)))) {
2666	/ record error /
2667	if (!nmp->nm_mounterror)
2668	nmp->nm_mounterror = error;
2669	/ signal the thread that we are aborting /
2670	nmp->nm_sockflags \|= NMSOCK_UNMOUNT;
2671	if (nmp->nm_nss)
2672	wakeup(nmp->nm_nss);
2673	/ and continue waiting on it to finish /
2674	slpflag = `0`;
2675	}
2676	}
2677	lck_mtx_unlock(&nmp->nm_lock);
2678
2679	/ grab mount connect status /
2680	error = nmp->nm_mounterror;
2681
2682	return (error);
2683	}
2684
2685	/ Table of maximum minor version for a given version /
2686	uint32_t maxminorverstab[] = {
2687	`0`, / Version 0 (does not exist) /
2688	`0`, / Version 1 (does not exist) /
2689	`0`, / Version 2 /
2690	`0`, / Version 3 /
2691	`0`, / Version 4 /
2692	};
2693
2694	#define NFS_MAX_SUPPORTED_VERSION ((long)(sizeof (maxminorverstab) / sizeof (uint32_t) - 1))
2695	#define NFS_MAX_SUPPORTED_MINOR_VERSION(v) ((long)(maxminorverstab[(v)]))
2696
2697	#define DEFAULT_NFS_MIN_VERS VER2PVER(2, 0)
2698	#define DEFAULT_NFS_MAX_VERS VER2PVER(3, 0)
2699
2700	/*
2701	* Common code to mount an NFS file system.
2702	*/
2703	int
2704	mountnfs(
2705	char *xdrbuf,
2706	mount_t mp,
2707	vfs_context_t ctx,
2708	vnode_t *vpp)
2709	{
2710	struct nfsmount *nmp;
2711	nfsnode_t np;
2712	int error = `0`;
2713	struct vfsstatfs *sbp;
2714	struct xdrbuf xb;
2715	uint32_t i, val, maxio, iosize, len;
2716	uint32_t *mattrs;
2717	uint32_t *mflags_mask;
2718	uint32_t *mflags;
2719	uint32_t argslength, attrslength;
2720	struct nfs_location_index firstloc = { NLI_VALID, `0`, `0`, `0` };
2721	static const struct nfs_etype nfs_default_etypes = {
2722	.count = NFS_MAX_ETYPES,
2723	.selected = NFS_MAX_ETYPES,
2724	.etypes = { NFS_AES256_CTS_HMAC_SHA1_96,
2725	NFS_AES128_CTS_HMAC_SHA1_96,
2726	NFS_DES3_CBC_SHA1_KD
2727	}
2728	};
2729	/ make sure mbuf constants are set up /
2730	if (!nfs_mbuf_mhlen)
2731	nfs_mbuf_init();
2732
2733	if (vfs_flags(mp) & MNT_UPDATE) {
2734	nmp = VFSTONFS(mp);
2735	/ update paths, file handles, etc, here XXX /
2736	xb_free(xdrbuf);
2737	return (`0`);
2738	} else {
2739	/ allocate an NFS mount structure for this mount /
2740	MALLOC_ZONE(nmp, struct nfsmount *,
2741	sizeof (struct nfsmount), M_NFSMNT, M_WAITOK);
2742	if (!nmp) {
2743	xb_free(xdrbuf);
2744	return (ENOMEM);
2745	}
2746	bzero((caddr_t)nmp, sizeof (struct nfsmount));
2747	lck_mtx_init(&nmp->nm_lock, nfs_mount_grp, LCK_ATTR_NULL);
2748	TAILQ_INIT(&nmp->nm_resendq);
2749	TAILQ_INIT(&nmp->nm_iodq);
2750	TAILQ_INIT(&nmp->nm_gsscl);
2751	LIST_INIT(&nmp->nm_monlist);
2752	vfs_setfsprivate(mp, nmp);
2753	vfs_getnewfsid(mp);
2754	nmp->nm_mountp = mp;
2755	vfs_setauthopaque(mp);
2756	/*
2757	* Disable cache_lookup_path for NFS. NFS lookup always needs
2758	* to be called to check if the directory attribute cache is
2759	* valid and possibly purge the directory before calling
2760	* cache_lookup.
2761	*/
2762	vfs_setauthcache_ttl(mp, `0`);
2763
2764	nfs_nhinit_finish();
2765
2766	nmp->nm_args = xdrbuf;
2767
2768	/ set up defaults /
2769	nmp->nm_ref = `0`;
2770	nmp->nm_vers = `0`;
2771	nmp->nm_min_vers = DEFAULT_NFS_MIN_VERS;
2772	nmp->nm_max_vers = DEFAULT_NFS_MAX_VERS;
2773	nmp->nm_timeo = NFS_TIMEO;
2774	nmp->nm_retry = NFS_RETRANS;
2775	nmp->nm_sotype = `0`;
2776	nmp->nm_sofamily = `0`;
2777	nmp->nm_nfsport = `0`;
2778	nmp->nm_wsize = NFS_WSIZE;
2779	nmp->nm_rsize = NFS_RSIZE;
2780	nmp->nm_readdirsize = NFS_READDIRSIZE;
2781	nmp->nm_numgrps = NFS_MAXGRPS;
2782	nmp->nm_readahead = NFS_DEFRAHEAD;
2783	nmp->nm_tprintf_delay = nfs_tprintf_delay;
2784	if (nmp->nm_tprintf_delay < `0`)
2785	nmp->nm_tprintf_delay = `0`;
2786	nmp->nm_tprintf_initial_delay = nfs_tprintf_initial_delay;
2787	if (nmp->nm_tprintf_initial_delay < `0`)
2788	nmp->nm_tprintf_initial_delay = `0`;
2789	nmp->nm_acregmin = NFS_MINATTRTIMO;
2790	nmp->nm_acregmax = NFS_MAXATTRTIMO;
2791	nmp->nm_acdirmin = NFS_MINDIRATTRTIMO;
2792	nmp->nm_acdirmax = NFS_MAXDIRATTRTIMO;
2793	nmp->nm_etype = nfs_default_etypes;
2794	nmp->nm_auth = RPCAUTH_SYS;
2795	nmp->nm_iodlink.tqe_next = NFSNOLIST;
2796	nmp->nm_deadtimeout = `0`;
2797	nmp->nm_curdeadtimeout = `0`;
2798	NFS_BITMAP_SET(nmp->nm_flags, NFS_MFLAG_NOACL);
2799	nmp->nm_realm = NULL;
2800	nmp->nm_principal = NULL;
2801	nmp->nm_sprinc = NULL;
2802	}
2803
2804	mattrs = nmp->nm_mattrs;
2805	mflags = nmp->nm_mflags;
2806	mflags_mask = nmp->nm_mflags_mask;
2807
2808	/ set up NFS mount with args /
2809	xb_init_buffer(&xb, xdrbuf, `2`*XDRWORD);
2810	xb_get_32(error, &xb, val); / version /
2811	xb_get_32(error, &xb, argslength); / args length /
2812	nfsmerr_if(error);
2813	xb_init_buffer(&xb, xdrbuf, argslength); / restart parsing with actual buffer length /
2814	xb_get_32(error, &xb, val); / version /
2815	xb_get_32(error, &xb, argslength); / args length /
2816	xb_get_32(error, &xb, val); / XDR args version /
2817	if (val != NFS_XDRARGS_VERSION_0 \|\| argslength < ((`4` + NFS_MATTR_BITMAP_LEN + `1`) * XDRWORD)) {
2818	error = EINVAL;
2819	}
2820	len = NFS_MATTR_BITMAP_LEN;
2821	xb_get_bitmap(error, &xb, mattrs, len); / mount attribute bitmap /
2822	attrslength = `0`;
2823	xb_get_32(error, &xb, attrslength); / attrs length /
2824	if (!error && (attrslength > (argslength - ((`4`+NFS_MATTR_BITMAP_LEN+`1`)*XDRWORD))))
2825	error = EINVAL;
2826	nfsmerr_if(error);
2827	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FLAGS)) {
2828	len = NFS_MFLAG_BITMAP_LEN;
2829	xb_get_bitmap(error, &xb, mflags_mask, len); / mount flag mask /
2830	len = NFS_MFLAG_BITMAP_LEN;
2831	xb_get_bitmap(error, &xb, mflags, len); / mount flag values /
2832	if (!error) {
2833	/ clear all mask bits and OR in all the ones that are set /
2834	nmp->nm_flags[`0`] &= ~mflags_mask[`0`];
2835	nmp->nm_flags[`0`] \|= (mflags_mask[`0`] & mflags[`0`]);
2836	}
2837	}
2838	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION)) {
2839	/ Can't specify a single version and a range /
2840	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION_RANGE))
2841	error = EINVAL;
2842	xb_get_32(error, &xb, nmp->nm_vers);
2843	if (nmp->nm_vers > NFS_MAX_SUPPORTED_VERSION \|\|
2844	nmp->nm_vers < NFS_VER2)
2845	error = EINVAL;
2846	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_MINOR_VERSION))
2847	xb_get_32(error, &xb, nmp->nm_minor_vers);
2848	else
2849	nmp->nm_minor_vers = maxminorverstab[nmp->nm_vers];
2850	if (nmp->nm_minor_vers > maxminorverstab[nmp->nm_vers])
2851	error = EINVAL;
2852	nmp->nm_max_vers = nmp->nm_min_vers =
2853	VER2PVER(nmp->nm_vers, nmp->nm_minor_vers);
2854	}
2855	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_MINOR_VERSION)) {
2856	/ should have also gotten NFS version (and already gotten minor version) /
2857	if (!NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION))
2858	error = EINVAL;
2859	}
2860	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION_RANGE)) {
2861	xb_get_32(error, &xb, nmp->nm_min_vers);
2862	xb_get_32(error, &xb, nmp->nm_max_vers);
2863	if ((nmp->nm_min_vers > nmp->nm_max_vers) \|\|
2864	(PVER2MAJOR(nmp->nm_max_vers) > NFS_MAX_SUPPORTED_VERSION) \|\|
2865	(PVER2MINOR(nmp->nm_min_vers) > maxminorverstab[PVER2MAJOR(nmp->nm_min_vers)]) \|\|
2866	(PVER2MINOR(nmp->nm_max_vers) > maxminorverstab[PVER2MAJOR(nmp->nm_max_vers)]))
2867	error = EINVAL;
2868	}
2869	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE))
2870	xb_get_32(error, &xb, nmp->nm_rsize);
2871	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE))
2872	xb_get_32(error, &xb, nmp->nm_wsize);
2873	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READDIR_SIZE))
2874	xb_get_32(error, &xb, nmp->nm_readdirsize);
2875	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READAHEAD))
2876	xb_get_32(error, &xb, nmp->nm_readahead);
2877	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_REG_MIN)) {
2878	xb_get_32(error, &xb, nmp->nm_acregmin);
2879	xb_skip(error, &xb, XDRWORD);
2880	}
2881	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_REG_MAX)) {
2882	xb_get_32(error, &xb, nmp->nm_acregmax);
2883	xb_skip(error, &xb, XDRWORD);
2884	}
2885	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MIN)) {
2886	xb_get_32(error, &xb, nmp->nm_acdirmin);
2887	xb_skip(error, &xb, XDRWORD);
2888	}
2889	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MAX)) {
2890	xb_get_32(error, &xb, nmp->nm_acdirmax);
2891	xb_skip(error, &xb, XDRWORD);
2892	}
2893	nfsmerr_if(error);
2894	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCK_MODE)) {
2895	xb_get_32(error, &xb, val);
2896	switch (val) {
2897	case NFS_LOCK_MODE_DISABLED:
2898	case NFS_LOCK_MODE_LOCAL:
2899	if (nmp->nm_vers >= NFS_VER4) {
2900	/ disabled/local lock mode only allowed on v2/v3 /
2901	error = EINVAL;
2902	break;
2903	}
2904	/ FALLTHROUGH /
2905	case NFS_LOCK_MODE_ENABLED:
2906	nmp->nm_lockmode = val;
2907	break;
2908	default:
2909	error = EINVAL;
2910	}
2911	}
2912	nfsmerr_if(error);
2913	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SECURITY)) {
2914	uint32_t seccnt;
2915	xb_get_32(error, &xb, seccnt);
2916	if (!error && ((seccnt < `1`) \|\| (seccnt > NX_MAX_SEC_FLAVORS)))
2917	error = EINVAL;
2918	nfsmerr_if(error);
2919	nmp->nm_sec.count = seccnt;
2920	for (i=`0`; i < seccnt; i++) {
2921	xb_get_32(error, &xb, nmp->nm_sec.flavors[i]);
2922	/ Check for valid security flavor /
2923	switch (nmp->nm_sec.flavors[i]) {
2924	case RPCAUTH_NONE:
2925	case RPCAUTH_SYS:
2926	case RPCAUTH_KRB5:
2927	case RPCAUTH_KRB5I:
2928	case RPCAUTH_KRB5P:
2929	break;
2930	default:
2931	error = EINVAL;
2932	}
2933	}
2934	/ start with the first flavor /
2935	nmp->nm_auth = nmp->nm_sec.flavors[`0`];
2936	}
2937	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_KERB_ETYPE)) {
2938	uint32_t etypecnt;
2939	xb_get_32(error, &xb, etypecnt);
2940	if (!error && ((etypecnt < `1`) \|\| (etypecnt > NFS_MAX_ETYPES)))
2941	error = EINVAL;
2942	nfsmerr_if(error);
2943	nmp->nm_etype.count = etypecnt;
2944	xb_get_32(error, &xb, nmp->nm_etype.selected);
2945	nfsmerr_if(error);
2946	if (etypecnt) {
2947	nmp->nm_etype.selected = etypecnt; / Nothing is selected yet, so set selected to count /
2948	for (i=`0`; i < etypecnt; i++) {
2949	xb_get_32(error, &xb, nmp->nm_etype.etypes[i]);
2950	/ Check for valid encryption type /
2951	switch (nmp->nm_etype.etypes[i]) {
2952	case NFS_DES3_CBC_SHA1_KD:
2953	case NFS_AES128_CTS_HMAC_SHA1_96:
2954	case NFS_AES256_CTS_HMAC_SHA1_96:
2955	break;
2956	default:
2957	error = EINVAL;
2958	}
2959	}
2960	}
2961	}
2962	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MAX_GROUP_LIST))
2963	xb_get_32(error, &xb, nmp->nm_numgrps);
2964	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOCKET_TYPE)) {
2965	char sotype[`6`];
2966
2967	xb_get_32(error, &xb, val);
2968	if (!error && ((val < `3`) \|\| (val > `5`)))
2969	error = EINVAL;
2970	nfsmerr_if(error);
2971	error = xb_get_bytes(&xb, sotype, val, `0`);
2972	nfsmerr_if(error);
2973	sotype[val] = `'\0'`;
2974	if (!strcmp(sotype, "tcp")) {
2975	nmp->nm_sotype = SOCK_STREAM;
2976	} else if (!strcmp(sotype, "udp")) {
2977	nmp->nm_sotype = SOCK_DGRAM;
2978	} else if (!strcmp(sotype, "tcp4")) {
2979	nmp->nm_sotype = SOCK_STREAM;
2980	nmp->nm_sofamily = AF_INET;
2981	} else if (!strcmp(sotype, "udp4")) {
2982	nmp->nm_sotype = SOCK_DGRAM;
2983	nmp->nm_sofamily = AF_INET;
2984	} else if (!strcmp(sotype, "tcp6")) {
2985	nmp->nm_sotype = SOCK_STREAM;
2986	nmp->nm_sofamily = AF_INET6;
2987	} else if (!strcmp(sotype, "udp6")) {
2988	nmp->nm_sotype = SOCK_DGRAM;
2989	nmp->nm_sofamily = AF_INET6;
2990	} else if (!strcmp(sotype, "inet4")) {
2991	nmp->nm_sofamily = AF_INET;
2992	} else if (!strcmp(sotype, "inet6")) {
2993	nmp->nm_sofamily = AF_INET6;
2994	} else if (!strcmp(sotype, "inet")) {
2995	nmp->nm_sofamily = `0`; / ok /
2996	} else {
2997	error = EINVAL;
2998	}
2999	if (!error && (nmp->nm_vers >= NFS_VER4) && nmp->nm_sotype &&
3000	(nmp->nm_sotype != SOCK_STREAM))
3001	error = EINVAL; / NFSv4 is only allowed over TCP. /
3002	nfsmerr_if(error);
3003	}
3004	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_PORT))
3005	xb_get_32(error, &xb, nmp->nm_nfsport);
3006	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MOUNT_PORT))
3007	xb_get_32(error, &xb, nmp->nm_mountport);
3008	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_REQUEST_TIMEOUT)) {
3009	/ convert from time to 0.1s units /
3010	xb_get_32(error, &xb, nmp->nm_timeo);
3011	xb_get_32(error, &xb, val);
3012	nfsmerr_if(error);
3013	if (val >= `1000000000`)
3014	error = EINVAL;
3015	nfsmerr_if(error);
3016	nmp->nm_timeo *= `10`;
3017	nmp->nm_timeo += (val+`100000000`-`1`)/`100000000`;
3018	/ now convert to ticks /
3019	nmp->nm_timeo = (nmp->nm_timeo * NFS_HZ + `5`) / `10`;
3020	}
3021	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT)) {
3022	xb_get_32(error, &xb, val);
3023	if (!error && (val > `1`))
3024	nmp->nm_retry = val;
3025	}
3026	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_DEAD_TIMEOUT)) {
3027	xb_get_32(error, &xb, nmp->nm_deadtimeout);
3028	xb_skip(error, &xb, XDRWORD);
3029	}
3030	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FH)) {
3031	nfsmerr_if(error);
3032	MALLOC(nmp->nm_fh, fhandle_t , sizeof*(fhandle_t), M_TEMP, M_WAITOK\|M_ZERO);
3033	if (!nmp->nm_fh)
3034	error = ENOMEM;
3035	xb_get_32(error, &xb, nmp->nm_fh->fh_len);
3036	nfsmerr_if(error);
3037	if ((size_t)nmp->nm_fh->fh_len > sizeof(nmp->nm_fh->fh_data))
3038	error = EINVAL;
3039	else
3040	error = xb_get_bytes(&xb, (char*)&nmp->nm_fh->fh_data[`0`], nmp->nm_fh->fh_len, `0`);
3041	}
3042	nfsmerr_if(error);
3043	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FS_LOCATIONS)) {
3044	uint32_t loc, serv, addr, comp;
3045	struct nfs_fs_location *fsl;
3046	struct nfs_fs_server *fss;
3047	struct nfs_fs_path *fsp;
3048
3049	xb_get_32(error, &xb, nmp->nm_locations.nl_numlocs); / fs location count /
3050	/ sanity check location count /
3051	if (!error && ((nmp->nm_locations.nl_numlocs < `1`) \|\| (nmp->nm_locations.nl_numlocs > `256`)))
3052	error = EINVAL;
3053	nfsmerr_if(error);
3054	MALLOC(nmp->nm_locations.nl_locations, struct nfs_fs_location *, nmp->nm_locations.nl_numlocs sizeof(struct nfs_fs_location*), M_TEMP, M_WAITOK\|M_ZERO);
3055	if (!nmp->nm_locations.nl_locations)
3056	error = ENOMEM;
3057	for (loc = `0`; loc < nmp->nm_locations.nl_numlocs; loc++) {
3058	nfsmerr_if(error);
3059	MALLOC(fsl, struct nfs_fs_location , sizeof(struct* nfs_fs_location), M_TEMP, M_WAITOK\|M_ZERO);
3060	if (!fsl)
3061	error = ENOMEM;
3062	nmp->nm_locations.nl_locations[loc] = fsl;
3063	xb_get_32(error, &xb, fsl->nl_servcount); / server count /
3064	/ sanity check server count /
3065	if (!error && ((fsl->nl_servcount < `1`) \|\| (fsl->nl_servcount > `256`)))
3066	error = EINVAL;
3067	nfsmerr_if(error);
3068	MALLOC(fsl->nl_servers, struct nfs_fs_server *, fsl->nl_servcount sizeof(struct nfs_fs_server*), M_TEMP, M_WAITOK\|M_ZERO);
3069	if (!fsl->nl_servers)
3070	error = ENOMEM;
3071	for (serv = `0`; serv < fsl->nl_servcount; serv++) {
3072	nfsmerr_if(error);
3073	MALLOC(fss, struct nfs_fs_server , sizeof(struct* nfs_fs_server), M_TEMP, M_WAITOK\|M_ZERO);
3074	if (!fss)
3075	error = ENOMEM;
3076	fsl->nl_servers[serv] = fss;
3077	xb_get_32(error, &xb, val); / server name length /
3078	/ sanity check server name length /
3079	if (!error && ((val < `1`) \|\| (val > MAXPATHLEN)))
3080	error = EINVAL;
3081	nfsmerr_if(error);
3082	MALLOC(fss->ns_name, char *, val+`1`, M_TEMP, M_WAITOK\|M_ZERO);
3083	if (!fss->ns_name)
3084	error = ENOMEM;
3085	nfsmerr_if(error);
3086	error = xb_get_bytes(&xb, fss->ns_name, val, `0`); / server name /
3087	xb_get_32(error, &xb, fss->ns_addrcount); / address count /
3088	/ sanity check address count (OK to be zero) /
3089	if (!error && (fss->ns_addrcount > `256`))
3090	error = EINVAL;
3091	nfsmerr_if(error);
3092	if (fss->ns_addrcount > `0`) {
3093	MALLOC(fss->ns_addresses, char *, fss->ns_addrcount sizeof(char *), M_TEMP, M_WAITOK\|M_ZERO);
3094	if (!fss->ns_addresses)
3095	error = ENOMEM;
3096	for (addr = `0`; addr < fss->ns_addrcount; addr++) {
3097	xb_get_32(error, &xb, val); / address length /
3098	/ sanity check address length /
3099	if (!error && ((val < `1`) \|\| (val > `128`)))
3100	error = EINVAL;
3101	nfsmerr_if(error);
3102	MALLOC(fss->ns_addresses[addr], char *, val+`1`, M_TEMP, M_WAITOK\|M_ZERO);
3103	if (!fss->ns_addresses[addr])
3104	error = ENOMEM;
3105	nfsmerr_if(error);
3106	error = xb_get_bytes(&xb, fss->ns_addresses[addr], val, `0`); / address /
3107	}
3108	}
3109	xb_get_32(error, &xb, val); / server info length /
3110	xb_skip(error, &xb, val); / skip server info /
3111	}
3112	/ get pathname /
3113	fsp = &fsl->nl_path;
3114	xb_get_32(error, &xb, fsp->np_compcount); / component count /
3115	/ sanity check component count /
3116	if (!error && (fsp->np_compcount > MAXPATHLEN))
3117	error = EINVAL;
3118	nfsmerr_if(error);
3119	if (fsp->np_compcount) {
3120	MALLOC(fsp->np_components, char *, fsp->np_compcount sizeof(char*), M_TEMP, M_WAITOK\|M_ZERO);
3121	if (!fsp->np_components)
3122	error = ENOMEM;
3123	}
3124	for (comp = `0`; comp < fsp->np_compcount; comp++) {
3125	xb_get_32(error, &xb, val); / component length /
3126	/ sanity check component length /
3127	if (!error && (val == `0`)) {
3128	/*
3129	* Apparently some people think a path with zero components should
3130	* be encoded with one zero-length component. So, just ignore any
3131	* zero length components.
3132	*/
3133	comp--;
3134	fsp->np_compcount--;
3135	if (fsp->np_compcount == `0`) {
3136	FREE(fsp->np_components, M_TEMP);
3137	fsp->np_components = NULL;
3138	}
3139	continue;
3140	}
3141	if (!error && ((val < `1`) \|\| (val > MAXPATHLEN)))
3142	error = EINVAL;
3143	nfsmerr_if(error);
3144	MALLOC(fsp->np_components[comp], char *, val+`1`, M_TEMP, M_WAITOK\|M_ZERO);
3145	if (!fsp->np_components[comp])
3146	error = ENOMEM;
3147	nfsmerr_if(error);
3148	error = xb_get_bytes(&xb, fsp->np_components[comp], val, `0`); / component /
3149	}
3150	xb_get_32(error, &xb, val); / fs location info length /
3151	xb_skip(error, &xb, val); / skip fs location info /
3152	}
3153	}
3154	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFLAGS))
3155	xb_skip(error, &xb, XDRWORD);
3156	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFROM)) {
3157	xb_get_32(error, &xb, len);
3158	nfsmerr_if(error);
3159	val = len;
3160	if (val >= sizeof(vfs_statfs(mp)->f_mntfromname))
3161	val = sizeof(vfs_statfs(mp)->f_mntfromname) - `1`;
3162	error = xb_get_bytes(&xb, vfs_statfs(mp)->f_mntfromname, val, `0`);
3163	if ((len - val) > `0`)
3164	xb_skip(error, &xb, len - val);
3165	nfsmerr_if(error);
3166	vfs_statfs(mp)->f_mntfromname[val] = `'\0'`;
3167	}
3168	nfsmerr_if(error);
3169
3170	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_REALM)) {
3171	xb_get_32(error, &xb, len);
3172	if (!error && ((len < `1`) \|\| (len > MAXPATHLEN)))
3173	error=EINVAL;
3174	nfsmerr_if(error);
3175	/ allocate an extra byte for a leading '@' if its not already prepended to the realm /
3176	MALLOC(nmp->nm_realm, char *, len+`2`, M_TEMP, M_WAITOK\|M_ZERO);
3177	if (!nmp->nm_realm)
3178	error = ENOMEM;
3179	nfsmerr_if(error);
3180	error = xb_get_bytes(&xb, nmp->nm_realm, len, `0`);
3181	if (error == `0` && *nmp->nm_realm != `'@'`) {
3182	bcopy(nmp->nm_realm, &nmp->nm_realm[`1`], len);
3183	nmp->nm_realm[`0`] = `'@'`;
3184	}
3185	}
3186	nfsmerr_if(error);
3187
3188	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_PRINCIPAL)) {
3189	xb_get_32(error, &xb, len);
3190	if (!error && ((len < `1`) \|\| (len > MAXPATHLEN)))
3191	error=EINVAL;
3192	nfsmerr_if(error);
3193	MALLOC(nmp->nm_principal, char *, len+`1`, M_TEMP, M_WAITOK\|M_ZERO);
3194	if (!nmp->nm_principal)
3195	error = ENOMEM;
3196	nfsmerr_if(error);
3197	error = xb_get_bytes(&xb, nmp->nm_principal, len, `0`);
3198	}
3199	nfsmerr_if(error);
3200
3201	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SVCPRINCIPAL)) {
3202	xb_get_32(error, &xb, len);
3203	if (!error && ((len < `1`) \|\| (len > MAXPATHLEN)))
3204	error=EINVAL;
3205	nfsmerr_if(error);
3206	MALLOC(nmp->nm_sprinc, char *, len+`1`, M_TEMP, M_WAITOK\|M_ZERO);
3207	if (!nmp->nm_sprinc)
3208	error = ENOMEM;
3209	nfsmerr_if(error);
3210	error = xb_get_bytes(&xb, nmp->nm_sprinc, len, `0`);
3211	}
3212	nfsmerr_if(error);
3213
3214	/*
3215	* Sanity check/finalize settings.
3216	*/
3217
3218	if (nmp->nm_timeo < NFS_MINTIMEO)
3219	nmp->nm_timeo = NFS_MINTIMEO;
3220	else if (nmp->nm_timeo > NFS_MAXTIMEO)
3221	nmp->nm_timeo = NFS_MAXTIMEO;
3222	if (nmp->nm_retry > NFS_MAXREXMIT)
3223	nmp->nm_retry = NFS_MAXREXMIT;
3224
3225	if (nmp->nm_numgrps > NFS_MAXGRPS)
3226	nmp->nm_numgrps = NFS_MAXGRPS;
3227	if (nmp->nm_readahead > NFS_MAXRAHEAD)
3228	nmp->nm_readahead = NFS_MAXRAHEAD;
3229	if (nmp->nm_acregmin > nmp->nm_acregmax)
3230	nmp->nm_acregmin = nmp->nm_acregmax;
3231	if (nmp->nm_acdirmin > nmp->nm_acdirmax)
3232	nmp->nm_acdirmin = nmp->nm_acdirmax;
3233
3234	/ need at least one fs location /
3235	if (nmp->nm_locations.nl_numlocs < `1`)
3236	error = EINVAL;
3237	nfsmerr_if(error);
3238
3239	/ init mount's mntfromname to first location /
3240	if (!NM_OMATTR_GIVEN(nmp, MNTFROM))
3241	nfs_location_mntfromname(&nmp->nm_locations, firstloc,
3242	vfs_statfs(mp)->f_mntfromname, sizeof(vfs_statfs(mp)->f_mntfromname), `0`);
3243
3244	/ Need to save the mounting credential for v4. /
3245	nmp->nm_mcred = vfs_context_ucred(ctx);
3246	if (IS_VALID_CRED(nmp->nm_mcred))
3247	kauth_cred_ref(nmp->nm_mcred);
3248
3249	/*
3250	* If a reserved port is required, check for that privilege.
3251	* (Note that mirror mounts are exempt because the privilege was
3252	* already checked for the original mount.)
3253	*/
3254	if (NMFLAG(nmp, RESVPORT) && !vfs_iskernelmount(mp))
3255	error = priv_check_cred(nmp->nm_mcred, PRIV_NETINET_RESERVEDPORT, `0`);
3256	nfsmerr_if(error);
3257
3258	/ do mount's initial socket connection /
3259	error = nfs_mount_connect(nmp);
3260	nfsmerr_if(error);
3261
3262	/ set up the version-specific function tables /
3263	if (nmp->nm_vers < NFS_VER4)
3264	nmp->nm_funcs = &nfs3_funcs;
3265	else
3266	nmp->nm_funcs = &nfs4_funcs;
3267
3268	/ sanity check settings now that version/connection is set /
3269	if (nmp->nm_vers == NFS_VER2) / ignore RDIRPLUS on NFSv2 /
3270	NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_RDIRPLUS);
3271	if (nmp->nm_vers >= NFS_VER4) {
3272	if (NFS_BITMAP_ISSET(nmp->nm_flags, NFS_MFLAG_ACLONLY)) / aclonly trumps noacl /
3273	NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_NOACL);
3274	NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_CALLUMNT);
3275	if (nmp->nm_lockmode != NFS_LOCK_MODE_ENABLED)
3276	error = EINVAL; / disabled/local lock mode only allowed on v2/v3 /
3277	} else {
3278	/ ignore these if not v4 /
3279	NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_NOCALLBACK);
3280	NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_NAMEDATTR);
3281	NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_NOACL);
3282	NFS_BITMAP_CLR(nmp->nm_flags, NFS_MFLAG_ACLONLY);
3283	}
3284	nfsmerr_if(error);
3285
3286	if (nmp->nm_sotype == SOCK_DGRAM) {
3287	/ I/O size defaults for UDP are different /
3288	if (!NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE))
3289	nmp->nm_rsize = NFS_DGRAM_RSIZE;
3290	if (!NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE))
3291	nmp->nm_wsize = NFS_DGRAM_WSIZE;
3292	}
3293
3294	/ round down I/O sizes to multiple of NFS_FABLKSIZE /
3295	nmp->nm_rsize &= ~(NFS_FABLKSIZE - `1`);
3296	if (nmp->nm_rsize <= `0`)
3297	nmp->nm_rsize = NFS_FABLKSIZE;
3298	nmp->nm_wsize &= ~(NFS_FABLKSIZE - `1`);
3299	if (nmp->nm_wsize <= `0`)
3300	nmp->nm_wsize = NFS_FABLKSIZE;
3301
3302	/ and limit I/O sizes to maximum allowed /
3303	maxio = (nmp->nm_vers == NFS_VER2) ? NFS_V2MAXDATA :
3304	(nmp->nm_sotype == SOCK_DGRAM) ? NFS_MAXDGRAMDATA : NFS_MAXDATA;
3305	if (maxio > NFS_MAXBSIZE)
3306	maxio = NFS_MAXBSIZE;
3307	if (nmp->nm_rsize > maxio)
3308	nmp->nm_rsize = maxio;
3309	if (nmp->nm_wsize > maxio)
3310	nmp->nm_wsize = maxio;
3311
3312	if (nmp->nm_readdirsize > maxio)
3313	nmp->nm_readdirsize = maxio;
3314	if (nmp->nm_readdirsize > nmp->nm_rsize)
3315	nmp->nm_readdirsize = nmp->nm_rsize;
3316
3317	/ Set up the sockets and related info /
3318	if (nmp->nm_sotype == SOCK_DGRAM)
3319	TAILQ_INIT(&nmp->nm_cwndq);
3320
3321	/*
3322	* Get the root node/attributes from the NFS server and
3323	* do any basic, version-specific setup.
3324	*/
3325	error = nmp->nm_funcs->nf_mount(nmp, ctx, &np);
3326	nfsmerr_if(error);
3327
3328	/*
3329	* A reference count is needed on the node representing the
3330	* remote root. If this object is not persistent, then backward
3331	* traversals of the mount point (i.e. "..") will not work if
3332	* the node gets flushed out of the cache.
3333	*/
3334	nmp->nm_dnp = np;
3335	*vpp = NFSTOV(np);
3336	/ get usecount and drop iocount /
3337	error = vnode_ref(*vpp);
3338	vnode_put(*vpp);
3339	if (error) {
3340	vnode_recycle(*vpp);
3341	goto nfsmerr;
3342	}
3343
3344	/*
3345	* Do statfs to ensure static info gets set to reasonable values.
3346	*/
3347	if ((error = nmp->nm_funcs->nf_update_statfs(nmp, ctx))) {
3348	int error2 = vnode_getwithref(*vpp);
3349	vnode_rele(*vpp);
3350	if (!error2)
3351	vnode_put(*vpp);
3352	vnode_recycle(*vpp);
3353	goto nfsmerr;
3354	}
3355	sbp = vfs_statfs(mp);
3356	sbp->f_bsize = nmp->nm_fsattr.nfsa_bsize;
3357	sbp->f_blocks = nmp->nm_fsattr.nfsa_space_total / sbp->f_bsize;
3358	sbp->f_bfree = nmp->nm_fsattr.nfsa_space_free / sbp->f_bsize;
3359	sbp->f_bavail = nmp->nm_fsattr.nfsa_space_avail / sbp->f_bsize;
3360	sbp->f_bused = (nmp->nm_fsattr.nfsa_space_total / sbp->f_bsize) -
3361	(nmp->nm_fsattr.nfsa_space_free / sbp->f_bsize);
3362	sbp->f_files = nmp->nm_fsattr.nfsa_files_total;
3363	sbp->f_ffree = nmp->nm_fsattr.nfsa_files_free;
3364	sbp->f_iosize = nfs_iosize;
3365
3366	/*
3367	* Calculate the size used for I/O buffers. Use the larger
3368	* of the two sizes to minimise NFS requests but make sure
3369	* that it is at least one VM page to avoid wasting buffer
3370	* space and to allow easy mmapping of I/O buffers.
3371	* The read/write RPC calls handle the splitting up of
3372	* buffers into multiple requests if the buffer size is
3373	* larger than the I/O size.
3374	*/
3375	#ifndef CONFIG_EMBEDDED
3376	iosize = max(nmp->nm_rsize, nmp->nm_wsize);
3377	if (iosize < PAGE_SIZE)
3378	iosize = PAGE_SIZE;
3379	#else
3380	iosize = PAGE_SIZE;
3381	#endif
3382	nmp->nm_biosize = trunc_page_32(iosize);
3383
3384	/ For NFSv3 and greater, there is a (relatively) reliable ACCESS call. /
3385	if (nmp->nm_vers > NFS_VER2)
3386	vfs_setauthopaqueaccess(mp);
3387
3388	switch (nmp->nm_lockmode) {
3389	case NFS_LOCK_MODE_DISABLED:
3390	break;
3391	case NFS_LOCK_MODE_LOCAL:
3392	vfs_setlocklocal(nmp->nm_mountp);
3393	break;
3394	case NFS_LOCK_MODE_ENABLED:
3395	default:
3396	if (nmp->nm_vers <= NFS_VER3)
3397	nfs_lockd_mount_register(nmp);
3398	break;
3399	}
3400
3401	/ success! /
3402	lck_mtx_lock(&nmp->nm_lock);
3403	nmp->nm_state \|= NFSSTA_MOUNTED;
3404	lck_mtx_unlock(&nmp->nm_lock);
3405	return (`0`);
3406	nfsmerr:
3407	nfs_mount_drain_and_cleanup(nmp);
3408	return (error);
3409	}
3410
3411	#if CONFIG_TRIGGERS
3412
3413	/*
3414	* We've detected a file system boundary on the server and
3415	* need to mount a new file system so that our file systems
3416	* MIRROR the file systems on the server.
3417	*
3418	* Build the mount arguments for the new mount and call kernel_mount().
3419	*/
3420	int
3421	nfs_mirror_mount_domount(vnode_t dvp, vnode_t vp, vfs_context_t ctx)
3422	{
3423	nfsnode_t np = VTONFS(vp);
3424	nfsnode_t dnp = VTONFS(dvp);
3425	struct nfsmount *nmp = NFSTONMP(np);
3426	char fstype[MFSTYPENAMELEN], mntfromname = NULL, path = NULL, relpath, p, *cp;
3427	int error = `0`, pathbuflen = MAXPATHLEN, i, mntflags = `0`, referral, skipcopy = `0`;
3428	size_t nlen;
3429	struct xdrbuf xb, xbnew;
3430	uint32_t mattrs[NFS_MATTR_BITMAP_LEN];
3431	uint32_t newmattrs[NFS_MATTR_BITMAP_LEN];
3432	uint32_t newmflags[NFS_MFLAG_BITMAP_LEN];
3433	uint32_t newmflags_mask[NFS_MFLAG_BITMAP_LEN];
3434	uint32_t argslength = `0`, val, count, mlen, mlen2, rlen, relpathcomps;
3435	uint32_t argslength_offset, attrslength_offset, end_offset;
3436	uint32_t numlocs, loc, numserv, serv, numaddr, addr, numcomp, comp;
3437	char buf[XDRWORD];
3438	struct nfs_fs_locations nfsls;
3439
3440	referral = (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER_REFERRAL);
3441	if (referral)
3442	bzero(&nfsls, sizeof(nfsls));
3443
3444	xb_init(&xbnew, `0`);
3445
3446	if (!nmp \|\| (nmp->nm_state & (NFSSTA_FORCE\|NFSSTA_DEAD)))
3447	return (ENXIO);
3448
3449	/ allocate a couple path buffers we need /
3450	MALLOC_ZONE(mntfromname, char *, pathbuflen, M_NAMEI, M_WAITOK);
3451	if (!mntfromname) {
3452	error = ENOMEM;
3453	goto nfsmerr;
3454	}
3455	MALLOC_ZONE(path, char *, pathbuflen, M_NAMEI, M_WAITOK);
3456	if (!path) {
3457	error = ENOMEM;
3458	goto nfsmerr;
3459	}
3460
3461	/ get the path for the directory being mounted on /
3462	error = vn_getpath(vp, path, &pathbuflen);
3463	if (error) {
3464	error = ENOMEM;
3465	goto nfsmerr;
3466	}
3467
3468	/*
3469	* Set up the mntfromname for the new mount based on the
3470	* current mount's mntfromname and the directory's path
3471	* relative to the current mount's mntonname.
3472	* Set up relpath to point at the relative path on the current mount.
3473	* Also, count the number of components in relpath.
3474	* We'll be adding those to each fs location path in the new args.
3475	*/
3476	nlen = strlcpy(mntfromname, vfs_statfs(nmp->nm_mountp)->f_mntfromname, MAXPATHLEN);
3477	if ((nlen > `0`) && (mntfromname[nlen-`1`] == `'/'`)) { / avoid double '/' in new name /
3478	mntfromname[nlen-`1`] = `'\0'`;
3479	nlen--;
3480	}
3481	relpath = mntfromname + nlen;
3482	nlen = strlcat(mntfromname, path + strlen(vfs_statfs(nmp->nm_mountp)->f_mntonname), MAXPATHLEN);
3483	if (nlen >= MAXPATHLEN) {
3484	error = ENAMETOOLONG;
3485	goto nfsmerr;
3486	}
3487	/ count the number of components in relpath /
3488	p = relpath;
3489	while (p && (p == `'/'`))
3490	p++;
3491	relpathcomps = `0`;
3492	while (*p) {
3493	relpathcomps++;
3494	while (p && (p != `'/'`))
3495	p++;
3496	while (p && (p == `'/'`))
3497	p++;
3498	}
3499
3500	/ grab a copy of the file system type /
3501	vfs_name(vnode_mount(vp), fstype);
3502
3503	/ for referrals, fetch the fs locations /
3504	if (referral) {
3505	const char *vname = vnode_getname(NFSTOV(np));
3506	if (!vname) {
3507	error = ENOENT;
3508	} else {
3509	error = nfs4_get_fs_locations(nmp, dnp, NULL, `0`, vname, ctx, &nfsls);
3510	vnode_putname(vname);
3511	if (!error && (nfsls.nl_numlocs < `1`))
3512	error = ENOENT;
3513	}
3514	nfsmerr_if(error);
3515	}
3516
3517	/ set up NFS mount args based on current mount args /
3518
3519	#define xb_copy_32(E, XBSRC, XBDST, V) \
3520	do { \
3521	if (E) break; \
3522	xb_get_32((E), (XBSRC), (V)); \
3523	if (skipcopy) break; \
3524	xb_add_32((E), (XBDST), (V)); \
3525	} while (0)
3526	#define xb_copy_opaque(E, XBSRC, XBDST) \
3527	do { \
3528	uint32_t __count, __val; \
3529	xb_copy_32((E), (XBSRC), (XBDST), __count); \
3530	if (E) break; \
3531	__count = nfsm_rndup(__count); \
3532	__count /= XDRWORD; \
3533	while (__count-- > 0) \
3534	xb_copy_32((E), (XBSRC), (XBDST), __val); \
3535	} while (0)
3536
3537	xb_init_buffer(&xb, nmp->nm_args, `2`*XDRWORD);
3538	xb_get_32(error, &xb, val); / version /
3539	xb_get_32(error, &xb, argslength); / args length /
3540	xb_init_buffer(&xb, nmp->nm_args, argslength);
3541
3542	xb_init_buffer(&xbnew, NULL, `0`);
3543	xb_copy_32(error, &xb, &xbnew, val); / version /
3544	argslength_offset = xb_offset(&xbnew);
3545	xb_copy_32(error, &xb, &xbnew, val); / args length /
3546	xb_copy_32(error, &xb, &xbnew, val); / XDR args version /
3547	count = NFS_MATTR_BITMAP_LEN;
3548	xb_get_bitmap(error, &xb, mattrs, count); / mount attribute bitmap /
3549	nfsmerr_if(error);
3550	for (i = `0`; i < NFS_MATTR_BITMAP_LEN; i++)
3551	newmattrs[i] = mattrs[i];
3552	if (referral)
3553	NFS_BITMAP_SET(newmattrs, NFS_MATTR_FS_LOCATIONS);
3554	else
3555	NFS_BITMAP_SET(newmattrs, NFS_MATTR_FH);
3556	NFS_BITMAP_SET(newmattrs, NFS_MATTR_FLAGS);
3557	NFS_BITMAP_SET(newmattrs, NFS_MATTR_MNTFLAGS);
3558	NFS_BITMAP_CLR(newmattrs, NFS_MATTR_MNTFROM);
3559	xb_add_bitmap(error, &xbnew, newmattrs, NFS_MATTR_BITMAP_LEN);
3560	attrslength_offset = xb_offset(&xbnew);
3561	xb_copy_32(error, &xb, &xbnew, val); / attrs length /
3562	NFS_BITMAP_ZERO(newmflags_mask, NFS_MFLAG_BITMAP_LEN);
3563	NFS_BITMAP_ZERO(newmflags, NFS_MFLAG_BITMAP_LEN);
3564	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FLAGS)) {
3565	count = NFS_MFLAG_BITMAP_LEN;
3566	xb_get_bitmap(error, &xb, newmflags_mask, count); / mount flag mask bitmap /
3567	count = NFS_MFLAG_BITMAP_LEN;
3568	xb_get_bitmap(error, &xb, newmflags, count); / mount flag bitmap /
3569	}
3570	NFS_BITMAP_SET(newmflags_mask, NFS_MFLAG_EPHEMERAL);
3571	NFS_BITMAP_SET(newmflags, NFS_MFLAG_EPHEMERAL);
3572	xb_add_bitmap(error, &xbnew, newmflags_mask, NFS_MFLAG_BITMAP_LEN);
3573	xb_add_bitmap(error, &xbnew, newmflags, NFS_MFLAG_BITMAP_LEN);
3574	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION))
3575	xb_copy_32(error, &xb, &xbnew, val);
3576	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_MINOR_VERSION))
3577	xb_copy_32(error, &xb, &xbnew, val);
3578	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_VERSION_RANGE)) {
3579	xb_copy_32(error, &xb, &xbnew, val);
3580	xb_copy_32(error, &xb, &xbnew, val);
3581	}
3582	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READ_SIZE))
3583	xb_copy_32(error, &xb, &xbnew, val);
3584	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_WRITE_SIZE))
3585	xb_copy_32(error, &xb, &xbnew, val);
3586	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READDIR_SIZE))
3587	xb_copy_32(error, &xb, &xbnew, val);
3588	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_READAHEAD))
3589	xb_copy_32(error, &xb, &xbnew, val);
3590	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_REG_MIN)) {
3591	xb_copy_32(error, &xb, &xbnew, val);
3592	xb_copy_32(error, &xb, &xbnew, val);
3593	}
3594	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_REG_MAX)) {
3595	xb_copy_32(error, &xb, &xbnew, val);
3596	xb_copy_32(error, &xb, &xbnew, val);
3597	}
3598	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MIN)) {
3599	xb_copy_32(error, &xb, &xbnew, val);
3600	xb_copy_32(error, &xb, &xbnew, val);
3601	}
3602	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MAX)) {
3603	xb_copy_32(error, &xb, &xbnew, val);
3604	xb_copy_32(error, &xb, &xbnew, val);
3605	}
3606	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_LOCK_MODE))
3607	xb_copy_32(error, &xb, &xbnew, val);
3608	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SECURITY)) {
3609	xb_copy_32(error, &xb, &xbnew, count);
3610	while (!error && (count-- > `0`))
3611	xb_copy_32(error, &xb, &xbnew, val);
3612	}
3613	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_KERB_ETYPE)) {
3614	xb_copy_32(error, &xb, &xbnew, count);
3615	xb_add_32(error, &xbnew, -`1`);
3616	while (!error && (count-- > `0`))
3617	xb_copy_32(error, &xb, &xbnew, val);
3618	}
3619	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MAX_GROUP_LIST))
3620	xb_copy_32(error, &xb, &xbnew, val);
3621	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOCKET_TYPE))
3622	xb_copy_opaque(error, &xb, &xbnew);
3623	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_NFS_PORT))
3624	xb_copy_32(error, &xb, &xbnew, val);
3625	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MOUNT_PORT))
3626	xb_copy_32(error, &xb, &xbnew, val);
3627	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_REQUEST_TIMEOUT)) {
3628	xb_copy_32(error, &xb, &xbnew, val);
3629	xb_copy_32(error, &xb, &xbnew, val);
3630	}
3631	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT))
3632	xb_copy_32(error, &xb, &xbnew, val);
3633	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_DEAD_TIMEOUT)) {
3634	xb_copy_32(error, &xb, &xbnew, val);
3635	xb_copy_32(error, &xb, &xbnew, val);
3636	}
3637	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FH)) {
3638	xb_get_32(error, &xb, count);
3639	xb_skip(error, &xb, count);
3640	}
3641	if (!referral) {
3642	/ set the initial file handle to the directory's file handle /
3643	xb_add_fh(error, &xbnew, np->n_fhp, np->n_fhsize);
3644	}
3645	/ copy/extend/skip fs locations /
3646	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_FS_LOCATIONS)) {
3647	numlocs = numserv = numaddr = numcomp = `0`;
3648	if (referral) / don't copy the fs locations for a referral /
3649	skipcopy = `1`;
3650	xb_copy_32(error, &xb, &xbnew, numlocs); / location count /
3651	for (loc = `0`; !error && (loc < numlocs); loc++) {
3652	xb_copy_32(error, &xb, &xbnew, numserv); / server count /
3653	for (serv = `0`; !error && (serv < numserv); serv++) {
3654	xb_copy_opaque(error, &xb, &xbnew); / server name /
3655	xb_copy_32(error, &xb, &xbnew, numaddr); / address count /
3656	for (addr = `0`; !error && (addr < numaddr); addr++)
3657	xb_copy_opaque(error, &xb, &xbnew); / address /
3658	xb_copy_opaque(error, &xb, &xbnew); / server info /
3659	}
3660	/ pathname /
3661	xb_get_32(error, &xb, numcomp); / component count /
3662	if (!skipcopy)
3663	xb_add_32(error, &xbnew, numcomp+relpathcomps); / new component count /
3664	for (comp = `0`; !error && (comp < numcomp); comp++)
3665	xb_copy_opaque(error, &xb, &xbnew); / component /
3666	/ add additional components /
3667	for (comp = `0`; !skipcopy && !error && (comp < relpathcomps); comp++) {
3668	p = relpath;
3669	while (p && (p == `'/'`))
3670	p++;
3671	while (*p && !error) {
3672	cp = p;
3673	while (p && (p != `'/'`))
3674	p++;
3675	xb_add_string(error, &xbnew, cp, (p - cp)); / component /
3676	while (p && (p == `'/'`))
3677	p++;
3678	}
3679	}
3680	xb_copy_opaque(error, &xb, &xbnew); / fs location info /
3681	}
3682	if (referral)
3683	skipcopy = `0`;
3684	}
3685	if (referral) {
3686	/ add referral's fs locations /
3687	xb_add_32(error, &xbnew, nfsls.nl_numlocs); / FS_LOCATIONS /
3688	for (loc = `0`; !error && (loc < nfsls.nl_numlocs); loc++) {
3689	xb_add_32(error, &xbnew, nfsls.nl_locations[loc]->nl_servcount);
3690	for (serv = `0`; !error && (serv < nfsls.nl_locations[loc]->nl_servcount); serv++) {
3691	xb_add_string(error, &xbnew, nfsls.nl_locations[loc]->nl_servers[serv]->ns_name,
3692	strlen(nfsls.nl_locations[loc]->nl_servers[serv]->ns_name));
3693	xb_add_32(error, &xbnew, nfsls.nl_locations[loc]->nl_servers[serv]->ns_addrcount);
3694	for (addr = `0`; !error && (addr < nfsls.nl_locations[loc]->nl_servers[serv]->ns_addrcount); addr++)
3695	xb_add_string(error, &xbnew, nfsls.nl_locations[loc]->nl_servers[serv]->ns_addresses[addr],
3696	strlen(nfsls.nl_locations[loc]->nl_servers[serv]->ns_addresses[addr]));
3697	xb_add_32(error, &xbnew, `0`); / empty server info /
3698	}
3699	xb_add_32(error, &xbnew, nfsls.nl_locations[loc]->nl_path.np_compcount);
3700	for (comp = `0`; !error && (comp < nfsls.nl_locations[loc]->nl_path.np_compcount); comp++)
3701	xb_add_string(error, &xbnew, nfsls.nl_locations[loc]->nl_path.np_components[comp],
3702	strlen(nfsls.nl_locations[loc]->nl_path.np_components[comp]));
3703	xb_add_32(error, &xbnew, `0`); / empty fs location info /
3704	}
3705	}
3706	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFLAGS))
3707	xb_get_32(error, &xb, mntflags);
3708	/*
3709	* We add the following mount flags to the ones for the mounted-on mount:
3710	* MNT_DONTBROWSE - to keep the mount from showing up as a separate volume
3711	* MNT_AUTOMOUNTED - to keep DiskArb from retriggering the mount after
3712	* an unmount (looking for /.autodiskmounted)
3713	*/
3714	mntflags \|= (MNT_AUTOMOUNTED \| MNT_DONTBROWSE);
3715	xb_add_32(error, &xbnew, mntflags);
3716	if (!referral && NFS_BITMAP_ISSET(mattrs, NFS_MATTR_MNTFROM)) {
3717	/ copy mntfrom string and add relpath /
3718	rlen = strlen(relpath);
3719	xb_get_32(error, &xb, mlen);
3720	nfsmerr_if(error);
3721	mlen2 = mlen + ((relpath[`0`] != `'/'`) ? `1` : `0`) + rlen;
3722	xb_add_32(error, &xbnew, mlen2);
3723	count = mlen/XDRWORD;
3724	/ copy the original string /
3725	while (count-- > `0`)
3726	xb_copy_32(error, &xb, &xbnew, val);
3727	if (!error && (mlen % XDRWORD)) {
3728	error = xb_get_bytes(&xb, buf, mlen%XDRWORD, `0`);
3729	if (!error)
3730	error = xb_add_bytes(&xbnew, buf, mlen%XDRWORD, `1`);
3731	}
3732	/ insert a '/' if the relative path doesn't start with one /
3733	if (!error && (relpath[`0`] != `'/'`)) {
3734	buf[`0`] = `'/'`;
3735	error = xb_add_bytes(&xbnew, buf, `1`, `1`);
3736	}
3737	/ add the additional relative path /
3738	if (!error)
3739	error = xb_add_bytes(&xbnew, relpath, rlen, `1`);
3740	/ make sure the resulting string has the right number of pad bytes /
3741	if (!error && (mlen2 != nfsm_rndup(mlen2))) {
3742	bzero(buf, sizeof(buf));
3743	count = nfsm_rndup(mlen2) - mlen2;
3744	error = xb_add_bytes(&xbnew, buf, count, `1`);
3745	}
3746	}
3747	xb_build_done(error, &xbnew);
3748
3749	/ update opaque counts /
3750	end_offset = xb_offset(&xbnew);
3751	if (!error) {
3752	error = xb_seek(&xbnew, argslength_offset);
3753	argslength = end_offset - argslength_offset + XDRWORD/version/;
3754	xb_add_32(error, &xbnew, argslength);
3755	}
3756	if (!error) {
3757	error = xb_seek(&xbnew, attrslength_offset);
3758	xb_add_32(error, &xbnew, end_offset - attrslength_offset - XDRWORD/don't include length field/);
3759	}
3760	nfsmerr_if(error);
3761
3762	/*
3763	* For kernel_mount() call, use the existing mount flags (instead of the
3764	* original flags) because flags like MNT_NOSUID and MNT_NODEV may have
3765	* been silently enforced.
3766	*/
3767	mntflags = vnode_vfsvisflags(vp);
3768	mntflags \|= (MNT_AUTOMOUNTED \| MNT_DONTBROWSE);
3769
3770	/ do the mount /
3771	error = kernel_mount(fstype, dvp, vp, path, xb_buffer_base(&xbnew), argslength,
3772	mntflags, KERNEL_MOUNT_PERMIT_UNMOUNT \| KERNEL_MOUNT_NOAUTH, ctx);
3773
3774	nfsmerr:
3775	if (error)
3776	printf("nfs: mirror mount of %s on %s failed (%d)\n",
3777	mntfromname, path, error);
3778	/ clean up /
3779	xb_cleanup(&xbnew);
3780	if (referral)
3781	nfs_fs_locations_cleanup(&nfsls);
3782	if (path)
3783	FREE_ZONE(path, MAXPATHLEN, M_NAMEI);
3784	if (mntfromname)
3785	FREE_ZONE(mntfromname, MAXPATHLEN, M_NAMEI);
3786	if (!error)
3787	nfs_ephemeral_mount_harvester_start();
3788	return (error);
3789	}
3790
3791	/*
3792	* trigger vnode functions
3793	*/
3794
3795	resolver_result_t
3796	nfs_mirror_mount_trigger_resolve(
3797	vnode_t vp,
3798	const struct componentname *cnp,
3799	enum path_operation pop,
3800	__unused int flags,
3801	__unused void *data,
3802	vfs_context_t ctx)
3803	{
3804	nfsnode_t np = VTONFS(vp);
3805	vnode_t pvp = NULLVP;
3806	int error = `0`;
3807	resolver_result_t result;
3808
3809	/*
3810	* We have a trigger node that doesn't have anything mounted on it yet.
3811	* We'll do the mount if either:
3812	* (a) this isn't the last component of the path OR
3813	* (b) this is an op that looks like it should trigger the mount.
3814	*/
3815	if (cnp->cn_flags & ISLASTCN) {
3816	switch (pop) {
3817	case OP_MOUNT:
3818	case OP_UNMOUNT:
3819	case OP_STATFS:
3820	case OP_LINK:
3821	case OP_UNLINK:
3822	case OP_RENAME:
3823	case OP_MKNOD:
3824	case OP_MKFIFO:
3825	case OP_SYMLINK:
3826	case OP_ACCESS:
3827	case OP_GETATTR:
3828	case OP_MKDIR:
3829	case OP_RMDIR:
3830	case OP_REVOKE:
3831	case OP_GETXATTR:
3832	case OP_LISTXATTR:
3833	/ don't perform the mount for these operations /
3834	result = vfs_resolver_result(np->n_trigseq, RESOLVER_NOCHANGE, `0`);
3835	#ifdef NFS_TRIGGER_DEBUG
3836	NP(np, "nfs trigger RESOLVE: no change, last %d nameiop %d, seq %d",
3837	(cnp->cn_flags & ISLASTCN) ? `1` : `0`, cnp->cn_nameiop, np->n_trigseq);
3838	#endif
3839	return (result);
3840	case OP_OPEN:
3841	case OP_CHDIR:
3842	case OP_CHROOT:
3843	case OP_TRUNCATE:
3844	case OP_COPYFILE:
3845	case OP_PATHCONF:
3846	case OP_READLINK:
3847	case OP_SETATTR:
3848	case OP_EXCHANGEDATA:
3849	case OP_SEARCHFS:
3850	case OP_FSCTL:
3851	case OP_SETXATTR:
3852	case OP_REMOVEXATTR:
3853	default:
3854	/ go ahead and do the mount /
3855	break;
3856	}
3857	}
3858
3859	if (vnode_mountedhere(vp) != NULL) {
3860	/*
3861	* Um... there's already something mounted.
3862	* Been there. Done that. Let's just say it succeeded.
3863	*/
3864	error = `0`;
3865	goto skipmount;
3866	}
3867
3868	if ((error = nfs_node_set_busy(np, vfs_context_thread(ctx)))) {
3869	result = vfs_resolver_result(np->n_trigseq, RESOLVER_ERROR, error);
3870	#ifdef NFS_TRIGGER_DEBUG
3871	NP(np, "nfs trigger RESOLVE: busy error %d, last %d nameiop %d, seq %d",
3872	error, (cnp->cn_flags & ISLASTCN) ? `1` : `0`, cnp->cn_nameiop, np->n_trigseq);
3873	#endif
3874	return (result);
3875	}
3876
3877	pvp = vnode_getparent(vp);
3878	if (pvp == NULLVP)
3879	error = EINVAL;
3880	if (!error)
3881	error = nfs_mirror_mount_domount(pvp, vp, ctx);
3882	skipmount:
3883	if (!error)
3884	np->n_trigseq++;
3885	result = vfs_resolver_result(np->n_trigseq, error ? RESOLVER_ERROR : RESOLVER_RESOLVED, error);
3886	#ifdef NFS_TRIGGER_DEBUG
3887	NP(np, "nfs trigger RESOLVE: %s %d, last %d nameiop %d, seq %d",
3888	error ? "error" : "resolved", error,
3889	(cnp->cn_flags & ISLASTCN) ? `1` : `0`, cnp->cn_nameiop, np->n_trigseq);
3890	#endif
3891
3892	if (pvp != NULLVP)
3893	vnode_put(pvp);
3894	nfs_node_clear_busy(np);
3895	return (result);
3896	}
3897
3898	resolver_result_t
3899	nfs_mirror_mount_trigger_unresolve(
3900	vnode_t vp,
3901	int flags,
3902	__unused void *data,
3903	vfs_context_t ctx)
3904	{
3905	nfsnode_t np = VTONFS(vp);
3906	mount_t mp;
3907	int error;
3908	resolver_result_t result;
3909
3910	if ((error = nfs_node_set_busy(np, vfs_context_thread(ctx)))) {
3911	result = vfs_resolver_result(np->n_trigseq, RESOLVER_ERROR, error);
3912	#ifdef NFS_TRIGGER_DEBUG
3913	NP(np, "nfs trigger UNRESOLVE: busy error %d, seq %d", error, np->n_trigseq);
3914	#endif
3915	return (result);
3916	}
3917
3918	mp = vnode_mountedhere(vp);
3919	if (!mp)
3920	error = EINVAL;
3921	if (!error)
3922	error = vfs_unmountbyfsid(&(vfs_statfs(mp)->f_fsid), flags, ctx);
3923	if (!error)
3924	np->n_trigseq++;
3925	result = vfs_resolver_result(np->n_trigseq, error ? RESOLVER_ERROR : RESOLVER_UNRESOLVED, error);
3926	#ifdef NFS_TRIGGER_DEBUG
3927	NP(np, "nfs trigger UNRESOLVE: %s %d, seq %d",
3928	error ? "error" : "unresolved", error, np->n_trigseq);
3929	#endif
3930	nfs_node_clear_busy(np);
3931	return (result);
3932	}
3933
3934	resolver_result_t
3935	nfs_mirror_mount_trigger_rearm(
3936	vnode_t vp,
3937	__unused int flags,
3938	__unused void *data,
3939	vfs_context_t ctx)
3940	{
3941	nfsnode_t np = VTONFS(vp);
3942	int error;
3943	resolver_result_t result;
3944
3945	if ((error = nfs_node_set_busy(np, vfs_context_thread(ctx)))) {
3946	result = vfs_resolver_result(np->n_trigseq, RESOLVER_ERROR, error);
3947	#ifdef NFS_TRIGGER_DEBUG
3948	NP(np, "nfs trigger REARM: busy error %d, seq %d", error, np->n_trigseq);
3949	#endif
3950	return (result);
3951	}
3952
3953	np->n_trigseq++;
3954	result = vfs_resolver_result(np->n_trigseq,
3955	vnode_mountedhere(vp) ? RESOLVER_RESOLVED : RESOLVER_UNRESOLVED, `0`);
3956	#ifdef NFS_TRIGGER_DEBUG
3957	NP(np, "nfs trigger REARM: %s, seq %d",
3958	vnode_mountedhere(vp) ? "resolved" : "unresolved", np->n_trigseq);
3959	#endif
3960	nfs_node_clear_busy(np);
3961	return (result);
3962	}
3963
3964	/*
3965	* Periodically attempt to unmount ephemeral (mirror) mounts in an attempt to limit
3966	* the number of unused mounts.
3967	*/
3968
3969	#define NFS_EPHEMERAL_MOUNT_HARVEST_INTERVAL 120 /* how often the harvester runs */
3970	struct nfs_ephemeral_mount_harvester_info {
3971	fsid_t fsid; / FSID that we need to try to unmount /
3972	uint32_t mountcount; / count of ephemeral mounts seen in scan /
3973	};
3974	/ various globals for the harvester /
3975	static thread_call_t nfs_ephemeral_mount_harvester_timer = NULL;
3976	static int nfs_ephemeral_mount_harvester_on = `0`;
3977
3978	kern_return_t thread_terminate(thread_t);
3979
3980	static int
3981	nfs_ephemeral_mount_harvester_callback(mount_t mp, void *arg)
3982	{
3983	struct nfs_ephemeral_mount_harvester_info *hinfo = arg;
3984	struct nfsmount *nmp;
3985	struct timeval now;
3986
3987	if (strcmp(mp->mnt_vfsstat.f_fstypename, "nfs"))
3988	return (VFS_RETURNED);
3989	nmp = VFSTONFS(mp);
3990	if (!nmp \|\| !NMFLAG(nmp, EPHEMERAL))
3991	return (VFS_RETURNED);
3992	hinfo->mountcount++;
3993
3994	/ avoid unmounting mounts that have been triggered within the last harvest interval /
3995	microtime(&now);
3996	if ((nmp->nm_mounttime >> `32`) > ((uint32_t)now.tv_sec - NFS_EPHEMERAL_MOUNT_HARVEST_INTERVAL))
3997	return (VFS_RETURNED);
3998
3999	if (hinfo->fsid.val[`0`] \|\| hinfo->fsid.val[`1`]) {
4000	/ attempt to unmount previously-found ephemeral mount /
4001	vfs_unmountbyfsid(&hinfo->fsid, `0`, vfs_context_kernel());
4002	hinfo->fsid.val[`0`] = hinfo->fsid.val[`1`] = `0`;
4003	}
4004
4005	/*
4006	* We can't call unmount here since we hold a mount iter ref
4007	* on mp so save its fsid for the next call iteration to unmount.
4008	*/
4009	hinfo->fsid.val[`0`] = mp->mnt_vfsstat.f_fsid.val[`0`];
4010	hinfo->fsid.val[`1`] = mp->mnt_vfsstat.f_fsid.val[`1`];
4011
4012	return (VFS_RETURNED);
4013	}
4014
4015	/*
4016	* Spawn a thread to do the ephemeral mount harvesting.
4017	*/
4018	static void
4019	nfs_ephemeral_mount_harvester_timer_func(void)
4020	{
4021	thread_t thd;
4022
4023	if (kernel_thread_start(nfs_ephemeral_mount_harvester, NULL, &thd) == KERN_SUCCESS)
4024	thread_deallocate(thd);
4025	}
4026
4027	/*
4028	* Iterate all mounts looking for NFS ephemeral mounts to try to unmount.
4029	*/
4030	void
4031	nfs_ephemeral_mount_harvester(__unused void *arg, __unused wait_result_t wr)
4032	{
4033	struct nfs_ephemeral_mount_harvester_info hinfo;
4034	uint64_t deadline;
4035
4036	hinfo.mountcount = `0`;
4037	hinfo.fsid.val[`0`] = hinfo.fsid.val[`1`] = `0`;
4038	vfs_iterate(VFS_ITERATE_TAIL_FIRST, nfs_ephemeral_mount_harvester_callback, &hinfo);
4039	if (hinfo.fsid.val[`0`] \|\| hinfo.fsid.val[`1`]) {
4040	/ attempt to unmount last found ephemeral mount /
4041	vfs_unmountbyfsid(&hinfo.fsid, `0`, vfs_context_kernel());
4042	}
4043
4044	lck_mtx_lock(nfs_global_mutex);
4045	if (!hinfo.mountcount) {
4046	/ no more ephemeral mounts - don't need timer /
4047	nfs_ephemeral_mount_harvester_on = `0`;
4048	} else {
4049	/ re-arm the timer /
4050	clock_interval_to_deadline(NFS_EPHEMERAL_MOUNT_HARVEST_INTERVAL, NSEC_PER_SEC, &deadline);
4051	thread_call_enter_delayed(nfs_ephemeral_mount_harvester_timer, deadline);
4052	nfs_ephemeral_mount_harvester_on = `1`;
4053	}
4054	lck_mtx_unlock(nfs_global_mutex);
4055
4056	/ thread done /
4057	thread_terminate(current_thread());
4058	}
4059
4060	/*
4061	* Make sure the NFS ephemeral mount harvester timer is running.
4062	*/
4063	void
4064	nfs_ephemeral_mount_harvester_start(void)
4065	{
4066	uint64_t deadline;
4067
4068	lck_mtx_lock(nfs_global_mutex);
4069	if (nfs_ephemeral_mount_harvester_on) {
4070	lck_mtx_unlock(nfs_global_mutex);
4071	return;
4072	}
4073	if (nfs_ephemeral_mount_harvester_timer == NULL)
4074	nfs_ephemeral_mount_harvester_timer = thread_call_allocate((thread_call_func_t)nfs_ephemeral_mount_harvester_timer_func, NULL);
4075	clock_interval_to_deadline(NFS_EPHEMERAL_MOUNT_HARVEST_INTERVAL, NSEC_PER_SEC, &deadline);
4076	thread_call_enter_delayed(nfs_ephemeral_mount_harvester_timer, deadline);
4077	nfs_ephemeral_mount_harvester_on = `1`;
4078	lck_mtx_unlock(nfs_global_mutex);
4079	}
4080
4081	#endif
4082
4083	/*
4084	* Send a MOUNT protocol MOUNT request to the server to get the initial file handle (and security).
4085	*/
4086	int
4087	nfs3_mount_rpc(struct nfsmount nmp, struct* sockaddr sa, int* sotype, int nfsvers, char path, vfs_context_t ctx, int* timeo, fhandle_t fh, struct* nfs_sec *sec)
4088	{
4089	int error = `0`, slen, mntproto;
4090	thread_t thd = vfs_context_thread(ctx);
4091	kauth_cred_t cred = vfs_context_ucred(ctx);
4092	uint64_t xid = `0`;
4093	struct nfsm_chain nmreq, nmrep;
4094	mbuf_t mreq;
4095	uint32_t mntvers, mntport, val;
4096	struct sockaddr_storage ss;
4097	struct sockaddr saddr = (struct* sockaddr*)&ss;
4098
4099	nfsm_chain_null(&nmreq);
4100	nfsm_chain_null(&nmrep);
4101
4102	mntvers = (nfsvers == NFS_VER2) ? RPCMNT_VER1 : RPCMNT_VER3;
4103	mntproto = (NM_OMFLAG(nmp, MNTUDP) \|\| (sotype == SOCK_DGRAM)) ? IPPROTO_UDP : IPPROTO_TCP;
4104	sec->count = `0`;
4105
4106	bcopy(sa, saddr, min(sizeof(ss), sa->sa_len));
4107	if (saddr->sa_family == AF_INET) {
4108	if (nmp->nm_mountport)
4109	((struct sockaddr_in*)saddr)->sin_port = htons(nmp->nm_mountport);
4110	mntport = ntohs(((struct sockaddr_in*)saddr)->sin_port);
4111	} else {
4112	if (nmp->nm_mountport)
4113	((struct sockaddr_in6*)saddr)->sin6_port = htons(nmp->nm_mountport);
4114	mntport = ntohs(((struct sockaddr_in6*)saddr)->sin6_port);
4115	}
4116
4117	while (!mntport) {
4118	error = nfs_portmap_lookup(nmp, ctx, saddr, NULL, RPCPROG_MNT, mntvers, mntproto, timeo);
4119	nfsmout_if(error);
4120	if (saddr->sa_family == AF_INET)
4121	mntport = ntohs(((struct sockaddr_in*)saddr)->sin_port);
4122	else
4123	mntport = ntohs(((struct sockaddr_in6*)saddr)->sin6_port);
4124	if (!mntport) {
4125	/ if not found and TCP, then retry with UDP /
4126	if (mntproto == IPPROTO_UDP) {
4127	error = EPROGUNAVAIL;
4128	break;
4129	}
4130	mntproto = IPPROTO_UDP;
4131	bcopy(sa, saddr, min(sizeof(ss), sa->sa_len));
4132	}
4133	}
4134	nfsmout_if(error \|\| !mntport);
4135
4136	/ MOUNT protocol MOUNT request /
4137	slen = strlen(path);
4138	nfsm_chain_build_alloc_init(error, &nmreq, NFSX_UNSIGNED + nfsm_rndup(slen));
4139	nfsm_chain_add_name(error, &nmreq, path, slen, nmp);
4140	nfsm_chain_build_done(error, &nmreq);
4141	nfsmout_if(error);
4142	error = nfsm_rpchead2(nmp, (mntproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM,
4143	RPCPROG_MNT, mntvers, RPCMNT_MOUNT,
4144	RPCAUTH_SYS, cred, NULL, nmreq.nmc_mhead, &xid, &mreq);
4145	nfsmout_if(error);
4146	nmreq.nmc_mhead = NULL;
4147	error = nfs_aux_request(nmp, thd, saddr, NULL,
4148	((mntproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM),
4149	mreq, R_XID32(xid), `1`, timeo, &nmrep);
4150	nfsmout_if(error);
4151	nfsm_chain_get_32(error, &nmrep, val);
4152	if (!error && val)
4153	error = val;
4154	nfsm_chain_get_fh(error, &nmrep, nfsvers, fh);
4155	if (!error && (nfsvers > NFS_VER2)) {
4156	sec->count = NX_MAX_SEC_FLAVORS;
4157	error = nfsm_chain_get_secinfo(&nmrep, &sec->flavors[`0`], &sec->count);
4158	}
4159	nfsmout:
4160	nfsm_chain_cleanup(&nmreq);
4161	nfsm_chain_cleanup(&nmrep);
4162	return (error);
4163	}
4164
4165
4166	/*
4167	* Send a MOUNT protocol UNMOUNT request to tell the server we've unmounted it.
4168	*/
4169	void
4170	nfs3_umount_rpc(struct nfsmount nmp, vfs_context_t ctx, int* timeo)
4171	{
4172	int error = `0`, slen, mntproto;
4173	thread_t thd = vfs_context_thread(ctx);
4174	kauth_cred_t cred = vfs_context_ucred(ctx);
4175	char *path;
4176	uint64_t xid = `0`;
4177	struct nfsm_chain nmreq, nmrep;
4178	mbuf_t mreq;
4179	uint32_t mntvers, mntport;
4180	struct sockaddr_storage ss;
4181	struct sockaddr saddr = (struct* sockaddr*)&ss;
4182
4183	if (!nmp->nm_saddr)
4184	return;
4185
4186	nfsm_chain_null(&nmreq);
4187	nfsm_chain_null(&nmrep);
4188
4189	mntvers = (nmp->nm_vers == NFS_VER2) ? RPCMNT_VER1 : RPCMNT_VER3;
4190	mntproto = (NM_OMFLAG(nmp, MNTUDP) \|\| (nmp->nm_sotype == SOCK_DGRAM)) ? IPPROTO_UDP : IPPROTO_TCP;
4191	mntport = nmp->nm_mountport;
4192
4193	bcopy(nmp->nm_saddr, saddr, min(sizeof(ss), nmp->nm_saddr->sa_len));
4194	if (saddr->sa_family == AF_INET)
4195	((struct sockaddr_in*)saddr)->sin_port = htons(mntport);
4196	else
4197	((struct sockaddr_in6*)saddr)->sin6_port = htons(mntport);
4198
4199	while (!mntport) {
4200	error = nfs_portmap_lookup(nmp, ctx, saddr, NULL, RPCPROG_MNT, mntvers, mntproto, timeo);
4201	nfsmout_if(error);
4202	if (saddr->sa_family == AF_INET)
4203	mntport = ntohs(((struct sockaddr_in*)saddr)->sin_port);
4204	else
4205	mntport = ntohs(((struct sockaddr_in6*)saddr)->sin6_port);
4206	/ if not found and mntvers > VER1, then retry with VER1 /
4207	if (!mntport) {
4208	if (mntvers > RPCMNT_VER1) {
4209	mntvers = RPCMNT_VER1;
4210	} else if (mntproto == IPPROTO_TCP) {
4211	mntproto = IPPROTO_UDP;
4212	mntvers = (nmp->nm_vers == NFS_VER2) ? RPCMNT_VER1 : RPCMNT_VER3;
4213	} else {
4214	break;
4215	}
4216	bcopy(nmp->nm_saddr, saddr, min(sizeof(ss), nmp->nm_saddr->sa_len));
4217	}
4218	}
4219	nfsmout_if(!mntport);
4220
4221	/ MOUNT protocol UNMOUNT request /
4222	path = &vfs_statfs(nmp->nm_mountp)->f_mntfromname[`0`];
4223	while (path && (path != `'/'`))
4224	path++;
4225	slen = strlen(path);
4226	nfsm_chain_build_alloc_init(error, &nmreq, NFSX_UNSIGNED + nfsm_rndup(slen));
4227	nfsm_chain_add_name(error, &nmreq, path, slen, nmp);
4228	nfsm_chain_build_done(error, &nmreq);
4229	nfsmout_if(error);
4230	error = nfsm_rpchead2(nmp, (mntproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM,
4231	RPCPROG_MNT, RPCMNT_VER1, RPCMNT_UMOUNT,
4232	RPCAUTH_SYS, cred, NULL, nmreq.nmc_mhead, &xid, &mreq);
4233	nfsmout_if(error);
4234	nmreq.nmc_mhead = NULL;
4235	error = nfs_aux_request(nmp, thd, saddr, NULL,
4236	((mntproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM),
4237	mreq, R_XID32(xid), `1`, timeo, &nmrep);
4238	nfsmout:
4239	nfsm_chain_cleanup(&nmreq);
4240	nfsm_chain_cleanup(&nmrep);
4241	}
4242
4243	/*
4244	* unmount system call
4245	*/
4246	int
4247	nfs_vfs_unmount(
4248	mount_t mp,
4249	int mntflags,
4250	__unused vfs_context_t ctx)
4251	{
4252	struct nfsmount *nmp;
4253	vnode_t vp;
4254	int error, flags = `0`;
4255	struct timespec ts = { `1`, `0` };
4256
4257	nmp = VFSTONFS(mp);
4258	lck_mtx_lock(&nmp->nm_lock);
4259	/*
4260	* Set the flag indicating that an unmount attempt is in progress.
4261	*/
4262	nmp->nm_state \|= NFSSTA_UNMOUNTING;
4263	/*
4264	* During a force unmount we want to...
4265	* Mark that we are doing a force unmount.
4266	* Make the mountpoint soft.
4267	*/
4268	if (mntflags & MNT_FORCE) {
4269	flags \|= FORCECLOSE;
4270	nmp->nm_state \|= NFSSTA_FORCE;
4271	NFS_BITMAP_SET(nmp->nm_flags, NFS_MFLAG_SOFT);
4272	}
4273	/*
4274	* Wait for any in-progress monitored node scan to complete.
4275	*/
4276	while (nmp->nm_state & NFSSTA_MONITOR_SCAN)
4277	msleep(&nmp->nm_state, &nmp->nm_lock, PZERO-`1`, "nfswaitmonscan", &ts);
4278	/*
4279	* Goes something like this..
4280	* - Call vflush() to clear out vnodes for this file system,
4281	* except for the swap files. Deal with them in 2nd pass.
4282	* - Decrement reference on the vnode representing remote root.
4283	* - Clean up the NFS mount structure.
4284	*/
4285	vp = NFSTOV(nmp->nm_dnp);
4286	lck_mtx_unlock(&nmp->nm_lock);
4287
4288	/*
4289	* vflush will check for busy vnodes on mountpoint.
4290	* Will do the right thing for MNT_FORCE. That is, we should
4291	* not get EBUSY back.
4292	*/
4293	error = vflush(mp, vp, SKIPSWAP \| flags);
4294	if (mntflags & MNT_FORCE) {
4295	error = vflush(mp, NULLVP, flags); / locks vp in the process /
4296	} else {
4297	if (vnode_isinuse(vp, `1`))
4298	error = EBUSY;
4299	else
4300	error = vflush(mp, vp, flags);
4301	}
4302	if (error) {
4303	lck_mtx_lock(&nmp->nm_lock);
4304	nmp->nm_state &= ~NFSSTA_UNMOUNTING;
4305	lck_mtx_unlock(&nmp->nm_lock);
4306	return (error);
4307	}
4308
4309	lck_mtx_lock(&nmp->nm_lock);
4310	nmp->nm_dnp = NULL;
4311	lck_mtx_unlock(&nmp->nm_lock);
4312
4313	/*
4314	* Release the root vnode reference held by mountnfs()
4315	*/
4316	error = vnode_get(vp);
4317	vnode_rele(vp);
4318	if (!error)
4319	vnode_put(vp);
4320
4321	vflush(mp, NULLVP, FORCECLOSE);
4322
4323	/ Wait for all other references to be released and free the mount /
4324	nfs_mount_drain_and_cleanup(nmp);
4325
4326	return (`0`);
4327	}
4328
4329	/*
4330	* cleanup/destroy NFS fs locations structure
4331	*/
4332	void
4333	nfs_fs_locations_cleanup(struct nfs_fs_locations *nfslsp)
4334	{
4335	struct nfs_fs_location *fsl;
4336	struct nfs_fs_server *fss;
4337	struct nfs_fs_path *fsp;
4338	uint32_t loc, serv, addr, comp;
4339
4340	/ free up fs locations /
4341	if (!nfslsp->nl_numlocs \|\| !nfslsp->nl_locations)
4342	return;
4343
4344	for (loc = `0`; loc < nfslsp->nl_numlocs; loc++) {
4345	fsl = nfslsp->nl_locations[loc];
4346	if (!fsl)
4347	continue;
4348	if ((fsl->nl_servcount > `0`) && fsl->nl_servers) {
4349	for (serv = `0`; serv < fsl->nl_servcount; serv++) {
4350	fss = fsl->nl_servers[serv];
4351	if (!fss)
4352	continue;
4353	if ((fss->ns_addrcount > `0`) && fss->ns_addresses) {
4354	for (addr = `0`; addr < fss->ns_addrcount; addr++)
4355	FREE(fss->ns_addresses[addr], M_TEMP);
4356	FREE(fss->ns_addresses, M_TEMP);
4357	}
4358	FREE(fss->ns_name, M_TEMP);
4359	FREE(fss, M_TEMP);
4360	}
4361	FREE(fsl->nl_servers, M_TEMP);
4362	}
4363	fsp = &fsl->nl_path;
4364	if (fsp->np_compcount && fsp->np_components) {
4365	for (comp = `0`; comp < fsp->np_compcount; comp++)
4366	if (fsp->np_components[comp])
4367	FREE(fsp->np_components[comp], M_TEMP);
4368	FREE(fsp->np_components, M_TEMP);
4369	}
4370	FREE(fsl, M_TEMP);
4371	}
4372	FREE(nfslsp->nl_locations, M_TEMP);
4373	nfslsp->nl_numlocs = `0`;
4374	nfslsp->nl_locations = NULL;
4375	}
4376
4377	void
4378	nfs_mount_rele(struct nfsmount *nmp)
4379	{
4380	int wup = `0`;
4381
4382	lck_mtx_lock(&nmp->nm_lock);
4383	if (nmp->nm_ref < `1`)
4384	panic("nfs zombie mount underflow\n");
4385	nmp->nm_ref--;
4386	if (nmp->nm_ref == `0`)
4387	wup = nmp->nm_state & NFSSTA_MOUNT_DRAIN;
4388	lck_mtx_unlock(&nmp->nm_lock);
4389	if (wup)
4390	wakeup(&nmp->nm_ref);
4391	}
4392
4393	void
4394	nfs_mount_drain_and_cleanup(struct nfsmount *nmp)
4395	{
4396	lck_mtx_lock(&nmp->nm_lock);
4397	nmp->nm_state \|= NFSSTA_MOUNT_DRAIN;
4398	while (nmp->nm_ref > `0`) {
4399	msleep(&nmp->nm_ref, &nmp->nm_lock, PZERO-`1`, "nfs_mount_drain", NULL);
4400	}
4401	assert(nmp->nm_ref == `0`);
4402	lck_mtx_unlock(&nmp->nm_lock);
4403	nfs_mount_cleanup(nmp);
4404	}
4405
4406	/*
4407	* nfs_mount_zombie
4408	*/
4409	void
4410	nfs_mount_zombie(struct nfsmount nmp, int* nm_state_flags)
4411	{
4412	struct nfsreq req, treq;
4413	struct nfs_reqqhead iodq, resendq;
4414	struct timespec ts = { `1`, `0` };
4415	struct nfs_open_owner noop, nextnoop;
4416	nfsnode_t np;
4417	int docallback;
4418
4419	lck_mtx_lock(&nmp->nm_lock);
4420	nmp->nm_state \|= nm_state_flags;
4421	nmp->nm_ref++;
4422	lck_mtx_unlock(&nmp->nm_lock);
4423
4424	/ stop callbacks /
4425	if ((nmp->nm_vers >= NFS_VER4) && !NMFLAG(nmp, NOCALLBACK) && nmp->nm_cbid)
4426	nfs4_mount_callback_shutdown(nmp);
4427
4428	/ Destroy any RPCSEC_GSS contexts /
4429	nfs_gss_clnt_ctx_unmount(nmp);
4430
4431	/ mark the socket for termination /
4432	lck_mtx_lock(&nmp->nm_lock);
4433	nmp->nm_sockflags \|= NMSOCK_UNMOUNT;
4434
4435	/ Have the socket thread send the unmount RPC, if requested/appropriate. /
4436	if ((nmp->nm_vers < NFS_VER4) && (nmp->nm_state & NFSSTA_MOUNTED) &&
4437	!(nmp->nm_state & (NFSSTA_FORCE\|NFSSTA_DEAD)) && NMFLAG(nmp, CALLUMNT))
4438	nfs_mount_sock_thread_wake(nmp);
4439
4440	/ wait for the socket thread to terminate /
4441	while (nmp->nm_sockthd && current_thread() != nmp->nm_sockthd) {
4442	wakeup(&nmp->nm_sockthd);
4443	msleep(&nmp->nm_sockthd, &nmp->nm_lock, PZERO-`1`, "nfswaitsockthd", &ts);
4444	}
4445	lck_mtx_unlock(&nmp->nm_lock);
4446
4447	/ tear down the socket /
4448	nfs_disconnect(nmp);
4449
4450	lck_mtx_lock(&nmp->nm_lock);
4451
4452	if ((nmp->nm_vers >= NFS_VER4) && !NMFLAG(nmp, NOCALLBACK) && nmp->nm_cbid) {
4453	/ clear out any pending delegation return requests /
4454	while ((np = TAILQ_FIRST(&nmp->nm_dreturnq))) {
4455	TAILQ_REMOVE(&nmp->nm_dreturnq, np, n_dreturn);
4456	np->n_dreturn.tqe_next = NFSNOLIST;
4457	}
4458	}
4459
4460	/ cancel any renew timer /
4461	if ((nmp->nm_vers >= NFS_VER4) && nmp->nm_renew_timer) {
4462	thread_call_cancel(nmp->nm_renew_timer);
4463	thread_call_free(nmp->nm_renew_timer);
4464	nmp->nm_renew_timer = NULL;
4465	}
4466
4467	lck_mtx_unlock(&nmp->nm_lock);
4468
4469	if (nmp->nm_state & NFSSTA_MOUNTED)
4470	switch (nmp->nm_lockmode) {
4471	case NFS_LOCK_MODE_DISABLED:
4472	case NFS_LOCK_MODE_LOCAL:
4473	break;
4474	case NFS_LOCK_MODE_ENABLED:
4475	default:
4476	if (nmp->nm_vers <= NFS_VER3) {
4477	nfs_lockd_mount_unregister(nmp);
4478	nmp->nm_lockmode = NFS_LOCK_MODE_DISABLED;
4479	}
4480	break;
4481	}
4482
4483	if ((nmp->nm_vers >= NFS_VER4) && nmp->nm_longid) {
4484	/ remove/deallocate the client ID data /
4485	lck_mtx_lock(nfs_global_mutex);
4486	TAILQ_REMOVE(&nfsclientids, nmp->nm_longid, nci_link);
4487	if (nmp->nm_longid->nci_id)
4488	FREE(nmp->nm_longid->nci_id, M_TEMP);
4489	FREE(nmp->nm_longid, M_TEMP);
4490	nmp->nm_longid = NULL;
4491	lck_mtx_unlock(nfs_global_mutex);
4492	}
4493
4494	/*
4495	* Be sure all requests for this mount are completed
4496	* and removed from the resend queue.
4497	*/
4498	TAILQ_INIT(&resendq);
4499	lck_mtx_lock(nfs_request_mutex);
4500	TAILQ_FOREACH(req, &nfs_reqq, r_chain) {
4501	if (req->r_nmp == nmp) {
4502	lck_mtx_lock(&req->r_mtx);
4503	if (!req->r_error && req->r_nmrep.nmc_mhead == NULL)
4504	req->r_error = EIO;
4505	if (req->r_flags & R_RESENDQ) {
4506	lck_mtx_lock(&nmp->nm_lock);
4507	req->r_flags &= ~R_RESENDQ;
4508	if (req->r_rchain.tqe_next != NFSREQNOLIST) {
4509	TAILQ_REMOVE(&nmp->nm_resendq, req, r_rchain);
4510	/*
4511	* Queue up the request so that we can unreference them
4512	* with out holding nfs_request_mutex
4513	*/
4514	TAILQ_INSERT_TAIL(&resendq, req, r_rchain);
4515	}
4516	lck_mtx_unlock(&nmp->nm_lock);
4517	}
4518	wakeup(req);
4519	lck_mtx_unlock(&req->r_mtx);
4520	}
4521	}
4522	lck_mtx_unlock(nfs_request_mutex);
4523
4524	/ Since we've drop the request mutex we can now safely unreference the request /
4525	TAILQ_FOREACH_SAFE(req, &resendq, r_rchain, treq) {
4526	TAILQ_REMOVE(&resendq, req, r_rchain);
4527	/ Make sure we don't try and remove again in nfs_request_destroy /
4528	req->r_rchain.tqe_next = NFSREQNOLIST;
4529	nfs_request_rele(req);
4530	}
4531
4532	/*
4533	* Now handle and outstanding async requests. We need to walk the
4534	* request queue again this time with the nfsiod_mutex held. No
4535	* other iods can grab our requests until we've put them on our own
4536	* local iod queue for processing.
4537	*/
4538	TAILQ_INIT(&iodq);
4539	lck_mtx_lock(nfs_request_mutex);
4540	lck_mtx_lock(nfsiod_mutex);
4541	TAILQ_FOREACH(req, &nfs_reqq, r_chain) {
4542	if (req->r_nmp == nmp) {
4543	lck_mtx_lock(&req->r_mtx);
4544	if (req->r_callback.rcb_func
4545	&& !(req->r_flags & R_WAITSENT) && !(req->r_flags & R_IOD)) {
4546	/*
4547	* Since R_IOD is not set then we need to handle it. If
4548	* we're not on a list add it to our iod queue. Otherwise
4549	* we must already be on nm_iodq which is added to our
4550	* local queue below.
4551	* %%% We should really keep a back pointer to our iod queue
4552	* that we're on.
4553	*/
4554	req->r_flags \|= R_IOD;
4555	if (req->r_achain.tqe_next == NFSREQNOLIST) {
4556	TAILQ_INSERT_TAIL(&iodq, req, r_achain);
4557	}
4558	}
4559	lck_mtx_unlock(&req->r_mtx);
4560	}
4561	}
4562
4563	/ finish any async I/O RPCs queued up /
4564	if (nmp->nm_iodlink.tqe_next != NFSNOLIST)
4565	TAILQ_REMOVE(&nfsiodmounts, nmp, nm_iodlink);
4566	TAILQ_CONCAT(&iodq, &nmp->nm_iodq, r_achain);
4567	lck_mtx_unlock(nfsiod_mutex);
4568	lck_mtx_unlock(nfs_request_mutex);
4569
4570	TAILQ_FOREACH_SAFE(req, &iodq, r_achain, treq) {
4571	TAILQ_REMOVE(&iodq, req, r_achain);
4572	req->r_achain.tqe_next = NFSREQNOLIST;
4573	lck_mtx_lock(&req->r_mtx);
4574	docallback = !(req->r_flags & R_WAITSENT);
4575	lck_mtx_unlock(&req->r_mtx);
4576	if (docallback)
4577	req->r_callback.rcb_func(req);
4578	}
4579
4580	/ clean up common state /
4581	lck_mtx_lock(&nmp->nm_lock);
4582	while ((np = LIST_FIRST(&nmp->nm_monlist))) {
4583	LIST_REMOVE(np, n_monlink);
4584	np->n_monlink.le_next = NFSNOLIST;
4585	}
4586	TAILQ_FOREACH_SAFE(noop, &nmp->nm_open_owners, noo_link, nextnoop) {
4587	TAILQ_REMOVE(&nmp->nm_open_owners, noop, noo_link);
4588	noop->noo_flags &= ~NFS_OPEN_OWNER_LINK;
4589	if (noop->noo_refcnt)
4590	continue;
4591	nfs_open_owner_destroy(noop);
4592	}
4593	lck_mtx_unlock(&nmp->nm_lock);
4594
4595	/ clean up NFSv4 state /
4596	if (nmp->nm_vers >= NFS_VER4) {
4597	lck_mtx_lock(&nmp->nm_lock);
4598	while ((np = TAILQ_FIRST(&nmp->nm_delegations))) {
4599	TAILQ_REMOVE(&nmp->nm_delegations, np, n_dlink);
4600	np->n_dlink.tqe_next = NFSNOLIST;
4601	}
4602	lck_mtx_unlock(&nmp->nm_lock);
4603	}
4604
4605	nfs_mount_rele(nmp);
4606	}
4607
4608	/*
4609	* cleanup/destroy an nfsmount
4610	*/
4611	void
4612	nfs_mount_cleanup(struct nfsmount *nmp)
4613	{
4614	if (!nmp)
4615	return;
4616
4617	nfs_mount_zombie(nmp, `0`);
4618
4619	NFS_VFS_DBG("Unmounting %s from %s\n",
4620	vfs_statfs(nmp->nm_mountp)->f_mntfromname,
4621	vfs_statfs(nmp->nm_mountp)->f_mntonname);
4622	NFS_VFS_DBG("nfs state = 0x%8.8x\n", nmp->nm_state);
4623	NFS_VFS_DBG("nfs socket flags = 0x%8.8x\n", nmp->nm_sockflags);
4624	NFS_VFS_DBG("nfs mount ref count is %d\n", nmp->nm_ref);
4625	NFS_VFS_DBG("mount ref count is %d\n", nmp->nm_mountp->mnt_count);
4626
4627	if (nmp->nm_mountp)
4628	vfs_setfsprivate(nmp->nm_mountp, NULL);
4629
4630	lck_mtx_lock(&nmp->nm_lock);
4631	if (nmp->nm_ref)
4632	panic("Some one has grabbed a ref %d state flags = 0x%8.8x\n", nmp->nm_ref, nmp->nm_state);
4633
4634	if (nmp->nm_saddr)
4635	FREE(nmp->nm_saddr, M_SONAME);
4636	if ((nmp->nm_vers < NFS_VER4) && nmp->nm_rqsaddr)
4637	FREE(nmp->nm_rqsaddr, M_SONAME);
4638
4639	if (IS_VALID_CRED(nmp->nm_mcred))
4640	kauth_cred_unref(&nmp->nm_mcred);
4641
4642	nfs_fs_locations_cleanup(&nmp->nm_locations);
4643
4644	if (nmp->nm_realm)
4645	FREE(nmp->nm_realm, M_TEMP);
4646	if (nmp->nm_principal)
4647	FREE(nmp->nm_principal, M_TEMP);
4648	if (nmp->nm_sprinc)
4649	FREE(nmp->nm_sprinc, M_TEMP);
4650
4651	if (nmp->nm_args)
4652	xb_free(nmp->nm_args);
4653
4654	lck_mtx_unlock(&nmp->nm_lock);
4655
4656	lck_mtx_destroy(&nmp->nm_lock, nfs_mount_grp);
4657	if (nmp->nm_fh)
4658	FREE(nmp->nm_fh, M_TEMP);
4659	FREE_ZONE((caddr_t)nmp, sizeof (struct nfsmount), M_NFSMNT);
4660	}
4661
4662	/*
4663	* Return root of a filesystem
4664	*/
4665	int
4666	nfs_vfs_root(mount_t mp, vnode_t *vpp, __unused vfs_context_t ctx)
4667	{
4668	vnode_t vp;
4669	struct nfsmount *nmp;
4670	int error;
4671	u_int32_t vpid;
4672
4673	nmp = VFSTONFS(mp);
4674	if (!nmp \|\| !nmp->nm_dnp)
4675	return (ENXIO);
4676	vp = NFSTOV(nmp->nm_dnp);
4677	vpid = vnode_vid(vp);
4678	while ((error = vnode_getwithvid(vp, vpid))) {
4679	/ vnode_get() may return ENOENT if the dir changes. /
4680	/ If that happens, just try it again, else return the error. /
4681	if ((error != ENOENT) \|\| (vnode_vid(vp) == vpid))
4682	return (error);
4683	vpid = vnode_vid(vp);
4684	}
4685	*vpp = vp;
4686	return (`0`);
4687	}
4688
4689	/*
4690	* Do operations associated with quotas
4691	*/
4692	#if !QUOTA
4693	int
4694	nfs_vfs_quotactl(
4695	__unused mount_t mp,
4696	__unused int cmds,
4697	__unused uid_t uid,
4698	__unused caddr_t datap,
4699	__unused vfs_context_t context)
4700	{
4701	return (ENOTSUP);
4702	}
4703	#else
4704
4705	static int
4706	nfs_sa_getport(struct sockaddr sa, int* *error)
4707	{
4708	int port = `0`;
4709
4710	if (sa->sa_family == AF_INET6)
4711	port = ntohs(((struct sockaddr_in6*)sa)->sin6_port);
4712	else if (sa->sa_family == AF_INET)
4713	port = ntohs(((struct sockaddr_in*)sa)->sin_port);
4714	else if (error)
4715	*error = EIO;
4716
4717	return port;
4718	}
4719
4720	static void
4721	nfs_sa_setport(struct sockaddr sa, int* port)
4722	{
4723	if (sa->sa_family == AF_INET6)
4724	((struct sockaddr_in6*)sa)->sin6_port = htons(port);
4725	else if (sa->sa_family == AF_INET)
4726	((struct sockaddr_in*)sa)->sin_port = htons(port);
4727	}
4728
4729	int
4730	nfs3_getquota(struct nfsmount nmp, vfs_context_t ctx, uid_t id, int* type, struct dqblk *dqb)
4731	{
4732	int error = `0`, slen, timeo;
4733	int rqport = `0`, rqproto, rqvers = (type == GRPQUOTA) ? RPCRQUOTA_EXT_VER : RPCRQUOTA_VER;
4734	thread_t thd = vfs_context_thread(ctx);
4735	kauth_cred_t cred = vfs_context_ucred(ctx);
4736	char *path;
4737	uint64_t xid = `0`;
4738	struct nfsm_chain nmreq, nmrep;
4739	mbuf_t mreq;
4740	uint32_t val = `0`, bsize = `0`;
4741	struct sockaddr *rqsaddr;
4742	struct timeval now;
4743	struct timespec ts = { `1`, `0` };
4744
4745	if (!nmp->nm_saddr)
4746	return (ENXIO);
4747
4748	if (NMFLAG(nmp, NOQUOTA))
4749	return (ENOTSUP);
4750
4751	/*
4752	* Allocate an address for rquotad if needed
4753	*/
4754	if (!nmp->nm_rqsaddr) {
4755	int need_free = `0`;
4756
4757	MALLOC(rqsaddr, struct sockaddr , sizeof(struct* sockaddr_storage), M_SONAME, M_WAITOK\|M_ZERO);
4758	bcopy(nmp->nm_saddr, rqsaddr, min(sizeof(struct sockaddr_storage), nmp->nm_saddr->sa_len));
4759	/ Set the port to zero, will call rpcbind to get the port below /
4760	nfs_sa_setport(rqsaddr, `0`);
4761	microuptime(&now);
4762
4763	lck_mtx_lock(&nmp->nm_lock);
4764	if (!nmp->nm_rqsaddr) {
4765	nmp->nm_rqsaddr = rqsaddr;
4766	nmp->nm_rqsaddrstamp = now.tv_sec;
4767	} else {
4768	need_free = `1`;
4769	}
4770	lck_mtx_unlock(&nmp->nm_lock);
4771	if (need_free)
4772	FREE(rqsaddr, M_SONAME);
4773	}
4774
4775	timeo = NMFLAG(nmp, SOFT) ? `10` : `60`;
4776	rqproto = IPPROTO_UDP; / XXX should prefer TCP if mount is TCP /
4777
4778	/ check if we have a recently cached rquota port /
4779	microuptime(&now);
4780	lck_mtx_lock(&nmp->nm_lock);
4781	rqsaddr = nmp->nm_rqsaddr;
4782	rqport = nfs_sa_getport(rqsaddr, &error);
4783	while (!error && (!rqport \|\| ((nmp->nm_rqsaddrstamp + `60`) <= (uint32_t)now.tv_sec))) {
4784	error = nfs_sigintr(nmp, NULL, thd, `1`);
4785	if (error) {
4786	lck_mtx_unlock(&nmp->nm_lock);
4787	return (error);
4788	}
4789	if (nmp->nm_state & NFSSTA_RQUOTAINPROG) {
4790	nmp->nm_state \|= NFSSTA_WANTRQUOTA;
4791	msleep(&nmp->nm_rqsaddr, &nmp->nm_lock, PZERO-`1`, "nfswaitrquotaaddr", &ts);
4792	rqport = nfs_sa_getport(rqsaddr, &error);
4793	continue;
4794	}
4795	nmp->nm_state \|= NFSSTA_RQUOTAINPROG;
4796	lck_mtx_unlock(&nmp->nm_lock);
4797
4798	/ send portmap request to get rquota port /
4799	error = nfs_portmap_lookup(nmp, ctx, rqsaddr, NULL, RPCPROG_RQUOTA, rqvers, rqproto, timeo);
4800	if (error)
4801	goto out;
4802	rqport = nfs_sa_getport(rqsaddr, &error);
4803	if (error)
4804	goto out;
4805
4806	if (!rqport) {
4807	/*
4808	* We overload PMAPPORT for the port if rquotad is not
4809	* currently registered or up at the server. In the
4810	* while loop above, port will be set and we will defer
4811	* for a bit. Perhaps the service isn't online yet.
4812	*
4813	* Note that precludes using indirect, but we're not doing
4814	* that here.
4815	*/
4816	rqport = PMAPPORT;
4817	nfs_sa_setport(rqsaddr, rqport);
4818	}
4819	microuptime(&now);
4820	nmp->nm_rqsaddrstamp = now.tv_sec;
4821	out:
4822	lck_mtx_lock(&nmp->nm_lock);
4823	nmp->nm_state &= ~NFSSTA_RQUOTAINPROG;
4824	if (nmp->nm_state & NFSSTA_WANTRQUOTA) {
4825	nmp->nm_state &= ~NFSSTA_WANTRQUOTA;
4826	wakeup(&nmp->nm_rqsaddr);
4827	}
4828	}
4829	lck_mtx_unlock(&nmp->nm_lock);
4830	if (error)
4831	return (error);
4832
4833	/ Using PMAPPORT for unavailabe rquota service /
4834	if (rqport == PMAPPORT)
4835	return (ENOTSUP);
4836
4837	/ rquota request /
4838	nfsm_chain_null(&nmreq);
4839	nfsm_chain_null(&nmrep);
4840	path = &vfs_statfs(nmp->nm_mountp)->f_mntfromname[`0`];
4841	while (path && (path != `'/'`))
4842	path++;
4843	slen = strlen(path);
4844	nfsm_chain_build_alloc_init(error, &nmreq, `3` * NFSX_UNSIGNED + nfsm_rndup(slen));
4845	nfsm_chain_add_name(error, &nmreq, path, slen, nmp);
4846	if (type == GRPQUOTA)
4847	nfsm_chain_add_32(error, &nmreq, type);
4848	nfsm_chain_add_32(error, &nmreq, id);
4849	nfsm_chain_build_done(error, &nmreq);
4850	nfsmout_if(error);
4851	error = nfsm_rpchead2(nmp, (rqproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM,
4852	RPCPROG_RQUOTA, rqvers, RPCRQUOTA_GET,
4853	RPCAUTH_SYS, cred, NULL, nmreq.nmc_mhead, &xid, &mreq);
4854	nfsmout_if(error);
4855	nmreq.nmc_mhead = NULL;
4856	error = nfs_aux_request(nmp, thd, rqsaddr, NULL,
4857	(rqproto == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM,
4858	mreq, R_XID32(xid), `0`, timeo, &nmrep);
4859	nfsmout_if(error);
4860
4861	/ parse rquota response /
4862	nfsm_chain_get_32(error, &nmrep, val);
4863	if (!error && (val != RQUOTA_STAT_OK)) {
4864	if (val == RQUOTA_STAT_NOQUOTA)
4865	error = ENOENT;
4866	else if (val == RQUOTA_STAT_EPERM)
4867	error = EPERM;
4868	else
4869	error = EIO;
4870	}
4871	nfsm_chain_get_32(error, &nmrep, bsize);
4872	nfsm_chain_adv(error, &nmrep, NFSX_UNSIGNED);
4873	nfsm_chain_get_32(error, &nmrep, val);
4874	nfsmout_if(error);
4875	dqb->dqb_bhardlimit = (uint64_t)val * bsize;
4876	nfsm_chain_get_32(error, &nmrep, val);
4877	nfsmout_if(error);
4878	dqb->dqb_bsoftlimit = (uint64_t)val * bsize;
4879	nfsm_chain_get_32(error, &nmrep, val);
4880	nfsmout_if(error);
4881	dqb->dqb_curbytes = (uint64_t)val * bsize;
4882	nfsm_chain_get_32(error, &nmrep, dqb->dqb_ihardlimit);
4883	nfsm_chain_get_32(error, &nmrep, dqb->dqb_isoftlimit);
4884	nfsm_chain_get_32(error, &nmrep, dqb->dqb_curinodes);
4885	nfsm_chain_get_32(error, &nmrep, dqb->dqb_btime);
4886	nfsm_chain_get_32(error, &nmrep, dqb->dqb_itime);
4887	nfsmout_if(error);
4888	dqb->dqb_id = id;
4889	nfsmout:
4890	nfsm_chain_cleanup(&nmreq);
4891	nfsm_chain_cleanup(&nmrep);
4892	return (error);
4893	}
4894
4895	int
4896	nfs4_getquota(struct nfsmount nmp, vfs_context_t ctx, uid_t id, int* type, struct dqblk *dqb)
4897	{
4898	nfsnode_t np;
4899	int error = `0`, status, nfsvers, numops;
4900	u_int64_t xid;
4901	struct nfsm_chain nmreq, nmrep;
4902	uint32_t bitmap[NFS_ATTR_BITMAP_LEN];
4903	thread_t thd = vfs_context_thread(ctx);
4904	kauth_cred_t cred = vfs_context_ucred(ctx);
4905	struct nfsreq_secinfo_args si;
4906
4907	if (type != USRQUOTA) / NFSv4 only supports user quotas /
4908	return (ENOTSUP);
4909
4910	/ first check that the server supports any of the quota attributes /
4911	if (!NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_AVAIL_HARD) &&
4912	!NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_AVAIL_SOFT) &&
4913	!NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_USED))
4914	return (ENOTSUP);
4915
4916	/*
4917	* The credential passed to the server needs to have
4918	* an effective uid that matches the given uid.
4919	*/
4920	if (id != kauth_cred_getuid(cred)) {
4921	struct posix_cred temp_pcred;
4922	posix_cred_t pcred = posix_cred_get(cred);
4923	bzero(&temp_pcred, sizeof(temp_pcred));
4924	temp_pcred.cr_uid = id;
4925	temp_pcred.cr_ngroups = pcred->cr_ngroups;
4926	bcopy(pcred->cr_groups, temp_pcred.cr_groups, sizeof(temp_pcred.cr_groups));
4927	cred = posix_cred_create(&temp_pcred);
4928	if (!IS_VALID_CRED(cred))
4929	return (ENOMEM);
4930	} else {
4931	kauth_cred_ref(cred);
4932	}
4933
4934	nfsvers = nmp->nm_vers;
4935	np = nmp->nm_dnp;
4936	if (!np)
4937	error = ENXIO;
4938	if (error \|\| ((error = vnode_get(NFSTOV(np))))) {
4939	kauth_cred_unref(&cred);
4940	return(error);
4941	}
4942
4943	NFSREQ_SECINFO_SET(&si, np, NULL, `0`, NULL, `0`);
4944	nfsm_chain_null(&nmreq);
4945	nfsm_chain_null(&nmrep);
4946
4947	// PUTFH + GETATTR
4948	numops = `2`;
4949	nfsm_chain_build_alloc_init(error, &nmreq, `15` * NFSX_UNSIGNED);
4950	nfsm_chain_add_compound_header(error, &nmreq, "quota", nmp->nm_minor_vers, numops);
4951	numops--;
4952	nfsm_chain_add_32(error, &nmreq, NFS_OP_PUTFH);
4953	nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
4954	numops--;
4955	nfsm_chain_add_32(error, &nmreq, NFS_OP_GETATTR);
4956	NFS_CLEAR_ATTRIBUTES(bitmap);
4957	NFS_BITMAP_SET(bitmap, NFS_FATTR_QUOTA_AVAIL_HARD);
4958	NFS_BITMAP_SET(bitmap, NFS_FATTR_QUOTA_AVAIL_SOFT);
4959	NFS_BITMAP_SET(bitmap, NFS_FATTR_QUOTA_USED);
4960	nfsm_chain_add_bitmap_supported(error, &nmreq, bitmap, nmp, NULL);
4961	nfsm_chain_build_done(error, &nmreq);
4962	nfsm_assert(error, (numops == `0`), EPROTO);
4963	nfsmout_if(error);
4964	error = nfs_request2(np, NULL, &nmreq, NFSPROC4_COMPOUND, thd, cred, &si, `0`, &nmrep, &xid, &status);
4965	nfsm_chain_skip_tag(error, &nmrep);
4966	nfsm_chain_get_32(error, &nmrep, numops);
4967	nfsm_chain_op_check(error, &nmrep, NFS_OP_PUTFH);
4968	nfsm_chain_op_check(error, &nmrep, NFS_OP_GETATTR);
4969	nfsm_assert(error, NFSTONMP(np), ENXIO);
4970	nfsmout_if(error);
4971	error = nfs4_parsefattr(&nmrep, NULL, NULL, NULL, dqb, NULL);
4972	nfsmout_if(error);
4973	nfsm_assert(error, NFSTONMP(np), ENXIO);
4974	nfsmout:
4975	nfsm_chain_cleanup(&nmreq);
4976	nfsm_chain_cleanup(&nmrep);
4977	vnode_put(NFSTOV(np));
4978	kauth_cred_unref(&cred);
4979	return (error);
4980	}
4981
4982	int
4983	nfs_vfs_quotactl(mount_t mp, int cmds, uid_t uid, caddr_t datap, vfs_context_t ctx)
4984	{
4985	struct nfsmount *nmp;
4986	int cmd, type, error, nfsvers;
4987	uid_t euid = kauth_cred_getuid(vfs_context_ucred(ctx));
4988	struct dqblk dqb = (struct* dqblk*)datap;
4989
4990	nmp = VFSTONFS(mp);
4991	if (nfs_mount_gone(nmp))
4992	return (ENXIO);
4993	nfsvers = nmp->nm_vers;
4994
4995	if (uid == ~`0U`)
4996	uid = euid;
4997
4998	/ we can only support Q_GETQUOTA /
4999	cmd = cmds >> SUBCMDSHIFT;
5000	switch (cmd) {
5001	case Q_GETQUOTA:
5002	break;
5003	case Q_QUOTAON:
5004	case Q_QUOTAOFF:
5005	case Q_SETQUOTA:
5006	case Q_SETUSE:
5007	case Q_SYNC:
5008	case Q_QUOTASTAT:
5009	return (ENOTSUP);
5010	default:
5011	return (EINVAL);
5012	}
5013
5014	type = cmds & SUBCMDMASK;
5015	if ((u_int)type >= MAXQUOTAS)
5016	return (EINVAL);
5017	if ((uid != euid) && ((error = vfs_context_suser(ctx))))
5018	return (error);
5019
5020	if (vfs_busy(mp, LK_NOWAIT))
5021	return (`0`);
5022	bzero(dqb, sizeof(*dqb));
5023	error = nmp->nm_funcs->nf_getquota(nmp, ctx, uid, type, dqb);
5024	vfs_unbusy(mp);
5025	return (error);
5026	}
5027	#endif
5028
5029	/*
5030	* Flush out the buffer cache
5031	*/
5032	int nfs_sync_callout(vnode_t, void *);
5033
5034	struct nfs_sync_cargs {
5035	vfs_context_t ctx;
5036	int waitfor;
5037	int error;
5038	};
5039
5040	int
5041	nfs_sync_callout(vnode_t vp, void *arg)
5042	{
5043	struct nfs_sync_cargs cargs = (struct* nfs_sync_cargs*)arg;
5044	nfsnode_t np = VTONFS(vp);
5045	int error;
5046
5047	if (np->n_flag & NREVOKE) {
5048	vn_revoke(vp, REVOKEALL, cargs->ctx);
5049	return (VNODE_RETURNED);
5050	}
5051
5052	if (LIST_EMPTY(&np->n_dirtyblkhd))
5053	return (VNODE_RETURNED);
5054	if (np->n_wrbusy > `0`)
5055	return (VNODE_RETURNED);
5056	if (np->n_bflag & (NBFLUSHINPROG\|NBINVALINPROG))
5057	return (VNODE_RETURNED);
5058
5059	error = nfs_flush(np, cargs->waitfor, vfs_context_thread(cargs->ctx), `0`);
5060	if (error)
5061	cargs->error = error;
5062
5063	return (VNODE_RETURNED);
5064	}
5065
5066	int
5067	nfs_vfs_sync(mount_t mp, int waitfor, vfs_context_t ctx)
5068	{
5069	struct nfs_sync_cargs cargs;
5070
5071	cargs.waitfor = waitfor;
5072	cargs.ctx = ctx;
5073	cargs.error = `0`;
5074
5075	vnode_iterate(mp, `0`, nfs_sync_callout, &cargs);
5076
5077	return (cargs.error);
5078	}
5079
5080	/*
5081	* NFS flat namespace lookup.
5082	* Currently unsupported.
5083	*/
5084	/ARGSUSED/
5085	int
5086	nfs_vfs_vget(
5087	__unused mount_t mp,
5088	__unused ino64_t ino,
5089	__unused vnode_t *vpp,
5090	__unused vfs_context_t ctx)
5091	{
5092
5093	return (ENOTSUP);
5094	}
5095
5096	/*
5097	* At this point, this should never happen
5098	*/
5099	/ARGSUSED/
5100	int
5101	nfs_vfs_fhtovp(
5102	__unused mount_t mp,
5103	__unused int fhlen,
5104	__unused unsigned char *fhp,
5105	__unused vnode_t *vpp,
5106	__unused vfs_context_t ctx)
5107	{
5108
5109	return (ENOTSUP);
5110	}
5111
5112	/*
5113	* Vnode pointer to File handle, should never happen either
5114	*/
5115	/ARGSUSED/
5116	int
5117	nfs_vfs_vptofh(
5118	__unused vnode_t vp,
5119	__unused int *fhlenp,
5120	__unused unsigned char *fhp,
5121	__unused vfs_context_t ctx)
5122	{
5123
5124	return (ENOTSUP);
5125	}
5126
5127	/*
5128	* Vfs start routine, a no-op.
5129	*/
5130	/ARGSUSED/
5131	int
5132	nfs_vfs_start(
5133	__unused mount_t mp,
5134	__unused int flags,
5135	__unused vfs_context_t ctx)
5136	{
5137
5138	return (`0`);
5139	}
5140
5141	/*
5142	* Build the mount info buffer for NFS_MOUNTINFO.
5143	*/
5144	int
5145	nfs_mountinfo_assemble(struct nfsmount nmp, struct* xdrbuf *xb)
5146	{
5147	struct xdrbuf xbinfo, xborig;
5148	char sotype[`6`];
5149	uint32_t origargsvers, origargslength;
5150	uint32_t infolength_offset, curargsopaquelength_offset, curargslength_offset, attrslength_offset, curargs_end_offset, end_offset;
5151	uint32_t miattrs[NFS_MIATTR_BITMAP_LEN];
5152	uint32_t miflags_mask[NFS_MIFLAG_BITMAP_LEN];
5153	uint32_t miflags[NFS_MIFLAG_BITMAP_LEN];
5154	uint32_t mattrs[NFS_MATTR_BITMAP_LEN];
5155	uint32_t mflags_mask[NFS_MFLAG_BITMAP_LEN];
5156	uint32_t mflags[NFS_MFLAG_BITMAP_LEN];
5157	uint32_t loc, serv, addr, comp;
5158	int i, timeo, error = `0`;
5159
5160	/ set up mount info attr and flag bitmaps /
5161	NFS_BITMAP_ZERO(miattrs, NFS_MIATTR_BITMAP_LEN);
5162	NFS_BITMAP_SET(miattrs, NFS_MIATTR_FLAGS);
5163	NFS_BITMAP_SET(miattrs, NFS_MIATTR_ORIG_ARGS);
5164	NFS_BITMAP_SET(miattrs, NFS_MIATTR_CUR_ARGS);
5165	NFS_BITMAP_SET(miattrs, NFS_MIATTR_CUR_LOC_INDEX);
5166	NFS_BITMAP_ZERO(miflags_mask, NFS_MIFLAG_BITMAP_LEN);
5167	NFS_BITMAP_ZERO(miflags, NFS_MIFLAG_BITMAP_LEN);
5168	NFS_BITMAP_SET(miflags_mask, NFS_MIFLAG_DEAD);
5169	NFS_BITMAP_SET(miflags_mask, NFS_MIFLAG_NOTRESP);
5170	NFS_BITMAP_SET(miflags_mask, NFS_MIFLAG_RECOVERY);
5171	if (nmp->nm_state & NFSSTA_DEAD)
5172	NFS_BITMAP_SET(miflags, NFS_MIFLAG_DEAD);
5173	if ((nmp->nm_state & (NFSSTA_TIMEO\|NFSSTA_JUKEBOXTIMEO)) \|\|
5174	((nmp->nm_state & NFSSTA_LOCKTIMEO) && (nmp->nm_lockmode == NFS_LOCK_MODE_ENABLED)))
5175	NFS_BITMAP_SET(miflags, NFS_MIFLAG_NOTRESP);
5176	if (nmp->nm_state & NFSSTA_RECOVER)
5177	NFS_BITMAP_SET(miflags, NFS_MIFLAG_RECOVERY);
5178
5179	/ get original mount args length /
5180	xb_init_buffer(&xborig, nmp->nm_args, `2`*XDRWORD);
5181	xb_get_32(error, &xborig, origargsvers); / version /
5182	xb_get_32(error, &xborig, origargslength); / args length /
5183	nfsmerr_if(error);
5184
5185	/ set up current mount attributes bitmap /
5186	NFS_BITMAP_ZERO(mattrs, NFS_MATTR_BITMAP_LEN);
5187	NFS_BITMAP_SET(mattrs, NFS_MATTR_FLAGS);
5188	NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_VERSION);
5189	if (nmp->nm_vers >= NFS_VER4)
5190	NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_MINOR_VERSION);
5191	NFS_BITMAP_SET(mattrs, NFS_MATTR_READ_SIZE);
5192	NFS_BITMAP_SET(mattrs, NFS_MATTR_WRITE_SIZE);
5193	NFS_BITMAP_SET(mattrs, NFS_MATTR_READDIR_SIZE);
5194	NFS_BITMAP_SET(mattrs, NFS_MATTR_READAHEAD);
5195	NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_REG_MIN);
5196	NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_REG_MAX);
5197	NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MIN);
5198	NFS_BITMAP_SET(mattrs, NFS_MATTR_ATTRCACHE_DIR_MAX);
5199	NFS_BITMAP_SET(mattrs, NFS_MATTR_LOCK_MODE);
5200	NFS_BITMAP_SET(mattrs, NFS_MATTR_SECURITY);
5201	if (nmp->nm_etype.selected < nmp->nm_etype.count)
5202	NFS_BITMAP_SET(mattrs, NFS_MATTR_KERB_ETYPE);
5203	NFS_BITMAP_SET(mattrs, NFS_MATTR_MAX_GROUP_LIST);
5204	NFS_BITMAP_SET(mattrs, NFS_MATTR_SOCKET_TYPE);
5205	NFS_BITMAP_SET(mattrs, NFS_MATTR_NFS_PORT);
5206	if ((nmp->nm_vers < NFS_VER4) && nmp->nm_mountport)
5207	NFS_BITMAP_SET(mattrs, NFS_MATTR_MOUNT_PORT);
5208	NFS_BITMAP_SET(mattrs, NFS_MATTR_REQUEST_TIMEOUT);
5209	if (NMFLAG(nmp, SOFT))
5210	NFS_BITMAP_SET(mattrs, NFS_MATTR_SOFT_RETRY_COUNT);
5211	if (nmp->nm_deadtimeout)
5212	NFS_BITMAP_SET(mattrs, NFS_MATTR_DEAD_TIMEOUT);
5213	if (nmp->nm_fh)
5214	NFS_BITMAP_SET(mattrs, NFS_MATTR_FH);
5215	NFS_BITMAP_SET(mattrs, NFS_MATTR_FS_LOCATIONS);
5216	NFS_BITMAP_SET(mattrs, NFS_MATTR_MNTFLAGS);
5217	if (origargsvers < NFS_ARGSVERSION_XDR)
5218	NFS_BITMAP_SET(mattrs, NFS_MATTR_MNTFROM);
5219	if (nmp->nm_realm)
5220	NFS_BITMAP_SET(mattrs, NFS_MATTR_REALM);
5221	if (nmp->nm_principal)
5222	NFS_BITMAP_SET(mattrs, NFS_MATTR_PRINCIPAL);
5223	if (nmp->nm_sprinc)
5224	NFS_BITMAP_SET(mattrs, NFS_MATTR_SVCPRINCIPAL);
5225
5226	/ set up current mount flags bitmap /
5227	/ first set the flags that we will be setting - either on OR off /
5228	NFS_BITMAP_ZERO(mflags_mask, NFS_MFLAG_BITMAP_LEN);
5229	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_SOFT);
5230	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_INTR);
5231	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_RESVPORT);
5232	if (nmp->nm_sotype == SOCK_DGRAM)
5233	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NOCONNECT);
5234	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_DUMBTIMER);
5235	if (nmp->nm_vers < NFS_VER4)
5236	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_CALLUMNT);
5237	if (nmp->nm_vers >= NFS_VER3)
5238	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_RDIRPLUS);
5239	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NONEGNAMECACHE);
5240	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_MUTEJUKEBOX);
5241	if (nmp->nm_vers >= NFS_VER4) {
5242	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_EPHEMERAL);
5243	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NOCALLBACK);
5244	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NAMEDATTR);
5245	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NOACL);
5246	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_ACLONLY);
5247	}
5248	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NFC);
5249	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_NOQUOTA);
5250	if (nmp->nm_vers < NFS_VER4)
5251	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_MNTUDP);
5252	NFS_BITMAP_SET(mflags_mask, NFS_MFLAG_MNTQUICK);
5253	/ now set the flags that should be set /
5254	NFS_BITMAP_ZERO(mflags, NFS_MFLAG_BITMAP_LEN);
5255	if (NMFLAG(nmp, SOFT))
5256	NFS_BITMAP_SET(mflags, NFS_MFLAG_SOFT);
5257	if (NMFLAG(nmp, INTR))
5258	NFS_BITMAP_SET(mflags, NFS_MFLAG_INTR);
5259	if (NMFLAG(nmp, RESVPORT))
5260	NFS_BITMAP_SET(mflags, NFS_MFLAG_RESVPORT);
5261	if ((nmp->nm_sotype == SOCK_DGRAM) && NMFLAG(nmp, NOCONNECT))
5262	NFS_BITMAP_SET(mflags, NFS_MFLAG_NOCONNECT);
5263	if (NMFLAG(nmp, DUMBTIMER))
5264	NFS_BITMAP_SET(mflags, NFS_MFLAG_DUMBTIMER);
5265	if ((nmp->nm_vers < NFS_VER4) && NMFLAG(nmp, CALLUMNT))
5266	NFS_BITMAP_SET(mflags, NFS_MFLAG_CALLUMNT);
5267	if ((nmp->nm_vers >= NFS_VER3) && NMFLAG(nmp, RDIRPLUS))
5268	NFS_BITMAP_SET(mflags, NFS_MFLAG_RDIRPLUS);
5269	if (NMFLAG(nmp, NONEGNAMECACHE))
5270	NFS_BITMAP_SET(mflags, NFS_MFLAG_NONEGNAMECACHE);
5271	if (NMFLAG(nmp, MUTEJUKEBOX))
5272	NFS_BITMAP_SET(mflags, NFS_MFLAG_MUTEJUKEBOX);
5273	if (nmp->nm_vers >= NFS_VER4) {
5274	if (NMFLAG(nmp, EPHEMERAL))
5275	NFS_BITMAP_SET(mflags, NFS_MFLAG_EPHEMERAL);
5276	if (NMFLAG(nmp, NOCALLBACK))
5277	NFS_BITMAP_SET(mflags, NFS_MFLAG_NOCALLBACK);
5278	if (NMFLAG(nmp, NAMEDATTR))
5279	NFS_BITMAP_SET(mflags, NFS_MFLAG_NAMEDATTR);
5280	if (NMFLAG(nmp, NOACL))
5281	NFS_BITMAP_SET(mflags, NFS_MFLAG_NOACL);
5282	if (NMFLAG(nmp, ACLONLY))
5283	NFS_BITMAP_SET(mflags, NFS_MFLAG_ACLONLY);
5284	}
5285	if (NMFLAG(nmp, NFC))
5286	NFS_BITMAP_SET(mflags, NFS_MFLAG_NFC);
5287	if (NMFLAG(nmp, NOQUOTA) \|\| ((nmp->nm_vers >= NFS_VER4) &&
5288	!NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_AVAIL_HARD) &&
5289	!NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_AVAIL_SOFT) &&
5290	!NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_supp_attr, NFS_FATTR_QUOTA_USED)))
5291	NFS_BITMAP_SET(mflags, NFS_MFLAG_NOQUOTA);
5292	if ((nmp->nm_vers < NFS_VER4) && NMFLAG(nmp, MNTUDP))
5293	NFS_BITMAP_SET(mflags, NFS_MFLAG_MNTUDP);
5294	if (NMFLAG(nmp, MNTQUICK))
5295	NFS_BITMAP_SET(mflags, NFS_MFLAG_MNTQUICK);
5296
5297	/ assemble info buffer: /
5298	xb_init_buffer(&xbinfo, NULL, `0`);
5299	xb_add_32(error, &xbinfo, NFS_MOUNT_INFO_VERSION);
5300	infolength_offset = xb_offset(&xbinfo);
5301	xb_add_32(error, &xbinfo, `0`);
5302	xb_add_bitmap(error, &xbinfo, miattrs, NFS_MIATTR_BITMAP_LEN);
5303	xb_add_bitmap(error, &xbinfo, miflags, NFS_MIFLAG_BITMAP_LEN);
5304	xb_add_32(error, &xbinfo, origargslength);
5305	if (!error)
5306	error = xb_add_bytes(&xbinfo, nmp->nm_args, origargslength, `0`);
5307
5308	/ the opaque byte count for the current mount args values: /
5309	curargsopaquelength_offset = xb_offset(&xbinfo);
5310	xb_add_32(error, &xbinfo, `0`);
5311
5312	/ Encode current mount args values /
5313	xb_add_32(error, &xbinfo, NFS_ARGSVERSION_XDR);
5314	curargslength_offset = xb_offset(&xbinfo);
5315	xb_add_32(error, &xbinfo, `0`);
5316	xb_add_32(error, &xbinfo, NFS_XDRARGS_VERSION_0);
5317	xb_add_bitmap(error, &xbinfo, mattrs, NFS_MATTR_BITMAP_LEN);
5318	attrslength_offset = xb_offset(&xbinfo);
5319	xb_add_32(error, &xbinfo, `0`);
5320	xb_add_bitmap(error, &xbinfo, mflags_mask, NFS_MFLAG_BITMAP_LEN);
5321	xb_add_bitmap(error, &xbinfo, mflags, NFS_MFLAG_BITMAP_LEN);
5322	xb_add_32(error, &xbinfo, nmp->nm_vers); / NFS_VERSION /
5323	if (nmp->nm_vers >= NFS_VER4)
5324	xb_add_32(error, &xbinfo, nmp->nm_minor_vers); / NFS_MINOR_VERSION /
5325	xb_add_32(error, &xbinfo, nmp->nm_rsize); / READ_SIZE /
5326	xb_add_32(error, &xbinfo, nmp->nm_wsize); / WRITE_SIZE /
5327	xb_add_32(error, &xbinfo, nmp->nm_readdirsize); / READDIR_SIZE /
5328	xb_add_32(error, &xbinfo, nmp->nm_readahead); / READAHEAD /
5329	xb_add_32(error, &xbinfo, nmp->nm_acregmin); / ATTRCACHE_REG_MIN /
5330	xb_add_32(error, &xbinfo, `0`); / ATTRCACHE_REG_MIN /
5331	xb_add_32(error, &xbinfo, nmp->nm_acregmax); / ATTRCACHE_REG_MAX /
5332	xb_add_32(error, &xbinfo, `0`); / ATTRCACHE_REG_MAX /
5333	xb_add_32(error, &xbinfo, nmp->nm_acdirmin); / ATTRCACHE_DIR_MIN /
5334	xb_add_32(error, &xbinfo, `0`); / ATTRCACHE_DIR_MIN /
5335	xb_add_32(error, &xbinfo, nmp->nm_acdirmax); / ATTRCACHE_DIR_MAX /
5336	xb_add_32(error, &xbinfo, `0`); / ATTRCACHE_DIR_MAX /
5337	xb_add_32(error, &xbinfo, nmp->nm_lockmode); / LOCK_MODE /
5338	if (nmp->nm_sec.count) {
5339	xb_add_32(error, &xbinfo, nmp->nm_sec.count); / SECURITY /
5340	nfsmerr_if(error);
5341	for (i=`0`; i < nmp->nm_sec.count; i++)
5342	xb_add_32(error, &xbinfo, nmp->nm_sec.flavors[i]);
5343	} else if (nmp->nm_servsec.count) {
5344	xb_add_32(error, &xbinfo, nmp->nm_servsec.count); / SECURITY /
5345	nfsmerr_if(error);
5346	for (i=`0`; i < nmp->nm_servsec.count; i++)
5347	xb_add_32(error, &xbinfo, nmp->nm_servsec.flavors[i]);
5348	} else {
5349	xb_add_32(error, &xbinfo, `1`); / SECURITY /
5350	xb_add_32(error, &xbinfo, nmp->nm_auth);
5351	}
5352	if (nmp->nm_etype.selected < nmp->nm_etype.count) {
5353	xb_add_32(error, &xbinfo, nmp->nm_etype.count);
5354	xb_add_32(error, &xbinfo, nmp->nm_etype.selected);
5355	for (uint32_t j=`0`; j < nmp->nm_etype.count; j++)
5356	xb_add_32(error, &xbinfo, nmp->nm_etype.etypes[j]);
5357	nfsmerr_if(error);
5358	}
5359	xb_add_32(error, &xbinfo, nmp->nm_numgrps); / MAX_GROUP_LIST /
5360	nfsmerr_if(error);
5361	snprintf(sotype, sizeof(sotype), "%s%s", (nmp->nm_sotype == SOCK_DGRAM) ? "udp" : "tcp",
5362	nmp->nm_sofamily ? (nmp->nm_sofamily == AF_INET) ? "4" : "6" : "");
5363	xb_add_string(error, &xbinfo, sotype, strlen(sotype)); / SOCKET_TYPE /
5364	xb_add_32(error, &xbinfo, ntohs(((struct sockaddr_in)nmp->nm_saddr)->sin_port)); /* NFS_PORT /
5365	if ((nmp->nm_vers < NFS_VER4) && nmp->nm_mountport)
5366	xb_add_32(error, &xbinfo, nmp->nm_mountport); / MOUNT_PORT /
5367	timeo = (nmp->nm_timeo * `10`) / NFS_HZ;
5368	xb_add_32(error, &xbinfo, timeo/`10`); / REQUEST_TIMEOUT /
5369	xb_add_32(error, &xbinfo, (timeo%`10`)`100000000`); /* REQUEST_TIMEOUT /
5370	if (NMFLAG(nmp, SOFT))
5371	xb_add_32(error, &xbinfo, nmp->nm_retry); / SOFT_RETRY_COUNT /
5372	if (nmp->nm_deadtimeout) {
5373	xb_add_32(error, &xbinfo, nmp->nm_deadtimeout); / DEAD_TIMEOUT /
5374	xb_add_32(error, &xbinfo, `0`); / DEAD_TIMEOUT /
5375	}
5376	if (nmp->nm_fh)
5377	xb_add_fh(error, &xbinfo, &nmp->nm_fh->fh_data[`0`], nmp->nm_fh->fh_len); / FH /
5378	xb_add_32(error, &xbinfo, nmp->nm_locations.nl_numlocs); / FS_LOCATIONS /
5379	for (loc = `0`; !error && (loc < nmp->nm_locations.nl_numlocs); loc++) {
5380	xb_add_32(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_servcount);
5381	for (serv = `0`; !error && (serv < nmp->nm_locations.nl_locations[loc]->nl_servcount); serv++) {
5382	xb_add_string(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_name,
5383	strlen(nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_name));
5384	xb_add_32(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addrcount);
5385	for (addr = `0`; !error && (addr < nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addrcount); addr++)
5386	xb_add_string(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addresses[addr],
5387	strlen(nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addresses[addr]));
5388	xb_add_32(error, &xbinfo, `0`); / empty server info /
5389	}
5390	xb_add_32(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_path.np_compcount);
5391	for (comp = `0`; !error && (comp < nmp->nm_locations.nl_locations[loc]->nl_path.np_compcount); comp++)
5392	xb_add_string(error, &xbinfo, nmp->nm_locations.nl_locations[loc]->nl_path.np_components[comp],
5393	strlen(nmp->nm_locations.nl_locations[loc]->nl_path.np_components[comp]));
5394	xb_add_32(error, &xbinfo, `0`); / empty fs location info /
5395	}
5396	xb_add_32(error, &xbinfo, vfs_flags(nmp->nm_mountp)); / MNTFLAGS /
5397	if (origargsvers < NFS_ARGSVERSION_XDR)
5398	xb_add_string(error, &xbinfo, vfs_statfs(nmp->nm_mountp)->f_mntfromname,
5399	strlen(vfs_statfs(nmp->nm_mountp)->f_mntfromname)); / MNTFROM /
5400	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_REALM))
5401	xb_add_string(error, &xbinfo, nmp->nm_realm, strlen(nmp->nm_realm));
5402	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_PRINCIPAL))
5403	xb_add_string(error, &xbinfo, nmp->nm_principal, strlen(nmp->nm_principal));
5404	if (NFS_BITMAP_ISSET(mattrs, NFS_MATTR_SVCPRINCIPAL))
5405	xb_add_string(error, &xbinfo, nmp->nm_sprinc, strlen(nmp->nm_sprinc));
5406
5407	curargs_end_offset = xb_offset(&xbinfo);
5408
5409	/ NFS_MIATTR_CUR_LOC_INDEX /
5410	xb_add_32(error, &xbinfo, nmp->nm_locations.nl_current.nli_flags);
5411	xb_add_32(error, &xbinfo, nmp->nm_locations.nl_current.nli_loc);
5412	xb_add_32(error, &xbinfo, nmp->nm_locations.nl_current.nli_serv);
5413	xb_add_32(error, &xbinfo, nmp->nm_locations.nl_current.nli_addr);
5414
5415	xb_build_done(error, &xbinfo);
5416
5417	/ update opaque counts /
5418	end_offset = xb_offset(&xbinfo);
5419	if (!error) {
5420	error = xb_seek(&xbinfo, attrslength_offset);
5421	xb_add_32(error, &xbinfo, curargs_end_offset - attrslength_offset - XDRWORD/don't include length field/);
5422	}
5423	if (!error) {
5424	error = xb_seek(&xbinfo, curargslength_offset);
5425	xb_add_32(error, &xbinfo, curargs_end_offset - curargslength_offset + XDRWORD/version/);
5426	}
5427	if (!error) {
5428	error = xb_seek(&xbinfo, curargsopaquelength_offset);
5429	xb_add_32(error, &xbinfo, curargs_end_offset - curargslength_offset + XDRWORD/version/);
5430	}
5431	if (!error) {
5432	error = xb_seek(&xbinfo, infolength_offset);
5433	xb_add_32(error, &xbinfo, end_offset - infolength_offset + XDRWORD/version/);
5434	}
5435	nfsmerr_if(error);
5436
5437	/ copy result xdrbuf to caller /
5438	*xb = xbinfo;
5439
5440	/ and mark the local copy as not needing cleanup /
5441	xbinfo.xb_flags &= ~XB_CLEANUP;
5442	nfsmerr:
5443	xb_cleanup(&xbinfo);
5444	return (error);
5445	}
5446
5447	/*
5448	* Do that sysctl thang...
5449	*/
5450	int
5451	nfs_vfs_sysctl(int name, u_int namelen, user_addr_t oldp, size_t oldlenp,
5452	user_addr_t newp, size_t newlen, vfs_context_t ctx)
5453	{
5454	int error = `0`, val;
5455	#ifndef CONFIG_EMBEDDED
5456	int softnobrowse;
5457	#endif
5458	struct sysctl_req *req = NULL;
5459	union union_vfsidctl vc;
5460	mount_t mp;
5461	struct nfsmount *nmp = NULL;
5462	struct vfsquery vq;
5463	struct nfsreq *rq;
5464	boolean_t is_64_bit;
5465	fsid_t fsid;
5466	struct xdrbuf xb;
5467	struct netfs_status *nsp = NULL;
5468	int timeoutmask;
5469	uint pos, totlen, count, numThreads;
5470	#if NFSSERVER
5471	struct nfs_exportfs *nxfs;
5472	struct nfs_export *nx;
5473	struct nfs_active_user_list *ulist;
5474	struct nfs_export_stat_desc stat_desc = {};
5475	struct nfs_export_stat_rec statrec;
5476	struct nfs_user_stat_node unode, unode_next;
5477	struct nfs_user_stat_desc ustat_desc = {};
5478	struct nfs_user_stat_user_rec ustat_rec;
5479	struct nfs_user_stat_path_rec upath_rec;
5480	uint bytes_avail, bytes_total, recs_copied;
5481	uint numExports, numRecs;
5482	#endif /* NFSSERVER */
5483
5484	/*
5485	* All names at this level are terminal.
5486	*/
5487	if (namelen > `1`)
5488	return (ENOTDIR); / overloaded /
5489
5490	is_64_bit = vfs_context_is64bit(ctx);
5491
5492	/ common code for "new style" VFS_CTL sysctl, get the mount. /
5493	switch (name[`0`]) {
5494	case VFS_CTL_TIMEO:
5495	case VFS_CTL_NOLOCKS:
5496	case VFS_CTL_NSTATUS:
5497	#ifndef CONFIG_EMBEDDED
5498	case VFS_CTL_QUERY:
5499	#endif
5500	req = CAST_DOWN(struct sysctl_req *, oldp);
5501	if (req == NULL) {
5502	return EFAULT;
5503	}
5504	error = SYSCTL_IN(req, &vc, is_64_bit? sizeof(vc.vc64):sizeof(vc.vc32));
5505	if (error)
5506	return (error);
5507	mp = vfs_getvfs(&vc.vc32.vc_fsid); / works for 32 and 64 /
5508	if (mp == NULL)
5509	return (ENOENT);
5510	nmp = VFSTONFS(mp);
5511	if (!nmp)
5512	return (ENOENT);
5513	bzero(&vq, sizeof(vq));
5514	req->newidx = `0`;
5515	if (is_64_bit) {
5516	req->newptr = vc.vc64.vc_ptr;
5517	req->newlen = (size_t)vc.vc64.vc_len;
5518	} else {
5519	req->newptr = CAST_USER_ADDR_T(vc.vc32.vc_ptr);
5520	req->newlen = vc.vc32.vc_len;
5521	}
5522	break;
5523	#if CONFIG_EMBEDDED
5524	case VFS_CTL_QUERY:
5525	return EPERM;
5526	#endif
5527	}
5528
5529	switch(name[`0`]) {
5530	case NFS_NFSSTATS:
5531	if (!oldp) {
5532	oldlenp = sizeof* nfsstats;
5533	return (`0`);
5534	}
5535
5536	if (oldlenp < sizeof* nfsstats) {
5537	oldlenp = sizeof* nfsstats;
5538	return (ENOMEM);
5539	}
5540
5541	error = copyout(&nfsstats, oldp, sizeof nfsstats);
5542	if (error)
5543	return (error);
5544
5545	if (newp && newlen != sizeof nfsstats)
5546	return (EINVAL);
5547
5548	if (newp)
5549	return copyin(newp, &nfsstats, sizeof nfsstats);
5550	return (`0`);
5551	case NFS_MOUNTINFO:
5552	/ read in the fsid /
5553	if (oldlenp < sizeof*(fsid))
5554	return (EINVAL);
5555	if ((error = copyin(oldp, &fsid, sizeof(fsid))))
5556	return (error);
5557	/ swizzle it back to host order /
5558	fsid.val[`0`] = ntohl(fsid.val[`0`]);
5559	fsid.val[`1`] = ntohl(fsid.val[`1`]);
5560	/ find mount and make sure it's NFS /
5561	if (((mp = vfs_getvfs(&fsid))) == NULL)
5562	return (ENOENT);
5563	if (strcmp(mp->mnt_vfsstat.f_fstypename, "nfs"))
5564	return (EINVAL);
5565	if (((nmp = VFSTONFS(mp))) == NULL)
5566	return (ENOENT);
5567	xb_init(&xb, `0`);
5568	if ((error = nfs_mountinfo_assemble(nmp, &xb)))
5569	return (error);
5570	if (*oldlenp < xb.xb_u.xb_buffer.xbb_len)
5571	error = ENOMEM;
5572	else
5573	error = copyout(xb_buffer_base(&xb), oldp, xb.xb_u.xb_buffer.xbb_len);
5574	*oldlenp = xb.xb_u.xb_buffer.xbb_len;
5575	xb_cleanup(&xb);
5576	break;
5577	#if NFSSERVER
5578	case NFS_EXPORTSTATS:
5579	/ setup export stat descriptor /
5580	stat_desc.rec_vers = NFS_EXPORT_STAT_REC_VERSION;
5581
5582	if (!nfsrv_is_initialized()) {
5583	stat_desc.rec_count = `0`;
5584	if (oldp && (oldlenp >= sizeof(struct* nfs_export_stat_desc)))
5585	error = copyout(&stat_desc, oldp, sizeof(struct nfs_export_stat_desc));
5586	oldlenp = sizeof(struct* nfs_export_stat_desc);
5587	return (error);
5588	}
5589
5590	/ Count the number of exported directories /
5591	lck_rw_lock_shared(&nfsrv_export_rwlock);
5592	numExports = `0`;
5593	LIST_FOREACH(nxfs, &nfsrv_exports, nxfs_next)
5594	LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next)
5595	numExports += `1`;
5596
5597	/ update stat descriptor's export record count /
5598	stat_desc.rec_count = numExports;
5599
5600	/ calculate total size of required buffer /
5601	totlen = sizeof(struct nfs_export_stat_desc) + (numExports * sizeof(struct nfs_export_stat_rec));
5602
5603	/ Check caller's buffer /
5604	if (oldp == `0`) {
5605	lck_rw_done(&nfsrv_export_rwlock);
5606	/ indicate required buffer len /
5607	*oldlenp = totlen;
5608	return (`0`);
5609	}
5610
5611	/ We require the caller's buffer to be at least large enough to hold the descriptor /
5612	if (oldlenp < sizeof(struct* nfs_export_stat_desc)) {
5613	lck_rw_done(&nfsrv_export_rwlock);
5614	/ indicate required buffer len /
5615	*oldlenp = totlen;
5616	return (ENOMEM);
5617	}
5618
5619	/ indicate required buffer len /
5620	*oldlenp = totlen;
5621
5622	/ check if export table is empty /
5623	if (!numExports) {
5624	lck_rw_done(&nfsrv_export_rwlock);
5625	error = copyout(&stat_desc, oldp, sizeof(struct nfs_export_stat_desc));
5626	return (error);
5627	}
5628
5629	/ calculate how many actual export stat records fit into caller's buffer /
5630	numRecs = (oldlenp - sizeof(struct* nfs_export_stat_desc)) / sizeof(struct nfs_export_stat_rec);
5631
5632	if (!numRecs) {
5633	/ caller's buffer can only accomodate descriptor /
5634	lck_rw_done(&nfsrv_export_rwlock);
5635	stat_desc.rec_count = `0`;
5636	error = copyout(&stat_desc, oldp, sizeof(struct nfs_export_stat_desc));
5637	return (error);
5638	}
5639
5640	/ adjust to actual number of records to copyout to caller's buffer /
5641	if (numRecs > numExports)
5642	numRecs = numExports;
5643
5644	/ set actual number of records we are returning /
5645	stat_desc.rec_count = numRecs;
5646
5647	/ first copy out the stat descriptor /
5648	pos = `0`;
5649	error = copyout(&stat_desc, oldp + pos, sizeof(struct nfs_export_stat_desc));
5650	if (error) {
5651	lck_rw_done(&nfsrv_export_rwlock);
5652	return (error);
5653	}
5654	pos += sizeof(struct nfs_export_stat_desc);
5655
5656	/ Loop through exported directories /
5657	count = `0`;
5658	LIST_FOREACH(nxfs, &nfsrv_exports, nxfs_next) {
5659	LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next) {
5660
5661	if (count >= numRecs)
5662	break;
5663
5664	/ build exported filesystem path /
5665	memset(statrec.path, `0`, sizeof(statrec.path));
5666	snprintf(statrec.path, sizeof(statrec.path), "%s%s%s",
5667	nxfs->nxfs_path, ((nxfs->nxfs_path[`1`] && nx->nx_path[`0`]) ? "/" : ""),
5668	nx->nx_path);
5669
5670	/ build the 64-bit export stat counters /
5671	statrec.ops = ((uint64_t)nx->nx_stats.ops.hi << `32`) \|
5672	nx->nx_stats.ops.lo;
5673	statrec.bytes_read = ((uint64_t)nx->nx_stats.bytes_read.hi << `32`) \|
5674	nx->nx_stats.bytes_read.lo;
5675	statrec.bytes_written = ((uint64_t)nx->nx_stats.bytes_written.hi << `32`) \|
5676	nx->nx_stats.bytes_written.lo;
5677	error = copyout(&statrec, oldp + pos, sizeof(statrec));
5678	if (error) {
5679	lck_rw_done(&nfsrv_export_rwlock);
5680	return (error);
5681	}
5682	/ advance buffer position /
5683	pos += sizeof(statrec);
5684	}
5685	}
5686	lck_rw_done(&nfsrv_export_rwlock);
5687	break;
5688	case NFS_USERSTATS:
5689	/ init structures used for copying out of kernel /
5690	ustat_desc.rec_vers = NFS_USER_STAT_REC_VERSION;
5691	ustat_rec.rec_type = NFS_USER_STAT_USER_REC;
5692	upath_rec.rec_type = NFS_USER_STAT_PATH_REC;
5693
5694	/ initialize counters /
5695	bytes_total = sizeof(struct nfs_user_stat_desc);
5696	bytes_avail = *oldlenp;
5697	recs_copied = `0`;
5698
5699	if (!nfsrv_is_initialized()) / NFS server not initialized, so no stats /
5700	goto ustat_skip;
5701
5702	/ reclaim old expired user nodes /
5703	nfsrv_active_user_list_reclaim();
5704
5705	/ reserve space for the buffer descriptor /
5706	if (bytes_avail >= sizeof(struct nfs_user_stat_desc))
5707	bytes_avail -= sizeof(struct nfs_user_stat_desc);
5708	else
5709	bytes_avail = `0`;
5710
5711	/ put buffer position past the buffer descriptor /
5712	pos = sizeof(struct nfs_user_stat_desc);
5713
5714	/ Loop through exported directories /
5715	lck_rw_lock_shared(&nfsrv_export_rwlock);
5716	LIST_FOREACH(nxfs, &nfsrv_exports, nxfs_next) {
5717	LIST_FOREACH(nx, &nxfs->nxfs_exports, nx_next) {
5718	/ copy out path /
5719	if (bytes_avail >= sizeof(struct nfs_user_stat_path_rec)) {
5720	memset(upath_rec.path, `0`, sizeof(upath_rec.path));
5721	snprintf(upath_rec.path, sizeof(upath_rec.path), "%s%s%s",
5722	nxfs->nxfs_path, ((nxfs->nxfs_path[`1`] && nx->nx_path[`0`]) ? "/" : ""),
5723	nx->nx_path);
5724
5725	error = copyout(&upath_rec, oldp + pos, sizeof(struct nfs_user_stat_path_rec));
5726	if (error) {
5727	/ punt /
5728	goto ustat_done;
5729	}
5730
5731	pos += sizeof(struct nfs_user_stat_path_rec);
5732	bytes_avail -= sizeof(struct nfs_user_stat_path_rec);
5733	recs_copied++;
5734	}
5735	else {
5736	/ Caller's buffer is exhausted /
5737	bytes_avail = `0`;
5738	}
5739
5740	bytes_total += sizeof(struct nfs_user_stat_path_rec);
5741
5742	/ Scan through all user nodes of this export /
5743	ulist = &nx->nx_user_list;
5744	lck_mtx_lock(&ulist->user_mutex);
5745	for (unode = TAILQ_FIRST(&ulist->user_lru); unode; unode = unode_next) {
5746	unode_next = TAILQ_NEXT(unode, lru_link);
5747
5748	/ copy out node if there is space /
5749	if (bytes_avail >= sizeof(struct nfs_user_stat_user_rec)) {
5750	/ prepare a user stat rec for copying out /
5751	ustat_rec.uid = unode->uid;
5752	memset(&ustat_rec.sock, `0`, sizeof(ustat_rec.sock));
5753	bcopy(&unode->sock, &ustat_rec.sock, unode->sock.ss_len);
5754	ustat_rec.ops = unode->ops;
5755	ustat_rec.bytes_read = unode->bytes_read;
5756	ustat_rec.bytes_written = unode->bytes_written;
5757	ustat_rec.tm_start = unode->tm_start;
5758	ustat_rec.tm_last = unode->tm_last;
5759
5760	error = copyout(&ustat_rec, oldp + pos, sizeof(struct nfs_user_stat_user_rec));
5761
5762	if (error) {
5763	/ punt /
5764	lck_mtx_unlock(&ulist->user_mutex);
5765	goto ustat_done;
5766	}
5767
5768	pos += sizeof(struct nfs_user_stat_user_rec);
5769	bytes_avail -= sizeof(struct nfs_user_stat_user_rec);
5770	recs_copied++;
5771	}
5772	else {
5773	/ Caller's buffer is exhausted /
5774	bytes_avail = `0`;
5775	}
5776	bytes_total += sizeof(struct nfs_user_stat_user_rec);
5777	}
5778	/ can unlock this export's list now /
5779	lck_mtx_unlock(&ulist->user_mutex);
5780	}
5781	}
5782
5783	ustat_done:
5784	/ unlock the export table /
5785	lck_rw_done(&nfsrv_export_rwlock);
5786
5787	ustat_skip:
5788	/ indicate number of actual records copied /
5789	ustat_desc.rec_count = recs_copied;
5790
5791	if (!error) {
5792	/ check if there was enough room for the buffer descriptor /
5793	if (oldlenp >= sizeof(struct* nfs_user_stat_desc))
5794	error = copyout(&ustat_desc, oldp, sizeof(struct nfs_user_stat_desc));
5795	else
5796	error = ENOMEM;
5797
5798	/ always indicate required buffer size /
5799	*oldlenp = bytes_total;
5800	}
5801	break;
5802	case NFS_USERCOUNT:
5803	if (!oldp) {
5804	oldlenp = sizeof*(nfsrv_user_stat_node_count);
5805	return (`0`);
5806	}
5807
5808	if (oldlenp < sizeof*(nfsrv_user_stat_node_count)) {
5809	oldlenp = sizeof*(nfsrv_user_stat_node_count);
5810	return (ENOMEM);
5811	}
5812
5813	if (nfsrv_is_initialized()) {
5814	/ reclaim old expired user nodes /
5815	nfsrv_active_user_list_reclaim();
5816	}
5817
5818	error = copyout(&nfsrv_user_stat_node_count, oldp, sizeof(nfsrv_user_stat_node_count));
5819	break;
5820	#endif /* NFSSERVER */
5821	case VFS_CTL_NOLOCKS:
5822	if (req->oldptr != USER_ADDR_NULL) {
5823	lck_mtx_lock(&nmp->nm_lock);
5824	val = (nmp->nm_lockmode == NFS_LOCK_MODE_DISABLED) ? `1` : `0`;
5825	lck_mtx_unlock(&nmp->nm_lock);
5826	error = SYSCTL_OUT(req, &val, sizeof(val));
5827	if (error)
5828	return (error);
5829	}
5830	if (req->newptr != USER_ADDR_NULL) {
5831	error = SYSCTL_IN(req, &val, sizeof(val));
5832	if (error)
5833	return (error);
5834	lck_mtx_lock(&nmp->nm_lock);
5835	if (nmp->nm_lockmode == NFS_LOCK_MODE_LOCAL) {
5836	/ can't toggle locks when using local locks /
5837	error = EINVAL;
5838	} else if ((nmp->nm_vers >= NFS_VER4) && val) {
5839	/ can't disable locks for NFSv4 /
5840	error = EINVAL;
5841	} else if (val) {
5842	if ((nmp->nm_vers <= NFS_VER3) && (nmp->nm_lockmode == NFS_LOCK_MODE_ENABLED))
5843	nfs_lockd_mount_unregister(nmp);
5844	nmp->nm_lockmode = NFS_LOCK_MODE_DISABLED;
5845	nmp->nm_state &= ~NFSSTA_LOCKTIMEO;
5846	} else {
5847	if ((nmp->nm_vers <= NFS_VER3) && (nmp->nm_lockmode == NFS_LOCK_MODE_DISABLED))
5848	nfs_lockd_mount_register(nmp);
5849	nmp->nm_lockmode = NFS_LOCK_MODE_ENABLED;
5850	}
5851	lck_mtx_unlock(&nmp->nm_lock);
5852	}
5853	break;
5854	#ifndef CONFIG_EMBEDDED
5855	case VFS_CTL_QUERY:
5856	lck_mtx_lock(&nmp->nm_lock);
5857	/ XXX don't allow users to know about/disconnect unresponsive, soft, nobrowse mounts /
5858	softnobrowse = (NMFLAG(nmp, SOFT) && (vfs_flags(nmp->nm_mountp) & MNT_DONTBROWSE));
5859	if (!softnobrowse && (nmp->nm_state & NFSSTA_TIMEO))
5860	vq.vq_flags \|= VQ_NOTRESP;
5861	if (!softnobrowse && (nmp->nm_state & NFSSTA_JUKEBOXTIMEO) && !NMFLAG(nmp, MUTEJUKEBOX))
5862	vq.vq_flags \|= VQ_NOTRESP;
5863	if (!softnobrowse && (nmp->nm_state & NFSSTA_LOCKTIMEO) &&
5864	(nmp->nm_lockmode == NFS_LOCK_MODE_ENABLED))
5865	vq.vq_flags \|= VQ_NOTRESP;
5866	if (nmp->nm_state & NFSSTA_DEAD)
5867	vq.vq_flags \|= VQ_DEAD;
5868	lck_mtx_unlock(&nmp->nm_lock);
5869	error = SYSCTL_OUT(req, &vq, sizeof(vq));
5870	break;
5871	#endif
5872	case VFS_CTL_TIMEO:
5873	if (req->oldptr != USER_ADDR_NULL) {
5874	lck_mtx_lock(&nmp->nm_lock);
5875	val = nmp->nm_tprintf_initial_delay;
5876	lck_mtx_unlock(&nmp->nm_lock);
5877	error = SYSCTL_OUT(req, &val, sizeof(val));
5878	if (error)
5879	return (error);
5880	}
5881	if (req->newptr != USER_ADDR_NULL) {
5882	error = SYSCTL_IN(req, &val, sizeof(val));
5883	if (error)
5884	return (error);
5885	lck_mtx_lock(&nmp->nm_lock);
5886	if (val < `0`)
5887	nmp->nm_tprintf_initial_delay = `0`;
5888	else
5889	nmp->nm_tprintf_initial_delay = val;
5890	lck_mtx_unlock(&nmp->nm_lock);
5891	}
5892	break;
5893	case VFS_CTL_NSTATUS:
5894	/*
5895	* Return the status of this mount. This is much more
5896	* information than VFS_CTL_QUERY. In addition to the
5897	* vq_flags return the significant mount options along
5898	* with the list of threads blocked on the mount and
5899	* how long the threads have been waiting.
5900	*/
5901
5902	lck_mtx_lock(nfs_request_mutex);
5903	lck_mtx_lock(&nmp->nm_lock);
5904
5905	/*
5906	* Count the number of requests waiting for a reply.
5907	* Note: there could be multiple requests from the same thread.
5908	*/
5909	numThreads = `0`;
5910	TAILQ_FOREACH(rq, &nfs_reqq, r_chain) {
5911	if (rq->r_nmp == nmp)
5912	numThreads++;
5913	}
5914
5915	/ Calculate total size of result buffer /
5916	totlen = sizeof(struct netfs_status) + (numThreads * sizeof(uint64_t));
5917
5918	if (req->oldptr == USER_ADDR_NULL) { // Caller is querying buffer size
5919	lck_mtx_unlock(&nmp->nm_lock);
5920	lck_mtx_unlock(nfs_request_mutex);
5921	return SYSCTL_OUT(req, NULL, totlen);
5922	}
5923	if (req->oldlen < totlen) { // Check if caller's buffer is big enough
5924	lck_mtx_unlock(&nmp->nm_lock);
5925	lck_mtx_unlock(nfs_request_mutex);
5926	return (ERANGE);
5927	}
5928
5929	MALLOC(nsp, struct netfs_status *, totlen, M_TEMP, M_WAITOK\|M_ZERO);
5930	if (nsp == NULL) {
5931	lck_mtx_unlock(&nmp->nm_lock);
5932	lck_mtx_unlock(nfs_request_mutex);
5933	return (ENOMEM);
5934	}
5935	timeoutmask = NFSSTA_TIMEO \| NFSSTA_LOCKTIMEO \| NFSSTA_JUKEBOXTIMEO;
5936	if (nmp->nm_state & timeoutmask)
5937	nsp->ns_status \|= VQ_NOTRESP;
5938	if (nmp->nm_state & NFSSTA_DEAD)
5939	nsp->ns_status \|= VQ_DEAD;
5940
5941	(void) nfs_mountopts(nmp, nsp->ns_mountopts, sizeof(nsp->ns_mountopts));
5942	nsp->ns_threadcount = numThreads;
5943
5944	/*
5945	* Get the thread ids of threads waiting for a reply
5946	* and find the longest wait time.
5947	*/
5948	if (numThreads > `0`) {
5949	struct timeval now;
5950	time_t sendtime;
5951
5952	microuptime(&now);
5953	count = `0`;
5954	sendtime = now.tv_sec;
5955	TAILQ_FOREACH(rq, &nfs_reqq, r_chain) {
5956	if (rq->r_nmp == nmp) {
5957	if (rq->r_start < sendtime)
5958	sendtime = rq->r_start;
5959	// A thread_id of zero is used to represent an async I/O request.
5960	nsp->ns_threadids[count] =
5961	rq->r_thread ? thread_tid(rq->r_thread) : `0`;
5962	if (++count >= numThreads)
5963	break;
5964	}
5965	}
5966	nsp->ns_waittime = now.tv_sec - sendtime;
5967	}
5968
5969	lck_mtx_unlock(&nmp->nm_lock);
5970	lck_mtx_unlock(nfs_request_mutex);
5971
5972	error = SYSCTL_OUT(req, nsp, totlen);
5973	FREE(nsp, M_TEMP);
5974	break;
5975	default:
5976	return (ENOTSUP);
5977	}
5978	return (error);
5979	}
5980

Browse the source code of codebrowser/bsd/nfs/nfs_vfsops.c