1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25/*
26 *	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T
27 *		All rights reserved.
28 */
29
30#include <sys/errno.h>
31#include <sys/param.h>
32#include <sys/types.h>
33#include <sys/user.h>
34#include <sys/stat.h>
35#include <sys/time.h>
36#include <sys/utsname.h>
37#include <sys/vfs.h>
38#include <sys/vfs_opreg.h>
39#include <sys/vnode.h>
40#include <sys/pathname.h>
41#include <sys/bootconf.h>
42#include <fs/fs_subr.h>
43#include <rpc/types.h>
44#include <nfs/nfs.h>
45#include <nfs/nfs4.h>
46#include <nfs/nfs_clnt.h>
47#include <nfs/rnode.h>
48#include <nfs/mount.h>
49#include <nfs/nfssys.h>
50#include <sys/debug.h>
51#include <sys/cmn_err.h>
52#include <sys/file.h>
53#include <sys/fcntl.h>
54#include <sys/zone.h>
55
56/*
57 * This is the loadable module wrapper.
58 */
59#include <sys/systm.h>
60#include <sys/modctl.h>
61#include <sys/syscall.h>
62#include <sys/ddi.h>
63
64#include <rpc/types.h>
65#include <rpc/auth.h>
66#include <rpc/clnt.h>
67#include <rpc/svc.h>
68
69/*
70 * The pseudo NFS filesystem to allow diskless booting to dynamically
71 * mount either a NFS V2, NFS V3, or NFS V4 filesystem.  This only implements
72 * the VFS_MOUNTROOT op and is only intended to be used by the
73 * diskless booting code until the real root filesystem is mounted.
74 * Nothing else should ever call this!
75 *
76 * The strategy is that if the initial rootfs type is set to "nfsdyn"
77 * by loadrootmodules() this filesystem is called to mount the
78 * root filesystem.  It first attempts to mount a V4 filesystem, and if that
79 * fails due to an RPC version mismatch it tries V3 and finally V2.
80 * Once the real mount succeeds the vfsops and rootfs name are changed
81 * to reflect the real filesystem type.
82 */
83static int nfsdyninit(int, char *);
84static int nfsdyn_mountroot(vfs_t *, whymountroot_t);
85
86vfsops_t *nfsdyn_vfsops;
87
88/*
89 * The following data structures are used to configure the NFS
90 * system call, the NFS Version 2 client VFS, and the NFS Version
91 * 3 client VFS into the system.  The NFS Version 4 structures are defined in
92 * nfs4_common.c
93 */
94
95/*
96 * The NFS system call.
97 */
98static struct sysent nfssysent = {
99	2,
100	SE_32RVAL1 | SE_ARGC | SE_NOUNLOAD,
101	nfssys
102};
103
104static struct modlsys modlsys = {
105	&mod_syscallops,
106	"NFS syscall, client, and common",
107	&nfssysent
108};
109
110#ifdef _SYSCALL32_IMPL
111static struct modlsys modlsys32 = {
112	&mod_syscallops32,
113	"NFS syscall, client, and common (32-bit)",
114	&nfssysent
115};
116#endif /* _SYSCALL32_IMPL */
117
118/*
119 * The NFS Dynamic client VFS.
120 */
121static vfsdef_t vfw = {
122	VFSDEF_VERSION,
123	"nfsdyn",
124	nfsdyninit,
125	VSW_ZMOUNT,
126	NULL
127};
128
129static struct modlfs modlfs = {
130	&mod_fsops,
131	"network filesystem",
132	&vfw
133};
134
135/*
136 * The NFS Version 2 client VFS.
137 */
138static vfsdef_t vfw2 = {
139	VFSDEF_VERSION,
140	"nfs",
141	nfsinit,
142	VSW_CANREMOUNT|VSW_NOTZONESAFE|VSW_STATS|VSW_ZMOUNT,
143	NULL
144};
145
146static struct modlfs modlfs2 = {
147	&mod_fsops,
148	"network filesystem version 2",
149	&vfw2
150};
151
152/*
153 * The NFS Version 3 client VFS.
154 */
155static vfsdef_t vfw3 = {
156	VFSDEF_VERSION,
157	"nfs3",
158	nfs3init,
159	VSW_CANREMOUNT|VSW_NOTZONESAFE|VSW_STATS|VSW_ZMOUNT,
160	NULL
161};
162
163static struct modlfs modlfs3 = {
164	&mod_fsops,
165	"network filesystem version 3",
166	&vfw3
167};
168
169extern struct modlfs modlfs4;
170
171/*
172 * We have too many linkage structures so we define our own XXX
173 */
174struct modlinkage_big {
175	int		ml_rev;		/* rev of loadable modules system */
176	void		*ml_linkage[7];	/* NULL terminated list of */
177					/* linkage structures */
178};
179
180/*
181 * All of the module configuration linkages required to configure
182 * the system call and client VFS's into the system.
183 */
184static struct modlinkage_big modlinkage = {
185	MODREV_1,
186	&modlsys,
187#ifdef _SYSCALL32_IMPL
188	&modlsys32,
189#endif
190	&modlfs,
191	&modlfs2,
192	&modlfs3,
193	&modlfs4,
194	NULL
195};
196
197/*
198 * specfs - for getfsname only??
199 * rpcmod - too many symbols to build stubs for them all
200 */
201char _depends_on[] = "fs/specfs strmod/rpcmod misc/rpcsec";
202
203/*
204 * This routine is invoked automatically when the kernel module
205 * containing this routine is loaded.  This allows module specific
206 * initialization to be done when the module is loaded.
207 */
208int
209_init(void)
210{
211	int status;
212
213	if ((status = nfs_clntinit()) != 0) {
214		cmn_err(CE_WARN, "_init: nfs_clntinit failed");
215		return (status);
216	}
217
218	/*
219	 * Create the version specific kstats.
220	 *
221	 * PSARC 2001/697 Contract Private Interface
222	 * All nfs kstats are under SunMC contract
223	 * Please refer to the PSARC listed above and contact
224	 * SunMC before making any changes!
225	 *
226	 * Changes must be reviewed by Solaris File Sharing
227	 * Changes must be communicated to contract-2001-697@sun.com
228	 *
229	 */
230
231	zone_key_create(&nfsstat_zone_key, nfsstat_zone_init, NULL,
232	    nfsstat_zone_fini);
233	status = mod_install((struct modlinkage *)&modlinkage);
234
235	if (status)  {
236		(void) zone_key_delete(nfsstat_zone_key);
237
238		/*
239		 * Failed to install module, cleanup previous
240		 * initialization work.
241		 */
242		nfs_clntfini();
243
244		/*
245		 * Clean up work performed indirectly by mod_installfs()
246		 * as a result of our call to mod_install().
247		 */
248		nfs4fini();
249		nfs3fini();
250		nfsfini();
251	}
252	return (status);
253}
254
255int
256_fini(void)
257{
258	/* Don't allow module to be unloaded */
259	return (EBUSY);
260}
261
262int
263_info(struct modinfo *modinfop)
264{
265	return (mod_info((struct modlinkage *)&modlinkage, modinfop));
266}
267
268/*
269 * General utilities
270 */
271
272/*
273 * Returns the preferred transfer size in bytes based on
274 * what network interfaces are available.
275 */
276int
277nfstsize(void)
278{
279	/*
280	 * For the moment, just return NFS_MAXDATA until we can query the
281	 * appropriate transport.
282	 */
283	return (NFS_MAXDATA);
284}
285
286/*
287 * Returns the preferred transfer size in bytes based on
288 * what network interfaces are available.
289 */
290
291/* this should reflect the largest transfer size possible */
292static int nfs3_max_transfer_size = 1024 * 1024;
293
294int
295nfs3tsize(void)
296{
297	/*
298	 * For the moment, just return nfs3_max_transfer_size until we
299	 * can query the appropriate transport.
300	 */
301	return (nfs3_max_transfer_size);
302}
303
304static uint_t nfs3_max_transfer_size_clts = 32 * 1024;
305static uint_t nfs3_max_transfer_size_cots = 1024 * 1024;
306static uint_t nfs3_max_transfer_size_rdma = 1024 * 1024;
307
308uint_t
309nfs3_tsize(struct knetconfig *knp)
310{
311
312	if (knp->knc_semantics == NC_TPI_COTS_ORD ||
313	    knp->knc_semantics == NC_TPI_COTS)
314		return (nfs3_max_transfer_size_cots);
315	if (knp->knc_semantics == NC_TPI_RDMA)
316		return (nfs3_max_transfer_size_rdma);
317	return (nfs3_max_transfer_size_clts);
318}
319
320uint_t
321rfs3_tsize(struct svc_req *req)
322{
323
324	if (req->rq_xprt->xp_type == T_COTS_ORD ||
325	    req->rq_xprt->xp_type == T_COTS)
326		return (nfs3_max_transfer_size_cots);
327	if (req->rq_xprt->xp_type == T_RDMA)
328		return (nfs3_max_transfer_size_rdma);
329	return (nfs3_max_transfer_size_clts);
330}
331
332/* ARGSUSED */
333static int
334nfsdyninit(int fstyp, char *name)
335{
336	static const fs_operation_def_t nfsdyn_vfsops_template[] = {
337		VFSNAME_MOUNTROOT, { .vfs_mountroot = nfsdyn_mountroot },
338		NULL, NULL
339	};
340	int error;
341
342	error = vfs_setfsops(fstyp, nfsdyn_vfsops_template, &nfsdyn_vfsops);
343	if (error != 0)
344		return (error);
345
346	return (0);
347}
348
349/* ARGSUSED */
350static int
351nfsdyn_mountroot(vfs_t *vfsp, whymountroot_t why)
352{
353	char root_hostname[SYS_NMLN+1];
354	struct servinfo *svp;
355	int error;
356	int vfsflags;
357	char *root_path;
358	struct pathname pn;
359	char *name;
360	static char token[10];
361	struct nfs_args args;		/* nfs mount arguments */
362
363	bzero(&args, sizeof (args));
364
365	/* do this BEFORE getfile which causes xid stamps to be initialized */
366	clkset(-1L);		/* hack for now - until we get time svc? */
367
368	if (why == ROOT_REMOUNT) {
369		/*
370		 * Shouldn't happen.
371		 */
372		panic("nfs3_mountroot: why == ROOT_REMOUNT\n");
373	}
374
375	if (why == ROOT_UNMOUNT) {
376		/*
377		 * Nothing to do for NFS.
378		 */
379		return (0);
380	}
381
382	/*
383	 * why == ROOT_INIT
384	 */
385
386	name = token;
387	*name = 0;
388	getfsname("root", name, sizeof (token));
389
390	pn_alloc(&pn);
391	root_path = pn.pn_path;
392
393	svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
394	mutex_init(&svp->sv_lock, NULL, MUTEX_DEFAULT, NULL);
395	svp->sv_knconf = kmem_zalloc(sizeof (*svp->sv_knconf), KM_SLEEP);
396	svp->sv_knconf->knc_protofmly = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
397	svp->sv_knconf->knc_proto = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
398
399	/*
400	 * First try version 4
401	 */
402	vfs_setops(vfsp, nfs4_vfsops);
403	args.addr = &svp->sv_addr;
404	args.fh = (char *)&svp->sv_fhandle;
405	args.knconf = svp->sv_knconf;
406	args.hostname = root_hostname;
407	vfsflags = 0;
408
409	if (error = mount_root(*name ? name : "root", root_path, NFS_V4,
410	    &args, &vfsflags)) {
411		if (error != EPROTONOSUPPORT) {
412			nfs_cmn_err(error, CE_WARN,
413			    "Unable to mount NFS root filesystem: %m");
414			sv_free(svp);
415			pn_free(&pn);
416			vfs_setops(vfsp, nfsdyn_vfsops);
417			return (error);
418		}
419
420		/*
421		 * Then try version 3
422		 */
423		bzero(&args, sizeof (args));
424		vfs_setops(vfsp, nfs3_vfsops);
425		args.addr = &svp->sv_addr;
426		args.fh = (char *)&svp->sv_fhandle;
427		args.knconf = svp->sv_knconf;
428		args.hostname = root_hostname;
429		vfsflags = 0;
430
431		if (error = mount_root(*name ? name : "root", root_path,
432		    NFS_V3, &args, &vfsflags)) {
433			if (error != EPROTONOSUPPORT) {
434				nfs_cmn_err(error, CE_WARN,
435				    "Unable to mount NFS root filesystem: %m");
436				sv_free(svp);
437				pn_free(&pn);
438				vfs_setops(vfsp, nfsdyn_vfsops);
439				return (error);
440			}
441
442			/*
443			 * Finally, try version 2
444			 */
445			bzero(&args, sizeof (args));
446			args.addr = &svp->sv_addr;
447			args.fh = (char *)&svp->sv_fhandle.fh_buf;
448			args.knconf = svp->sv_knconf;
449			args.hostname = root_hostname;
450			vfsflags = 0;
451
452			vfs_setops(vfsp, nfs_vfsops);
453
454			if (error = mount_root(*name ? name : "root",
455			    root_path, NFS_VERSION, &args, &vfsflags)) {
456				nfs_cmn_err(error, CE_WARN,
457				    "Unable to mount NFS root filesystem: %m");
458				sv_free(svp);
459				pn_free(&pn);
460				vfs_setops(vfsp, nfsdyn_vfsops);
461				return (error);
462			}
463		}
464	}
465
466	sv_free(svp);
467	pn_free(&pn);
468	return (VFS_MOUNTROOT(vfsp, why));
469}
470
471int
472nfs_setopts(vnode_t *vp, model_t model, struct nfs_args *buf)
473{
474	mntinfo_t *mi;			/* mount info, pointed at by vfs */
475	STRUCT_HANDLE(nfs_args, args);
476	int flags;
477
478#ifdef lint
479	model = model;
480#endif
481
482	STRUCT_SET_HANDLE(args, model, buf);
483
484	flags = STRUCT_FGET(args, flags);
485
486	/*
487	 * Set option fields in mount info record
488	 */
489	mi = VTOMI(vp);
490
491	if (flags & NFSMNT_NOAC) {
492		mi->mi_flags |= MI_NOAC;
493		PURGE_ATTRCACHE(vp);
494	}
495	if (flags & NFSMNT_NOCTO)
496		mi->mi_flags |= MI_NOCTO;
497	if (flags & NFSMNT_LLOCK)
498		mi->mi_flags |= MI_LLOCK;
499	if (flags & NFSMNT_GRPID)
500		mi->mi_flags |= MI_GRPID;
501	if (flags & NFSMNT_RETRANS) {
502		if (STRUCT_FGET(args, retrans) < 0)
503			return (EINVAL);
504		mi->mi_retrans = STRUCT_FGET(args, retrans);
505	}
506	if (flags & NFSMNT_TIMEO) {
507		if (STRUCT_FGET(args, timeo) <= 0)
508			return (EINVAL);
509		mi->mi_timeo = STRUCT_FGET(args, timeo);
510		/*
511		 * The following scales the standard deviation and
512		 * and current retransmission timer to match the
513		 * initial value for the timeout specified.
514		 */
515		mi->mi_timers[NFS_CALLTYPES].rt_deviate =
516		    (mi->mi_timeo * hz * 2) / 5;
517		mi->mi_timers[NFS_CALLTYPES].rt_rtxcur =
518		    mi->mi_timeo * hz / 10;
519	}
520	if (flags & NFSMNT_RSIZE) {
521		if (STRUCT_FGET(args, rsize) <= 0)
522			return (EINVAL);
523		mi->mi_tsize = MIN(mi->mi_tsize, STRUCT_FGET(args, rsize));
524		mi->mi_curread = MIN(mi->mi_curread, mi->mi_tsize);
525	}
526	if (flags & NFSMNT_WSIZE) {
527		if (STRUCT_FGET(args, wsize) <= 0)
528			return (EINVAL);
529		mi->mi_stsize = MIN(mi->mi_stsize, STRUCT_FGET(args, wsize));
530		mi->mi_curwrite = MIN(mi->mi_curwrite, mi->mi_stsize);
531	}
532	if (flags & NFSMNT_ACREGMIN) {
533		if (STRUCT_FGET(args, acregmin) < 0)
534			mi->mi_acregmin = ACMINMAX;
535		else
536			mi->mi_acregmin = MIN(STRUCT_FGET(args, acregmin),
537			    ACMINMAX);
538		mi->mi_acregmin = SEC2HR(mi->mi_acregmin);
539	}
540	if (flags & NFSMNT_ACREGMAX) {
541		if (STRUCT_FGET(args, acregmax) < 0)
542			mi->mi_acregmax = ACMAXMAX;
543		else
544			mi->mi_acregmax = MIN(STRUCT_FGET(args, acregmax),
545			    ACMAXMAX);
546		mi->mi_acregmax = SEC2HR(mi->mi_acregmax);
547	}
548	if (flags & NFSMNT_ACDIRMIN) {
549		if (STRUCT_FGET(args, acdirmin) < 0)
550			mi->mi_acdirmin = ACMINMAX;
551		else
552			mi->mi_acdirmin = MIN(STRUCT_FGET(args, acdirmin),
553			    ACMINMAX);
554		mi->mi_acdirmin = SEC2HR(mi->mi_acdirmin);
555	}
556	if (flags & NFSMNT_ACDIRMAX) {
557		if (STRUCT_FGET(args, acdirmax) < 0)
558			mi->mi_acdirmax = ACMAXMAX;
559		else
560			mi->mi_acdirmax = MIN(STRUCT_FGET(args, acdirmax),
561			    ACMAXMAX);
562		mi->mi_acdirmax = SEC2HR(mi->mi_acdirmax);
563	}
564
565	if (flags & NFSMNT_LOOPBACK)
566		mi->mi_flags |= MI_LOOPBACK;
567
568	return (0);
569}
570
571/*
572 * Set or Clear direct I/O flag
573 * VOP_RWLOCK() is held for write access to prevent a race condition
574 * which would occur if a process is in the middle of a write when
575 * directio flag gets set. It is possible that all pages may not get flushed.
576 */
577
578/* ARGSUSED */
579int
580nfs_directio(vnode_t *vp, int cmd, cred_t *cr)
581{
582	int	error = 0;
583	rnode_t	*rp;
584
585	rp = VTOR(vp);
586
587	if (cmd == DIRECTIO_ON) {
588
589		if (rp->r_flags & RDIRECTIO)
590			return (0);
591
592		/*
593		 * Flush the page cache.
594		 */
595
596		(void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL);
597
598		if (rp->r_flags & RDIRECTIO) {
599			VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL);
600			return (0);
601		}
602
603		if (vn_has_cached_data(vp) &&
604		    ((rp->r_flags & RDIRTY) || rp->r_awcount > 0)) {
605			error = VOP_PUTPAGE(vp, (offset_t)0, (uint_t)0,
606			    B_INVAL, cr, NULL);
607			if (error) {
608				if (error == ENOSPC || error == EDQUOT) {
609					mutex_enter(&rp->r_statelock);
610					if (!rp->r_error)
611						rp->r_error = error;
612					mutex_exit(&rp->r_statelock);
613				}
614				VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL);
615				return (error);
616			}
617		}
618
619		mutex_enter(&rp->r_statelock);
620		rp->r_flags |= RDIRECTIO;
621		mutex_exit(&rp->r_statelock);
622		VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL);
623		return (0);
624	}
625
626	if (cmd == DIRECTIO_OFF) {
627		mutex_enter(&rp->r_statelock);
628		rp->r_flags &= ~RDIRECTIO;	/* disable direct mode */
629		mutex_exit(&rp->r_statelock);
630		return (0);
631	}
632
633	return (EINVAL);
634}
635