1 /*- 2 * Copyright (c) 2000,2004 3 * Poul-Henning Kamp. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Neither the name of the University nor the names of its contributors 11 * may be used to endorse or promote products derived from this software 12 * without specific prior written permission. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * From: FreeBSD: src/sys/miscfs/kernfs/kernfs_vfsops.c 1.36 27 * 28 * $FreeBSD$ 29 */ 30 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/conf.h> 34 #include <sys/dirent.h> 35 #include <sys/kernel.h> 36 #include <sys/limits.h> 37 #include <sys/lock.h> 38 #include <sys/malloc.h> 39 #include <sys/proc.h> 40 #include <sys/sx.h> 41 #include <sys/sysctl.h> 42 #include <sys/vnode.h> 43 44 #include <sys/kdb.h> 45 46 #include <fs/devfs/devfs.h> 47 #include <fs/devfs/devfs_int.h> 48 49 #include <security/mac/mac_framework.h> 50 51 /* 52 * The one true (but secret) list of active devices in the system. 53 * Locked by dev_lock()/devmtx 54 */ 55 struct cdev_priv_list cdevp_list = TAILQ_HEAD_INITIALIZER(cdevp_list); 56 57 struct unrhdr *devfs_inos; 58 59 60 static MALLOC_DEFINE(M_DEVFS2, "DEVFS2", "DEVFS data 2"); 61 static MALLOC_DEFINE(M_DEVFS3, "DEVFS3", "DEVFS data 3"); 62 static MALLOC_DEFINE(M_CDEVP, "DEVFS1", "DEVFS cdev_priv storage"); 63 64 static SYSCTL_NODE(_vfs, OID_AUTO, devfs, CTLFLAG_RW, 0, "DEVFS filesystem"); 65 66 static unsigned devfs_generation; 67 SYSCTL_UINT(_vfs_devfs, OID_AUTO, generation, CTLFLAG_RD, 68 &devfs_generation, 0, "DEVFS generation number"); 69 70 unsigned devfs_rule_depth = 1; 71 SYSCTL_UINT(_vfs_devfs, OID_AUTO, rule_depth, CTLFLAG_RW, 72 &devfs_rule_depth, 0, "Max depth of ruleset include"); 73 74 /* 75 * Helper sysctl for devname(3). We're given a dev_t and return the 76 * name, if any, registered by the device driver. 77 */ 78 static int 79 sysctl_devname(SYSCTL_HANDLER_ARGS) 80 { 81 int error; 82 dev_t ud; 83 struct cdev_priv *cdp; 84 struct cdev *dev; 85 86 error = SYSCTL_IN(req, &ud, sizeof (ud)); 87 if (error) 88 return (error); 89 if (ud == NODEV) 90 return (EINVAL); 91 dev = NULL; 92 dev_lock(); 93 TAILQ_FOREACH(cdp, &cdevp_list, cdp_list) 94 if (cdp->cdp_inode == ud) { 95 dev = &cdp->cdp_c; 96 dev_refl(dev); 97 break; 98 } 99 dev_unlock(); 100 if (dev == NULL) 101 return (ENOENT); 102 error = SYSCTL_OUT(req, dev->si_name, strlen(dev->si_name) + 1); 103 dev_rel(dev); 104 return (error); 105 } 106 107 SYSCTL_PROC(_kern, OID_AUTO, devname, 108 CTLTYPE_OPAQUE|CTLFLAG_RW|CTLFLAG_ANYBODY|CTLFLAG_MPSAFE, 109 NULL, 0, sysctl_devname, "", "devname(3) handler"); 110 111 SYSCTL_INT(_debug_sizeof, OID_AUTO, cdev, CTLFLAG_RD, 112 0, sizeof(struct cdev), "sizeof(struct cdev)"); 113 114 SYSCTL_INT(_debug_sizeof, OID_AUTO, cdev_priv, CTLFLAG_RD, 115 0, sizeof(struct cdev_priv), "sizeof(struct cdev_priv)"); 116 117 struct cdev * 118 devfs_alloc(int flags) 119 { 120 struct cdev_priv *cdp; 121 struct cdev *cdev; 122 struct timespec ts; 123 124 cdp = malloc(sizeof *cdp, M_CDEVP, M_USE_RESERVE | M_ZERO | 125 ((flags & MAKEDEV_NOWAIT) ? M_NOWAIT : M_WAITOK)); 126 if (cdp == NULL) 127 return (NULL); 128 129 cdp->cdp_dirents = &cdp->cdp_dirent0; 130 cdp->cdp_dirent0 = NULL; 131 cdp->cdp_maxdirent = 0; 132 cdp->cdp_inode = 0; 133 134 cdev = &cdp->cdp_c; 135 136 cdev->si_name = cdev->__si_namebuf; 137 LIST_INIT(&cdev->si_children); 138 vfs_timestamp(&ts); 139 cdev->si_atime = cdev->si_mtime = cdev->si_ctime = ts; 140 cdev->si_cred = NULL; 141 142 return (cdev); 143 } 144 145 void 146 devfs_free(struct cdev *cdev) 147 { 148 struct cdev_priv *cdp; 149 150 cdp = cdev2priv(cdev); 151 if (cdev->si_cred != NULL) 152 crfree(cdev->si_cred); 153 if (cdp->cdp_inode > 0) 154 free_unr(devfs_inos, cdp->cdp_inode); 155 if (cdp->cdp_maxdirent > 0) 156 free(cdp->cdp_dirents, M_DEVFS2); 157 free(cdp, M_CDEVP); 158 } 159 160 struct devfs_dirent * 161 devfs_find(struct devfs_dirent *dd, const char *name, int namelen, int type) 162 { 163 struct devfs_dirent *de; 164 165 TAILQ_FOREACH(de, &dd->de_dlist, de_list) { 166 if (namelen != de->de_dirent->d_namlen) 167 continue; 168 if (type != 0 && type != de->de_dirent->d_type) 169 continue; 170 if (bcmp(name, de->de_dirent->d_name, namelen) != 0) 171 continue; 172 break; 173 } 174 KASSERT(de == NULL || (de->de_flags & DE_DOOMED) == 0, 175 ("devfs_find: returning a doomed entry")); 176 return (de); 177 } 178 179 struct devfs_dirent * 180 devfs_newdirent(char *name, int namelen) 181 { 182 int i; 183 struct devfs_dirent *de; 184 struct dirent d; 185 186 d.d_namlen = namelen; 187 i = sizeof (*de) + GENERIC_DIRSIZ(&d); 188 de = malloc(i, M_DEVFS3, M_WAITOK | M_ZERO); 189 de->de_dirent = (struct dirent *)(de + 1); 190 de->de_dirent->d_namlen = namelen; 191 de->de_dirent->d_reclen = GENERIC_DIRSIZ(&d); 192 bcopy(name, de->de_dirent->d_name, namelen); 193 de->de_dirent->d_name[namelen] = '\0'; 194 vfs_timestamp(&de->de_ctime); 195 de->de_mtime = de->de_atime = de->de_ctime; 196 de->de_links = 1; 197 de->de_holdcnt = 1; 198 #ifdef MAC 199 mac_devfs_init(de); 200 #endif 201 return (de); 202 } 203 204 struct devfs_dirent * 205 devfs_parent_dirent(struct devfs_dirent *de) 206 { 207 208 if (de->de_dirent->d_type != DT_DIR) 209 return (de->de_dir); 210 211 if (de->de_flags & (DE_DOT | DE_DOTDOT)) 212 return (NULL); 213 214 de = TAILQ_FIRST(&de->de_dlist); /* "." */ 215 if (de == NULL) 216 return (NULL); 217 de = TAILQ_NEXT(de, de_list); /* ".." */ 218 if (de == NULL) 219 return (NULL); 220 221 return (de->de_dir); 222 } 223 224 struct devfs_dirent * 225 devfs_vmkdir(struct devfs_mount *dmp, char *name, int namelen, struct devfs_dirent *dotdot, u_int inode) 226 { 227 struct devfs_dirent *dd; 228 struct devfs_dirent *de; 229 230 /* Create the new directory */ 231 dd = devfs_newdirent(name, namelen); 232 TAILQ_INIT(&dd->de_dlist); 233 dd->de_dirent->d_type = DT_DIR; 234 dd->de_mode = 0555; 235 dd->de_links = 2; 236 dd->de_dir = dd; 237 if (inode != 0) 238 dd->de_inode = inode; 239 else 240 dd->de_inode = alloc_unr(devfs_inos); 241 242 /* 243 * "." and ".." are always the two first entries in the 244 * de_dlist list. 245 * 246 * Create the "." entry in the new directory. 247 */ 248 de = devfs_newdirent(".", 1); 249 de->de_dirent->d_type = DT_DIR; 250 de->de_flags |= DE_DOT; 251 TAILQ_INSERT_TAIL(&dd->de_dlist, de, de_list); 252 de->de_dir = dd; 253 254 /* Create the ".." entry in the new directory. */ 255 de = devfs_newdirent("..", 2); 256 de->de_dirent->d_type = DT_DIR; 257 de->de_flags |= DE_DOTDOT; 258 TAILQ_INSERT_TAIL(&dd->de_dlist, de, de_list); 259 if (dotdot == NULL) { 260 de->de_dir = dd; 261 } else { 262 de->de_dir = dotdot; 263 TAILQ_INSERT_TAIL(&dotdot->de_dlist, dd, de_list); 264 dotdot->de_links++; 265 } 266 267 #ifdef MAC 268 mac_devfs_create_directory(dmp->dm_mount, name, namelen, dd); 269 #endif 270 return (dd); 271 } 272 273 void 274 devfs_dirent_free(struct devfs_dirent *de) 275 { 276 free(de, M_DEVFS3); 277 } 278 279 /* 280 * Removes a directory if it is empty. Also empty parent directories are 281 * removed recursively. 282 */ 283 static void 284 devfs_rmdir_empty(struct devfs_mount *dm, struct devfs_dirent *de) 285 { 286 struct devfs_dirent *dd, *de_dot, *de_dotdot; 287 288 sx_assert(&dm->dm_lock, SX_XLOCKED); 289 290 for (;;) { 291 KASSERT(de->de_dirent->d_type == DT_DIR, 292 ("devfs_rmdir_empty: de is not a directory")); 293 294 if ((de->de_flags & DE_DOOMED) != 0 || de == dm->dm_rootdir) 295 return; 296 297 de_dot = TAILQ_FIRST(&de->de_dlist); 298 KASSERT(de_dot != NULL, ("devfs_rmdir_empty: . missing")); 299 de_dotdot = TAILQ_NEXT(de_dot, de_list); 300 KASSERT(de_dotdot != NULL, ("devfs_rmdir_empty: .. missing")); 301 /* Return if the directory is not empty. */ 302 if (TAILQ_NEXT(de_dotdot, de_list) != NULL) 303 return; 304 305 dd = devfs_parent_dirent(de); 306 KASSERT(dd != NULL, ("devfs_rmdir_empty: NULL dd")); 307 TAILQ_REMOVE(&de->de_dlist, de_dot, de_list); 308 TAILQ_REMOVE(&de->de_dlist, de_dotdot, de_list); 309 TAILQ_REMOVE(&dd->de_dlist, de, de_list); 310 DEVFS_DE_HOLD(dd); 311 devfs_delete(dm, de, DEVFS_DEL_NORECURSE); 312 devfs_delete(dm, de_dot, DEVFS_DEL_NORECURSE); 313 devfs_delete(dm, de_dotdot, DEVFS_DEL_NORECURSE); 314 if (DEVFS_DE_DROP(dd)) { 315 devfs_dirent_free(dd); 316 return; 317 } 318 319 de = dd; 320 } 321 } 322 323 /* 324 * The caller needs to hold the dm for the duration of the call since 325 * dm->dm_lock may be temporary dropped. 326 */ 327 void 328 devfs_delete(struct devfs_mount *dm, struct devfs_dirent *de, int flags) 329 { 330 struct devfs_dirent *dd; 331 struct vnode *vp; 332 333 KASSERT((de->de_flags & DE_DOOMED) == 0, 334 ("devfs_delete doomed dirent")); 335 de->de_flags |= DE_DOOMED; 336 337 if ((flags & DEVFS_DEL_NORECURSE) == 0) { 338 dd = devfs_parent_dirent(de); 339 if (dd != NULL) 340 DEVFS_DE_HOLD(dd); 341 } else 342 dd = NULL; 343 344 mtx_lock(&devfs_de_interlock); 345 vp = de->de_vnode; 346 if (vp != NULL) { 347 VI_LOCK(vp); 348 mtx_unlock(&devfs_de_interlock); 349 vholdl(vp); 350 sx_unlock(&dm->dm_lock); 351 if ((flags & DEVFS_DEL_VNLOCKED) == 0) 352 vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK | LK_RETRY); 353 else 354 VI_UNLOCK(vp); 355 vgone(vp); 356 if ((flags & DEVFS_DEL_VNLOCKED) == 0) 357 VOP_UNLOCK(vp, 0); 358 vdrop(vp); 359 sx_xlock(&dm->dm_lock); 360 } else 361 mtx_unlock(&devfs_de_interlock); 362 if (de->de_symlink) { 363 free(de->de_symlink, M_DEVFS); 364 de->de_symlink = NULL; 365 } 366 #ifdef MAC 367 mac_devfs_destroy(de); 368 #endif 369 if (de->de_inode > DEVFS_ROOTINO) { 370 free_unr(devfs_inos, de->de_inode); 371 de->de_inode = 0; 372 } 373 if (DEVFS_DE_DROP(de)) 374 devfs_dirent_free(de); 375 376 if (dd != NULL) { 377 if (DEVFS_DE_DROP(dd)) 378 devfs_dirent_free(dd); 379 else 380 devfs_rmdir_empty(dm, dd); 381 } 382 } 383 384 /* 385 * Called on unmount. 386 * Recursively removes the entire tree. 387 * The caller needs to hold the dm for the duration of the call. 388 */ 389 390 static void 391 devfs_purge(struct devfs_mount *dm, struct devfs_dirent *dd) 392 { 393 struct devfs_dirent *de; 394 395 sx_assert(&dm->dm_lock, SX_XLOCKED); 396 397 DEVFS_DE_HOLD(dd); 398 for (;;) { 399 de = TAILQ_FIRST(&dd->de_dlist); 400 if (de == NULL) 401 break; 402 TAILQ_REMOVE(&dd->de_dlist, de, de_list); 403 if (de->de_flags & (DE_DOT | DE_DOTDOT)) 404 devfs_delete(dm, de, DEVFS_DEL_NORECURSE); 405 else if (de->de_dirent->d_type == DT_DIR) 406 devfs_purge(dm, de); 407 else 408 devfs_delete(dm, de, DEVFS_DEL_NORECURSE); 409 } 410 if (DEVFS_DE_DROP(dd)) 411 devfs_dirent_free(dd); 412 else if ((dd->de_flags & DE_DOOMED) == 0) 413 devfs_delete(dm, dd, DEVFS_DEL_NORECURSE); 414 } 415 416 /* 417 * Each cdev_priv has an array of pointers to devfs_dirent which is indexed 418 * by the mount points dm_idx. 419 * This function extends the array when necessary, taking into account that 420 * the default array is 1 element and not malloc'ed. 421 */ 422 static void 423 devfs_metoo(struct cdev_priv *cdp, struct devfs_mount *dm) 424 { 425 struct devfs_dirent **dep; 426 int siz; 427 428 siz = (dm->dm_idx + 1) * sizeof *dep; 429 dep = malloc(siz, M_DEVFS2, M_WAITOK | M_ZERO); 430 dev_lock(); 431 if (dm->dm_idx <= cdp->cdp_maxdirent) { 432 /* We got raced */ 433 dev_unlock(); 434 free(dep, M_DEVFS2); 435 return; 436 } 437 memcpy(dep, cdp->cdp_dirents, (cdp->cdp_maxdirent + 1) * sizeof *dep); 438 if (cdp->cdp_maxdirent > 0) 439 free(cdp->cdp_dirents, M_DEVFS2); 440 cdp->cdp_dirents = dep; 441 /* 442 * XXX: if malloc told us how much we actually got this could 443 * XXX: be optimized. 444 */ 445 cdp->cdp_maxdirent = dm->dm_idx; 446 dev_unlock(); 447 } 448 449 /* 450 * The caller needs to hold the dm for the duration of the call. 451 */ 452 static int 453 devfs_populate_loop(struct devfs_mount *dm, int cleanup) 454 { 455 struct cdev_priv *cdp; 456 struct devfs_dirent *de; 457 struct devfs_dirent *dd; 458 struct cdev *pdev; 459 int de_flags, j; 460 char *q, *s; 461 462 sx_assert(&dm->dm_lock, SX_XLOCKED); 463 dev_lock(); 464 TAILQ_FOREACH(cdp, &cdevp_list, cdp_list) { 465 466 KASSERT(cdp->cdp_dirents != NULL, ("NULL cdp_dirents")); 467 468 /* 469 * If we are unmounting, or the device has been destroyed, 470 * clean up our dirent. 471 */ 472 if ((cleanup || !(cdp->cdp_flags & CDP_ACTIVE)) && 473 dm->dm_idx <= cdp->cdp_maxdirent && 474 cdp->cdp_dirents[dm->dm_idx] != NULL) { 475 de = cdp->cdp_dirents[dm->dm_idx]; 476 cdp->cdp_dirents[dm->dm_idx] = NULL; 477 KASSERT(cdp == de->de_cdp, 478 ("%s %d %s %p %p", __func__, __LINE__, 479 cdp->cdp_c.si_name, cdp, de->de_cdp)); 480 KASSERT(de->de_dir != NULL, ("Null de->de_dir")); 481 dev_unlock(); 482 483 TAILQ_REMOVE(&de->de_dir->de_dlist, de, de_list); 484 de->de_cdp = NULL; 485 de->de_inode = 0; 486 devfs_delete(dm, de, 0); 487 dev_lock(); 488 cdp->cdp_inuse--; 489 dev_unlock(); 490 return (1); 491 } 492 /* 493 * GC any lingering devices 494 */ 495 if (!(cdp->cdp_flags & CDP_ACTIVE)) { 496 if (cdp->cdp_inuse > 0) 497 continue; 498 TAILQ_REMOVE(&cdevp_list, cdp, cdp_list); 499 dev_unlock(); 500 dev_rel(&cdp->cdp_c); 501 return (1); 502 } 503 /* 504 * Don't create any new dirents if we are unmounting 505 */ 506 if (cleanup) 507 continue; 508 KASSERT((cdp->cdp_flags & CDP_ACTIVE), ("Bogons, I tell ya'!")); 509 510 if (dm->dm_idx <= cdp->cdp_maxdirent && 511 cdp->cdp_dirents[dm->dm_idx] != NULL) { 512 de = cdp->cdp_dirents[dm->dm_idx]; 513 KASSERT(cdp == de->de_cdp, ("inconsistent cdp")); 514 continue; 515 } 516 517 518 cdp->cdp_inuse++; 519 dev_unlock(); 520 521 if (dm->dm_idx > cdp->cdp_maxdirent) 522 devfs_metoo(cdp, dm); 523 524 dd = dm->dm_rootdir; 525 s = cdp->cdp_c.si_name; 526 for (;;) { 527 for (q = s; *q != '/' && *q != '\0'; q++) 528 continue; 529 if (*q != '/') 530 break; 531 de = devfs_find(dd, s, q - s, 0); 532 if (de == NULL) 533 de = devfs_vmkdir(dm, s, q - s, dd, 0); 534 else if (de->de_dirent->d_type == DT_LNK) { 535 de = devfs_find(dd, s, q - s, DT_DIR); 536 if (de == NULL) 537 de = devfs_vmkdir(dm, s, q - s, dd, 0); 538 de->de_flags |= DE_COVERED; 539 } 540 s = q + 1; 541 dd = de; 542 KASSERT(dd->de_dirent->d_type == DT_DIR && 543 (dd->de_flags & (DE_DOT | DE_DOTDOT)) == 0, 544 ("%s: invalid directory (si_name=%s)", 545 __func__, cdp->cdp_c.si_name)); 546 547 } 548 de_flags = 0; 549 de = devfs_find(dd, s, q - s, DT_LNK); 550 if (de != NULL) 551 de_flags |= DE_COVERED; 552 553 de = devfs_newdirent(s, q - s); 554 if (cdp->cdp_c.si_flags & SI_ALIAS) { 555 de->de_uid = 0; 556 de->de_gid = 0; 557 de->de_mode = 0755; 558 de->de_dirent->d_type = DT_LNK; 559 pdev = cdp->cdp_c.si_parent; 560 j = strlen(pdev->si_name) + 1; 561 de->de_symlink = malloc(j, M_DEVFS, M_WAITOK); 562 bcopy(pdev->si_name, de->de_symlink, j); 563 } else { 564 de->de_uid = cdp->cdp_c.si_uid; 565 de->de_gid = cdp->cdp_c.si_gid; 566 de->de_mode = cdp->cdp_c.si_mode; 567 de->de_dirent->d_type = DT_CHR; 568 } 569 de->de_flags |= de_flags; 570 de->de_inode = cdp->cdp_inode; 571 de->de_cdp = cdp; 572 #ifdef MAC 573 mac_devfs_create_device(cdp->cdp_c.si_cred, dm->dm_mount, 574 &cdp->cdp_c, de); 575 #endif 576 de->de_dir = dd; 577 TAILQ_INSERT_TAIL(&dd->de_dlist, de, de_list); 578 devfs_rules_apply(dm, de); 579 dev_lock(); 580 /* XXX: could check that cdp is still active here */ 581 KASSERT(cdp->cdp_dirents[dm->dm_idx] == NULL, 582 ("%s %d\n", __func__, __LINE__)); 583 cdp->cdp_dirents[dm->dm_idx] = de; 584 KASSERT(de->de_cdp != (void *)0xdeadc0de, 585 ("%s %d\n", __func__, __LINE__)); 586 dev_unlock(); 587 return (1); 588 } 589 dev_unlock(); 590 return (0); 591 } 592 593 /* 594 * The caller needs to hold the dm for the duration of the call. 595 */ 596 void 597 devfs_populate(struct devfs_mount *dm) 598 { 599 600 sx_assert(&dm->dm_lock, SX_XLOCKED); 601 if (dm->dm_generation == devfs_generation) 602 return; 603 while (devfs_populate_loop(dm, 0)) 604 continue; 605 dm->dm_generation = devfs_generation; 606 } 607 608 /* 609 * The caller needs to hold the dm for the duration of the call. 610 */ 611 void 612 devfs_cleanup(struct devfs_mount *dm) 613 { 614 615 sx_assert(&dm->dm_lock, SX_XLOCKED); 616 while (devfs_populate_loop(dm, 1)) 617 continue; 618 devfs_purge(dm, dm->dm_rootdir); 619 } 620 621 /* 622 * devfs_create() and devfs_destroy() are called from kern_conf.c and 623 * in both cases the devlock() mutex is held, so no further locking 624 * is necesary and no sleeping allowed. 625 */ 626 627 void 628 devfs_create(struct cdev *dev) 629 { 630 struct cdev_priv *cdp; 631 632 mtx_assert(&devmtx, MA_OWNED); 633 cdp = cdev2priv(dev); 634 cdp->cdp_flags |= CDP_ACTIVE; 635 cdp->cdp_inode = alloc_unrl(devfs_inos); 636 dev_refl(dev); 637 TAILQ_INSERT_TAIL(&cdevp_list, cdp, cdp_list); 638 devfs_generation++; 639 } 640 641 void 642 devfs_destroy(struct cdev *dev) 643 { 644 struct cdev_priv *cdp; 645 646 mtx_assert(&devmtx, MA_OWNED); 647 cdp = cdev2priv(dev); 648 cdp->cdp_flags &= ~CDP_ACTIVE; 649 devfs_generation++; 650 } 651 652 static void 653 devfs_devs_init(void *junk __unused) 654 { 655 656 devfs_inos = new_unrhdr(DEVFS_ROOTINO + 1, INT_MAX, &devmtx); 657 } 658 659 SYSINIT(devfs_devs, SI_SUB_DEVFS, SI_ORDER_FIRST, devfs_devs_init, NULL); 660