1 /*
2 * Copyright (c) 2000-2010 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
29 /*
30 * Copyright (c) 1989, 1993
31 * The Regents of the University of California. All rights reserved.
32 *
33 * This code is derived from software contributed
34 * to Berkeley by John Heidemann of the UCLA Ficus project.
35 *
36 * Source: * @(#)i405_init.c 2.10 92/04/27 UCLA Ficus project
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. All advertising materials mentioning features or use of this software
47 * must display the following acknowledgement:
48 * This product includes software developed by the University of
49 * California, Berkeley and its contributors.
50 * 4. Neither the name of the University nor the names of its contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 * SUCH DAMAGE.
65 *
66 * @(#)vfs_init.c 8.5 (Berkeley) 5/11/95
67 */
68 /*
69 * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
70 * support for mandatory and extensible security protections. This notice
71 * is included in support of clause 2.2 (b) of the Apple Public License,
72 * Version 2.0.
73 */
74
75
76 #include <sys/param.h>
77 #include <sys/mount_internal.h>
78 #include <sys/time.h>
79 #include <sys/vm.h>
80 #include <sys/vnode_internal.h>
81 #include <sys/stat.h>
82 #include <sys/namei.h>
83 #include <sys/ucred.h>
84 #include <sys/errno.h>
85 #include <kern/kalloc.h>
86 #include <sys/decmpfs.h>
87
88 #if CONFIG_MACF
89 #include <security/mac_framework.h>
90 #include <sys/kauth.h>
91 #endif
92 #if QUOTA
93 #include <sys/quota.h>
94 #endif
95
96 /*
97 * Sigh, such primitive tools are these...
98 */
99 #if 0
100 #define DODEBUG(A) A
101 #else
102 #define DODEBUG(A)
103 #endif
104
105 ZONE_DEFINE_TYPE(mount_zone, "mount", struct mount, ZC_ZFREE_CLEARMEM);
106
107 __private_extern__ void vntblinit(void);
108
109 extern const struct vnodeopv_desc *vfs_opv_descs[];
110 /* a list of lists of vnodeops defns */
111 extern struct vnodeop_desc *vfs_op_descs[];
112 /* and the operations they perform */
113 /*
114 * This code doesn't work if the defn is **vnodop_defns with cc.
115 * The problem is because of the compiler sometimes putting in an
116 * extra level of indirection for arrays. It's an interesting
117 * "feature" of C.
118 */
119 int vfs_opv_numops;
120
121 typedef int (*PFIvp)(void *);
122
123 /*
124 * A miscellaneous routine.
125 * A generic "default" routine that just returns an error.
126 */
127 int
vn_default_error(void)128 vn_default_error(void)
129 {
130 return ENOTSUP;
131 }
132
133 /*
134 * vfs_init.c
135 *
136 * Allocate and fill in operations vectors.
137 *
138 * An undocumented feature of this approach to defining operations is that
139 * there can be multiple entries in vfs_opv_descs for the same operations
140 * vector. This allows third parties to extend the set of operations
141 * supported by another layer in a binary compatibile way. For example,
142 * assume that NFS needed to be modified to support Ficus. NFS has an entry
143 * (probably nfs_vnopdeop_decls) declaring all the operations NFS supports by
144 * default. Ficus could add another entry (ficus_nfs_vnodeop_decl_entensions)
145 * listing those new operations Ficus adds to NFS, all without modifying the
146 * NFS code. (Of couse, the OTW NFS protocol still needs to be munged, but
147 * that is a(whole)nother story.) This is a feature.
148 */
149 void
vfs_opv_init(void)150 vfs_opv_init(void)
151 {
152 int i, j, k;
153 int(***opv_desc_vector_p)(void *);
154 int(**opv_desc_vector)(void *);
155 const struct vnodeopv_entry_desc *opve_descp;
156
157 /*
158 * Allocate the dynamic vectors and fill them in.
159 */
160 for (i = 0; vfs_opv_descs[i]; i++) {
161 opv_desc_vector_p = vfs_opv_descs[i]->opv_desc_vector_p;
162 /*
163 * Allocate and init the vector, if it needs it.
164 * Also handle backwards compatibility.
165 */
166 if (*opv_desc_vector_p == NULL) {
167 *opv_desc_vector_p = zalloc_permanent(vfs_opv_numops * sizeof(PFIvp),
168 ZALIGN(PFIvp));
169 DODEBUG(printf("vector at %x allocated\n",
170 opv_desc_vector_p));
171 }
172 opv_desc_vector = *opv_desc_vector_p;
173 for (j = 0; vfs_opv_descs[i]->opv_desc_ops[j].opve_op; j++) {
174 opve_descp = &(vfs_opv_descs[i]->opv_desc_ops[j]);
175
176 /* Silently skip known-disabled operations */
177 if (opve_descp->opve_op->vdesc_flags & VDESC_DISABLED) {
178 printf("vfs_fsadd: Ignoring reference in %p to disabled operation %s.\n",
179 vfs_opv_descs[i], opve_descp->opve_op->vdesc_name);
180 continue;
181 }
182
183 /*
184 * Sanity check: is this operation listed
185 * in the list of operations? We check this
186 * by seeing if its offest is zero. Since
187 * the default routine should always be listed
188 * first, it should be the only one with a zero
189 * offset. Any other operation with a zero
190 * offset is probably not listed in
191 * vfs_op_descs, and so is probably an error.
192 *
193 * A panic here means the layer programmer
194 * has committed the all-too common bug
195 * of adding a new operation to the layer's
196 * list of vnode operations but
197 * not adding the operation to the system-wide
198 * list of supported operations.
199 */
200 if (opve_descp->opve_op->vdesc_offset == 0 &&
201 opve_descp->opve_op !=
202 VDESC(vnop_default)) {
203 printf("operation %s not listed in %s.\n",
204 opve_descp->opve_op->vdesc_name,
205 "vfs_op_descs");
206 panic("vfs_opv_init: bad operation");
207 }
208 /*
209 * Fill in this entry.
210 */
211 opv_desc_vector[opve_descp->opve_op->vdesc_offset] =
212 opve_descp->opve_impl;
213 }
214 }
215 /*
216 * Finally, go back and replace unfilled routines
217 * with their default. (Sigh, an O(n^3) algorithm. I
218 * could make it better, but that'd be work, and n is small.)
219 */
220 for (i = 0; vfs_opv_descs[i]; i++) {
221 opv_desc_vector = *(vfs_opv_descs[i]->opv_desc_vector_p);
222 /*
223 * Force every operations vector to have a default routine.
224 */
225 if (opv_desc_vector[VOFFSET(vnop_default)] == NULL) {
226 panic("vfs_opv_init: operation vector without default routine.");
227 }
228 for (k = 0; k < vfs_opv_numops; k++) {
229 if (opv_desc_vector[k] == NULL) {
230 opv_desc_vector[k] =
231 opv_desc_vector[VOFFSET(vnop_default)];
232 }
233 }
234 }
235 }
236
237 /*
238 * Initialize known vnode operations vectors.
239 */
240 void
vfs_op_init(void)241 vfs_op_init(void)
242 {
243 int i;
244
245 DODEBUG(printf("Vnode_interface_init.\n"));
246 /*
247 * Set all vnode vectors to a well known value.
248 */
249 for (i = 0; vfs_opv_descs[i]; i++) {
250 *(vfs_opv_descs[i]->opv_desc_vector_p) = NULL;
251 }
252 /*
253 * Figure out how many ops there are by counting the table,
254 * and assign each its offset.
255 */
256 for (vfs_opv_numops = 0, i = 0; vfs_op_descs[i]; i++) {
257 /* Silently skip known-disabled operations */
258 if (vfs_op_descs[i]->vdesc_flags & VDESC_DISABLED) {
259 continue;
260 }
261 vfs_op_descs[i]->vdesc_offset = vfs_opv_numops;
262 vfs_opv_numops++;
263 }
264 DODEBUG(printf("vfs_opv_numops=%d\n", vfs_opv_numops));
265 }
266
267 /*
268 * Routines having to do with the management of the vnode table.
269 */
270 extern struct vnodeops dead_vnodeops;
271 extern struct vnodeops spec_vnodeops;
272
273 /* vars for vnode list lock */
274 static LCK_GRP_DECLARE(vnode_list_lck_grp, "vnode list");
275 static LCK_ATTR_DECLARE(vnode_list_lck_attr, 0, 0);
276 static LCK_SPIN_DECLARE_ATTR(vnode_list_spin_lock,
277 &vnode_list_lck_grp, &vnode_list_lck_attr);
278 static LCK_MTX_DECLARE_ATTR(spechash_mtx_lock,
279 &vnode_list_lck_grp, &vnode_list_lck_attr);
280 LCK_MTX_DECLARE_ATTR(pkg_extensions_lck,
281 &vnode_list_lck_grp, &vnode_list_lck_attr);
282
283 /* vars for mount lock */
284 static LCK_GRP_DECLARE(mnt_lck_grp, "mount");
285 static LCK_ATTR_DECLARE(mnt_lck_attr, 0, 0);
286
287 /* vars for mount list lock */
288 static LCK_GRP_DECLARE(mnt_list_lck_grp, "mount list");
289 LCK_MTX_DECLARE(mnt_list_mtx_lock, &mnt_list_lck_grp);
290
291 /*
292 * We want dead_mountp to be a constant pointer, but vfsinit() runs
293 * pretty late, so we'll allocate the dead_mount statically and
294 * statically-initialized dead_mountp.
295 */
296 static struct mount dead_mount_store;
297 struct mount * const dead_mountp = &dead_mount_store;
298
299 /*
300 * Initialize the vnode structures and initialize each file system type.
301 */
302 void
vfsinit(void)303 vfsinit(void)
304 {
305 struct vfstable *vfsp;
306 int i, maxtypenum;
307 struct mount * mp;
308
309 /*
310 * Initialize the vnode table
311 */
312 vntblinit();
313 /*
314 * Initialize the filesystem event mechanism.
315 */
316 vfs_event_init();
317 /*
318 * Initialize the vnode name cache
319 */
320 nchinit();
321
322 /*
323 * Build vnode operation vectors.
324 */
325 vfs_op_init();
326 vfs_opv_init(); /* finish the job */
327 /*
328 * Initialize each file system type in the static list,
329 * until the first NULL ->vfs_vfsops is encountered.
330 */
331 maxtypenum = VT_NON;
332 for (vfsp = vfsconf, i = 0; i < maxvfsslots; i++, vfsp++) {
333 struct vfsconf vfsc;
334 if (vfsp->vfc_vfsops == (struct vfsops *)0) {
335 break;
336 }
337 if (i) {
338 vfsconf[i - 1].vfc_next = vfsp;
339 }
340 if (maxtypenum <= vfsp->vfc_typenum) {
341 maxtypenum = vfsp->vfc_typenum + 1;
342 }
343
344 bzero(&vfsc, sizeof(struct vfsconf));
345 vfsc.vfc_reserved1 = 0;
346 bcopy(vfsp->vfc_name, vfsc.vfc_name, sizeof(vfsc.vfc_name));
347 vfsc.vfc_typenum = vfsp->vfc_typenum;
348 vfsc.vfc_refcount = vfsp->vfc_refcount;
349 vfsc.vfc_flags = vfsp->vfc_flags;
350 vfsc.vfc_reserved2 = 0;
351 vfsc.vfc_reserved3 = 0;
352
353 if (vfsp->vfc_vfsops->vfs_sysctl) {
354 struct sysctl_oid *oidp = NULL;
355 struct sysctl_oid oid = SYSCTL_STRUCT_INIT(_vfs, vfsp->vfc_typenum, , CTLTYPE_NODE | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED, NULL, 0, vfs_sysctl_node, "-", "");
356
357 oidp = kalloc_type(struct sysctl_oid, Z_WAITOK);
358 *oidp = oid;
359
360 /* Memory for VFS oid held by vfsentry forever */
361 vfsp->vfc_sysctl = oidp;
362 oidp->oid_name = vfsp->vfc_name;
363 sysctl_register_oid(vfsp->vfc_sysctl);
364 }
365
366 (*vfsp->vfc_vfsops->vfs_init)(&vfsc);
367
368 numused_vfsslots++;
369 numregistered_fses++;
370 }
371 /* next vfc_typenum to be used */
372 maxvfstypenum = maxtypenum;
373
374 /*
375 * Initialize the vnop authorization scope.
376 */
377 vnode_authorize_init();
378
379 /*
380 * create a mount point for dead vnodes
381 */
382 mp = &dead_mount_store;
383 /* Initialize the default IO constraints */
384 mp->mnt_maxreadcnt = mp->mnt_maxwritecnt = MAXPHYS;
385 mp->mnt_segreadcnt = mp->mnt_segwritecnt = 32;
386 mp->mnt_maxsegreadsize = mp->mnt_maxreadcnt;
387 mp->mnt_maxsegwritesize = mp->mnt_maxwritecnt;
388 mp->mnt_devblocksize = DEV_BSIZE;
389 mp->mnt_alignmentmask = PAGE_MASK;
390 mp->mnt_ioqueue_depth = MNT_DEFAULT_IOQUEUE_DEPTH;
391 mp->mnt_ioscale = 1;
392 mp->mnt_ioflags = 0;
393 mp->mnt_realrootvp = NULLVP;
394 mp->mnt_authcache_ttl = CACHED_LOOKUP_RIGHT_TTL;
395
396 TAILQ_INIT(&mp->mnt_vnodelist);
397 TAILQ_INIT(&mp->mnt_workerqueue);
398 TAILQ_INIT(&mp->mnt_newvnodes);
399 mp->mnt_flag = MNT_LOCAL;
400 mp->mnt_lflag = MNT_LDEAD;
401 mount_lock_init(mp);
402
403 #if CONFIG_MACF
404 mac_mount_label_init(mp);
405 mac_mount_label_associate(vfs_context_kernel(), mp);
406 #endif
407 /*
408 * dead_mountp is a statically-initialized constant pointer
409 * to dead_mount_store.
410 */
411
412 #if FS_COMPRESSION
413 decmpfs_init();
414 #endif
415
416 nspace_resolver_init();
417 }
418
419 void
vnode_list_lock(void)420 vnode_list_lock(void)
421 {
422 lck_spin_lock_grp(&vnode_list_spin_lock, &vnode_list_lck_grp);
423 }
424
425 void
vnode_list_unlock(void)426 vnode_list_unlock(void)
427 {
428 lck_spin_unlock(&vnode_list_spin_lock);
429 }
430
431 void
mount_list_lock(void)432 mount_list_lock(void)
433 {
434 lck_mtx_lock(&mnt_list_mtx_lock);
435 }
436
437 void
mount_list_unlock(void)438 mount_list_unlock(void)
439 {
440 lck_mtx_unlock(&mnt_list_mtx_lock);
441 }
442
443 void
mount_lock_init(mount_t mp)444 mount_lock_init(mount_t mp)
445 {
446 lck_mtx_init(&mp->mnt_mlock, &mnt_lck_grp, &mnt_lck_attr);
447 lck_mtx_init(&mp->mnt_iter_lock, &mnt_lck_grp, &mnt_lck_attr);
448 lck_mtx_init(&mp->mnt_renamelock, &mnt_lck_grp, &mnt_lck_attr);
449 lck_rw_init(&mp->mnt_rwlock, &mnt_lck_grp, &mnt_lck_attr);
450 }
451
452 void
mount_lock_destroy(mount_t mp)453 mount_lock_destroy(mount_t mp)
454 {
455 lck_mtx_destroy(&mp->mnt_mlock, &mnt_lck_grp);
456 lck_mtx_destroy(&mp->mnt_iter_lock, &mnt_lck_grp);
457 lck_mtx_destroy(&mp->mnt_renamelock, &mnt_lck_grp);
458 lck_rw_destroy(&mp->mnt_rwlock, &mnt_lck_grp);
459 }
460
461
462 /*
463 * Name: vfstable_add
464 *
465 * Description: Add a filesystem to the vfsconf list at the first
466 * unused slot. If no slots are available, return an
467 * error.
468 *
469 * Parameter: nvfsp vfsconf for VFS to add
470 *
471 * Returns: 0 Success
472 * -1 Failure
473 *
474 * Notes: The vfsconf should be treated as a linked list by
475 * all external references, as the implementation is
476 * expected to change in the future. The linkage is
477 * through ->vfc_next, and the list is NULL terminated.
478 *
479 * Warning: This code assumes that vfsconf[0] is non-empty.
480 */
481 struct vfstable *
vfstable_add(struct vfstable * nvfsp)482 vfstable_add(struct vfstable *nvfsp)
483 {
484 int slot;
485 struct vfstable *slotp, *allocated = NULL;
486 struct sysctl_oid *oidp = NULL;
487
488
489 if (nvfsp->vfc_vfsops->vfs_sysctl) {
490 struct sysctl_oid oid = SYSCTL_STRUCT_INIT(_vfs, nvfsp->vfc_typenum, , CTLTYPE_NODE | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED, NULL, 0, vfs_sysctl_node, "-", "");
491
492 oidp = kalloc_type(struct sysctl_oid, Z_WAITOK);
493 *oidp = oid;
494 }
495
496 /*
497 * Find the next empty slot; we recognize an empty slot by a
498 * NULL-valued ->vfc_vfsops, so if we delete a VFS, we must
499 * ensure we set the entry back to NULL.
500 */
501 findslot:
502 mount_list_lock();
503 for (slot = 0; slot < maxvfsslots; slot++) {
504 if (vfsconf[slot].vfc_vfsops == NULL) {
505 break;
506 }
507 }
508 if (slot == maxvfsslots) {
509 if (allocated == NULL) {
510 mount_list_unlock();
511 /* out of static slots; allocate one instead */
512 allocated = kalloc_type(struct vfstable, Z_WAITOK);
513 goto findslot;
514 } else {
515 slotp = allocated;
516 }
517 } else {
518 slotp = &vfsconf[slot];
519 }
520
521 /*
522 * Replace the contents of the next empty slot with the contents
523 * of the provided nvfsp.
524 *
525 * Note; Takes advantage of the fact that 'slot' was left
526 * with the value of 'maxvfslots' in the allocation case.
527 */
528 bcopy(nvfsp, slotp, sizeof(struct vfstable));
529 if (slot != 0) {
530 slotp->vfc_next = vfsconf[slot - 1].vfc_next;
531 vfsconf[slot - 1].vfc_next = slotp;
532 } else {
533 slotp->vfc_next = NULL;
534 }
535
536 if (slotp != allocated) {
537 /* used a statically allocated slot */
538 numused_vfsslots++;
539 }
540 numregistered_fses++;
541
542 if (oidp) {
543 /* Memory freed in vfstable_del after unregistration */
544 slotp->vfc_sysctl = oidp;
545 oidp->oid_name = slotp->vfc_name;
546 sysctl_register_oid(slotp->vfc_sysctl);
547 }
548
549 mount_list_unlock();
550
551 if (allocated && allocated != slotp) {
552 /* did allocation, but ended up using static slot */
553 kfree_type(struct vfstable, allocated);
554 }
555
556 return slotp;
557 }
558
559 /*
560 * Name: vfstable_del
561 *
562 * Description: Remove a filesystem from the vfsconf list by name.
563 * If no such filesystem exists, return an error.
564 *
565 * Parameter: fs_name name of VFS to remove
566 *
567 * Returns: 0 Success
568 * -1 Failure
569 *
570 * Notes: Hopefully all filesystems have unique names.
571 */
572 int
vfstable_del(struct vfstable * vtbl)573 vfstable_del(struct vfstable * vtbl)
574 {
575 struct vfstable **vcpp;
576 struct vfstable *vcdelp;
577
578 #if DEBUG
579 lck_mtx_assert(&mnt_list_mtx_lock, LCK_MTX_ASSERT_OWNED);
580 #endif /* DEBUG */
581
582 /*
583 * Traverse the list looking for vtbl; if found, *vcpp
584 * will contain the address of the pointer to the entry to
585 * be removed.
586 */
587 for (vcpp = &vfsconf; *vcpp; vcpp = &(*vcpp)->vfc_next) {
588 if (*vcpp == vtbl) {
589 break;
590 }
591 }
592
593 if (*vcpp == NULL) {
594 return ESRCH; /* vtbl not on vfsconf list */
595 }
596 if ((*vcpp)->vfc_sysctl) {
597 sysctl_unregister_oid((*vcpp)->vfc_sysctl);
598 (*vcpp)->vfc_sysctl->oid_name = NULL;
599 kfree_type(struct sysctl_oid, (*vcpp)->vfc_sysctl);
600 }
601
602 /* Unlink entry */
603 vcdelp = *vcpp;
604 *vcpp = (*vcpp)->vfc_next;
605
606 /*
607 * Is this an entry from our static table? We find out by
608 * seeing if the pointer to the object to be deleted places
609 * the object in the address space containing the table (or not).
610 */
611 if (vcdelp >= vfsconf && vcdelp < (vfsconf + maxvfsslots)) { /* Y */
612 /* Mark as empty for vfscon_add() */
613 bzero(vcdelp, sizeof(struct vfstable));
614 numregistered_fses--;
615 numused_vfsslots--;
616 } else { /* N */
617 /*
618 * This entry was dynamically allocated; we must free it;
619 * we would prefer to have just linked the caller's
620 * vfsconf onto our list, but it may not be persistent
621 * because of the previous (copying) implementation.
622 */
623 numregistered_fses--;
624 mount_list_unlock();
625 kfree_type(struct vfstable, vcdelp);
626 mount_list_lock();
627 }
628
629 #if DEBUG
630 lck_mtx_assert(&mnt_list_mtx_lock, LCK_MTX_ASSERT_OWNED);
631 #endif /* DEBUG */
632
633 return 0;
634 }
635
636 void
SPECHASH_LOCK(void)637 SPECHASH_LOCK(void)
638 {
639 lck_mtx_lock(&spechash_mtx_lock);
640 }
641
642 void
SPECHASH_UNLOCK(void)643 SPECHASH_UNLOCK(void)
644 {
645 lck_mtx_unlock(&spechash_mtx_lock);
646 }
647