Print this page
7127 remove -Wno-missing-braces from Makefile.uts
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/lofs/lofs_vfsops.c
+++ new/usr/src/uts/common/fs/lofs/lofs_vfsops.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) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 */
24 24
25 25 #include <sys/param.h>
26 26 #include <sys/errno.h>
27 27 #include <sys/vfs.h>
28 28 #include <sys/vfs_opreg.h>
29 29 #include <sys/vnode.h>
30 30 #include <sys/uio.h>
31 31 #include <sys/pathname.h>
32 32 #include <sys/kmem.h>
33 33 #include <sys/cred.h>
34 34 #include <sys/statvfs.h>
35 35 #include <sys/fs/lofs_info.h>
36 36 #include <sys/fs/lofs_node.h>
37 37 #include <sys/mount.h>
38 38 #include <sys/mntent.h>
39 39 #include <sys/mkdev.h>
40 40 #include <sys/priv.h>
41 41 #include <sys/sysmacros.h>
42 42 #include <sys/systm.h>
43 43 #include <sys/cmn_err.h>
44 44 #include <sys/policy.h>
45 45 #include <sys/tsol/label.h>
46 46 #include "fs/fs_subr.h"
47 47
48 48 /*
49 49 * This is the loadable module wrapper.
50 50 */
51 51 #include <sys/modctl.h>
52 52
53 53 static mntopts_t lofs_mntopts;
54 54
55 55 static int lofsinit(int, char *);
56 56
57 57 static vfsdef_t vfw = {
58 58 VFSDEF_VERSION,
59 59 "lofs",
60 60 lofsinit,
61 61 VSW_HASPROTO|VSW_STATS|VSW_ZMOUNT,
62 62 &lofs_mntopts
63 63 };
64 64
65 65 /*
66 66 * LOFS mount options table
67 67 */
68 68 static char *xattr_cancel[] = { MNTOPT_NOXATTR, NULL };
69 69 static char *noxattr_cancel[] = { MNTOPT_XATTR, NULL };
70 70 static char *sub_cancel[] = { MNTOPT_LOFS_NOSUB, NULL };
71 71 static char *nosub_cancel[] = { MNTOPT_LOFS_SUB, NULL };
72 72
73 73 static mntopt_t mntopts[] = {
74 74 /*
75 75 * option name cancel option default arg flags
76 76 * private data
77 77 */
78 78 { MNTOPT_XATTR, xattr_cancel, NULL, 0,
79 79 (void *)0 },
80 80 { MNTOPT_NOXATTR, noxattr_cancel, NULL, 0,
81 81 (void *)0 },
82 82 { MNTOPT_LOFS_SUB, sub_cancel, NULL, 0,
83 83 (void *)0 },
84 84 { MNTOPT_LOFS_NOSUB, nosub_cancel, NULL, 0,
85 85 (void *)0 },
86 86 };
87 87
88 88 static mntopts_t lofs_mntopts = {
89 89 sizeof (mntopts) / sizeof (mntopt_t),
90 90 mntopts
91 91 };
|
↓ open down ↓ |
91 lines elided |
↑ open up ↑ |
92 92
93 93 /*
94 94 * Module linkage information for the kernel.
95 95 */
96 96
97 97 static struct modlfs modlfs = {
98 98 &mod_fsops, "filesystem for lofs", &vfw
99 99 };
100 100
101 101 static struct modlinkage modlinkage = {
102 - MODREV_1, (void *)&modlfs, NULL
102 + MODREV_1, { (void *)&modlfs, NULL }
103 103 };
104 104
105 105 /*
106 106 * This is the module initialization routine.
107 107 */
108 108
109 109 int
110 110 _init(void)
111 111 {
112 112 int status;
113 113
114 114 lofs_subrinit();
115 115 status = mod_install(&modlinkage);
116 116 if (status != 0) {
117 117 /*
118 118 * Cleanup previously initialized work.
119 119 */
120 120 lofs_subrfini();
121 121 }
122 122
123 123 return (status);
124 124 }
125 125
126 126 /*
127 127 * Don't allow the lofs module to be unloaded for now.
128 128 * There is a memory leak if it gets unloaded.
129 129 */
130 130
131 131 int
132 132 _fini(void)
133 133 {
134 134 return (EBUSY);
135 135 }
136 136
137 137 int
138 138 _info(struct modinfo *modinfop)
139 139 {
140 140 return (mod_info(&modlinkage, modinfop));
141 141 }
142 142
143 143
144 144 static int lofsfstype;
145 145 vfsops_t *lo_vfsops;
146 146
147 147 /*
148 148 * lo mount vfsop
149 149 * Set up mount info record and attach it to vfs struct.
150 150 */
151 151 /*ARGSUSED*/
152 152 static int
153 153 lo_mount(struct vfs *vfsp,
154 154 struct vnode *vp,
155 155 struct mounta *uap,
156 156 struct cred *cr)
157 157 {
158 158 int error;
159 159 struct vnode *srootvp = NULL; /* the server's root */
160 160 struct vnode *realrootvp;
161 161 struct loinfo *li;
162 162 int nodev;
163 163
164 164 nodev = vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL);
165 165
166 166 if ((error = secpolicy_fs_mount(cr, vp, vfsp)) != 0)
167 167 return (EPERM);
168 168
169 169 /*
170 170 * Loopback devices which get "nodevices" added can be done without
171 171 * "nodevices" set because we cannot import devices into a zone
172 172 * with loopback. Note that we have all zone privileges when
173 173 * this happens; if not, we'd have gotten "nosuid".
174 174 */
175 175 if (!nodev && vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL))
176 176 vfs_setmntopt(vfsp, MNTOPT_DEVICES, NULL, VFS_NODISPLAY);
177 177
178 178 mutex_enter(&vp->v_lock);
179 179 if (!(uap->flags & MS_OVERLAY) &&
180 180 (vp->v_count != 1 || (vp->v_flag & VROOT))) {
181 181 mutex_exit(&vp->v_lock);
182 182 return (EBUSY);
183 183 }
184 184 mutex_exit(&vp->v_lock);
185 185
186 186 /*
187 187 * Find real root, and make vfs point to real vfs
188 188 */
189 189
190 190 if (error = lookupname(uap->spec, (uap->flags & MS_SYSSPACE) ?
191 191 UIO_SYSSPACE : UIO_USERSPACE, FOLLOW, NULLVPP, &realrootvp))
192 192 return (error);
193 193
194 194 /*
195 195 * Enforce MAC policy if needed.
196 196 *
197 197 * Loopback mounts must not allow writing up. The dominance test
198 198 * is intended to prevent a global zone caller from accidentally
199 199 * creating write-up conditions between two labeled zones.
200 200 * Local zones can't violate MAC on their own without help from
201 201 * the global zone because they can't name a pathname that
202 202 * they don't already have.
203 203 *
204 204 * The special case check for the NET_MAC_AWARE process flag is
205 205 * to support the case of the automounter in the global zone. We
206 206 * permit automounting of local zone directories such as home
207 207 * directories, into the global zone as required by setlabel,
208 208 * zonecopy, and saving of desktop sessions. Such mounts are
209 209 * trusted not to expose the contents of one zone's directories
210 210 * to another by leaking them through the global zone.
211 211 */
212 212 if (is_system_labeled() && crgetzoneid(cr) == GLOBAL_ZONEID) {
213 213 char specname[MAXPATHLEN];
214 214 zone_t *from_zptr;
215 215 zone_t *to_zptr;
216 216
217 217 if (vnodetopath(NULL, realrootvp, specname,
218 218 sizeof (specname), CRED()) != 0) {
219 219 VN_RELE(realrootvp);
220 220 return (EACCES);
221 221 }
222 222
223 223 from_zptr = zone_find_by_path(specname);
224 224 to_zptr = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
225 225
226 226 /*
227 227 * Special case for scratch zones used for Live Upgrade:
228 228 * this is used to mount the zone's root from /root to /a in
229 229 * the scratch zone. As with the other special case, this
230 230 * appears to be outside of the zone because it's not under
231 231 * the zone rootpath, which is $ZONEPATH/lu in the scratch
232 232 * zone case.
233 233 */
234 234
235 235 if (from_zptr != to_zptr &&
236 236 !(to_zptr->zone_flags & ZF_IS_SCRATCH)) {
237 237 /*
238 238 * We know at this point that the labels aren't equal
239 239 * because the zone pointers aren't equal, and zones
240 240 * can't share a label.
241 241 *
242 242 * If the source is the global zone then making
243 243 * it available to a local zone must be done in
244 244 * read-only mode as the label will become admin_low.
245 245 *
246 246 * If it is a mount between local zones then if
247 247 * the current process is in the global zone and has
248 248 * the NET_MAC_AWARE flag, then regular read-write
249 249 * access is allowed. If it's in some other zone, but
250 250 * the label on the mount point dominates the original
251 251 * source, then allow the mount as read-only
252 252 * ("read-down").
253 253 */
254 254 if (from_zptr->zone_id == GLOBAL_ZONEID) {
255 255 /* make the mount read-only */
256 256 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
257 257 } else { /* cross-zone mount */
258 258 if (to_zptr->zone_id == GLOBAL_ZONEID &&
259 259 /* LINTED: no consequent */
260 260 getpflags(NET_MAC_AWARE, cr) != 0) {
261 261 /* Allow the mount as read-write */
262 262 } else if (bldominates(
263 263 label2bslabel(to_zptr->zone_slabel),
264 264 label2bslabel(from_zptr->zone_slabel))) {
265 265 /* make the mount read-only */
266 266 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
267 267 } else {
268 268 VN_RELE(realrootvp);
269 269 zone_rele(to_zptr);
270 270 zone_rele(from_zptr);
271 271 return (EACCES);
272 272 }
273 273 }
274 274 }
275 275 zone_rele(to_zptr);
276 276 zone_rele(from_zptr);
277 277 }
278 278
279 279 /*
280 280 * realrootvp may be an AUTOFS node, in which case we perform a
281 281 * VOP_ACCESS() to trigger the mount of the intended filesystem.
282 282 * This causes a loopback mount of the intended filesystem instead
283 283 * of the AUTOFS filesystem.
284 284 *
285 285 * If a lofs mount creates a mount loop (such that a lofs vfs is
286 286 * mounted on an autofs node and that lofs vfs points back to the
287 287 * autofs node which it is mounted on) then a VOP_ACCESS call will
288 288 * create a deadlock. Once this deadlock is released, VOP_ACCESS will
289 289 * return EINTR. In such a case we don't want the lofs vfs to be
290 290 * created as the loop could panic the system.
291 291 */
292 292 if ((error = VOP_ACCESS(realrootvp, 0, 0, cr, NULL)) != 0) {
293 293 VN_RELE(realrootvp);
294 294 return (error);
295 295 }
296 296
297 297 /*
298 298 * We're interested in the top most filesystem.
299 299 * This is specially important when uap->spec is a trigger
300 300 * AUTOFS node, since we're really interested in mounting the
301 301 * filesystem AUTOFS mounted as result of the VOP_ACCESS()
302 302 * call not the AUTOFS node itself.
303 303 */
304 304 if (vn_mountedvfs(realrootvp) != NULL) {
305 305 if (error = traverse(&realrootvp)) {
306 306 VN_RELE(realrootvp);
307 307 return (error);
308 308 }
309 309 }
310 310
311 311 /*
312 312 * Allocate a vfs info struct and attach it
313 313 */
314 314 li = kmem_zalloc(sizeof (struct loinfo), KM_SLEEP);
315 315 li->li_realvfs = realrootvp->v_vfsp;
316 316 li->li_mountvfs = vfsp;
317 317
318 318 /*
319 319 * Set mount flags to be inherited by loopback vfs's
320 320 */
321 321 if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) {
322 322 li->li_mflag |= VFS_RDONLY;
323 323 }
324 324 if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {
325 325 li->li_mflag |= (VFS_NOSETUID|VFS_NODEVICES);
326 326 }
327 327 if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) {
328 328 li->li_mflag |= VFS_NODEVICES;
329 329 }
330 330 if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) {
331 331 li->li_mflag |= VFS_NOSETUID;
332 332 }
333 333 /*
334 334 * Permissive flags are added to the "deny" bitmap.
335 335 */
336 336 if (vfs_optionisset(vfsp, MNTOPT_NOXATTR, NULL)) {
337 337 li->li_dflag |= VFS_XATTR;
338 338 }
339 339 if (vfs_optionisset(vfsp, MNTOPT_NONBMAND, NULL)) {
340 340 li->li_dflag |= VFS_NBMAND;
341 341 }
342 342
343 343 /*
344 344 * Propagate inheritable mount flags from the real vfs.
345 345 */
346 346 if ((li->li_realvfs->vfs_flag & VFS_RDONLY) &&
347 347 !vfs_optionisset(vfsp, MNTOPT_RO, NULL))
348 348 vfs_setmntopt(vfsp, MNTOPT_RO, NULL,
349 349 VFS_NODISPLAY);
350 350 if ((li->li_realvfs->vfs_flag & VFS_NOSETUID) &&
351 351 !vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL))
352 352 vfs_setmntopt(vfsp, MNTOPT_NOSETUID, NULL,
353 353 VFS_NODISPLAY);
354 354 if ((li->li_realvfs->vfs_flag & VFS_NODEVICES) &&
355 355 !vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL))
356 356 vfs_setmntopt(vfsp, MNTOPT_NODEVICES, NULL,
357 357 VFS_NODISPLAY);
358 358 /*
359 359 * Permissive flags such as VFS_XATTR, as opposed to restrictive flags
360 360 * such as VFS_RDONLY, are handled differently. An explicit
361 361 * MNTOPT_NOXATTR should override the underlying filesystem's VFS_XATTR.
362 362 */
363 363 if ((li->li_realvfs->vfs_flag & VFS_XATTR) &&
364 364 !vfs_optionisset(vfsp, MNTOPT_NOXATTR, NULL) &&
365 365 !vfs_optionisset(vfsp, MNTOPT_XATTR, NULL))
366 366 vfs_setmntopt(vfsp, MNTOPT_XATTR, NULL,
367 367 VFS_NODISPLAY);
368 368 if ((li->li_realvfs->vfs_flag & VFS_NBMAND) &&
369 369 !vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL) &&
370 370 !vfs_optionisset(vfsp, MNTOPT_NONBMAND, NULL))
371 371 vfs_setmntopt(vfsp, MNTOPT_NBMAND, NULL,
372 372 VFS_NODISPLAY);
373 373
374 374 li->li_refct = 0;
375 375 vfsp->vfs_data = (caddr_t)li;
376 376 vfsp->vfs_bcount = 0;
377 377 vfsp->vfs_fstype = lofsfstype;
378 378 vfsp->vfs_bsize = li->li_realvfs->vfs_bsize;
379 379
380 380 vfsp->vfs_dev = li->li_realvfs->vfs_dev;
381 381 vfsp->vfs_fsid.val[0] = li->li_realvfs->vfs_fsid.val[0];
382 382 vfsp->vfs_fsid.val[1] = li->li_realvfs->vfs_fsid.val[1];
383 383
384 384 if (vfs_optionisset(vfsp, MNTOPT_LOFS_NOSUB, NULL)) {
385 385 li->li_flag |= LO_NOSUB;
386 386 }
387 387
388 388 /*
389 389 * Propagate any VFS features
390 390 */
391 391
392 392 vfs_propagate_features(li->li_realvfs, vfsp);
393 393
394 394 /*
395 395 * Setup the hashtable. If the root of this mount isn't a directory,
396 396 * there's no point in allocating a large hashtable. A table with one
397 397 * bucket is sufficient.
398 398 */
399 399 if (realrootvp->v_type != VDIR)
400 400 lsetup(li, 1);
401 401 else
402 402 lsetup(li, 0);
403 403
404 404 /*
405 405 * Make the root vnode
406 406 */
407 407 srootvp = makelonode(realrootvp, li, 0);
408 408 srootvp->v_flag |= VROOT;
409 409 li->li_rootvp = srootvp;
410 410
411 411 #ifdef LODEBUG
412 412 lo_dprint(4, "lo_mount: vfs %p realvfs %p root %p realroot %p li %p\n",
413 413 vfsp, li->li_realvfs, srootvp, realrootvp, li);
414 414 #endif
415 415 return (0);
416 416 }
417 417
418 418 /*
419 419 * Undo loopback mount
420 420 */
421 421 static int
422 422 lo_unmount(struct vfs *vfsp, int flag, struct cred *cr)
423 423 {
424 424 struct loinfo *li;
425 425
426 426 if (secpolicy_fs_unmount(cr, vfsp) != 0)
427 427 return (EPERM);
428 428
429 429 /*
430 430 * Forced unmount is not supported by this file system
431 431 * and thus, ENOTSUP, is being returned.
432 432 */
433 433 if (flag & MS_FORCE)
434 434 return (ENOTSUP);
435 435
436 436 li = vtoli(vfsp);
437 437 #ifdef LODEBUG
438 438 lo_dprint(4, "lo_unmount(%p) li %p\n", vfsp, li);
439 439 #endif
440 440 if (li->li_refct != 1 || li->li_rootvp->v_count != 1) {
441 441 #ifdef LODEBUG
442 442 lo_dprint(4, "refct %d v_ct %d\n", li->li_refct,
443 443 li->li_rootvp->v_count);
444 444 #endif
445 445 return (EBUSY);
446 446 }
447 447 VN_RELE(li->li_rootvp);
448 448 return (0);
449 449 }
450 450
451 451 /*
452 452 * Find root of lofs mount.
453 453 */
454 454 static int
455 455 lo_root(struct vfs *vfsp, struct vnode **vpp)
456 456 {
457 457 *vpp = vtoli(vfsp)->li_rootvp;
458 458 #ifdef LODEBUG
459 459 lo_dprint(4, "lo_root(0x%p) = %p\n", vfsp, *vpp);
460 460 #endif
461 461 /*
462 462 * If the root of the filesystem is a special file, return the specvp
463 463 * version of the vnode. We don't save the specvp vnode in our
464 464 * hashtable since that's exclusively for lnodes.
465 465 */
466 466 if (IS_DEVVP(*vpp)) {
467 467 struct vnode *svp;
468 468
469 469 svp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, kcred);
470 470 if (svp == NULL)
471 471 return (ENOSYS);
472 472 *vpp = svp;
473 473 } else {
474 474 VN_HOLD(*vpp);
475 475 }
476 476
477 477 return (0);
478 478 }
479 479
480 480 /*
481 481 * Get file system statistics.
482 482 */
483 483 static int
484 484 lo_statvfs(register struct vfs *vfsp, struct statvfs64 *sbp)
485 485 {
486 486 vnode_t *realrootvp;
487 487
488 488 #ifdef LODEBUG
489 489 lo_dprint(4, "lostatvfs %p\n", vfsp);
490 490 #endif
491 491 /*
492 492 * Using realrootvp->v_vfsp (instead of the realvfsp that was
493 493 * cached) is necessary to make lofs work woth forced UFS unmounts.
494 494 * In the case of a forced unmount, UFS stores a set of dummy vfsops
495 495 * in all the (i)vnodes in the filesystem. The dummy ops simply
496 496 * returns back EIO.
497 497 */
498 498 (void) lo_realvfs(vfsp, &realrootvp);
499 499 if (realrootvp != NULL)
500 500 return (VFS_STATVFS(realrootvp->v_vfsp, sbp));
501 501 else
502 502 return (EIO);
503 503 }
504 504
505 505 /*
506 506 * LOFS doesn't have any data or metadata to flush, pending I/O on the
507 507 * underlying filesystem will be flushed when such filesystem is synched.
508 508 */
509 509 /* ARGSUSED */
510 510 static int
511 511 lo_sync(struct vfs *vfsp,
512 512 short flag,
513 513 struct cred *cr)
514 514 {
515 515 #ifdef LODEBUG
516 516 lo_dprint(4, "lo_sync: %p\n", vfsp);
517 517 #endif
518 518 return (0);
519 519 }
520 520
521 521 /*
522 522 * Obtain the vnode from the underlying filesystem.
523 523 */
524 524 static int
525 525 lo_vget(struct vfs *vfsp, struct vnode **vpp, struct fid *fidp)
526 526 {
527 527 vnode_t *realrootvp;
528 528
529 529 #ifdef LODEBUG
530 530 lo_dprint(4, "lo_vget: %p\n", vfsp);
531 531 #endif
532 532 (void) lo_realvfs(vfsp, &realrootvp);
533 533 if (realrootvp != NULL)
534 534 return (VFS_VGET(realrootvp->v_vfsp, vpp, fidp));
535 535 else
536 536 return (EIO);
537 537 }
538 538
539 539 /*
540 540 * Free mount-specific data.
541 541 */
542 542 static void
543 543 lo_freevfs(struct vfs *vfsp)
544 544 {
|
↓ open down ↓ |
432 lines elided |
↑ open up ↑ |
545 545 struct loinfo *li = vtoli(vfsp);
546 546
547 547 ldestroy(li);
548 548 kmem_free(li, sizeof (struct loinfo));
549 549 }
550 550
551 551 static int
552 552 lofsinit(int fstyp, char *name)
553 553 {
554 554 static const fs_operation_def_t lo_vfsops_template[] = {
555 - VFSNAME_MOUNT, { .vfs_mount = lo_mount },
556 - VFSNAME_UNMOUNT, { .vfs_unmount = lo_unmount },
557 - VFSNAME_ROOT, { .vfs_root = lo_root },
558 - VFSNAME_STATVFS, { .vfs_statvfs = lo_statvfs },
559 - VFSNAME_SYNC, { .vfs_sync = lo_sync },
560 - VFSNAME_VGET, { .vfs_vget = lo_vget },
561 - VFSNAME_FREEVFS, { .vfs_freevfs = lo_freevfs },
562 - NULL, NULL
555 + { VFSNAME_MOUNT, { .vfs_mount = lo_mount } },
556 + { VFSNAME_UNMOUNT, { .vfs_unmount = lo_unmount } },
557 + { VFSNAME_ROOT, { .vfs_root = lo_root } },
558 + { VFSNAME_STATVFS, { .vfs_statvfs = lo_statvfs } },
559 + { VFSNAME_SYNC, { .vfs_sync = lo_sync } },
560 + { VFSNAME_VGET, { .vfs_vget = lo_vget } },
561 + { VFSNAME_FREEVFS, { .vfs_freevfs = lo_freevfs } },
562 + { NULL, { NULL } }
563 563 };
564 564 int error;
565 565
566 566 error = vfs_setfsops(fstyp, lo_vfsops_template, &lo_vfsops);
567 567 if (error != 0) {
568 568 cmn_err(CE_WARN, "lofsinit: bad vfs ops template");
569 569 return (error);
570 570 }
571 571
572 572 error = vn_make_ops(name, lo_vnodeops_template, &lo_vnodeops);
573 573 if (error != 0) {
574 574 (void) vfs_freevfsops_by_type(fstyp);
575 575 cmn_err(CE_WARN, "lofsinit: bad vnode ops template");
576 576 return (error);
577 577 }
578 578
579 579 lofsfstype = fstyp;
580 580
581 581 return (0);
582 582 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX