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) 1986, 2010, Oracle and/or its affiliates. All rights reserved.
23 *
24 * Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T.
25 * All rights reserved.
26 */
27
28 #include <sys/param.h>
29 #include <sys/types.h>
30 #include <sys/systm.h>
31 #include <sys/cred.h>
32 #include <sys/vfs.h>
33 #include <sys/vfs_opreg.h>
34 #include <sys/vnode.h>
35 #include <sys/pathname.h>
36 #include <sys/sysmacros.h>
37 #include <sys/kmem.h>
38 #include <sys/mkdev.h>
39 #include <sys/mount.h>
40 #include <sys/mntent.h>
41 #include <sys/statvfs.h>
42 #include <sys/errno.h>
43 #include <sys/debug.h>
44 #include <sys/cmn_err.h>
45 #include <sys/utsname.h>
46 #include <sys/bootconf.h>
47 #include <sys/modctl.h>
48 #include <sys/acl.h>
49 #include <sys/flock.h>
50 #include <sys/policy.h>
51 #include <sys/zone.h>
52 #include <sys/class.h>
53 #include <sys/socket.h>
54 #include <sys/netconfig.h>
55 #include <sys/mntent.h>
56 #include <sys/tsol/label.h>
57
58 #include <rpc/types.h>
59 #include <rpc/auth.h>
60 #include <rpc/clnt.h>
61
62 #include <nfs/nfs.h>
63 #include <nfs/nfs_clnt.h>
64 #include <nfs/rnode.h>
65 #include <nfs/mount.h>
66 #include <nfs/nfs_acl.h>
67
68 #include <fs/fs_subr.h>
69
70 /*
71 * From rpcsec module (common/rpcsec).
72 */
73 extern int sec_clnt_loadinfo(struct sec_data *, struct sec_data **, model_t);
74 extern void sec_clnt_freeinfo(struct sec_data *);
75
76 static int pathconf_copyin(struct nfs_args *, struct pathcnf *);
77 static int pathconf_get(struct mntinfo *, struct nfs_args *);
78 static void pathconf_rele(struct mntinfo *);
79
80 /*
81 * The order and contents of this structure must be kept in sync with that of
82 * rfsreqcnt_v2_tmpl in nfs_stats.c
83 */
84 static char *rfsnames_v2[] = {
85 "null", "getattr", "setattr", "unused", "lookup", "readlink", "read",
86 "unused", "write", "create", "remove", "rename", "link", "symlink",
87 "mkdir", "rmdir", "readdir", "fsstat"
88 };
89
90 /*
91 * This table maps from NFS protocol number into call type.
92 * Zero means a "Lookup" type call
93 * One means a "Read" type call
94 * Two means a "Write" type call
95 * This is used to select a default time-out.
96 */
97 static uchar_t call_type_v2[] = {
98 0, 0, 1, 0, 0, 0, 1,
99 0, 2, 2, 2, 2, 2, 2,
100 2, 2, 1, 0
101 };
102
103 /*
104 * Similar table, but to determine which timer to use
105 * (only real reads and writes!)
106 */
107 static uchar_t timer_type_v2[] = {
108 0, 0, 0, 0, 0, 0, 1,
109 0, 2, 0, 0, 0, 0, 0,
110 0, 0, 1, 0
111 };
112
113 /*
114 * This table maps from NFS protocol number into a call type
115 * for the semisoft mount option.
116 * Zero means do not repeat operation.
117 * One means repeat.
118 */
119 static uchar_t ss_call_type_v2[] = {
120 0, 0, 1, 0, 0, 0, 0,
121 0, 1, 1, 1, 1, 1, 1,
122 1, 1, 0, 0
123 };
124
125 /*
126 * nfs vfs operations.
127 */
128 static int nfs_mount(vfs_t *, vnode_t *, struct mounta *, cred_t *);
129 static int nfs_unmount(vfs_t *, int, cred_t *);
130 static int nfs_root(vfs_t *, vnode_t **);
131 static int nfs_statvfs(vfs_t *, struct statvfs64 *);
132 static int nfs_sync(vfs_t *, short, cred_t *);
133 static int nfs_vget(vfs_t *, vnode_t **, fid_t *);
134 static int nfs_mountroot(vfs_t *, whymountroot_t);
135 static void nfs_freevfs(vfs_t *);
136
137 static int nfsrootvp(vnode_t **, vfs_t *, struct servinfo *,
138 int, cred_t *, zone_t *);
139
140 /*
141 * Initialize the vfs structure
142 */
143
144 int nfsfstyp;
145 vfsops_t *nfs_vfsops;
146
147 /*
148 * Debug variable to check for rdma based
149 * transport startup and cleanup. Controlled
150 * through /etc/system. Off by default.
151 */
152 int rdma_debug = 0;
153
154 int
155 nfsinit(int fstyp, char *name)
156 {
157 static const fs_operation_def_t nfs_vfsops_template[] = {
158 { VFSNAME_MOUNT, { .vfs_mount = nfs_mount } },
159 { VFSNAME_UNMOUNT, { .vfs_unmount = nfs_unmount } },
160 { VFSNAME_ROOT, { .vfs_root = nfs_root } },
161 { VFSNAME_STATVFS, { .vfs_statvfs = nfs_statvfs } },
162 { VFSNAME_SYNC, { .vfs_sync = nfs_sync } },
163 { VFSNAME_VGET, { .vfs_vget = nfs_vget } },
164 { VFSNAME_MOUNTROOT, { .vfs_mountroot = nfs_mountroot } },
165 { VFSNAME_FREEVFS, { .vfs_freevfs = nfs_freevfs } },
166 { NULL, { NULL } }
167 };
168 int error;
169
170 error = vfs_setfsops(fstyp, nfs_vfsops_template, &nfs_vfsops);
171 if (error != 0) {
172 zcmn_err(GLOBAL_ZONEID, CE_WARN,
173 "nfsinit: bad vfs ops template");
174 return (error);
175 }
176
177 error = vn_make_ops(name, nfs_vnodeops_template, &nfs_vnodeops);
178 if (error != 0) {
179 (void) vfs_freevfsops_by_type(fstyp);
180 zcmn_err(GLOBAL_ZONEID, CE_WARN,
181 "nfsinit: bad vnode ops template");
182 return (error);
183 }
184
185
186 nfsfstyp = fstyp;
187
188 return (0);
189 }
190
191 void
192 nfsfini(void)
193 {
194 }
195
196 static void
197 nfs_free_args(struct nfs_args *nargs, nfs_fhandle *fh)
198 {
199
200 if (fh)
201 kmem_free(fh, sizeof (*fh));
202
203 if (nargs->pathconf) {
204 kmem_free(nargs->pathconf, sizeof (struct pathcnf));
205 nargs->pathconf = NULL;
206 }
207
208 if (nargs->knconf) {
209 if (nargs->knconf->knc_protofmly)
210 kmem_free(nargs->knconf->knc_protofmly, KNC_STRSIZE);
211 if (nargs->knconf->knc_proto)
212 kmem_free(nargs->knconf->knc_proto, KNC_STRSIZE);
213 kmem_free(nargs->knconf, sizeof (*nargs->knconf));
214 nargs->knconf = NULL;
215 }
216
217 if (nargs->fh) {
218 kmem_free(nargs->fh, strlen(nargs->fh) + 1);
219 nargs->fh = NULL;
220 }
221
222 if (nargs->hostname) {
223 kmem_free(nargs->hostname, strlen(nargs->hostname) + 1);
224 nargs->hostname = NULL;
225 }
226
227 if (nargs->addr) {
228 if (nargs->addr->buf) {
229 ASSERT(nargs->addr->len);
230 kmem_free(nargs->addr->buf, nargs->addr->len);
231 }
232 kmem_free(nargs->addr, sizeof (struct netbuf));
233 nargs->addr = NULL;
234 }
235
236 if (nargs->syncaddr) {
237 ASSERT(nargs->syncaddr->len);
238 if (nargs->syncaddr->buf) {
239 ASSERT(nargs->syncaddr->len);
240 kmem_free(nargs->syncaddr->buf, nargs->syncaddr->len);
241 }
242 kmem_free(nargs->syncaddr, sizeof (struct netbuf));
243 nargs->syncaddr = NULL;
244 }
245
246 if (nargs->netname) {
247 kmem_free(nargs->netname, strlen(nargs->netname) + 1);
248 nargs->netname = NULL;
249 }
250
251 if (nargs->nfs_ext_u.nfs_extA.secdata) {
252 sec_clnt_freeinfo(nargs->nfs_ext_u.nfs_extA.secdata);
253 nargs->nfs_ext_u.nfs_extA.secdata = NULL;
254 }
255 }
256
257 static int
258 nfs_copyin(char *data, int datalen, struct nfs_args *nargs, nfs_fhandle *fh)
259 {
260
261 int error;
262 size_t nlen; /* length of netname */
263 size_t hlen; /* length of hostname */
264 char netname[MAXNETNAMELEN+1]; /* server's netname */
265 struct netbuf addr; /* server's address */
266 struct netbuf syncaddr; /* AUTH_DES time sync addr */
267 struct knetconfig *knconf; /* transport knetconfig structure */
268 struct sec_data *secdata = NULL; /* security data */
269 STRUCT_DECL(nfs_args, args); /* nfs mount arguments */
270 STRUCT_DECL(knetconfig, knconf_tmp);
271 STRUCT_DECL(netbuf, addr_tmp);
272 int flags;
273 struct pathcnf *pc; /* Pathconf */
274 char *p, *pf;
275 char *userbufptr;
276
277
278 bzero(nargs, sizeof (*nargs));
279
280 STRUCT_INIT(args, get_udatamodel());
281 bzero(STRUCT_BUF(args), SIZEOF_STRUCT(nfs_args, DATAMODEL_NATIVE));
282 if (copyin(data, STRUCT_BUF(args), MIN(datalen, STRUCT_SIZE(args))))
283 return (EFAULT);
284
285 nargs->wsize = STRUCT_FGET(args, wsize);
286 nargs->rsize = STRUCT_FGET(args, rsize);
287 nargs->timeo = STRUCT_FGET(args, timeo);
288 nargs->retrans = STRUCT_FGET(args, retrans);
289 nargs->acregmin = STRUCT_FGET(args, acregmin);
290 nargs->acregmax = STRUCT_FGET(args, acregmax);
291 nargs->acdirmin = STRUCT_FGET(args, acdirmin);
292 nargs->acdirmax = STRUCT_FGET(args, acdirmax);
293
294 flags = STRUCT_FGET(args, flags);
295 nargs->flags = flags;
296
297
298 addr.buf = NULL;
299 syncaddr.buf = NULL;
300
301 /*
302 * Allocate space for a knetconfig structure and
303 * its strings and copy in from user-land.
304 */
305 knconf = kmem_zalloc(sizeof (*knconf), KM_SLEEP);
306 STRUCT_INIT(knconf_tmp, get_udatamodel());
307 if (copyin(STRUCT_FGETP(args, knconf), STRUCT_BUF(knconf_tmp),
308 STRUCT_SIZE(knconf_tmp))) {
309 kmem_free(knconf, sizeof (*knconf));
310 return (EFAULT);
311 }
312
313 knconf->knc_semantics = STRUCT_FGET(knconf_tmp, knc_semantics);
314 knconf->knc_protofmly = STRUCT_FGETP(knconf_tmp, knc_protofmly);
315 knconf->knc_proto = STRUCT_FGETP(knconf_tmp, knc_proto);
316 if (get_udatamodel() != DATAMODEL_LP64) {
317 knconf->knc_rdev = expldev(STRUCT_FGET(knconf_tmp, knc_rdev));
318 } else {
319 knconf->knc_rdev = STRUCT_FGET(knconf_tmp, knc_rdev);
320 }
321
322 pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
323 p = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
324 error = copyinstr(knconf->knc_protofmly, pf, KNC_STRSIZE, NULL);
325 if (error) {
326 kmem_free(pf, KNC_STRSIZE);
327 kmem_free(p, KNC_STRSIZE);
328 kmem_free(knconf, sizeof (*knconf));
329 return (error);
330 }
331
332 error = copyinstr(knconf->knc_proto, p, KNC_STRSIZE, NULL);
333 if (error) {
334 kmem_free(pf, KNC_STRSIZE);
335 kmem_free(p, KNC_STRSIZE);
336 kmem_free(knconf, sizeof (*knconf));
337 return (error);
338 }
339
340
341 knconf->knc_protofmly = pf;
342 knconf->knc_proto = p;
343
344 nargs->knconf = knconf;
345
346 /* Copyin pathconf if there is one */
347 if (STRUCT_FGETP(args, pathconf) != NULL) {
348 pc = kmem_alloc(sizeof (*pc), KM_SLEEP);
349 error = pathconf_copyin(STRUCT_BUF(args), pc);
350 nargs->pathconf = pc;
351 if (error)
352 goto errout;
353 }
354
355 /*
356 * Get server address
357 */
358 STRUCT_INIT(addr_tmp, get_udatamodel());
359 if (copyin(STRUCT_FGETP(args, addr), STRUCT_BUF(addr_tmp),
360 STRUCT_SIZE(addr_tmp))) {
361 error = EFAULT;
362 goto errout;
363 }
364 nargs->addr = kmem_alloc(sizeof (struct netbuf), KM_SLEEP);
365 userbufptr = STRUCT_FGETP(addr_tmp, buf);
366 addr.len = STRUCT_FGET(addr_tmp, len);
367 addr.buf = kmem_alloc(addr.len, KM_SLEEP);
368 addr.maxlen = addr.len;
369 if (copyin(userbufptr, addr.buf, addr.len)) {
370 kmem_free(addr.buf, addr.len);
371 error = EFAULT;
372 goto errout;
373 }
374 bcopy(&addr, nargs->addr, sizeof (struct netbuf));
375
376 /*
377 * Get the root fhandle
378 */
379
380 if (copyin(STRUCT_FGETP(args, fh), &fh->fh_buf, NFS_FHSIZE)) {
381 error = EFAULT;
382 goto errout;
383 }
384 fh->fh_len = NFS_FHSIZE;
385
386 /*
387 * Get server's hostname
388 */
389 if (flags & NFSMNT_HOSTNAME) {
390 error = copyinstr(STRUCT_FGETP(args, hostname), netname,
391 sizeof (netname), &hlen);
392 if (error)
393 goto errout;
394 nargs->hostname = kmem_zalloc(hlen, KM_SLEEP);
395 (void) strcpy(nargs->hostname, netname);
396
397 } else {
398 nargs->hostname = NULL;
399 }
400
401
402 /*
403 * If there are syncaddr and netname data, load them in. This is
404 * to support data needed for NFSV4 when AUTH_DH is the negotiated
405 * flavor via SECINFO. (instead of using MOUNT protocol in V3).
406 */
407 netname[0] = '\0';
408 if (flags & NFSMNT_SECURE) {
409 if (STRUCT_FGETP(args, syncaddr) == NULL) {
410 error = EINVAL;
411 goto errout;
412 }
413 /* get syncaddr */
414 STRUCT_INIT(addr_tmp, get_udatamodel());
415 if (copyin(STRUCT_FGETP(args, syncaddr), STRUCT_BUF(addr_tmp),
416 STRUCT_SIZE(addr_tmp))) {
417 error = EINVAL;
418 goto errout;
419 }
420 userbufptr = STRUCT_FGETP(addr_tmp, buf);
421 syncaddr.len = STRUCT_FGET(addr_tmp, len);
422 syncaddr.buf = kmem_alloc(syncaddr.len, KM_SLEEP);
423 syncaddr.maxlen = syncaddr.len;
424 if (copyin(userbufptr, syncaddr.buf, syncaddr.len)) {
425 kmem_free(syncaddr.buf, syncaddr.len);
426 error = EFAULT;
427 goto errout;
428 }
429
430 nargs->syncaddr = kmem_alloc(sizeof (struct netbuf), KM_SLEEP);
431 bcopy(&syncaddr, nargs->syncaddr, sizeof (struct netbuf));
432
433 ASSERT(STRUCT_FGETP(args, netname));
434 if (copyinstr(STRUCT_FGETP(args, netname), netname,
435 sizeof (netname), &nlen)) {
436 error = EFAULT;
437 goto errout;
438 }
439
440 netname[nlen] = '\0';
441 nargs->netname = kmem_zalloc(nlen, KM_SLEEP);
442 (void) strcpy(nargs->netname, netname);
443 }
444
445 /*
446 * Get the extention data which has the security data structure.
447 * This includes data for AUTH_SYS as well.
448 */
449 if (flags & NFSMNT_NEWARGS) {
450 nargs->nfs_args_ext = STRUCT_FGET(args, nfs_args_ext);
451 if (nargs->nfs_args_ext == NFS_ARGS_EXTA ||
452 nargs->nfs_args_ext == NFS_ARGS_EXTB) {
453 /*
454 * Indicating the application is using the new
455 * sec_data structure to pass in the security
456 * data.
457 */
458 if (STRUCT_FGETP(args,
459 nfs_ext_u.nfs_extA.secdata) != NULL) {
460 error = sec_clnt_loadinfo(
461 (struct sec_data *)STRUCT_FGETP(args,
462 nfs_ext_u.nfs_extA.secdata), &secdata,
463 get_udatamodel());
464 }
465 nargs->nfs_ext_u.nfs_extA.secdata = secdata;
466 }
467 }
468
469 if (error)
470 goto errout;
471
472 /*
473 * Failover support:
474 *
475 * We may have a linked list of nfs_args structures,
476 * which means the user is looking for failover. If
477 * the mount is either not "read-only" or "soft",
478 * we want to bail out with EINVAL.
479 */
480 if (nargs->nfs_args_ext == NFS_ARGS_EXTB)
481 nargs->nfs_ext_u.nfs_extB.next =
482 STRUCT_FGETP(args, nfs_ext_u.nfs_extB.next);
483
484 errout:
485 if (error)
486 nfs_free_args(nargs, fh);
487
488 return (error);
489 }
490
491
492 /*
493 * nfs mount vfsop
494 * Set up mount info record and attach it to vfs struct.
495 */
496 static int
497 nfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
498 {
499 char *data = uap->dataptr;
500 int error;
501 vnode_t *rtvp; /* the server's root */
502 mntinfo_t *mi; /* mount info, pointed at by vfs */
503 size_t nlen; /* length of netname */
504 struct knetconfig *knconf; /* transport knetconfig structure */
505 struct knetconfig *rdma_knconf; /* rdma transport structure */
506 rnode_t *rp;
507 struct servinfo *svp; /* nfs server info */
508 struct servinfo *svp_tail = NULL; /* previous nfs server info */
509 struct servinfo *svp_head; /* first nfs server info */
510 struct servinfo *svp_2ndlast; /* 2nd last in the server info list */
511 struct sec_data *secdata; /* security data */
512 struct nfs_args *args = NULL;
513 int flags, addr_type;
514 zone_t *zone = nfs_zone();
515 zone_t *mntzone = NULL;
516 nfs_fhandle *fhandle = NULL;
517
518 if ((error = secpolicy_fs_mount(cr, mvp, vfsp)) != 0)
519 return (error);
520
521 if (mvp->v_type != VDIR)
522 return (ENOTDIR);
523
524 /*
525 * get arguments
526 *
527 * nfs_args is now versioned and is extensible, so
528 * uap->datalen might be different from sizeof (args)
529 * in a compatible situation.
530 */
531 more:
532
533 if (!(uap->flags & MS_SYSSPACE)) {
534 if (args == NULL)
535 args = kmem_alloc(sizeof (struct nfs_args), KM_SLEEP);
536 else {
537 nfs_free_args(args, fhandle);
538 fhandle = NULL;
539 }
540 if (fhandle == NULL)
541 fhandle = kmem_zalloc(sizeof (nfs_fhandle), KM_SLEEP);
542 error = nfs_copyin(data, uap->datalen, args, fhandle);
543 if (error) {
544 if (args)
545 kmem_free(args, sizeof (*args));
546 return (error);
547 }
548 } else {
549 args = (struct nfs_args *)data;
550 fhandle = (nfs_fhandle *)args->fh;
551 }
552
553
554 flags = args->flags;
555
556 if (uap->flags & MS_REMOUNT) {
557 size_t n;
558 char name[FSTYPSZ];
559
560 if (uap->flags & MS_SYSSPACE)
561 error = copystr(uap->fstype, name, FSTYPSZ, &n);
562 else
563 error = copyinstr(uap->fstype, name, FSTYPSZ, &n);
564
565 if (error) {
566 if (error == ENAMETOOLONG)
567 return (EINVAL);
568 return (error);
569 }
570
571
572 /*
573 * This check is to ensure that the request is a
574 * genuine nfs remount request.
575 */
576
577 if (strncmp(name, "nfs", 3) != 0)
578 return (EINVAL);
579
580 /*
581 * If the request changes the locking type, disallow the
582 * remount,
583 * because it's questionable whether we can transfer the
584 * locking state correctly.
585 *
586 * Remounts need to save the pathconf information.
587 * Part of the infamous static kludge.
588 */
589
590 if ((mi = VFTOMI(vfsp)) != NULL) {
591 uint_t new_mi_llock;
592 uint_t old_mi_llock;
593
594 new_mi_llock = (flags & NFSMNT_LLOCK) ? 1 : 0;
595 old_mi_llock = (mi->mi_flags & MI_LLOCK) ? 1 : 0;
596 if (old_mi_llock != new_mi_llock)
597 return (EBUSY);
598 }
599 error = pathconf_get((struct mntinfo *)vfsp->vfs_data, args);
600
601 if (!(uap->flags & MS_SYSSPACE)) {
602 nfs_free_args(args, fhandle);
603 kmem_free(args, sizeof (*args));
604 }
605
606 return (error);
607 }
608
609 mutex_enter(&mvp->v_lock);
610 if (!(uap->flags & MS_OVERLAY) &&
611 (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
612 mutex_exit(&mvp->v_lock);
613 if (!(uap->flags & MS_SYSSPACE)) {
614 nfs_free_args(args, fhandle);
615 kmem_free(args, sizeof (*args));
616 }
617 return (EBUSY);
618 }
619 mutex_exit(&mvp->v_lock);
620
621 /* make sure things are zeroed for errout: */
622 rtvp = NULL;
623 mi = NULL;
624 secdata = NULL;
625
626 /*
627 * A valid knetconfig structure is required.
628 */
629 if (!(flags & NFSMNT_KNCONF)) {
630 if (!(uap->flags & MS_SYSSPACE)) {
631 nfs_free_args(args, fhandle);
632 kmem_free(args, sizeof (*args));
633 }
634 return (EINVAL);
635 }
636
637 if ((strlen(args->knconf->knc_protofmly) >= KNC_STRSIZE) ||
638 (strlen(args->knconf->knc_proto) >= KNC_STRSIZE)) {
639 if (!(uap->flags & MS_SYSSPACE)) {
640 nfs_free_args(args, fhandle);
641 kmem_free(args, sizeof (*args));
642 }
643 return (EINVAL);
644 }
645
646
647 /*
648 * Allocate a servinfo struct.
649 */
650 svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
651 mutex_init(&svp->sv_lock, NULL, MUTEX_DEFAULT, NULL);
652 if (svp_tail) {
653 svp_2ndlast = svp_tail;
654 svp_tail->sv_next = svp;
655 } else {
656 svp_head = svp;
657 svp_2ndlast = svp;
658 }
659
660 svp_tail = svp;
661
662 /*
663 * Get knetconfig and server address
664 */
665 svp->sv_knconf = args->knconf;
666 args->knconf = NULL;
667
668 if (args->addr == NULL || args->addr->buf == NULL) {
669 error = EINVAL;
670 goto errout;
671 }
672
673 svp->sv_addr.maxlen = args->addr->maxlen;
674 svp->sv_addr.len = args->addr->len;
675 svp->sv_addr.buf = args->addr->buf;
676 args->addr->buf = NULL;
677
678 /*
679 * Get the root fhandle
680 */
681 ASSERT(fhandle);
682
683 bcopy(&fhandle->fh_buf, &svp->sv_fhandle.fh_buf, fhandle->fh_len);
684 svp->sv_fhandle.fh_len = fhandle->fh_len;
685
686 /*
687 * Get server's hostname
688 */
689 if (flags & NFSMNT_HOSTNAME) {
690 if (args->hostname == NULL) {
691 error = EINVAL;
692 goto errout;
693 }
694 svp->sv_hostnamelen = strlen(args->hostname) + 1;
695 svp->sv_hostname = args->hostname;
696 args->hostname = NULL;
697 } else {
698 char *p = "unknown-host";
699 svp->sv_hostnamelen = strlen(p) + 1;
700 svp->sv_hostname = kmem_zalloc(svp->sv_hostnamelen, KM_SLEEP);
701 (void) strcpy(svp->sv_hostname, p);
702 }
703
704
705 /*
706 * RDMA MOUNT SUPPORT FOR NFS v2:
707 * Establish, is it possible to use RDMA, if so overload the
708 * knconf with rdma specific knconf and free the orignal.
709 */
710 if ((flags & NFSMNT_TRYRDMA) || (flags & NFSMNT_DORDMA)) {
711 /*
712 * Determine the addr type for RDMA, IPv4 or v6.
713 */
714 if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET) == 0)
715 addr_type = AF_INET;
716 else if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET6) == 0)
717 addr_type = AF_INET6;
718
719 if (rdma_reachable(addr_type, &svp->sv_addr,
720 &rdma_knconf) == 0) {
721 /*
722 * If successful, hijack, the orignal knconf and
723 * replace with a new one, depending on the flags.
724 */
725 svp->sv_origknconf = svp->sv_knconf;
726 svp->sv_knconf = rdma_knconf;
727 knconf = rdma_knconf;
728 } else {
729 if (flags & NFSMNT_TRYRDMA) {
730 #ifdef DEBUG
731 if (rdma_debug)
732 zcmn_err(getzoneid(), CE_WARN,
733 "no RDMA onboard, revert\n");
734 #endif
735 }
736
737 if (flags & NFSMNT_DORDMA) {
738 /*
739 * If proto=rdma is specified and no RDMA
740 * path to this server is avialable then
741 * ditch this server.
742 * This is not included in the mountable
743 * server list or the replica list.
744 * Check if more servers are specified;
745 * Failover case, otherwise bail out of mount.
746 */
747 if (args->nfs_args_ext == NFS_ARGS_EXTB &&
748 args->nfs_ext_u.nfs_extB.next != NULL) {
749 data = (char *)
750 args->nfs_ext_u.nfs_extB.next;
751 if (uap->flags & MS_RDONLY &&
752 !(flags & NFSMNT_SOFT)) {
753 if (svp_head->sv_next == NULL) {
754 svp_tail = NULL;
755 svp_2ndlast = NULL;
756 sv_free(svp_head);
757 goto more;
758 } else {
759 svp_tail = svp_2ndlast;
760 svp_2ndlast->sv_next =
761 NULL;
762 sv_free(svp);
763 goto more;
764 }
765 }
766 } else {
767 /*
768 * This is the last server specified
769 * in the nfs_args list passed down
770 * and its not rdma capable.
771 */
772 if (svp_head->sv_next == NULL) {
773 /*
774 * Is this the only one
775 */
776 error = EINVAL;
777 #ifdef DEBUG
778 if (rdma_debug)
779 zcmn_err(getzoneid(),
780 CE_WARN,
781 "No RDMA srv");
782 #endif
783 goto errout;
784 } else {
785 /*
786 * There is list, since some
787 * servers specified before
788 * this passed all requirements
789 */
790 svp_tail = svp_2ndlast;
791 svp_2ndlast->sv_next = NULL;
792 sv_free(svp);
793 goto proceed;
794 }
795 }
796 }
797 }
798 }
799
800 /*
801 * Get the extention data which has the new security data structure.
802 */
803 if (flags & NFSMNT_NEWARGS) {
804 switch (args->nfs_args_ext) {
805 case NFS_ARGS_EXTA:
806 case NFS_ARGS_EXTB:
807 /*
808 * Indicating the application is using the new
809 * sec_data structure to pass in the security
810 * data.
811 */
812 secdata = args->nfs_ext_u.nfs_extA.secdata;
813 if (secdata == NULL) {
814 error = EINVAL;
815 } else {
816 /*
817 * Need to validate the flavor here if
818 * sysspace, userspace was already
819 * validate from the nfs_copyin function.
820 */
821 switch (secdata->rpcflavor) {
822 case AUTH_NONE:
823 case AUTH_UNIX:
824 case AUTH_LOOPBACK:
825 case AUTH_DES:
826 case RPCSEC_GSS:
827 break;
828 default:
829 error = EINVAL;
830 goto errout;
831 }
832 }
833 args->nfs_ext_u.nfs_extA.secdata = NULL;
834 break;
835
836 default:
837 error = EINVAL;
838 break;
839 }
840 } else if (flags & NFSMNT_SECURE) {
841 /*
842 * Keep this for backward compatibility to support
843 * NFSMNT_SECURE/NFSMNT_RPCTIMESYNC flags.
844 */
845 if (args->syncaddr == NULL || args->syncaddr->buf == NULL) {
846 error = EINVAL;
847 goto errout;
848 }
849
850 /*
851 * get time sync address.
852 */
853 if (args->syncaddr == NULL) {
854 error = EFAULT;
855 goto errout;
856 }
857
858 /*
859 * Move security related data to the sec_data structure.
860 */
861 {
862 dh_k4_clntdata_t *data;
863 char *pf, *p;
864
865 secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP);
866 if (flags & NFSMNT_RPCTIMESYNC)
867 secdata->flags |= AUTH_F_RPCTIMESYNC;
868 data = kmem_alloc(sizeof (*data), KM_SLEEP);
869 bcopy(args->syncaddr, &data->syncaddr,
870 sizeof (*args->syncaddr));
871
872
873 /*
874 * duplicate the knconf information for the
875 * new opaque data.
876 */
877 data->knconf = kmem_alloc(sizeof (*knconf), KM_SLEEP);
878 *data->knconf = *knconf;
879 pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
880 p = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
881 bcopy(knconf->knc_protofmly, pf, KNC_STRSIZE);
882 bcopy(knconf->knc_proto, pf, KNC_STRSIZE);
883 data->knconf->knc_protofmly = pf;
884 data->knconf->knc_proto = p;
885
886 /* move server netname to the sec_data structure */
887 nlen = strlen(args->hostname) + 1;
888 if (nlen != 0) {
889 data->netname = kmem_alloc(nlen, KM_SLEEP);
890 bcopy(args->hostname, data->netname, nlen);
891 data->netnamelen = (int)nlen;
892 }
893 secdata->secmod = secdata->rpcflavor = AUTH_DES;
894 secdata->data = (caddr_t)data;
895 }
896 } else {
897 secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP);
898 secdata->secmod = secdata->rpcflavor = AUTH_UNIX;
899 secdata->data = NULL;
900 }
901 svp->sv_secdata = secdata;
902
903 /*
904 * See bug 1180236.
905 * If mount secure failed, we will fall back to AUTH_NONE
906 * and try again. nfs3rootvp() will turn this back off.
907 *
908 * The NFS Version 2 mount uses GETATTR and STATFS procedures.
909 * The server does not care if these procedures have the proper
910 * authentication flavor, so if mount retries using AUTH_NONE
911 * that does not require a credential setup for root then the
912 * automounter would work without requiring root to be
913 * keylogged into AUTH_DES.
914 */
915 if (secdata->rpcflavor != AUTH_UNIX &&
916 secdata->rpcflavor != AUTH_LOOPBACK)
917 secdata->flags |= AUTH_F_TRYNONE;
918
919 /*
920 * Failover support:
921 *
922 * We may have a linked list of nfs_args structures,
923 * which means the user is looking for failover. If
924 * the mount is either not "read-only" or "soft",
925 * we want to bail out with EINVAL.
926 */
927 if (args->nfs_args_ext == NFS_ARGS_EXTB &&
928 args->nfs_ext_u.nfs_extB.next != NULL) {
929 if (uap->flags & MS_RDONLY && !(flags & NFSMNT_SOFT)) {
930 data = (char *)args->nfs_ext_u.nfs_extB.next;
931 goto more;
932 }
933 error = EINVAL;
934 goto errout;
935 }
936
937 /*
938 * Determine the zone we're being mounted into.
939 */
940 zone_hold(mntzone = zone); /* start with this assumption */
941 if (getzoneid() == GLOBAL_ZONEID) {
942 zone_rele(mntzone);
943 mntzone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
944 ASSERT(mntzone != NULL);
945 if (mntzone != zone) {
946 error = EBUSY;
947 goto errout;
948 }
949 }
950
951 if (is_system_labeled()) {
952 error = nfs_mount_label_policy(vfsp, &svp->sv_addr,
953 svp->sv_knconf, cr);
954
955 if (error > 0)
956 goto errout;
957
958 if (error == -1) {
959 /* change mount to read-only to prevent write-down */
960 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
961 }
962 }
963
964 /*
965 * Stop the mount from going any further if the zone is going away.
966 */
967 if (zone_status_get(mntzone) >= ZONE_IS_SHUTTING_DOWN) {
968 error = EBUSY;
969 goto errout;
970 }
971
972 /*
973 * Get root vnode.
974 */
975 proceed:
976 error = nfsrootvp(&rtvp, vfsp, svp_head, flags, cr, mntzone);
977
978 if (error)
979 goto errout;
980
981 /*
982 * Set option fields in the mount info record
983 */
984 mi = VTOMI(rtvp);
985
986 if (svp_head->sv_next)
987 mi->mi_flags |= MI_LLOCK;
988
989 error = nfs_setopts(rtvp, DATAMODEL_NATIVE, args);
990 if (!error) {
991 /* static pathconf kludge */
992 error = pathconf_get(mi, args);
993 }
994
995 errout:
996 if (rtvp != NULL) {
997 if (error) {
998 rp = VTOR(rtvp);
999 if (rp->r_flags & RHASHED)
1000 rp_rmhash(rp);
1001 }
1002 VN_RELE(rtvp);
1003 }
1004
1005 if (error) {
1006 sv_free(svp_head);
1007 if (mi != NULL) {
1008 nfs_async_stop(vfsp);
1009 nfs_async_manager_stop(vfsp);
1010 if (mi->mi_io_kstats) {
1011 kstat_delete(mi->mi_io_kstats);
1012 mi->mi_io_kstats = NULL;
1013 }
1014 if (mi->mi_ro_kstats) {
1015 kstat_delete(mi->mi_ro_kstats);
1016 mi->mi_ro_kstats = NULL;
1017 }
1018 nfs_free_mi(mi);
1019 }
1020 }
1021
1022 if (!(uap->flags & MS_SYSSPACE)) {
1023 nfs_free_args(args, fhandle);
1024 kmem_free(args, sizeof (*args));
1025 }
1026
1027 if (mntzone != NULL)
1028 zone_rele(mntzone);
1029
1030 return (error);
1031 }
1032
1033 /*
1034 * The pathconf information is kept on a linked list of kmem_alloc'ed
1035 * structs. We search the list & add a new struct iff there is no other
1036 * struct with the same information.
1037 * See sys/pathconf.h for ``the rest of the story.''
1038 */
1039 static struct pathcnf *allpc = NULL;
1040
1041 static int
1042 pathconf_copyin(struct nfs_args *args, struct pathcnf *pc)
1043 {
1044 STRUCT_DECL(pathcnf, pc_tmp);
1045 STRUCT_HANDLE(nfs_args, ap);
1046 int i;
1047 model_t model;
1048
1049 model = get_udatamodel();
1050 STRUCT_INIT(pc_tmp, model);
1051 STRUCT_SET_HANDLE(ap, model, args);
1052
1053 if ((STRUCT_FGET(ap, flags) & NFSMNT_POSIX) &&
1054 STRUCT_FGETP(ap, pathconf) != NULL) {
1055 if (copyin(STRUCT_FGETP(ap, pathconf), STRUCT_BUF(pc_tmp),
1056 STRUCT_SIZE(pc_tmp)))
1057 return (EFAULT);
1058 if (_PC_ISSET(_PC_ERROR, STRUCT_FGET(pc_tmp, pc_mask)))
1059 return (EINVAL);
1060
1061 pc->pc_link_max = STRUCT_FGET(pc_tmp, pc_link_max);
1062 pc->pc_max_canon = STRUCT_FGET(pc_tmp, pc_max_canon);
1063 pc->pc_max_input = STRUCT_FGET(pc_tmp, pc_max_input);
1064 pc->pc_name_max = STRUCT_FGET(pc_tmp, pc_name_max);
1065 pc->pc_path_max = STRUCT_FGET(pc_tmp, pc_path_max);
1066 pc->pc_pipe_buf = STRUCT_FGET(pc_tmp, pc_pipe_buf);
1067 pc->pc_vdisable = STRUCT_FGET(pc_tmp, pc_vdisable);
1068 pc->pc_xxx = STRUCT_FGET(pc_tmp, pc_xxx);
1069 for (i = 0; i < _PC_N; i++)
1070 pc->pc_mask[i] = STRUCT_FGET(pc_tmp, pc_mask[i]);
1071 }
1072 return (0);
1073 }
1074
1075 static int
1076 pathconf_get(struct mntinfo *mi, struct nfs_args *args)
1077 {
1078 struct pathcnf *p, *pc;
1079
1080 pc = args->pathconf;
1081 if (mi->mi_pathconf != NULL) {
1082 pathconf_rele(mi);
1083 mi->mi_pathconf = NULL;
1084 }
1085
1086 if (args->flags & NFSMNT_POSIX && args->pathconf != NULL) {
1087 if (_PC_ISSET(_PC_ERROR, pc->pc_mask))
1088 return (EINVAL);
1089
1090 for (p = allpc; p != NULL; p = p->pc_next) {
1091 if (PCCMP(p, pc) == 0)
1092 break;
1093 }
1094 if (p != NULL) {
1095 mi->mi_pathconf = p;
1096 p->pc_refcnt++;
1097 } else {
1098 p = kmem_alloc(sizeof (*p), KM_SLEEP);
1099 bcopy(pc, p, sizeof (struct pathcnf));
1100 p->pc_next = allpc;
1101 p->pc_refcnt = 1;
1102 allpc = mi->mi_pathconf = p;
1103 }
1104 }
1105 return (0);
1106 }
1107
1108 /*
1109 * release the static pathconf information
1110 */
1111 static void
1112 pathconf_rele(struct mntinfo *mi)
1113 {
1114 if (mi->mi_pathconf != NULL) {
1115 if (--mi->mi_pathconf->pc_refcnt == 0) {
1116 struct pathcnf *p;
1117 struct pathcnf *p2;
1118
1119 p2 = p = allpc;
1120 while (p != NULL && p != mi->mi_pathconf) {
1121 p2 = p;
1122 p = p->pc_next;
1123 }
1124 if (p == NULL) {
1125 panic("mi->pathconf");
1126 /*NOTREACHED*/
1127 }
1128 if (p == allpc)
1129 allpc = p->pc_next;
1130 else
1131 p2->pc_next = p->pc_next;
1132 kmem_free(p, sizeof (*p));
1133 mi->mi_pathconf = NULL;
1134 }
1135 }
1136 }
1137
1138 static int nfs_dynamic = 1; /* global variable to enable dynamic retrans. */
1139 static ushort_t nfs_max_threads = 8; /* max number of active async threads */
1140 static uint_t nfs_async_clusters = 1; /* # of reqs from each async queue */
1141 static uint_t nfs_cots_timeo = NFS_COTS_TIMEO;
1142
1143 static int
1144 nfsrootvp(vnode_t **rtvpp, vfs_t *vfsp, struct servinfo *svp,
1145 int flags, cred_t *cr, zone_t *zone)
1146 {
1147 vnode_t *rtvp;
1148 mntinfo_t *mi;
1149 dev_t nfs_dev;
1150 struct vattr va;
1151 int error;
1152 rnode_t *rp;
1153 int i;
1154 struct nfs_stats *nfsstatsp;
1155 cred_t *lcr = NULL, *tcr = cr;
1156
1157 nfsstatsp = zone_getspecific(nfsstat_zone_key, nfs_zone());
1158 ASSERT(nfsstatsp != NULL);
1159
1160 /*
1161 * Create a mount record and link it to the vfs struct.
1162 */
1163 mi = kmem_zalloc(sizeof (*mi), KM_SLEEP);
1164 mutex_init(&mi->mi_lock, NULL, MUTEX_DEFAULT, NULL);
1165 mutex_init(&mi->mi_remap_lock, NULL, MUTEX_DEFAULT, NULL);
1166 mi->mi_flags = MI_ACL | MI_EXTATTR;
1167 if (!(flags & NFSMNT_SOFT))
1168 mi->mi_flags |= MI_HARD;
1169 if ((flags & NFSMNT_SEMISOFT))
1170 mi->mi_flags |= MI_SEMISOFT;
1171 if ((flags & NFSMNT_NOPRINT))
1172 mi->mi_flags |= MI_NOPRINT;
1173 if (flags & NFSMNT_INT)
1174 mi->mi_flags |= MI_INT;
1175 mi->mi_retrans = NFS_RETRIES;
1176 if (svp->sv_knconf->knc_semantics == NC_TPI_COTS_ORD ||
1177 svp->sv_knconf->knc_semantics == NC_TPI_COTS)
1178 mi->mi_timeo = nfs_cots_timeo;
1179 else
1180 mi->mi_timeo = NFS_TIMEO;
1181 mi->mi_prog = NFS_PROGRAM;
1182 mi->mi_vers = NFS_VERSION;
1183 mi->mi_rfsnames = rfsnames_v2;
1184 mi->mi_reqs = nfsstatsp->nfs_stats_v2.rfsreqcnt_ptr;
1185 mi->mi_call_type = call_type_v2;
1186 mi->mi_ss_call_type = ss_call_type_v2;
1187 mi->mi_timer_type = timer_type_v2;
1188 mi->mi_aclnames = aclnames_v2;
1189 mi->mi_aclreqs = nfsstatsp->nfs_stats_v2.aclreqcnt_ptr;
1190 mi->mi_acl_call_type = acl_call_type_v2;
1191 mi->mi_acl_ss_call_type = acl_ss_call_type_v2;
1192 mi->mi_acl_timer_type = acl_timer_type_v2;
1193 cv_init(&mi->mi_failover_cv, NULL, CV_DEFAULT, NULL);
1194 mi->mi_servers = svp;
1195 mi->mi_curr_serv = svp;
1196 mi->mi_acregmin = SEC2HR(ACREGMIN);
1197 mi->mi_acregmax = SEC2HR(ACREGMAX);
1198 mi->mi_acdirmin = SEC2HR(ACDIRMIN);
1199 mi->mi_acdirmax = SEC2HR(ACDIRMAX);
1200
1201 if (nfs_dynamic)
1202 mi->mi_flags |= MI_DYNAMIC;
1203
1204 if (flags & NFSMNT_DIRECTIO)
1205 mi->mi_flags |= MI_DIRECTIO;
1206
1207 /*
1208 * Make a vfs struct for nfs. We do this here instead of below
1209 * because rtvp needs a vfs before we can do a getattr on it.
1210 *
1211 * Assign a unique device id to the mount
1212 */
1213 mutex_enter(&nfs_minor_lock);
1214 do {
1215 nfs_minor = (nfs_minor + 1) & MAXMIN32;
1216 nfs_dev = makedevice(nfs_major, nfs_minor);
1217 } while (vfs_devismounted(nfs_dev));
1218 mutex_exit(&nfs_minor_lock);
1219
1220 vfsp->vfs_dev = nfs_dev;
1221 vfs_make_fsid(&vfsp->vfs_fsid, nfs_dev, nfsfstyp);
1222 vfsp->vfs_data = (caddr_t)mi;
1223 vfsp->vfs_fstype = nfsfstyp;
1224 vfsp->vfs_bsize = NFS_MAXDATA;
1225
1226 /*
1227 * Initialize fields used to support async putpage operations.
1228 */
1229 for (i = 0; i < NFS_ASYNC_TYPES; i++)
1230 mi->mi_async_clusters[i] = nfs_async_clusters;
1231 mi->mi_async_init_clusters = nfs_async_clusters;
1232 mi->mi_async_curr[NFS_ASYNC_QUEUE] =
1233 mi->mi_async_curr[NFS_ASYNC_PGOPS_QUEUE] = &mi->mi_async_reqs[0];
1234 mi->mi_max_threads = nfs_max_threads;
1235 mutex_init(&mi->mi_async_lock, NULL, MUTEX_DEFAULT, NULL);
1236 cv_init(&mi->mi_async_reqs_cv, NULL, CV_DEFAULT, NULL);
1237 cv_init(&mi->mi_async_work_cv[NFS_ASYNC_QUEUE], NULL, CV_DEFAULT, NULL);
1238 cv_init(&mi->mi_async_work_cv[NFS_ASYNC_PGOPS_QUEUE], NULL,
1239 CV_DEFAULT, NULL);
1240 cv_init(&mi->mi_async_cv, NULL, CV_DEFAULT, NULL);
1241
1242 mi->mi_vfsp = vfsp;
1243 mi->mi_zone = zone;
1244 zone_init_ref(&mi->mi_zone_ref);
1245 zone_hold_ref(zone, &mi->mi_zone_ref, ZONE_REF_NFS);
1246 nfs_mi_zonelist_add(mi);
1247
1248 /*
1249 * Make the root vnode, use it to get attributes,
1250 * then remake it with the attributes.
1251 */
1252 rtvp = makenfsnode((fhandle_t *)svp->sv_fhandle.fh_buf,
1253 NULL, vfsp, gethrtime(), cr, NULL, NULL);
1254
1255 va.va_mask = AT_ALL;
1256
1257 /*
1258 * If the uid is set then set the creds for secure mounts
1259 * by proxy processes such as automountd.
1260 */
1261 if (svp->sv_secdata->uid != 0 &&
1262 svp->sv_secdata->rpcflavor == RPCSEC_GSS) {
1263 lcr = crdup(cr);
1264 (void) crsetugid(lcr, svp->sv_secdata->uid, crgetgid(cr));
1265 tcr = lcr;
1266 }
1267
1268 error = nfsgetattr(rtvp, &va, tcr);
1269 if (error)
1270 goto bad;
1271 rtvp->v_type = va.va_type;
1272
1273 /*
1274 * Poll every server to get the filesystem stats; we're
1275 * only interested in the server's transfer size, and we
1276 * want the minimum.
1277 *
1278 * While we're looping, we'll turn off AUTH_F_TRYNONE,
1279 * which is only for the mount operation.
1280 */
1281
1282 mi->mi_tsize = MIN(NFS_MAXDATA, nfstsize());
1283 mi->mi_stsize = MIN(NFS_MAXDATA, nfstsize());
1284
1285 for (svp = mi->mi_servers; svp != NULL; svp = svp->sv_next) {
1286 struct nfsstatfs fs;
1287 int douprintf;
1288
1289 douprintf = 1;
1290 mi->mi_curr_serv = svp;
1291
1292 error = rfs2call(mi, RFS_STATFS, xdr_fhandle,
1293 (caddr_t)svp->sv_fhandle.fh_buf, xdr_statfs, (caddr_t)&fs,
1294 tcr, &douprintf, &fs.fs_status, 0, NULL);
1295 if (error)
1296 goto bad;
1297 mi->mi_stsize = MIN(mi->mi_stsize, fs.fs_tsize);
1298 svp->sv_secdata->flags &= ~AUTH_F_TRYNONE;
1299 }
1300 mi->mi_curr_serv = mi->mi_servers;
1301 mi->mi_curread = mi->mi_tsize;
1302 mi->mi_curwrite = mi->mi_stsize;
1303
1304 /*
1305 * Start the manager thread responsible for handling async worker
1306 * threads.
1307 */
1308 VFS_HOLD(vfsp); /* add reference for thread */
1309 mi->mi_manager_thread = zthread_create(NULL, 0, nfs_async_manager,
1310 vfsp, 0, minclsyspri);
1311 ASSERT(mi->mi_manager_thread != NULL);
1312
1313 /*
1314 * Initialize kstats
1315 */
1316 nfs_mnt_kstat_init(vfsp);
1317
1318 mi->mi_type = rtvp->v_type;
1319
1320 *rtvpp = rtvp;
1321 if (lcr != NULL)
1322 crfree(lcr);
1323
1324 return (0);
1325 bad:
1326 /*
1327 * An error occurred somewhere, need to clean up...
1328 * We need to release our reference to the root vnode and
1329 * destroy the mntinfo struct that we just created.
1330 */
1331 if (lcr != NULL)
1332 crfree(lcr);
1333 rp = VTOR(rtvp);
1334 if (rp->r_flags & RHASHED)
1335 rp_rmhash(rp);
1336 VN_RELE(rtvp);
1337 nfs_async_stop(vfsp);
1338 nfs_async_manager_stop(vfsp);
1339 if (mi->mi_io_kstats) {
1340 kstat_delete(mi->mi_io_kstats);
1341 mi->mi_io_kstats = NULL;
1342 }
1343 if (mi->mi_ro_kstats) {
1344 kstat_delete(mi->mi_ro_kstats);
1345 mi->mi_ro_kstats = NULL;
1346 }
1347 nfs_free_mi(mi);
1348 *rtvpp = NULL;
1349 return (error);
1350 }
1351
1352 /*
1353 * vfs operations
1354 */
1355 static int
1356 nfs_unmount(vfs_t *vfsp, int flag, cred_t *cr)
1357 {
1358 mntinfo_t *mi;
1359 ushort_t omax;
1360
1361 if (secpolicy_fs_unmount(cr, vfsp) != 0)
1362 return (EPERM);
1363
1364 mi = VFTOMI(vfsp);
1365 if (flag & MS_FORCE) {
1366
1367 vfsp->vfs_flag |= VFS_UNMOUNTED;
1368
1369 /*
1370 * We are about to stop the async manager.
1371 * Let every one know not to schedule any
1372 * more async requests.
1373 */
1374 mutex_enter(&mi->mi_async_lock);
1375 mi->mi_max_threads = 0;
1376 NFS_WAKEALL_ASYNC_WORKERS(mi->mi_async_work_cv);
1377 mutex_exit(&mi->mi_async_lock);
1378
1379 /*
1380 * We need to stop the manager thread explicitly; the worker
1381 * threads can time out and exit on their own.
1382 */
1383 nfs_async_manager_stop(vfsp);
1384 destroy_rtable(vfsp, cr);
1385 if (mi->mi_io_kstats) {
1386 kstat_delete(mi->mi_io_kstats);
1387 mi->mi_io_kstats = NULL;
1388 }
1389 if (mi->mi_ro_kstats) {
1390 kstat_delete(mi->mi_ro_kstats);
1391 mi->mi_ro_kstats = NULL;
1392 }
1393 return (0);
1394 }
1395 /*
1396 * Wait until all asynchronous putpage operations on
1397 * this file system are complete before flushing rnodes
1398 * from the cache.
1399 */
1400 omax = mi->mi_max_threads;
1401 if (nfs_async_stop_sig(vfsp)) {
1402 return (EINTR);
1403 }
1404 rflush(vfsp, cr);
1405 /*
1406 * If there are any active vnodes on this file system,
1407 * then the file system is busy and can't be umounted.
1408 */
1409 if (check_rtable(vfsp)) {
1410 mutex_enter(&mi->mi_async_lock);
1411 mi->mi_max_threads = omax;
1412 mutex_exit(&mi->mi_async_lock);
1413 return (EBUSY);
1414 }
1415 /*
1416 * The unmount can't fail from now on; stop the manager thread.
1417 */
1418 nfs_async_manager_stop(vfsp);
1419 /*
1420 * Destroy all rnodes belonging to this file system from the
1421 * rnode hash queues and purge any resources allocated to
1422 * them.
1423 */
1424 destroy_rtable(vfsp, cr);
1425 if (mi->mi_io_kstats) {
1426 kstat_delete(mi->mi_io_kstats);
1427 mi->mi_io_kstats = NULL;
1428 }
1429 if (mi->mi_ro_kstats) {
1430 kstat_delete(mi->mi_ro_kstats);
1431 mi->mi_ro_kstats = NULL;
1432 }
1433 return (0);
1434 }
1435
1436 /*
1437 * find root of nfs
1438 */
1439 static int
1440 nfs_root(vfs_t *vfsp, vnode_t **vpp)
1441 {
1442 mntinfo_t *mi;
1443 vnode_t *vp;
1444 servinfo_t *svp;
1445 rnode_t *rp;
1446 int error = 0;
1447
1448 mi = VFTOMI(vfsp);
1449
1450 if (nfs_zone() != mi->mi_zone)
1451 return (EPERM);
1452
1453 svp = mi->mi_curr_serv;
1454 if (svp && (svp->sv_flags & SV_ROOT_STALE)) {
1455 mutex_enter(&svp->sv_lock);
1456 svp->sv_flags &= ~SV_ROOT_STALE;
1457 mutex_exit(&svp->sv_lock);
1458 error = ENOENT;
1459 }
1460
1461 vp = makenfsnode((fhandle_t *)mi->mi_curr_serv->sv_fhandle.fh_buf,
1462 NULL, vfsp, gethrtime(), CRED(), NULL, NULL);
1463
1464 /*
1465 * if the SV_ROOT_STALE flag was reset above, reset the
1466 * RSTALE flag if needed and return an error
1467 */
1468 if (error == ENOENT) {
1469 rp = VTOR(vp);
1470 if (svp && rp->r_flags & RSTALE) {
1471 mutex_enter(&rp->r_statelock);
1472 rp->r_flags &= ~RSTALE;
1473 mutex_exit(&rp->r_statelock);
1474 }
1475 VN_RELE(vp);
1476 return (error);
1477 }
1478
1479 ASSERT(vp->v_type == VNON || vp->v_type == mi->mi_type);
1480
1481 vp->v_type = mi->mi_type;
1482
1483 *vpp = vp;
1484
1485 return (0);
1486 }
1487
1488 /*
1489 * Get file system statistics.
1490 */
1491 static int
1492 nfs_statvfs(vfs_t *vfsp, struct statvfs64 *sbp)
1493 {
1494 int error;
1495 mntinfo_t *mi;
1496 struct nfsstatfs fs;
1497 int douprintf;
1498 failinfo_t fi;
1499 vnode_t *vp;
1500
1501 error = nfs_root(vfsp, &vp);
1502 if (error)
1503 return (error);
1504
1505 mi = VFTOMI(vfsp);
1506 douprintf = 1;
1507 fi.vp = vp;
1508 fi.fhp = NULL; /* no need to update, filehandle not copied */
1509 fi.copyproc = nfscopyfh;
1510 fi.lookupproc = nfslookup;
1511 fi.xattrdirproc = acl_getxattrdir2;
1512
1513 error = rfs2call(mi, RFS_STATFS, xdr_fhandle, (caddr_t)VTOFH(vp),
1514 xdr_statfs, (caddr_t)&fs, CRED(), &douprintf, &fs.fs_status, 0,
1515 &fi);
1516
1517 if (!error) {
1518 error = geterrno(fs.fs_status);
1519 if (!error) {
1520 mutex_enter(&mi->mi_lock);
1521 if (mi->mi_stsize) {
1522 mi->mi_stsize = MIN(mi->mi_stsize, fs.fs_tsize);
1523 } else {
1524 mi->mi_stsize = fs.fs_tsize;
1525 mi->mi_curwrite = mi->mi_stsize;
1526 }
1527 mutex_exit(&mi->mi_lock);
1528 sbp->f_bsize = fs.fs_bsize;
1529 sbp->f_frsize = fs.fs_bsize;
1530 sbp->f_blocks = (fsblkcnt64_t)fs.fs_blocks;
1531 sbp->f_bfree = (fsblkcnt64_t)fs.fs_bfree;
1532 /*
1533 * Some servers may return negative available
1534 * block counts. They may do this because they
1535 * calculate the number of available blocks by
1536 * subtracting the number of used blocks from
1537 * the total number of blocks modified by the
1538 * minimum free value. For example, if the
1539 * minumum free percentage is 10 and the file
1540 * system is greater than 90 percent full, then
1541 * 90 percent of the total blocks minus the
1542 * actual number of used blocks may be a
1543 * negative number.
1544 *
1545 * In this case, we need to sign extend the
1546 * negative number through the assignment from
1547 * the 32 bit bavail count to the 64 bit bavail
1548 * count.
1549 *
1550 * We need to be able to discern between there
1551 * just being a lot of available blocks on the
1552 * file system and the case described above.
1553 * We are making the assumption that it does
1554 * not make sense to have more available blocks
1555 * than there are free blocks. So, if there
1556 * are, then we treat the number as if it were
1557 * a negative number and arrange to have it
1558 * sign extended when it is converted from 32
1559 * bits to 64 bits.
1560 */
1561 if (fs.fs_bavail <= fs.fs_bfree)
1562 sbp->f_bavail = (fsblkcnt64_t)fs.fs_bavail;
1563 else {
1564 sbp->f_bavail =
1565 (fsblkcnt64_t)((long)fs.fs_bavail);
1566 }
1567 sbp->f_files = (fsfilcnt64_t)-1;
1568 sbp->f_ffree = (fsfilcnt64_t)-1;
1569 sbp->f_favail = (fsfilcnt64_t)-1;
1570 sbp->f_fsid = (unsigned long)vfsp->vfs_fsid.val[0];
1571 (void) strncpy(sbp->f_basetype,
1572 vfssw[vfsp->vfs_fstype].vsw_name, FSTYPSZ);
1573 sbp->f_flag = vf_to_stf(vfsp->vfs_flag);
1574 sbp->f_namemax = (uint32_t)-1;
1575 } else {
1576 PURGE_STALE_FH(error, vp, CRED());
1577 }
1578 }
1579
1580 VN_RELE(vp);
1581
1582 return (error);
1583 }
1584
1585 static kmutex_t nfs_syncbusy;
1586
1587 /*
1588 * Flush dirty nfs files for file system vfsp.
1589 * If vfsp == NULL, all nfs files are flushed.
1590 */
1591 /* ARGSUSED */
1592 static int
1593 nfs_sync(vfs_t *vfsp, short flag, cred_t *cr)
1594 {
1595 /*
1596 * Cross-zone calls are OK here, since this translates to a
1597 * VOP_PUTPAGE(B_ASYNC), which gets picked up by the right zone.
1598 */
1599 if (!(flag & SYNC_ATTR) && mutex_tryenter(&nfs_syncbusy) != 0) {
1600 rflush(vfsp, cr);
1601 mutex_exit(&nfs_syncbusy);
1602 }
1603 return (0);
1604 }
1605
1606 /* ARGSUSED */
1607 static int
1608 nfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
1609 {
1610 int error;
1611 vnode_t *vp;
1612 struct vattr va;
1613 struct nfs_fid *nfsfidp = (struct nfs_fid *)fidp;
1614 zoneid_t zoneid = VFTOMI(vfsp)->mi_zone->zone_id;
1615
1616 if (nfs_zone() != VFTOMI(vfsp)->mi_zone)
1617 return (EPERM);
1618 if (fidp->fid_len != (sizeof (*nfsfidp) - sizeof (short))) {
1619 #ifdef DEBUG
1620 zcmn_err(zoneid, CE_WARN,
1621 "nfs_vget: bad fid len, %d/%d", fidp->fid_len,
1622 (int)(sizeof (*nfsfidp) - sizeof (short)));
1623 #endif
1624 *vpp = NULL;
1625 return (ESTALE);
1626 }
1627
1628 vp = makenfsnode((fhandle_t *)(nfsfidp->nf_data), NULL, vfsp,
1629 gethrtime(), CRED(), NULL, NULL);
1630
1631 if (VTOR(vp)->r_flags & RSTALE) {
1632 VN_RELE(vp);
1633 *vpp = NULL;
1634 return (ENOENT);
1635 }
1636
1637 if (vp->v_type == VNON) {
1638 va.va_mask = AT_ALL;
1639 error = nfsgetattr(vp, &va, CRED());
1640 if (error) {
1641 VN_RELE(vp);
1642 *vpp = NULL;
1643 return (error);
1644 }
1645 vp->v_type = va.va_type;
1646 }
1647
1648 *vpp = vp;
1649
1650 return (0);
1651 }
1652
1653 /* ARGSUSED */
1654 static int
1655 nfs_mountroot(vfs_t *vfsp, whymountroot_t why)
1656 {
1657 vnode_t *rtvp;
1658 char root_hostname[SYS_NMLN+1];
1659 struct servinfo *svp;
1660 int error;
1661 int vfsflags;
1662 size_t size;
1663 char *root_path;
1664 struct pathname pn;
1665 char *name;
1666 cred_t *cr;
1667 struct nfs_args args; /* nfs mount arguments */
1668 static char token[10];
1669
1670 bzero(&args, sizeof (args));
1671
1672 /* do this BEFORE getfile which causes xid stamps to be initialized */
1673 clkset(-1L); /* hack for now - until we get time svc? */
1674
1675 if (why == ROOT_REMOUNT) {
1676 /*
1677 * Shouldn't happen.
1678 */
1679 panic("nfs_mountroot: why == ROOT_REMOUNT");
1680 }
1681
1682 if (why == ROOT_UNMOUNT) {
1683 /*
1684 * Nothing to do for NFS.
1685 */
1686 return (0);
1687 }
1688
1689 /*
1690 * why == ROOT_INIT
1691 */
1692
1693 name = token;
1694 *name = 0;
1695 getfsname("root", name, sizeof (token));
1696
1697 pn_alloc(&pn);
1698 root_path = pn.pn_path;
1699
1700 svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
1701 svp->sv_knconf = kmem_zalloc(sizeof (*svp->sv_knconf), KM_SLEEP);
1702 svp->sv_knconf->knc_protofmly = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
1703 svp->sv_knconf->knc_proto = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
1704
1705 /*
1706 * Get server address
1707 * Get the root fhandle
1708 * Get server's transport
1709 * Get server's hostname
1710 * Get options
1711 */
1712 args.addr = &svp->sv_addr;
1713 args.fh = (char *)&svp->sv_fhandle.fh_buf;
1714 args.knconf = svp->sv_knconf;
1715 args.hostname = root_hostname;
1716 vfsflags = 0;
1717 if (error = mount_root(*name ? name : "root", root_path, NFS_VERSION,
1718 &args, &vfsflags)) {
1719 nfs_cmn_err(error, CE_WARN,
1720 "nfs_mountroot: mount_root failed: %m");
1721 sv_free(svp);
1722 pn_free(&pn);
1723 return (error);
1724 }
1725 svp->sv_fhandle.fh_len = NFS_FHSIZE;
1726 svp->sv_hostnamelen = (int)(strlen(root_hostname) + 1);
1727 svp->sv_hostname = kmem_alloc(svp->sv_hostnamelen, KM_SLEEP);
1728 (void) strcpy(svp->sv_hostname, root_hostname);
1729
1730 /*
1731 * Force root partition to always be mounted with AUTH_UNIX for now
1732 */
1733 svp->sv_secdata = kmem_alloc(sizeof (*svp->sv_secdata), KM_SLEEP);
1734 svp->sv_secdata->secmod = AUTH_UNIX;
1735 svp->sv_secdata->rpcflavor = AUTH_UNIX;
1736 svp->sv_secdata->data = NULL;
1737
1738 cr = crgetcred();
1739 rtvp = NULL;
1740
1741 error = nfsrootvp(&rtvp, vfsp, svp, args.flags, cr, global_zone);
1742
1743 crfree(cr);
1744
1745 if (error) {
1746 pn_free(&pn);
1747 sv_free(svp);
1748 return (error);
1749 }
1750
1751 error = nfs_setopts(rtvp, DATAMODEL_NATIVE, &args);
1752 if (error) {
1753 nfs_cmn_err(error, CE_WARN,
1754 "nfs_mountroot: invalid root mount options");
1755 pn_free(&pn);
1756 goto errout;
1757 }
1758
1759 (void) vfs_lock_wait(vfsp);
1760 vfs_add(NULL, vfsp, vfsflags);
1761 vfs_unlock(vfsp);
1762
1763 size = strlen(svp->sv_hostname);
1764 (void) strcpy(rootfs.bo_name, svp->sv_hostname);
1765 rootfs.bo_name[size] = ':';
1766 (void) strcpy(&rootfs.bo_name[size + 1], root_path);
1767
1768 pn_free(&pn);
1769
1770 errout:
1771 if (error) {
1772 sv_free(svp);
1773 nfs_async_stop(vfsp);
1774 nfs_async_manager_stop(vfsp);
1775 }
1776
1777 if (rtvp != NULL)
1778 VN_RELE(rtvp);
1779
1780 return (error);
1781 }
1782
1783 /*
1784 * Initialization routine for VFS routines. Should only be called once
1785 */
1786 int
1787 nfs_vfsinit(void)
1788 {
1789 mutex_init(&nfs_syncbusy, NULL, MUTEX_DEFAULT, NULL);
1790 return (0);
1791 }
1792
1793 void
1794 nfs_vfsfini(void)
1795 {
1796 mutex_destroy(&nfs_syncbusy);
1797 }
1798
1799 void
1800 nfs_freevfs(vfs_t *vfsp)
1801 {
1802 mntinfo_t *mi;
1803 servinfo_t *svp;
1804
1805 /* free up the resources */
1806 mi = VFTOMI(vfsp);
1807 pathconf_rele(mi);
1808 svp = mi->mi_servers;
1809 mi->mi_servers = mi->mi_curr_serv = NULL;
1810 sv_free(svp);
1811
1812 /*
1813 * By this time we should have already deleted the
1814 * mi kstats in the unmount code. If they are still around
1815 * somethings wrong
1816 */
1817 ASSERT(mi->mi_io_kstats == NULL);
1818 nfs_free_mi(mi);
1819 }