xnu-3789.1.32.tar.gz

[apple/xnu.git] / iokit / bsddev / IOKitBSDInit.cpp

diff --git a/iokit/bsddev/IOKitBSDInit.cpp b/iokit/bsddev/IOKitBSDInit.cpp
index 0900a09855b7aaded06b573c8e3b574d6442c6d0..a35aa54953d13e7328de76b3739e4b57de405b45 100644 (file)
--- a/iokit/bsddev/IOKitBSDInit.cpp
+++ b/iokit/bsddev/IOKitBSDInit.cpp
@@ -1,16 +1,19 @@
 /*
 /*

- * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1998-2011 Apple Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
- * 
- * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in
  * 
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in

- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ * 
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.

  * 
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * 
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER


@@ -20,38 +23,137 @@
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * 
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 #include <IOKit/IOBSD.h>
 #include <IOKit/IOLib.h>
 #include <IOKit/IOService.h>
  */
 #include <IOKit/IOBSD.h>
 #include <IOKit/IOLib.h>
 #include <IOKit/IOService.h>

+#include <IOKit/IOCatalogue.h>

 #include <IOKit/IODeviceTreeSupport.h>
 #include <IOKit/IOKitKeys.h>
 #include <IOKit/IOPlatformExpert.h>
 #include <IOKit/IODeviceTreeSupport.h>
 #include <IOKit/IOKitKeys.h>
 #include <IOKit/IOPlatformExpert.h>

-
-#include <sys/disklabel.h>
+#include <IOKit/IOUserClient.h>

 
 extern "C" {
 
 #include <pexpert/pexpert.h>
 #include <kern/clock.h>
 
 extern "C" {
 
 #include <pexpert/pexpert.h>
 #include <kern/clock.h>

+#include <uuid/uuid.h>
+#include <sys/vnode_internal.h>
+#include <sys/mount.h>

 
 // how long to wait for matching root device, secs
 
 // how long to wait for matching root device, secs

-#define ROOTDEVICETIMEOUT      60
+#if DEBUG
+#define ROOTDEVICETIMEOUT       120
+#else
+#define ROOTDEVICETIMEOUT       60
+#endif
+
+int panic_on_exception_triage = 0;

 
 

-extern dev_t mdevadd(int devid, ppnum_t base, unsigned int size, int phys);
+extern dev_t mdevadd(int devid, uint64_t base, unsigned int size, int phys);

 extern dev_t mdevlookup(int devid);
 extern dev_t mdevlookup(int devid);

+extern void mdevremoveall(void);
+extern int mdevgetrange(int devid, uint64_t *base, uint64_t *size);
+extern void di_root_ramfile(IORegistryEntry * entry);
+
+
+#if   DEVELOPMENT
+#define IOPOLLED_COREFILE      1
+// no sizing
+#define kIOCoreDumpSize                0ULL
+#define kIOCoreDumpFreeSize    0ULL
+#else
+#define IOPOLLED_COREFILE      0
+#endif
+
+
+#if IOPOLLED_COREFILE
+static bool 
+NewKernelCoreMedia(void * target, void * refCon,
+                  IOService * newService,
+                  IONotifier * notifier);
+#endif /* IOPOLLED_COREFILE */
+
+#if CONFIG_KDP_INTERACTIVE_DEBUGGING
+/*
+ * Touched by IOFindBSDRoot() if a RAMDisk is used for the root device.
+ */
+extern uint64_t kdp_core_ramdisk_addr;
+extern uint64_t kdp_core_ramdisk_size;
+#endif

 
 kern_return_t
 IOKitBSDInit( void )
 {
 
 kern_return_t
 IOKitBSDInit( void )
 {

-    IOLog("IOKitBSDInit\n");
-

     IOService::publishResource("IOBSD");
     IOService::publishResource("IOBSD");

- 
+

     return( kIOReturnSuccess );
 }
 
     return( kIOReturnSuccess );
 }
 

+void
+IOServicePublishResource( const char * property, boolean_t value )
+{
+    if ( value)
+        IOService::publishResource( property, kOSBooleanTrue );
+    else
+        IOService::getResourceService()->removeProperty( property );
+}
+
+boolean_t
+IOServiceWaitForMatchingResource( const char * property, uint64_t timeout )
+{
+    OSDictionary *     dict = 0;
+    IOService *         match = 0;
+    boolean_t          found = false;
+    
+    do {
+        
+        dict = IOService::resourceMatching( property );
+        if( !dict)
+            continue;
+        match = IOService::waitForMatchingService( dict, timeout );
+        if ( match)
+            found = true;
+        
+    } while( false );
+    
+    if( dict)
+        dict->release();
+    if( match)
+        match->release();
+    
+    return( found );
+}
+
+boolean_t
+IOCatalogueMatchingDriversPresent( const char * property )
+{
+    OSDictionary *     dict = 0;
+    OSOrderedSet *     set = 0;
+    SInt32             generationCount = 0;
+    boolean_t          found = false;
+    
+    do {
+        
+        dict = OSDictionary::withCapacity(1);
+        if( !dict)
+            continue;
+        dict->setObject( property, kOSBooleanTrue );
+        set = gIOCatalogue->findDrivers( dict, &generationCount );
+        if ( set && (set->getCount() > 0))
+            found = true;
+        
+    } while( false );
+    
+    if( dict)
+        dict->release();
+    if( set)
+        set->release();
+    
+    return( found );
+}
+

 OSDictionary * IOBSDNameMatching( const char * name )
 {
     OSDictionary *     dict;
 OSDictionary * IOBSDNameMatching( const char * name )
 {
     OSDictionary *     dict;


@@ -80,81 +182,9 @@ OSDictionary * IOBSDNameMatching( const char * name )
     return( 0 );
 }
 
     return( 0 );
 }
 

-OSDictionary * IOCDMatching( const char * name )
+OSDictionary * IOUUIDMatching( void )

 {
 {

-    OSDictionary *     dict;
-    const OSSymbol *   str;
-
-       dict = IOService::serviceMatching( "IOMedia" );
-       if( dict == 0 ) {
-          IOLog("Unable to find IOMedia\n");
-          return 0;
-       } 
-
-       str = OSSymbol::withCString( "CD_ROM_Mode_1" );
-       if( str == 0 ) {
-           dict->release();
-           return 0;
-       }
-
-       dict->setObject( "Content", (OSObject *)str );
-       str->release();
-        return( dict );
-}
-
-OSDictionary * IONetworkMatching(  const char * path,
-                                  char * buf, int maxLen )
-{
-    OSDictionary *     matching = 0;
-    OSDictionary *     dict;
-    OSString *         str;
-    char *             comp;
-    const char *       skip;
-    int                        len;
-
-    do {
-
-       len = strlen( kIODeviceTreePlane ":" );
-       maxLen -= len;
-       if( maxLen < 0)
-           continue;
-
-       strcpy( buf, kIODeviceTreePlane ":" );
-       comp = buf + len;
-
-        // remove parameters following ':' from the path
-        skip = strchr( path, ':');
-       if( !skip)
-           continue;
-
-        len = skip - path;
-       maxLen -= len;
-       if( maxLen < 0)
-           continue;
-        strncpy( comp, path, len );
-        comp[ len ] = 0;
-
-       matching = IOService::serviceMatching( "IONetworkInterface" );
-       if( !matching)
-           continue;
-       dict = IOService::addLocation( matching );
-       if( !dict)
-           continue;
-
-       str = OSString::withCString( buf );
-       if( !str)
-           continue;
-        dict->setObject( kIOPathMatchKey, str );
-       str->release();
-
-       return( matching );
-
-    } while( false );
-
-    if( matching)
-        matching->release();
-
-    return( 0 );
+    return IOService::resourceMatching( "boot-uuid-media" );

 }
 
 OSDictionary * IONetworkNamePrefixMatching( const char * prefix )
 }
 
 OSDictionary * IONetworkNamePrefixMatching( const char * prefix )


@@ -162,7 +192,8 @@ OSDictionary * IONetworkNamePrefixMatching( const char * prefix )
     OSDictionary *      matching;
     OSDictionary *   propDict = 0;
     const OSSymbol * str      = 0;
     OSDictionary *      matching;
     OSDictionary *   propDict = 0;
     const OSSymbol * str      = 0;

-
+       char networkType[128];
+       

     do {
         matching = IOService::serviceMatching( "IONetworkInterface" );
         if ( matching == 0 )
     do {
         matching = IOService::serviceMatching( "IONetworkInterface" );
         if ( matching == 0 )


@@ -180,6 +211,18 @@ OSDictionary * IONetworkNamePrefixMatching( const char * prefix )
         str->release();
         str = 0;
 
         str->release();
         str = 0;
 

+               // see if we're contrained to netroot off of specific network type
+               if(PE_parse_boot_argn( "network-type", networkType, 128 ))
+               {
+                       str = OSSymbol::withCString( networkType );
+                       if(str)
+                       {
+                               propDict->setObject( "IONetworkRootType", str);
+                               str->release();
+                               str = 0;
+                       }
+               }
+

         if ( matching->setObject( gIOPropertyMatchKey,
                                   (OSObject *) propDict ) != true )
             continue;
         if ( matching->setObject( gIOPropertyMatchKey,
                                   (OSObject *) propDict ) != true )
             continue;


@@ -251,87 +294,53 @@ static bool IORegisterNetworkInterface( IOService * netif )
        return ( netif->getProperty( kIOBSDNameKey ) != 0 );
 }
 
        return ( netif->getProperty( kIOBSDNameKey ) != 0 );
 }
 

-OSDictionary * IODiskMatching( const char * path, char * buf, int maxLen )
+OSDictionary * IOOFPathMatching( const char * path, char * buf, int maxLen )

 {
 {

-    const char * look;
-    const char * alias;
-    char *       comp;
-    long         unit = -1;
-    long         partition = -1;
-    char         c;
-
-    // scan the tail of the path for "@unit:partition"
-    do {
-        // Have to get the full path to the controller - an alias may
-        // tell us next to nothing, like "hd:8"
-        alias = IORegistryEntry::dealiasPath( &path, gIODTPlane );
-
-        look = path + strlen( path);
-        c = ':';
-        while( look != path) {
-            if( *(--look) == c) {
-                if( c == ':') {
-                    partition = strtol( look + 1, 0, 0 );
-                    c = '@';
-                } else if( c == '@') {
-                    unit = strtol( look + 1, 0, 16 );
-                    c = '/';
-                } else if( c == '/') {
-                    c = 0;
-                    break;
-                }
-            }
+    OSDictionary *     matching = NULL;
+    OSString *         str;
+    char *             comp;
+    int                        len;

 
 

-               if( alias && (look == path)) {
-                path = alias;
-                look = path + strlen( path);
-                alias = 0;
-            }
-        }
-        if( c || unit == -1 || partition == -1)
-            continue;
+    do {

 
 

-        maxLen -= strlen( "{" kIOPathMatchKey "='" kIODeviceTreePlane ":" );
-        maxLen -= ( alias ? strlen( alias ) : 0 ) + (look - path);
-        maxLen -= strlen( "/@hhhhhhhh:dddddddddd';}" );
+       len = strlen( kIODeviceTreePlane ":" );
+       maxLen -= len;
+       if( maxLen <= 0)
+           continue;

 
 

-        if( maxLen > 0) {
-            sprintf( buf, "{" kIOPathMatchKey "='" kIODeviceTreePlane ":" );
-            comp = buf + strlen( buf );
+       strlcpy( buf, kIODeviceTreePlane ":", len + 1 );
+       comp = buf + len;

 
 

-            if( alias) {
-                strcpy( comp, alias );
-                comp += strlen( alias );
-            }
+       len = strlen( path );
+       maxLen -= len;
+       if( maxLen <= 0)
+           continue;
+       strlcpy( comp, path, len + 1 );

 
 

-            if ( (look - path)) {
-                strncpy( comp, path, look - path);
-                comp += look - path;
-            }
+       matching = OSDictionary::withCapacity( 1 );
+       if( !matching)
+           continue;

 
 

-            sprintf( comp, "/@%lx:%ld';}", unit, partition );
-        } else
-            continue;
+       str = OSString::withCString( buf );
+       if( !str)
+           continue;
+        matching->setObject( kIOPathMatchKey, str );
+       str->release();

 
 

-        return( OSDynamicCast(OSDictionary, OSUnserialize( buf, 0 )) );
+       return( matching );

 
     } while( false );
 
 
     } while( false );
 

-    return( 0 );
-}
-
-OSDictionary * IOOFPathMatching( const char * path, char * buf, int maxLen )
-{
-    /* need to look up path, get device type,
-        call matching help based on device type */
-
-    return( IODiskMatching( path, buf, maxLen ));
+    if( matching)
+        matching->release();

 
 

+    return( 0 );

 }
 
 static int didRam = 0;
 }
 
 static int didRam = 0;

+enum { kMaxPathBuf = 512, kMaxBootVar = 128 };

 
 

-kern_return_t IOFindBSDRoot( char * rootName,
+kern_return_t IOFindBSDRoot( char * rootName, unsigned int rootNameSize,

                                dev_t * root, u_int32_t * oflags )
 {
     mach_timespec_t    t;
                                dev_t * root, u_int32_t * oflags )
 {
     mach_timespec_t    t;


@@ -341,62 +350,81 @@ kern_return_t IOFindBSDRoot( char * rootName,
     OSString *         iostr;
     OSNumber *         off;
     OSData *           data = 0;
     OSString *         iostr;
     OSNumber *         off;
     OSData *           data = 0;

-    UInt32             *ramdParms = 0;

 
     UInt32             flags = 0;
 
     UInt32             flags = 0;

-    int                        minor, major;
+    int                        mnr, mjr;
+    const char *        mediaProperty = 0;

     char *             rdBootVar;
     char *             rdBootVar;

-    enum {             kMaxPathBuf = 512, kMaxBootVar = 128 };

     char *             str;
     const char *       look = 0;
     int                        len;
     char *             str;
     const char *       look = 0;
     int                        len;

-    bool               forceNet = false;

     bool               debugInfoPrintedOnce = false;
     bool               debugInfoPrintedOnce = false;

+    const char *       uuidStr = NULL;

 
     static int         mountAttempts = 0;
                                
 
     static int         mountAttempts = 0;
                                

-       int xchar, dchar;
-                               
+    int xchar, dchar;
+
+    // stall here for anyone matching on the IOBSD resource to finish (filesystems)
+    matching = IOService::serviceMatching(gIOResourcesKey);
+    assert(matching);
+    matching->setObject(gIOResourceMatchedKey, gIOBSDKey);
+
+       if ((service = IOService::waitForMatchingService(matching, 30ULL * kSecondScale))) {
+               service->release();
+       } else {
+               IOLog("!BSD\n");
+       }
+    matching->release();
+       matching = NULL;

 
     if( mountAttempts++)
 
     if( mountAttempts++)

+    {
+        IOLog("mount(%d) failed\n", mountAttempts);

        IOSleep( 5 * 1000 );
        IOSleep( 5 * 1000 );

+    }

 
     str = (char *) IOMalloc( kMaxPathBuf + kMaxBootVar );
     if( !str)
        return( kIOReturnNoMemory );
     rdBootVar = str + kMaxPathBuf;
 
 
     str = (char *) IOMalloc( kMaxPathBuf + kMaxBootVar );
     if( !str)
        return( kIOReturnNoMemory );
     rdBootVar = str + kMaxPathBuf;
 

-    if (!PE_parse_boot_arg("rd", rdBootVar )
-     && !PE_parse_boot_arg("rootdev", rdBootVar ))
+    if (!PE_parse_boot_argn("rd", rdBootVar, kMaxBootVar )
+     && !PE_parse_boot_argn("rootdev", rdBootVar, kMaxBootVar ))

        rdBootVar[0] = 0;
 
     do {
        rdBootVar[0] = 0;
 
     do {

-        if( (regEntry = IORegistryEntry::fromPath( "/chosen", gIODTPlane ))) {
-                       data = (OSData *) regEntry->getProperty( "rootpath" );
-                       regEntry->release();
-                       if( data) continue;
-               }
-        if( (regEntry = IORegistryEntry::fromPath( "/options", gIODTPlane ))) {
-                       data = (OSData *) regEntry->getProperty( "boot-file" );
-                       regEntry->release();
-                       if( data) continue;
-               }
-    } while( false );
-
-    if( data)
-        look = (const char *) data->getBytesNoCopy();
+       if( (regEntry = IORegistryEntry::fromPath( "/chosen", gIODTPlane ))) {
+           di_root_ramfile(regEntry);
+            data = OSDynamicCast(OSData, regEntry->getProperty( "root-matching" ));
+            if (data) {
+               matching = OSDynamicCast(OSDictionary, OSUnserializeXML((char *)data->getBytesNoCopy()));
+                if (matching) {
+                    continue;
+                }
+            }

 
 

-    if( rdBootVar[0] == '*') {
-        look = rdBootVar + 1;
-               forceNet = false;
-    } else {
-        if( (regEntry = IORegistryEntry::fromPath( "/", gIODTPlane ))) {
-            forceNet = (0 != regEntry->getProperty( "net-boot" ));
-               regEntry->release();
+           data = (OSData *) regEntry->getProperty( "boot-uuid" );
+           if( data) {
+               uuidStr = (const char*)data->getBytesNoCopy();
+               OSString *uuidString = OSString::withCString( uuidStr );
+
+               // match the boot-args boot-uuid processing below
+               if( uuidString) {
+                   IOLog("rooting via boot-uuid from /chosen: %s\n", uuidStr);
+                   IOService::publishResource( "boot-uuid", uuidString );
+                   uuidString->release();
+                   matching = IOUUIDMatching();
+                   mediaProperty = "boot-uuid-media";
+                   regEntry->release();
+                   continue;
+               } else {
+                   uuidStr = NULL;

                }
                }

-    }
-
-
+           }
+           regEntry->release();
+       }
+    } while( false );

 
 //
 //     See if we have a RAMDisk property in /chosen/memory-map.  If so, make it into a device.
 
 //
 //     See if we have a RAMDisk property in /chosen/memory-map.  If so, make it into a device.


@@ -408,9 +436,9 @@ kern_return_t IOFindBSDRoot( char * rootName,
                if((regEntry = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane ))) {        /* Find the map node */
                        data = (OSData *)regEntry->getProperty("RAMDisk");      /* Find the ram disk, if there */
                        if(data) {                                                                                      /* We found one */
                if((regEntry = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane ))) {        /* Find the map node */
                        data = (OSData *)regEntry->getProperty("RAMDisk");      /* Find the ram disk, if there */
                        if(data) {                                                                                      /* We found one */

-
-                               ramdParms = (UInt32 *)data->getBytesNoCopy();   /* Point to the ram disk base and size */
-                               (void)mdevadd(-1, ramdParms[0] >> 12, ramdParms[1] >> 12, 0);   /* Initialize it and pass back the device number */
+                               uintptr_t *ramdParms;
+                               ramdParms = (uintptr_t *)data->getBytesNoCopy();        /* Point to the ram disk base and size */
+                               (void)mdevadd(-1, ml_static_ptovirt(ramdParms[0]) >> 12, ramdParms[1] >> 12, 0);        /* Initialize it and pass back the device number */

                        }
                        regEntry->release();                                                            /* Toss the entry */
                }
                        }
                        regEntry->release();                                                            /* Toss the entry */
                }


@@ -434,30 +462,28 @@ kern_return_t IOFindBSDRoot( char * rootName,
                if(xchar >= 0) {                                                                                /* Do we have a valid memory device name? */
                        *root = mdevlookup(xchar);                                                      /* Find the device number */
                        if(*root >= 0) {                                                                        /* Did we find one? */
                if(xchar >= 0) {                                                                                /* Do we have a valid memory device name? */
                        *root = mdevlookup(xchar);                                                      /* Find the device number */
                        if(*root >= 0) {                                                                        /* Did we find one? */

-

                                rootName[0] = 'm';                                                              /* Build root name */
                                rootName[1] = 'd';                                                              /* Build root name */
                                rootName[2] = dchar;                                                    /* Build root name */
                                rootName[3] = 0;                                                                /* Build root name */
                                IOLog("BSD root: %s, major %d, minor %d\n", rootName, major(*root), minor(*root));
                                *oflags = 0;                                                                    /* Show that this is not network */
                                rootName[0] = 'm';                                                              /* Build root name */
                                rootName[1] = 'd';                                                              /* Build root name */
                                rootName[2] = dchar;                                                    /* Build root name */
                                rootName[3] = 0;                                                                /* Build root name */
                                IOLog("BSD root: %s, major %d, minor %d\n", rootName, major(*root), minor(*root));
                                *oflags = 0;                                                                    /* Show that this is not network */

+
+#if CONFIG_KDP_INTERACTIVE_DEBUGGING
+                /* retrieve final ramdisk range and initialize KDP variables */
+                if (mdevgetrange(xchar, &kdp_core_ramdisk_addr, &kdp_core_ramdisk_size) != 0) {
+                    IOLog("Unable to retrieve range for root memory device %d\n", xchar);
+                    kdp_core_ramdisk_addr = 0;
+                    kdp_core_ramdisk_size = 0;
+                }
+#endif
+

                                goto iofrootx;                                                                  /* Join common exit... */
                        }
                        panic("IOFindBSDRoot: specified root memory device, %s, has not been configured\n", rdBootVar); /* Not there */
                }
        }
 
                                goto iofrootx;                                                                  /* Join common exit... */
                        }
                        panic("IOFindBSDRoot: specified root memory device, %s, has not been configured\n", rdBootVar); /* Not there */
                }
        }
 

-    if( look) {
-       // from OpenFirmware path
-       IOLog("From path: \"%s\", ", look);
-
-       if( forceNet || (0 == strncmp( look, "enet", strlen( "enet" ))) ) {
-            matching = IONetworkMatching( look, str, kMaxPathBuf );
-        } else {
-            matching = IODiskMatching( look, str, kMaxPathBuf );
-        }
-    }
-    

       if( (!matching) && rdBootVar[0] ) {
        // by BSD name
        look = rdBootVar;
       if( (!matching) && rdBootVar[0] ) {
        // by BSD name
        look = rdBootVar;


@@ -466,24 +492,48 @@ kern_return_t IOFindBSDRoot( char * rootName,
     
        if ( strncmp( look, "en", strlen( "en" )) == 0 ) {
            matching = IONetworkNamePrefixMatching( "en" );
     
        if ( strncmp( look, "en", strlen( "en" )) == 0 ) {
            matching = IONetworkNamePrefixMatching( "en" );

-       } else if ( strncmp( look, "cdrom", strlen( "cdrom" )) == 0 ) { 
-           matching = IOCDMatching( look );
+       } else if ( strncmp( look, "uuid", strlen( "uuid" )) == 0 ) {
+            char *uuid;
+            OSString *uuidString;
+
+            uuid = (char *)IOMalloc( kMaxBootVar );
+                  
+            if ( uuid ) {
+                if (!PE_parse_boot_argn( "boot-uuid", uuid, kMaxBootVar )) {
+                    panic( "rd=uuid but no boot-uuid=<value> specified" ); 
+                } 
+                uuidString = OSString::withCString( uuid );
+                if ( uuidString ) {
+                    IOService::publishResource( "boot-uuid", uuidString );
+                    uuidString->release();
+                    IOLog( "\nWaiting for boot volume with UUID %s\n", uuid );
+                    matching = IOUUIDMatching();
+                    mediaProperty = "boot-uuid-media";
+                }
+                IOFree( uuid, kMaxBootVar );
+            }

        } else {
            matching = IOBSDNameMatching( look );
        }
     }
 
     if( !matching) {
        } else {
            matching = IOBSDNameMatching( look );
        }
     }
 
     if( !matching) {

-        OSString * astring;
-       // any UFS
+       OSString * astring;
+       // Match any HFS media
+       

         matching = IOService::serviceMatching( "IOMedia" );
         matching = IOService::serviceMatching( "IOMedia" );

-        astring = OSString::withCStringNoCopy("Apple_UFS");
+        astring = OSString::withCStringNoCopy("Apple_HFS");

         if ( astring ) {
             matching->setObject("Content", astring);
             astring->release();
         }
     }
 
         if ( astring ) {
             matching->setObject("Content", astring);
             astring->release();
         }
     }
 

+    if( gIOKitDebug & kIOWaitQuietBeforeRoot ) {
+       IOLog( "Waiting for matching to complete\n" );
+       IOService::getPlatform()->waitQuiet();
+    }
+

     if( true && matching) {
         OSSerialize * s = OSSerialize::withCapacity( 5 );
 
     if( true && matching) {
         OSSerialize * s = OSSerialize::withCapacity( 5 );
 


@@ -519,8 +569,12 @@ kern_return_t IOFindBSDRoot( char * rootName,
     } while( !service);
     matching->release();
 
     } while( !service);
     matching->release();
 

-    major = 0;
-    minor = 0;
+    if ( service && mediaProperty ) {
+        service = (IOService *)service->getProperty(mediaProperty);
+    }
+
+    mjr = 0;
+    mnr = 0;

 
     // If the IOService we matched to is a subclass of IONetworkInterface,
     // then make sure it has been registered with BSD and has a BSD name
 
     // If the IOService we matched to is a subclass of IONetworkInterface,
     // then make sure it has been registered with BSD and has a BSD name


@@ -541,13 +595,13 @@ kern_return_t IOFindBSDRoot( char * rootName,
 
        iostr = (OSString *) service->getProperty( kIOBSDNameKey );
        if( iostr)
 
        iostr = (OSString *) service->getProperty( kIOBSDNameKey );
        if( iostr)

-           strcpy( rootName, iostr->getCStringNoCopy() );
+           strlcpy( rootName, iostr->getCStringNoCopy(), rootNameSize );

        off = (OSNumber *) service->getProperty( kIOBSDMajorKey );
        if( off)
        off = (OSNumber *) service->getProperty( kIOBSDMajorKey );
        if( off)

-           major = off->unsigned32BitValue();
+           mjr = off->unsigned32BitValue();

        off = (OSNumber *) service->getProperty( kIOBSDMinorKey );
        if( off)
        off = (OSNumber *) service->getProperty( kIOBSDMinorKey );
        if( off)

-           minor = off->unsigned32BitValue();
+           mnr = off->unsigned32BitValue();

 
        if( service->metaCast( "IONetworkInterface" ))
            flags |= 1;
 
        if( service->metaCast( "IONetworkInterface" ))
            flags |= 1;


@@ -555,17 +609,17 @@ kern_return_t IOFindBSDRoot( char * rootName,
     } else {
 
        IOLog( "Wait for root failed\n" );
     } else {
 
        IOLog( "Wait for root failed\n" );

-        strcpy( rootName, "en0");
+        strlcpy( rootName, "en0", rootNameSize );

         flags |= 1;
     }
 
     IOLog( "BSD root: %s", rootName );
         flags |= 1;
     }
 
     IOLog( "BSD root: %s", rootName );

-    if( major)
-       IOLog(", major %d, minor %d\n", major, minor );
+    if( mjr)
+       IOLog(", major %d, minor %d\n", mjr, mnr );

     else
        IOLog("\n");
 
     else
        IOLog("\n");
 

-    *root = makedev( major, minor );
+    *root = makedev( mjr, mnr );

     *oflags = flags;
 
     IOFree( str,  kMaxPathBuf + kMaxBootVar );
     *oflags = flags;
 
     IOFree( str,  kMaxPathBuf + kMaxBootVar );


@@ -589,6 +643,22 @@ iofrootx:
     return( kIOReturnSuccess );
 }
 
     return( kIOReturnSuccess );
 }
 

+bool IORamDiskBSDRoot(void)
+{
+    char rdBootVar[kMaxBootVar];
+    if (PE_parse_boot_argn("rd", rdBootVar, kMaxBootVar )
+     || PE_parse_boot_argn("rootdev", rdBootVar, kMaxBootVar )) {
+        if((rdBootVar[0] == 'm') && (rdBootVar[1] == 'd') && (rdBootVar[3] == 0)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void IOSecureBSDRoot(const char * rootName)
+{
+}
+

 void *
 IOBSDRegistryEntryForDeviceTree(char * path)
 {
 void *
 IOBSDRegistryEntryForDeviceTree(char * path)
 {


@@ -620,4 +690,176 @@ IOBSDRegistryEntryGetData(void * entry, char * property_name,
     return (NULL);
 }
 
     return (NULL);
 }
 

+kern_return_t IOBSDGetPlatformUUID( uuid_t uuid, mach_timespec_t timeout )
+{
+    IOService * resources;
+    OSString *  string;
+
+    resources = IOService::waitForService( IOService::resourceMatching( kIOPlatformUUIDKey ), ( timeout.tv_sec || timeout.tv_nsec ) ? &timeout : 0 );
+    if ( resources == 0 ) return KERN_OPERATION_TIMED_OUT;
+
+    string = ( OSString * ) IOService::getPlatform( )->getProvider( )->getProperty( kIOPlatformUUIDKey );
+    if ( string == 0 ) return KERN_NOT_SUPPORTED;
+
+    uuid_parse( string->getCStringNoCopy( ), uuid );
+
+    return KERN_SUCCESS;
+}
+

 } /* extern "C" */
 } /* extern "C" */

+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <sys/conf.h>
+#include <sys/vnode.h>
+#include <sys/vnode_internal.h>
+#include <sys/fcntl.h>
+#include <IOKit/IOPolledInterface.h>
+#include <IOKit/IOBufferMemoryDescriptor.h>
+
+IOPolledFileIOVars * gIOPolledCoreFileVars;
+
+#if IOPOLLED_COREFILE
+
+static IOReturn 
+IOOpenPolledCoreFile(const char * filename)
+{
+    IOReturn err;
+    unsigned int debug;
+
+    if (gIOPolledCoreFileVars)                             return (kIOReturnBusy);
+    if (!IOPolledInterface::gMetaClass.getInstanceCount()) return (kIOReturnUnsupported);
+
+    debug = 0;
+    PE_parse_boot_argn("debug", &debug, sizeof (debug));
+    if (DB_DISABLE_LOCAL_CORE & debug)                     return (kIOReturnUnsupported);
+
+    err = IOPolledFileOpen(filename, kIOCoreDumpSize, kIOCoreDumpFreeSize,
+                           NULL, 0,
+                           &gIOPolledCoreFileVars, NULL, NULL, 0);
+    if (kIOReturnSuccess != err)                           return (err);
+
+    err = IOPolledFilePollersSetup(gIOPolledCoreFileVars, kIOPolledPreflightCoreDumpState);
+    if (kIOReturnSuccess != err)
+    {
+       IOPolledFileClose(&gIOPolledCoreFileVars, NULL, NULL, 0, 0, 0);
+    }
+
+    return (err);
+}
+
+static void 
+IOClosePolledCoreFile(void)
+{
+    IOPolledFilePollersClose(gIOPolledCoreFileVars, kIOPolledPostflightCoreDumpState);
+    IOPolledFileClose(&gIOPolledCoreFileVars, NULL, NULL, 0, 0, 0);
+}
+
+static thread_call_t gIOOpenPolledCoreFileTC;
+static IONotifier  * gIOPolledCoreFileNotifier;
+static IONotifier  * gIOPolledCoreFileInterestNotifier;
+
+static IOReturn 
+KernelCoreMediaInterest(void * target, void * refCon,
+                       UInt32 messageType, IOService * provider,
+                       void * messageArgument, vm_size_t argSize )
+{
+    if (kIOMessageServiceIsTerminated == messageType)
+    {
+       gIOPolledCoreFileInterestNotifier->remove();
+       gIOPolledCoreFileInterestNotifier = 0;
+       IOClosePolledCoreFile();
+    }
+
+    return (kIOReturnSuccess);
+}
+
+static void
+OpenKernelCoreMedia(thread_call_param_t p0, thread_call_param_t p1)
+{
+    IOService * newService;
+    OSString  * string;
+    char        filename[16];
+
+    newService = (IOService *) p1;
+    do
+    {
+       if (gIOPolledCoreFileVars) break;
+       string = OSDynamicCast(OSString, newService->getProperty(kIOBSDNameKey));
+       if (!string) break;
+       snprintf(filename, sizeof(filename), "/dev/%s", string->getCStringNoCopy());
+       if (kIOReturnSuccess != IOOpenPolledCoreFile(filename)) break;
+       gIOPolledCoreFileInterestNotifier = newService->registerInterest(
+                               gIOGeneralInterest, &KernelCoreMediaInterest, NULL, 0);
+    }
+    while (false);
+
+    newService->release();
+}
+
+static bool 
+NewKernelCoreMedia(void * target, void * refCon,
+                  IOService * newService,
+                  IONotifier * notifier)
+{
+    static volatile UInt32 onlyOneCorePartition = 0;
+    do
+    {
+       if (!OSCompareAndSwap(0, 1, &onlyOneCorePartition)) break;
+       if (gIOPolledCoreFileVars)    break;
+        if (!gIOOpenPolledCoreFileTC) break;
+        newService = newService->getProvider();
+        if (!newService)              break;
+        newService->retain();
+       thread_call_enter1(gIOOpenPolledCoreFileTC, newService);
+    }
+    while (false);
+
+    return (false);
+}
+
+#endif /* IOPOLLED_COREFILE */
+
+extern "C" void 
+IOBSDMountChange(struct mount * mp, uint32_t op)
+{
+#if IOPOLLED_COREFILE
+
+    OSDictionary * bsdMatching;
+    OSDictionary * mediaMatching;
+    OSString     * string;
+
+    if (!gIOPolledCoreFileNotifier) do
+    {
+       if (!gIOOpenPolledCoreFileTC) gIOOpenPolledCoreFileTC = thread_call_allocate(&OpenKernelCoreMedia, NULL);
+       bsdMatching = IOService::serviceMatching("IOMediaBSDClient");
+       if (!bsdMatching) break;
+       mediaMatching = IOService::serviceMatching("IOMedia");
+       string = OSString::withCStringNoCopy("5361644D-6163-11AA-AA11-00306543ECAC");
+       if (!string || !mediaMatching) break;
+       mediaMatching->setObject("Content", string);
+       string->release();
+       bsdMatching->setObject(gIOParentMatchKey, mediaMatching);
+       mediaMatching->release();
+
+       gIOPolledCoreFileNotifier = IOService::addMatchingNotification(
+                                                 gIOFirstMatchNotification, bsdMatching, 
+                                                 &NewKernelCoreMedia, NULL, NULL, -1000);
+    }
+    while (false);
+
+#endif /* IOPOLLED_COREFILE */
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+extern "C" boolean_t 
+IOTaskHasEntitlement(task_t task, const char * entitlement)
+{
+    OSObject * obj;
+    obj = IOUserClient::copyClientEntitlement(task, entitlement);
+    if (!obj) return (false);
+    obj->release();
+    return (obj != kOSBooleanFalse);
+}
+