xnu-1228.0.2.tar.gz

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

diff --git a/iokit/bsddev/IOKitBSDInit.cpp b/iokit/bsddev/IOKitBSDInit.cpp
index 0900a09855b7aaded06b573c8e3b574d6442c6d0..7621a257f032f718745f1ea39427ba2a29220f67 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-2000 Apple Computer, 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,7 +23,7 @@
  * 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/IOBSD.h>
 #include <IOKit/IOLib.h>


@@ -29,12 +32,11 @@
 #include <IOKit/IOKitKeys.h>
 #include <IOKit/IOPlatformExpert.h>
 
 #include <IOKit/IOKitKeys.h>
 #include <IOKit/IOPlatformExpert.h>
 

-#include <sys/disklabel.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>

 
 // how long to wait for matching root device, secs
 #define ROOTDEVICETIMEOUT      60
 
 // how long to wait for matching root device, secs
 #define ROOTDEVICETIMEOUT      60


@@ -45,8 +47,6 @@ extern dev_t mdevlookup(int devid);
 kern_return_t
 IOKitBSDInit( void )
 {
 kern_return_t
 IOKitBSDInit( void )
 {

-    IOLog("IOKitBSDInit\n");
-

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


@@ -80,26 +80,32 @@ 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;
-       } 
+    return IOService::resourceMatching( "boot-uuid-media" );
+}

 
 

-       str = OSSymbol::withCString( "CD_ROM_Mode_1" );
-       if( str == 0 ) {
-           dict->release();
-           return 0;
-       }

 
 

-       dict->setObject( "Content", (OSObject *)str );
-       str->release();
-        return( dict );
+OSDictionary * IOCDMatching( 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 Hint", (OSObject *)str );
+    str->release();        
+    return( dict );

 }
 
 OSDictionary * IONetworkMatching(  const char * path,
 }
 
 OSDictionary * IONetworkMatching(  const char * path,


@@ -162,7 +168,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 +187,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;


@@ -258,6 +277,7 @@ OSDictionary * IODiskMatching( const char * path, char * buf, int maxLen )
     char *       comp;
     long         unit = -1;
     long         partition = -1;
     char *       comp;
     long         unit = -1;
     long         partition = -1;

+    long                lun = -1;

     char         c;
 
     // scan the tail of the path for "@unit:partition"
     char         c;
 
     // scan the tail of the path for "@unit:partition"


@@ -265,7 +285,7 @@ OSDictionary * IODiskMatching( const char * path, char * buf, int maxLen )
         // 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 );
         // 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) {
         look = path + strlen( path);
         c = ':';
         while( look != path) {


@@ -274,7 +294,12 @@ OSDictionary * IODiskMatching( const char * path, char * buf, int maxLen )
                     partition = strtol( look + 1, 0, 0 );
                     c = '@';
                 } else if( c == '@') {
                     partition = strtol( look + 1, 0, 0 );
                     c = '@';
                 } else if( c == '@') {

-                    unit = strtol( look + 1, 0, 16 );
+                    unit = strtol( look + 1, &comp, 16 );
+
+                    if( *comp == ',') {
+                        lun = strtol( comp + 1, 0, 16 );
+                    }
+                    

                     c = '/';
                 } else if( c == '/') {
                     c = 0;
                     c = '/';
                 } else if( c == '/') {
                     c = 0;


@@ -290,29 +315,36 @@ OSDictionary * IODiskMatching( const char * path, char * buf, int maxLen )
         }
         if( c || unit == -1 || partition == -1)
             continue;
         }
         if( c || unit == -1 || partition == -1)
             continue;

-
+               

         maxLen -= strlen( "{" kIOPathMatchKey "='" kIODeviceTreePlane ":" );
         maxLen -= ( alias ? strlen( alias ) : 0 ) + (look - path);
         maxLen -= strlen( "{" kIOPathMatchKey "='" kIODeviceTreePlane ":" );
         maxLen -= ( alias ? strlen( alias ) : 0 ) + (look - path);

-        maxLen -= strlen( "/@hhhhhhhh:dddddddddd';}" );
+        maxLen -= strlen( "/@hhhhhhhh,hhhhhhhh:dddddddddd';}" );

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

-
+                       

             if( alias) {
                 strcpy( comp, alias );
                 comp += strlen( alias );
             }
             if( alias) {
                 strcpy( comp, alias );
                 comp += strlen( alias );
             }

-
+                       

             if ( (look - path)) {
                 strncpy( comp, path, look - path);
                 comp += look - path;
             }
             if ( (look - path)) {
                 strncpy( comp, path, look - path);
                 comp += look - path;
             }

-
-            sprintf( comp, "/@%lx:%ld';}", unit, partition );
+                       
+                       if ( lun != -1 )
+                       {
+                               sprintf ( comp, "/@%lx,%lx:%ld';}", unit, lun, partition );
+                       }
+                       else
+                       {
+               sprintf( comp, "/@%lx:%ld';}", unit, partition );
+            }

         } else
             continue;
         } else
             continue;

-
+               

         return( OSDynamicCast(OSDictionary, OSUnserialize( buf, 0 )) );
 
     } while( false );
         return( OSDynamicCast(OSDictionary, OSUnserialize( buf, 0 )) );
 
     } while( false );


@@ -322,11 +354,89 @@ OSDictionary * IODiskMatching( const char * path, char * buf, int maxLen )
 
 OSDictionary * IOOFPathMatching( const char * path, char * buf, int maxLen )
 {
 
 OSDictionary * IOOFPathMatching( const char * path, char * buf, int maxLen )
 {

+    OSDictionary *     matching;
+    OSString *         str;
+    char *             comp;
+    int                        len;
+

     /* need to look up path, get device type,
         call matching help based on device type */
 
     /* need to look up path, get device type,
         call matching help based on device type */
 

-    return( IODiskMatching( path, buf, maxLen ));
+    matching = IODiskMatching( path, buf, maxLen );
+    if( matching)
+       return( matching );
+
+    do {
+
+       len = strlen( kIODeviceTreePlane ":" );
+       maxLen -= len;
+       if( maxLen < 0)
+           continue;
+
+       strcpy( buf, kIODeviceTreePlane ":" );
+       comp = buf + len;
+
+       len = strlen( path );
+       maxLen -= len;
+       if( maxLen < 0)
+           continue;
+        strncpy( comp, path, len );
+        comp[ len ] = 0;

 
 

+       matching = OSDictionary::withCapacity( 1 );
+       if( !matching)
+           continue;
+
+       str = OSString::withCString( buf );
+       if( !str)
+           continue;
+        matching->setObject( kIOPathMatchKey, str );
+       str->release();
+
+       return( matching );
+
+    } while( false );
+
+    if( matching)
+        matching->release();
+
+    return( 0 );
+}
+
+IOService * IOFindMatchingChild( IOService * service )
+{
+    // find a matching child service
+    IOService * child = 0;
+    OSIterator * iter = service->getClientIterator();
+    if ( iter ) {
+        while( ( child = (IOService *) iter->getNextObject() ) ) {
+            OSDictionary * dict = OSDictionary::withCapacity( 1 );
+            if( dict == 0 ) {
+                iter->release();
+                return 0;
+            }
+            const OSSymbol * str = OSSymbol::withCString( "Apple_HFS" );
+            if( str == 0 ) {
+                dict->release();
+                iter->release();
+                return 0;
+            }
+            dict->setObject( "Content", (OSObject *)str );
+            str->release();
+            if ( child->compareProperty( dict, "Content" ) ) {
+                dict->release();
+                break;
+            }
+            dict->release();
+            IOService * subchild = IOFindMatchingChild( child );
+            if ( subchild ) {
+                child = subchild;
+                break;
+            }
+        }
+        iter->release();
+    }
+    return child;

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


@@ -344,7 +454,9 @@ kern_return_t IOFindBSDRoot( char * rootName,
     UInt32             *ramdParms = 0;
 
     UInt32             flags = 0;
     UInt32             *ramdParms = 0;
 
     UInt32             flags = 0;

-    int                        minor, major;
+    int                        mnr, mjr;
+    bool               findHFSChild = false;
+    char *              mediaProperty = 0;

     char *             rdBootVar;
     enum {             kMaxPathBuf = 512, kMaxBootVar = 128 };
     char *             str;
     char *             rdBootVar;
     enum {             kMaxPathBuf = 512, kMaxBootVar = 128 };
     char *             str;


@@ -352,11 +464,12 @@ kern_return_t IOFindBSDRoot( char * rootName,
     int                        len;
     bool               forceNet = false;
     bool               debugInfoPrintedOnce = false;
     int                        len;
     bool               forceNet = false;
     bool               debugInfoPrintedOnce = false;

+    const char *       uuidStr = NULL;

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

-       int xchar, dchar;
-                               
+    int xchar, dchar;
+                                    

 
     if( mountAttempts++)
        IOSleep( 5 * 1000 );
 
     if( mountAttempts++)
        IOSleep( 5 * 1000 );


@@ -366,24 +479,52 @@ kern_return_t IOFindBSDRoot( char * rootName,
        return( kIOReturnNoMemory );
     rdBootVar = str + kMaxPathBuf;
 
        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( "/chosen", gIODTPlane ))) {
+            data = OSDynamicCast(OSData, regEntry->getProperty( "root-matching" ));
+            if (data) {
+               matching = OSDynamicCast(OSDictionary, OSUnserializeXML((char *)data->getBytesNoCopy()));
+                if (matching) {
+                    continue;
+                }
+            }
+
+           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;

                }
                }

+           }
+
+           // else try for an OF Path
+           data = (OSData *) regEntry->getProperty( "rootpath" );
+           regEntry->release();
+           if( data) continue;
+       }

         if( (regEntry = IORegistryEntry::fromPath( "/options", gIODTPlane ))) {
         if( (regEntry = IORegistryEntry::fromPath( "/options", gIODTPlane ))) {

-                       data = (OSData *) regEntry->getProperty( "boot-file" );
-                       regEntry->release();
-                       if( data) continue;
-               }
+           data = (OSData *) regEntry->getProperty( "boot-file" );
+           regEntry->release();
+           if( data) continue;
+       }

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

-    if( data)
+    if( data && !uuidStr)

         look = (const char *) data->getBytesNoCopy();
 
     if( rdBootVar[0] == '*') {
         look = (const char *) data->getBytesNoCopy();
 
     if( rdBootVar[0] == '*') {


@@ -451,10 +592,12 @@ kern_return_t IOFindBSDRoot( char * rootName,
        // from OpenFirmware path
        IOLog("From path: \"%s\", ", 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) {
+            if( forceNet || (0 == strncmp( look, "enet", strlen( "enet" ))) ) {
+                matching = IONetworkMatching( look, str, kMaxPathBuf );
+            } else {
+                matching = IODiskMatching( look, str, kMaxPathBuf );
+            }

         }
     }
     
         }
     }
     


@@ -466,18 +609,40 @@ 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, "cdrom", strlen( "cdrom" )) == 0 ) {
+            matching = IOCDMatching();
+            findHFSChild = true;
+        } 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();


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

-    major = 0;
-    minor = 0;
+    if ( service && findHFSChild ) {
+        bool waiting = true;
+        // wait for children services to finish registering
+        while ( waiting ) {
+            t.tv_sec = ROOTDEVICETIMEOUT;
+            t.tv_nsec = 0;
+            if ( service->waitQuiet( &t ) == kIOReturnSuccess ) {
+                waiting = false;
+            } else {
+                IOLog( "Waiting for child registration\n" );
+            }
+        }
+        // look for a subservice with an Apple_HFS child
+        IOService * subservice = IOFindMatchingChild( service );
+        if ( subservice ) service = subservice;
+    } else 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


@@ -544,10 +728,10 @@ kern_return_t IOFindBSDRoot( char * rootName,
            strcpy( rootName, iostr->getCStringNoCopy() );
        off = (OSNumber *) service->getProperty( kIOBSDMajorKey );
        if( off)
            strcpy( rootName, iostr->getCStringNoCopy() );
        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;


@@ -560,12 +744,12 @@ kern_return_t IOFindBSDRoot( char * rootName,
     }
 
     IOLog( "BSD root: %s", rootName );
     }
 
     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 +773,20 @@ iofrootx:
     return( kIOReturnSuccess );
 }
 
     return( kIOReturnSuccess );
 }
 

+void IOSecureBSDRoot(const char * rootName)
+{
+#if CONFIG_EMBEDDED
+    IOPlatformExpert *pe;
+    const OSSymbol *functionName = OSSymbol::withCStringNoCopy("SecureRootName");
+    
+    while ((pe = IOService::getPlatform()) == 0) IOSleep(1 * 1000);
+    
+    pe->callPlatformFunction(functionName, false, (void *)rootName, (void *)0, (void *)0, (void *)0);
+    
+    functionName->release();
+#endif
+}
+

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


@@ -620,4 +818,20 @@ 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 );
+    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" */