Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/fs/devfs/devfs_devs.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
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: releng/8.4/sys/fs/devfs/devfs_devs.c 224904 2011-08-16 08:41:09Z kib $ 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 struct cdev * and return 76 * the 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 85 error = SYSCTL_IN(req, &ud, sizeof (ud)); 86 if (error) 87 return (error); 88 if (ud == NODEV) 89 return(EINVAL); 90 /* 91 ud ^ devfs_random(); 92 */ 93 dev_lock(); 94 TAILQ_FOREACH(cdp, &cdevp_list, cdp_list) 95 if (cdp->cdp_inode == ud) 96 break; 97 dev_unlock(); 98 if (cdp == NULL) 99 return(ENOENT); 100 return(SYSCTL_OUT(req, cdp->cdp_c.si_name, strlen(cdp->cdp_c.si_name) + 1)); 101 return (error); 102 } 103 104 SYSCTL_PROC(_kern, OID_AUTO, devname, 105 CTLTYPE_OPAQUE|CTLFLAG_RW|CTLFLAG_ANYBODY|CTLFLAG_MPSAFE, 106 NULL, 0, sysctl_devname, "", "devname(3) handler"); 107 108 SYSCTL_INT(_debug_sizeof, OID_AUTO, cdev, CTLFLAG_RD, 109 0, sizeof(struct cdev), "sizeof(struct cdev)"); 110 111 SYSCTL_INT(_debug_sizeof, OID_AUTO, cdev_priv, CTLFLAG_RD, 112 0, sizeof(struct cdev_priv), "sizeof(struct cdev_priv)"); 113 114 struct cdev * 115 devfs_alloc(int flags) 116 { 117 struct cdev_priv *cdp; 118 struct cdev *cdev; 119 struct timespec ts; 120 121 cdp = malloc(sizeof *cdp, M_CDEVP, M_USE_RESERVE | M_ZERO | 122 ((flags & MAKEDEV_NOWAIT) ? M_NOWAIT : M_WAITOK)); 123 if (cdp == NULL) 124 return (NULL); 125 126 cdp->cdp_dirents = &cdp->cdp_dirent0; 127 cdp->cdp_dirent0 = NULL; 128 cdp->cdp_maxdirent = 0; 129 cdp->cdp_inode = 0; 130 131 cdev = &cdp->cdp_c; 132 133 cdev->si_name = cdev->__si_namebuf; 134 LIST_INIT(&cdev->si_children); 135 vfs_timestamp(&ts); 136 cdev->si_atime = cdev->si_mtime = cdev->si_ctime = ts; 137 cdev->si_cred = NULL; 138 139 return (cdev); 140 } 141 142 void 143 devfs_free(struct cdev *cdev) 144 { 145 struct cdev_priv *cdp; 146 147 cdp = cdev2priv(cdev); 148 if (cdev->si_cred != NULL) 149 crfree(cdev->si_cred); 150 if (cdp->cdp_inode > 0) 151 free_unr(devfs_inos, cdp->cdp_inode); 152 if (cdp->cdp_maxdirent > 0) 153 free(cdp->cdp_dirents, M_DEVFS2); 154 free(cdp, M_CDEVP); 155 } 156 157 struct devfs_dirent * 158 devfs_find(struct devfs_dirent *dd, const char *name, int namelen) 159 { 160 struct devfs_dirent *de; 161 162 TAILQ_FOREACH(de, &dd->de_dlist, de_list) { 163 if (namelen != de->de_dirent->d_namlen) 164 continue; 165 if (bcmp(name, de->de_dirent->d_name, namelen) != 0) 166 continue; 167 break; 168 } 169 return (de); 170 } 171 172 struct devfs_dirent * 173 devfs_newdirent(char *name, int namelen) 174 { 175 int i; 176 struct devfs_dirent *de; 177 struct dirent d; 178 179 d.d_namlen = namelen; 180 i = sizeof (*de) + GENERIC_DIRSIZ(&d); 181 de = malloc(i, M_DEVFS3, M_WAITOK | M_ZERO); 182 de->de_dirent = (struct dirent *)(de + 1); 183 de->de_dirent->d_namlen = namelen; 184 de->de_dirent->d_reclen = GENERIC_DIRSIZ(&d); 185 bcopy(name, de->de_dirent->d_name, namelen); 186 de->de_dirent->d_name[namelen] = '\0'; 187 vfs_timestamp(&de->de_ctime); 188 de->de_mtime = de->de_atime = de->de_ctime; 189 de->de_links = 1; 190 de->de_holdcnt = 1; 191 #ifdef MAC 192 mac_devfs_init(de); 193 #endif 194 return (de); 195 } 196 197 struct devfs_dirent * 198 devfs_parent_dirent(struct devfs_dirent *de) 199 { 200 201 if (de->de_dirent->d_type != DT_DIR) 202 return (de->de_dir); 203 204 if (de->de_flags & (DE_DOT | DE_DOTDOT)) 205 return (NULL); 206 207 de = TAILQ_FIRST(&de->de_dlist); /* "." */ 208 if (de == NULL) 209 return (NULL); 210 de = TAILQ_NEXT(de, de_list); /* ".." */ 211 if (de == NULL) 212 return (NULL); 213 214 return (de->de_dir); 215 } 216 217 struct devfs_dirent * 218 devfs_vmkdir(struct devfs_mount *dmp, char *name, int namelen, struct devfs_dirent *dotdot, u_int inode) 219 { 220 struct devfs_dirent *dd; 221 struct devfs_dirent *de; 222 223 /* Create the new directory */ 224 dd = devfs_newdirent(name, namelen); 225 TAILQ_INIT(&dd->de_dlist); 226 dd->de_dirent->d_type = DT_DIR; 227 dd->de_mode = 0555; 228 dd->de_links = 2; 229 dd->de_dir = dd; 230 if (inode != 0) 231 dd->de_inode = inode; 232 else 233 dd->de_inode = alloc_unr(devfs_inos); 234 235 /* Create the "." entry in the new directory */ 236 de = devfs_newdirent(".", 1); 237 de->de_dirent->d_type = DT_DIR; 238 de->de_flags |= DE_DOT; 239 TAILQ_INSERT_TAIL(&dd->de_dlist, de, de_list); 240 de->de_dir = dd; 241 242 /* Create the ".." entry in the new directory */ 243 de = devfs_newdirent("..", 2); 244 de->de_dirent->d_type = DT_DIR; 245 de->de_flags |= DE_DOTDOT; 246 TAILQ_INSERT_TAIL(&dd->de_dlist, de, de_list); 247 if (dotdot == NULL) { 248 de->de_dir = dd; 249 } else { 250 de->de_dir = dotdot; 251 sx_assert(&dmp->dm_lock, SX_XLOCKED); 252 TAILQ_INSERT_TAIL(&dotdot->de_dlist, dd, de_list); 253 dotdot->de_links++; 254 devfs_rules_apply(dmp, dd); 255 } 256 257 #ifdef MAC 258 mac_devfs_create_directory(dmp->dm_mount, name, namelen, dd); 259 #endif 260 return (dd); 261 } 262 263 void 264 devfs_dirent_free(struct devfs_dirent *de) 265 { 266 free(de, M_DEVFS3); 267 } 268 269 /* 270 * The caller needs to hold the dm for the duration of the call since 271 * dm->dm_lock may be temporary dropped. 272 */ 273 void 274 devfs_delete(struct devfs_mount *dm, struct devfs_dirent *de, int vp_locked) 275 { 276 struct vnode *vp; 277 278 KASSERT((de->de_flags & DE_DOOMED) == 0, 279 ("devfs_delete doomed dirent")); 280 de->de_flags |= DE_DOOMED; 281 mtx_lock(&devfs_de_interlock); 282 vp = de->de_vnode; 283 if (vp != NULL) { 284 VI_LOCK(vp); 285 mtx_unlock(&devfs_de_interlock); 286 vholdl(vp); 287 sx_unlock(&dm->dm_lock); 288 if (!vp_locked) 289 vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK | LK_RETRY); 290 else 291 VI_UNLOCK(vp); 292 vgone(vp); 293 if (!vp_locked) 294 VOP_UNLOCK(vp, 0); 295 vdrop(vp); 296 sx_xlock(&dm->dm_lock); 297 } else 298 mtx_unlock(&devfs_de_interlock); 299 if (de->de_symlink) { 300 free(de->de_symlink, M_DEVFS); 301 de->de_symlink = NULL; 302 } 303 #ifdef MAC 304 mac_devfs_destroy(de); 305 #endif 306 if (de->de_inode > DEVFS_ROOTINO) { 307 free_unr(devfs_inos, de->de_inode); 308 de->de_inode = 0; 309 } 310 if (DEVFS_DE_DROP(de)) 311 devfs_dirent_free(de); 312 } 313 314 /* 315 * Called on unmount. 316 * Recursively removes the entire tree. 317 * The caller needs to hold the dm for the duration of the call. 318 */ 319 320 static void 321 devfs_purge(struct devfs_mount *dm, struct devfs_dirent *dd) 322 { 323 struct devfs_dirent *de; 324 325 sx_assert(&dm->dm_lock, SX_XLOCKED); 326 for (;;) { 327 de = TAILQ_FIRST(&dd->de_dlist); 328 if (de == NULL) 329 break; 330 TAILQ_REMOVE(&dd->de_dlist, de, de_list); 331 if (de->de_flags & (DE_DOT|DE_DOTDOT)) 332 devfs_delete(dm, de, 0); 333 else if (de->de_dirent->d_type == DT_DIR) 334 devfs_purge(dm, de); 335 else 336 devfs_delete(dm, de, 0); 337 } 338 devfs_delete(dm, dd, 0); 339 } 340 341 /* 342 * Each cdev_priv has an array of pointers to devfs_dirent which is indexed 343 * by the mount points dm_idx. 344 * This function extends the array when necessary, taking into account that 345 * the default array is 1 element and not malloc'ed. 346 */ 347 static void 348 devfs_metoo(struct cdev_priv *cdp, struct devfs_mount *dm) 349 { 350 struct devfs_dirent **dep; 351 int siz; 352 353 siz = (dm->dm_idx + 1) * sizeof *dep; 354 dep = malloc(siz, M_DEVFS2, M_WAITOK | M_ZERO); 355 dev_lock(); 356 if (dm->dm_idx <= cdp->cdp_maxdirent) { 357 /* We got raced */ 358 dev_unlock(); 359 free(dep, M_DEVFS2); 360 return; 361 } 362 memcpy(dep, cdp->cdp_dirents, (cdp->cdp_maxdirent + 1) * sizeof *dep); 363 if (cdp->cdp_maxdirent > 0) 364 free(cdp->cdp_dirents, M_DEVFS2); 365 cdp->cdp_dirents = dep; 366 /* 367 * XXX: if malloc told us how much we actually got this could 368 * XXX: be optimized. 369 */ 370 cdp->cdp_maxdirent = dm->dm_idx; 371 dev_unlock(); 372 } 373 374 /* 375 * The caller needs to hold the dm for the duration of the call. 376 */ 377 static int 378 devfs_populate_loop(struct devfs_mount *dm, int cleanup) 379 { 380 struct cdev_priv *cdp; 381 struct devfs_dirent *de; 382 struct devfs_dirent *dd; 383 struct cdev *pdev; 384 int j; 385 char *q, *s; 386 387 sx_assert(&dm->dm_lock, SX_XLOCKED); 388 dev_lock(); 389 TAILQ_FOREACH(cdp, &cdevp_list, cdp_list) { 390 391 KASSERT(cdp->cdp_dirents != NULL, ("NULL cdp_dirents")); 392 393 /* 394 * If we are unmounting, or the device has been destroyed, 395 * clean up our dirent. 396 */ 397 if ((cleanup || !(cdp->cdp_flags & CDP_ACTIVE)) && 398 dm->dm_idx <= cdp->cdp_maxdirent && 399 cdp->cdp_dirents[dm->dm_idx] != NULL) { 400 de = cdp->cdp_dirents[dm->dm_idx]; 401 cdp->cdp_dirents[dm->dm_idx] = NULL; 402 KASSERT(cdp == de->de_cdp, 403 ("%s %d %s %p %p", __func__, __LINE__, 404 cdp->cdp_c.si_name, cdp, de->de_cdp)); 405 KASSERT(de->de_dir != NULL, ("Null de->de_dir")); 406 dev_unlock(); 407 408 TAILQ_REMOVE(&de->de_dir->de_dlist, de, de_list); 409 de->de_cdp = NULL; 410 de->de_inode = 0; 411 devfs_delete(dm, de, 0); 412 dev_lock(); 413 cdp->cdp_inuse--; 414 dev_unlock(); 415 return (1); 416 } 417 /* 418 * GC any lingering devices 419 */ 420 if (!(cdp->cdp_flags & CDP_ACTIVE)) { 421 if (cdp->cdp_inuse > 0) 422 continue; 423 TAILQ_REMOVE(&cdevp_list, cdp, cdp_list); 424 dev_unlock(); 425 dev_rel(&cdp->cdp_c); 426 return (1); 427 } 428 /* 429 * Don't create any new dirents if we are unmounting 430 */ 431 if (cleanup) 432 continue; 433 KASSERT((cdp->cdp_flags & CDP_ACTIVE), ("Bogons, I tell ya'!")); 434 435 if (dm->dm_idx <= cdp->cdp_maxdirent && 436 cdp->cdp_dirents[dm->dm_idx] != NULL) { 437 de = cdp->cdp_dirents[dm->dm_idx]; 438 KASSERT(cdp == de->de_cdp, ("inconsistent cdp")); 439 continue; 440 } 441 442 443 cdp->cdp_inuse++; 444 dev_unlock(); 445 446 if (dm->dm_idx > cdp->cdp_maxdirent) 447 devfs_metoo(cdp, dm); 448 449 dd = dm->dm_rootdir; 450 s = cdp->cdp_c.si_name; 451 for (;;) { 452 for (q = s; *q != '/' && *q != '\0'; q++) 453 continue; 454 if (*q != '/') 455 break; 456 de = devfs_find(dd, s, q - s); 457 if (de == NULL) 458 de = devfs_vmkdir(dm, s, q - s, dd, 0); 459 s = q + 1; 460 dd = de; 461 } 462 463 de = devfs_newdirent(s, q - s); 464 if (cdp->cdp_c.si_flags & SI_ALIAS) { 465 de->de_uid = 0; 466 de->de_gid = 0; 467 de->de_mode = 0755; 468 de->de_dirent->d_type = DT_LNK; 469 pdev = cdp->cdp_c.si_parent; 470 j = strlen(pdev->si_name) + 1; 471 de->de_symlink = malloc(j, M_DEVFS, M_WAITOK); 472 bcopy(pdev->si_name, de->de_symlink, j); 473 } else { 474 de->de_uid = cdp->cdp_c.si_uid; 475 de->de_gid = cdp->cdp_c.si_gid; 476 de->de_mode = cdp->cdp_c.si_mode; 477 de->de_dirent->d_type = DT_CHR; 478 } 479 de->de_inode = cdp->cdp_inode; 480 de->de_cdp = cdp; 481 #ifdef MAC 482 mac_devfs_create_device(cdp->cdp_c.si_cred, dm->dm_mount, 483 &cdp->cdp_c, de); 484 #endif 485 de->de_dir = dd; 486 TAILQ_INSERT_TAIL(&dd->de_dlist, de, de_list); 487 devfs_rules_apply(dm, de); 488 dev_lock(); 489 /* XXX: could check that cdp is still active here */ 490 KASSERT(cdp->cdp_dirents[dm->dm_idx] == NULL, 491 ("%s %d\n", __func__, __LINE__)); 492 cdp->cdp_dirents[dm->dm_idx] = de; 493 KASSERT(de->de_cdp != (void *)0xdeadc0de, 494 ("%s %d\n", __func__, __LINE__)); 495 dev_unlock(); 496 return (1); 497 } 498 dev_unlock(); 499 return (0); 500 } 501 502 /* 503 * The caller needs to hold the dm for the duration of the call. 504 */ 505 void 506 devfs_populate(struct devfs_mount *dm) 507 { 508 unsigned gen; 509 510 sx_assert(&dm->dm_lock, SX_XLOCKED); 511 gen = devfs_generation; 512 if (dm->dm_generation == gen) 513 return; 514 while (devfs_populate_loop(dm, 0)) 515 continue; 516 dm->dm_generation = gen; 517 } 518 519 /* 520 * The caller needs to hold the dm for the duration of the call. 521 */ 522 void 523 devfs_cleanup(struct devfs_mount *dm) 524 { 525 526 sx_assert(&dm->dm_lock, SX_XLOCKED); 527 while (devfs_populate_loop(dm, 1)) 528 continue; 529 devfs_purge(dm, dm->dm_rootdir); 530 } 531 532 /* 533 * devfs_create() and devfs_destroy() are called from kern_conf.c and 534 * in both cases the devlock() mutex is held, so no further locking 535 * is necesary and no sleeping allowed. 536 */ 537 538 void 539 devfs_create(struct cdev *dev) 540 { 541 struct cdev_priv *cdp; 542 543 mtx_assert(&devmtx, MA_OWNED); 544 cdp = cdev2priv(dev); 545 cdp->cdp_flags |= CDP_ACTIVE; 546 cdp->cdp_inode = alloc_unrl(devfs_inos); 547 dev_refl(dev); 548 TAILQ_INSERT_TAIL(&cdevp_list, cdp, cdp_list); 549 devfs_generation++; 550 } 551 552 void 553 devfs_destroy(struct cdev *dev) 554 { 555 struct cdev_priv *cdp; 556 557 mtx_assert(&devmtx, MA_OWNED); 558 cdp = cdev2priv(dev); 559 cdp->cdp_flags &= ~CDP_ACTIVE; 560 devfs_generation++; 561 } 562 563 static void 564 devfs_devs_init(void *junk __unused) 565 { 566 567 devfs_inos = new_unrhdr(DEVFS_ROOTINO + 1, INT_MAX, &devmtx); 568 } 569 570 SYSINIT(devfs_devs, SI_SUB_DEVFS, SI_ORDER_FIRST, devfs_devs_init, NULL);
Cache object: 17f209742413e900867a9b36f66a06ab
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]