bsd/vfs/vfs_init.c

   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 <sys/malloc.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 __private_extern__ void vntblinit(void);
 106
 107 extern struct vnodeopv_desc *vfs_opv_descs[];
 108                                 /* a list of lists of vnodeops defns */
 109 extern struct vnodeop_desc *vfs_op_descs[];
 110                                 /* and the operations they perform */
 111 /*
 112  * This code doesn't work if the defn is **vnodop_defns with cc.
 113  * The problem is because of the compiler sometimes putting in an
 114  * extra level of indirection for arrays.  It's an interesting
 115  * "feature" of C.
 116  */
 117 int vfs_opv_numops;
 118
 119 typedef int (*PFIvp)(void *);
 120
 121 /*
 122  * A miscellaneous routine.
 123  * A generic "default" routine that just returns an error.
 124  */
 125 int
 126 vn_default_error(void)
 127 {
 128
 129         return (ENOTSUP);
 130 }
 131
 132 /*
 133  * vfs_init.c
 134  *
 135  * Allocate and fill in operations vectors.
 136  *
 137  * An undocumented feature of this approach to defining operations is that
 138  * there can be multiple entries in vfs_opv_descs for the same operations
 139  * vector. This allows third parties to extend the set of operations
 140  * supported by another layer in a binary compatibile way. For example,
 141  * assume that NFS needed to be modified to support Ficus. NFS has an entry
 142  * (probably nfs_vnopdeop_decls) declaring all the operations NFS supports by
 143  * default. Ficus could add another entry (ficus_nfs_vnodeop_decl_entensions)
 144  * listing those new operations Ficus adds to NFS, all without modifying the
 145  * NFS code. (Of couse, the OTW NFS protocol still needs to be munged, but
 146  * that is a(whole)nother story.) This is a feature.
 147  */
 148 void
 149 vfs_opv_init(void)
 150 {
 151         int i, j, k;
 152         int (***opv_desc_vector_p)(void *);
 153         int (**opv_desc_vector)(void *);
 154         struct vnodeopv_entry_desc *opve_descp;
 155
 156         /*
 157          * Allocate the dynamic vectors and fill them in.
 158          */
 159         for (i=0; vfs_opv_descs[i]; i++) {
 160                 opv_desc_vector_p = vfs_opv_descs[i]->opv_desc_vector_p;
 161                 /*
 162                  * Allocate and init the vector, if it needs it.
 163                  * Also handle backwards compatibility.
 164                  */
 165                 if (*opv_desc_vector_p == NULL) {
 166                         MALLOC(*opv_desc_vector_p, PFIvp*,
 167                                vfs_opv_numops*sizeof(PFIvp), M_TEMP, M_WAITOK);
 168                         bzero (*opv_desc_vector_p, vfs_opv_numops*sizeof(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  * Initialize known vnode operations vectors.
 237  */
 238 void
 239 vfs_op_init(void)
 240 {
 241         int i;
 242
 243         DODEBUG(printf("Vnode_interface_init.\n"));
 244         /*
 245          * Set all vnode vectors to a well known value.
 246          */
 247         for (i = 0; vfs_opv_descs[i]; i++)
 248                 *(vfs_opv_descs[i]->opv_desc_vector_p) = NULL;
 249         /*
 250          * Figure out how many ops there are by counting the table,
 251          * and assign each its offset.
 252          */
 253         for (vfs_opv_numops = 0, i = 0; vfs_op_descs[i]; i++) {
 254                 /* Silently skip known-disabled operations */
 255                 if (vfs_op_descs[i]->vdesc_flags & VDESC_DISABLED) {
 256                         continue;
 257                 }
 258                 vfs_op_descs[i]->vdesc_offset = vfs_opv_numops;
 259                 vfs_opv_numops++;
 260         }
 261         DODEBUG(printf ("vfs_opv_numops=%d\n", vfs_opv_numops));
 262 }
 263
 264 /*
 265  * Routines having to do with the management of the vnode table.
 266  */
 267 extern struct vnodeops dead_vnodeops;
 268 extern struct vnodeops spec_vnodeops;
 269
 270 /* vars for vnode lock */
 271 lck_grp_t * vnode_lck_grp;
 272 lck_grp_attr_t * vnode_lck_grp_attr;
 273 lck_attr_t * vnode_lck_attr;
 274
 275 #if CONFIG_TRIGGERS
 276 /* vars for vnode trigger resolver */
 277 lck_grp_t * trigger_vnode_lck_grp;
 278 lck_grp_attr_t * trigger_vnode_lck_grp_attr;
 279 lck_attr_t * trigger_vnode_lck_attr;
 280 #endif
 281
 282 lck_grp_t * fd_vn_lck_grp;
 283 lck_grp_attr_t * fd_vn_lck_grp_attr;
 284 lck_attr_t * fd_vn_lck_attr;
 285
 286 /* vars for vnode list lock */
 287 lck_grp_t * vnode_list_lck_grp;
 288 lck_grp_attr_t * vnode_list_lck_grp_attr;
 289 lck_attr_t * vnode_list_lck_attr;
 290 lck_spin_t * vnode_list_spin_lock;
 291 lck_mtx_t * spechash_mtx_lock;
 292
 293 /* vars for vfsconf lock */
 294 lck_grp_t * fsconf_lck_grp;
 295 lck_grp_attr_t * fsconf_lck_grp_attr;
 296 lck_attr_t * fsconf_lck_attr;
 297
 298
 299 /* vars for mount lock */
 300 lck_grp_t * mnt_lck_grp;
 301 lck_grp_attr_t * mnt_lck_grp_attr;
 302 lck_attr_t * mnt_lck_attr;
 303
 304 /* vars for mount list lock */
 305 lck_grp_t * mnt_list_lck_grp;
 306 lck_grp_attr_t * mnt_list_lck_grp_attr;
 307 lck_attr_t * mnt_list_lck_attr;
 308 lck_mtx_t * mnt_list_mtx_lock;
 309
 310 /* vars for sync mutex */
 311 lck_grp_t * sync_mtx_lck_grp;
 312 lck_grp_attr_t * sync_mtx_lck_grp_attr;
 313 lck_attr_t * sync_mtx_lck_attr;
 314 lck_mtx_t * sync_mtx_lck;
 315
 316 lck_mtx_t *pkg_extensions_lck;
 317
 318 struct mount * dead_mountp;
 319
 320 extern void nspace_handler_init(void);
 321
 322 /*
 323  * Initialize the vnode structures and initialize each file system type.
 324  */
 325 void
 326 vfsinit(void)
 327 {
 328         struct vfstable *vfsp;
 329         int i, maxtypenum;
 330         struct mount * mp;
 331
 332         /* Allocate vnode list lock group attribute and group */
 333         vnode_list_lck_grp_attr = lck_grp_attr_alloc_init();
 334
 335         vnode_list_lck_grp = lck_grp_alloc_init("vnode list",  vnode_list_lck_grp_attr);
 336
 337         /* Allocate vnode list lock attribute */
 338         vnode_list_lck_attr = lck_attr_alloc_init();
 339
 340         /* Allocate vnode list lock */
 341         vnode_list_spin_lock = lck_spin_alloc_init(vnode_list_lck_grp, vnode_list_lck_attr);
 342
 343         /* Allocate spec hash list lock */
 344         spechash_mtx_lock = lck_mtx_alloc_init(vnode_list_lck_grp, vnode_list_lck_attr);
 345
 346         /* Allocate the package extensions table lock */
 347         pkg_extensions_lck = lck_mtx_alloc_init(vnode_list_lck_grp, vnode_list_lck_attr);
 348
 349         /* allocate vnode lock group attribute and group */
 350         vnode_lck_grp_attr= lck_grp_attr_alloc_init();
 351
 352         vnode_lck_grp = lck_grp_alloc_init("vnode",  vnode_lck_grp_attr);
 353
 354         /* Allocate vnode lock attribute */
 355         vnode_lck_attr = lck_attr_alloc_init();
 356
 357 #if CONFIG_TRIGGERS
 358         trigger_vnode_lck_grp_attr = lck_grp_attr_alloc_init();
 359         trigger_vnode_lck_grp = lck_grp_alloc_init("trigger_vnode", trigger_vnode_lck_grp_attr);
 360         trigger_vnode_lck_attr = lck_attr_alloc_init();
 361 #endif
 362         /* Allocate per fd vnode data lock attribute and group */
 363         fd_vn_lck_grp_attr = lck_grp_attr_alloc_init();
 364         fd_vn_lck_grp = lck_grp_alloc_init("fd_vnode_data", fd_vn_lck_grp_attr);
 365         fd_vn_lck_attr = lck_attr_alloc_init();
 366
 367         /* Allocate fs config lock group attribute and group */
 368         fsconf_lck_grp_attr= lck_grp_attr_alloc_init();
 369
 370         fsconf_lck_grp = lck_grp_alloc_init("fs conf",  fsconf_lck_grp_attr);
 371
 372         /* Allocate fs config lock attribute */
 373         fsconf_lck_attr = lck_attr_alloc_init();
 374
 375         /* Allocate mount point related lock structures  */
 376
 377         /* Allocate mount list lock group attribute and group */
 378         mnt_list_lck_grp_attr= lck_grp_attr_alloc_init();
 379
 380         mnt_list_lck_grp = lck_grp_alloc_init("mount list",  mnt_list_lck_grp_attr);
 381
 382         /* Allocate mount list lock attribute */
 383         mnt_list_lck_attr = lck_attr_alloc_init();
 384
 385         /* Allocate mount list lock */
 386         mnt_list_mtx_lock = lck_mtx_alloc_init(mnt_list_lck_grp, mnt_list_lck_attr);
 387
 388
 389         /* allocate mount lock group attribute and group */
 390         mnt_lck_grp_attr= lck_grp_attr_alloc_init();
 391
 392         mnt_lck_grp = lck_grp_alloc_init("mount",  mnt_lck_grp_attr);
 393
 394         /* Allocate mount lock attribute */
 395         mnt_lck_attr = lck_attr_alloc_init();
 396
 397         /* Allocate sync lock */
 398         sync_mtx_lck_grp_attr =  lck_grp_attr_alloc_init();
 399         sync_mtx_lck_grp =       lck_grp_alloc_init("sync thread",  sync_mtx_lck_grp_attr);
 400         sync_mtx_lck_attr =      lck_attr_alloc_init();
 401         sync_mtx_lck =           lck_mtx_alloc_init(sync_mtx_lck_grp, sync_mtx_lck_attr);
 402
 403         /*
 404          * Initialize the vnode table
 405          */
 406         vntblinit();
 407         /*
 408          * Initialize the filesystem event mechanism.
 409          */
 410         vfs_event_init();
 411         /*
 412          * Initialize the vnode name cache
 413          */
 414         nchinit();
 415
 416         nspace_handler_init();
 417
 418         /*
 419          * Build vnode operation vectors.
 420          */
 421         vfs_op_init();
 422         vfs_opv_init();   /* finish the job */
 423         /*
 424          * Initialize each file system type in the static list,
 425          * until the first NULL ->vfs_vfsops is encountered.
 426          */
 427         maxtypenum = VT_NON;
 428         for (vfsp = vfsconf, i = 0; i < maxvfsslots; i++, vfsp++) {
 429                 struct vfsconf vfsc;
 430                 if (vfsp->vfc_vfsops == (struct vfsops *)0)
 431                         break;
 432                 if (i) vfsconf[i-1].vfc_next = vfsp;
 433                 if (maxtypenum <= vfsp->vfc_typenum)
 434                         maxtypenum = vfsp->vfc_typenum + 1;
 435
 436                 bzero(&vfsc, sizeof(struct vfsconf));
 437                 vfsc.vfc_reserved1 = 0;
 438                 bcopy(vfsp->vfc_name, vfsc.vfc_name, sizeof(vfsc.vfc_name));
 439                 vfsc.vfc_typenum = vfsp->vfc_typenum;
 440                 vfsc.vfc_refcount = vfsp->vfc_refcount;
 441                 vfsc.vfc_flags = vfsp->vfc_flags;
 442                 vfsc.vfc_reserved2 = 0;
 443                 vfsc.vfc_reserved3 = 0;
 444
 445                 if (vfsp->vfc_vfsops->vfs_sysctl) {
 446                         struct sysctl_oid *oidp = NULL;
 447                         struct sysctl_oid oid = SYSCTL_STRUCT_INIT(_vfs, vfsp->vfc_typenum, , CTLTYPE_NODE | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED, NULL, 0, vfs_sysctl_node, "-", "");
 448
 449                         MALLOC(oidp, struct sysctl_oid *, sizeof(struct sysctl_oid), M_TEMP, M_WAITOK);
 450                         *oidp = oid;
 451
 452                         /* Memory for VFS oid held by vfsentry forever */
 453                         vfsp->vfc_sysctl = oidp;
 454                         oidp->oid_name = vfsp->vfc_name;
 455                         sysctl_register_oid(vfsp->vfc_sysctl);
 456                 }
 457
 458                 (*vfsp->vfc_vfsops->vfs_init)(&vfsc);
 459
 460                 numused_vfsslots++;
 461                 numregistered_fses++;
 462         }
 463         /* next vfc_typenum to be used */
 464         maxvfstypenum = maxtypenum;
 465
 466         /*
 467          * Initialize the vnop authorization scope.
 468          */
 469         vnode_authorize_init();
 470
 471         /*
 472          * Initialiize the quota system.
 473          */
 474 #if QUOTA
 475         dqinit();
 476 #endif
 477
 478         /*
 479          * create a mount point for dead vnodes
 480          */
 481         MALLOC_ZONE(mp, struct mount *, sizeof(struct mount),
 482                 M_MOUNT, M_WAITOK);
 483         bzero((char *)mp, sizeof(struct mount));
 484         /* Initialize the default IO constraints */
 485         mp->mnt_maxreadcnt = mp->mnt_maxwritecnt = MAXPHYS;
 486         mp->mnt_segreadcnt = mp->mnt_segwritecnt = 32;
 487         mp->mnt_maxsegreadsize = mp->mnt_maxreadcnt;
 488         mp->mnt_maxsegwritesize = mp->mnt_maxwritecnt;
 489         mp->mnt_devblocksize = DEV_BSIZE;
 490         mp->mnt_alignmentmask = PAGE_MASK;
 491         mp->mnt_ioqueue_depth = MNT_DEFAULT_IOQUEUE_DEPTH;
 492         mp->mnt_ioscale = 1;
 493         mp->mnt_ioflags = 0;
 494         mp->mnt_realrootvp = NULLVP;
 495         mp->mnt_authcache_ttl = CACHED_LOOKUP_RIGHT_TTL;
 496
 497         TAILQ_INIT(&mp->mnt_vnodelist);
 498         TAILQ_INIT(&mp->mnt_workerqueue);
 499         TAILQ_INIT(&mp->mnt_newvnodes);
 500         mp->mnt_flag = MNT_LOCAL;
 501         mp->mnt_lflag = MNT_LDEAD;
 502         mount_lock_init(mp);
 503
 504 #if CONFIG_MACF
 505         mac_mount_label_init(mp);
 506         mac_mount_label_associate(vfs_context_kernel(), mp);
 507 #endif
 508         dead_mountp = mp;
 509
 510 #if FS_COMPRESSION
 511         decmpfs_init();
 512 #endif
 513 }
 514
 515 void
 516 vnode_list_lock(void)
 517 {
 518         lck_spin_lock(vnode_list_spin_lock);
 519 }
 520
 521 void
 522 vnode_list_unlock(void)
 523 {
 524         lck_spin_unlock(vnode_list_spin_lock);
 525 }
 526
 527 void
 528 mount_list_lock(void)
 529 {
 530         lck_mtx_lock(mnt_list_mtx_lock);
 531 }
 532
 533 void
 534 mount_list_unlock(void)
 535 {
 536         lck_mtx_unlock(mnt_list_mtx_lock);
 537 }
 538
 539 void
 540 mount_lock_init(mount_t mp)
 541 {
 542         lck_mtx_init(&mp->mnt_mlock, mnt_lck_grp, mnt_lck_attr);
 543         lck_mtx_init(&mp->mnt_iter_lock, mnt_lck_grp, mnt_lck_attr);
 544         lck_mtx_init(&mp->mnt_renamelock, mnt_lck_grp, mnt_lck_attr);
 545         lck_rw_init(&mp->mnt_rwlock, mnt_lck_grp, mnt_lck_attr);
 546 }
 547
 548 void
 549 mount_lock_destroy(mount_t mp)
 550 {
 551         lck_mtx_destroy(&mp->mnt_mlock, mnt_lck_grp);
 552         lck_mtx_destroy(&mp->mnt_iter_lock, mnt_lck_grp);
 553         lck_mtx_destroy(&mp->mnt_renamelock, mnt_lck_grp);
 554         lck_rw_destroy(&mp->mnt_rwlock, mnt_lck_grp);
 555 }
 556
 557
 558 /*
 559  * Name:        vfstable_add
 560  *
 561  * Description: Add a filesystem to the vfsconf list at the first
 562  *              unused slot.  If no slots are available, return an
 563  *              error.
 564  *
 565  * Parameter:   nvfsp           vfsconf for VFS to add
 566  *
 567  * Returns:     0               Success
 568  *              -1              Failure
 569  *
 570  * Notes:       The vfsconf should be treated as a linked list by
 571  *              all external references, as the implementation is
 572  *              expected to change in the future.  The linkage is
 573  *              through ->vfc_next, and the list is NULL terminated.
 574  *
 575  * Warning:     This code assumes that vfsconf[0] is non-empty.
 576  */
 577 struct vfstable *
 578 vfstable_add(struct vfstable  *nvfsp)
 579 {
 580         int slot;
 581         struct vfstable *slotp, *allocated = NULL;
 582         struct sysctl_oid *oidp = NULL;
 583
 584
 585         if (nvfsp->vfc_vfsops->vfs_sysctl) {
 586                 struct sysctl_oid oid = SYSCTL_STRUCT_INIT(_vfs, nvfsp->vfc_typenum, , CTLTYPE_NODE | CTLFLAG_KERN | CTLFLAG_RW | CTLFLAG_LOCKED, NULL, 0, vfs_sysctl_node, "-", "");
 587
 588                 MALLOC(oidp, struct sysctl_oid *, sizeof(struct sysctl_oid), M_TEMP, M_WAITOK);
 589                 *oidp = oid;
 590         }
 591
 592         /*
 593          * Find the next empty slot; we recognize an empty slot by a
 594          * NULL-valued ->vfc_vfsops, so if we delete a VFS, we must
 595          * ensure we set the entry back to NULL.
 596          */
 597 findslot:
 598         mount_list_lock();
 599         for (slot = 0; slot < maxvfsslots; slot++) {
 600                 if (vfsconf[slot].vfc_vfsops == NULL)
 601                         break;
 602         }
 603         if (slot == maxvfsslots) {
 604                 if (allocated == NULL) {
 605                         mount_list_unlock();
 606                         /* out of static slots; allocate one instead */
 607                         MALLOC(allocated, struct vfstable *, sizeof(struct vfstable),
 608                                         M_TEMP, M_WAITOK);
 609                         goto findslot;
 610                 } else {
 611                         slotp = allocated;
 612                 }
 613         } else {
 614                 slotp = &vfsconf[slot];
 615         }
 616
 617         /*
 618          * Replace the contents of the next empty slot with the contents
 619          * of the provided nvfsp.
 620          *
 621          * Note; Takes advantage of the fact that 'slot' was left
 622          * with the value of 'maxvfslots' in the allocation case.
 623          */
 624         bcopy(nvfsp, slotp, sizeof(struct vfstable));
 625         if (slot != 0) {
 626                 slotp->vfc_next = vfsconf[slot - 1].vfc_next;
 627                 vfsconf[slot - 1].vfc_next = slotp;
 628         } else {
 629                 slotp->vfc_next = NULL;
 630         }
 631
 632         if (slotp != allocated) {
 633                 /* used a statically allocated slot */
 634                 numused_vfsslots++;
 635         }
 636         numregistered_fses++;
 637
 638         if (oidp) {
 639                 /* Memory freed in vfstable_del after unregistration */
 640                 slotp->vfc_sysctl = oidp;
 641                 oidp->oid_name = slotp->vfc_name;
 642                 sysctl_register_oid(slotp->vfc_sysctl);
 643         }
 644
 645         mount_list_unlock();
 646
 647         if (allocated && allocated != slotp) {
 648                 /* did allocation, but ended up using static slot */
 649                 FREE(allocated, M_TEMP);
 650         }
 651
 652         return(slotp);
 653 }
 654
 655 /*
 656  * Name:        vfstable_del
 657  *
 658  * Description: Remove a filesystem from the vfsconf list by name.
 659  *              If no such filesystem exists, return an error.
 660  *
 661  * Parameter:   fs_name         name of VFS to remove
 662  *
 663  * Returns:     0               Success
 664  *              -1              Failure
 665  *
 666  * Notes:       Hopefully all filesystems have unique names.
 667  */
 668 int
 669 vfstable_del(struct vfstable  * vtbl)
 670 {
 671         struct vfstable **vcpp;
 672         struct vfstable *vcdelp;
 673
 674 #if DEBUG
 675         lck_mtx_assert(mnt_list_mtx_lock, LCK_MTX_ASSERT_OWNED);
 676 #endif /* DEBUG */
 677
 678         /*
 679          * Traverse the list looking for vtbl; if found, *vcpp
 680          * will contain the address of the pointer to the entry to
 681          * be removed.
 682          */
 683         for( vcpp = &vfsconf; *vcpp; vcpp = &(*vcpp)->vfc_next) {
 684                 if (*vcpp == vtbl)
 685                         break;
 686         }
 687
 688         if (*vcpp == NULL)
 689            return(ESRCH);       /* vtbl not on vfsconf list */
 690
 691         if ((*vcpp)->vfc_sysctl) {
 692                 sysctl_unregister_oid((*vcpp)->vfc_sysctl);
 693                 (*vcpp)->vfc_sysctl->oid_name = NULL;
 694                 FREE((*vcpp)->vfc_sysctl, M_TEMP);
 695                 (*vcpp)->vfc_sysctl = NULL;
 696         }
 697
 698         /* Unlink entry */
 699         vcdelp = *vcpp;
 700         *vcpp = (*vcpp)->vfc_next;
 701
 702         /*
 703          * Is this an entry from our static table?  We find out by
 704          * seeing if the pointer to the object to be deleted places
 705          * the object in the address space containing the table (or not).
 706          */
 707         if (vcdelp >= vfsconf && vcdelp < (vfsconf + maxvfsslots)) {    /* Y */
 708                 /* Mark as empty for vfscon_add() */
 709                 bzero(vcdelp, sizeof(struct vfstable));
 710                 numregistered_fses--;
 711                 numused_vfsslots--;
 712         } else {                                                        /* N */
 713                 /*
 714                  * This entry was dynamically allocated; we must free it;
 715                  * we would prefer to have just linked the caller's
 716                  * vfsconf onto our list, but it may not be persistent
 717                  * because of the previous (copying) implementation.
 718                  */
 719                 numregistered_fses--;
 720                 mount_list_unlock();
 721                 FREE(vcdelp, M_TEMP);
 722                 mount_list_lock();
 723         }
 724
 725 #if DEBUG
 726         lck_mtx_assert(mnt_list_mtx_lock, LCK_MTX_ASSERT_OWNED);
 727 #endif /* DEBUG */
 728
 729         return(0);
 730 }
 731
 732 void
 733 SPECHASH_LOCK(void)
 734 {
 735         lck_mtx_lock(spechash_mtx_lock);
 736 }
 737
 738 void
 739 SPECHASH_UNLOCK(void)
 740 {
 741         lck_mtx_unlock(spechash_mtx_lock);
 742 }
 743