xref: /freebsd/sys/fs/nfs/nfs_commonport.c (revision 313376588638950ba1e93c403dd8c97bc52fd3a2)
1 /*-
2  * Copyright (c) 1989, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Rick Macklem at The University of Guelph.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 4. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  */
33 
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
36 
37 /*
38  * Functions that need to be different for different versions of BSD
39  * kernel should be kept here, along with any global storage specific
40  * to this BSD variant.
41  */
42 #include <fs/nfs/nfsport.h>
43 #include <sys/sysctl.h>
44 #include <vm/vm.h>
45 #include <vm/vm_object.h>
46 #include <vm/vm_page.h>
47 #include <vm/vm_param.h>
48 #include <vm/vm_map.h>
49 #include <vm/vm_kern.h>
50 #include <vm/vm_extern.h>
51 #include <vm/uma.h>
52 
53 extern int nfscl_ticks;
54 extern int nfsrv_nfsuserd;
55 extern struct nfssockreq nfsrv_nfsuserdsock;
56 extern void (*nfsd_call_recall)(struct vnode *, int, struct ucred *,
57     struct thread *);
58 extern int nfsrv_useacl;
59 struct mount nfsv4root_mnt;
60 int newnfs_numnfsd = 0;
61 struct nfsstats newnfsstats;
62 int nfs_numnfscbd = 0;
63 int nfscl_debuglevel = 0;
64 char nfsv4_callbackaddr[INET6_ADDRSTRLEN];
65 struct callout newnfsd_callout;
66 void (*nfsd_call_servertimer)(void) = NULL;
67 void (*ncl_call_invalcaches)(struct vnode *) = NULL;
68 
69 static int nfs_realign_test;
70 static int nfs_realign_count;
71 
72 SYSCTL_NODE(_vfs, OID_AUTO, nfs, CTLFLAG_RW, 0, "New NFS filesystem");
73 SYSCTL_INT(_vfs_nfs, OID_AUTO, realign_test, CTLFLAG_RW, &nfs_realign_test,
74     0, "Number of realign tests done");
75 SYSCTL_INT(_vfs_nfs, OID_AUTO, realign_count, CTLFLAG_RW, &nfs_realign_count,
76     0, "Number of mbuf realignments done");
77 SYSCTL_STRING(_vfs_nfs, OID_AUTO, callback_addr, CTLFLAG_RW,
78     nfsv4_callbackaddr, sizeof(nfsv4_callbackaddr),
79     "NFSv4 callback addr for server to use");
80 SYSCTL_INT(_vfs_nfs, OID_AUTO, debuglevel, CTLFLAG_RW, &nfscl_debuglevel,
81     0, "Debug level for new nfs client");
82 
83 /*
84  * Defines for malloc
85  * (Here for FreeBSD, since they allocate storage.)
86  */
87 MALLOC_DEFINE(M_NEWNFSRVCACHE, "NFSD srvcache", "NFSD Server Request Cache");
88 MALLOC_DEFINE(M_NEWNFSDCLIENT, "NFSD V4client", "NFSD V4 Client Id");
89 MALLOC_DEFINE(M_NEWNFSDSTATE, "NFSD V4state",
90     "NFSD V4 State (Openowner, Open, Lockowner, Delegation");
91 MALLOC_DEFINE(M_NEWNFSDLOCK, "NFSD V4lock", "NFSD V4 byte range lock");
92 MALLOC_DEFINE(M_NEWNFSDLOCKFILE, "NFSD lckfile", "NFSD Open/Lock file");
93 MALLOC_DEFINE(M_NEWNFSSTRING, "NFSD string", "NFSD V4 long string");
94 MALLOC_DEFINE(M_NEWNFSUSERGROUP, "NFSD usrgroup", "NFSD V4 User/group map");
95 MALLOC_DEFINE(M_NEWNFSDREQ, "NFS req", "NFS request header");
96 MALLOC_DEFINE(M_NEWNFSFH, "NFS fh", "NFS file handle");
97 MALLOC_DEFINE(M_NEWNFSCLOWNER, "NFSCL owner", "NFSCL Open Owner");
98 MALLOC_DEFINE(M_NEWNFSCLOPEN, "NFSCL open", "NFSCL Open");
99 MALLOC_DEFINE(M_NEWNFSCLDELEG, "NFSCL deleg", "NFSCL Delegation");
100 MALLOC_DEFINE(M_NEWNFSCLCLIENT, "NFSCL client", "NFSCL Client");
101 MALLOC_DEFINE(M_NEWNFSCLLOCKOWNER, "NFSCL lckown", "NFSCL Lock Owner");
102 MALLOC_DEFINE(M_NEWNFSCLLOCK, "NFSCL lck", "NFSCL Lock");
103 MALLOC_DEFINE(M_NEWNFSV4NODE, "NEWNFSnode", "New nfs vnode");
104 MALLOC_DEFINE(M_NEWNFSDIRECTIO, "NEWdirectio", "New nfs Direct IO buffer");
105 MALLOC_DEFINE(M_NEWNFSDIROFF, "NFSCL diroffdiroff",
106     "New NFS directory offset data");
107 MALLOC_DEFINE(M_NEWNFSDROLLBACK, "NFSD rollback",
108     "New NFS local lock rollback");
109 MALLOC_DEFINE(M_NEWNFSLAYOUT, "NFSCL layout", "NFSv4.1 Layout");
110 MALLOC_DEFINE(M_NEWNFSFLAYOUT, "NFSCL flayout", "NFSv4.1 File Layout");
111 MALLOC_DEFINE(M_NEWNFSDEVINFO, "NFSCL devinfo", "NFSv4.1 Device Info");
112 MALLOC_DEFINE(M_NEWNFSSOCKREQ, "NFSCL sockreq", "NFS Sock Req");
113 MALLOC_DEFINE(M_NEWNFSCLDS, "NFSCL session", "NFSv4.1 Session");
114 MALLOC_DEFINE(M_NEWNFSLAYRECALL, "NFSCL layrecall", "NFSv4.1 Layout Recall");
115 MALLOC_DEFINE(M_NEWNFSDSESSION, "NFSD session", "NFSD Session for a client");
116 
117 /*
118  * Definition of mutex locks.
119  * newnfsd_mtx is used in nfsrvd_nfsd() to protect the nfs socket list
120  * and assorted other nfsd structures.
121  */
122 struct mtx newnfsd_mtx;
123 struct mtx nfs_sockl_mutex;
124 struct mtx nfs_state_mutex;
125 struct mtx nfs_nameid_mutex;
126 struct mtx nfs_req_mutex;
127 struct mtx nfs_slock_mutex;
128 
129 /* local functions */
130 static int nfssvc_call(struct thread *, struct nfssvc_args *, struct ucred *);
131 
132 #ifdef __NO_STRICT_ALIGNMENT
133 /*
134  * These architectures don't need re-alignment, so just return.
135  */
136 int
137 newnfs_realign(struct mbuf **pm, int how)
138 {
139 
140 	return (0);
141 }
142 #else	/* !__NO_STRICT_ALIGNMENT */
143 /*
144  *	newnfs_realign:
145  *
146  *	Check for badly aligned mbuf data and realign by copying the unaligned
147  *	portion of the data into a new mbuf chain and freeing the portions
148  *	of the old chain that were replaced.
149  *
150  *	We cannot simply realign the data within the existing mbuf chain
151  *	because the underlying buffers may contain other rpc commands and
152  *	we cannot afford to overwrite them.
153  *
154  *	We would prefer to avoid this situation entirely.  The situation does
155  *	not occur with NFS/UDP and is supposed to only occassionally occur
156  *	with TCP.  Use vfs.nfs.realign_count and realign_test to check this.
157  *
158  */
159 int
160 newnfs_realign(struct mbuf **pm, int how)
161 {
162 	struct mbuf *m, *n;
163 	int off, space;
164 
165 	++nfs_realign_test;
166 	while ((m = *pm) != NULL) {
167 		if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) {
168 			/*
169 			 * NB: we can't depend on m_pkthdr.len to help us
170 			 * decide what to do here.  May not be worth doing
171 			 * the m_length calculation as m_copyback will
172 			 * expand the mbuf chain below as needed.
173 			 */
174 			space = m_length(m, NULL);
175 			if (space >= MINCLSIZE) {
176 				/* NB: m_copyback handles space > MCLBYTES */
177 				n = m_getcl(how, MT_DATA, 0);
178 			} else
179 				n = m_get(how, MT_DATA);
180 			if (n == NULL)
181 				return (ENOMEM);
182 			/*
183 			 * Align the remainder of the mbuf chain.
184 			 */
185 			n->m_len = 0;
186 			off = 0;
187 			while (m != NULL) {
188 				m_copyback(n, off, m->m_len, mtod(m, caddr_t));
189 				off += m->m_len;
190 				m = m->m_next;
191 			}
192 			m_freem(*pm);
193 			*pm = n;
194 			++nfs_realign_count;
195 			break;
196 		}
197 		pm = &m->m_next;
198 	}
199 
200 	return (0);
201 }
202 #endif	/* __NO_STRICT_ALIGNMENT */
203 
204 #ifdef notdef
205 static void
206 nfsrv_object_create(struct vnode *vp, struct thread *td)
207 {
208 
209 	if (vp == NULL || vp->v_type != VREG)
210 		return;
211 	(void) vfs_object_create(vp, td, td->td_ucred);
212 }
213 #endif
214 
215 /*
216  * Look up a file name. Basically just initialize stuff and call namei().
217  */
218 int
219 nfsrv_lookupfilename(struct nameidata *ndp, char *fname, NFSPROC_T *p)
220 {
221 	int error;
222 
223 	NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, fname,
224 	    p);
225 	error = namei(ndp);
226 	if (!error) {
227 		NDFREE(ndp, NDF_ONLY_PNBUF);
228 	}
229 	return (error);
230 }
231 
232 /*
233  * Copy NFS uid, gids to the cred structure.
234  */
235 void
236 newnfs_copycred(struct nfscred *nfscr, struct ucred *cr)
237 {
238 
239 	KASSERT(nfscr->nfsc_ngroups >= 0,
240 	    ("newnfs_copycred: negative nfsc_ngroups"));
241 	cr->cr_uid = nfscr->nfsc_uid;
242 	crsetgroups(cr, nfscr->nfsc_ngroups, nfscr->nfsc_groups);
243 }
244 
245 /*
246  * Map args from nfsmsleep() to msleep().
247  */
248 int
249 nfsmsleep(void *chan, void *mutex, int prio, const char *wmesg,
250     struct timespec *ts)
251 {
252 	u_int64_t nsecval;
253 	int error, timeo;
254 
255 	if (ts) {
256 		timeo = hz * ts->tv_sec;
257 		nsecval = (u_int64_t)ts->tv_nsec;
258 		nsecval = ((nsecval * ((u_int64_t)hz)) + 500000000) /
259 		    1000000000;
260 		timeo += (int)nsecval;
261 	} else {
262 		timeo = 0;
263 	}
264 	error = msleep(chan, (struct mtx *)mutex, prio, wmesg, timeo);
265 	return (error);
266 }
267 
268 /*
269  * Get the file system info for the server. For now, just assume FFS.
270  */
271 void
272 nfsvno_getfs(struct nfsfsinfo *sip, int isdgram)
273 {
274 	int pref;
275 
276 	/*
277 	 * XXX
278 	 * There should be file system VFS OP(s) to get this information.
279 	 * For now, assume ufs.
280 	 */
281 	if (isdgram)
282 		pref = NFS_MAXDGRAMDATA;
283 	else
284 		pref = NFS_MAXDATA;
285 	sip->fs_rtmax = NFS_MAXDATA;
286 	sip->fs_rtpref = pref;
287 	sip->fs_rtmult = NFS_FABLKSIZE;
288 	sip->fs_wtmax = NFS_MAXDATA;
289 	sip->fs_wtpref = pref;
290 	sip->fs_wtmult = NFS_FABLKSIZE;
291 	sip->fs_dtpref = pref;
292 	sip->fs_maxfilesize = 0xffffffffffffffffull;
293 	sip->fs_timedelta.tv_sec = 0;
294 	sip->fs_timedelta.tv_nsec = 1;
295 	sip->fs_properties = (NFSV3FSINFO_LINK |
296 	    NFSV3FSINFO_SYMLINK | NFSV3FSINFO_HOMOGENEOUS |
297 	    NFSV3FSINFO_CANSETTIME);
298 }
299 
300 /*
301  * Do the pathconf vnode op.
302  */
303 int
304 nfsvno_pathconf(struct vnode *vp, int flag, register_t *retf,
305     struct ucred *cred, struct thread *p)
306 {
307 	int error;
308 
309 	error = VOP_PATHCONF(vp, flag, retf);
310 	if (error == EOPNOTSUPP || error == EINVAL) {
311 		/*
312 		 * Some file systems return EINVAL for name arguments not
313 		 * supported and some return EOPNOTSUPP for this case.
314 		 * So the NFSv3 Pathconf RPC doesn't fail for these cases,
315 		 * just fake them.
316 		 */
317 		switch (flag) {
318 		case _PC_LINK_MAX:
319 			*retf = LINK_MAX;
320 			break;
321 		case _PC_NAME_MAX:
322 			*retf = NAME_MAX;
323 			break;
324 		case _PC_CHOWN_RESTRICTED:
325 			*retf = 1;
326 			break;
327 		case _PC_NO_TRUNC:
328 			*retf = 1;
329 			break;
330 		default:
331 			/*
332 			 * Only happens if a _PC_xxx is added to the server,
333 			 * but this isn't updated.
334 			 */
335 			*retf = 0;
336 			printf("nfsrvd pathconf flag=%d not supp\n", flag);
337 		};
338 		error = 0;
339 	}
340 	NFSEXITCODE(error);
341 	return (error);
342 }
343 
344 /* Fake nfsrv_atroot. Just return 0 */
345 int
346 nfsrv_atroot(struct vnode *vp, long *retp)
347 {
348 
349 	return (0);
350 }
351 
352 /*
353  * Set the credentials to refer to root.
354  * If only the various BSDen could agree on whether cr_gid is a separate
355  * field or cr_groups[0]...
356  */
357 void
358 newnfs_setroot(struct ucred *cred)
359 {
360 
361 	cred->cr_uid = 0;
362 	cred->cr_groups[0] = 0;
363 	cred->cr_ngroups = 1;
364 }
365 
366 /*
367  * Get the client credential. Used for Renew and recovery.
368  */
369 struct ucred *
370 newnfs_getcred(void)
371 {
372 	struct ucred *cred;
373 	struct thread *td = curthread;
374 
375 	cred = crdup(td->td_ucred);
376 	newnfs_setroot(cred);
377 	return (cred);
378 }
379 
380 /*
381  * Nfs timer routine
382  * Call the nfsd's timer function once/sec.
383  */
384 void
385 newnfs_timer(void *arg)
386 {
387 	static time_t lasttime = 0;
388 	/*
389 	 * Call the server timer, if set up.
390 	 * The argument indicates if it is the next second and therefore
391 	 * leases should be checked.
392 	 */
393 	if (lasttime != NFSD_MONOSEC) {
394 		lasttime = NFSD_MONOSEC;
395 		if (nfsd_call_servertimer != NULL)
396 			(*nfsd_call_servertimer)();
397 	}
398 	callout_reset(&newnfsd_callout, nfscl_ticks, newnfs_timer, NULL);
399 }
400 
401 
402 /*
403  * Sleep for a short period of time unless errval == NFSERR_GRACE, where
404  * the sleep should be for 5 seconds.
405  * Since lbolt doesn't exist in FreeBSD-CURRENT, just use a timeout on
406  * an event that never gets a wakeup. Only return EINTR or 0.
407  */
408 int
409 nfs_catnap(int prio, int errval, const char *wmesg)
410 {
411 	static int non_event;
412 	int ret;
413 
414 	if (errval == NFSERR_GRACE)
415 		ret = tsleep(&non_event, prio, wmesg, 5 * hz);
416 	else
417 		ret = tsleep(&non_event, prio, wmesg, 1);
418 	if (ret != EINTR)
419 		ret = 0;
420 	return (ret);
421 }
422 
423 /*
424  * Get referral. For now, just fail.
425  */
426 struct nfsreferral *
427 nfsv4root_getreferral(struct vnode *vp, struct vnode *dvp, u_int32_t fileno)
428 {
429 
430 	return (NULL);
431 }
432 
433 static int
434 nfssvc_nfscommon(struct thread *td, struct nfssvc_args *uap)
435 {
436 	int error;
437 
438 	error = nfssvc_call(td, uap, td->td_ucred);
439 	NFSEXITCODE(error);
440 	return (error);
441 }
442 
443 static int
444 nfssvc_call(struct thread *p, struct nfssvc_args *uap, struct ucred *cred)
445 {
446 	int error = EINVAL;
447 	struct nfsd_idargs nid;
448 
449 	if (uap->flag & NFSSVC_IDNAME) {
450 		error = copyin(uap->argp, (caddr_t)&nid, sizeof (nid));
451 		if (error)
452 			goto out;
453 		error = nfssvc_idname(&nid);
454 		goto out;
455 	} else if (uap->flag & NFSSVC_GETSTATS) {
456 		error = copyout(&newnfsstats,
457 		    CAST_USER_ADDR_T(uap->argp), sizeof (newnfsstats));
458 		if (error == 0) {
459 			if ((uap->flag & NFSSVC_ZEROCLTSTATS) != 0) {
460 				newnfsstats.attrcache_hits = 0;
461 				newnfsstats.attrcache_misses = 0;
462 				newnfsstats.lookupcache_hits = 0;
463 				newnfsstats.lookupcache_misses = 0;
464 				newnfsstats.direofcache_hits = 0;
465 				newnfsstats.direofcache_misses = 0;
466 				newnfsstats.accesscache_hits = 0;
467 				newnfsstats.accesscache_misses = 0;
468 				newnfsstats.biocache_reads = 0;
469 				newnfsstats.read_bios = 0;
470 				newnfsstats.read_physios = 0;
471 				newnfsstats.biocache_writes = 0;
472 				newnfsstats.write_bios = 0;
473 				newnfsstats.write_physios = 0;
474 				newnfsstats.biocache_readlinks = 0;
475 				newnfsstats.readlink_bios = 0;
476 				newnfsstats.biocache_readdirs = 0;
477 				newnfsstats.readdir_bios = 0;
478 				newnfsstats.rpcretries = 0;
479 				newnfsstats.rpcrequests = 0;
480 				newnfsstats.rpctimeouts = 0;
481 				newnfsstats.rpcunexpected = 0;
482 				newnfsstats.rpcinvalid = 0;
483 				bzero(newnfsstats.rpccnt,
484 				    sizeof(newnfsstats.rpccnt));
485 			}
486 			if ((uap->flag & NFSSVC_ZEROSRVSTATS) != 0) {
487 				newnfsstats.srvrpc_errs = 0;
488 				newnfsstats.srv_errs = 0;
489 				newnfsstats.srvcache_inproghits = 0;
490 				newnfsstats.srvcache_idemdonehits = 0;
491 				newnfsstats.srvcache_nonidemdonehits = 0;
492 				newnfsstats.srvcache_misses = 0;
493 				newnfsstats.srvcache_tcppeak = 0;
494 				newnfsstats.srvclients = 0;
495 				newnfsstats.srvopenowners = 0;
496 				newnfsstats.srvopens = 0;
497 				newnfsstats.srvlockowners = 0;
498 				newnfsstats.srvlocks = 0;
499 				newnfsstats.srvdelegates = 0;
500 				newnfsstats.clopenowners = 0;
501 				newnfsstats.clopens = 0;
502 				newnfsstats.cllockowners = 0;
503 				newnfsstats.cllocks = 0;
504 				newnfsstats.cldelegates = 0;
505 				newnfsstats.cllocalopenowners = 0;
506 				newnfsstats.cllocalopens = 0;
507 				newnfsstats.cllocallockowners = 0;
508 				newnfsstats.cllocallocks = 0;
509 				bzero(newnfsstats.srvrpccnt,
510 				    sizeof(newnfsstats.srvrpccnt));
511 				bzero(newnfsstats.cbrpccnt,
512 				    sizeof(newnfsstats.cbrpccnt));
513 			}
514 		}
515 		goto out;
516 	} else if (uap->flag & NFSSVC_NFSUSERDPORT) {
517 		u_short sockport;
518 
519 		error = copyin(uap->argp, (caddr_t)&sockport,
520 		    sizeof (u_short));
521 		if (!error)
522 			error = nfsrv_nfsuserdport(sockport, p);
523 	} else if (uap->flag & NFSSVC_NFSUSERDDELPORT) {
524 		nfsrv_nfsuserddelport();
525 		error = 0;
526 	}
527 
528 out:
529 	NFSEXITCODE(error);
530 	return (error);
531 }
532 
533 /*
534  * called by all three modevent routines, so that it gets things
535  * initialized soon enough.
536  */
537 void
538 newnfs_portinit(void)
539 {
540 	static int inited = 0;
541 
542 	if (inited)
543 		return;
544 	inited = 1;
545 	/* Initialize SMP locks used by both client and server. */
546 	mtx_init(&newnfsd_mtx, "newnfsd_mtx", NULL, MTX_DEF);
547 	mtx_init(&nfs_state_mutex, "nfs_state_mutex", NULL, MTX_DEF);
548 }
549 
550 /*
551  * Determine if the file system supports NFSv4 ACLs.
552  * Return 1 if it does, 0 otherwise.
553  */
554 int
555 nfs_supportsnfsv4acls(struct vnode *vp)
556 {
557 	int error;
558 	register_t retval;
559 
560 	ASSERT_VOP_LOCKED(vp, "nfs supports nfsv4acls");
561 
562 	if (nfsrv_useacl == 0)
563 		return (0);
564 	error = VOP_PATHCONF(vp, _PC_ACL_NFS4, &retval);
565 	if (error == 0 && retval != 0)
566 		return (1);
567 	return (0);
568 }
569 
570 extern int (*nfsd_call_nfscommon)(struct thread *, struct nfssvc_args *);
571 
572 /*
573  * Called once to initialize data structures...
574  */
575 static int
576 nfscommon_modevent(module_t mod, int type, void *data)
577 {
578 	int error = 0;
579 	static int loaded = 0;
580 
581 	switch (type) {
582 	case MOD_LOAD:
583 		if (loaded)
584 			goto out;
585 		newnfs_portinit();
586 		mtx_init(&nfs_nameid_mutex, "nfs_nameid_mutex", NULL, MTX_DEF);
587 		mtx_init(&nfs_sockl_mutex, "nfs_sockl_mutex", NULL, MTX_DEF);
588 		mtx_init(&nfs_slock_mutex, "nfs_slock_mutex", NULL, MTX_DEF);
589 		mtx_init(&nfs_req_mutex, "nfs_req_mutex", NULL, MTX_DEF);
590 		mtx_init(&nfsrv_nfsuserdsock.nr_mtx, "nfsuserd", NULL,
591 		    MTX_DEF);
592 		callout_init(&newnfsd_callout, CALLOUT_MPSAFE);
593 		newnfs_init();
594 		nfsd_call_nfscommon = nfssvc_nfscommon;
595 		loaded = 1;
596 		break;
597 
598 	case MOD_UNLOAD:
599 		if (newnfs_numnfsd != 0 || nfsrv_nfsuserd != 0 ||
600 		    nfs_numnfscbd != 0) {
601 			error = EBUSY;
602 			break;
603 		}
604 
605 		nfsd_call_nfscommon = NULL;
606 		callout_drain(&newnfsd_callout);
607 		/* and get rid of the mutexes */
608 		mtx_destroy(&nfs_nameid_mutex);
609 		mtx_destroy(&newnfsd_mtx);
610 		mtx_destroy(&nfs_state_mutex);
611 		mtx_destroy(&nfs_sockl_mutex);
612 		mtx_destroy(&nfs_slock_mutex);
613 		mtx_destroy(&nfs_req_mutex);
614 		mtx_destroy(&nfsrv_nfsuserdsock.nr_mtx);
615 		loaded = 0;
616 		break;
617 	default:
618 		error = EOPNOTSUPP;
619 		break;
620 	}
621 
622 out:
623 	NFSEXITCODE(error);
624 	return error;
625 }
626 static moduledata_t nfscommon_mod = {
627 	"nfscommon",
628 	nfscommon_modevent,
629 	NULL,
630 };
631 DECLARE_MODULE(nfscommon, nfscommon_mod, SI_SUB_VFS, SI_ORDER_ANY);
632 
633 /* So that loader and kldload(2) can find us, wherever we are.. */
634 MODULE_VERSION(nfscommon, 1);
635 MODULE_DEPEND(nfscommon, nfssvc, 1, 1, 1);
636 MODULE_DEPEND(nfscommon, krpc, 1, 1, 1);
637 
638