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 */
83 static int nfsdyninit(int, char *);
84 static int nfsdyn_mountroot(vfs_t *, whymountroot_t);
85
86 vfsops_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 */
98 static struct sysent nfssysent = {
99 2,
100 SE_32RVAL1 | SE_ARGC | SE_NOUNLOAD,
101 nfssys
102 };
103
104 static struct modlsys modlsys = {
105 &mod_syscallops,
106 "NFS syscall, client, and common",
107 &nfssysent
108 };
109
110 #ifdef _SYSCALL32_IMPL
111 static 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 */
121 static vfsdef_t vfw = {
122 VFSDEF_VERSION,
123 "nfsdyn",
124 nfsdyninit,
125 VSW_ZMOUNT,
126 NULL
127 };
128
129 static struct modlfs modlfs = {
130 &mod_fsops,
131 "network filesystem",
132 &vfw
133 };
134
135 /*
136 * The NFS Version 2 client VFS.
137 */
138 static vfsdef_t vfw2 = {
139 VFSDEF_VERSION,
140 "nfs",
141 nfsinit,
142 VSW_CANREMOUNT|VSW_NOTZONESAFE|VSW_STATS|VSW_ZMOUNT,
143 NULL
144 };
145
146 static struct modlfs modlfs2 = {
147 &mod_fsops,
148 "network filesystem version 2",
149 &vfw2
150 };
151
152 /*
153 * The NFS Version 3 client VFS.
154 */
155 static vfsdef_t vfw3 = {
156 VFSDEF_VERSION,
157 "nfs3",
158 nfs3init,
159 VSW_CANREMOUNT|VSW_NOTZONESAFE|VSW_STATS|VSW_ZMOUNT,
160 NULL
161 };
162
163 static struct modlfs modlfs3 = {
164 &mod_fsops,
165 "network filesystem version 3",
166 &vfw3
167 };
168
169 extern struct modlfs modlfs4;
170
171 /*
172 * We have too many linkage structures so we define our own XXX
173 */
174 struct 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 */
184 static 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 */
201 char _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 */
208 int
_init(void)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
255 int
_fini(void)256 _fini(void)
257 {
258 /* Don't allow module to be unloaded */
259 return (EBUSY);
260 }
261
262 int
_info(struct modinfo * modinfop)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 */
276 int
nfstsize(void)277 nfstsize(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 */
292 static int nfs3_max_transfer_size = 1024 * 1024;
293
294 int
nfs3tsize(void)295 nfs3tsize(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
304 static uint_t nfs3_max_transfer_size_clts = 32 * 1024;
305 static uint_t nfs3_max_transfer_size_cots = 1024 * 1024;
306 static uint_t nfs3_max_transfer_size_rdma = 1024 * 1024;
307
308 uint_t
nfs3_tsize(struct knetconfig * knp)309 nfs3_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
320 uint_t
rfs3_tsize(struct svc_req * req)321 rfs3_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 */
333 static int
nfsdyninit(int fstyp,char * name)334 nfsdyninit(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 */
350 static int
nfsdyn_mountroot(vfs_t * vfsp,whymountroot_t why)351 nfsdyn_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
471 int
nfs_setopts(vnode_t * vp,model_t model,struct nfs_args * buf)472 nfs_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 */
579 int
nfs_directio(vnode_t * vp,int cmd,cred_t * cr)580 nfs_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