iokit/bsddev/IOKitBSDInit.cpp

   1 /*
   2  * Copyright (c) 1998-2011 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 #include <IOKit/IOBSD.h>
  29 #include <IOKit/IOLib.h>
  30 #include <IOKit/IOService.h>
  31 #include <IOKit/IOCatalogue.h>
  32 #include <IOKit/IODeviceTreeSupport.h>
  33 #include <IOKit/IOKitKeys.h>
  34 #include <IOKit/IOPlatformExpert.h>
  35
  36 extern "C" {
  37
  38 #include <pexpert/pexpert.h>
  39 #include <kern/clock.h>
  40 #include <uuid/uuid.h>
  41 #include <sys/vnode_internal.h>
  42
  43 // how long to wait for matching root device, secs
  44 #if DEBUG
  45 #define ROOTDEVICETIMEOUT       120
  46 #else
  47 #define ROOTDEVICETIMEOUT       60
  48 #endif
  49
  50 extern dev_t mdevadd(int devid, uint64_t base, unsigned int size, int phys);
  51 extern dev_t mdevlookup(int devid);
  52 extern void mdevremoveall(void);
  53 extern void di_root_ramfile(IORegistryEntry * entry);
  54
  55 kern_return_t
  56 IOKitBSDInit( void )
  57 {
  58     IOService::publishResource("IOBSD");
  59
  60     return( kIOReturnSuccess );
  61 }
  62
  63 void
  64 IOServicePublishResource( const char * property, boolean_t value )
  65 {
  66     if ( value)
  67         IOService::publishResource( property, kOSBooleanTrue );
  68     else
  69         IOService::getResourceService()->removeProperty( property );
  70 }
  71
  72 boolean_t
  73 IOServiceWaitForMatchingResource( const char * property, uint64_t timeout )
  74 {
  75     OSDictionary *      dict = 0;
  76     IOService *         match = 0;
  77     boolean_t           found = false;
  78
  79     do {
  80
  81         dict = IOService::resourceMatching( property );
  82         if( !dict)
  83             continue;
  84         match = IOService::waitForMatchingService( dict, timeout );
  85         if ( match)
  86             found = true;
  87
  88     } while( false );
  89
  90     if( dict)
  91         dict->release();
  92     if( match)
  93         match->release();
  94
  95     return( found );
  96 }
  97
  98 boolean_t
  99 IOCatalogueMatchingDriversPresent( const char * property )
 100 {
 101     OSDictionary *      dict = 0;
 102     OSOrderedSet *      set = 0;
 103     SInt32              generationCount = 0;
 104     boolean_t           found = false;
 105
 106     do {
 107
 108         dict = OSDictionary::withCapacity(1);
 109         if( !dict)
 110             continue;
 111         dict->setObject( property, kOSBooleanTrue );
 112         set = gIOCatalogue->findDrivers( dict, &generationCount );
 113         if ( set && (set->getCount() > 0))
 114             found = true;
 115
 116     } while( false );
 117
 118     if( dict)
 119         dict->release();
 120     if( set)
 121         set->release();
 122
 123     return( found );
 124 }
 125
 126 OSDictionary * IOBSDNameMatching( const char * name )
 127 {
 128     OSDictionary *      dict;
 129     const OSSymbol *    str = 0;
 130
 131     do {
 132
 133         dict = IOService::serviceMatching( gIOServiceKey );
 134         if( !dict)
 135             continue;
 136         str = OSSymbol::withCString( name );
 137         if( !str)
 138             continue;
 139         dict->setObject( kIOBSDNameKey, (OSObject *) str );
 140         str->release();
 141
 142         return( dict );
 143
 144     } while( false );
 145
 146     if( dict)
 147         dict->release();
 148     if( str)
 149         str->release();
 150
 151     return( 0 );
 152 }
 153
 154 OSDictionary * IOUUIDMatching( void )
 155 {
 156     return IOService::resourceMatching( "boot-uuid-media" );
 157 }
 158
 159 OSDictionary * IONetworkNamePrefixMatching( const char * prefix )
 160 {
 161     OSDictionary *       matching;
 162     OSDictionary *   propDict = 0;
 163     const OSSymbol * str      = 0;
 164         char networkType[128];
 165
 166     do {
 167         matching = IOService::serviceMatching( "IONetworkInterface" );
 168         if ( matching == 0 )
 169             continue;
 170
 171         propDict = OSDictionary::withCapacity(1);
 172         if ( propDict == 0 )
 173             continue;
 174
 175         str = OSSymbol::withCString( prefix );
 176         if ( str == 0 )
 177             continue;
 178
 179         propDict->setObject( "IOInterfaceNamePrefix", (OSObject *) str );
 180         str->release();
 181         str = 0;
 182
 183                 // see if we're contrained to netroot off of specific network type
 184                 if(PE_parse_boot_argn( "network-type", networkType, 128 ))
 185                 {
 186                         str = OSSymbol::withCString( networkType );
 187                         if(str)
 188                         {
 189                                 propDict->setObject( "IONetworkRootType", str);
 190                                 str->release();
 191                                 str = 0;
 192                         }
 193                 }
 194
 195         if ( matching->setObject( gIOPropertyMatchKey,
 196                                   (OSObject *) propDict ) != true )
 197             continue;
 198
 199         propDict->release();
 200         propDict = 0;
 201
 202         return( matching );
 203
 204     } while ( false );
 205
 206     if ( matching ) matching->release();
 207     if ( propDict ) propDict->release();
 208     if ( str      ) str->release();
 209
 210     return( 0 );
 211 }
 212
 213 static bool IORegisterNetworkInterface( IOService * netif )
 214 {
 215     // A network interface is typically named and registered
 216     // with BSD after receiving a request from a user space
 217     // "namer". However, for cases when the system needs to
 218     // root from the network, this registration task must be
 219     // done inside the kernel and completed before the root
 220     // device is handed to BSD.
 221
 222     IOService *    stack;
 223     OSNumber *     zero    = 0;
 224     OSString *     path    = 0;
 225     OSDictionary * dict    = 0;
 226     char *         pathBuf = 0;
 227     int            len;
 228     enum { kMaxPathLen = 512 };
 229
 230     do {
 231         stack = IOService::waitForService(
 232                 IOService::serviceMatching("IONetworkStack") );
 233         if ( stack == 0 ) break;
 234
 235         dict = OSDictionary::withCapacity(3);
 236         if ( dict == 0 ) break;
 237
 238         zero = OSNumber::withNumber((UInt64) 0, 32);
 239         if ( zero == 0 ) break;
 240
 241         pathBuf = (char *) IOMalloc( kMaxPathLen );
 242         if ( pathBuf == 0 ) break;
 243
 244         len = kMaxPathLen;
 245         if ( netif->getPath( pathBuf, &len, gIOServicePlane )
 246              == false ) break;
 247
 248         path = OSString::withCStringNoCopy( pathBuf );
 249         if ( path == 0 ) break;
 250
 251         dict->setObject( "IOInterfaceUnit", zero );
 252         dict->setObject( kIOPathMatchKey,   path );
 253
 254         stack->setProperties( dict );
 255     }
 256     while ( false );
 257
 258     if ( zero ) zero->release();
 259     if ( path ) path->release();
 260     if ( dict ) dict->release();
 261     if ( pathBuf ) IOFree(pathBuf, kMaxPathLen);
 262
 263         return ( netif->getProperty( kIOBSDNameKey ) != 0 );
 264 }
 265
 266 OSDictionary * IOOFPathMatching( const char * path, char * buf, int maxLen )
 267 {
 268     OSDictionary *      matching = NULL;
 269     OSString *          str;
 270     char *              comp;
 271     int                 len;
 272
 273     do {
 274
 275         len = strlen( kIODeviceTreePlane ":" );
 276         maxLen -= len;
 277         if( maxLen <= 0)
 278             continue;
 279
 280         strlcpy( buf, kIODeviceTreePlane ":", len + 1 );
 281         comp = buf + len;
 282
 283         len = strlen( path );
 284         maxLen -= len;
 285         if( maxLen <= 0)
 286             continue;
 287         strlcpy( comp, path, len + 1 );
 288
 289         matching = OSDictionary::withCapacity( 1 );
 290         if( !matching)
 291             continue;
 292
 293         str = OSString::withCString( buf );
 294         if( !str)
 295             continue;
 296         matching->setObject( kIOPathMatchKey, str );
 297         str->release();
 298
 299         return( matching );
 300
 301     } while( false );
 302
 303     if( matching)
 304         matching->release();
 305
 306     return( 0 );
 307 }
 308
 309 static int didRam = 0;
 310 enum { kMaxPathBuf = 512, kMaxBootVar = 128 };
 311
 312 kern_return_t IOFindBSDRoot( char * rootName, unsigned int rootNameSize,
 313                                 dev_t * root, u_int32_t * oflags )
 314 {
 315     mach_timespec_t     t;
 316     IOService *         service;
 317     IORegistryEntry *   regEntry;
 318     OSDictionary *      matching = 0;
 319     OSString *          iostr;
 320     OSNumber *          off;
 321     OSData *            data = 0;
 322
 323     UInt32              flags = 0;
 324     int                 mnr, mjr;
 325     const char *        mediaProperty = 0;
 326     char *              rdBootVar;
 327     char *              str;
 328     const char *        look = 0;
 329     int                 len;
 330     bool                debugInfoPrintedOnce = false;
 331     const char *        uuidStr = NULL;
 332
 333     static int          mountAttempts = 0;
 334
 335     int xchar, dchar;
 336
 337
 338     if( mountAttempts++)
 339         IOSleep( 5 * 1000 );
 340
 341     str = (char *) IOMalloc( kMaxPathBuf + kMaxBootVar );
 342     if( !str)
 343         return( kIOReturnNoMemory );
 344     rdBootVar = str + kMaxPathBuf;
 345
 346     if (!PE_parse_boot_argn("rd", rdBootVar, kMaxBootVar )
 347      && !PE_parse_boot_argn("rootdev", rdBootVar, kMaxBootVar ))
 348         rdBootVar[0] = 0;
 349
 350     do {
 351         if( (regEntry = IORegistryEntry::fromPath( "/chosen", gIODTPlane ))) {
 352             di_root_ramfile(regEntry);
 353             data = OSDynamicCast(OSData, regEntry->getProperty( "root-matching" ));
 354             if (data) {
 355                matching = OSDynamicCast(OSDictionary, OSUnserializeXML((char *)data->getBytesNoCopy()));
 356                 if (matching) {
 357                     continue;
 358                 }
 359             }
 360
 361             data = (OSData *) regEntry->getProperty( "boot-uuid" );
 362             if( data) {
 363                 uuidStr = (const char*)data->getBytesNoCopy();
 364                 OSString *uuidString = OSString::withCString( uuidStr );
 365
 366                 // match the boot-args boot-uuid processing below
 367                 if( uuidString) {
 368                     IOLog("rooting via boot-uuid from /chosen: %s\n", uuidStr);
 369                     IOService::publishResource( "boot-uuid", uuidString );
 370                     uuidString->release();
 371                     matching = IOUUIDMatching();
 372                     mediaProperty = "boot-uuid-media";
 373                     regEntry->release();
 374                     continue;
 375                 } else {
 376                     uuidStr = NULL;
 377                 }
 378             }
 379             regEntry->release();
 380         }
 381     } while( false );
 382
 383 //
 384 //      See if we have a RAMDisk property in /chosen/memory-map.  If so, make it into a device.
 385 //      It will become /dev/mdx, where x is 0-f.
 386 //
 387
 388         if(!didRam) {                                                                                           /* Have we already build this ram disk? */
 389                 didRam = 1;                                                                                             /* Remember we did this */
 390                 if((regEntry = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane ))) {        /* Find the map node */
 391                         data = (OSData *)regEntry->getProperty("RAMDisk");      /* Find the ram disk, if there */
 392                         if(data) {                                                                                      /* We found one */
 393                                 uintptr_t *ramdParms;
 394                                 ramdParms = (uintptr_t *)data->getBytesNoCopy();        /* Point to the ram disk base and size */
 395                                 (void)mdevadd(-1, ml_static_ptovirt(ramdParms[0]) >> 12, ramdParms[1] >> 12, 0);        /* Initialize it and pass back the device number */
 396                         }
 397                         regEntry->release();                                                            /* Toss the entry */
 398                 }
 399         }
 400
 401 //
 402 //      Now check if we are trying to root on a memory device
 403 //
 404
 405         if((rdBootVar[0] == 'm') && (rdBootVar[1] == 'd') && (rdBootVar[3] == 0)) {
 406                 dchar = xchar = rdBootVar[2];                                                   /* Get the actual device */
 407                 if((xchar >= '0') && (xchar <= '9')) xchar = xchar - '0';       /* If digit, convert */
 408                 else {
 409                         xchar = xchar & ~' ';                                                           /* Fold to upper case */
 410                         if((xchar >= 'A') && (xchar <= 'F')) {                          /* Is this a valid digit? */
 411                                 xchar = (xchar & 0xF) + 9;                                              /* Convert the hex digit */
 412                                 dchar = dchar | ' ';                                                    /* Fold to lower case */
 413                         }
 414                         else xchar = -1;                                                                        /* Show bogus */
 415                 }
 416                 if(xchar >= 0) {                                                                                /* Do we have a valid memory device name? */
 417                         *root = mdevlookup(xchar);                                                      /* Find the device number */
 418                         if(*root >= 0) {                                                                        /* Did we find one? */
 419
 420                                 rootName[0] = 'm';                                                              /* Build root name */
 421                                 rootName[1] = 'd';                                                              /* Build root name */
 422                                 rootName[2] = dchar;                                                    /* Build root name */
 423                                 rootName[3] = 0;                                                                /* Build root name */
 424                                 IOLog("BSD root: %s, major %d, minor %d\n", rootName, major(*root), minor(*root));
 425                                 *oflags = 0;                                                                    /* Show that this is not network */
 426                                 goto iofrootx;                                                                  /* Join common exit... */
 427                         }
 428                         panic("IOFindBSDRoot: specified root memory device, %s, has not been configured\n", rdBootVar); /* Not there */
 429                 }
 430         }
 431
 432       if( (!matching) && rdBootVar[0] ) {
 433         // by BSD name
 434         look = rdBootVar;
 435         if( look[0] == '*')
 436             look++;
 437
 438         if ( strncmp( look, "en", strlen( "en" )) == 0 ) {
 439             matching = IONetworkNamePrefixMatching( "en" );
 440         } else if ( strncmp( look, "uuid", strlen( "uuid" )) == 0 ) {
 441             char *uuid;
 442             OSString *uuidString;
 443
 444             uuid = (char *)IOMalloc( kMaxBootVar );
 445
 446             if ( uuid ) {
 447                 if (!PE_parse_boot_argn( "boot-uuid", uuid, kMaxBootVar )) {
 448                     panic( "rd=uuid but no boot-uuid=<value> specified" );
 449                 }
 450                 uuidString = OSString::withCString( uuid );
 451                 if ( uuidString ) {
 452                     IOService::publishResource( "boot-uuid", uuidString );
 453                     uuidString->release();
 454                     IOLog( "\nWaiting for boot volume with UUID %s\n", uuid );
 455                     matching = IOUUIDMatching();
 456                     mediaProperty = "boot-uuid-media";
 457                 }
 458                 IOFree( uuid, kMaxBootVar );
 459             }
 460         } else {
 461             matching = IOBSDNameMatching( look );
 462         }
 463     }
 464
 465     if( !matching) {
 466         OSString * astring;
 467         // Match any HFS media
 468
 469         matching = IOService::serviceMatching( "IOMedia" );
 470         astring = OSString::withCStringNoCopy("Apple_HFS");
 471         if ( astring ) {
 472             matching->setObject("Content", astring);
 473             astring->release();
 474         }
 475     }
 476
 477     if( gIOKitDebug & kIOWaitQuietBeforeRoot ) {
 478         IOLog( "Waiting for matching to complete\n" );
 479         IOService::getPlatform()->waitQuiet();
 480     }
 481
 482     if( true && matching) {
 483         OSSerialize * s = OSSerialize::withCapacity( 5 );
 484
 485         if( matching->serialize( s )) {
 486             IOLog( "Waiting on %s\n", s->text() );
 487             s->release();
 488         }
 489     }
 490
 491     do {
 492         t.tv_sec = ROOTDEVICETIMEOUT;
 493         t.tv_nsec = 0;
 494         matching->retain();
 495         service = IOService::waitForService( matching, &t );
 496         if( (!service) || (mountAttempts == 10)) {
 497             PE_display_icon( 0, "noroot");
 498             IOLog( "Still waiting for root device\n" );
 499
 500             if( !debugInfoPrintedOnce) {
 501                 debugInfoPrintedOnce = true;
 502                 if( gIOKitDebug & kIOLogDTree) {
 503                     IOLog("\nDT plane:\n");
 504                     IOPrintPlane( gIODTPlane );
 505                 }
 506                 if( gIOKitDebug & kIOLogServiceTree) {
 507                     IOLog("\nService plane:\n");
 508                     IOPrintPlane( gIOServicePlane );
 509                 }
 510                 if( gIOKitDebug & kIOLogMemory)
 511                     IOPrintMemory();
 512             }
 513         }
 514     } while( !service);
 515     matching->release();
 516
 517     if ( service && mediaProperty ) {
 518         service = (IOService *)service->getProperty(mediaProperty);
 519     }
 520
 521     mjr = 0;
 522     mnr = 0;
 523
 524     // If the IOService we matched to is a subclass of IONetworkInterface,
 525     // then make sure it has been registered with BSD and has a BSD name
 526     // assigned.
 527
 528     if ( service
 529     &&   service->metaCast( "IONetworkInterface" )
 530     &&   !IORegisterNetworkInterface( service ) )
 531     {
 532         service = 0;
 533     }
 534
 535     if( service) {
 536
 537         len = kMaxPathBuf;
 538         service->getPath( str, &len, gIOServicePlane );
 539         IOLog( "Got boot device = %s\n", str );
 540
 541         iostr = (OSString *) service->getProperty( kIOBSDNameKey );
 542         if( iostr)
 543             strlcpy( rootName, iostr->getCStringNoCopy(), rootNameSize );
 544         off = (OSNumber *) service->getProperty( kIOBSDMajorKey );
 545         if( off)
 546             mjr = off->unsigned32BitValue();
 547         off = (OSNumber *) service->getProperty( kIOBSDMinorKey );
 548         if( off)
 549             mnr = off->unsigned32BitValue();
 550
 551         if( service->metaCast( "IONetworkInterface" ))
 552             flags |= 1;
 553
 554     } else {
 555
 556         IOLog( "Wait for root failed\n" );
 557         strlcpy( rootName, "en0", rootNameSize );
 558         flags |= 1;
 559     }
 560
 561     IOLog( "BSD root: %s", rootName );
 562     if( mjr)
 563         IOLog(", major %d, minor %d\n", mjr, mnr );
 564     else
 565         IOLog("\n");
 566
 567     *root = makedev( mjr, mnr );
 568     *oflags = flags;
 569
 570     IOFree( str,  kMaxPathBuf + kMaxBootVar );
 571
 572 iofrootx:
 573     if( (gIOKitDebug & (kIOLogDTree | kIOLogServiceTree | kIOLogMemory)) && !debugInfoPrintedOnce) {
 574
 575         IOService::getPlatform()->waitQuiet();
 576         if( gIOKitDebug & kIOLogDTree) {
 577             IOLog("\nDT plane:\n");
 578             IOPrintPlane( gIODTPlane );
 579         }
 580         if( gIOKitDebug & kIOLogServiceTree) {
 581             IOLog("\nService plane:\n");
 582             IOPrintPlane( gIOServicePlane );
 583         }
 584         if( gIOKitDebug & kIOLogMemory)
 585             IOPrintMemory();
 586     }
 587
 588     return( kIOReturnSuccess );
 589 }
 590
 591 bool IORamDiskBSDRoot(void)
 592 {
 593     char rdBootVar[kMaxBootVar];
 594     if (PE_parse_boot_argn("rd", rdBootVar, kMaxBootVar )
 595      || PE_parse_boot_argn("rootdev", rdBootVar, kMaxBootVar )) {
 596         if((rdBootVar[0] == 'm') && (rdBootVar[1] == 'd') && (rdBootVar[3] == 0)) {
 597             return true;
 598         }
 599     }
 600     return false;
 601 }
 602
 603 void IOSecureBSDRoot(const char * rootName)
 604 {
 605 }
 606
 607 void *
 608 IOBSDRegistryEntryForDeviceTree(char * path)
 609 {
 610     return (IORegistryEntry::fromPath(path, gIODTPlane));
 611 }
 612
 613 void
 614 IOBSDRegistryEntryRelease(void * entry)
 615 {
 616     IORegistryEntry * regEntry = (IORegistryEntry *)entry;
 617
 618     if (regEntry)
 619         regEntry->release();
 620     return;
 621 }
 622
 623 const void *
 624 IOBSDRegistryEntryGetData(void * entry, char * property_name,
 625                           int * packet_length)
 626 {
 627     OSData *            data;
 628     IORegistryEntry *   regEntry = (IORegistryEntry *)entry;
 629
 630     data = (OSData *) regEntry->getProperty(property_name);
 631     if (data) {
 632         *packet_length = data->getLength();
 633         return (data->getBytesNoCopy());
 634     }
 635     return (NULL);
 636 }
 637
 638 kern_return_t IOBSDGetPlatformUUID( uuid_t uuid, mach_timespec_t timeout )
 639 {
 640     IOService * resources;
 641     OSString *  string;
 642
 643     resources = IOService::waitForService( IOService::resourceMatching( kIOPlatformUUIDKey ), ( timeout.tv_sec || timeout.tv_nsec ) ? &timeout : 0 );
 644     if ( resources == 0 ) return KERN_OPERATION_TIMED_OUT;
 645
 646     string = ( OSString * ) IOService::getPlatform( )->getProvider( )->getProperty( kIOPlatformUUIDKey );
 647     if ( string == 0 ) return KERN_NOT_SUPPORTED;
 648
 649     uuid_parse( string->getCStringNoCopy( ), uuid );
 650
 651     return KERN_SUCCESS;
 652 }
 653
 654 kern_return_t IOBSDGetPlatformSerialNumber( char *serial_number_str, u_int32_t len )
 655 {
 656     OSDictionary * platform_dict;
 657     IOService *platform;
 658     OSString *  string;
 659
 660     if (len < 1) {
 661             return 0;
 662     }
 663     serial_number_str[0] = '\0';
 664
 665     platform_dict = IOService::serviceMatching( "IOPlatformExpertDevice" );
 666     if (platform_dict == NULL) {
 667             return KERN_NOT_SUPPORTED;
 668     }
 669
 670     platform = IOService::waitForService( platform_dict );
 671     if (platform) {
 672             string = ( OSString * ) platform->getProperty( kIOPlatformSerialNumberKey );
 673             if ( string == 0 ) {
 674                     return KERN_NOT_SUPPORTED;
 675             } else {
 676                     strlcpy( serial_number_str, string->getCStringNoCopy( ), len );
 677             }
 678     }
 679
 680     return KERN_SUCCESS;
 681 }
 682
 683 void IOBSDIterateMediaWithContent(const char *content_uuid_cstring, int (*func)(const char *bsd_dev_name, const char *uuid_str, void *arg), void *arg)
 684 {
 685     OSDictionary *dictionary;
 686     OSString *content_uuid_string;
 687
 688     dictionary = IOService::serviceMatching( "IOMedia" );
 689     if( dictionary ) {
 690         content_uuid_string = OSString::withCString( content_uuid_cstring );
 691         if( content_uuid_string ) {
 692             IOService *service;
 693             OSIterator *iter;
 694
 695             dictionary->setObject( "Content", content_uuid_string );
 696             dictionary->retain();
 697
 698             iter = IOService::getMatchingServices(dictionary);
 699             while (iter && (service = (IOService *)iter->getNextObject())) {
 700                     if( service ) {
 701                             OSString *iostr = (OSString *) service->getProperty( kIOBSDNameKey );
 702                             OSString *uuidstr = (OSString *) service->getProperty( "UUID" );
 703                             const char *uuid;
 704
 705                             if( iostr) {
 706                                     if (uuidstr) {
 707                                             uuid = uuidstr->getCStringNoCopy();
 708                                     } else {
 709                                             uuid = "00000000-0000-0000-0000-000000000000";
 710                                     }
 711
 712                                     // call the callback
 713                                     if (func && func(iostr->getCStringNoCopy(), uuid, arg) == 0) {
 714                                             break;
 715                                     }
 716                             }
 717                     }
 718             }
 719             if (iter)
 720                     iter->release();
 721
 722             content_uuid_string->release();
 723         }
 724         dictionary->release();
 725     }
 726 }
 727
 728
 729 int IOBSDIsMediaEjectable( const char *cdev_name )
 730 {
 731     int ret = 0;
 732     OSDictionary *dictionary;
 733     OSString *dev_name;
 734
 735     if (strncmp(cdev_name, "/dev/", 5) == 0) {
 736             cdev_name += 5;
 737     }
 738
 739     dictionary = IOService::serviceMatching( "IOMedia" );
 740     if( dictionary ) {
 741         dev_name = OSString::withCString( cdev_name );
 742         if( dev_name ) {
 743             IOService *service;
 744             mach_timespec_t tv = { 5, 0 };    // wait up to "timeout" seconds for the device
 745
 746             dictionary->setObject( kIOBSDNameKey, dev_name );
 747             dictionary->retain();
 748             service = IOService::waitForService( dictionary, &tv );
 749             if( service ) {
 750                 OSBoolean *ejectable = (OSBoolean *) service->getProperty( "Ejectable" );
 751
 752                 if( ejectable ) {
 753                         ret = (int)ejectable->getValue();
 754                 }
 755
 756             }
 757             dev_name->release();
 758         }
 759         dictionary->release();
 760     }
 761
 762     return ret;
 763 }
 764
 765 } /* extern "C" */