![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to devfs_tree.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / miscfs / devfs|
Return to devfs_tree.c CVS log | Up to [Apple XNU] / XNU / bsd / miscfs / devfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: ! 23: /* ! 24: * Copyright 1997,1998 Julian Elischer. All rights reserved. ! 25: * [email protected] ! 26: * ! 27: * Redistribution and use in source and binary forms, with or without ! 28: * modification, are permitted provided that the following conditions are ! 29: * met: ! 30: * 1. Redistributions of source code must retain the above copyright ! 31: * notice, this list of conditions and the following disclaimer. ! 32: * 2. Redistributions in binary form must reproduce the above copyright notice, ! 33: * this list of conditions and the following disclaimer in the documentation ! 34: * and/or other materials provided with the distribution. ! 35: * ! 36: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS ! 37: * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ! 38: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE ! 39: * DISCLAIMED. IN NO EVENT SHALL THE HOLDER OR CONTRIBUTORS BE LIABLE FOR ! 40: * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 41: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR ! 42: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER ! 43: * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 44: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 45: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 46: * SUCH DAMAGE. ! 47: * ! 48: * devfs_tree.c ! 49: */ ! 50: ! 51: /* ! 52: * HISTORY ! 53: * Dieter Siegmund ([email protected]) Thu Apr 8 14:08:19 PDT 1999 ! 54: * - removed mounting of "hidden" mountpoint ! 55: * - fixed problem in which devnode->dn_vn pointer was not ! 56: * updated with the vnode returned from checkalias() ! 57: * - replaced devfs_vntodn() with a macro VTODN() ! 58: * - rewrote dev_finddir() to not use recursion ! 59: * - added locking to avoid data structure corruption (DEVFS_(UN)LOCK()) ! 60: * Dieter Siegmund ([email protected]) Wed Jul 14 13:37:59 PDT 1999 ! 61: * - fixed problem with devfs_dntovn() checking the v_id against the ! 62: * value cached in the device node; a union mount on top of us causes ! 63: * the v_id to get incremented thus, we would end up returning a new ! 64: * vnode instead of the existing one that has the mounted_here ! 65: * field filled in; the net effect was that the filesystem mounted ! 66: * on top of us would never show up ! 67: * - added devfs_stats to store how many data structures are actually ! 68: * allocated ! 69: */ ! 70: ! 71: /* SPLIT_DEVS means each devfs uses a different devnode for the same device */ ! 72: /* Otherwise the same device always ends up at the same vnode even if */ ! 73: /* reached througgh a different devfs instance. The practical difference */ ! 74: /* is that with the same vnode, chmods and chowns show up on all instances of */ ! 75: /* a device. (etc) */ ! 76: ! 77: #define SPLIT_DEVS 1 /* maybe make this an option */ ! 78: /*#define SPLIT_DEVS 1*/ ! 79: ! 80: #include <sys/param.h> ! 81: #include <sys/systm.h> ! 82: #include <sys/kernel.h> ! 83: #include <sys/conf.h> ! 84: #include <sys/malloc.h> ! 85: #include <sys/mount.h> ! 86: #include <sys/proc.h> ! 87: #include <sys/vnode.h> ! 88: #include <stdarg.h> ! 89: ! 90: #include "devfs.h" ! 91: #include "devfsdefs.h" ! 92: ! 93: struct lock__bsd__ devfs_lock; /* the "big switch" */ ! 94: devdirent_t * dev_root = NULL; /* root of backing tree */ ! 95: struct devfs_stats devfs_stats; /* hold stats */ ! 96: ! 97: #ifdef HIDDEN_MOUNTPOINT ! 98: static struct mount *devfs_hidden_mount; ! 99: #endif HIDDEN_MOINTPOINT ! 100: ! 101: static int devfs_ready = 0; ! 102: ! 103: #define NOCREATE FALSE ! 104: #define CREATE TRUE ! 105: ! 106: /* ! 107: * Set up the root directory node in the backing plane ! 108: * This is happenning before the vfs system has been ! 109: * set up yet, so be careful about what we reference.. ! 110: * Notice that the ops are by indirection.. as they haven't ! 111: * been set up yet! ! 112: * DEVFS has a hidden mountpoint that is used as the anchor point ! 113: * for the internal 'blueprint' version of the dev filesystem tree. ! 114: */ ! 115: /*proto*/ ! 116: int ! 117: devfs_sinit(void) ! 118: { ! 119: lockinit(&devfs_lock, PINOD, "devfs", 0, 0); ! 120: if (dev_add_entry("root", NULL, DEV_DIR, NULL, NULL, NULL, ! 121: &dev_root)) { ! 122: printf("devfs_sinit: dev_add_entry failed "); ! 123: return (EOPNOTSUPP); ! 124: } ! 125: #ifdef HIDDEN_MOUNTPOINT ! 126: MALLOC(devfs_hidden_mount, struct mount *, sizeof(struct mount), ! 127: M_MOUNT, M_NOWAIT); ! 128: bzero(devfs_hidden_mount,sizeof(struct mount)); ! 129: devfs_mount(devfs_hidden_mount,"dummy",NULL,NULL,NULL); ! 130: dev_root->de_dnp->dn_dvm ! 131: = (struct devfsmount *)devfs_hidden_mount->mnt_data; ! 132: #endif HIDDEN_MOUNTPOINT ! 133: devfs_ready = 1; ! 134: return (0); ! 135: } ! 136: ! 137: /***********************************************************************\ ! 138: ************************************************************************* ! 139: * Routines used to find our way to a point in the tree * ! 140: ************************************************************************* ! 141: \***********************************************************************/ ! 142: ! 143: ! 144: /***************************************************************\ ! 145: * Search down the linked list off a dir to find "name" * ! 146: * return the devnode_t * for that node. ! 147: \***************************************************************/ ! 148: /*proto*/ ! 149: devdirent_t * ! 150: dev_findname(devnode_t * dir,char *name) ! 151: { ! 152: devdirent_t * newfp; ! 153: if (dir->dn_type != DEV_DIR) return 0;/*XXX*/ /* printf?*/ ! 154: ! 155: if (name[0] == '.') ! 156: { ! 157: if(name[1] == 0) ! 158: { ! 159: return dir->dn_typeinfo.Dir.myname; ! 160: } ! 161: if((name[1] == '.') && (name[2] == 0)) ! 162: { ! 163: /* for root, .. == . */ ! 164: return dir->dn_typeinfo.Dir.parent->dn_typeinfo.Dir.myname; ! 165: } ! 166: } ! 167: newfp = dir->dn_typeinfo.Dir.dirlist; ! 168: while(newfp) ! 169: { ! 170: if(!(strcmp(name,newfp->de_name))) ! 171: return newfp; ! 172: newfp = newfp->de_next; ! 173: } ! 174: return NULL; ! 175: } ! 176: ! 177: #if 0 ! 178: /***********************************************************************\ ! 179: * Given a starting node (0 for root) and a pathname, return the node * ! 180: * for the end item on the path. It MUST BE A DIRECTORY. If the 'CREATE' * ! 181: * option is true, then create any missing nodes in the path and create * ! 182: * and return the final node as well. * ! 183: * This is used to set up a directory, before making nodes in it.. * ! 184: * * ! 185: * Warning: This function is RECURSIVE. * ! 186: \***********************************************************************/ ! 187: int ! 188: dev_finddir(char * orig_path, /* find this dir (err if not dir) */ ! 189: devnode_t * dirnode, /* starting point */ ! 190: int create, /* create path? */ ! 191: devnode_t * * dn_pp) /* returned */ ! 192: { ! 193: devdirent_t * dirent_p; ! 194: devnode_t * dnp = NULL; ! 195: char pathbuf[DEVMAXPATHSIZE]; ! 196: char *path; ! 197: char *name; ! 198: register char *cp; ! 199: int retval; ! 200: ! 201: ! 202: /***************************************\ ! 203: * If no parent directory is given * ! 204: * then start at the root of the tree * ! 205: \***************************************/ ! 206: if(!dirnode) dirnode = dev_root->de_dnp; ! 207: ! 208: /***************************************\ ! 209: * Sanity Checks * ! 210: \***************************************/ ! 211: if (dirnode->dn_type != DEV_DIR) return ENOTDIR; ! 212: if(strlen(orig_path) > (DEVMAXPATHSIZE - 1)) return ENAMETOOLONG; ! 213: ! 214: ! 215: path = pathbuf; ! 216: strcpy(path,orig_path); ! 217: ! 218: /***************************************\ ! 219: * always absolute, skip leading / * ! 220: * get rid of / or // or /// etc. * ! 221: \***************************************/ ! 222: while(*path == '/') path++; ! 223: ! 224: /***************************************\ ! 225: * If nothing left, then parent was it.. * ! 226: \***************************************/ ! 227: if ( *path == '\0' ) { ! 228: *dn_pp = dirnode; ! 229: return 0; ! 230: } ! 231: ! 232: /***************************************\ ! 233: * find the next segment of the name * ! 234: \***************************************/ ! 235: cp = name = path; ! 236: while((*cp != '/') && (*cp != 0)) { ! 237: cp++; ! 238: } ! 239: ! 240: /***********************************************\ ! 241: * Check to see if it's the last component * ! 242: \***********************************************/ ! 243: if(*cp) { ! 244: path = cp + 1; /* path refers to the rest */ ! 245: *cp = 0; /* name is now a separate string */ ! 246: if(!(*path)) { ! 247: path = (char *)0; /* was trailing slash */ ! 248: } ! 249: } else { ! 250: path = NULL; /* no more to do */ ! 251: } ! 252: ! 253: /***************************************\ ! 254: * Start scanning along the linked list * ! 255: \***************************************/ ! 256: dirent_p = dev_findname(dirnode,name); ! 257: if(dirent_p) { /* check it's a directory */ ! 258: dnp = dirent_p->de_dnp; ! 259: if(dnp->dn_type != DEV_DIR) return ENOTDIR; ! 260: } else { ! 261: /***************************************\ ! 262: * The required element does not exist * ! 263: * So we will add it if asked to. * ! 264: \***************************************/ ! 265: if(!create) return ENOENT; ! 266: ! 267: if((retval = dev_add_entry(name, dirnode, ! 268: DEV_DIR, NULL, NULL, NULL, ! 269: &dirent_p)) != 0) { ! 270: return retval; ! 271: } ! 272: dnp = dirent_p->de_dnp; ! 273: devfs_propogate(dirnode->dn_typeinfo.Dir.myname,dirent_p); ! 274: } ! 275: if(path != NULL) { /* decide whether to recurse more or return */ ! 276: return (dev_finddir(path,dnp,create,dn_pp)); ! 277: } else { ! 278: *dn_pp = dnp; ! 279: return 0; ! 280: } ! 281: } ! 282: #endif 0 ! 283: /***********************************************************************\ ! 284: * Given a starting node (0 for root) and a pathname, return the node * ! 285: * for the end item on the path. It MUST BE A DIRECTORY. If the 'CREATE' * ! 286: * option is true, then create any missing nodes in the path and create * ! 287: * and return the final node as well. * ! 288: * This is used to set up a directory, before making nodes in it.. * ! 289: \***********************************************************************/ ! 290: /* proto */ ! 291: int ! 292: dev_finddir(char * path, ! 293: devnode_t * dirnode, ! 294: int create, ! 295: devnode_t * * dn_pp) ! 296: { ! 297: devnode_t * dnp = NULL; ! 298: int error = 0; ! 299: char * scan; ! 300: ! 301: ! 302: if (!dirnode) /* dirnode == NULL means start at root */ ! 303: dirnode = dev_root->de_dnp; ! 304: ! 305: if (dirnode->dn_type != DEV_DIR) ! 306: return ENOTDIR; ! 307: ! 308: if (strlen(path) > (DEVMAXPATHSIZE - 1)) ! 309: return ENAMETOOLONG; ! 310: ! 311: scan = path; ! 312: ! 313: while (*scan == '/') ! 314: scan++; ! 315: ! 316: *dn_pp = NULL; ! 317: ! 318: while (1) { ! 319: char component[DEVMAXPATHSIZE]; ! 320: devdirent_t * dirent_p; ! 321: char * start; ! 322: ! 323: if (*scan == 0) { ! 324: /* we hit the end of the string, we're done */ ! 325: *dn_pp = dirnode; ! 326: break; ! 327: } ! 328: start = scan; ! 329: while (*scan != '/' && *scan) ! 330: scan++; ! 331: ! 332: strncpy(component, start, scan - start); ! 333: if (*scan == '/') ! 334: scan++; ! 335: ! 336: dirent_p = dev_findname(dirnode, component); ! 337: if (dirent_p) { ! 338: dnp = dirent_p->de_dnp; ! 339: if (dnp->dn_type != DEV_DIR) { ! 340: error = ENOTDIR; ! 341: break; ! 342: } ! 343: } ! 344: else { ! 345: if (!create) { ! 346: error = ENOENT; ! 347: break; ! 348: } ! 349: error = dev_add_entry(component, dirnode, ! 350: DEV_DIR, NULL, NULL, NULL, &dirent_p); ! 351: if (error) ! 352: break; ! 353: dnp = dirent_p->de_dnp; ! 354: devfs_propogate(dirnode->dn_typeinfo.Dir.myname, dirent_p); ! 355: } ! 356: dirnode = dnp; /* continue relative to this directory */ ! 357: } ! 358: return (error); ! 359: } ! 360: ! 361: ! 362: /***********************************************************************\ ! 363: * Add a new NAME element to the devfs * ! 364: * If we're creating a root node, then dirname is NULL * ! 365: * Basically this creates a new namespace entry for the device node * ! 366: * * ! 367: * Creates a name node, and links it to the supplied node * ! 368: \***********************************************************************/ ! 369: /*proto*/ ! 370: int ! 371: dev_add_name(char * name, devnode_t * dirnode, devdirent_t * back, ! 372: devnode_t * dnp, devdirent_t * *dirent_pp) ! 373: { ! 374: devdirent_t * dirent_p = NULL; ! 375: ! 376: if(dirnode != NULL ) { ! 377: if(dirnode->dn_type != DEV_DIR) return(ENOTDIR); ! 378: ! 379: if( dev_findname(dirnode,name)) ! 380: return(EEXIST); ! 381: } ! 382: /* ! 383: * make sure the name is legal ! 384: * slightly misleading in the case of NULL ! 385: */ ! 386: if (!name || (strlen(name) > (DEVMAXNAMESIZE - 1))) ! 387: return (ENAMETOOLONG); ! 388: ! 389: /* ! 390: * Allocate and fill out a new directory entry ! 391: */ ! 392: MALLOC(dirent_p, devdirent_t *, sizeof(devdirent_t), ! 393: M_DEVFSNAME, M_NOWAIT); ! 394: if (!dirent_p) { ! 395: return ENOMEM; ! 396: } ! 397: bzero(dirent_p,sizeof(devdirent_t)); ! 398: ! 399: /* inherrit our parent's mount info */ /*XXX*/ ! 400: /* a kludge but.... */ ! 401: if(dirnode && ( dnp->dn_dvm == NULL)) { ! 402: dnp->dn_dvm = dirnode->dn_dvm; ! 403: /* if(!dnp->dn_dvm) printf("parent had null dvm "); */ ! 404: } ! 405: ! 406: /* ! 407: * Link the two together ! 408: * include the implicit link in the count of links to the devnode.. ! 409: * this stops it from being accidentally freed later. ! 410: */ ! 411: dirent_p->de_dnp = dnp; ! 412: dnp->dn_links++ ; /* implicit from our own name-node */ ! 413: ! 414: /* ! 415: * Make sure that we can find all the links that reference a node ! 416: * so that we can get them all if we need to zap the node. ! 417: */ ! 418: if(dnp->dn_linklist) { ! 419: dirent_p->de_nextlink = dnp->dn_linklist; ! 420: dirent_p->de_prevlinkp = dirent_p->de_nextlink->de_prevlinkp; ! 421: dirent_p->de_nextlink->de_prevlinkp = &(dirent_p->de_nextlink); ! 422: *dirent_p->de_prevlinkp = dirent_p; ! 423: } else { ! 424: dirent_p->de_nextlink = dirent_p; ! 425: dirent_p->de_prevlinkp = &(dirent_p->de_nextlink); ! 426: } ! 427: dnp->dn_linklist = dirent_p; ! 428: ! 429: /* ! 430: * If the node is a directory, then we need to handle the ! 431: * creation of the .. link. ! 432: * A NULL dirnode indicates a root node, so point to ourself. ! 433: */ ! 434: if(dnp->dn_type == DEV_DIR) { ! 435: dnp->dn_typeinfo.Dir.myname = dirent_p; ! 436: /* ! 437: * If we are unlinking from an old dir, decrement its links ! 438: * as we point our '..' elsewhere ! 439: * Note: it's up to the calling code to remove the ! 440: * us from the original directory's list ! 441: */ ! 442: if(dnp->dn_typeinfo.Dir.parent) { ! 443: dnp->dn_typeinfo.Dir.parent->dn_links--; ! 444: } ! 445: if(dirnode) { ! 446: dnp->dn_typeinfo.Dir.parent = dirnode; ! 447: } else { ! 448: dnp->dn_typeinfo.Dir.parent = dnp; ! 449: } ! 450: dnp->dn_typeinfo.Dir.parent->dn_links++; /* account for the new '..' */ ! 451: } ! 452: ! 453: /* ! 454: * put the name into the directory entry. ! 455: */ ! 456: strcpy(dirent_p->de_name, name); ! 457: ! 458: ! 459: /* ! 460: * Check if we are not making a root node.. ! 461: * (i.e. have parent) ! 462: */ ! 463: if(dirnode) { ! 464: /* ! 465: * Put it on the END of the linked list of directory entries ! 466: */ ! 467: int len; ! 468: ! 469: dirent_p->de_parent = dirnode; /* null for root */ ! 470: dirent_p->de_prevp = dirnode->dn_typeinfo.Dir.dirlast; ! 471: dirent_p->de_next = *(dirent_p->de_prevp); /* should be NULL */ ! 472: /*right?*/ ! 473: *(dirent_p->de_prevp) = dirent_p; ! 474: dirnode->dn_typeinfo.Dir.dirlast = &(dirent_p->de_next); ! 475: dirnode->dn_typeinfo.Dir.entrycount++; ! 476: dirnode->dn_len += strlen(name) + 8;/*ok, ok?*/ ! 477: } ! 478: ! 479: *dirent_pp = dirent_p; ! 480: DEVFS_INCR_ENTRIES(); ! 481: return 0 ; ! 482: } ! 483: ! 484: ! 485: /***********************************************************************\ ! 486: * Add a new element to the devfs plane. * ! 487: * * ! 488: * Creates a new dev_node to go with it if the prototype should not be * ! 489: * reused. (Is a DIR, or we select SPLIT_DEVS at compile time) * ! 490: * typeinfo gives us info to make our node if we don't have a prototype. * ! 491: * If typeinfo is null and proto exists, then the typeinfo field of * ! 492: * the proto is used intead in the CREATE case. * ! 493: * note the 'links' count is 0 (except if a dir) * ! 494: * but it is only cleared on a transition * ! 495: * so this is ok till we link it to something * ! 496: * Even in SPLIT_DEVS mode, * ! 497: * if the node already exists on the wanted plane, just return it * ! 498: \***********************************************************************/ ! 499: /*proto*/ ! 500: int ! 501: dev_add_node(int entrytype, devnode_type_t * typeinfo, devnode_t * proto, ! 502: devnode_t * *dn_pp, struct devfsmount *dvm) ! 503: { ! 504: devnode_t * dnp = NULL; ! 505: ! 506: #if defined SPLIT_DEVS ! 507: /* ! 508: * If we have a prototype, then check if there is already a sibling ! 509: * on the mount plane we are looking at, if so, just return it. ! 510: */ ! 511: if (proto) { ! 512: dnp = proto->dn_nextsibling; ! 513: while( dnp != proto) { ! 514: if (dnp->dn_dvm == dvm) { ! 515: *dn_pp = dnp; ! 516: return (0); ! 517: } ! 518: dnp = dnp->dn_nextsibling; ! 519: } ! 520: if (typeinfo == NULL) ! 521: typeinfo = &(proto->dn_typeinfo); ! 522: } ! 523: #else /* SPLIT_DEVS */ ! 524: if ( proto ) { ! 525: switch (proto->type) { ! 526: case DEV_BDEV: ! 527: case DEV_CDEV: ! 528: *dn_pp = proto; ! 529: return 0; ! 530: } ! 531: } ! 532: #endif /* SPLIT_DEVS */ ! 533: MALLOC(dnp, devnode_t *, sizeof(devnode_t), M_DEVFSNODE, M_NOWAIT); ! 534: if (!dnp) { ! 535: return ENOMEM; ! 536: } ! 537: ! 538: /* ! 539: * If we have a proto, that means that we are duplicating some ! 540: * other device, which can only happen if we are not at the back plane ! 541: */ ! 542: if(proto) { ! 543: bcopy(proto, dnp, sizeof(devnode_t)); ! 544: dnp->dn_links = 0; ! 545: dnp->dn_linklist = NULL; ! 546: dnp->dn_vn = NULL; ! 547: dnp->dn_len = 0; ! 548: /* add to END of siblings list */ ! 549: dnp->dn_prevsiblingp = proto->dn_prevsiblingp; ! 550: *(dnp->dn_prevsiblingp) = dnp; ! 551: dnp->dn_nextsibling = proto; ! 552: proto->dn_prevsiblingp = &(dnp->dn_nextsibling); ! 553: } else { ! 554: struct timeval tv; ! 555: ! 556: /* ! 557: * We have no prototype, so start off with a clean slate ! 558: */ ! 559: tv = time; ! 560: bzero(dnp,sizeof(devnode_t)); ! 561: dnp->dn_type = entrytype; ! 562: dnp->dn_nextsibling = dnp; ! 563: dnp->dn_prevsiblingp = &(dnp->dn_nextsibling); ! 564: dnp->dn_atime.tv_sec = tv.tv_sec; ! 565: dnp->dn_mtime.tv_sec = tv.tv_sec; ! 566: dnp->dn_ctime.tv_sec = tv.tv_sec; ! 567: } ! 568: dnp->dn_dvm = dvm; ! 569: ! 570: /* ! 571: * fill out the dev node according to type ! 572: */ ! 573: switch(entrytype) { ! 574: case DEV_DIR: ! 575: /* ! 576: * As it's a directory, make sure ! 577: * it has a null entries list ! 578: */ ! 579: dnp->dn_typeinfo.Dir.dirlast = &(dnp->dn_typeinfo.Dir.dirlist); ! 580: dnp->dn_typeinfo.Dir.dirlist = (devdirent_t *)0; ! 581: dnp->dn_typeinfo.Dir.entrycount = 0; ! 582: /* until we know better, it has a null parent pointer*/ ! 583: dnp->dn_typeinfo.Dir.parent = NULL; ! 584: dnp->dn_links++; /* for .*/ ! 585: dnp->dn_typeinfo.Dir.myname = NULL; ! 586: /* ! 587: * make sure that the ops associated with it are the ops ! 588: * that we use (by default) for directories ! 589: */ ! 590: dnp->dn_ops = &devfs_vnodeop_p; ! 591: dnp->dn_mode |= 0555; /* default perms */ ! 592: break; ! 593: case DEV_SLNK: ! 594: /* ! 595: * As it's a symlink allocate and store the link info ! 596: * Symlinks should only ever be created by the user, ! 597: * so they are not on the back plane and should not be ! 598: * propogated forward.. a bit like directories in that way.. ! 599: * A symlink only exists on one plane and has its own ! 600: * node.. therefore we might be on any random plane. ! 601: */ ! 602: MALLOC(dnp->dn_typeinfo.Slnk.name, char *, ! 603: typeinfo->Slnk.namelen+1, ! 604: M_DEVFSNODE, M_NOWAIT); ! 605: if (!dnp->dn_typeinfo.Slnk.name) { ! 606: FREE(dnp,M_DEVFSNODE); ! 607: return ENOMEM; ! 608: } ! 609: strncpy(dnp->dn_typeinfo.Slnk.name, typeinfo->Slnk.name, ! 610: typeinfo->Slnk.namelen); ! 611: dnp->dn_typeinfo.Slnk.name[typeinfo->Slnk.namelen] = '\0'; ! 612: dnp->dn_typeinfo.Slnk.namelen = typeinfo->Slnk.namelen; ! 613: DEVFS_INCR_STRINGSPACE(dnp->dn_typeinfo.Slnk.namelen + 1); ! 614: dnp->dn_ops = &devfs_vnodeop_p; ! 615: dnp->dn_mode |= 0555; /* default perms */ ! 616: break; ! 617: case DEV_CDEV: ! 618: case DEV_BDEV: ! 619: /* ! 620: * Make sure it has DEVICE type ops ! 621: * and device specific fields are correct ! 622: */ ! 623: dnp->dn_ops = &devfs_spec_vnodeop_p; ! 624: dnp->dn_typeinfo.dev = typeinfo->dev; ! 625: break; ! 626: default: ! 627: return EINVAL; ! 628: } ! 629: ! 630: *dn_pp = dnp; ! 631: DEVFS_INCR_NODES(); ! 632: return 0 ; ! 633: } ! 634: ! 635: ! 636: /*proto*/ ! 637: void ! 638: devnode_free(devnode_t * dnp) ! 639: { ! 640: if (dnp->dn_type == DEV_SLNK) { ! 641: DEVFS_DECR_STRINGSPACE(dnp->dn_typeinfo.Slnk.namelen + 1); ! 642: FREE(dnp->dn_typeinfo.Slnk.name,M_DEVFSNODE); ! 643: } ! 644: FREE(dnp, M_DEVFSNODE); ! 645: DEVFS_DECR_NODES(); ! 646: return; ! 647: } ! 648: ! 649: /*proto*/ ! 650: void ! 651: devfs_dn_free(devnode_t * dnp) ! 652: { ! 653: if(--dnp->dn_links <= 0 ) /* can be -1 for initial free, on error */ ! 654: { ! 655: /*probably need to do other cleanups XXX */ ! 656: if (dnp->dn_nextsibling != dnp) { ! 657: devnode_t * * prevp = dnp->dn_prevsiblingp; ! 658: *prevp = dnp->dn_nextsibling; ! 659: dnp->dn_nextsibling->dn_prevsiblingp = prevp; ! 660: ! 661: } ! 662: if (dnp->dn_vn == NULL) { ! 663: #if 0 ! 664: printf("devfs_dn_free: free'ing %x\n", (unsigned int)dnp); ! 665: #endif 0 ! 666: devnode_free(dnp); /* no accesses/references */ ! 667: } ! 668: else { ! 669: #if 0 ! 670: printf("devfs_dn_free: marking %x for deletion\n", ! 671: (unsigned int)dnp); ! 672: #endif 0 ! 673: dnp->dn_delete = TRUE; ! 674: } ! 675: } ! 676: } ! 677: ! 678: /***********************************************************************\ ! 679: * Front Node Operations * ! 680: * Add or delete a chain of front nodes * ! 681: \***********************************************************************/ ! 682: ! 683: /***********************************************************************\ ! 684: * Given a directory backing node, and a child backing node, add the * ! 685: * appropriate front nodes to the front nodes of the directory to * ! 686: * represent the child node to the user * ! 687: * * ! 688: * on failure, front nodes will either be correct or not exist for each * ! 689: * front dir, however dirs completed will not be stripped of completed * ! 690: * frontnodes on failure of a later frontnode * ! 691: * * ! 692: * This allows a new node to be propogated through all mounted planes * ! 693: * * ! 694: \***********************************************************************/ ! 695: /*proto*/ ! 696: int ! 697: devfs_propogate(devdirent_t * parent,devdirent_t * child) ! 698: { ! 699: int error; ! 700: devdirent_t * newnmp; ! 701: devnode_t * dnp = child->de_dnp; ! 702: devnode_t * pdnp = parent->de_dnp; ! 703: devnode_t * adnp = parent->de_dnp; ! 704: int type = child->de_dnp->dn_type; ! 705: ! 706: /***********************************************\ ! 707: * Find the other instances of the parent node * ! 708: \***********************************************/ ! 709: for (adnp = pdnp->dn_nextsibling; ! 710: adnp != pdnp; ! 711: adnp = adnp->dn_nextsibling) ! 712: { ! 713: /* ! 714: * Make the node, using the original as a prototype) ! 715: * if the node already exists on that plane it won't be ! 716: * re-made.. ! 717: */ ! 718: if ((error = dev_add_entry(child->de_name, adnp, type, ! 719: NULL, dnp, adnp->dn_dvm, ! 720: &newnmp)) != 0) { ! 721: printf("duplicating %s failed\n",child->de_name); ! 722: } ! 723: } ! 724: return 0; /* for now always succeed */ ! 725: } ! 726: ! 727: /*********************************************************************** ! 728: * remove all instances of this devicename [for backing nodes..] ! 729: * note.. if there is another link to the node (non dir nodes only) ! 730: * then the devfs_node will still exist as the ref count will be non-0 ! 731: * removing a directory node will remove all sup-nodes on all planes (ZAP) ! 732: * ! 733: * Used by device drivers to remove nodes that are no longer relevant ! 734: * The argument is the 'cookie' they were given when they created the node ! 735: * this function is exported.. see devfs.h ! 736: ***********************************************************************/ ! 737: void ! 738: devfs_remove(void *dirent_p) ! 739: { ! 740: devnode_t * dnp = ((devdirent_t *)dirent_p)->de_dnp; ! 741: devnode_t * dnp2; ! 742: ! 743: if (!devfs_ready) ! 744: printf("devfs_remove: not ready for devices!\n"); ! 745: ! 746: DEVFS_LOCK(0); ! 747: ! 748: /* keep removing the next sibling till only we exist. */ ! 749: while((dnp2 = dnp->dn_nextsibling) != dnp) { ! 750: ! 751: /* ! 752: * Keep removing the next front node till no more exist ! 753: */ ! 754: dnp->dn_nextsibling = dnp2->dn_nextsibling; ! 755: dnp->dn_nextsibling->dn_prevsiblingp = &(dnp->dn_nextsibling); ! 756: dnp2->dn_nextsibling = dnp2; ! 757: dnp2->dn_prevsiblingp = &(dnp2->dn_nextsibling); ! 758: while(dnp2->dn_linklist) ! 759: { ! 760: dev_free_name(dnp2->dn_linklist); ! 761: } ! 762: } ! 763: ! 764: /* ! 765: * then free the main node ! 766: * If we are not running in SPLIT_DEVS mode, then ! 767: * THIS is what gets rid of the propogated nodes. ! 768: */ ! 769: while(dnp->dn_linklist) ! 770: { ! 771: dev_free_name(dnp->dn_linklist); ! 772: } ! 773: DEVFS_UNLOCK(0); ! 774: return ; ! 775: } ! 776: ! 777: ! 778: /*************************************************************** ! 779: * duplicate the backing tree into a tree of nodes hung off the ! 780: * mount point given as the argument. Do this by ! 781: * calling dev_dup_entry which recurses all the way ! 782: * up the tree.. ! 783: **************************************************************/ ! 784: /*proto*/ ! 785: int ! 786: dev_dup_plane(struct devfsmount *devfs_mp_p) ! 787: { ! 788: devdirent_t * new; ! 789: int error = 0; ! 790: ! 791: if ((error = dev_dup_entry(NULL, dev_root, &new, devfs_mp_p))) ! 792: return error; ! 793: devfs_mp_p->plane_root = new; ! 794: return error; ! 795: } ! 796: ! 797: ! 798: ! 799: /***************************************************************\ ! 800: * Free a whole plane ! 801: \***************************************************************/ ! 802: /*proto*/ ! 803: void ! 804: devfs_free_plane(struct devfsmount *devfs_mp_p) ! 805: { ! 806: devdirent_t * dirent_p; ! 807: ! 808: dirent_p = devfs_mp_p->plane_root; ! 809: if(dirent_p) { ! 810: dev_free_hier(dirent_p); ! 811: dev_free_name(dirent_p); ! 812: } ! 813: devfs_mp_p->plane_root = NULL; ! 814: } ! 815: ! 816: /***************************************************************\ ! 817: * Create and link in a new front element.. * ! 818: * Parent can be 0 for a root node * ! 819: * Not presently usable to make a symlink XXX * ! 820: * (Ok, symlinks don't propogate) ! 821: * recursively will create subnodes corresponding to equivalent * ! 822: * child nodes in the base level * ! 823: \***************************************************************/ ! 824: /*proto*/ ! 825: int ! 826: dev_dup_entry(devnode_t * parent, devdirent_t * back, devdirent_t * *dnm_pp, ! 827: struct devfsmount *dvm) ! 828: { ! 829: devdirent_t * entry_p; ! 830: devdirent_t * newback; ! 831: devdirent_t * newfront; ! 832: int error; ! 833: devnode_t * dnp = back->de_dnp; ! 834: int type = dnp->dn_type; ! 835: ! 836: /* ! 837: * go get the node made (if we need to) ! 838: * use the back one as a prototype ! 839: */ ! 840: if ((error = dev_add_entry(back->de_name, parent, type, ! 841: NULL, dnp, ! 842: parent?parent->dn_dvm:dvm, &entry_p)) != 0) { ! 843: printf("duplicating %s failed\n",back->de_name); ! 844: } ! 845: ! 846: /* ! 847: * If we have just made the root, then insert the pointer to the ! 848: * mount information ! 849: */ ! 850: if(dvm) { ! 851: entry_p->de_dnp->dn_dvm = dvm; ! 852: } ! 853: ! 854: /* ! 855: * If it is a directory, then recurse down all the other ! 856: * subnodes in it.... ! 857: * note that this time we don't pass on the mount info.. ! 858: */ ! 859: if (type == DEV_DIR) ! 860: { ! 861: for(newback = back->de_dnp->dn_typeinfo.Dir.dirlist; ! 862: newback; newback = newback->de_next) ! 863: { ! 864: if((error = dev_dup_entry(entry_p->de_dnp, ! 865: newback, &newfront, NULL)) != 0) ! 866: { ! 867: break; /* back out with an error */ ! 868: } ! 869: } ! 870: } ! 871: *dnm_pp = entry_p; ! 872: return error; ! 873: } ! 874: ! 875: /***************************************************************\ ! 876: * Free a name node * ! 877: * remember that if there are other names pointing to the * ! 878: * dev_node then it may not get freed yet * ! 879: * can handle if there is no dnp * ! 880: \***************************************************************/ ! 881: /*proto*/ ! 882: int ! 883: dev_free_name(devdirent_t * dirent_p) ! 884: { ! 885: devnode_t * parent = dirent_p->de_parent; ! 886: devnode_t * dnp = dirent_p->de_dnp; ! 887: ! 888: if(dnp) { ! 889: if(dnp->dn_type == DEV_DIR) ! 890: { ! 891: devnode_t * p; ! 892: ! 893: if(dnp->dn_typeinfo.Dir.dirlist) ! 894: return (ENOTEMPTY); ! 895: p = dnp->dn_typeinfo.Dir.parent; ! 896: devfs_dn_free(dnp); /* account for '.' */ ! 897: devfs_dn_free(p); /* '..' */ ! 898: } ! 899: /* ! 900: * unlink us from the list of links for this node ! 901: * If we are the only link, it's easy! ! 902: * if we are a DIR of course there should not be any ! 903: * other links. ! 904: */ ! 905: if(dirent_p->de_nextlink == dirent_p) { ! 906: dnp->dn_linklist = NULL; ! 907: } else { ! 908: if(dnp->dn_linklist == dirent_p) { ! 909: dnp->dn_linklist = dirent_p->de_nextlink; ! 910: } ! 911: dirent_p->de_nextlink->de_prevlinkp ! 912: = dirent_p->de_prevlinkp; ! 913: *dirent_p->de_prevlinkp = dirent_p->de_nextlink; ! 914: } ! 915: devfs_dn_free(dnp); ! 916: } ! 917: ! 918: /* ! 919: * unlink ourselves from the directory on this plane ! 920: */ ! 921: if(parent) /* if not fs root */ ! 922: { ! 923: if( (*dirent_p->de_prevp = dirent_p->de_next) )/* yes, assign */ ! 924: { ! 925: dirent_p->de_next->de_prevp = dirent_p->de_prevp; ! 926: } ! 927: else ! 928: { ! 929: parent->dn_typeinfo.Dir.dirlast ! 930: = dirent_p->de_prevp; ! 931: } ! 932: parent->dn_typeinfo.Dir.entrycount--; ! 933: parent->dn_len -= strlen(dirent_p->de_name) + 8; ! 934: } ! 935: ! 936: DEVFS_DECR_ENTRIES(); ! 937: FREE(dirent_p,M_DEVFSNAME); ! 938: return 0; ! 939: } ! 940: ! 941: /***************************************************************\ ! 942: * Free a hierarchy starting at a directory node name * ! 943: * remember that if there are other names pointing to the * ! 944: * dev_node then it may not get freed yet * ! 945: * can handle if there is no dnp * ! 946: * leave the node itself allocated. * ! 947: \***************************************************************/ ! 948: /*proto*/ ! 949: void ! 950: dev_free_hier(devdirent_t * dirent_p) ! 951: { ! 952: devnode_t * dnp = dirent_p->de_dnp; ! 953: ! 954: if(dnp) { ! 955: if(dnp->dn_type == DEV_DIR) ! 956: { ! 957: while(dnp->dn_typeinfo.Dir.dirlist) ! 958: { ! 959: dev_free_hier(dnp->dn_typeinfo.Dir.dirlist); ! 960: dev_free_name(dnp->dn_typeinfo.Dir.dirlist); ! 961: } ! 962: } ! 963: } ! 964: } ! 965: ! 966: /***************************************************************\ ! 967: * given a dev_node, find the appropriate vnode if one is already ! 968: * associated, or get a new one and associate it with the dev_node ! 969: \***************************************************************/ ! 970: /*proto*/ ! 971: int ! 972: devfs_dntovn(devnode_t * dnp, struct vnode **vn_pp, struct proc * p) ! 973: { ! 974: struct vnode *vn_p, *nvp; ! 975: int error = 0; ! 976: ! 977: *vn_pp = NULL; ! 978: vn_p = dnp->dn_vn; ! 979: if (vn_p) { /* already has a vnode */ ! 980: *vn_pp = vn_p; ! 981: return(vget(vn_p, LK_EXCLUSIVE, p)); ! 982: } ! 983: if (!(error = getnewvnode(VT_DEVFS, dnp->dn_dvm->mount, ! 984: *(dnp->dn_ops), &vn_p))) { ! 985: switch(dnp->dn_type) { ! 986: case DEV_SLNK: ! 987: vn_p->v_type = VLNK; ! 988: break; ! 989: case DEV_DIR: ! 990: if (dnp->dn_typeinfo.Dir.parent == dnp) { ! 991: vn_p->v_flag |= VROOT; ! 992: } ! 993: vn_p->v_type = VDIR; ! 994: break; ! 995: case DEV_BDEV: ! 996: case DEV_CDEV: ! 997: vn_p->v_type ! 998: = (dnp->dn_type == DEV_BDEV) ? VBLK : VCHR; ! 999: if ((nvp = checkalias(vn_p, dnp->dn_typeinfo.dev, ! 1000: dnp->dn_dvm->mount)) != NULL) { ! 1001: vput(vn_p); ! 1002: vn_p = nvp; ! 1003: } ! 1004: break; ! 1005: } ! 1006: vn_p->v_mount = dnp->dn_dvm->mount;/* XXX Duplicated */ ! 1007: *vn_pp = vn_p; ! 1008: vn_p->v_data = (void *)dnp; ! 1009: dnp->dn_vn = vn_p; ! 1010: error = vn_lock(vn_p, LK_EXCLUSIVE | LK_RETRY, p); ! 1011: } ! 1012: return error; ! 1013: } ! 1014: ! 1015: /***********************************************************************\ ! 1016: * add a whole device, with no prototype.. make name element and node * ! 1017: * Used for adding the original device entries * ! 1018: \***********************************************************************/ ! 1019: /*proto*/ ! 1020: int ! 1021: dev_add_entry(char *name, devnode_t * parent, int type, devnode_type_t * typeinfo, ! 1022: devnode_t * proto, struct devfsmount *dvm, devdirent_t * *nm_pp) ! 1023: { ! 1024: devnode_t * dnp; ! 1025: int error = 0; ! 1026: ! 1027: if ((error = dev_add_node(type, typeinfo, proto, &dnp, ! 1028: (parent?parent->dn_dvm:dvm))) != 0) ! 1029: { ! 1030: printf("devfs: %s: base node allocation failed (Errno=%d)\n", ! 1031: name,error); ! 1032: return error; ! 1033: } ! 1034: if ((error = dev_add_name(name ,parent ,NULL, dnp, nm_pp)) != 0) ! 1035: { ! 1036: devfs_dn_free(dnp); /* 1->0 for dir, 0->(-1) for other */ ! 1037: printf("devfs: %s: name slot allocation failed (Errno=%d)\n", ! 1038: name,error); ! 1039: ! 1040: } ! 1041: return error; ! 1042: } ! 1043: ! 1044: #include <sys/subr_prf.h> ! 1045: ! 1046: /* ! 1047: * Function: devfs_make_node ! 1048: * ! 1049: * Purpose ! 1050: * Create a device node with the given pathname in the devfs namespace. ! 1051: * ! 1052: * Parameters: ! 1053: * dev - the dev_t value to associate ! 1054: * chrblk - block or character device (DEVFS_CHAR or DEVFS_BLOCK) ! 1055: * uid, gid - ownership ! 1056: * perms - permissions ! 1057: * fmt, ... - path format string with printf args to format the path name ! 1058: * Returns: ! 1059: * A handle to a device node if successful, NULL otherwise. ! 1060: */ ! 1061: void * ! 1062: devfs_make_node(dev_t dev, int chrblk, uid_t uid, ! 1063: gid_t gid, int perms, char *fmt, ...) ! 1064: { ! 1065: devdirent_t * new_dev = NULL; ! 1066: devnode_t * dnp; /* devnode for parent directory */ ! 1067: devnode_type_t typeinfo; ! 1068: ! 1069: char *name, *path, buf[256]; /* XXX */ ! 1070: char * b_ptr = buf; ! 1071: int i; ! 1072: va_list ap; ! 1073: ! 1074: if (!devfs_ready) { ! 1075: printf("devfs_make_node: not ready for devices!\n"); ! 1076: return (NULL); ! 1077: } ! 1078: ! 1079: if (chrblk != DEVFS_CHAR && chrblk != DEVFS_BLOCK) ! 1080: return (NULL); ! 1081: ! 1082: va_start(ap, fmt); ! 1083: prf(fmt, ap, TOSTR, (struct tty *)&b_ptr); ! 1084: va_end(ap); ! 1085: *b_ptr = 0; ! 1086: ! 1087: name = NULL; ! 1088: ! 1089: for(i=strlen(buf); i>0; i--) ! 1090: if(buf[i] == '/') { ! 1091: name=&buf[i]; ! 1092: buf[i]=0; ! 1093: break; ! 1094: } ! 1095: ! 1096: if (name) { ! 1097: *name++ = '\0'; ! 1098: path = buf; ! 1099: } else { ! 1100: name = buf; ! 1101: path = "/"; ! 1102: } ! 1103: ! 1104: DEVFS_LOCK(0); ! 1105: /* find/create directory path ie. mkdir -p */ ! 1106: if (dev_finddir(path, NULL, CREATE, &dnp) == 0) { ! 1107: typeinfo.dev = dev; ! 1108: if (dev_add_entry(name, dnp, ! 1109: (chrblk == DEVFS_CHAR) ? DEV_CDEV : DEV_BDEV, ! 1110: &typeinfo, NULL, NULL, &new_dev) == 0) { ! 1111: new_dev->de_dnp->dn_gid = gid; ! 1112: new_dev->de_dnp->dn_uid = uid; ! 1113: new_dev->de_dnp->dn_mode |= perms; ! 1114: devfs_propogate(dnp->dn_typeinfo.Dir.myname, new_dev); ! 1115: } ! 1116: } ! 1117: DEVFS_UNLOCK(0); ! 1118: return new_dev; ! 1119: } ! 1120: ! 1121: /* ! 1122: * Function: devfs_make_link ! 1123: * ! 1124: * Purpose: ! 1125: * Create a link to a previously created device node. ! 1126: * ! 1127: * Returns: ! 1128: * 0 if successful, -1 if failed ! 1129: */ ! 1130: int ! 1131: devfs_make_link(void *original, char *fmt, ...) ! 1132: { ! 1133: devdirent_t * new_dev = NULL; ! 1134: devdirent_t * orig = (devdirent_t *) original; ! 1135: devnode_t * dirnode; /* devnode for parent directory */ ! 1136: ! 1137: va_list ap; ! 1138: char *p, buf[256]; /* XXX */ ! 1139: char * b_ptr = buf; ! 1140: int i; ! 1141: ! 1142: if (!devfs_ready) { ! 1143: printf("devfs_make_link: not ready for devices!\n"); ! 1144: return (-1); ! 1145: } ! 1146: ! 1147: va_start(ap, fmt); ! 1148: prf(fmt, ap, TOSTR, (struct tty *)&b_ptr); ! 1149: va_end(ap); ! 1150: *b_ptr = 0; ! 1151: ! 1152: p = NULL; ! 1153: ! 1154: for(i=strlen(buf); i>0; i--) ! 1155: if(buf[i] == '/') { ! 1156: p=&buf[i]; ! 1157: buf[i]=0; ! 1158: break; ! 1159: } ! 1160: DEVFS_LOCK(0); ! 1161: if (p) { ! 1162: *p++ = '\0'; ! 1163: if (dev_finddir(buf, NULL, CREATE, &dirnode) ! 1164: || dev_add_name(p, dirnode, NULL, orig->de_dnp, &new_dev)) ! 1165: goto fail; ! 1166: } else { ! 1167: if (dev_finddir("", NULL, CREATE, &dirnode) ! 1168: || dev_add_name(buf, dirnode, NULL, orig->de_dnp, &new_dev)) ! 1169: goto fail; ! 1170: } ! 1171: devfs_propogate(dirnode->dn_typeinfo.Dir.myname, new_dev); ! 1172: fail: ! 1173: DEVFS_UNLOCK(0); ! 1174: return ((new_dev != NULL) ? 0 : -1); ! 1175: } ! 1176:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.