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