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

/*
 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
#include <IOKit/IOBSD.h>
#include <IOKit/IOLib.h>
#include <IOKit/IOService.h>
#include <IOKit/IODeviceTreeSupport.h>
#include <IOKit/IOKitKeys.h>
#include <IOKit/storage/IOMedia.h>
#include <IOKit/network/IONetworkStack.h>
#include <IOKit/network/IONetworkInterface.h>
#include <IOKit/IOPlatformExpert.h>

#include <sys/disklabel.h>

extern "C" {

#include <pexpert/pexpert.h>
#include <kern/clock.h>

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


kern_return_t
IOKitBSDInit( void )
{
    IOLog("IOKitBSDInit\n");

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

OSDictionary * IOBSDNameMatching( const char * name )
{
    OSDictionary *	dict;
    const OSSymbol *	str = 0;

    do {

	dict = IOService::serviceMatching( gIOServiceKey );
	if( !dict)
	    continue;
        str = OSSymbol::withCString( name );
	if( !str)
	    continue;
        dict->setObject( kIOBSDNameKey, (OSObject *) str );
        str->release();

        return( dict );

    } while( false );

    if( dict)
	dict->release();
    if( str)
	str->release();

    return( 0 );
}

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 );
}

OSDictionary * IONetworkNamePrefixMatching( const char * prefix )
{
    OSDictionary *	 matching;
    OSDictionary *   propDict = 0;
    const OSSymbol * str      = 0;

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

        propDict = OSDictionary::withCapacity(1);
        if ( propDict == 0 )
            continue;

        str = OSSymbol::withCString( prefix );
        if ( str == 0 )
            continue;

        propDict->setObject( kIOInterfaceNamePrefix, (OSObject *) str );
        str->release();
        str = 0;

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

        propDict->release();
        propDict = 0;

        return( matching );

    } while ( false );

    if ( matching ) matching->release();
    if ( propDict ) propDict->release();
    if ( str      ) str->release();

    return( 0 );
}

static bool IORegisterNetworkInterface( IONetworkInterface * netif )
{
    IONetworkStack * stack;

    if (( stack = IONetworkStack::getNetworkStack() ))
    {
        stack->registerInterface( netif, netif->getNamePrefix() );
    }

	return ( netif->getProperty( kIOBSDNameKey ) != 0 );
}

static void IORegisterPrimaryNetworkInterface()
{
    IONetworkStack * stack;

    if (( stack = IONetworkStack::getNetworkStack() ))
    {
        stack->registerPrimaryInterface( true );
    }    
}

OSDictionary * IODiskMatching( 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;
                }
            }

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

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

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

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

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

            sprintf( comp, "/@%lx:%ld';}", unit, partition );
        } else
            continue;

        return( OSDynamicCast(OSDictionary, OSUnserialize( buf, 0 )) );

    } 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 ));

}

kern_return_t IOFindBSDRoot( char * rootName,
				dev_t * root, u_int32_t * oflags )
{
    mach_timespec_t	t;
    IOService *		service;
    IORegistryEntry *	regEntry;
    OSDictionary *	matching = 0;
    OSString *		iostr;
    OSNumber *		off;
    OSData *		data = 0;

    UInt32		flags = 0;
    int			minor, major;
    char *		rdBootVar;
    enum {		kMaxPathBuf = 512, kMaxBootVar = 128 };
    char *		str;
    const char *	look = 0;
    int			len;
    bool		forceNet = false;

    static int		mountAttempts = 0;

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

    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 ))
	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( rdBootVar[0] == '*') {
        look = rdBootVar + 1;
	forceNet = false;
    } else {
        if( (regEntry = IORegistryEntry::fromPath( "/", gIODTPlane ))) {
            forceNet = (0 != regEntry->getProperty( "net-boot" ));
	    regEntry->release();
	}
    }

    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( look[0] == '*')
	    look++;
    
    if ( strncmp( look, "en", strlen( "en" )) == 0 )
        matching = IONetworkNamePrefixMatching( "en" );
    else
        matching = IOBSDNameMatching( look );
    }

    if( !matching) {
        OSString * astring;
	// any UFS
        matching = IOService::serviceMatching( "IOMedia" );
        astring = OSString::withCStringNoCopy("Apple_UFS");
        if ( astring ) {
            matching->setObject(kIOMediaContentKey, astring);
            astring->release();
        }
    }

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

        if( matching->serialize( s )) {
            IOLog( "Waiting on %s\n", s->text() );
            s->release();
        }
    }

    IOService::waitForService(IOService::serviceMatching("IOMediaBSDClient"));

    do {
        t.tv_sec = ROOTDEVICETIMEOUT;
        t.tv_nsec = 0;
	matching->retain();
        service = IOService::waitForService( matching, &t );
	if( (!service) || (mountAttempts == 10)) {
            PE_display_icon( 0, "noroot");
            IOLog( "Still waiting for root device\n" );
	}
    } while( !service);
    matching->release();

    major = 0;
    minor = 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
    // assigned.

    if ( service
    &&   service->metaCast( "IONetworkInterface" )
    &&   !IORegisterNetworkInterface( (IONetworkInterface *) service ) )
    {
        service = 0;
    }
    IORegisterPrimaryNetworkInterface();

    if( service) {

	len = kMaxPathBuf;
	service->getPath( str, &len, gIOServicePlane );
	IOLog( "Got boot device = %s\n", str );

	iostr = (OSString *) service->getProperty( kIOBSDNameKey );
	if( iostr)
	    strcpy( rootName, iostr->getCStringNoCopy() );
	off = (OSNumber *) service->getProperty( kIOBSDMajorKey );
	if( off)
	    major = off->unsigned32BitValue();
	off = (OSNumber *) service->getProperty( kIOBSDMinorKey );
	if( off)
	    minor = off->unsigned32BitValue();

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

    } else {

	IOLog( "Wait for root failed\n" );
        strcpy( rootName, "en0");
        flags |= 1;
    }

    IOLog( "BSD root: %s", rootName );
    if( major)
	IOLog(", major %d, minor %d\n", major, minor );
    else
	IOLog("\n");

    *root = makedev( major, minor );
    *oflags = flags;

    IOFree( str,  kMaxPathBuf + kMaxBootVar );

    if( gIOKitDebug & (kIOLogDTree | kIOLogServiceTree | kIOLogMemory)) {

	IOSleep(10 * 1000);
//	IOService::getPlatform()->waitQuiet();
        if( gIOKitDebug & kIOLogDTree) {
            IOLog("\nDT plane:\n");
            IOPrintPlane( gIODTPlane );
        }
        if( gIOKitDebug & kIOLogServiceTree) {
            IOLog("\nService plane:\n");
            IOPrintPlane( gIOServicePlane );
        }
        if( gIOKitDebug & kIOLogMemory)
            IOPrintMemory();
    }

    return( kIOReturnSuccess );
}

} /* extern "C" */
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 1998-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	#include <IOKit/IOBSD.h>
	23	#include <IOKit/IOLib.h>
	24	#include <IOKit/IOService.h>
	25	#include <IOKit/IODeviceTreeSupport.h>
	26	#include <IOKit/IOKitKeys.h>
	27	#include <IOKit/storage/IOMedia.h>
	28	#include <IOKit/network/IONetworkStack.h>
	29	#include <IOKit/network/IONetworkInterface.h>
	30	#include <IOKit/IOPlatformExpert.h>
	31
	32	#include <sys/disklabel.h>
	33
	34	extern "C" {
	35
	36	#include <pexpert/pexpert.h>
	37	#include <kern/clock.h>
	38
	39	// how long to wait for matching root device, secs
	40	#define ROOTDEVICETIMEOUT 60
	41
	42
	43	kern_return_t
	44	IOKitBSDInit( void )
	45	{
	46	IOLog("IOKitBSDInit\n");
	47
	48	IOService::publishResource("IOBSD");
	49
	50	return( kIOReturnSuccess );
	51	}
	52
	53	OSDictionary * IOBSDNameMatching( const char * name )
	54	{
	55	OSDictionary * dict;
	56	const OSSymbol * str = 0;
	57
	58	do {
	59
	60	dict = IOService::serviceMatching( gIOServiceKey );
	61	if( !dict)
	62	continue;
	63	str = OSSymbol::withCString( name );
	64	if( !str)
65	continue;
66	dict->setObject( kIOBSDNameKey, (OSObject *) str );
67	str->release();
68
69	return( dict );
70
71	} while( false );
72
73	if( dict)
74	dict->release();
75	if( str)
76	str->release();
77
78	return( 0 );
79	}
80
81	OSDictionary * IONetworkMatching( const char * path,
82	char * buf, int maxLen )
83	{
84	OSDictionary * matching = 0;
85	OSDictionary * dict;
86	OSString * str;
87	char * comp;
88	const char * skip;
89	int len;
90
91	do {
92
93	len = strlen( kIODeviceTreePlane ":" );
94	maxLen -= len;
95	if( maxLen < 0)
96	continue;
97
98	strcpy( buf, kIODeviceTreePlane ":" );
99	comp = buf + len;
100
101	// remove parameters following ':' from the path
102	skip = strchr( path, ':');
103	if( !skip)
104	continue;
105
106	len = skip - path;
107	maxLen -= len;
108	if( maxLen < 0)
109	continue;
110	strncpy( comp, path, len );
111	comp[ len ] = 0;
112
113	matching = IOService::serviceMatching( "IONetworkInterface" );
114	if( !matching)
115	continue;
116	dict = IOService::addLocation( matching );
117	if( !dict)
118	continue;
119
120	str = OSString::withCString( buf );
121	if( !str)
122	continue;
123	dict->setObject( kIOPathMatchKey, str );
124	str->release();
125
126	return( matching );
127
128	} while( false );
129
130	if( matching)
131	matching->release();
132
133	return( 0 );
134	}
135
136	OSDictionary * IONetworkNamePrefixMatching( const char * prefix )
137	{
138	OSDictionary * matching;
139	OSDictionary * propDict = 0;
140	const OSSymbol * str = 0;
141
142	do {
143	matching = IOService::serviceMatching( "IONetworkInterface" );
144	if ( matching == 0 )
145	continue;
146
147	propDict = OSDictionary::withCapacity(1);
148	if ( propDict == 0 )
149	continue;
150
151	str = OSSymbol::withCString( prefix );
152	if ( str == 0 )
153	continue;
154
155	propDict->setObject( kIOInterfaceNamePrefix, (OSObject *) str );
156	str->release();
157	str = 0;
158
159	if ( matching->setObject( gIOPropertyMatchKey,
160	(OSObject *) propDict ) != true )
161	continue;
162
163	propDict->release();
164	propDict = 0;
165
166	return( matching );
167
168	} while ( false );
169
170	if ( matching ) matching->release();
171	if ( propDict ) propDict->release();
172	if ( str ) str->release();
173
174	return( 0 );
175	}
176
177	static bool IORegisterNetworkInterface( IONetworkInterface * netif )
178	{
179	IONetworkStack * stack;
180
181	if (( stack = IONetworkStack::getNetworkStack() ))
182	{
183	stack->registerInterface( netif, netif->getNamePrefix() );
184	}
185
186	return ( netif->getProperty( kIOBSDNameKey ) != 0 );
187	}
188
189	static void IORegisterPrimaryNetworkInterface()
190	{
191	IONetworkStack * stack;
192
193	if (( stack = IONetworkStack::getNetworkStack() ))
194	{
195	stack->registerPrimaryInterface( true );
196	}
197	}
198
199	OSDictionary * IODiskMatching( const char * path, char * buf, int maxLen )
200	{
201	const char * look;
202	const char * alias;
203	char * comp;
204	long unit = -1;
205	long partition = -1;
206	char c;
207
208	// scan the tail of the path for "@unit:partition"
209	do {
210	// Have to get the full path to the controller - an alias may
211	// tell us next to nothing, like "hd:8"
212	alias = IORegistryEntry::dealiasPath( &path, gIODTPlane );
213
214	look = path + strlen( path);
215	c = ':';
216	while( look != path) {
217	if( *(--look) == c) {
218	if( c == ':') {
219	partition = strtol( look + 1, 0, 0 );
220	c = '@';
221	} else if( c == '@') {
222	unit = strtol( look + 1, 0, 16 );
223	c = '/';
224	} else if( c == '/') {
225	c = 0;
226	break;
227	}
228	}
229
230	if( alias && (look == path)) {
231	path = alias;
232	look = path + strlen( path);
233	alias = 0;
234	}
235	}
236	if( c \|\| unit == -1 \|\| partition == -1)
237	continue;
238
239	maxLen -= strlen( "{" kIOPathMatchKey "='" kIODeviceTreePlane ":" );
240	maxLen -= ( alias ? strlen( alias ) : 0 ) + (look - path);
241	maxLen -= strlen( "/@hhhhhhhh:dddddddddd';}" );
242
243	if( maxLen > 0) {
244	sprintf( buf, "{" kIOPathMatchKey "='" kIODeviceTreePlane ":" );
245	comp = buf + strlen( buf );
246
247	if( alias) {
248	strcpy( comp, alias );
249	comp += strlen( alias );
250	}
251
252	if ( (look - path)) {
253	strncpy( comp, path, look - path);
254	comp += look - path;
255	}
256
257	sprintf( comp, "/@%lx:%ld';}", unit, partition );
258	} else
259	continue;
260
261	return( OSDynamicCast(OSDictionary, OSUnserialize( buf, 0 )) );
262
263	} while( false );
264
265	return( 0 );
266	}
267
268	OSDictionary * IOOFPathMatching( const char * path, char * buf, int maxLen )
269	{
270	/* need to look up path, get device type,
271	call matching help based on device type */
272
273	return( IODiskMatching( path, buf, maxLen ));
274
275	}
276
277	kern_return_t IOFindBSDRoot( char * rootName,
278	dev_t * root, u_int32_t * oflags )
279	{
280	mach_timespec_t t;
281	IOService * service;
282	IORegistryEntry * regEntry;
283	OSDictionary * matching = 0;
284	OSString * iostr;
285	OSNumber * off;
286	OSData * data = 0;
287
288	UInt32 flags = 0;
289	int minor, major;
290	char * rdBootVar;
291	enum { kMaxPathBuf = 512, kMaxBootVar = 128 };
292	char * str;
293	const char * look = 0;
294	int len;
295	bool forceNet = false;
296
297	static int mountAttempts = 0;
298
299	if( mountAttempts++)
300	IOSleep( 5 * 1000 );
301
302	str = (char *) IOMalloc( kMaxPathBuf + kMaxBootVar );
303	if( !str)
304	return( kIOReturnNoMemory );
305	rdBootVar = str + kMaxPathBuf;
306
307	if (!PE_parse_boot_arg("rd", rdBootVar )
308	&& !PE_parse_boot_arg("rootdev", rdBootVar ))
309	rdBootVar[0] = 0;
310
311	do {
312	if( (regEntry = IORegistryEntry::fromPath( "/chosen", gIODTPlane ))) {
313	data = (OSData *) regEntry->getProperty( "rootpath" );
314	regEntry->release();
315	if( data)
316	continue;
317	}
318	if( (regEntry = IORegistryEntry::fromPath( "/options", gIODTPlane ))) {
319	data = (OSData *) regEntry->getProperty( "boot-file" );
320	regEntry->release();
321	if( data)
322	continue;
323	}
324	} while( false );
325
326	if( data)
327	look = (const char *) data->getBytesNoCopy();
328
329	if( rdBootVar[0] == '*') {
330	look = rdBootVar + 1;
331	forceNet = false;
332	} else {
333	if( (regEntry = IORegistryEntry::fromPath( "/", gIODTPlane ))) {
334	forceNet = (0 != regEntry->getProperty( "net-boot" ));
335	regEntry->release();
336	}
337	}
338
339	if( look) {
340	// from OpenFirmware path
341	IOLog("From path: \"%s\", ", look);
342
343	if( forceNet \|\| (0 == strncmp( look, "enet", strlen( "enet" ))) )
344	matching = IONetworkMatching( look, str, kMaxPathBuf );
345	else
346	matching = IODiskMatching( look, str, kMaxPathBuf );
347	}
348
349	if( (!matching) && rdBootVar[0] ) {
350	// by BSD name
351	look = rdBootVar;
352	if( look[0] == '*')
353	look++;
354
355	if ( strncmp( look, "en", strlen( "en" )) == 0 )
356	matching = IONetworkNamePrefixMatching( "en" );
357	else
358	matching = IOBSDNameMatching( look );
359	}
360
361	if( !matching) {
362	OSString * astring;
363	// any UFS
364	matching = IOService::serviceMatching( "IOMedia" );
365	astring = OSString::withCStringNoCopy("Apple_UFS");
366	if ( astring ) {
367	matching->setObject(kIOMediaContentKey, astring);
368	astring->release();
369	}
370	}
371
372	if( true && matching) {
373	OSSerialize * s = OSSerialize::withCapacity( 5 );
374
375	if( matching->serialize( s )) {
376	IOLog( "Waiting on %s\n", s->text() );
377	s->release();
378	}
379	}
380
381	IOService::waitForService(IOService::serviceMatching("IOMediaBSDClient"));
382
383	do {
384	t.tv_sec = ROOTDEVICETIMEOUT;
385	t.tv_nsec = 0;
386	matching->retain();
387	service = IOService::waitForService( matching, &t );
388	if( (!service) \|\| (mountAttempts == 10)) {
389	PE_display_icon( 0, "noroot");
390	IOLog( "Still waiting for root device\n" );
391	}
392	} while( !service);
393	matching->release();
394
395	major = 0;
396	minor = 0;
397
398	// If the IOService we matched to is a subclass of IONetworkInterface,
399	// then make sure it has been registered with BSD and has a BSD name
400	// assigned.
401
402	if ( service
403	&& service->metaCast( "IONetworkInterface" )
404	&& !IORegisterNetworkInterface( (IONetworkInterface *) service ) )
405	{
406	service = 0;
407	}
408	IORegisterPrimaryNetworkInterface();
409
410	if( service) {
411
412	len = kMaxPathBuf;
413	service->getPath( str, &len, gIOServicePlane );
414	IOLog( "Got boot device = %s\n", str );
415
416	iostr = (OSString *) service->getProperty( kIOBSDNameKey );
417	if( iostr)
418	strcpy( rootName, iostr->getCStringNoCopy() );
419	off = (OSNumber *) service->getProperty( kIOBSDMajorKey );
420	if( off)
421	major = off->unsigned32BitValue();
422	off = (OSNumber *) service->getProperty( kIOBSDMinorKey );
423	if( off)
424	minor = off->unsigned32BitValue();
425
426	if( service->metaCast( "IONetworkInterface" ))
427	flags \|= 1;
428
429	} else {
430
431	IOLog( "Wait for root failed\n" );
432	strcpy( rootName, "en0");
433	flags \|= 1;
434	}
435
436	IOLog( "BSD root: %s", rootName );
437	if( major)
438	IOLog(", major %d, minor %d\n", major, minor );
439	else
440	IOLog("\n");
441
442	*root = makedev( major, minor );
443	*oflags = flags;
444
445	IOFree( str, kMaxPathBuf + kMaxBootVar );
446
447	if( gIOKitDebug & (kIOLogDTree \| kIOLogServiceTree \| kIOLogMemory)) {
448
449	IOSleep(10 * 1000);
450	// IOService::getPlatform()->waitQuiet();
451	if( gIOKitDebug & kIOLogDTree) {
452	IOLog("\nDT plane:\n");
453	IOPrintPlane( gIODTPlane );
454	}
455	if( gIOKitDebug & kIOLogServiceTree) {
456	IOLog("\nService plane:\n");
457	IOPrintPlane( gIOServicePlane );
458	}
459	if( gIOKitDebug & kIOLogMemory)
460	IOPrintMemory();
461	}
462
463	return( kIOReturnSuccess );
464	}
465
466	} /* extern "C" */