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) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
26 /* All Rights Reserved */
27
28 /*
29 * University Copyright- Copyright (c) 1982, 1986, 1988
30 * The Regents of the University of California
31 * All Rights Reserved
32 *
33 * University Acknowledgment- Portions of this document are derived from
34 * software developed by the University of California, Berkeley, and its
35 * contributors.
36 */
37
38 #include <sys/types.h>
39 #include <sys/t_lock.h>
40 #include <sys/param.h>
41 #include <sys/errno.h>
42 #include <sys/user.h>
43 #include <sys/fstyp.h>
44 #include <sys/kmem.h>
45 #include <sys/systm.h>
46 #include <sys/proc.h>
47 #include <sys/mount.h>
48 #include <sys/vfs.h>
49 #include <sys/vfs_opreg.h>
50 #include <sys/fem.h>
51 #include <sys/mntent.h>
52 #include <sys/stat.h>
53 #include <sys/statvfs.h>
54 #include <sys/statfs.h>
55 #include <sys/cred.h>
56 #include <sys/vnode.h>
57 #include <sys/rwstlock.h>
58 #include <sys/dnlc.h>
59 #include <sys/file.h>
60 #include <sys/time.h>
61 #include <sys/atomic.h>
62 #include <sys/cmn_err.h>
63 #include <sys/buf.h>
64 #include <sys/swap.h>
65 #include <sys/debug.h>
66 #include <sys/vnode.h>
67 #include <sys/modctl.h>
68 #include <sys/ddi.h>
69 #include <sys/pathname.h>
70 #include <sys/bootconf.h>
71 #include <sys/dumphdr.h>
72 #include <sys/dc_ki.h>
73 #include <sys/poll.h>
74 #include <sys/sunddi.h>
75 #include <sys/sysmacros.h>
76 #include <sys/zone.h>
77 #include <sys/policy.h>
78 #include <sys/ctfs.h>
79 #include <sys/objfs.h>
80 #include <sys/console.h>
81 #include <sys/reboot.h>
82 #include <sys/attr.h>
83 #include <sys/zio.h>
84 #include <sys/spa.h>
85 #include <sys/lofi.h>
86 #include <sys/bootprops.h>
87
88 #include <vm/page.h>
89
90 #include <fs/fs_subr.h>
91 /* Private interfaces to create vopstats-related data structures */
92 extern void initialize_vopstats(vopstats_t *);
93 extern vopstats_t *get_fstype_vopstats(struct vfs *, struct vfssw *);
94 extern vsk_anchor_t *get_vskstat_anchor(struct vfs *);
95
96 static void vfs_clearmntopt_nolock(mntopts_t *, const char *, int);
97 static void vfs_setmntopt_nolock(mntopts_t *, const char *,
98 const char *, int, int);
99 static int vfs_optionisset_nolock(const mntopts_t *, const char *, char **);
100 static void vfs_freemnttab(struct vfs *);
101 static void vfs_freeopt(mntopt_t *);
102 static void vfs_swapopttbl_nolock(mntopts_t *, mntopts_t *);
103 static void vfs_swapopttbl(mntopts_t *, mntopts_t *);
104 static void vfs_copyopttbl_extend(const mntopts_t *, mntopts_t *, int);
105 static void vfs_createopttbl_extend(mntopts_t *, const char *,
106 const mntopts_t *);
107 static char **vfs_copycancelopt_extend(char **const, int);
108 static void vfs_freecancelopt(char **);
109 static void getrootfs(char **, char **);
110 static int getmacpath(dev_info_t *, void *);
111 static void vfs_mnttabvp_setup(void);
112
113 struct ipmnt {
114 struct ipmnt *mip_next;
115 dev_t mip_dev;
116 struct vfs *mip_vfsp;
117 };
118
119 static kmutex_t vfs_miplist_mutex;
120 static struct ipmnt *vfs_miplist = NULL;
121 static struct ipmnt *vfs_miplist_end = NULL;
122
123 static kmem_cache_t *vfs_cache; /* Pointer to VFS kmem cache */
124
125 /*
126 * VFS global data.
127 */
128 vnode_t *rootdir; /* pointer to root inode vnode. */
129 vnode_t *devicesdir; /* pointer to inode of devices root */
130 vnode_t *devdir; /* pointer to inode of dev root */
131
132 char *server_rootpath; /* root path for diskless clients */
133 char *server_hostname; /* hostname of diskless server */
134
135 static struct vfs root;
136 static struct vfs devices;
137 static struct vfs dev;
138 struct vfs *rootvfs = &root; /* pointer to root vfs; head of VFS list. */
139 rvfs_t *rvfs_list; /* array of vfs ptrs for vfs hash list */
140 int vfshsz = 512; /* # of heads/locks in vfs hash arrays */
141 /* must be power of 2! */
142 timespec_t vfs_mnttab_ctime; /* mnttab created time */
143 timespec_t vfs_mnttab_mtime; /* mnttab last modified time */
144 char *vfs_dummyfstype = "\0";
145 struct pollhead vfs_pollhd; /* for mnttab pollers */
146 struct vnode *vfs_mntdummyvp; /* to fake mnttab read/write for file events */
147 int mntfstype; /* will be set once mnt fs is mounted */
148
149 /*
150 * Table for generic options recognized in the VFS layer and acted
151 * on at this level before parsing file system specific options.
152 * The nosuid option is stronger than any of the devices and setuid
153 * options, so those are canceled when nosuid is seen.
154 *
155 * All options which are added here need to be added to the
156 * list of standard options in usr/src/cmd/fs.d/fslib.c as well.
157 */
158 /*
159 * VFS Mount options table
160 */
161 static char *ro_cancel[] = { MNTOPT_RW, NULL };
162 static char *rw_cancel[] = { MNTOPT_RO, NULL };
163 static char *suid_cancel[] = { MNTOPT_NOSUID, NULL };
164 static char *nosuid_cancel[] = { MNTOPT_SUID, MNTOPT_DEVICES, MNTOPT_NODEVICES,
165 MNTOPT_NOSETUID, MNTOPT_SETUID, NULL };
166 static char *devices_cancel[] = { MNTOPT_NODEVICES, NULL };
167 static char *nodevices_cancel[] = { MNTOPT_DEVICES, NULL };
168 static char *setuid_cancel[] = { MNTOPT_NOSETUID, NULL };
169 static char *nosetuid_cancel[] = { MNTOPT_SETUID, NULL };
170 static char *nbmand_cancel[] = { MNTOPT_NONBMAND, NULL };
171 static char *nonbmand_cancel[] = { MNTOPT_NBMAND, NULL };
172 static char *exec_cancel[] = { MNTOPT_NOEXEC, NULL };
173 static char *noexec_cancel[] = { MNTOPT_EXEC, NULL };
174
175 static const mntopt_t mntopts[] = {
176 /*
177 * option name cancel options default arg flags
178 */
179 { MNTOPT_REMOUNT, NULL, NULL,
180 MO_NODISPLAY, (void *)0 },
181 { MNTOPT_RO, ro_cancel, NULL, 0,
182 (void *)0 },
183 { MNTOPT_RW, rw_cancel, NULL, 0,
184 (void *)0 },
185 { MNTOPT_SUID, suid_cancel, NULL, 0,
186 (void *)0 },
187 { MNTOPT_NOSUID, nosuid_cancel, NULL, 0,
188 (void *)0 },
189 { MNTOPT_DEVICES, devices_cancel, NULL, 0,
190 (void *)0 },
191 { MNTOPT_NODEVICES, nodevices_cancel, NULL, 0,
192 (void *)0 },
193 { MNTOPT_SETUID, setuid_cancel, NULL, 0,
194 (void *)0 },
195 { MNTOPT_NOSETUID, nosetuid_cancel, NULL, 0,
196 (void *)0 },
197 { MNTOPT_NBMAND, nbmand_cancel, NULL, 0,
198 (void *)0 },
199 { MNTOPT_NONBMAND, nonbmand_cancel, NULL, 0,
200 (void *)0 },
201 { MNTOPT_EXEC, exec_cancel, NULL, 0,
202 (void *)0 },
203 { MNTOPT_NOEXEC, noexec_cancel, NULL, 0,
204 (void *)0 },
205 };
206
207 const mntopts_t vfs_mntopts = {
208 sizeof (mntopts) / sizeof (mntopt_t),
209 (mntopt_t *)&mntopts[0]
210 };
211
212 /*
213 * File system operation dispatch functions.
214 */
215
216 int
217 fsop_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
218 {
219 return (*(vfsp)->vfs_op->vfs_mount)(vfsp, mvp, uap, cr);
220 }
221
222 int
223 fsop_unmount(vfs_t *vfsp, int flag, cred_t *cr)
224 {
225 return (*(vfsp)->vfs_op->vfs_unmount)(vfsp, flag, cr);
226 }
227
228 int
229 fsop_root(vfs_t *vfsp, vnode_t **vpp)
230 {
231 refstr_t *mntpt;
232 int ret = (*(vfsp)->vfs_op->vfs_root)(vfsp, vpp);
233 /*
234 * Make sure this root has a path. With lofs, it is possible to have
235 * a NULL mountpoint.
236 */
237 if (ret == 0 && vfsp->vfs_mntpt != NULL && (*vpp)->v_path == NULL) {
238 mntpt = vfs_getmntpoint(vfsp);
239 vn_setpath_str(*vpp, refstr_value(mntpt),
240 strlen(refstr_value(mntpt)));
241 refstr_rele(mntpt);
242 }
243
244 return (ret);
245 }
246
247 int
248 fsop_statfs(vfs_t *vfsp, statvfs64_t *sp)
249 {
250 return (*(vfsp)->vfs_op->vfs_statvfs)(vfsp, sp);
251 }
252
253 int
254 fsop_sync(vfs_t *vfsp, short flag, cred_t *cr)
255 {
256 return (*(vfsp)->vfs_op->vfs_sync)(vfsp, flag, cr);
257 }
258
259 int
260 fsop_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
261 {
262 /*
263 * In order to handle system attribute fids in a manner
264 * transparent to the underlying fs, we embed the fid for
265 * the sysattr parent object in the sysattr fid and tack on
266 * some extra bytes that only the sysattr layer knows about.
267 *
268 * This guarantees that sysattr fids are larger than other fids
269 * for this vfs. If the vfs supports the sysattr view interface
270 * (as indicated by VFSFT_SYSATTR_VIEWS), we cannot have a size
271 * collision with XATTR_FIDSZ.
272 */
273 if (vfs_has_feature(vfsp, VFSFT_SYSATTR_VIEWS) &&
274 fidp->fid_len == XATTR_FIDSZ)
275 return (xattr_dir_vget(vfsp, vpp, fidp));
276
277 return (*(vfsp)->vfs_op->vfs_vget)(vfsp, vpp, fidp);
278 }
279
280 int
281 fsop_mountroot(vfs_t *vfsp, enum whymountroot reason)
282 {
283 return (*(vfsp)->vfs_op->vfs_mountroot)(vfsp, reason);
284 }
285
286 void
287 fsop_freefs(vfs_t *vfsp)
288 {
289 (*(vfsp)->vfs_op->vfs_freevfs)(vfsp);
290 }
291
292 int
293 fsop_vnstate(vfs_t *vfsp, vnode_t *vp, vntrans_t nstate)
294 {
295 return ((*(vfsp)->vfs_op->vfs_vnstate)(vfsp, vp, nstate));
296 }
297
298 int
299 fsop_sync_by_kind(int fstype, short flag, cred_t *cr)
300 {
301 ASSERT((fstype >= 0) && (fstype < nfstype));
302
303 if (ALLOCATED_VFSSW(&vfssw[fstype]) && VFS_INSTALLED(&vfssw[fstype]))
304 return (*vfssw[fstype].vsw_vfsops.vfs_sync) (NULL, flag, cr);
305 else
306 return (ENOTSUP);
307 }
308
309 /*
310 * File system initialization. vfs_setfsops() must be called from a file
311 * system's init routine.
312 */
313
314 static int
315 fs_copyfsops(const fs_operation_def_t *template, vfsops_t *actual,
316 int *unused_ops)
317 {
318 static const fs_operation_trans_def_t vfs_ops_table[] = {
319 VFSNAME_MOUNT, offsetof(vfsops_t, vfs_mount),
320 fs_nosys, fs_nosys,
321
322 VFSNAME_UNMOUNT, offsetof(vfsops_t, vfs_unmount),
323 fs_nosys, fs_nosys,
324
325 VFSNAME_ROOT, offsetof(vfsops_t, vfs_root),
326 fs_nosys, fs_nosys,
327
328 VFSNAME_STATVFS, offsetof(vfsops_t, vfs_statvfs),
329 fs_nosys, fs_nosys,
330
331 VFSNAME_SYNC, offsetof(vfsops_t, vfs_sync),
332 (fs_generic_func_p) fs_sync,
333 (fs_generic_func_p) fs_sync, /* No errors allowed */
334
335 VFSNAME_VGET, offsetof(vfsops_t, vfs_vget),
336 fs_nosys, fs_nosys,
337
338 VFSNAME_MOUNTROOT, offsetof(vfsops_t, vfs_mountroot),
339 fs_nosys, fs_nosys,
340
341 VFSNAME_FREEVFS, offsetof(vfsops_t, vfs_freevfs),
342 (fs_generic_func_p)fs_freevfs,
343 (fs_generic_func_p)fs_freevfs, /* Shouldn't fail */
344
345 VFSNAME_VNSTATE, offsetof(vfsops_t, vfs_vnstate),
346 (fs_generic_func_p)fs_nosys,
347 (fs_generic_func_p)fs_nosys,
348
349 NULL, 0, NULL, NULL
350 };
351
352 return (fs_build_vector(actual, unused_ops, vfs_ops_table, template));
353 }
354
355 void
356 zfs_boot_init() {
357
358 if (strcmp(rootfs.bo_fstype, MNTTYPE_ZFS) == 0)
359 spa_boot_init();
360 }
361
362 int
363 vfs_setfsops(int fstype, const fs_operation_def_t *template, vfsops_t **actual)
364 {
365 int error;
366 int unused_ops;
367
368 /*
369 * Verify that fstype refers to a valid fs. Note that
370 * 0 is valid since it's used to set "stray" ops.
371 */
372 if ((fstype < 0) || (fstype >= nfstype))
373 return (EINVAL);
374
375 if (!ALLOCATED_VFSSW(&vfssw[fstype]))
376 return (EINVAL);
377
378 /* Set up the operations vector. */
379
380 error = fs_copyfsops(template, &vfssw[fstype].vsw_vfsops, &unused_ops);
381
382 if (error != 0)
383 return (error);
384
385 vfssw[fstype].vsw_flag |= VSW_INSTALLED;
386
387 if (actual != NULL)
388 *actual = &vfssw[fstype].vsw_vfsops;
389
390 #if DEBUG
391 if (unused_ops != 0)
392 cmn_err(CE_WARN, "vfs_setfsops: %s: %d operations supplied "
393 "but not used", vfssw[fstype].vsw_name, unused_ops);
394 #endif
395
396 return (0);
397 }
398
399 int
400 vfs_makefsops(const fs_operation_def_t *template, vfsops_t **actual)
401 {
402 int error;
403 int unused_ops;
404
405 *actual = (vfsops_t *)kmem_alloc(sizeof (vfsops_t), KM_SLEEP);
406
407 error = fs_copyfsops(template, *actual, &unused_ops);
408 if (error != 0) {
409 kmem_free(*actual, sizeof (vfsops_t));
410 *actual = NULL;
411 return (error);
412 }
413
414 return (0);
415 }
416
417 /*
418 * Free a vfsops structure created as a result of vfs_makefsops().
419 * NOTE: For a vfsops structure initialized by vfs_setfsops(), use
420 * vfs_freevfsops_by_type().
421 */
422 void
423 vfs_freevfsops(vfsops_t *vfsops)
424 {
425 kmem_free(vfsops, sizeof (vfsops_t));
426 }
427
428 /*
429 * Since the vfsops structure is part of the vfssw table and wasn't
430 * really allocated, we're not really freeing anything. We keep
431 * the name for consistency with vfs_freevfsops(). We do, however,
432 * need to take care of a little bookkeeping.
433 * NOTE: For a vfsops structure created by vfs_setfsops(), use
434 * vfs_freevfsops_by_type().
435 */
436 int
437 vfs_freevfsops_by_type(int fstype)
438 {
439
440 /* Verify that fstype refers to a loaded fs (and not fsid 0). */
441 if ((fstype <= 0) || (fstype >= nfstype))
442 return (EINVAL);
443
444 WLOCK_VFSSW();
445 if ((vfssw[fstype].vsw_flag & VSW_INSTALLED) == 0) {
446 WUNLOCK_VFSSW();
447 return (EINVAL);
448 }
449
450 vfssw[fstype].vsw_flag &= ~VSW_INSTALLED;
451 WUNLOCK_VFSSW();
452
453 return (0);
454 }
455
456 /* Support routines used to reference vfs_op */
457
458 /* Set the operations vector for a vfs */
459 void
460 vfs_setops(vfs_t *vfsp, vfsops_t *vfsops)
461 {
462 vfsops_t *op;
463
464 ASSERT(vfsp != NULL);
465 ASSERT(vfsops != NULL);
466
467 op = vfsp->vfs_op;
468 membar_consumer();
469 if (vfsp->vfs_femhead == NULL &&
470 casptr(&vfsp->vfs_op, op, vfsops) == op) {
471 return;
472 }
473 fsem_setvfsops(vfsp, vfsops);
474 }
475
476 /* Retrieve the operations vector for a vfs */
477 vfsops_t *
478 vfs_getops(vfs_t *vfsp)
479 {
480 vfsops_t *op;
481
482 ASSERT(vfsp != NULL);
483
484 op = vfsp->vfs_op;
485 membar_consumer();
486 if (vfsp->vfs_femhead == NULL && op == vfsp->vfs_op) {
487 return (op);
488 } else {
489 return (fsem_getvfsops(vfsp));
490 }
491 }
492
493 /*
494 * Returns non-zero (1) if the vfsops matches that of the vfs.
495 * Returns zero (0) if not.
496 */
497 int
498 vfs_matchops(vfs_t *vfsp, vfsops_t *vfsops)
499 {
500 return (vfs_getops(vfsp) == vfsops);
501 }
502
503 /*
504 * Returns non-zero (1) if the file system has installed a non-default,
505 * non-error vfs_sync routine. Returns zero (0) otherwise.
506 */
507 int
508 vfs_can_sync(vfs_t *vfsp)
509 {
510 /* vfs_sync() routine is not the default/error function */
511 return (vfs_getops(vfsp)->vfs_sync != fs_sync);
512 }
513
514 /*
515 * Initialize a vfs structure.
516 */
517 void
518 vfs_init(vfs_t *vfsp, vfsops_t *op, void *data)
519 {
520 /* Other initialization has been moved to vfs_alloc() */
521 vfsp->vfs_count = 0;
522 vfsp->vfs_next = vfsp;
523 vfsp->vfs_prev = vfsp;
524 vfsp->vfs_zone_next = vfsp;
525 vfsp->vfs_zone_prev = vfsp;
526 vfsp->vfs_lofi_minor = 0;
527 sema_init(&vfsp->vfs_reflock, 1, NULL, SEMA_DEFAULT, NULL);
528 vfsimpl_setup(vfsp);
529 vfsp->vfs_data = (data);
530 vfs_setops((vfsp), (op));
531 }
532
533 /*
534 * Allocate and initialize the vfs implementation private data
535 * structure, vfs_impl_t.
536 */
537 void
538 vfsimpl_setup(vfs_t *vfsp)
539 {
540 int i;
541
542 if (vfsp->vfs_implp != NULL) {
543 return;
544 }
545
546 vfsp->vfs_implp = kmem_alloc(sizeof (vfs_impl_t), KM_SLEEP);
547 /* Note that these are #define'd in vfs.h */
548 vfsp->vfs_vskap = NULL;
549 vfsp->vfs_fstypevsp = NULL;
550
551 /* Set size of counted array, then zero the array */
552 vfsp->vfs_featureset[0] = VFS_FEATURE_MAXSZ - 1;
553 for (i = 1; i < VFS_FEATURE_MAXSZ; i++) {
554 vfsp->vfs_featureset[i] = 0;
555 }
556 }
557
558 /*
559 * Release the vfs_impl_t structure, if it exists. Some unbundled
560 * filesystems may not use the newer version of vfs and thus
561 * would not contain this implementation private data structure.
562 */
563 void
564 vfsimpl_teardown(vfs_t *vfsp)
565 {
566 vfs_impl_t *vip = vfsp->vfs_implp;
567
568 if (vip == NULL)
569 return;
570
571 kmem_free(vfsp->vfs_implp, sizeof (vfs_impl_t));
572 vfsp->vfs_implp = NULL;
573 }
574
575 /*
576 * VFS system calls: mount, umount, syssync, statfs, fstatfs, statvfs,
577 * fstatvfs, and sysfs moved to common/syscall.
578 */
579
580 /*
581 * Update every mounted file system. We call the vfs_sync operation of
582 * each file system type, passing it a NULL vfsp to indicate that all
583 * mounted file systems of that type should be updated.
584 */
585 void
586 vfs_sync(int flag)
587 {
588 struct vfssw *vswp;
589 RLOCK_VFSSW();
590 for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
591 if (ALLOCATED_VFSSW(vswp) && VFS_INSTALLED(vswp)) {
592 vfs_refvfssw(vswp);
593 RUNLOCK_VFSSW();
594 (void) (*vswp->vsw_vfsops.vfs_sync)(NULL, flag,
595 CRED());
596 vfs_unrefvfssw(vswp);
597 RLOCK_VFSSW();
598 }
599 }
600 RUNLOCK_VFSSW();
601 }
602
603 void
604 sync(void)
605 {
606 vfs_sync(0);
607 }
608
609 /*
610 * External routines.
611 */
612
613 krwlock_t vfssw_lock; /* lock accesses to vfssw */
614
615 /*
616 * Lock for accessing the vfs linked list. Initialized in vfs_mountroot(),
617 * but otherwise should be accessed only via vfs_list_lock() and
618 * vfs_list_unlock(). Also used to protect the timestamp for mods to the list.
619 */
620 static krwlock_t vfslist;
621
622 /*
623 * Mount devfs on /devices. This is done right after root is mounted
624 * to provide device access support for the system
625 */
626 static void
627 vfs_mountdevices(void)
628 {
629 struct vfssw *vsw;
630 struct vnode *mvp;
631 struct mounta mounta = { /* fake mounta for devfs_mount() */
632 NULL,
633 NULL,
634 MS_SYSSPACE,
635 NULL,
636 NULL,
637 0,
638 NULL,
639 0
640 };
641
642 /*
643 * _init devfs module to fill in the vfssw
644 */
645 if (modload("fs", "devfs") == -1)
646 panic("Cannot _init devfs module");
647
648 /*
649 * Hold vfs
650 */
651 RLOCK_VFSSW();
652 vsw = vfs_getvfsswbyname("devfs");
653 VFS_INIT(&devices, &vsw->vsw_vfsops, NULL);
654 VFS_HOLD(&devices);
655
656 /*
657 * Locate mount point
658 */
659 if (lookupname("/devices", UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp))
660 panic("Cannot find /devices");
661
662 /*
663 * Perform the mount of /devices
664 */
665 if (VFS_MOUNT(&devices, mvp, &mounta, CRED()))
666 panic("Cannot mount /devices");
667
668 RUNLOCK_VFSSW();
669
670 /*
671 * Set appropriate members and add to vfs list for mnttab display
672 */
673 vfs_setresource(&devices, "/devices", 0);
674 vfs_setmntpoint(&devices, "/devices", 0);
675
676 /*
677 * Hold the root of /devices so it won't go away
678 */
679 if (VFS_ROOT(&devices, &devicesdir))
680 panic("vfs_mountdevices: not devices root");
681
682 if (vfs_lock(&devices) != 0) {
683 VN_RELE(devicesdir);
684 cmn_err(CE_NOTE, "Cannot acquire vfs_lock of /devices");
685 return;
686 }
687
688 if (vn_vfswlock(mvp) != 0) {
689 vfs_unlock(&devices);
690 VN_RELE(devicesdir);
691 cmn_err(CE_NOTE, "Cannot acquire vfswlock of /devices");
692 return;
693 }
694
695 vfs_add(mvp, &devices, 0);
696 vn_vfsunlock(mvp);
697 vfs_unlock(&devices);
698 VN_RELE(devicesdir);
699 }
700
701 /*
702 * mount the first instance of /dev to root and remain mounted
703 */
704 static void
705 vfs_mountdev1(void)
706 {
707 struct vfssw *vsw;
708 struct vnode *mvp;
709 struct mounta mounta = { /* fake mounta for sdev_mount() */
710 NULL,
711 NULL,
712 MS_SYSSPACE | MS_OVERLAY,
713 NULL,
714 NULL,
715 0,
716 NULL,
717 0
718 };
719
720 /*
721 * _init dev module to fill in the vfssw
722 */
723 if (modload("fs", "dev") == -1)
724 cmn_err(CE_PANIC, "Cannot _init dev module\n");
725
726 /*
727 * Hold vfs
728 */
729 RLOCK_VFSSW();
730 vsw = vfs_getvfsswbyname("dev");
731 VFS_INIT(&dev, &vsw->vsw_vfsops, NULL);
732 VFS_HOLD(&dev);
733
734 /*
735 * Locate mount point
736 */
737 if (lookupname("/dev", UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp))
738 cmn_err(CE_PANIC, "Cannot find /dev\n");
739
740 /*
741 * Perform the mount of /dev
742 */
743 if (VFS_MOUNT(&dev, mvp, &mounta, CRED()))
744 cmn_err(CE_PANIC, "Cannot mount /dev 1\n");
745
746 RUNLOCK_VFSSW();
747
748 /*
749 * Set appropriate members and add to vfs list for mnttab display
750 */
751 vfs_setresource(&dev, "/dev", 0);
752 vfs_setmntpoint(&dev, "/dev", 0);
753
754 /*
755 * Hold the root of /dev so it won't go away
756 */
757 if (VFS_ROOT(&dev, &devdir))
758 cmn_err(CE_PANIC, "vfs_mountdev1: not dev root");
759
760 if (vfs_lock(&dev) != 0) {
761 VN_RELE(devdir);
762 cmn_err(CE_NOTE, "Cannot acquire vfs_lock of /dev");
763 return;
764 }
765
766 if (vn_vfswlock(mvp) != 0) {
767 vfs_unlock(&dev);
768 VN_RELE(devdir);
769 cmn_err(CE_NOTE, "Cannot acquire vfswlock of /dev");
770 return;
771 }
772
773 vfs_add(mvp, &dev, 0);
774 vn_vfsunlock(mvp);
775 vfs_unlock(&dev);
776 VN_RELE(devdir);
777 }
778
779 /*
780 * Mount required filesystem. This is done right after root is mounted.
781 */
782 static void
783 vfs_mountfs(char *module, char *spec, char *path)
784 {
785 struct vnode *mvp;
786 struct mounta mounta;
787 vfs_t *vfsp;
788
789 mounta.flags = MS_SYSSPACE | MS_DATA;
790 mounta.fstype = module;
791 mounta.spec = spec;
792 mounta.dir = path;
793 if (lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp)) {
794 cmn_err(CE_WARN, "Cannot find %s", path);
795 return;
796 }
797 if (domount(NULL, &mounta, mvp, CRED(), &vfsp))
798 cmn_err(CE_WARN, "Cannot mount %s", path);
799 else
800 VFS_RELE(vfsp);
801 VN_RELE(mvp);
802 }
803
804 /*
805 * vfs_mountroot is called by main() to mount the root filesystem.
806 */
807 void
808 vfs_mountroot(void)
809 {
810 struct vnode *rvp = NULL;
811 char *path;
812 size_t plen;
813 struct vfssw *vswp;
814 proc_t *p;
815
816 rw_init(&vfssw_lock, NULL, RW_DEFAULT, NULL);
817 rw_init(&vfslist, NULL, RW_DEFAULT, NULL);
818
819 /*
820 * Alloc the vfs hash bucket array and locks
821 */
822 rvfs_list = kmem_zalloc(vfshsz * sizeof (rvfs_t), KM_SLEEP);
823
824 /*
825 * Call machine-dependent routine "rootconf" to choose a root
826 * file system type.
827 */
828 if (rootconf())
829 panic("vfs_mountroot: cannot mount root");
830 /*
831 * Get vnode for '/'. Set up rootdir, u.u_rdir and u.u_cdir
832 * to point to it. These are used by lookuppn() so that it
833 * knows where to start from ('/' or '.').
834 */
835 vfs_setmntpoint(rootvfs, "/", 0);
836 if (VFS_ROOT(rootvfs, &rootdir))
837 panic("vfs_mountroot: no root vnode");
838
839 /*
840 * At this point, the process tree consists of p0 and possibly some
841 * direct children of p0. (i.e. there are no grandchildren)
842 *
843 * Walk through them all, setting their current directory.
844 */
845 mutex_enter(&pidlock);
846 for (p = practive; p != NULL; p = p->p_next) {
847 ASSERT(p == &p0 || p->p_parent == &p0);
848
849 PTOU(p)->u_cdir = rootdir;
850 VN_HOLD(PTOU(p)->u_cdir);
851 PTOU(p)->u_rdir = NULL;
852 }
853 mutex_exit(&pidlock);
854
855 /*
856 * Setup the global zone's rootvp, now that it exists.
857 */
858 global_zone->zone_rootvp = rootdir;
859 VN_HOLD(global_zone->zone_rootvp);
860
861 /*
862 * Notify the module code that it can begin using the
863 * root filesystem instead of the boot program's services.
864 */
865 modrootloaded = 1;
866
867 /*
868 * Special handling for a ZFS root file system.
869 */
870 zfs_boot_init();
871
872 /*
873 * Set up mnttab information for root
874 */
875 vfs_setresource(rootvfs, rootfs.bo_name, 0);
876
877 /*
878 * Notify cluster software that the root filesystem is available.
879 */
880 clboot_mountroot();
881
882 /* Now that we're all done with the root FS, set up its vopstats */
883 if ((vswp = vfs_getvfsswbyvfsops(vfs_getops(rootvfs))) != NULL) {
884 /* Set flag for statistics collection */
885 if (vswp->vsw_flag & VSW_STATS) {
886 initialize_vopstats(&rootvfs->vfs_vopstats);
887 rootvfs->vfs_flag |= VFS_STATS;
888 rootvfs->vfs_fstypevsp =
889 get_fstype_vopstats(rootvfs, vswp);
890 rootvfs->vfs_vskap = get_vskstat_anchor(rootvfs);
891 }
892 vfs_unrefvfssw(vswp);
893 }
894
895 /*
896 * Mount /devices, /dev instance 1, /system/contract, /etc/mnttab,
897 * /etc/svc/volatile, /etc/dfs/sharetab, /system/object, and /proc.
898 */
899 vfs_mountdevices();
900 vfs_mountdev1();
901
902 vfs_mountfs("ctfs", "ctfs", CTFS_ROOT);
903 vfs_mountfs("proc", "/proc", "/proc");
904 vfs_mountfs("mntfs", "/etc/mnttab", "/etc/mnttab");
905 vfs_mountfs("tmpfs", "/etc/svc/volatile", "/etc/svc/volatile");
906 vfs_mountfs("objfs", "objfs", OBJFS_ROOT);
907
908 if (getzoneid() == GLOBAL_ZONEID) {
909 vfs_mountfs("sharefs", "sharefs", "/etc/dfs/sharetab");
910 }
911
912 #ifdef __sparc
913 /*
914 * This bit of magic can go away when we convert sparc to
915 * the new boot architecture based on ramdisk.
916 *
917 * Booting off a mirrored root volume:
918 * At this point, we have booted and mounted root on a
919 * single component of the mirror. Complete the boot
920 * by configuring SVM and converting the root to the
921 * dev_t of the mirrored root device. This dev_t conversion
922 * only works because the underlying device doesn't change.
923 */
924 if (root_is_svm) {
925 if (svm_rootconf()) {
926 panic("vfs_mountroot: cannot remount root");
927 }
928
929 /*
930 * mnttab should reflect the new root device
931 */
932 vfs_lock_wait(rootvfs);
933 vfs_setresource(rootvfs, rootfs.bo_name, 0);
934 vfs_unlock(rootvfs);
935 }
936 #endif /* __sparc */
937
938 if (strcmp(rootfs.bo_fstype, "zfs") != 0) {
939 /*
940 * Look up the root device via devfs so that a dv_node is
941 * created for it. The vnode is never VN_RELE()ed.
942 * We allocate more than MAXPATHLEN so that the
943 * buffer passed to i_ddi_prompath_to_devfspath() is
944 * exactly MAXPATHLEN (the function expects a buffer
945 * of that length).
946 */
947 plen = strlen("/devices");
948 path = kmem_alloc(plen + MAXPATHLEN, KM_SLEEP);
949 (void) strcpy(path, "/devices");
950
951 if (i_ddi_prompath_to_devfspath(rootfs.bo_name, path + plen)
952 != DDI_SUCCESS ||
953 lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, &rvp)) {
954
955 /* NUL terminate in case "path" has garbage */
956 path[plen + MAXPATHLEN - 1] = '\0';
957 #ifdef DEBUG
958 cmn_err(CE_WARN, "!Cannot lookup root device: %s",
959 path);
960 #endif
961 }
962 kmem_free(path, plen + MAXPATHLEN);
963 }
964
965 vfs_mnttabvp_setup();
966 }
967
968 /*
969 * Check to see if our "block device" is actually a file. If so,
970 * automatically add a lofi device, and keep track of this fact.
971 */
972 static int
973 lofi_add(const char *fsname, struct vfs *vfsp,
974 mntopts_t *mntopts, struct mounta *uap)
975 {
976 int fromspace = (uap->flags & MS_SYSSPACE) ?
977 UIO_SYSSPACE : UIO_USERSPACE;
978 struct lofi_ioctl *li = NULL;
979 struct vnode *vp = NULL;
980 struct pathname pn = { NULL };
981 ldi_ident_t ldi_id;
982 ldi_handle_t ldi_hdl;
983 vfssw_t *vfssw;
984 int minor;
985 int err = 0;
986
987 if ((vfssw = vfs_getvfssw(fsname)) == NULL)
988 return (0);
989
990 if (!(vfssw->vsw_flag & VSW_CANLOFI)) {
991 vfs_unrefvfssw(vfssw);
992 return (0);
993 }
994
995 vfs_unrefvfssw(vfssw);
996 vfssw = NULL;
997
998 if (pn_get(uap->spec, fromspace, &pn) != 0)
999 return (0);
1000
1001 if (lookupname(uap->spec, fromspace, FOLLOW, NULL, &vp) != 0)
1002 goto out;
1003
1004 if (vp->v_type != VREG)
1005 goto out;
1006
1007 /* OK, this is a lofi mount. */
1008
1009 if ((uap->flags & (MS_REMOUNT|MS_GLOBAL)) ||
1010 vfs_optionisset_nolock(mntopts, MNTOPT_SUID, NULL) ||
1011 vfs_optionisset_nolock(mntopts, MNTOPT_SETUID, NULL) ||
1012 vfs_optionisset_nolock(mntopts, MNTOPT_DEVICES, NULL)) {
1013 err = EINVAL;
1014 goto out;
1015 }
1016
1017 ldi_id = ldi_ident_from_anon();
1018 li = kmem_zalloc(sizeof (*li), KM_SLEEP);
1019 (void) strlcpy(li->li_filename, pn.pn_path, MAXPATHLEN);
1020
1021 err = ldi_open_by_name("/dev/lofictl", FREAD | FWRITE, kcred,
1022 &ldi_hdl, ldi_id);
1023
1024 if (err)
1025 goto out2;
1026
1027 err = ldi_ioctl(ldi_hdl, LOFI_MAP_FILE, (intptr_t)li,
1028 FREAD | FWRITE | FKIOCTL, kcred, &minor);
1029
1030 (void) ldi_close(ldi_hdl, FREAD | FWRITE, kcred);
1031
1032 if (!err)
1033 vfsp->vfs_lofi_minor = minor;
1034
1035 out2:
1036 ldi_ident_release(ldi_id);
1037 out:
1038 if (li != NULL)
1039 kmem_free(li, sizeof (*li));
1040 if (vp != NULL)
1041 VN_RELE(vp);
1042 pn_free(&pn);
1043 return (err);
1044 }
1045
1046 static void
1047 lofi_remove(struct vfs *vfsp)
1048 {
1049 struct lofi_ioctl *li = NULL;
1050 ldi_ident_t ldi_id;
1051 ldi_handle_t ldi_hdl;
1052 int err;
1053
1054 if (vfsp->vfs_lofi_minor == 0)
1055 return;
1056
1057 ldi_id = ldi_ident_from_anon();
1058
1059 li = kmem_zalloc(sizeof (*li), KM_SLEEP);
1060 li->li_minor = vfsp->vfs_lofi_minor;
1061 li->li_cleanup = B_TRUE;
1062
1063 err = ldi_open_by_name("/dev/lofictl", FREAD | FWRITE, kcred,
1064 &ldi_hdl, ldi_id);
1065
1066 if (err)
1067 goto out;
1068
1069 err = ldi_ioctl(ldi_hdl, LOFI_UNMAP_FILE_MINOR, (intptr_t)li,
1070 FREAD | FWRITE | FKIOCTL, kcred, NULL);
1071
1072 (void) ldi_close(ldi_hdl, FREAD | FWRITE, kcred);
1073
1074 if (!err)
1075 vfsp->vfs_lofi_minor = 0;
1076
1077 out:
1078 ldi_ident_release(ldi_id);
1079 if (li != NULL)
1080 kmem_free(li, sizeof (*li));
1081 }
1082
1083 /*
1084 * Common mount code. Called from the system call entry point, from autofs,
1085 * nfsv4 trigger mounts, and from pxfs.
1086 *
1087 * Takes the effective file system type, mount arguments, the mount point
1088 * vnode, flags specifying whether the mount is a remount and whether it
1089 * should be entered into the vfs list, and credentials. Fills in its vfspp
1090 * parameter with the mounted file system instance's vfs.
1091 *
1092 * Note that the effective file system type is specified as a string. It may
1093 * be null, in which case it's determined from the mount arguments, and may
1094 * differ from the type specified in the mount arguments; this is a hook to
1095 * allow interposition when instantiating file system instances.
1096 *
1097 * The caller is responsible for releasing its own hold on the mount point
1098 * vp (this routine does its own hold when necessary).
1099 * Also note that for remounts, the mount point vp should be the vnode for
1100 * the root of the file system rather than the vnode that the file system
1101 * is mounted on top of.
1102 */
1103 int
1104 domount(char *fsname, struct mounta *uap, vnode_t *vp, struct cred *credp,
1105 struct vfs **vfspp)
1106 {
1107 struct vfssw *vswp;
1108 vfsops_t *vfsops;
1109 struct vfs *vfsp;
1110 struct vnode *bvp;
1111 dev_t bdev = 0;
1112 mntopts_t mnt_mntopts;
1113 int error = 0;
1114 int copyout_error = 0;
1115 int ovflags;
1116 char *opts = uap->optptr;
1117 char *inargs = opts;
1118 int optlen = uap->optlen;
1119 int remount;
1120 int rdonly;
1121 int nbmand = 0;
1122 int delmip = 0;
1123 int addmip = 0;
1124 int splice = ((uap->flags & MS_NOSPLICE) == 0);
1125 int fromspace = (uap->flags & MS_SYSSPACE) ?
1126 UIO_SYSSPACE : UIO_USERSPACE;
1127 char *resource = NULL, *mountpt = NULL;
1128 refstr_t *oldresource, *oldmntpt;
1129 struct pathname pn, rpn;
1130 vsk_anchor_t *vskap;
1131 char fstname[FSTYPSZ];
1132
1133 /*
1134 * The v_flag value for the mount point vp is permanently set
1135 * to VVFSLOCK so that no one bypasses the vn_vfs*locks routine
1136 * for mount point locking.
1137 */
1138 mutex_enter(&vp->v_lock);
1139 vp->v_flag |= VVFSLOCK;
1140 mutex_exit(&vp->v_lock);
1141
1142 mnt_mntopts.mo_count = 0;
1143 /*
1144 * Find the ops vector to use to invoke the file system-specific mount
1145 * method. If the fsname argument is non-NULL, use it directly.
1146 * Otherwise, dig the file system type information out of the mount
1147 * arguments.
1148 *
1149 * A side effect is to hold the vfssw entry.
1150 *
1151 * Mount arguments can be specified in several ways, which are
1152 * distinguished by flag bit settings. The preferred way is to set
1153 * MS_OPTIONSTR, indicating an 8 argument mount with the file system
1154 * type supplied as a character string and the last two arguments
1155 * being a pointer to a character buffer and the size of the buffer.
1156 * On entry, the buffer holds a null terminated list of options; on
1157 * return, the string is the list of options the file system
1158 * recognized. If MS_DATA is set arguments five and six point to a
1159 * block of binary data which the file system interprets.
1160 * A further wrinkle is that some callers don't set MS_FSS and MS_DATA
1161 * consistently with these conventions. To handle them, we check to
1162 * see whether the pointer to the file system name has a numeric value
1163 * less than 256. If so, we treat it as an index.
1164 */
1165 if (fsname != NULL) {
1166 if ((vswp = vfs_getvfssw(fsname)) == NULL) {
1167 return (EINVAL);
1168 }
1169 } else if (uap->flags & (MS_OPTIONSTR | MS_DATA | MS_FSS)) {
1170 size_t n;
1171 uint_t fstype;
1172
1173 fsname = fstname;
1174
1175 if ((fstype = (uintptr_t)uap->fstype) < 256) {
1176 RLOCK_VFSSW();
1177 if (fstype == 0 || fstype >= nfstype ||
1178 !ALLOCATED_VFSSW(&vfssw[fstype])) {
1179 RUNLOCK_VFSSW();
1180 return (EINVAL);
1181 }
1182 (void) strcpy(fsname, vfssw[fstype].vsw_name);
1183 RUNLOCK_VFSSW();
1184 if ((vswp = vfs_getvfssw(fsname)) == NULL)
1185 return (EINVAL);
1186 } else {
1187 /*
1188 * Handle either kernel or user address space.
1189 */
1190 if (uap->flags & MS_SYSSPACE) {
1191 error = copystr(uap->fstype, fsname,
1192 FSTYPSZ, &n);
1193 } else {
1194 error = copyinstr(uap->fstype, fsname,
1195 FSTYPSZ, &n);
1196 }
1197 if (error) {
1198 if (error == ENAMETOOLONG)
1199 return (EINVAL);
1200 return (error);
1201 }
1202 if ((vswp = vfs_getvfssw(fsname)) == NULL)
1203 return (EINVAL);
1204 }
1205 } else {
1206 if ((vswp = vfs_getvfsswbyvfsops(vfs_getops(rootvfs))) == NULL)
1207 return (EINVAL);
1208 fsname = vswp->vsw_name;
1209 }
1210 if (!VFS_INSTALLED(vswp))
1211 return (EINVAL);
1212
1213 if ((error = secpolicy_fs_allowed_mount(fsname)) != 0) {
1214 vfs_unrefvfssw(vswp);
1215 return (error);
1216 }
1217
1218 vfsops = &vswp->vsw_vfsops;
1219
1220 vfs_copyopttbl(&vswp->vsw_optproto, &mnt_mntopts);
1221 /*
1222 * Fetch mount options and parse them for generic vfs options
1223 */
1224 if (uap->flags & MS_OPTIONSTR) {
1225 /*
1226 * Limit the buffer size
1227 */
1228 if (optlen < 0 || optlen > MAX_MNTOPT_STR) {
1229 error = EINVAL;
1230 goto errout;
1231 }
1232 if ((uap->flags & MS_SYSSPACE) == 0) {
1233 inargs = kmem_alloc(MAX_MNTOPT_STR, KM_SLEEP);
1234 inargs[0] = '\0';
1235 if (optlen) {
1236 error = copyinstr(opts, inargs, (size_t)optlen,
1237 NULL);
1238 if (error) {
1239 goto errout;
1240 }
1241 }
1242 }
1243 vfs_parsemntopts(&mnt_mntopts, inargs, 0);
1244 }
1245 /*
1246 * Flag bits override the options string.
1247 */
1248 if (uap->flags & MS_REMOUNT)
1249 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_REMOUNT, NULL, 0, 0);
1250 if (uap->flags & MS_RDONLY)
1251 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_RO, NULL, 0, 0);
1252 if (uap->flags & MS_NOSUID)
1253 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL, 0, 0);
1254
1255 /*
1256 * Check if this is a remount; must be set in the option string and
1257 * the file system must support a remount option.
1258 */
1259 if (remount = vfs_optionisset_nolock(&mnt_mntopts,
1260 MNTOPT_REMOUNT, NULL)) {
1261 if (!(vswp->vsw_flag & VSW_CANREMOUNT)) {
1262 error = ENOTSUP;
1263 goto errout;
1264 }
1265 uap->flags |= MS_REMOUNT;
1266 }
1267
1268 /*
1269 * uap->flags and vfs_optionisset() should agree.
1270 */
1271 if (rdonly = vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_RO, NULL)) {
1272 uap->flags |= MS_RDONLY;
1273 }
1274 if (vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL)) {
1275 uap->flags |= MS_NOSUID;
1276 }
1277 nbmand = vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_NBMAND, NULL);
1278 ASSERT(splice || !remount);
1279 /*
1280 * If we are splicing the fs into the namespace,
1281 * perform mount point checks.
1282 *
1283 * We want to resolve the path for the mount point to eliminate
1284 * '.' and ".." and symlinks in mount points; we can't do the
1285 * same for the resource string, since it would turn
1286 * "/dev/dsk/c0t0d0s0" into "/devices/pci@...". We need to do
1287 * this before grabbing vn_vfswlock(), because otherwise we
1288 * would deadlock with lookuppn().
1289 */
1290 if (splice) {
1291 ASSERT(vp->v_count > 0);
1292
1293 /*
1294 * Pick up mount point and device from appropriate space.
1295 */
1296 if (pn_get(uap->spec, fromspace, &pn) == 0) {
1297 resource = kmem_alloc(pn.pn_pathlen + 1,
1298 KM_SLEEP);
1299 (void) strcpy(resource, pn.pn_path);
1300 pn_free(&pn);
1301 }
1302 /*
1303 * Do a lookupname prior to taking the
1304 * writelock. Mark this as completed if
1305 * successful for later cleanup and addition to
1306 * the mount in progress table.
1307 */
1308 if ((uap->flags & MS_GLOBAL) == 0 &&
1309 lookupname(uap->spec, fromspace,
1310 FOLLOW, NULL, &bvp) == 0) {
1311 addmip = 1;
1312 }
1313
1314 if ((error = pn_get(uap->dir, fromspace, &pn)) == 0) {
1315 pathname_t *pnp;
1316
1317 if (*pn.pn_path != '/') {
1318 error = EINVAL;
1319 pn_free(&pn);
1320 goto errout;
1321 }
1322 pn_alloc(&rpn);
1323 /*
1324 * Kludge to prevent autofs from deadlocking with
1325 * itself when it calls domount().
1326 *
1327 * If autofs is calling, it is because it is doing
1328 * (autofs) mounts in the process of an NFS mount. A
1329 * lookuppn() here would cause us to block waiting for
1330 * said NFS mount to complete, which can't since this
1331 * is the thread that was supposed to doing it.
1332 */
1333 if (fromspace == UIO_USERSPACE) {
1334 if ((error = lookuppn(&pn, &rpn, FOLLOW, NULL,
1335 NULL)) == 0) {
1336 pnp = &rpn;
1337 } else {
1338 /*
1339 * The file disappeared or otherwise
1340 * became inaccessible since we opened
1341 * it; might as well fail the mount
1342 * since the mount point is no longer
1343 * accessible.
1344 */
1345 pn_free(&rpn);
1346 pn_free(&pn);
1347 goto errout;
1348 }
1349 } else {
1350 pnp = &pn;
1351 }
1352 mountpt = kmem_alloc(pnp->pn_pathlen + 1, KM_SLEEP);
1353 (void) strcpy(mountpt, pnp->pn_path);
1354
1355 /*
1356 * If the addition of the zone's rootpath
1357 * would push us over a total path length
1358 * of MAXPATHLEN, we fail the mount with
1359 * ENAMETOOLONG, which is what we would have
1360 * gotten if we were trying to perform the same
1361 * mount in the global zone.
1362 *
1363 * strlen() doesn't count the trailing
1364 * '\0', but zone_rootpathlen counts both a
1365 * trailing '/' and the terminating '\0'.
1366 */
1367 if ((curproc->p_zone->zone_rootpathlen - 1 +
1368 strlen(mountpt)) > MAXPATHLEN ||
1369 (resource != NULL &&
1370 (curproc->p_zone->zone_rootpathlen - 1 +
1371 strlen(resource)) > MAXPATHLEN)) {
1372 error = ENAMETOOLONG;
1373 }
1374
1375 pn_free(&rpn);
1376 pn_free(&pn);
1377 }
1378
1379 if (error)
1380 goto errout;
1381
1382 /*
1383 * Prevent path name resolution from proceeding past
1384 * the mount point.
1385 */
1386 if (vn_vfswlock(vp) != 0) {
1387 error = EBUSY;
1388 goto errout;
1389 }
1390
1391 /*
1392 * Verify that it's legitimate to establish a mount on
1393 * the prospective mount point.
1394 */
1395 if (vn_mountedvfs(vp) != NULL) {
1396 /*
1397 * The mount point lock was obtained after some
1398 * other thread raced through and established a mount.
1399 */
1400 vn_vfsunlock(vp);
1401 error = EBUSY;
1402 goto errout;
1403 }
1404 if (vp->v_flag & VNOMOUNT) {
1405 vn_vfsunlock(vp);
1406 error = EINVAL;
1407 goto errout;
1408 }
1409 }
1410 if ((uap->flags & (MS_DATA | MS_OPTIONSTR)) == 0) {
1411 uap->dataptr = NULL;
1412 uap->datalen = 0;
1413 }
1414
1415 /*
1416 * If this is a remount, we don't want to create a new VFS.
1417 * Instead, we pass the existing one with a remount flag.
1418 */
1419 if (remount) {
1420 /*
1421 * Confirm that the mount point is the root vnode of the
1422 * file system that is being remounted.
1423 * This can happen if the user specifies a different
1424 * mount point directory pathname in the (re)mount command.
1425 *
1426 * Code below can only be reached if splice is true, so it's
1427 * safe to do vn_vfsunlock() here.
1428 */
1429 if ((vp->v_flag & VROOT) == 0) {
1430 vn_vfsunlock(vp);
1431 error = ENOENT;
1432 goto errout;
1433 }
1434 /*
1435 * Disallow making file systems read-only unless file system
1436 * explicitly allows it in its vfssw. Ignore other flags.
1437 */
1438 if (rdonly && vn_is_readonly(vp) == 0 &&
1439 (vswp->vsw_flag & VSW_CANRWRO) == 0) {
1440 vn_vfsunlock(vp);
1441 error = EINVAL;
1442 goto errout;
1443 }
1444 /*
1445 * Disallow changing the NBMAND disposition of the file
1446 * system on remounts.
1447 */
1448 if ((nbmand && ((vp->v_vfsp->vfs_flag & VFS_NBMAND) == 0)) ||
1449 (!nbmand && (vp->v_vfsp->vfs_flag & VFS_NBMAND))) {
1450 vn_vfsunlock(vp);
1451 error = EINVAL;
1452 goto errout;
1453 }
1454 vfsp = vp->v_vfsp;
1455 ovflags = vfsp->vfs_flag;
1456 vfsp->vfs_flag |= VFS_REMOUNT;
1457 vfsp->vfs_flag &= ~VFS_RDONLY;
1458 } else {
1459 vfsp = vfs_alloc(KM_SLEEP);
1460 VFS_INIT(vfsp, vfsops, NULL);
1461 }
1462
1463 VFS_HOLD(vfsp);
1464
1465 if ((error = lofi_add(fsname, vfsp, &mnt_mntopts, uap)) != 0) {
1466 if (!remount) {
1467 if (splice)
1468 vn_vfsunlock(vp);
1469 vfs_free(vfsp);
1470 } else {
1471 vn_vfsunlock(vp);
1472 VFS_RELE(vfsp);
1473 }
1474 goto errout;
1475 }
1476
1477 /*
1478 * PRIV_SYS_MOUNT doesn't mean you can become root.
1479 */
1480 if (vfsp->vfs_lofi_minor != 0) {
1481 uap->flags |= MS_NOSUID;
1482 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL, 0, 0);
1483 }
1484
1485 /*
1486 * The vfs_reflock is not used anymore the code below explicitly
1487 * holds it preventing others accesing it directly.
1488 */
1489 if ((sema_tryp(&vfsp->vfs_reflock) == 0) &&
1490 !(vfsp->vfs_flag & VFS_REMOUNT))
1491 cmn_err(CE_WARN,
1492 "mount type %s couldn't get vfs_reflock", vswp->vsw_name);
1493
1494 /*
1495 * Lock the vfs. If this is a remount we want to avoid spurious umount
1496 * failures that happen as a side-effect of fsflush() and other mount
1497 * and unmount operations that might be going on simultaneously and
1498 * may have locked the vfs currently. To not return EBUSY immediately
1499 * here we use vfs_lock_wait() instead vfs_lock() for the remount case.
1500 */
1501 if (!remount) {
1502 if (error = vfs_lock(vfsp)) {
1503 vfsp->vfs_flag = ovflags;
1504
1505 lofi_remove(vfsp);
1506
1507 if (splice)
1508 vn_vfsunlock(vp);
1509 vfs_free(vfsp);
1510 goto errout;
1511 }
1512 } else {
1513 vfs_lock_wait(vfsp);
1514 }
1515
1516 /*
1517 * Add device to mount in progress table, global mounts require special
1518 * handling. It is possible that we have already done the lookupname
1519 * on a spliced, non-global fs. If so, we don't want to do it again
1520 * since we cannot do a lookupname after taking the
1521 * wlock above. This case is for a non-spliced, non-global filesystem.
1522 */
1523 if (!addmip) {
1524 if ((uap->flags & MS_GLOBAL) == 0 &&
1525 lookupname(uap->spec, fromspace, FOLLOW, NULL, &bvp) == 0) {
1526 addmip = 1;
1527 }
1528 }
1529
1530 if (addmip) {
1531 vnode_t *lvp = NULL;
1532
1533 error = vfs_get_lofi(vfsp, &lvp);
1534 if (error > 0) {
1535 lofi_remove(vfsp);
1536
1537 if (splice)
1538 vn_vfsunlock(vp);
1539 vfs_unlock(vfsp);
1540
1541 if (remount) {
1542 VFS_RELE(vfsp);
1543 } else {
1544 vfs_free(vfsp);
1545 }
1546
1547 goto errout;
1548 } else if (error == -1) {
1549 bdev = bvp->v_rdev;
1550 VN_RELE(bvp);
1551 } else {
1552 bdev = lvp->v_rdev;
1553 VN_RELE(lvp);
1554 VN_RELE(bvp);
1555 }
1556
1557 vfs_addmip(bdev, vfsp);
1558 addmip = 0;
1559 delmip = 1;
1560 }
1561 /*
1562 * Invalidate cached entry for the mount point.
1563 */
1564 if (splice)
1565 dnlc_purge_vp(vp);
1566
1567 /*
1568 * If have an option string but the filesystem doesn't supply a
1569 * prototype options table, create a table with the global
1570 * options and sufficient room to accept all the options in the
1571 * string. Then parse the passed in option string
1572 * accepting all the options in the string. This gives us an
1573 * option table with all the proper cancel properties for the
1574 * global options.
1575 *
1576 * Filesystems that supply a prototype options table are handled
1577 * earlier in this function.
1578 */
1579 if (uap->flags & MS_OPTIONSTR) {
1580 if (!(vswp->vsw_flag & VSW_HASPROTO)) {
1581 mntopts_t tmp_mntopts;
1582
1583 tmp_mntopts.mo_count = 0;
1584 vfs_createopttbl_extend(&tmp_mntopts, inargs,
1585 &mnt_mntopts);
1586 vfs_parsemntopts(&tmp_mntopts, inargs, 1);
1587 vfs_swapopttbl_nolock(&mnt_mntopts, &tmp_mntopts);
1588 vfs_freeopttbl(&tmp_mntopts);
1589 }
1590 }
1591
1592 /*
1593 * Serialize with zone creations.
1594 */
1595 mount_in_progress();
1596 /*
1597 * Instantiate (or reinstantiate) the file system. If appropriate,
1598 * splice it into the file system name space.
1599 *
1600 * We want VFS_MOUNT() to be able to override the vfs_resource
1601 * string if necessary (ie, mntfs), and also for a remount to
1602 * change the same (necessary when remounting '/' during boot).
1603 * So we set up vfs_mntpt and vfs_resource to what we think they
1604 * should be, then hand off control to VFS_MOUNT() which can
1605 * override this.
1606 *
1607 * For safety's sake, when changing vfs_resource or vfs_mntpt of
1608 * a vfs which is on the vfs list (i.e. during a remount), we must
1609 * never set those fields to NULL. Several bits of code make
1610 * assumptions that the fields are always valid.
1611 */
1612 vfs_swapopttbl(&mnt_mntopts, &vfsp->vfs_mntopts);
1613 if (remount) {
1614 if ((oldresource = vfsp->vfs_resource) != NULL)
1615 refstr_hold(oldresource);
1616 if ((oldmntpt = vfsp->vfs_mntpt) != NULL)
1617 refstr_hold(oldmntpt);
1618 }
1619 vfs_setresource(vfsp, resource, 0);
1620 vfs_setmntpoint(vfsp, mountpt, 0);
1621
1622 /*
1623 * going to mount on this vnode, so notify.
1624 */
1625 vnevent_mountedover(vp, NULL);
1626 error = VFS_MOUNT(vfsp, vp, uap, credp);
1627
1628 if (uap->flags & MS_RDONLY)
1629 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
1630 if (uap->flags & MS_NOSUID)
1631 vfs_setmntopt(vfsp, MNTOPT_NOSUID, NULL, 0);
1632 if (uap->flags & MS_GLOBAL)
1633 vfs_setmntopt(vfsp, MNTOPT_GLOBAL, NULL, 0);
1634
1635 if (error) {
1636 lofi_remove(vfsp);
1637
1638 if (remount) {
1639 /* put back pre-remount options */
1640 vfs_swapopttbl(&mnt_mntopts, &vfsp->vfs_mntopts);
1641 vfs_setmntpoint(vfsp, refstr_value(oldmntpt),
1642 VFSSP_VERBATIM);
1643 if (oldmntpt)
1644 refstr_rele(oldmntpt);
1645 vfs_setresource(vfsp, refstr_value(oldresource),
1646 VFSSP_VERBATIM);
1647 if (oldresource)
1648 refstr_rele(oldresource);
1649 vfsp->vfs_flag = ovflags;
1650 vfs_unlock(vfsp);
1651 VFS_RELE(vfsp);
1652 } else {
1653 vfs_unlock(vfsp);
1654 vfs_freemnttab(vfsp);
1655 vfs_free(vfsp);
1656 }
1657 } else {
1658 /*
1659 * Set the mount time to now
1660 */
1661 vfsp->vfs_mtime = ddi_get_time();
1662 if (remount) {
1663 vfsp->vfs_flag &= ~VFS_REMOUNT;
1664 if (oldresource)
1665 refstr_rele(oldresource);
1666 if (oldmntpt)
1667 refstr_rele(oldmntpt);
1668 } else if (splice) {
1669 /*
1670 * Link vfsp into the name space at the mount
1671 * point. Vfs_add() is responsible for
1672 * holding the mount point which will be
1673 * released when vfs_remove() is called.
1674 */
1675 vfs_add(vp, vfsp, uap->flags);
1676 } else {
1677 /*
1678 * Hold the reference to file system which is
1679 * not linked into the name space.
1680 */
1681 vfsp->vfs_zone = NULL;
1682 VFS_HOLD(vfsp);
1683 vfsp->vfs_vnodecovered = NULL;
1684 }
1685 /*
1686 * Set flags for global options encountered
1687 */
1688 if (vfs_optionisset(vfsp, MNTOPT_RO, NULL))
1689 vfsp->vfs_flag |= VFS_RDONLY;
1690 else
1691 vfsp->vfs_flag &= ~VFS_RDONLY;
1692 if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {
1693 vfsp->vfs_flag |= (VFS_NOSETUID|VFS_NODEVICES);
1694 } else {
1695 if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL))
1696 vfsp->vfs_flag |= VFS_NODEVICES;
1697 else
1698 vfsp->vfs_flag &= ~VFS_NODEVICES;
1699 if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL))
1700 vfsp->vfs_flag |= VFS_NOSETUID;
1701 else
1702 vfsp->vfs_flag &= ~VFS_NOSETUID;
1703 }
1704 if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL))
1705 vfsp->vfs_flag |= VFS_NBMAND;
1706 else
1707 vfsp->vfs_flag &= ~VFS_NBMAND;
1708
1709 if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL))
1710 vfsp->vfs_flag |= VFS_XATTR;
1711 else
1712 vfsp->vfs_flag &= ~VFS_XATTR;
1713
1714 if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL))
1715 vfsp->vfs_flag |= VFS_NOEXEC;
1716 else
1717 vfsp->vfs_flag &= ~VFS_NOEXEC;
1718
1719 /*
1720 * Now construct the output option string of options
1721 * we recognized.
1722 */
1723 if (uap->flags & MS_OPTIONSTR) {
1724 vfs_list_read_lock();
1725 copyout_error = vfs_buildoptionstr(
1726 &vfsp->vfs_mntopts, inargs, optlen);
1727 vfs_list_unlock();
1728 if (copyout_error == 0 &&
1729 (uap->flags & MS_SYSSPACE) == 0) {
1730 copyout_error = copyoutstr(inargs, opts,
1731 optlen, NULL);
1732 }
1733 }
1734
1735 /*
1736 * If this isn't a remount, set up the vopstats before
1737 * anyone can touch this. We only allow spliced file
1738 * systems (file systems which are in the namespace) to
1739 * have the VFS_STATS flag set.
1740 * NOTE: PxFS mounts the underlying file system with
1741 * MS_NOSPLICE set and copies those vfs_flags to its private
1742 * vfs structure. As a result, PxFS should never have
1743 * the VFS_STATS flag or else we might access the vfs
1744 * statistics-related fields prior to them being
1745 * properly initialized.
1746 */
1747 if (!remount && (vswp->vsw_flag & VSW_STATS) && splice) {
1748 initialize_vopstats(&vfsp->vfs_vopstats);
1749 /*
1750 * We need to set vfs_vskap to NULL because there's
1751 * a chance it won't be set below. This is checked
1752 * in teardown_vopstats() so we can't have garbage.
1753 */
1754 vfsp->vfs_vskap = NULL;
1755 vfsp->vfs_flag |= VFS_STATS;
1756 vfsp->vfs_fstypevsp = get_fstype_vopstats(vfsp, vswp);
1757 }
1758
1759 if (vswp->vsw_flag & VSW_XID)
1760 vfsp->vfs_flag |= VFS_XID;
1761
1762 vfs_unlock(vfsp);
1763 }
1764 mount_completed();
1765 if (splice)
1766 vn_vfsunlock(vp);
1767
1768 if ((error == 0) && (copyout_error == 0)) {
1769 if (!remount) {
1770 /*
1771 * Don't call get_vskstat_anchor() while holding
1772 * locks since it allocates memory and calls
1773 * VFS_STATVFS(). For NFS, the latter can generate
1774 * an over-the-wire call.
1775 */
1776 vskap = get_vskstat_anchor(vfsp);
1777 /* Only take the lock if we have something to do */
1778 if (vskap != NULL) {
1779 vfs_lock_wait(vfsp);
1780 if (vfsp->vfs_flag & VFS_STATS) {
1781 vfsp->vfs_vskap = vskap;
1782 }
1783 vfs_unlock(vfsp);
1784 }
1785 }
1786 /* Return vfsp to caller. */
1787 *vfspp = vfsp;
1788 }
1789 errout:
1790 vfs_freeopttbl(&mnt_mntopts);
1791 if (resource != NULL)
1792 kmem_free(resource, strlen(resource) + 1);
1793 if (mountpt != NULL)
1794 kmem_free(mountpt, strlen(mountpt) + 1);
1795 /*
1796 * It is possible we errored prior to adding to mount in progress
1797 * table. Must free vnode we acquired with successful lookupname.
1798 */
1799 if (addmip)
1800 VN_RELE(bvp);
1801 if (delmip)
1802 vfs_delmip(vfsp);
1803 ASSERT(vswp != NULL);
1804 vfs_unrefvfssw(vswp);
1805 if (inargs != opts)
1806 kmem_free(inargs, MAX_MNTOPT_STR);
1807 if (copyout_error) {
1808 lofi_remove(vfsp);
1809 VFS_RELE(vfsp);
1810 error = copyout_error;
1811 }
1812 return (error);
1813 }
1814
1815 static void
1816 vfs_setpath(
1817 struct vfs *vfsp, /* vfs being updated */
1818 refstr_t **refp, /* Ref-count string to contain the new path */
1819 const char *newpath, /* Path to add to refp (above) */
1820 uint32_t flag) /* flag */
1821 {
1822 size_t len;
1823 refstr_t *ref;
1824 zone_t *zone = curproc->p_zone;
1825 char *sp;
1826 int have_list_lock = 0;
1827
1828 ASSERT(!VFS_ON_LIST(vfsp) || vfs_lock_held(vfsp));
1829
1830 /*
1831 * New path must be less than MAXPATHLEN because mntfs
1832 * will only display up to MAXPATHLEN bytes. This is currently
1833 * safe, because domount() uses pn_get(), and other callers
1834 * similarly cap the size to fewer than MAXPATHLEN bytes.
1835 */
1836
1837 ASSERT(strlen(newpath) < MAXPATHLEN);
1838
1839 /* mntfs requires consistency while vfs list lock is held */
1840
1841 if (VFS_ON_LIST(vfsp)) {
1842 have_list_lock = 1;
1843 vfs_list_lock();
1844 }
1845
1846 if (*refp != NULL)
1847 refstr_rele(*refp);
1848
1849 /*
1850 * If we are in a non-global zone then we prefix the supplied path,
1851 * newpath, with the zone's root path, with two exceptions. The first
1852 * is where we have been explicitly directed to avoid doing so; this
1853 * will be the case following a failed remount, where the path supplied
1854 * will be a saved version which must now be restored. The second
1855 * exception is where newpath is not a pathname but a descriptive name,
1856 * e.g. "procfs".
1857 */
1858 if (zone == global_zone || (flag & VFSSP_VERBATIM) || *newpath != '/') {
1859 ref = refstr_alloc(newpath);
1860 goto out;
1861 }
1862
1863 /*
1864 * Truncate the trailing '/' in the zoneroot, and merge
1865 * in the zone's rootpath with the "newpath" (resource
1866 * or mountpoint) passed in.
1867 *
1868 * The size of the required buffer is thus the size of
1869 * the buffer required for the passed-in newpath
1870 * (strlen(newpath) + 1), plus the size of the buffer
1871 * required to hold zone_rootpath (zone_rootpathlen)
1872 * minus one for one of the now-superfluous NUL
1873 * terminations, minus one for the trailing '/'.
1874 *
1875 * That gives us:
1876 *
1877 * (strlen(newpath) + 1) + zone_rootpathlen - 1 - 1
1878 *
1879 * Which is what we have below.
1880 */
1881
1882 len = strlen(newpath) + zone->zone_rootpathlen - 1;
1883 sp = kmem_alloc(len, KM_SLEEP);
1884
1885 /*
1886 * Copy everything including the trailing slash, which
1887 * we then overwrite with the NUL character.
1888 */
1889
1890 (void) strcpy(sp, zone->zone_rootpath);
1891 sp[zone->zone_rootpathlen - 2] = '\0';
1892 (void) strcat(sp, newpath);
1893
1894 ref = refstr_alloc(sp);
1895 kmem_free(sp, len);
1896 out:
1897 *refp = ref;
1898
1899 if (have_list_lock) {
1900 vfs_mnttab_modtimeupd();
1901 vfs_list_unlock();
1902 }
1903 }
1904
1905 /*
1906 * Record a mounted resource name in a vfs structure.
1907 * If vfsp is already mounted, caller must hold the vfs lock.
1908 */
1909 void
1910 vfs_setresource(struct vfs *vfsp, const char *resource, uint32_t flag)
1911 {
1912 if (resource == NULL || resource[0] == '\0')
1913 resource = VFS_NORESOURCE;
1914 vfs_setpath(vfsp, &vfsp->vfs_resource, resource, flag);
1915 }
1916
1917 /*
1918 * Record a mount point name in a vfs structure.
1919 * If vfsp is already mounted, caller must hold the vfs lock.
1920 */
1921 void
1922 vfs_setmntpoint(struct vfs *vfsp, const char *mntpt, uint32_t flag)
1923 {
1924 if (mntpt == NULL || mntpt[0] == '\0')
1925 mntpt = VFS_NOMNTPT;
1926 vfs_setpath(vfsp, &vfsp->vfs_mntpt, mntpt, flag);
1927 }
1928
1929 /* Returns the vfs_resource. Caller must call refstr_rele() when finished. */
1930
1931 refstr_t *
1932 vfs_getresource(const struct vfs *vfsp)
1933 {
1934 refstr_t *resource;
1935
1936 vfs_list_read_lock();
1937 resource = vfsp->vfs_resource;
1938 refstr_hold(resource);
1939 vfs_list_unlock();
1940
1941 return (resource);
1942 }
1943
1944 /* Returns the vfs_mntpt. Caller must call refstr_rele() when finished. */
1945
1946 refstr_t *
1947 vfs_getmntpoint(const struct vfs *vfsp)
1948 {
1949 refstr_t *mntpt;
1950
1951 vfs_list_read_lock();
1952 mntpt = vfsp->vfs_mntpt;
1953 refstr_hold(mntpt);
1954 vfs_list_unlock();
1955
1956 return (mntpt);
1957 }
1958
1959 /*
1960 * Create an empty options table with enough empty slots to hold all
1961 * The options in the options string passed as an argument.
1962 * Potentially prepend another options table.
1963 *
1964 * Note: caller is responsible for locking the vfs list, if needed,
1965 * to protect mops.
1966 */
1967 static void
1968 vfs_createopttbl_extend(mntopts_t *mops, const char *opts,
1969 const mntopts_t *mtmpl)
1970 {
1971 const char *s = opts;
1972 uint_t count;
1973
1974 if (opts == NULL || *opts == '\0') {
1975 count = 0;
1976 } else {
1977 count = 1;
1978
1979 /*
1980 * Count number of options in the string
1981 */
1982 for (s = strchr(s, ','); s != NULL; s = strchr(s, ',')) {
1983 count++;
1984 s++;
1985 }
1986 }
1987 vfs_copyopttbl_extend(mtmpl, mops, count);
1988 }
1989
1990 /*
1991 * Create an empty options table with enough empty slots to hold all
1992 * The options in the options string passed as an argument.
1993 *
1994 * This function is *not* for general use by filesystems.
1995 *
1996 * Note: caller is responsible for locking the vfs list, if needed,
1997 * to protect mops.
1998 */
1999 void
2000 vfs_createopttbl(mntopts_t *mops, const char *opts)
2001 {
2002 vfs_createopttbl_extend(mops, opts, NULL);
2003 }
2004
2005
2006 /*
2007 * Swap two mount options tables
2008 */
2009 static void
2010 vfs_swapopttbl_nolock(mntopts_t *optbl1, mntopts_t *optbl2)
2011 {
2012 uint_t tmpcnt;
2013 mntopt_t *tmplist;
2014
2015 tmpcnt = optbl2->mo_count;
2016 tmplist = optbl2->mo_list;
2017 optbl2->mo_count = optbl1->mo_count;
2018 optbl2->mo_list = optbl1->mo_list;
2019 optbl1->mo_count = tmpcnt;
2020 optbl1->mo_list = tmplist;
2021 }
2022
2023 static void
2024 vfs_swapopttbl(mntopts_t *optbl1, mntopts_t *optbl2)
2025 {
2026 vfs_list_lock();
2027 vfs_swapopttbl_nolock(optbl1, optbl2);
2028 vfs_mnttab_modtimeupd();
2029 vfs_list_unlock();
2030 }
2031
2032 static char **
2033 vfs_copycancelopt_extend(char **const moc, int extend)
2034 {
2035 int i = 0;
2036 int j;
2037 char **result;
2038
2039 if (moc != NULL) {
2040 for (; moc[i] != NULL; i++)
2041 /* count number of options to cancel */;
2042 }
2043
2044 if (i + extend == 0)
2045 return (NULL);
2046
2047 result = kmem_alloc((i + extend + 1) * sizeof (char *), KM_SLEEP);
2048
2049 for (j = 0; j < i; j++) {
2050 result[j] = kmem_alloc(strlen(moc[j]) + 1, KM_SLEEP);
2051 (void) strcpy(result[j], moc[j]);
2052 }
2053 for (; j <= i + extend; j++)
2054 result[j] = NULL;
2055
2056 return (result);
2057 }
2058
2059 static void
2060 vfs_copyopt(const mntopt_t *s, mntopt_t *d)
2061 {
2062 char *sp, *dp;
2063
2064 d->mo_flags = s->mo_flags;
2065 d->mo_data = s->mo_data;
2066 sp = s->mo_name;
2067 if (sp != NULL) {
2068 dp = kmem_alloc(strlen(sp) + 1, KM_SLEEP);
2069 (void) strcpy(dp, sp);
2070 d->mo_name = dp;
2071 } else {
2072 d->mo_name = NULL; /* should never happen */
2073 }
2074
2075 d->mo_cancel = vfs_copycancelopt_extend(s->mo_cancel, 0);
2076
2077 sp = s->mo_arg;
2078 if (sp != NULL) {
2079 dp = kmem_alloc(strlen(sp) + 1, KM_SLEEP);
2080 (void) strcpy(dp, sp);
2081 d->mo_arg = dp;
2082 } else {
2083 d->mo_arg = NULL;
2084 }
2085 }
2086
2087 /*
2088 * Copy a mount options table, possibly allocating some spare
2089 * slots at the end. It is permissible to copy_extend the NULL table.
2090 */
2091 static void
2092 vfs_copyopttbl_extend(const mntopts_t *smo, mntopts_t *dmo, int extra)
2093 {
2094 uint_t i, count;
2095 mntopt_t *motbl;
2096
2097 /*
2098 * Clear out any existing stuff in the options table being initialized
2099 */
2100 vfs_freeopttbl(dmo);
2101 count = (smo == NULL) ? 0 : smo->mo_count;
2102 if ((count + extra) == 0) /* nothing to do */
2103 return;
2104 dmo->mo_count = count + extra;
2105 motbl = kmem_zalloc((count + extra) * sizeof (mntopt_t), KM_SLEEP);
2106 dmo->mo_list = motbl;
2107 for (i = 0; i < count; i++) {
2108 vfs_copyopt(&smo->mo_list[i], &motbl[i]);
2109 }
2110 for (i = count; i < count + extra; i++) {
2111 motbl[i].mo_flags = MO_EMPTY;
2112 }
2113 }
2114
2115 /*
2116 * Copy a mount options table.
2117 *
2118 * This function is *not* for general use by filesystems.
2119 *
2120 * Note: caller is responsible for locking the vfs list, if needed,
2121 * to protect smo and dmo.
2122 */
2123 void
2124 vfs_copyopttbl(const mntopts_t *smo, mntopts_t *dmo)
2125 {
2126 vfs_copyopttbl_extend(smo, dmo, 0);
2127 }
2128
2129 static char **
2130 vfs_mergecancelopts(const mntopt_t *mop1, const mntopt_t *mop2)
2131 {
2132 int c1 = 0;
2133 int c2 = 0;
2134 char **result;
2135 char **sp1, **sp2, **dp;
2136
2137 /*
2138 * First we count both lists of cancel options.
2139 * If either is NULL or has no elements, we return a copy of
2140 * the other.
2141 */
2142 if (mop1->mo_cancel != NULL) {
2143 for (; mop1->mo_cancel[c1] != NULL; c1++)
2144 /* count cancel options in mop1 */;
2145 }
2146
2147 if (c1 == 0)
2148 return (vfs_copycancelopt_extend(mop2->mo_cancel, 0));
2149
2150 if (mop2->mo_cancel != NULL) {
2151 for (; mop2->mo_cancel[c2] != NULL; c2++)
2152 /* count cancel options in mop2 */;
2153 }
2154
2155 result = vfs_copycancelopt_extend(mop1->mo_cancel, c2);
2156
2157 if (c2 == 0)
2158 return (result);
2159
2160 /*
2161 * When we get here, we've got two sets of cancel options;
2162 * we need to merge the two sets. We know that the result
2163 * array has "c1+c2+1" entries and in the end we might shrink
2164 * it.
2165 * Result now has a copy of the c1 entries from mop1; we'll
2166 * now lookup all the entries of mop2 in mop1 and copy it if
2167 * it is unique.
2168 * This operation is O(n^2) but it's only called once per
2169 * filesystem per duplicate option. This is a situation
2170 * which doesn't arise with the filesystems in ON and
2171 * n is generally 1.
2172 */
2173
2174 dp = &result[c1];
2175 for (sp2 = mop2->mo_cancel; *sp2 != NULL; sp2++) {
2176 for (sp1 = mop1->mo_cancel; *sp1 != NULL; sp1++) {
2177 if (strcmp(*sp1, *sp2) == 0)
2178 break;
2179 }
2180 if (*sp1 == NULL) {
2181 /*
2182 * Option *sp2 not found in mop1, so copy it.
2183 * The calls to vfs_copycancelopt_extend()
2184 * guarantee that there's enough room.
2185 */
2186 *dp = kmem_alloc(strlen(*sp2) + 1, KM_SLEEP);
2187 (void) strcpy(*dp++, *sp2);
2188 }
2189 }
2190 if (dp != &result[c1+c2]) {
2191 size_t bytes = (dp - result + 1) * sizeof (char *);
2192 char **nres = kmem_alloc(bytes, KM_SLEEP);
2193
2194 bcopy(result, nres, bytes);
2195 kmem_free(result, (c1 + c2 + 1) * sizeof (char *));
2196 result = nres;
2197 }
2198 return (result);
2199 }
2200
2201 /*
2202 * Merge two mount option tables (outer and inner) into one. This is very
2203 * similar to "merging" global variables and automatic variables in C.
2204 *
2205 * This isn't (and doesn't have to be) fast.
2206 *
2207 * This function is *not* for general use by filesystems.
2208 *
2209 * Note: caller is responsible for locking the vfs list, if needed,
2210 * to protect omo, imo & dmo.
2211 */
2212 void
2213 vfs_mergeopttbl(const mntopts_t *omo, const mntopts_t *imo, mntopts_t *dmo)
2214 {
2215 uint_t i, count;
2216 mntopt_t *mop, *motbl;
2217 uint_t freeidx;
2218
2219 /*
2220 * First determine how much space we need to allocate.
2221 */
2222 count = omo->mo_count;
2223 for (i = 0; i < imo->mo_count; i++) {
2224 if (imo->mo_list[i].mo_flags & MO_EMPTY)
2225 continue;
2226 if (vfs_hasopt(omo, imo->mo_list[i].mo_name) == NULL)
2227 count++;
2228 }
2229 ASSERT(count >= omo->mo_count &&
2230 count <= omo->mo_count + imo->mo_count);
2231 motbl = kmem_alloc(count * sizeof (mntopt_t), KM_SLEEP);
2232 for (i = 0; i < omo->mo_count; i++)
2233 vfs_copyopt(&omo->mo_list[i], &motbl[i]);
2234 freeidx = omo->mo_count;
2235 for (i = 0; i < imo->mo_count; i++) {
2236 if (imo->mo_list[i].mo_flags & MO_EMPTY)
2237 continue;
2238 if ((mop = vfs_hasopt(omo, imo->mo_list[i].mo_name)) != NULL) {
2239 char **newcanp;
2240 uint_t index = mop - omo->mo_list;
2241
2242 newcanp = vfs_mergecancelopts(mop, &motbl[index]);
2243
2244 vfs_freeopt(&motbl[index]);
2245 vfs_copyopt(&imo->mo_list[i], &motbl[index]);
2246
2247 vfs_freecancelopt(motbl[index].mo_cancel);
2248 motbl[index].mo_cancel = newcanp;
2249 } else {
2250 /*
2251 * If it's a new option, just copy it over to the first
2252 * free location.
2253 */
2254 vfs_copyopt(&imo->mo_list[i], &motbl[freeidx++]);
2255 }
2256 }
2257 dmo->mo_count = count;
2258 dmo->mo_list = motbl;
2259 }
2260
2261 /*
2262 * Functions to set and clear mount options in a mount options table.
2263 */
2264
2265 /*
2266 * Clear a mount option, if it exists.
2267 *
2268 * The update_mnttab arg indicates whether mops is part of a vfs that is on
2269 * the vfs list.
2270 */
2271 static void
2272 vfs_clearmntopt_nolock(mntopts_t *mops, const char *opt, int update_mnttab)
2273 {
2274 struct mntopt *mop;
2275 uint_t i, count;
2276
2277 ASSERT(!update_mnttab || RW_WRITE_HELD(&vfslist));
2278
2279 count = mops->mo_count;
2280 for (i = 0; i < count; i++) {
2281 mop = &mops->mo_list[i];
2282
2283 if (mop->mo_flags & MO_EMPTY)
2284 continue;
2285 if (strcmp(opt, mop->mo_name))
2286 continue;
2287 mop->mo_flags &= ~MO_SET;
2288 if (mop->mo_arg != NULL) {
2289 kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1);
2290 }
2291 mop->mo_arg = NULL;
2292 if (update_mnttab)
2293 vfs_mnttab_modtimeupd();
2294 break;
2295 }
2296 }
2297
2298 void
2299 vfs_clearmntopt(struct vfs *vfsp, const char *opt)
2300 {
2301 int gotlock = 0;
2302
2303 if (VFS_ON_LIST(vfsp)) {
2304 gotlock = 1;
2305 vfs_list_lock();
2306 }
2307 vfs_clearmntopt_nolock(&vfsp->vfs_mntopts, opt, gotlock);
2308 if (gotlock)
2309 vfs_list_unlock();
2310 }
2311
2312
2313 /*
2314 * Set a mount option on. If it's not found in the table, it's silently
2315 * ignored. If the option has MO_IGNORE set, it is still set unless the
2316 * VFS_NOFORCEOPT bit is set in the flags. Also, VFS_DISPLAY/VFS_NODISPLAY flag
2317 * bits can be used to toggle the MO_NODISPLAY bit for the option.
2318 * If the VFS_CREATEOPT flag bit is set then the first option slot with
2319 * MO_EMPTY set is created as the option passed in.
2320 *
2321 * The update_mnttab arg indicates whether mops is part of a vfs that is on
2322 * the vfs list.
2323 */
2324 static void
2325 vfs_setmntopt_nolock(mntopts_t *mops, const char *opt,
2326 const char *arg, int flags, int update_mnttab)
2327 {
2328 mntopt_t *mop;
2329 uint_t i, count;
2330 char *sp;
2331
2332 ASSERT(!update_mnttab || RW_WRITE_HELD(&vfslist));
2333
2334 if (flags & VFS_CREATEOPT) {
2335 if (vfs_hasopt(mops, opt) != NULL) {
2336 flags &= ~VFS_CREATEOPT;
2337 }
2338 }
2339 count = mops->mo_count;
2340 for (i = 0; i < count; i++) {
2341 mop = &mops->mo_list[i];
2342
2343 if (mop->mo_flags & MO_EMPTY) {
2344 if ((flags & VFS_CREATEOPT) == 0)
2345 continue;
2346 sp = kmem_alloc(strlen(opt) + 1, KM_SLEEP);
2347 (void) strcpy(sp, opt);
2348 mop->mo_name = sp;
2349 if (arg != NULL)
2350 mop->mo_flags = MO_HASVALUE;
2351 else
2352 mop->mo_flags = 0;
2353 } else if (strcmp(opt, mop->mo_name)) {
2354 continue;
2355 }
2356 if ((mop->mo_flags & MO_IGNORE) && (flags & VFS_NOFORCEOPT))
2357 break;
2358 if (arg != NULL && (mop->mo_flags & MO_HASVALUE) != 0) {
2359 sp = kmem_alloc(strlen(arg) + 1, KM_SLEEP);
2360 (void) strcpy(sp, arg);
2361 } else {
2362 sp = NULL;
2363 }
2364 if (mop->mo_arg != NULL)
2365 kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1);
2366 mop->mo_arg = sp;
2367 if (flags & VFS_DISPLAY)
2368 mop->mo_flags &= ~MO_NODISPLAY;
2369 if (flags & VFS_NODISPLAY)
2370 mop->mo_flags |= MO_NODISPLAY;
2371 mop->mo_flags |= MO_SET;
2372 if (mop->mo_cancel != NULL) {
2373 char **cp;
2374
2375 for (cp = mop->mo_cancel; *cp != NULL; cp++)
2376 vfs_clearmntopt_nolock(mops, *cp, 0);
2377 }
2378 if (update_mnttab)
2379 vfs_mnttab_modtimeupd();
2380 break;
2381 }
2382 }
2383
2384 void
2385 vfs_setmntopt(struct vfs *vfsp, const char *opt, const char *arg, int flags)
2386 {
2387 int gotlock = 0;
2388
2389 if (VFS_ON_LIST(vfsp)) {
2390 gotlock = 1;
2391 vfs_list_lock();
2392 }
2393 vfs_setmntopt_nolock(&vfsp->vfs_mntopts, opt, arg, flags, gotlock);
2394 if (gotlock)
2395 vfs_list_unlock();
2396 }
2397
2398
2399 /*
2400 * Add a "tag" option to a mounted file system's options list.
2401 *
2402 * Note: caller is responsible for locking the vfs list, if needed,
2403 * to protect mops.
2404 */
2405 static mntopt_t *
2406 vfs_addtag(mntopts_t *mops, const char *tag)
2407 {
2408 uint_t count;
2409 mntopt_t *mop, *motbl;
2410
2411 count = mops->mo_count + 1;
2412 motbl = kmem_zalloc(count * sizeof (mntopt_t), KM_SLEEP);
2413 if (mops->mo_count) {
2414 size_t len = (count - 1) * sizeof (mntopt_t);
2415
2416 bcopy(mops->mo_list, motbl, len);
2417 kmem_free(mops->mo_list, len);
2418 }
2419 mops->mo_count = count;
2420 mops->mo_list = motbl;
2421 mop = &motbl[count - 1];
2422 mop->mo_flags = MO_TAG;
2423 mop->mo_name = kmem_alloc(strlen(tag) + 1, KM_SLEEP);
2424 (void) strcpy(mop->mo_name, tag);
2425 return (mop);
2426 }
2427
2428 /*
2429 * Allow users to set arbitrary "tags" in a vfs's mount options.
2430 * Broader use within the kernel is discouraged.
2431 */
2432 int
2433 vfs_settag(uint_t major, uint_t minor, const char *mntpt, const char *tag,
2434 cred_t *cr)
2435 {
2436 vfs_t *vfsp;
2437 mntopts_t *mops;
2438 mntopt_t *mop;
2439 int found = 0;
2440 dev_t dev = makedevice(major, minor);
2441 int err = 0;
2442 char *buf = kmem_alloc(MAX_MNTOPT_STR, KM_SLEEP);
2443
2444 /*
2445 * Find the desired mounted file system
2446 */
2447 vfs_list_lock();
2448 vfsp = rootvfs;
2449 do {
2450 if (vfsp->vfs_dev == dev &&
2451 strcmp(mntpt, refstr_value(vfsp->vfs_mntpt)) == 0) {
2452 found = 1;
2453 break;
2454 }
2455 vfsp = vfsp->vfs_next;
2456 } while (vfsp != rootvfs);
2457
2458 if (!found) {
2459 err = EINVAL;
2460 goto out;
2461 }
2462 err = secpolicy_fs_config(cr, vfsp);
2463 if (err != 0)
2464 goto out;
2465
2466 mops = &vfsp->vfs_mntopts;
2467 /*
2468 * Add tag if it doesn't already exist
2469 */
2470 if ((mop = vfs_hasopt(mops, tag)) == NULL) {
2471 int len;
2472
2473 (void) vfs_buildoptionstr(mops, buf, MAX_MNTOPT_STR);
2474 len = strlen(buf);
2475 if (len + strlen(tag) + 2 > MAX_MNTOPT_STR) {
2476 err = ENAMETOOLONG;
2477 goto out;
2478 }
2479 mop = vfs_addtag(mops, tag);
2480 }
2481 if ((mop->mo_flags & MO_TAG) == 0) {
2482 err = EINVAL;
2483 goto out;
2484 }
2485 vfs_setmntopt_nolock(mops, tag, NULL, 0, 1);
2486 out:
2487 vfs_list_unlock();
2488 kmem_free(buf, MAX_MNTOPT_STR);
2489 return (err);
2490 }
2491
2492 /*
2493 * Allow users to remove arbitrary "tags" in a vfs's mount options.
2494 * Broader use within the kernel is discouraged.
2495 */
2496 int
2497 vfs_clrtag(uint_t major, uint_t minor, const char *mntpt, const char *tag,
2498 cred_t *cr)
2499 {
2500 vfs_t *vfsp;
2501 mntopt_t *mop;
2502 int found = 0;
2503 dev_t dev = makedevice(major, minor);
2504 int err = 0;
2505
2506 /*
2507 * Find the desired mounted file system
2508 */
2509 vfs_list_lock();
2510 vfsp = rootvfs;
2511 do {
2512 if (vfsp->vfs_dev == dev &&
2513 strcmp(mntpt, refstr_value(vfsp->vfs_mntpt)) == 0) {
2514 found = 1;
2515 break;
2516 }
2517 vfsp = vfsp->vfs_next;
2518 } while (vfsp != rootvfs);
2519
2520 if (!found) {
2521 err = EINVAL;
2522 goto out;
2523 }
2524 err = secpolicy_fs_config(cr, vfsp);
2525 if (err != 0)
2526 goto out;
2527
2528 if ((mop = vfs_hasopt(&vfsp->vfs_mntopts, tag)) == NULL) {
2529 err = EINVAL;
2530 goto out;
2531 }
2532 if ((mop->mo_flags & MO_TAG) == 0) {
2533 err = EINVAL;
2534 goto out;
2535 }
2536 vfs_clearmntopt_nolock(&vfsp->vfs_mntopts, tag, 1);
2537 out:
2538 vfs_list_unlock();
2539 return (err);
2540 }
2541
2542 /*
2543 * Function to parse an option string and fill in a mount options table.
2544 * Unknown options are silently ignored. The input option string is modified
2545 * by replacing separators with nulls. If the create flag is set, options
2546 * not found in the table are just added on the fly. The table must have
2547 * an option slot marked MO_EMPTY to add an option on the fly.
2548 *
2549 * This function is *not* for general use by filesystems.
2550 *
2551 * Note: caller is responsible for locking the vfs list, if needed,
2552 * to protect mops..
2553 */
2554 void
2555 vfs_parsemntopts(mntopts_t *mops, char *osp, int create)
2556 {
2557 char *s = osp, *p, *nextop, *valp, *cp, *ep;
2558 int setflg = VFS_NOFORCEOPT;
2559
2560 if (osp == NULL)
2561 return;
2562 while (*s != '\0') {
2563 p = strchr(s, ','); /* find next option */
2564 if (p == NULL) {
2565 cp = NULL;
2566 p = s + strlen(s);
2567 } else {
2568 cp = p; /* save location of comma */
2569 *p++ = '\0'; /* mark end and point to next option */
2570 }
2571 nextop = p;
2572 p = strchr(s, '='); /* look for value */
2573 if (p == NULL) {
2574 valp = NULL; /* no value supplied */
2575 } else {
2576 ep = p; /* save location of equals */
2577 *p++ = '\0'; /* end option and point to value */
2578 valp = p;
2579 }
2580 /*
2581 * set option into options table
2582 */
2583 if (create)
2584 setflg |= VFS_CREATEOPT;
2585 vfs_setmntopt_nolock(mops, s, valp, setflg, 0);
2586 if (cp != NULL)
2587 *cp = ','; /* restore the comma */
2588 if (valp != NULL)
2589 *ep = '='; /* restore the equals */
2590 s = nextop;
2591 }
2592 }
2593
2594 /*
2595 * Function to inquire if an option exists in a mount options table.
2596 * Returns a pointer to the option if it exists, else NULL.
2597 *
2598 * This function is *not* for general use by filesystems.
2599 *
2600 * Note: caller is responsible for locking the vfs list, if needed,
2601 * to protect mops.
2602 */
2603 struct mntopt *
2604 vfs_hasopt(const mntopts_t *mops, const char *opt)
2605 {
2606 struct mntopt *mop;
2607 uint_t i, count;
2608
2609 count = mops->mo_count;
2610 for (i = 0; i < count; i++) {
2611 mop = &mops->mo_list[i];
2612
2613 if (mop->mo_flags & MO_EMPTY)
2614 continue;
2615 if (strcmp(opt, mop->mo_name) == 0)
2616 return (mop);
2617 }
2618 return (NULL);
2619 }
2620
2621 /*
2622 * Function to inquire if an option is set in a mount options table.
2623 * Returns non-zero if set and fills in the arg pointer with a pointer to
2624 * the argument string or NULL if there is no argument string.
2625 */
2626 static int
2627 vfs_optionisset_nolock(const mntopts_t *mops, const char *opt, char **argp)
2628 {
2629 struct mntopt *mop;
2630 uint_t i, count;
2631
2632 count = mops->mo_count;
2633 for (i = 0; i < count; i++) {
2634 mop = &mops->mo_list[i];
2635
2636 if (mop->mo_flags & MO_EMPTY)
2637 continue;
2638 if (strcmp(opt, mop->mo_name))
2639 continue;
2640 if ((mop->mo_flags & MO_SET) == 0)
2641 return (0);
2642 if (argp != NULL && (mop->mo_flags & MO_HASVALUE) != 0)
2643 *argp = mop->mo_arg;
2644 return (1);
2645 }
2646 return (0);
2647 }
2648
2649
2650 int
2651 vfs_optionisset(const struct vfs *vfsp, const char *opt, char **argp)
2652 {
2653 int ret;
2654
2655 vfs_list_read_lock();
2656 ret = vfs_optionisset_nolock(&vfsp->vfs_mntopts, opt, argp);
2657 vfs_list_unlock();
2658 return (ret);
2659 }
2660
2661
2662 /*
2663 * Construct a comma separated string of the options set in the given
2664 * mount table, return the string in the given buffer. Return non-zero if
2665 * the buffer would overflow.
2666 *
2667 * This function is *not* for general use by filesystems.
2668 *
2669 * Note: caller is responsible for locking the vfs list, if needed,
2670 * to protect mp.
2671 */
2672 int
2673 vfs_buildoptionstr(const mntopts_t *mp, char *buf, int len)
2674 {
2675 char *cp;
2676 uint_t i;
2677
2678 buf[0] = '\0';
2679 cp = buf;
2680 for (i = 0; i < mp->mo_count; i++) {
2681 struct mntopt *mop;
2682
2683 mop = &mp->mo_list[i];
2684 if (mop->mo_flags & MO_SET) {
2685 int optlen, comma = 0;
2686
2687 if (buf[0] != '\0')
2688 comma = 1;
2689 optlen = strlen(mop->mo_name);
2690 if (strlen(buf) + comma + optlen + 1 > len)
2691 goto err;
2692 if (comma)
2693 *cp++ = ',';
2694 (void) strcpy(cp, mop->mo_name);
2695 cp += optlen;
2696 /*
2697 * Append option value if there is one
2698 */
2699 if (mop->mo_arg != NULL) {
2700 int arglen;
2701
2702 arglen = strlen(mop->mo_arg);
2703 if (strlen(buf) + arglen + 2 > len)
2704 goto err;
2705 *cp++ = '=';
2706 (void) strcpy(cp, mop->mo_arg);
2707 cp += arglen;
2708 }
2709 }
2710 }
2711 return (0);
2712 err:
2713 return (EOVERFLOW);
2714 }
2715
2716 static void
2717 vfs_freecancelopt(char **moc)
2718 {
2719 if (moc != NULL) {
2720 int ccnt = 0;
2721 char **cp;
2722
2723 for (cp = moc; *cp != NULL; cp++) {
2724 kmem_free(*cp, strlen(*cp) + 1);
2725 ccnt++;
2726 }
2727 kmem_free(moc, (ccnt + 1) * sizeof (char *));
2728 }
2729 }
2730
2731 static void
2732 vfs_freeopt(mntopt_t *mop)
2733 {
2734 if (mop->mo_name != NULL)
2735 kmem_free(mop->mo_name, strlen(mop->mo_name) + 1);
2736
2737 vfs_freecancelopt(mop->mo_cancel);
2738
2739 if (mop->mo_arg != NULL)
2740 kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1);
2741 }
2742
2743 /*
2744 * Free a mount options table
2745 *
2746 * This function is *not* for general use by filesystems.
2747 *
2748 * Note: caller is responsible for locking the vfs list, if needed,
2749 * to protect mp.
2750 */
2751 void
2752 vfs_freeopttbl(mntopts_t *mp)
2753 {
2754 uint_t i, count;
2755
2756 count = mp->mo_count;
2757 for (i = 0; i < count; i++) {
2758 vfs_freeopt(&mp->mo_list[i]);
2759 }
2760 if (count) {
2761 kmem_free(mp->mo_list, sizeof (mntopt_t) * count);
2762 mp->mo_count = 0;
2763 mp->mo_list = NULL;
2764 }
2765 }
2766
2767
2768 /* ARGSUSED */
2769 static int
2770 vfs_mntdummyread(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cred,
2771 caller_context_t *ct)
2772 {
2773 return (0);
2774 }
2775
2776 /* ARGSUSED */
2777 static int
2778 vfs_mntdummywrite(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cred,
2779 caller_context_t *ct)
2780 {
2781 return (0);
2782 }
2783
2784 /*
2785 * The dummy vnode is currently used only by file events notification
2786 * module which is just interested in the timestamps.
2787 */
2788 /* ARGSUSED */
2789 static int
2790 vfs_mntdummygetattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
2791 caller_context_t *ct)
2792 {
2793 bzero(vap, sizeof (vattr_t));
2794 vap->va_type = VREG;
2795 vap->va_nlink = 1;
2796 vap->va_ctime = vfs_mnttab_ctime;
2797 /*
2798 * it is ok to just copy mtime as the time will be monotonically
2799 * increasing.
2800 */
2801 vap->va_mtime = vfs_mnttab_mtime;
2802 vap->va_atime = vap->va_mtime;
2803 return (0);
2804 }
2805
2806 static void
2807 vfs_mnttabvp_setup(void)
2808 {
2809 vnode_t *tvp;
2810 vnodeops_t *vfs_mntdummyvnops;
2811 const fs_operation_def_t mnt_dummyvnodeops_template[] = {
2812 VOPNAME_READ, { .vop_read = vfs_mntdummyread },
2813 VOPNAME_WRITE, { .vop_write = vfs_mntdummywrite },
2814 VOPNAME_GETATTR, { .vop_getattr = vfs_mntdummygetattr },
2815 VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support },
2816 NULL, NULL
2817 };
2818
2819 if (vn_make_ops("mnttab", mnt_dummyvnodeops_template,
2820 &vfs_mntdummyvnops) != 0) {
2821 cmn_err(CE_WARN, "vfs_mnttabvp_setup: vn_make_ops failed");
2822 /* Shouldn't happen, but not bad enough to panic */
2823 return;
2824 }
2825
2826 /*
2827 * A global dummy vnode is allocated to represent mntfs files.
2828 * The mntfs file (/etc/mnttab) can be monitored for file events
2829 * and receive an event when mnttab changes. Dummy VOP calls
2830 * will be made on this vnode. The file events notification module
2831 * intercepts this vnode and delivers relevant events.
2832 */
2833 tvp = vn_alloc(KM_SLEEP);
2834 tvp->v_flag = VNOMOUNT|VNOMAP|VNOSWAP|VNOCACHE;
2835 vn_setops(tvp, vfs_mntdummyvnops);
2836 tvp->v_type = VREG;
2837 /*
2838 * The mnt dummy ops do not reference v_data.
2839 * No other module intercepting this vnode should either.
2840 * Just set it to point to itself.
2841 */
2842 tvp->v_data = (caddr_t)tvp;
2843 tvp->v_vfsp = rootvfs;
2844 vfs_mntdummyvp = tvp;
2845 }
2846
2847 /*
2848 * performs fake read/write ops
2849 */
2850 static void
2851 vfs_mnttab_rwop(int rw)
2852 {
2853 struct uio uio;
2854 struct iovec iov;
2855 char buf[1];
2856
2857 if (vfs_mntdummyvp == NULL)
2858 return;
2859
2860 bzero(&uio, sizeof (uio));
2861 bzero(&iov, sizeof (iov));
2862 iov.iov_base = buf;
2863 iov.iov_len = 0;
2864 uio.uio_iov = &iov;
2865 uio.uio_iovcnt = 1;
2866 uio.uio_loffset = 0;
2867 uio.uio_segflg = UIO_SYSSPACE;
2868 uio.uio_resid = 0;
2869 if (rw) {
2870 (void) VOP_WRITE(vfs_mntdummyvp, &uio, 0, kcred, NULL);
2871 } else {
2872 (void) VOP_READ(vfs_mntdummyvp, &uio, 0, kcred, NULL);
2873 }
2874 }
2875
2876 /*
2877 * Generate a write operation.
2878 */
2879 void
2880 vfs_mnttab_writeop(void)
2881 {
2882 vfs_mnttab_rwop(1);
2883 }
2884
2885 /*
2886 * Generate a read operation.
2887 */
2888 void
2889 vfs_mnttab_readop(void)
2890 {
2891 vfs_mnttab_rwop(0);
2892 }
2893
2894 /*
2895 * Free any mnttab information recorded in the vfs struct.
2896 * The vfs must not be on the vfs list.
2897 */
2898 static void
2899 vfs_freemnttab(struct vfs *vfsp)
2900 {
2901 ASSERT(!VFS_ON_LIST(vfsp));
2902
2903 /*
2904 * Free device and mount point information
2905 */
2906 if (vfsp->vfs_mntpt != NULL) {
2907 refstr_rele(vfsp->vfs_mntpt);
2908 vfsp->vfs_mntpt = NULL;
2909 }
2910 if (vfsp->vfs_resource != NULL) {
2911 refstr_rele(vfsp->vfs_resource);
2912 vfsp->vfs_resource = NULL;
2913 }
2914 /*
2915 * Now free mount options information
2916 */
2917 vfs_freeopttbl(&vfsp->vfs_mntopts);
2918 }
2919
2920 /*
2921 * Return the last mnttab modification time
2922 */
2923 void
2924 vfs_mnttab_modtime(timespec_t *ts)
2925 {
2926 ASSERT(RW_LOCK_HELD(&vfslist));
2927 *ts = vfs_mnttab_mtime;
2928 }
2929
2930 /*
2931 * See if mnttab is changed
2932 */
2933 void
2934 vfs_mnttab_poll(timespec_t *old, struct pollhead **phpp)
2935 {
2936 int changed;
2937
2938 *phpp = (struct pollhead *)NULL;
2939
2940 /*
2941 * Note: don't grab vfs list lock before accessing vfs_mnttab_mtime.
2942 * Can lead to deadlock against vfs_mnttab_modtimeupd(). It is safe
2943 * to not grab the vfs list lock because tv_sec is monotonically
2944 * increasing.
2945 */
2946
2947 changed = (old->tv_nsec != vfs_mnttab_mtime.tv_nsec) ||
2948 (old->tv_sec != vfs_mnttab_mtime.tv_sec);
2949 if (!changed) {
2950 *phpp = &vfs_pollhd;
2951 }
2952 }
2953
2954 /* Provide a unique and monotonically-increasing timestamp. */
2955 void
2956 vfs_mono_time(timespec_t *ts)
2957 {
2958 static volatile hrtime_t hrt; /* The saved time. */
2959 hrtime_t newhrt, oldhrt; /* For effecting the CAS. */
2960 timespec_t newts;
2961
2962 /*
2963 * Try gethrestime() first, but be prepared to fabricate a sensible
2964 * answer at the first sign of any trouble.
2965 */
2966 gethrestime(&newts);
2967 newhrt = ts2hrt(&newts);
2968 for (;;) {
2969 oldhrt = hrt;
2970 if (newhrt <= hrt)
2971 newhrt = hrt + 1;
2972 if (cas64((uint64_t *)&hrt, oldhrt, newhrt) == oldhrt)
2973 break;
2974 }
2975 hrt2ts(newhrt, ts);
2976 }
2977
2978 /*
2979 * Update the mnttab modification time and wake up any waiters for
2980 * mnttab changes
2981 */
2982 void
2983 vfs_mnttab_modtimeupd()
2984 {
2985 hrtime_t oldhrt, newhrt;
2986
2987 ASSERT(RW_WRITE_HELD(&vfslist));
2988 oldhrt = ts2hrt(&vfs_mnttab_mtime);
2989 gethrestime(&vfs_mnttab_mtime);
2990 newhrt = ts2hrt(&vfs_mnttab_mtime);
2991 if (oldhrt == (hrtime_t)0)
2992 vfs_mnttab_ctime = vfs_mnttab_mtime;
2993 /*
2994 * Attempt to provide unique mtime (like uniqtime but not).
2995 */
2996 if (newhrt == oldhrt) {
2997 newhrt++;
2998 hrt2ts(newhrt, &vfs_mnttab_mtime);
2999 }
3000 pollwakeup(&vfs_pollhd, (short)POLLRDBAND);
3001 vfs_mnttab_writeop();
3002 }
3003
3004 int
3005 dounmount(struct vfs *vfsp, int flag, cred_t *cr)
3006 {
3007 vnode_t *coveredvp;
3008 int error;
3009 extern void teardown_vopstats(vfs_t *);
3010
3011 /*
3012 * Get covered vnode. This will be NULL if the vfs is not linked
3013 * into the file system name space (i.e., domount() with MNT_NOSPICE).
3014 */
3015 coveredvp = vfsp->vfs_vnodecovered;
3016 ASSERT(coveredvp == NULL || vn_vfswlock_held(coveredvp));
3017
3018 /*
3019 * Purge all dnlc entries for this vfs.
3020 */
3021 (void) dnlc_purge_vfsp(vfsp, 0);
3022
3023 /* For forcible umount, skip VFS_SYNC() since it may hang */
3024 if ((flag & MS_FORCE) == 0)
3025 (void) VFS_SYNC(vfsp, 0, cr);
3026
3027 /*
3028 * Lock the vfs to maintain fs status quo during unmount. This
3029 * has to be done after the sync because ufs_update tries to acquire
3030 * the vfs_reflock.
3031 */
3032 vfs_lock_wait(vfsp);
3033
3034 if (error = VFS_UNMOUNT(vfsp, flag, cr)) {
3035 vfs_unlock(vfsp);
3036 if (coveredvp != NULL)
3037 vn_vfsunlock(coveredvp);
3038 } else if (coveredvp != NULL) {
3039 teardown_vopstats(vfsp);
3040 /*
3041 * vfs_remove() will do a VN_RELE(vfsp->vfs_vnodecovered)
3042 * when it frees vfsp so we do a VN_HOLD() so we can
3043 * continue to use coveredvp afterwards.
3044 */
3045 VN_HOLD(coveredvp);
3046 vfs_remove(vfsp);
3047 vn_vfsunlock(coveredvp);
3048 VN_RELE(coveredvp);
3049 } else {
3050 teardown_vopstats(vfsp);
3051 /*
3052 * Release the reference to vfs that is not linked
3053 * into the name space.
3054 */
3055 vfs_unlock(vfsp);
3056 VFS_RELE(vfsp);
3057 }
3058 return (error);
3059 }
3060
3061
3062 /*
3063 * Vfs_unmountall() is called by uadmin() to unmount all
3064 * mounted file systems (except the root file system) during shutdown.
3065 * It follows the existing locking protocol when traversing the vfs list
3066 * to sync and unmount vfses. Even though there should be no
3067 * other thread running while the system is shutting down, it is prudent
3068 * to still follow the locking protocol.
3069 */
3070 void
3071 vfs_unmountall(void)
3072 {
3073 struct vfs *vfsp;
3074 struct vfs *prev_vfsp = NULL;
3075 int error;
3076
3077 /*
3078 * Toss all dnlc entries now so that the per-vfs sync
3079 * and unmount operations don't have to slog through
3080 * a bunch of uninteresting vnodes over and over again.
3081 */
3082 dnlc_purge();
3083
3084 vfs_list_lock();
3085 for (vfsp = rootvfs->vfs_prev; vfsp != rootvfs; vfsp = prev_vfsp) {
3086 prev_vfsp = vfsp->vfs_prev;
3087
3088 if (vfs_lock(vfsp) != 0)
3089 continue;
3090 error = vn_vfswlock(vfsp->vfs_vnodecovered);
3091 vfs_unlock(vfsp);
3092 if (error)
3093 continue;
3094
3095 vfs_list_unlock();
3096
3097 (void) VFS_SYNC(vfsp, SYNC_CLOSE, CRED());
3098 (void) dounmount(vfsp, 0, CRED());
3099
3100 /*
3101 * Since we dropped the vfslist lock above we must
3102 * verify that next_vfsp still exists, else start over.
3103 */
3104 vfs_list_lock();
3105 for (vfsp = rootvfs->vfs_prev;
3106 vfsp != rootvfs; vfsp = vfsp->vfs_prev)
3107 if (vfsp == prev_vfsp)
3108 break;
3109 if (vfsp == rootvfs && prev_vfsp != rootvfs)
3110 prev_vfsp = rootvfs->vfs_prev;
3111 }
3112 vfs_list_unlock();
3113 }
3114
3115 /*
3116 * Called to add an entry to the end of the vfs mount in progress list
3117 */
3118 void
3119 vfs_addmip(dev_t dev, struct vfs *vfsp)
3120 {
3121 struct ipmnt *mipp;
3122
3123 mipp = (struct ipmnt *)kmem_alloc(sizeof (struct ipmnt), KM_SLEEP);
3124 mipp->mip_next = NULL;
3125 mipp->mip_dev = dev;
3126 mipp->mip_vfsp = vfsp;
3127 mutex_enter(&vfs_miplist_mutex);
3128 if (vfs_miplist_end != NULL)
3129 vfs_miplist_end->mip_next = mipp;
3130 else
3131 vfs_miplist = mipp;
3132 vfs_miplist_end = mipp;
3133 mutex_exit(&vfs_miplist_mutex);
3134 }
3135
3136 /*
3137 * Called to remove an entry from the mount in progress list
3138 * Either because the mount completed or it failed.
3139 */
3140 void
3141 vfs_delmip(struct vfs *vfsp)
3142 {
3143 struct ipmnt *mipp, *mipprev;
3144
3145 mutex_enter(&vfs_miplist_mutex);
3146 mipprev = NULL;
3147 for (mipp = vfs_miplist;
3148 mipp && mipp->mip_vfsp != vfsp; mipp = mipp->mip_next) {
3149 mipprev = mipp;
3150 }
3151 if (mipp == NULL)
3152 return; /* shouldn't happen */
3153 if (mipp == vfs_miplist_end)
3154 vfs_miplist_end = mipprev;
3155 if (mipprev == NULL)
3156 vfs_miplist = mipp->mip_next;
3157 else
3158 mipprev->mip_next = mipp->mip_next;
3159 mutex_exit(&vfs_miplist_mutex);
3160 kmem_free(mipp, sizeof (struct ipmnt));
3161 }
3162
3163 /*
3164 * vfs_add is called by a specific filesystem's mount routine to add
3165 * the new vfs into the vfs list/hash and to cover the mounted-on vnode.
3166 * The vfs should already have been locked by the caller.
3167 *
3168 * coveredvp is NULL if this is the root.
3169 */
3170 void
3171 vfs_add(vnode_t *coveredvp, struct vfs *vfsp, int mflag)
3172 {
3173 int newflag;
3174
3175 ASSERT(vfs_lock_held(vfsp));
3176 VFS_HOLD(vfsp);
3177 newflag = vfsp->vfs_flag;
3178 if (mflag & MS_RDONLY)
3179 newflag |= VFS_RDONLY;
3180 else
3181 newflag &= ~VFS_RDONLY;
3182 if (mflag & MS_NOSUID)
3183 newflag |= (VFS_NOSETUID|VFS_NODEVICES);
3184 else
3185 newflag &= ~(VFS_NOSETUID|VFS_NODEVICES);
3186 if (mflag & MS_NOMNTTAB)
3187 newflag |= VFS_NOMNTTAB;
3188 else
3189 newflag &= ~VFS_NOMNTTAB;
3190
3191 if (coveredvp != NULL) {
3192 ASSERT(vn_vfswlock_held(coveredvp));
3193 coveredvp->v_vfsmountedhere = vfsp;
3194 VN_HOLD(coveredvp);
3195 }
3196 vfsp->vfs_vnodecovered = coveredvp;
3197 vfsp->vfs_flag = newflag;
3198
3199 vfs_list_add(vfsp);
3200 }
3201
3202 /*
3203 * Remove a vfs from the vfs list, null out the pointer from the
3204 * covered vnode to the vfs (v_vfsmountedhere), and null out the pointer
3205 * from the vfs to the covered vnode (vfs_vnodecovered). Release the
3206 * reference to the vfs and to the covered vnode.
3207 *
3208 * Called from dounmount after it's confirmed with the file system
3209 * that the unmount is legal.
3210 */
3211 void
3212 vfs_remove(struct vfs *vfsp)
3213 {
3214 vnode_t *vp;
3215
3216 ASSERT(vfs_lock_held(vfsp));
3217
3218 /*
3219 * Can't unmount root. Should never happen because fs will
3220 * be busy.
3221 */
3222 if (vfsp == rootvfs)
3223 panic("vfs_remove: unmounting root");
3224
3225 vfs_list_remove(vfsp);
3226
3227 /*
3228 * Unhook from the file system name space.
3229 */
3230 vp = vfsp->vfs_vnodecovered;
3231 ASSERT(vn_vfswlock_held(vp));
3232 vp->v_vfsmountedhere = NULL;
3233 vfsp->vfs_vnodecovered = NULL;
3234 VN_RELE(vp);
3235
3236 /*
3237 * Release lock and wakeup anybody waiting.
3238 */
3239 vfs_unlock(vfsp);
3240 VFS_RELE(vfsp);
3241 }
3242
3243 /*
3244 * Lock a filesystem to prevent access to it while mounting,
3245 * unmounting and syncing. Return EBUSY immediately if lock
3246 * can't be acquired.
3247 */
3248 int
3249 vfs_lock(vfs_t *vfsp)
3250 {
3251 vn_vfslocks_entry_t *vpvfsentry;
3252
3253 vpvfsentry = vn_vfslocks_getlock(vfsp);
3254 if (rwst_tryenter(&vpvfsentry->ve_lock, RW_WRITER))
3255 return (0);
3256
3257 vn_vfslocks_rele(vpvfsentry);
3258 return (EBUSY);
3259 }
3260
3261 int
3262 vfs_rlock(vfs_t *vfsp)
3263 {
3264 vn_vfslocks_entry_t *vpvfsentry;
3265
3266 vpvfsentry = vn_vfslocks_getlock(vfsp);
3267
3268 if (rwst_tryenter(&vpvfsentry->ve_lock, RW_READER))
3269 return (0);
3270
3271 vn_vfslocks_rele(vpvfsentry);
3272 return (EBUSY);
3273 }
3274
3275 void
3276 vfs_lock_wait(vfs_t *vfsp)
3277 {
3278 vn_vfslocks_entry_t *vpvfsentry;
3279
3280 vpvfsentry = vn_vfslocks_getlock(vfsp);
3281 rwst_enter(&vpvfsentry->ve_lock, RW_WRITER);
3282 }
3283
3284 void
3285 vfs_rlock_wait(vfs_t *vfsp)
3286 {
3287 vn_vfslocks_entry_t *vpvfsentry;
3288
3289 vpvfsentry = vn_vfslocks_getlock(vfsp);
3290 rwst_enter(&vpvfsentry->ve_lock, RW_READER);
3291 }
3292
3293 /*
3294 * Unlock a locked filesystem.
3295 */
3296 void
3297 vfs_unlock(vfs_t *vfsp)
3298 {
3299 vn_vfslocks_entry_t *vpvfsentry;
3300
3301 /*
3302 * vfs_unlock will mimic sema_v behaviour to fix 4748018.
3303 * And these changes should remain for the patch changes as it is.
3304 */
3305 if (panicstr)
3306 return;
3307
3308 /*
3309 * ve_refcount needs to be dropped twice here.
3310 * 1. To release refernce after a call to vfs_locks_getlock()
3311 * 2. To release the reference from the locking routines like
3312 * vfs_rlock_wait/vfs_wlock_wait/vfs_wlock etc,.
3313 */
3314
3315 vpvfsentry = vn_vfslocks_getlock(vfsp);
3316 vn_vfslocks_rele(vpvfsentry);
3317
3318 rwst_exit(&vpvfsentry->ve_lock);
3319 vn_vfslocks_rele(vpvfsentry);
3320 }
3321
3322 /*
3323 * Utility routine that allows a filesystem to construct its
3324 * fsid in "the usual way" - by munging some underlying dev_t and
3325 * the filesystem type number into the 64-bit fsid. Note that
3326 * this implicitly relies on dev_t persistence to make filesystem
3327 * id's persistent.
3328 *
3329 * There's nothing to prevent an individual fs from constructing its
3330 * fsid in a different way, and indeed they should.
3331 *
3332 * Since we want fsids to be 32-bit quantities (so that they can be
3333 * exported identically by either 32-bit or 64-bit APIs, as well as
3334 * the fact that fsid's are "known" to NFS), we compress the device
3335 * number given down to 32-bits, and panic if that isn't possible.
3336 */
3337 void
3338 vfs_make_fsid(fsid_t *fsi, dev_t dev, int val)
3339 {
3340 if (!cmpldev((dev32_t *)&fsi->val[0], dev))
3341 panic("device number too big for fsid!");
3342 fsi->val[1] = val;
3343 }
3344
3345 int
3346 vfs_lock_held(vfs_t *vfsp)
3347 {
3348 int held;
3349 vn_vfslocks_entry_t *vpvfsentry;
3350
3351 /*
3352 * vfs_lock_held will mimic sema_held behaviour
3353 * if panicstr is set. And these changes should remain
3354 * for the patch changes as it is.
3355 */
3356 if (panicstr)
3357 return (1);
3358
3359 vpvfsentry = vn_vfslocks_getlock(vfsp);
3360 held = rwst_lock_held(&vpvfsentry->ve_lock, RW_WRITER);
3361
3362 vn_vfslocks_rele(vpvfsentry);
3363 return (held);
3364 }
3365
3366 struct _kthread *
3367 vfs_lock_owner(vfs_t *vfsp)
3368 {
3369 struct _kthread *owner;
3370 vn_vfslocks_entry_t *vpvfsentry;
3371
3372 /*
3373 * vfs_wlock_held will mimic sema_held behaviour
3374 * if panicstr is set. And these changes should remain
3375 * for the patch changes as it is.
3376 */
3377 if (panicstr)
3378 return (NULL);
3379
3380 vpvfsentry = vn_vfslocks_getlock(vfsp);
3381 owner = rwst_owner(&vpvfsentry->ve_lock);
3382
3383 vn_vfslocks_rele(vpvfsentry);
3384 return (owner);
3385 }
3386
3387 /*
3388 * vfs list locking.
3389 *
3390 * Rather than manipulate the vfslist lock directly, we abstract into lock
3391 * and unlock routines to allow the locking implementation to be changed for
3392 * clustering.
3393 *
3394 * Whenever the vfs list is modified through its hash links, the overall list
3395 * lock must be obtained before locking the relevant hash bucket. But to see
3396 * whether a given vfs is on the list, it suffices to obtain the lock for the
3397 * hash bucket without getting the overall list lock. (See getvfs() below.)
3398 */
3399
3400 void
3401 vfs_list_lock()
3402 {
3403 rw_enter(&vfslist, RW_WRITER);
3404 }
3405
3406 void
3407 vfs_list_read_lock()
3408 {
3409 rw_enter(&vfslist, RW_READER);
3410 }
3411
3412 void
3413 vfs_list_unlock()
3414 {
3415 rw_exit(&vfslist);
3416 }
3417
3418 /*
3419 * Low level worker routines for adding entries to and removing entries from
3420 * the vfs list.
3421 */
3422
3423 static void
3424 vfs_hash_add(struct vfs *vfsp, int insert_at_head)
3425 {
3426 int vhno;
3427 struct vfs **hp;
3428 dev_t dev;
3429
3430 ASSERT(RW_WRITE_HELD(&vfslist));
3431
3432 dev = expldev(vfsp->vfs_fsid.val[0]);
3433 vhno = VFSHASH(getmajor(dev), getminor(dev));
3434
3435 mutex_enter(&rvfs_list[vhno].rvfs_lock);
3436
3437 /*
3438 * Link into the hash table, inserting it at the end, so that LOFS
3439 * with the same fsid as UFS (or other) file systems will not hide the
3440 * UFS.
3441 */
3442 if (insert_at_head) {
3443 vfsp->vfs_hash = rvfs_list[vhno].rvfs_head;
3444 rvfs_list[vhno].rvfs_head = vfsp;
3445 } else {
3446 for (hp = &rvfs_list[vhno].rvfs_head; *hp != NULL;
3447 hp = &(*hp)->vfs_hash)
3448 continue;
3449 /*
3450 * hp now contains the address of the pointer to update
3451 * to effect the insertion.
3452 */
3453 vfsp->vfs_hash = NULL;
3454 *hp = vfsp;
3455 }
3456
3457 rvfs_list[vhno].rvfs_len++;
3458 mutex_exit(&rvfs_list[vhno].rvfs_lock);
3459 }
3460
3461
3462 static void
3463 vfs_hash_remove(struct vfs *vfsp)
3464 {
3465 int vhno;
3466 struct vfs *tvfsp;
3467 dev_t dev;
3468
3469 ASSERT(RW_WRITE_HELD(&vfslist));
3470
3471 dev = expldev(vfsp->vfs_fsid.val[0]);
3472 vhno = VFSHASH(getmajor(dev), getminor(dev));
3473
3474 mutex_enter(&rvfs_list[vhno].rvfs_lock);
3475
3476 /*
3477 * Remove from hash.
3478 */
3479 if (rvfs_list[vhno].rvfs_head == vfsp) {
3480 rvfs_list[vhno].rvfs_head = vfsp->vfs_hash;
3481 rvfs_list[vhno].rvfs_len--;
3482 goto foundit;
3483 }
3484 for (tvfsp = rvfs_list[vhno].rvfs_head; tvfsp != NULL;
3485 tvfsp = tvfsp->vfs_hash) {
3486 if (tvfsp->vfs_hash == vfsp) {
3487 tvfsp->vfs_hash = vfsp->vfs_hash;
3488 rvfs_list[vhno].rvfs_len--;
3489 goto foundit;
3490 }
3491 }
3492 cmn_err(CE_WARN, "vfs_list_remove: vfs not found in hash");
3493
3494 foundit:
3495
3496 mutex_exit(&rvfs_list[vhno].rvfs_lock);
3497 }
3498
3499
3500 void
3501 vfs_list_add(struct vfs *vfsp)
3502 {
3503 zone_t *zone;
3504
3505 /*
3506 * Typically, the vfs_t will have been created on behalf of the file
3507 * system in vfs_init, where it will have been provided with a
3508 * vfs_impl_t. This, however, might be lacking if the vfs_t was created
3509 * by an unbundled file system. We therefore check for such an example
3510 * before stamping the vfs_t with its creation time for the benefit of
3511 * mntfs.
3512 */
3513 if (vfsp->vfs_implp == NULL)
3514 vfsimpl_setup(vfsp);
3515 vfs_mono_time(&vfsp->vfs_hrctime);
3516
3517 /*
3518 * The zone that owns the mount is the one that performed the mount.
3519 * Note that this isn't necessarily the same as the zone mounted into.
3520 * The corresponding zone_rele_ref() will be done when the vfs_t
3521 * is being free'd.
3522 */
3523 vfsp->vfs_zone = curproc->p_zone;
3524 zone_init_ref(&vfsp->vfs_implp->vi_zone_ref);
3525 zone_hold_ref(vfsp->vfs_zone, &vfsp->vfs_implp->vi_zone_ref,
3526 ZONE_REF_VFS);
3527
3528 /*
3529 * Find the zone mounted into, and put this mount on its vfs list.
3530 */
3531 zone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
3532 ASSERT(zone != NULL);
3533 /*
3534 * Special casing for the root vfs. This structure is allocated
3535 * statically and hooked onto rootvfs at link time. During the
3536 * vfs_mountroot call at system startup time, the root file system's
3537 * VFS_MOUNTROOT routine will call vfs_add with this root vfs struct
3538 * as argument. The code below must detect and handle this special
3539 * case. The only apparent justification for this special casing is
3540 * to ensure that the root file system appears at the head of the
3541 * list.
3542 *
3543 * XXX: I'm assuming that it's ok to do normal list locking when
3544 * adding the entry for the root file system (this used to be
3545 * done with no locks held).
3546 */
3547 vfs_list_lock();
3548 /*
3549 * Link into the vfs list proper.
3550 */
3551 if (vfsp == &root) {
3552 /*
3553 * Assert: This vfs is already on the list as its first entry.
3554 * Thus, there's nothing to do.
3555 */
3556 ASSERT(rootvfs == vfsp);
3557 /*
3558 * Add it to the head of the global zone's vfslist.
3559 */
3560 ASSERT(zone == global_zone);
3561 ASSERT(zone->zone_vfslist == NULL);
3562 zone->zone_vfslist = vfsp;
3563 } else {
3564 /*
3565 * Link to end of list using vfs_prev (as rootvfs is now a
3566 * doubly linked circular list) so list is in mount order for
3567 * mnttab use.
3568 */
3569 rootvfs->vfs_prev->vfs_next = vfsp;
3570 vfsp->vfs_prev = rootvfs->vfs_prev;
3571 rootvfs->vfs_prev = vfsp;
3572 vfsp->vfs_next = rootvfs;
3573
3574 /*
3575 * Do it again for the zone-private list (which may be NULL).
3576 */
3577 if (zone->zone_vfslist == NULL) {
3578 ASSERT(zone != global_zone);
3579 zone->zone_vfslist = vfsp;
3580 } else {
3581 zone->zone_vfslist->vfs_zone_prev->vfs_zone_next = vfsp;
3582 vfsp->vfs_zone_prev = zone->zone_vfslist->vfs_zone_prev;
3583 zone->zone_vfslist->vfs_zone_prev = vfsp;
3584 vfsp->vfs_zone_next = zone->zone_vfslist;
3585 }
3586 }
3587
3588 /*
3589 * Link into the hash table, inserting it at the end, so that LOFS
3590 * with the same fsid as UFS (or other) file systems will not hide
3591 * the UFS.
3592 */
3593 vfs_hash_add(vfsp, 0);
3594
3595 /*
3596 * update the mnttab modification time
3597 */
3598 vfs_mnttab_modtimeupd();
3599 vfs_list_unlock();
3600 zone_rele(zone);
3601 }
3602
3603 void
3604 vfs_list_remove(struct vfs *vfsp)
3605 {
3606 zone_t *zone;
3607
3608 zone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
3609 ASSERT(zone != NULL);
3610 /*
3611 * Callers are responsible for preventing attempts to unmount the
3612 * root.
3613 */
3614 ASSERT(vfsp != rootvfs);
3615
3616 vfs_list_lock();
3617
3618 /*
3619 * Remove from hash.
3620 */
3621 vfs_hash_remove(vfsp);
3622
3623 /*
3624 * Remove from vfs list.
3625 */
3626 vfsp->vfs_prev->vfs_next = vfsp->vfs_next;
3627 vfsp->vfs_next->vfs_prev = vfsp->vfs_prev;
3628 vfsp->vfs_next = vfsp->vfs_prev = NULL;
3629
3630 /*
3631 * Remove from zone-specific vfs list.
3632 */
3633 if (zone->zone_vfslist == vfsp)
3634 zone->zone_vfslist = vfsp->vfs_zone_next;
3635
3636 if (vfsp->vfs_zone_next == vfsp) {
3637 ASSERT(vfsp->vfs_zone_prev == vfsp);
3638 ASSERT(zone->zone_vfslist == vfsp);
3639 zone->zone_vfslist = NULL;
3640 }
3641
3642 vfsp->vfs_zone_prev->vfs_zone_next = vfsp->vfs_zone_next;
3643 vfsp->vfs_zone_next->vfs_zone_prev = vfsp->vfs_zone_prev;
3644 vfsp->vfs_zone_next = vfsp->vfs_zone_prev = NULL;
3645
3646 /*
3647 * update the mnttab modification time
3648 */
3649 vfs_mnttab_modtimeupd();
3650 vfs_list_unlock();
3651 zone_rele(zone);
3652 }
3653
3654 struct vfs *
3655 getvfs(fsid_t *fsid)
3656 {
3657 struct vfs *vfsp;
3658 int val0 = fsid->val[0];
3659 int val1 = fsid->val[1];
3660 dev_t dev = expldev(val0);
3661 int vhno = VFSHASH(getmajor(dev), getminor(dev));
3662 kmutex_t *hmp = &rvfs_list[vhno].rvfs_lock;
3663
3664 mutex_enter(hmp);
3665 for (vfsp = rvfs_list[vhno].rvfs_head; vfsp; vfsp = vfsp->vfs_hash) {
3666 if (vfsp->vfs_fsid.val[0] == val0 &&
3667 vfsp->vfs_fsid.val[1] == val1) {
3668 VFS_HOLD(vfsp);
3669 mutex_exit(hmp);
3670 return (vfsp);
3671 }
3672 }
3673 mutex_exit(hmp);
3674 return (NULL);
3675 }
3676
3677 /*
3678 * Search the vfs mount in progress list for a specified device/vfs entry.
3679 * Returns 0 if the first entry in the list that the device matches has the
3680 * given vfs pointer as well. If the device matches but a different vfs
3681 * pointer is encountered in the list before the given vfs pointer then
3682 * a 1 is returned.
3683 */
3684
3685 int
3686 vfs_devmounting(dev_t dev, struct vfs *vfsp)
3687 {
3688 int retval = 0;
3689 struct ipmnt *mipp;
3690
3691 mutex_enter(&vfs_miplist_mutex);
3692 for (mipp = vfs_miplist; mipp != NULL; mipp = mipp->mip_next) {
3693 if (mipp->mip_dev == dev) {
3694 if (mipp->mip_vfsp != vfsp)
3695 retval = 1;
3696 break;
3697 }
3698 }
3699 mutex_exit(&vfs_miplist_mutex);
3700 return (retval);
3701 }
3702
3703 /*
3704 * Search the vfs list for a specified device. Returns 1, if entry is found
3705 * or 0 if no suitable entry is found.
3706 */
3707
3708 int
3709 vfs_devismounted(dev_t dev)
3710 {
3711 struct vfs *vfsp;
3712 int found;
3713
3714 vfs_list_read_lock();
3715 vfsp = rootvfs;
3716 found = 0;
3717 do {
3718 if (vfsp->vfs_dev == dev) {
3719 found = 1;
3720 break;
3721 }
3722 vfsp = vfsp->vfs_next;
3723 } while (vfsp != rootvfs);
3724
3725 vfs_list_unlock();
3726 return (found);
3727 }
3728
3729 /*
3730 * Search the vfs list for a specified device. Returns a pointer to it
3731 * or NULL if no suitable entry is found. The caller of this routine
3732 * is responsible for releasing the returned vfs pointer.
3733 */
3734 struct vfs *
3735 vfs_dev2vfsp(dev_t dev)
3736 {
3737 struct vfs *vfsp;
3738 int found;
3739
3740 vfs_list_read_lock();
3741 vfsp = rootvfs;
3742 found = 0;
3743 do {
3744 /*
3745 * The following could be made more efficient by making
3746 * the entire loop use vfs_zone_next if the call is from
3747 * a zone. The only callers, however, ustat(2) and
3748 * umount2(2), don't seem to justify the added
3749 * complexity at present.
3750 */
3751 if (vfsp->vfs_dev == dev &&
3752 ZONE_PATH_VISIBLE(refstr_value(vfsp->vfs_mntpt),
3753 curproc->p_zone)) {
3754 VFS_HOLD(vfsp);
3755 found = 1;
3756 break;
3757 }
3758 vfsp = vfsp->vfs_next;
3759 } while (vfsp != rootvfs);
3760 vfs_list_unlock();
3761 return (found ? vfsp: NULL);
3762 }
3763
3764 /*
3765 * Search the vfs list for a specified mntpoint. Returns a pointer to it
3766 * or NULL if no suitable entry is found. The caller of this routine
3767 * is responsible for releasing the returned vfs pointer.
3768 *
3769 * Note that if multiple mntpoints match, the last one matching is
3770 * returned in an attempt to return the "top" mount when overlay
3771 * mounts are covering the same mount point. This is accomplished by starting
3772 * at the end of the list and working our way backwards, stopping at the first
3773 * matching mount.
3774 */
3775 struct vfs *
3776 vfs_mntpoint2vfsp(const char *mp)
3777 {
3778 struct vfs *vfsp;
3779 struct vfs *retvfsp = NULL;
3780 zone_t *zone = curproc->p_zone;
3781 struct vfs *list;
3782
3783 vfs_list_read_lock();
3784 if (getzoneid() == GLOBAL_ZONEID) {
3785 /*
3786 * The global zone may see filesystems in any zone.
3787 */
3788 vfsp = rootvfs->vfs_prev;
3789 do {
3790 if (strcmp(refstr_value(vfsp->vfs_mntpt), mp) == 0) {
3791 retvfsp = vfsp;
3792 break;
3793 }
3794 vfsp = vfsp->vfs_prev;
3795 } while (vfsp != rootvfs->vfs_prev);
3796 } else if ((list = zone->zone_vfslist) != NULL) {
3797 const char *mntpt;
3798
3799 vfsp = list->vfs_zone_prev;
3800 do {
3801 mntpt = refstr_value(vfsp->vfs_mntpt);
3802 mntpt = ZONE_PATH_TRANSLATE(mntpt, zone);
3803 if (strcmp(mntpt, mp) == 0) {
3804 retvfsp = vfsp;
3805 break;
3806 }
3807 vfsp = vfsp->vfs_zone_prev;
3808 } while (vfsp != list->vfs_zone_prev);
3809 }
3810 if (retvfsp)
3811 VFS_HOLD(retvfsp);
3812 vfs_list_unlock();
3813 return (retvfsp);
3814 }
3815
3816 /*
3817 * Search the vfs list for a specified vfsops.
3818 * if vfs entry is found then return 1, else 0.
3819 */
3820 int
3821 vfs_opsinuse(vfsops_t *ops)
3822 {
3823 struct vfs *vfsp;
3824 int found;
3825
3826 vfs_list_read_lock();
3827 vfsp = rootvfs;
3828 found = 0;
3829 do {
3830 if (vfs_getops(vfsp) == ops) {
3831 found = 1;
3832 break;
3833 }
3834 vfsp = vfsp->vfs_next;
3835 } while (vfsp != rootvfs);
3836 vfs_list_unlock();
3837 return (found);
3838 }
3839
3840 /*
3841 * Allocate an entry in vfssw for a file system type
3842 */
3843 struct vfssw *
3844 allocate_vfssw(const char *type)
3845 {
3846 struct vfssw *vswp;
3847
3848 if (type[0] == '\0' || strlen(type) + 1 > _ST_FSTYPSZ) {
3849 /*
3850 * The vfssw table uses the empty string to identify an
3851 * available entry; we cannot add any type which has
3852 * a leading NUL. The string length is limited to
3853 * the size of the st_fstype array in struct stat.
3854 */
3855 return (NULL);
3856 }
3857
3858 ASSERT(VFSSW_WRITE_LOCKED());
3859 for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++)
3860 if (!ALLOCATED_VFSSW(vswp)) {
3861 vswp->vsw_name = kmem_alloc(strlen(type) + 1, KM_SLEEP);
3862 (void) strcpy(vswp->vsw_name, type);
3863 ASSERT(vswp->vsw_count == 0);
3864 vswp->vsw_count = 1;
3865 mutex_init(&vswp->vsw_lock, NULL, MUTEX_DEFAULT, NULL);
3866 return (vswp);
3867 }
3868 return (NULL);
3869 }
3870
3871 /*
3872 * Impose additional layer of translation between vfstype names
3873 * and module names in the filesystem.
3874 */
3875 static const char *
3876 vfs_to_modname(const char *vfstype)
3877 {
3878 if (strcmp(vfstype, "proc") == 0) {
3879 vfstype = "procfs";
3880 } else if (strcmp(vfstype, "fd") == 0) {
3881 vfstype = "fdfs";
3882 } else if (strncmp(vfstype, "nfs", 3) == 0) {
3883 vfstype = "nfs";
3884 }
3885
3886 return (vfstype);
3887 }
3888
3889 /*
3890 * Find a vfssw entry given a file system type name.
3891 * Try to autoload the filesystem if it's not found.
3892 * If it's installed, return the vfssw locked to prevent unloading.
3893 */
3894 struct vfssw *
3895 vfs_getvfssw(const char *type)
3896 {
3897 struct vfssw *vswp;
3898 const char *modname;
3899
3900 RLOCK_VFSSW();
3901 vswp = vfs_getvfsswbyname(type);
3902 modname = vfs_to_modname(type);
3903
3904 if (rootdir == NULL) {
3905 /*
3906 * If we haven't yet loaded the root file system, then our
3907 * _init won't be called until later. Allocate vfssw entry,
3908 * because mod_installfs won't be called.
3909 */
3910 if (vswp == NULL) {
3911 RUNLOCK_VFSSW();
3912 WLOCK_VFSSW();
3913 if ((vswp = vfs_getvfsswbyname(type)) == NULL) {
3914 if ((vswp = allocate_vfssw(type)) == NULL) {
3915 WUNLOCK_VFSSW();
3916 return (NULL);
3917 }
3918 }
3919 WUNLOCK_VFSSW();
3920 RLOCK_VFSSW();
3921 }
3922 if (!VFS_INSTALLED(vswp)) {
3923 RUNLOCK_VFSSW();
3924 (void) modloadonly("fs", modname);
3925 } else
3926 RUNLOCK_VFSSW();
3927 return (vswp);
3928 }
3929
3930 /*
3931 * Try to load the filesystem. Before calling modload(), we drop
3932 * our lock on the VFS switch table, and pick it up after the
3933 * module is loaded. However, there is a potential race: the
3934 * module could be unloaded after the call to modload() completes
3935 * but before we pick up the lock and drive on. Therefore,
3936 * we keep reloading the module until we've loaded the module
3937 * _and_ we have the lock on the VFS switch table.
3938 */
3939 while (vswp == NULL || !VFS_INSTALLED(vswp)) {
3940 RUNLOCK_VFSSW();
3941 if (modload("fs", modname) == -1)
3942 return (NULL);
3943 RLOCK_VFSSW();
3944 if (vswp == NULL)
3945 if ((vswp = vfs_getvfsswbyname(type)) == NULL)
3946 break;
3947 }
3948 RUNLOCK_VFSSW();
3949
3950 return (vswp);
3951 }
3952
3953 /*
3954 * Find a vfssw entry given a file system type name.
3955 */
3956 struct vfssw *
3957 vfs_getvfsswbyname(const char *type)
3958 {
3959 struct vfssw *vswp;
3960
3961 ASSERT(VFSSW_LOCKED());
3962 if (type == NULL || *type == '\0')
3963 return (NULL);
3964
3965 for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
3966 if (strcmp(type, vswp->vsw_name) == 0) {
3967 vfs_refvfssw(vswp);
3968 return (vswp);
3969 }
3970 }
3971
3972 return (NULL);
3973 }
3974
3975 /*
3976 * Find a vfssw entry given a set of vfsops.
3977 */
3978 struct vfssw *
3979 vfs_getvfsswbyvfsops(vfsops_t *vfsops)
3980 {
3981 struct vfssw *vswp;
3982
3983 RLOCK_VFSSW();
3984 for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
3985 if (ALLOCATED_VFSSW(vswp) && &vswp->vsw_vfsops == vfsops) {
3986 vfs_refvfssw(vswp);
3987 RUNLOCK_VFSSW();
3988 return (vswp);
3989 }
3990 }
3991 RUNLOCK_VFSSW();
3992
3993 return (NULL);
3994 }
3995
3996 /*
3997 * Reference a vfssw entry.
3998 */
3999 void
4000 vfs_refvfssw(struct vfssw *vswp)
4001 {
4002
4003 mutex_enter(&vswp->vsw_lock);
4004 vswp->vsw_count++;
4005 mutex_exit(&vswp->vsw_lock);
4006 }
4007
4008 /*
4009 * Unreference a vfssw entry.
4010 */
4011 void
4012 vfs_unrefvfssw(struct vfssw *vswp)
4013 {
4014
4015 mutex_enter(&vswp->vsw_lock);
4016 vswp->vsw_count--;
4017 mutex_exit(&vswp->vsw_lock);
4018 }
4019
4020 int sync_timeout = 30; /* timeout for syncing a page during panic */
4021 int sync_timeleft; /* portion of sync_timeout remaining */
4022
4023 static int sync_retries = 20; /* number of retries when not making progress */
4024 static int sync_triesleft; /* portion of sync_retries remaining */
4025
4026 static pgcnt_t old_pgcnt, new_pgcnt;
4027 static int new_bufcnt, old_bufcnt;
4028
4029 /*
4030 * Sync all of the mounted filesystems, and then wait for the actual i/o to
4031 * complete. We wait by counting the number of dirty pages and buffers,
4032 * pushing them out using bio_busy() and page_busy(), and then counting again.
4033 * This routine is used during both the uadmin A_SHUTDOWN code as well as
4034 * the SYNC phase of the panic code (see comments in panic.c). It should only
4035 * be used after some higher-level mechanism has quiesced the system so that
4036 * new writes are not being initiated while we are waiting for completion.
4037 *
4038 * To ensure finite running time, our algorithm uses two timeout mechanisms:
4039 * sync_timeleft (a timer implemented by the omnipresent deadman() cyclic), and
4040 * sync_triesleft (a progress counter used by the vfs_syncall() loop below).
4041 * Together these ensure that syncing completes if our i/o paths are stuck.
4042 * The counters are declared above so they can be found easily in the debugger.
4043 *
4044 * The sync_timeleft counter is reset by bio_busy() and page_busy() using the
4045 * vfs_syncprogress() subroutine whenever we make progress through the lists of
4046 * pages and buffers. It is decremented and expired by the deadman() cyclic.
4047 * When vfs_syncall() decides it is done, we disable the deadman() counter by
4048 * setting sync_timeleft to zero. This timer guards against vfs_syncall()
4049 * deadlocking or hanging inside of a broken filesystem or driver routine.
4050 *
4051 * The sync_triesleft counter is updated by vfs_syncall() itself. If we make
4052 * sync_retries consecutive calls to bio_busy() and page_busy() without
4053 * decreasing either the number of dirty buffers or dirty pages below the
4054 * lowest count we have seen so far, we give up and return from vfs_syncall().
4055 *
4056 * Each loop iteration ends with a call to delay() one second to allow time for
4057 * i/o completion and to permit the user time to read our progress messages.
4058 */
4059 void
4060 vfs_syncall(void)
4061 {
4062 if (rootdir == NULL && !modrootloaded)
4063 return; /* panic during boot - no filesystems yet */
4064
4065 printf("syncing file systems...");
4066 vfs_syncprogress();
4067 sync();
4068
4069 vfs_syncprogress();
4070 sync_triesleft = sync_retries;
4071
4072 old_bufcnt = new_bufcnt = INT_MAX;
4073 old_pgcnt = new_pgcnt = ULONG_MAX;
4074
4075 while (sync_triesleft > 0) {
4076 old_bufcnt = MIN(old_bufcnt, new_bufcnt);
4077 old_pgcnt = MIN(old_pgcnt, new_pgcnt);
4078
4079 new_bufcnt = bio_busy(B_TRUE);
4080 new_pgcnt = page_busy(B_TRUE);
4081 vfs_syncprogress();
4082
4083 if (new_bufcnt == 0 && new_pgcnt == 0)
4084 break;
4085
4086 if (new_bufcnt < old_bufcnt || new_pgcnt < old_pgcnt)
4087 sync_triesleft = sync_retries;
4088 else
4089 sync_triesleft--;
4090
4091 if (new_bufcnt)
4092 printf(" [%d]", new_bufcnt);
4093 if (new_pgcnt)
4094 printf(" %lu", new_pgcnt);
4095
4096 delay(hz);
4097 }
4098
4099 if (new_bufcnt != 0 || new_pgcnt != 0)
4100 printf(" done (not all i/o completed)\n");
4101 else
4102 printf(" done\n");
4103
4104 sync_timeleft = 0;
4105 delay(hz);
4106 }
4107
4108 /*
4109 * If we are in the middle of the sync phase of panic, reset sync_timeleft to
4110 * sync_timeout to indicate that we are making progress and the deadman()
4111 * omnipresent cyclic should not yet time us out. Note that it is safe to
4112 * store to sync_timeleft here since the deadman() is firing at high-level
4113 * on top of us. If we are racing with the deadman(), either the deadman()
4114 * will decrement the old value and then we will reset it, or we will
4115 * reset it and then the deadman() will immediately decrement it. In either
4116 * case, correct behavior results.
4117 */
4118 void
4119 vfs_syncprogress(void)
4120 {
4121 if (panicstr)
4122 sync_timeleft = sync_timeout;
4123 }
4124
4125 /*
4126 * Map VFS flags to statvfs flags. These shouldn't really be separate
4127 * flags at all.
4128 */
4129 uint_t
4130 vf_to_stf(uint_t vf)
4131 {
4132 uint_t stf = 0;
4133
4134 if (vf & VFS_RDONLY)
4135 stf |= ST_RDONLY;
4136 if (vf & VFS_NOSETUID)
4137 stf |= ST_NOSUID;
4138 if (vf & VFS_NOTRUNC)
4139 stf |= ST_NOTRUNC;
4140
4141 return (stf);
4142 }
4143
4144 /*
4145 * Entries for (illegal) fstype 0.
4146 */
4147 /* ARGSUSED */
4148 int
4149 vfsstray_sync(struct vfs *vfsp, short arg, struct cred *cr)
4150 {
4151 cmn_err(CE_PANIC, "stray vfs operation");
4152 return (0);
4153 }
4154
4155 /*
4156 * Entries for (illegal) fstype 0.
4157 */
4158 int
4159 vfsstray(void)
4160 {
4161 cmn_err(CE_PANIC, "stray vfs operation");
4162 return (0);
4163 }
4164
4165 /*
4166 * Support for dealing with forced UFS unmount and its interaction with
4167 * LOFS. Could be used by any filesystem.
4168 * See bug 1203132.
4169 */
4170 int
4171 vfs_EIO(void)
4172 {
4173 return (EIO);
4174 }
4175
4176 /*
4177 * We've gotta define the op for sync separately, since the compiler gets
4178 * confused if we mix and match ANSI and normal style prototypes when
4179 * a "short" argument is present and spits out a warning.
4180 */
4181 /*ARGSUSED*/
4182 int
4183 vfs_EIO_sync(struct vfs *vfsp, short arg, struct cred *cr)
4184 {
4185 return (EIO);
4186 }
4187
4188 vfs_t EIO_vfs;
4189 vfsops_t *EIO_vfsops;
4190
4191 /*
4192 * Called from startup() to initialize all loaded vfs's
4193 */
4194 void
4195 vfsinit(void)
4196 {
4197 struct vfssw *vswp;
4198 int error;
4199 extern int vopstats_enabled;
4200 extern void vopstats_startup();
4201
4202 static const fs_operation_def_t EIO_vfsops_template[] = {
4203 VFSNAME_MOUNT, { .error = vfs_EIO },
4204 VFSNAME_UNMOUNT, { .error = vfs_EIO },
4205 VFSNAME_ROOT, { .error = vfs_EIO },
4206 VFSNAME_STATVFS, { .error = vfs_EIO },
4207 VFSNAME_SYNC, { .vfs_sync = vfs_EIO_sync },
4208 VFSNAME_VGET, { .error = vfs_EIO },
4209 VFSNAME_MOUNTROOT, { .error = vfs_EIO },
4210 VFSNAME_FREEVFS, { .error = vfs_EIO },
4211 VFSNAME_VNSTATE, { .error = vfs_EIO },
4212 NULL, NULL
4213 };
4214
4215 static const fs_operation_def_t stray_vfsops_template[] = {
4216 VFSNAME_MOUNT, { .error = vfsstray },
4217 VFSNAME_UNMOUNT, { .error = vfsstray },
4218 VFSNAME_ROOT, { .error = vfsstray },
4219 VFSNAME_STATVFS, { .error = vfsstray },
4220 VFSNAME_SYNC, { .vfs_sync = vfsstray_sync },
4221 VFSNAME_VGET, { .error = vfsstray },
4222 VFSNAME_MOUNTROOT, { .error = vfsstray },
4223 VFSNAME_FREEVFS, { .error = vfsstray },
4224 VFSNAME_VNSTATE, { .error = vfsstray },
4225 NULL, NULL
4226 };
4227
4228 /* Create vfs cache */
4229 vfs_cache = kmem_cache_create("vfs_cache", sizeof (struct vfs),
4230 sizeof (uintptr_t), NULL, NULL, NULL, NULL, NULL, 0);
4231
4232 /* Initialize the vnode cache (file systems may use it during init). */
4233 vn_create_cache();
4234
4235 /* Setup event monitor framework */
4236 fem_init();
4237
4238 /* Initialize the dummy stray file system type. */
4239 error = vfs_setfsops(0, stray_vfsops_template, NULL);
4240
4241 /* Initialize the dummy EIO file system. */
4242 error = vfs_makefsops(EIO_vfsops_template, &EIO_vfsops);
4243 if (error != 0) {
4244 cmn_err(CE_WARN, "vfsinit: bad EIO vfs ops template");
4245 /* Shouldn't happen, but not bad enough to panic */
4246 }
4247
4248 VFS_INIT(&EIO_vfs, EIO_vfsops, (caddr_t)NULL);
4249
4250 /*
4251 * Default EIO_vfs.vfs_flag to VFS_UNMOUNTED so a lookup
4252 * on this vfs can immediately notice it's invalid.
4253 */
4254 EIO_vfs.vfs_flag |= VFS_UNMOUNTED;
4255
4256 /*
4257 * Call the init routines of non-loadable filesystems only.
4258 * Filesystems which are loaded as separate modules will be
4259 * initialized by the module loading code instead.
4260 */
4261
4262 for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
4263 RLOCK_VFSSW();
4264 if (vswp->vsw_init != NULL)
4265 (*vswp->vsw_init)(vswp - vfssw, vswp->vsw_name);
4266 RUNLOCK_VFSSW();
4267 }
4268
4269 vopstats_startup();
4270
4271 if (vopstats_enabled) {
4272 /* EIO_vfs can collect stats, but we don't retrieve them */
4273 initialize_vopstats(&EIO_vfs.vfs_vopstats);
4274 EIO_vfs.vfs_fstypevsp = NULL;
4275 EIO_vfs.vfs_vskap = NULL;
4276 EIO_vfs.vfs_flag |= VFS_STATS;
4277 }
4278
4279 xattr_init();
4280
4281 reparse_point_init();
4282 }
4283
4284 vfs_t *
4285 vfs_alloc(int kmflag)
4286 {
4287 vfs_t *vfsp;
4288
4289 vfsp = kmem_cache_alloc(vfs_cache, kmflag);
4290
4291 /*
4292 * Do the simplest initialization here.
4293 * Everything else gets done in vfs_init()
4294 */
4295 bzero(vfsp, sizeof (vfs_t));
4296 return (vfsp);
4297 }
4298
4299 void
4300 vfs_free(vfs_t *vfsp)
4301 {
4302 /*
4303 * One would be tempted to assert that "vfsp->vfs_count == 0".
4304 * The problem is that this gets called out of domount() with
4305 * a partially initialized vfs and a vfs_count of 1. This is
4306 * also called from vfs_rele() with a vfs_count of 0. We can't
4307 * call VFS_RELE() from domount() if VFS_MOUNT() hasn't successfully
4308 * returned. This is because VFS_MOUNT() fully initializes the
4309 * vfs structure and its associated data. VFS_RELE() will call
4310 * VFS_FREEVFS() which may panic the system if the data structures
4311 * aren't fully initialized from a successful VFS_MOUNT()).
4312 */
4313
4314 /* If FEM was in use, make sure everything gets cleaned up */
4315 if (vfsp->vfs_femhead) {
4316 ASSERT(vfsp->vfs_femhead->femh_list == NULL);
4317 mutex_destroy(&vfsp->vfs_femhead->femh_lock);
4318 kmem_free(vfsp->vfs_femhead, sizeof (*(vfsp->vfs_femhead)));
4319 vfsp->vfs_femhead = NULL;
4320 }
4321
4322 if (vfsp->vfs_implp)
4323 vfsimpl_teardown(vfsp);
4324 sema_destroy(&vfsp->vfs_reflock);
4325 kmem_cache_free(vfs_cache, vfsp);
4326 }
4327
4328 /*
4329 * Increments the vfs reference count by one atomically.
4330 */
4331 void
4332 vfs_hold(vfs_t *vfsp)
4333 {
4334 atomic_add_32(&vfsp->vfs_count, 1);
4335 ASSERT(vfsp->vfs_count != 0);
4336 }
4337
4338 /*
4339 * Decrements the vfs reference count by one atomically. When
4340 * vfs reference count becomes zero, it calls the file system
4341 * specific vfs_freevfs() to free up the resources.
4342 */
4343 void
4344 vfs_rele(vfs_t *vfsp)
4345 {
4346 ASSERT(vfsp->vfs_count != 0);
4347 if (atomic_add_32_nv(&vfsp->vfs_count, -1) == 0) {
4348 VFS_FREEVFS(vfsp);
4349 lofi_remove(vfsp);
4350 if (vfsp->vfs_zone)
4351 zone_rele_ref(&vfsp->vfs_implp->vi_zone_ref,
4352 ZONE_REF_VFS);
4353 vfs_freemnttab(vfsp);
4354 vfs_free(vfsp);
4355 }
4356 }
4357
4358 /*
4359 * Generic operations vector support.
4360 *
4361 * This is used to build operations vectors for both the vfs and vnode.
4362 * It's normally called only when a file system is loaded.
4363 *
4364 * There are many possible algorithms for this, including the following:
4365 *
4366 * (1) scan the list of known operations; for each, see if the file system
4367 * includes an entry for it, and fill it in as appropriate.
4368 *
4369 * (2) set up defaults for all known operations. scan the list of ops
4370 * supplied by the file system; for each which is both supplied and
4371 * known, fill it in.
4372 *
4373 * (3) sort the lists of known ops & supplied ops; scan the list, filling
4374 * in entries as we go.
4375 *
4376 * we choose (1) for simplicity, and because performance isn't critical here.
4377 * note that (2) could be sped up using a precomputed hash table on known ops.
4378 * (3) could be faster than either, but only if the lists were very large or
4379 * supplied in sorted order.
4380 *
4381 */
4382
4383 int
4384 fs_build_vector(void *vector, int *unused_ops,
4385 const fs_operation_trans_def_t *translation,
4386 const fs_operation_def_t *operations)
4387 {
4388 int i, num_trans, num_ops, used;
4389
4390 /*
4391 * Count the number of translations and the number of supplied
4392 * operations.
4393 */
4394
4395 {
4396 const fs_operation_trans_def_t *p;
4397
4398 for (num_trans = 0, p = translation;
4399 p->name != NULL;
4400 num_trans++, p++)
4401 ;
4402 }
4403
4404 {
4405 const fs_operation_def_t *p;
4406
4407 for (num_ops = 0, p = operations;
4408 p->name != NULL;
4409 num_ops++, p++)
4410 ;
4411 }
4412
4413 /* Walk through each operation known to our caller. There will be */
4414 /* one entry in the supplied "translation table" for each. */
4415
4416 used = 0;
4417
4418 for (i = 0; i < num_trans; i++) {
4419 int j, found;
4420 char *curname;
4421 fs_generic_func_p result;
4422 fs_generic_func_p *location;
4423
4424 curname = translation[i].name;
4425
4426 /* Look for a matching operation in the list supplied by the */
4427 /* file system. */
4428
4429 found = 0;
4430
4431 for (j = 0; j < num_ops; j++) {
4432 if (strcmp(operations[j].name, curname) == 0) {
4433 used++;
4434 found = 1;
4435 break;
4436 }
4437 }
4438
4439 /*
4440 * If the file system is using a "placeholder" for default
4441 * or error functions, grab the appropriate function out of
4442 * the translation table. If the file system didn't supply
4443 * this operation at all, use the default function.
4444 */
4445
4446 if (found) {
4447 result = operations[j].func.fs_generic;
4448 if (result == fs_default) {
4449 result = translation[i].defaultFunc;
4450 } else if (result == fs_error) {
4451 result = translation[i].errorFunc;
4452 } else if (result == NULL) {
4453 /* Null values are PROHIBITED */
4454 return (EINVAL);
4455 }
4456 } else {
4457 result = translation[i].defaultFunc;
4458 }
4459
4460 /* Now store the function into the operations vector. */
4461
4462 location = (fs_generic_func_p *)
4463 (((char *)vector) + translation[i].offset);
4464
4465 *location = result;
4466 }
4467
4468 *unused_ops = num_ops - used;
4469
4470 return (0);
4471 }
4472
4473 /* Placeholder functions, should never be called. */
4474
4475 int
4476 fs_error(void)
4477 {
4478 cmn_err(CE_PANIC, "fs_error called");
4479 return (0);
4480 }
4481
4482 int
4483 fs_default(void)
4484 {
4485 cmn_err(CE_PANIC, "fs_default called");
4486 return (0);
4487 }
4488
4489 #ifdef __sparc
4490
4491 /*
4492 * Part of the implementation of booting off a mirrored root
4493 * involves a change of dev_t for the root device. To
4494 * accomplish this, first remove the existing hash table
4495 * entry for the root device, convert to the new dev_t,
4496 * then re-insert in the hash table at the head of the list.
4497 */
4498 void
4499 vfs_root_redev(vfs_t *vfsp, dev_t ndev, int fstype)
4500 {
4501 vfs_list_lock();
4502
4503 vfs_hash_remove(vfsp);
4504
4505 vfsp->vfs_dev = ndev;
4506 vfs_make_fsid(&vfsp->vfs_fsid, ndev, fstype);
4507
4508 vfs_hash_add(vfsp, 1);
4509
4510 vfs_list_unlock();
4511 }
4512
4513 #else /* x86 NEWBOOT */
4514
4515 #if defined(__x86)
4516 extern int hvmboot_rootconf();
4517 #endif /* __x86 */
4518
4519 extern ib_boot_prop_t *iscsiboot_prop;
4520
4521 int
4522 rootconf()
4523 {
4524 int error;
4525 struct vfssw *vsw;
4526 extern void pm_init();
4527 char *fstyp, *fsmod;
4528 int ret = -1;
4529
4530 getrootfs(&fstyp, &fsmod);
4531
4532 #if defined(__x86)
4533 /*
4534 * hvmboot_rootconf() is defined in the hvm_bootstrap misc module,
4535 * which lives in /platform/i86hvm, and hence is only available when
4536 * booted in an x86 hvm environment. If the hvm_bootstrap misc module
4537 * is not available then the modstub for this function will return 0.
4538 * If the hvm_bootstrap misc module is available it will be loaded
4539 * and hvmboot_rootconf() will be invoked.
4540 */
4541 if (error = hvmboot_rootconf())
4542 return (error);
4543 #endif /* __x86 */
4544
4545 if (error = clboot_rootconf())
4546 return (error);
4547
4548 if (modload("fs", fsmod) == -1)
4549 panic("Cannot _init %s module", fsmod);
4550
4551 RLOCK_VFSSW();
4552 vsw = vfs_getvfsswbyname(fstyp);
4553 RUNLOCK_VFSSW();
4554 if (vsw == NULL) {
4555 cmn_err(CE_CONT, "Cannot find %s filesystem\n", fstyp);
4556 return (ENXIO);
4557 }
4558 VFS_INIT(rootvfs, &vsw->vsw_vfsops, 0);
4559 VFS_HOLD(rootvfs);
4560
4561 /* always mount readonly first */
4562 rootvfs->vfs_flag |= VFS_RDONLY;
4563
4564 pm_init();
4565
4566 if (netboot && iscsiboot_prop) {
4567 cmn_err(CE_WARN, "NFS boot and iSCSI boot"
4568 " shouldn't happen in the same time");
4569 return (EINVAL);
4570 }
4571
4572 if (netboot || iscsiboot_prop) {
4573 ret = strplumb();
4574 if (ret != 0) {
4575 cmn_err(CE_WARN, "Cannot plumb network device %d", ret);
4576 return (EFAULT);
4577 }
4578 }
4579
4580 if ((ret == 0) && iscsiboot_prop) {
4581 ret = modload("drv", "iscsi");
4582 /* -1 indicates fail */
4583 if (ret == -1) {
4584 cmn_err(CE_WARN, "Failed to load iscsi module");
4585 iscsi_boot_prop_free();
4586 return (EINVAL);
4587 } else {
4588 if (!i_ddi_attach_pseudo_node("iscsi")) {
4589 cmn_err(CE_WARN,
4590 "Failed to attach iscsi driver");
4591 iscsi_boot_prop_free();
4592 return (ENODEV);
4593 }
4594 }
4595 }
4596
4597 error = VFS_MOUNTROOT(rootvfs, ROOT_INIT);
4598 vfs_unrefvfssw(vsw);
4599 rootdev = rootvfs->vfs_dev;
4600
4601 if (error)
4602 cmn_err(CE_CONT, "Cannot mount root on %s fstype %s\n",
4603 rootfs.bo_name, fstyp);
4604 else
4605 cmn_err(CE_CONT, "?root on %s fstype %s\n",
4606 rootfs.bo_name, fstyp);
4607 return (error);
4608 }
4609
4610 /*
4611 * XXX this is called by nfs only and should probably be removed
4612 * If booted with ASKNAME, prompt on the console for a filesystem
4613 * name and return it.
4614 */
4615 void
4616 getfsname(char *askfor, char *name, size_t namelen)
4617 {
4618 if (boothowto & RB_ASKNAME) {
4619 printf("%s name: ", askfor);
4620 console_gets(name, namelen);
4621 }
4622 }
4623
4624 /*
4625 * Init the root filesystem type (rootfs.bo_fstype) from the "fstype"
4626 * property.
4627 *
4628 * Filesystem types starting with the prefix "nfs" are diskless clients;
4629 * init the root filename name (rootfs.bo_name), too.
4630 *
4631 * If we are booting via NFS we currently have these options:
4632 * nfs - dynamically choose NFS V2, V3, or V4 (default)
4633 * nfs2 - force NFS V2
4634 * nfs3 - force NFS V3
4635 * nfs4 - force NFS V4
4636 * Because we need to maintain backward compatibility with the naming
4637 * convention that the NFS V2 filesystem name is "nfs" (see vfs_conf.c)
4638 * we need to map "nfs" => "nfsdyn" and "nfs2" => "nfs". The dynamic
4639 * nfs module will map the type back to either "nfs", "nfs3", or "nfs4".
4640 * This is only for root filesystems, all other uses such as cachefs
4641 * will expect that "nfs" == NFS V2.
4642 */
4643 static void
4644 getrootfs(char **fstypp, char **fsmodp)
4645 {
4646 extern char *strplumb_get_netdev_path(void);
4647 char *propstr = NULL;
4648
4649 /*
4650 * Check fstype property; for diskless it should be one of "nfs",
4651 * "nfs2", "nfs3" or "nfs4".
4652 */
4653 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
4654 DDI_PROP_DONTPASS, "fstype", &propstr)
4655 == DDI_SUCCESS) {
4656 (void) strncpy(rootfs.bo_fstype, propstr, BO_MAXFSNAME);
4657 ddi_prop_free(propstr);
4658
4659 /*
4660 * if the boot property 'fstype' is not set, but 'zfs-bootfs' is set,
4661 * assume the type of this root filesystem is 'zfs'.
4662 */
4663 } else if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
4664 DDI_PROP_DONTPASS, "zfs-bootfs", &propstr)
4665 == DDI_SUCCESS) {
4666 (void) strncpy(rootfs.bo_fstype, "zfs", BO_MAXFSNAME);
4667 ddi_prop_free(propstr);
4668 }
4669
4670 if (strncmp(rootfs.bo_fstype, "nfs", 3) != 0) {
4671 *fstypp = *fsmodp = rootfs.bo_fstype;
4672 return;
4673 }
4674
4675 ++netboot;
4676
4677 if (strcmp(rootfs.bo_fstype, "nfs2") == 0)
4678 (void) strcpy(rootfs.bo_fstype, "nfs");
4679 else if (strcmp(rootfs.bo_fstype, "nfs") == 0)
4680 (void) strcpy(rootfs.bo_fstype, "nfsdyn");
4681
4682 /*
4683 * check if path to network interface is specified in bootpath
4684 * or by a hypervisor domain configuration file.
4685 * XXPV - enable strlumb_get_netdev_path()
4686 */
4687 if (ddi_prop_exists(DDI_DEV_T_ANY, ddi_root_node(), DDI_PROP_DONTPASS,
4688 "xpv-nfsroot")) {
4689 (void) strcpy(rootfs.bo_name, "/xpvd/xnf@0");
4690 } else if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
4691 DDI_PROP_DONTPASS, "bootpath", &propstr)
4692 == DDI_SUCCESS) {
4693 (void) strncpy(rootfs.bo_name, propstr, BO_MAXOBJNAME);
4694 ddi_prop_free(propstr);
4695 } else {
4696 /* attempt to determine netdev_path via boot_mac address */
4697 netdev_path = strplumb_get_netdev_path();
4698 if (netdev_path == NULL)
4699 panic("cannot find boot network interface");
4700 (void) strncpy(rootfs.bo_name, netdev_path, BO_MAXOBJNAME);
4701 }
4702 *fstypp = rootfs.bo_fstype;
4703 *fsmodp = "nfs";
4704 }
4705 #endif
4706
4707 /*
4708 * VFS feature routines
4709 */
4710
4711 #define VFTINDEX(feature) (((feature) >> 32) & 0xFFFFFFFF)
4712 #define VFTBITS(feature) ((feature) & 0xFFFFFFFFLL)
4713
4714 /* Register a feature in the vfs */
4715 void
4716 vfs_set_feature(vfs_t *vfsp, vfs_feature_t feature)
4717 {
4718 /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4719 if (vfsp->vfs_implp == NULL)
4720 return;
4721
4722 vfsp->vfs_featureset[VFTINDEX(feature)] |= VFTBITS(feature);
4723 }
4724
4725 void
4726 vfs_clear_feature(vfs_t *vfsp, vfs_feature_t feature)
4727 {
4728 /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4729 if (vfsp->vfs_implp == NULL)
4730 return;
4731 vfsp->vfs_featureset[VFTINDEX(feature)] &= VFTBITS(~feature);
4732 }
4733
4734 /*
4735 * Query a vfs for a feature.
4736 * Returns 1 if feature is present, 0 if not
4737 */
4738 int
4739 vfs_has_feature(vfs_t *vfsp, vfs_feature_t feature)
4740 {
4741 int ret = 0;
4742
4743 /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4744 if (vfsp->vfs_implp == NULL)
4745 return (ret);
4746
4747 if (vfsp->vfs_featureset[VFTINDEX(feature)] & VFTBITS(feature))
4748 ret = 1;
4749
4750 return (ret);
4751 }
4752
4753 /*
4754 * Propagate feature set from one vfs to another
4755 */
4756 void
4757 vfs_propagate_features(vfs_t *from, vfs_t *to)
4758 {
4759 int i;
4760
4761 if (to->vfs_implp == NULL || from->vfs_implp == NULL)
4762 return;
4763
4764 for (i = 1; i <= to->vfs_featureset[0]; i++) {
4765 to->vfs_featureset[i] = from->vfs_featureset[i];
4766 }
4767 }
4768
4769 #define LOFINODE_PATH "/dev/lofi/%d"
4770
4771 /*
4772 * Return the vnode for the lofi node if there's a lofi mount in place.
4773 * Returns -1 when there's no lofi node, 0 on success, and > 0 on
4774 * failure.
4775 */
4776 int
4777 vfs_get_lofi(vfs_t *vfsp, vnode_t **vpp)
4778 {
4779 char *path = NULL;
4780 int strsize;
4781 int err;
4782
4783 if (vfsp->vfs_lofi_minor == 0) {
4784 *vpp = NULL;
4785 return (-1);
4786 }
4787
4788 strsize = snprintf(NULL, 0, LOFINODE_PATH, vfsp->vfs_lofi_minor);
4789 path = kmem_alloc(strsize + 1, KM_SLEEP);
4790 (void) snprintf(path, strsize + 1, LOFINODE_PATH, vfsp->vfs_lofi_minor);
4791
4792 /*
4793 * We may be inside a zone, so we need to use the /dev path, but
4794 * it's created asynchronously, so we wait here.
4795 */
4796 for (;;) {
4797 err = lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, vpp);
4798
4799 if (err != ENOENT)
4800 break;
4801
4802 if ((err = delay_sig(hz / 8)) == EINTR)
4803 break;
4804 }
4805
4806 if (err)
4807 *vpp = NULL;
4808
4809 kmem_free(path, strsize + 1);
4810 return (err);
4811 }