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