xref: /freebsd/sys/fs/nfs/nfs_commonport.c (revision 3157ba21)
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 #include <vm/uma_int.h>
53 
54 extern int nfscl_ticks;
55 extern int nfsrv_nfsuserd;
56 extern struct nfssockreq nfsrv_nfsuserdsock;
57 extern void (*nfsd_call_recall)(struct vnode *, int, struct ucred *,
58     struct thread *);
59 extern int nfsrv_useacl;
60 struct mount nfsv4root_mnt;
61 int newnfs_numnfsd = 0;
62 struct nfsstats newnfsstats;
63 int nfs_numnfscbd = 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, newnfs, CTLFLAG_RW, 0, "New NFS filesystem");
73 SYSCTL_INT(_vfs_newnfs, OID_AUTO, newnfs_realign_test, CTLFLAG_RW, &nfs_realign_test, 0, "");
74 SYSCTL_INT(_vfs_newnfs, OID_AUTO, newnfs_realign_count, CTLFLAG_RW, &nfs_realign_count, 0, "");
75 SYSCTL_INT(_vfs_newnfs, OID_AUTO, nfs4acl_enable, CTLFLAG_RW, &nfsrv_useacl, 0, "");
76 SYSCTL_STRING(_vfs_newnfs, OID_AUTO, callback_addr, CTLFLAG_RW,
77     nfsv4_callbackaddr, sizeof(nfsv4_callbackaddr), "");
78 
79 /*
80  * Defines for malloc
81  * (Here for FreeBSD, since they allocate storage.)
82  */
83 MALLOC_DEFINE(M_NEWNFSRVCACHE, "NFSD srvcache", "NFSD Server Request Cache");
84 MALLOC_DEFINE(M_NEWNFSDCLIENT, "NFSD V4client", "NFSD V4 Client Id");
85 MALLOC_DEFINE(M_NEWNFSDSTATE, "NFSD V4state",
86     "NFSD V4 State (Openowner, Open, Lockowner, Delegation");
87 MALLOC_DEFINE(M_NEWNFSDLOCK, "NFSD V4lock", "NFSD V4 byte range lock");
88 MALLOC_DEFINE(M_NEWNFSDLOCKFILE, "NFSD lckfile", "NFSD Open/Lock file");
89 MALLOC_DEFINE(M_NEWNFSSTRING, "NFSD string", "NFSD V4 long string");
90 MALLOC_DEFINE(M_NEWNFSUSERGROUP, "NFSD usrgroup", "NFSD V4 User/group map");
91 MALLOC_DEFINE(M_NEWNFSDREQ, "NFS req", "NFS request header");
92 MALLOC_DEFINE(M_NEWNFSFH, "NFS fh", "NFS file handle");
93 MALLOC_DEFINE(M_NEWNFSCLOWNER, "NFSCL owner", "NFSCL Open Owner");
94 MALLOC_DEFINE(M_NEWNFSCLOPEN, "NFSCL open", "NFSCL Open");
95 MALLOC_DEFINE(M_NEWNFSCLDELEG, "NFSCL deleg", "NFSCL Delegation");
96 MALLOC_DEFINE(M_NEWNFSCLCLIENT, "NFSCL client", "NFSCL Client");
97 MALLOC_DEFINE(M_NEWNFSCLLOCKOWNER, "NFSCL lckown", "NFSCL Lock Owner");
98 MALLOC_DEFINE(M_NEWNFSCLLOCK, "NFSCL lck", "NFSCL Lock");
99 MALLOC_DEFINE(M_NEWNFSV4NODE, "NEWNFSnode", "New nfs vnode");
100 MALLOC_DEFINE(M_NEWNFSDIRECTIO, "NEWdirectio", "New nfs Direct IO buffer");
101 MALLOC_DEFINE(M_NEWNFSDIROFF, "NFSCL diroffdiroff",
102     "New NFS directory offset data");
103 MALLOC_DEFINE(M_NEWNFSDROLLBACK, "NFSD rollback",
104     "New NFS local lock rollback");
105 
106 /*
107  * Definition of mutex locks.
108  * newnfsd_mtx is used in nfsrvd_nfsd() to protect the nfs socket list
109  * and assorted other nfsd structures.
110  * Giant is used to protect the nfsd list and count, which is just
111  *  updated when nfsd's start/stop and is grabbed for nfsrvd_dorpc()
112  *  for the VFS ops.
113  */
114 struct mtx newnfsd_mtx;
115 struct mtx nfs_sockl_mutex;
116 struct mtx nfs_state_mutex;
117 struct mtx nfs_nameid_mutex;
118 struct mtx nfs_req_mutex;
119 struct mtx nfs_slock_mutex;
120 
121 /* local functions */
122 static int nfssvc_call(struct thread *, struct nfssvc_args *, struct ucred *);
123 
124 #ifdef __NO_STRICT_ALIGNMENT
125 /*
126  * These architectures don't need re-alignment, so just return.
127  */
128 void
129 newnfs_realign(struct mbuf **pm)
130 {
131 
132 	return;
133 }
134 #else	/* !__NO_STRICT_ALIGNMENT */
135 /*
136  *	newnfs_realign:
137  *
138  *	Check for badly aligned mbuf data and realign by copying the unaligned
139  *	portion of the data into a new mbuf chain and freeing the portions
140  *	of the old chain that were replaced.
141  *
142  *	We cannot simply realign the data within the existing mbuf chain
143  *	because the underlying buffers may contain other rpc commands and
144  *	we cannot afford to overwrite them.
145  *
146  *	We would prefer to avoid this situation entirely.  The situation does
147  *	not occur with NFS/UDP and is supposed to only occassionally occur
148  *	with TCP.  Use vfs.nfs.realign_count and realign_test to check this.
149  *
150  */
151 void
152 newnfs_realign(struct mbuf **pm)
153 {
154 	struct mbuf *m, *n;
155 	int off, space;
156 
157 	++nfs_realign_test;
158 	while ((m = *pm) != NULL) {
159 		if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) {
160 			/*
161 			 * NB: we can't depend on m_pkthdr.len to help us
162 			 * decide what to do here.  May not be worth doing
163 			 * the m_length calculation as m_copyback will
164 			 * expand the mbuf chain below as needed.
165 			 */
166 			space = m_length(m, NULL);
167 			if (space >= MINCLSIZE) {
168 				/* NB: m_copyback handles space > MCLBYTES */
169 				n = m_getcl(M_WAITOK, MT_DATA, 0);
170 			} else
171 				n = m_get(M_WAITOK, MT_DATA);
172 			if (n == NULL)
173 				return;
174 			/*
175 			 * Align the remainder of the mbuf chain.
176 			 */
177 			n->m_len = 0;
178 			off = 0;
179 			while (m != NULL) {
180 				m_copyback(n, off, m->m_len, mtod(m, caddr_t));
181 				off += m->m_len;
182 				m = m->m_next;
183 			}
184 			m_freem(*pm);
185 			*pm = n;
186 			++nfs_realign_count;
187 			break;
188 		}
189 		pm = &m->m_next;
190 	}
191 }
192 #endif	/* __NO_STRICT_ALIGNMENT */
193 
194 #ifdef notdef
195 static void
196 nfsrv_object_create(struct vnode *vp, struct thread *td)
197 {
198 
199 	if (vp == NULL || vp->v_type != VREG)
200 		return;
201 	(void) vfs_object_create(vp, td, td->td_ucred);
202 }
203 #endif
204 
205 /*
206  * Look up a file name. Basically just initialize stuff and call namei().
207  */
208 int
209 nfsrv_lookupfilename(struct nameidata *ndp, char *fname, NFSPROC_T *p)
210 {
211 	int error;
212 
213 	NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, fname, p);
214 	error = namei(ndp);
215 	if (!error) {
216 		NDFREE(ndp, NDF_ONLY_PNBUF);
217 	}
218 	return (error);
219 }
220 
221 /*
222  * Copy NFS uid, gids to the cred structure.
223  */
224 void
225 newnfs_copycred(struct nfscred *nfscr, struct ucred *cr)
226 {
227 
228 	KASSERT(nfscr->nfsc_ngroups >= 0,
229 	    ("newnfs_copycred: negative nfsc_ngroups"));
230 	cr->cr_uid = nfscr->nfsc_uid;
231 	crsetgroups(cr, nfscr->nfsc_ngroups, nfscr->nfsc_groups);
232 }
233 
234 /*
235  * Map args from nfsmsleep() to msleep().
236  */
237 int
238 nfsmsleep(void *chan, void *mutex, int prio, const char *wmesg,
239     struct timespec *ts)
240 {
241 	u_int64_t nsecval;
242 	int error, timeo;
243 
244 	if (ts) {
245 		timeo = hz * ts->tv_sec;
246 		nsecval = (u_int64_t)ts->tv_nsec;
247 		nsecval = ((nsecval * ((u_int64_t)hz)) + 500000000) /
248 		    1000000000;
249 		timeo += (int)nsecval;
250 	} else {
251 		timeo = 0;
252 	}
253 	error = msleep(chan, (struct mtx *)mutex, prio, wmesg, timeo);
254 	return (error);
255 }
256 
257 /*
258  * Get the file system info for the server. For now, just assume FFS.
259  */
260 void
261 nfsvno_getfs(struct nfsfsinfo *sip, int isdgram)
262 {
263 	int pref;
264 
265 	/*
266 	 * XXX
267 	 * There should be file system VFS OP(s) to get this information.
268 	 * For now, assume ufs.
269 	 */
270 	if (isdgram)
271 		pref = NFS_MAXDGRAMDATA;
272 	else
273 		pref = NFS_MAXDATA;
274 	sip->fs_rtmax = NFS_MAXDATA;
275 	sip->fs_rtpref = pref;
276 	sip->fs_rtmult = NFS_FABLKSIZE;
277 	sip->fs_wtmax = NFS_MAXDATA;
278 	sip->fs_wtpref = pref;
279 	sip->fs_wtmult = NFS_FABLKSIZE;
280 	sip->fs_dtpref = pref;
281 	sip->fs_maxfilesize = 0xffffffffffffffffull;
282 	sip->fs_timedelta.tv_sec = 0;
283 	sip->fs_timedelta.tv_nsec = 1;
284 	sip->fs_properties = (NFSV3FSINFO_LINK |
285 	    NFSV3FSINFO_SYMLINK | NFSV3FSINFO_HOMOGENEOUS |
286 	    NFSV3FSINFO_CANSETTIME);
287 }
288 
289 /* Fake nfsrv_atroot. Just return 0 */
290 int
291 nfsrv_atroot(struct vnode *vp, long *retp)
292 {
293 
294 	return (0);
295 }
296 
297 /*
298  * Set the credentials to refer to root.
299  * If only the various BSDen could agree on whether cr_gid is a separate
300  * field or cr_groups[0]...
301  */
302 void
303 newnfs_setroot(struct ucred *cred)
304 {
305 
306 	cred->cr_uid = 0;
307 	cred->cr_groups[0] = 0;
308 	cred->cr_ngroups = 1;
309 }
310 
311 /*
312  * Get the client credential. Used for Renew and recovery.
313  */
314 struct ucred *
315 newnfs_getcred(void)
316 {
317 	struct ucred *cred;
318 	struct thread *td = curthread;
319 
320 	cred = crdup(td->td_ucred);
321 	newnfs_setroot(cred);
322 	return (cred);
323 }
324 
325 /*
326  * Nfs timer routine
327  * Call the nfsd's timer function once/sec.
328  */
329 void
330 newnfs_timer(void *arg)
331 {
332 	static time_t lasttime = 0;
333 	/*
334 	 * Call the server timer, if set up.
335 	 * The argument indicates if it is the next second and therefore
336 	 * leases should be checked.
337 	 */
338 	if (lasttime != NFSD_MONOSEC) {
339 		lasttime = NFSD_MONOSEC;
340 		if (nfsd_call_servertimer != NULL)
341 			(*nfsd_call_servertimer)();
342 	}
343 	callout_reset(&newnfsd_callout, nfscl_ticks, newnfs_timer, NULL);
344 }
345 
346 
347 /*
348  * Sleep for a short period of time unless errval == NFSERR_GRACE, where
349  * the sleep should be for 5 seconds.
350  * Since lbolt doesn't exist in FreeBSD-CURRENT, just use a timeout on
351  * an event that never gets a wakeup. Only return EINTR or 0.
352  */
353 int
354 nfs_catnap(int prio, int errval, const char *wmesg)
355 {
356 	static int non_event;
357 	int ret;
358 
359 	if (errval == NFSERR_GRACE)
360 		ret = tsleep(&non_event, prio, wmesg, 5 * hz);
361 	else
362 		ret = tsleep(&non_event, prio, wmesg, 1);
363 	if (ret != EINTR)
364 		ret = 0;
365 	return (ret);
366 }
367 
368 /*
369  * Get referral. For now, just fail.
370  */
371 struct nfsreferral *
372 nfsv4root_getreferral(struct vnode *vp, struct vnode *dvp, u_int32_t fileno)
373 {
374 
375 	return (NULL);
376 }
377 
378 static int
379 nfssvc_nfscommon(struct thread *td, struct nfssvc_args *uap)
380 {
381 	int error;
382 
383 	error = nfssvc_call(td, uap, td->td_ucred);
384 	return (error);
385 }
386 
387 static int
388 nfssvc_call(struct thread *p, struct nfssvc_args *uap, struct ucred *cred)
389 {
390 	int error = EINVAL;
391 	struct nfsd_idargs nid;
392 
393 	if (uap->flag & NFSSVC_IDNAME) {
394 		error = copyin(uap->argp, (caddr_t)&nid, sizeof (nid));
395 		if (error)
396 			return (error);
397 		error = nfssvc_idname(&nid);
398 		return (error);
399 	} else if (uap->flag & NFSSVC_GETSTATS) {
400 		error = copyout(&newnfsstats,
401 		    CAST_USER_ADDR_T(uap->argp), sizeof (newnfsstats));
402 		return (error);
403 	} else if (uap->flag & NFSSVC_NFSUSERDPORT) {
404 		u_short sockport;
405 
406 		error = copyin(uap->argp, (caddr_t)&sockport,
407 		    sizeof (u_short));
408 		if (!error)
409 			error = nfsrv_nfsuserdport(sockport, p);
410 	} else if (uap->flag & NFSSVC_NFSUSERDDELPORT) {
411 		nfsrv_nfsuserddelport();
412 		error = 0;
413 	}
414 	return (error);
415 }
416 
417 /*
418  * called by all three modevent routines, so that it gets things
419  * initialized soon enough.
420  */
421 void
422 newnfs_portinit(void)
423 {
424 	static int inited = 0;
425 
426 	if (inited)
427 		return;
428 	inited = 1;
429 	/* Initialize SMP locks used by both client and server. */
430 	mtx_init(&newnfsd_mtx, "newnfsd_mtx", NULL, MTX_DEF);
431 	mtx_init(&nfs_state_mutex, "nfs_state_mutex", NULL, MTX_DEF);
432 }
433 
434 /*
435  * Determine if the file system supports NFSv4 ACLs.
436  * Return 1 if it does, 0 otherwise.
437  */
438 int
439 nfs_supportsnfsv4acls(struct mount *mp)
440 {
441 
442 	if (mp->mnt_stat.f_fstypename == NULL)
443 		return (0);
444 	if (strcmp(mp->mnt_stat.f_fstypename, "ufs") == 0) {
445 		/* Not yet */
446 		return (0);
447 	} else if (strcmp(mp->mnt_stat.f_fstypename, "zfs") == 0) {
448 		/* Always supports them */
449 		return (1);
450 	}
451 	return (0);
452 }
453 
454 extern int (*nfsd_call_nfscommon)(struct thread *, struct nfssvc_args *);
455 
456 /*
457  * Called once to initialize data structures...
458  */
459 static int
460 nfscommon_modevent(module_t mod, int type, void *data)
461 {
462 	int error = 0;
463 	static int loaded = 0;
464 
465 	switch (type) {
466 	case MOD_LOAD:
467 		if (loaded)
468 			return (0);
469 		newnfs_portinit();
470 		mtx_init(&nfs_nameid_mutex, "nfs_nameid_mutex", NULL, MTX_DEF);
471 		mtx_init(&nfs_sockl_mutex, "nfs_sockl_mutex", NULL, MTX_DEF);
472 		mtx_init(&nfs_slock_mutex, "nfs_slock_mutex", NULL, MTX_DEF);
473 		mtx_init(&nfs_req_mutex, "nfs_req_mutex", NULL, MTX_DEF);
474 		mtx_init(&nfsrv_nfsuserdsock.nr_mtx, "nfsuserd", NULL,
475 		    MTX_DEF);
476 		callout_init(&newnfsd_callout, CALLOUT_MPSAFE);
477 		newnfs_init();
478 		nfsd_call_nfscommon = nfssvc_nfscommon;
479 		loaded = 1;
480 		break;
481 
482 	case MOD_UNLOAD:
483 		if (newnfs_numnfsd != 0 || nfsrv_nfsuserd != 0 ||
484 		    nfs_numnfscbd != 0) {
485 			error = EBUSY;
486 			break;
487 		}
488 
489 		nfsd_call_nfscommon = NULL;
490 		callout_drain(&newnfsd_callout);
491 		/* and get rid of the mutexes */
492 		mtx_destroy(&nfs_nameid_mutex);
493 		mtx_destroy(&newnfsd_mtx);
494 		mtx_destroy(&nfs_state_mutex);
495 		mtx_destroy(&nfs_sockl_mutex);
496 		mtx_destroy(&nfs_slock_mutex);
497 		mtx_destroy(&nfs_req_mutex);
498 		mtx_destroy(&nfsrv_nfsuserdsock.nr_mtx);
499 		loaded = 0;
500 		break;
501 	default:
502 		error = EOPNOTSUPP;
503 		break;
504 	}
505 	return error;
506 }
507 static moduledata_t nfscommon_mod = {
508 	"nfscommon",
509 	nfscommon_modevent,
510 	NULL,
511 };
512 DECLARE_MODULE(nfscommon, nfscommon_mod, SI_SUB_VFS, SI_ORDER_ANY);
513 
514 /* So that loader and kldload(2) can find us, wherever we are.. */
515 MODULE_VERSION(nfscommon, 1);
516 MODULE_DEPEND(nfscommon, nfssvc, 1, 1, 1);
517 MODULE_DEPEND(nfscommon, krpc, 1, 1, 1);
518 
519