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#include <IOKit/IOUserClient.h>
36
37extern "C" {
38
39#include <pexpert/pexpert.h>
40#include <kern/clock.h>
41#include <mach/machine.h>
42#include <uuid/uuid.h>
43#include <sys/vnode_internal.h>
44#include <sys/mount.h>
45
46// how long to wait for matching root device, secs
47#if DEBUG
48#define ROOTDEVICETIMEOUT 120
49#else
50#define ROOTDEVICETIMEOUT 60
51#endif
52
53int panic_on_exception_triage = 0;
54
55extern dev_t mdevadd(int devid, uint64_t base, unsigned int size, int phys);
56extern dev_t mdevlookup(int devid);
57extern void mdevremoveall(void);
58extern int mdevgetrange(int devid, uint64_t *base, uint64_t *size);
59extern void di_root_ramfile(IORegistryEntry * entry);
60
61#if CONFIG_EMBEDDED
62#define IOPOLLED_COREFILE (CONFIG_KDP_INTERACTIVE_DEBUGGING)
63
64#if defined(XNU_TARGET_OS_BRIDGE)
65
66#define kIOCoreDumpSize 150ULL*1024ULL*1024ULL
67// leave free space on volume:
68#define kIOCoreDumpFreeSize 150ULL*1024ULL*1024ULL
69#define kIOCoreDumpPath "/private/var/internal/kernelcore"
70
71#else /* defined(XNU_TARGET_OS_BRIDGE) */
72#define kIOCoreDumpMinSize 350ULL*1024ULL*1024ULL
73#define kIOCoreDumpLargeSize 500ULL*1024ULL*1024ULL
74// leave free space on volume:
75#define kIOCoreDumpFreeSize 350ULL*1024ULL*1024ULL
76#define kIOCoreDumpPath "/private/var/vm/kernelcore"
77
78#endif /* defined(XNU_TARGET_OS_BRIDGE) */
79
80#elif DEVELOPMENT /* CONFIG_EMBEDDED */
81#define IOPOLLED_COREFILE 1
82// no sizing
83#define kIOCoreDumpSize 0ULL
84#define kIOCoreDumpFreeSize 0ULL
85#else /* CONFIG_EMBEDDED */
86#define IOPOLLED_COREFILE 0
87#endif /* CONFIG_EMBEDDED */
88
89
90#if IOPOLLED_COREFILE
91static bool
92NewKernelCoreMedia(void * target, void * refCon,
93 IOService * newService,
94 IONotifier * notifier);
95#endif /* IOPOLLED_COREFILE */
96
97#if CONFIG_KDP_INTERACTIVE_DEBUGGING
98/*
99 * Touched by IOFindBSDRoot() if a RAMDisk is used for the root device.
100 */
101extern uint64_t kdp_core_ramdisk_addr;
102extern uint64_t kdp_core_ramdisk_size;
103#endif
104
105kern_return_t
106IOKitBSDInit( void )
107{
108 IOService::publishResource("IOBSD");
109
110 return( kIOReturnSuccess );
111}
112
113void
114IOServicePublishResource( const char * property, boolean_t value )
115{
116 if ( value)
117 IOService::publishResource( property, kOSBooleanTrue );
118 else
119 IOService::getResourceService()->removeProperty( property );
120}
121
122boolean_t
123IOServiceWaitForMatchingResource( const char * property, uint64_t timeout )
124{
125 OSDictionary * dict = 0;
126 IOService * match = 0;
127 boolean_t found = false;
128
129 do {
130
131 dict = IOService::resourceMatching( property );
132 if( !dict)
133 continue;
134 match = IOService::waitForMatchingService( dict, timeout );
135 if ( match)
136 found = true;
137
138 } while( false );
139
140 if( dict)
141 dict->release();
142 if( match)
143 match->release();
144
145 return( found );
146}
147
148boolean_t
149IOCatalogueMatchingDriversPresent( const char * property )
150{
151 OSDictionary * dict = 0;
152 OSOrderedSet * set = 0;
153 SInt32 generationCount = 0;
154 boolean_t found = false;
155
156 do {
157
158 dict = OSDictionary::withCapacity(1);
159 if( !dict)
160 continue;
161 dict->setObject( property, kOSBooleanTrue );
162 set = gIOCatalogue->findDrivers( dict, &generationCount );
163 if ( set && (set->getCount() > 0))
164 found = true;
165
166 } while( false );
167
168 if( dict)
169 dict->release();
170 if( set)
171 set->release();
172
173 return( found );
174}
175
176OSDictionary * IOBSDNameMatching( const char * name )
177{
178 OSDictionary * dict;
179 const OSSymbol * str = 0;
180
181 do {
182
183 dict = IOService::serviceMatching( gIOServiceKey );
184 if( !dict)
185 continue;
186 str = OSSymbol::withCString( name );
187 if( !str)
188 continue;
189 dict->setObject( kIOBSDNameKey, (OSObject *) str );
190 str->release();
191
192 return( dict );
193
194 } while( false );
195
196 if( dict)
197 dict->release();
198 if( str)
199 str->release();
200
201 return( 0 );
202}
203
204OSDictionary * IOUUIDMatching( void )
205{
206 return IOService::resourceMatching( "boot-uuid-media" );
207}
208
209OSDictionary * IONetworkNamePrefixMatching( const char * prefix )
210{
211 OSDictionary * matching;
212 OSDictionary * propDict = 0;
213 const OSSymbol * str = 0;
214 char networkType[128];
215
216 do {
217 matching = IOService::serviceMatching( "IONetworkInterface" );
218 if ( matching == 0 )
219 continue;
220
221 propDict = OSDictionary::withCapacity(1);
222 if ( propDict == 0 )
223 continue;
224
225 str = OSSymbol::withCString( prefix );
226 if ( str == 0 )
227 continue;
228
229 propDict->setObject( "IOInterfaceNamePrefix", (OSObject *) str );
230 str->release();
231 str = 0;
232
233 // see if we're contrained to netroot off of specific network type
234 if(PE_parse_boot_argn( "network-type", networkType, 128 ))
235 {
236 str = OSSymbol::withCString( networkType );
237 if(str)
238 {
239 propDict->setObject( "IONetworkRootType", str);
240 str->release();
241 str = 0;
242 }
243 }
244
245 if ( matching->setObject( gIOPropertyMatchKey,
246 (OSObject *) propDict ) != true )
247 continue;
248
249 propDict->release();
250 propDict = 0;
251
252 return( matching );
253
254 } while ( false );
255
256 if ( matching ) matching->release();
257 if ( propDict ) propDict->release();
258 if ( str ) str->release();
259
260 return( 0 );
261}
262
263static bool IORegisterNetworkInterface( IOService * netif )
264{
265 // A network interface is typically named and registered
266 // with BSD after receiving a request from a user space
267 // "namer". However, for cases when the system needs to
268 // root from the network, this registration task must be
269 // done inside the kernel and completed before the root
270 // device is handed to BSD.
271
272 IOService * stack;
273 OSNumber * zero = 0;
274 OSString * path = 0;
275 OSDictionary * dict = 0;
276 char * pathBuf = 0;
277 int len;
278 enum { kMaxPathLen = 512 };
279
280 do {
281 stack = IOService::waitForService(
282 IOService::serviceMatching("IONetworkStack") );
283 if ( stack == 0 ) break;
284
285 dict = OSDictionary::withCapacity(3);
286 if ( dict == 0 ) break;
287
288 zero = OSNumber::withNumber((UInt64) 0, 32);
289 if ( zero == 0 ) break;
290
291 pathBuf = (char *) IOMalloc( kMaxPathLen );
292 if ( pathBuf == 0 ) break;
293
294 len = kMaxPathLen;
295 if ( netif->getPath( pathBuf, &len, gIOServicePlane )
296 == false ) break;
297
298 path = OSString::withCStringNoCopy( pathBuf );
299 if ( path == 0 ) break;
300
301 dict->setObject( "IOInterfaceUnit", zero );
302 dict->setObject( kIOPathMatchKey, path );
303
304 stack->setProperties( dict );
305 }
306 while ( false );
307
308 if ( zero ) zero->release();
309 if ( path ) path->release();
310 if ( dict ) dict->release();
311 if ( pathBuf ) IOFree(pathBuf, kMaxPathLen);
312
313 return ( netif->getProperty( kIOBSDNameKey ) != 0 );
314}
315
316OSDictionary * IOOFPathMatching( const char * path, char * buf, int maxLen )
317{
318 OSDictionary * matching = NULL;
319 OSString * str;
320 char * comp;
321 int len;
322
323 do {
324
325 len = strlen( kIODeviceTreePlane ":" );
326 maxLen -= len;
327 if( maxLen <= 0)
328 continue;
329
330 strlcpy( buf, kIODeviceTreePlane ":", len + 1 );
331 comp = buf + len;
332
333 len = strlen( path );
334 maxLen -= len;
335 if( maxLen <= 0)
336 continue;
337 strlcpy( comp, path, len + 1 );
338
339 matching = OSDictionary::withCapacity( 1 );
340 if( !matching)
341 continue;
342
343 str = OSString::withCString( buf );
344 if( !str)
345 continue;
346 matching->setObject( kIOPathMatchKey, str );
347 str->release();
348
349 return( matching );
350
351 } while( false );
352
353 if( matching)
354 matching->release();
355
356 return( 0 );
357}
358
359static int didRam = 0;
360enum { kMaxPathBuf = 512, kMaxBootVar = 128 };
361
362kern_return_t IOFindBSDRoot( char * rootName, unsigned int rootNameSize,
363 dev_t * root, u_int32_t * oflags )
364{
365 mach_timespec_t t;
366 IOService * service;
367 IORegistryEntry * regEntry;
368 OSDictionary * matching = 0;
369 OSString * iostr;
370 OSNumber * off;
371 OSData * data = 0;
372
373 UInt32 flags = 0;
374 int mnr, mjr;
375 const char * mediaProperty = 0;
376 char * rdBootVar;
377 char * str;
378 const char * look = 0;
379 int len;
380 bool debugInfoPrintedOnce = false;
381 const char * uuidStr = NULL;
382
383 static int mountAttempts = 0;
384
385 int xchar, dchar;
386
387 // stall here for anyone matching on the IOBSD resource to finish (filesystems)
388 matching = IOService::serviceMatching(gIOResourcesKey);
389 assert(matching);
390 matching->setObject(gIOResourceMatchedKey, gIOBSDKey);
391
392 if ((service = IOService::waitForMatchingService(matching, 30ULL * kSecondScale))) {
393 service->release();
394 } else {
395 IOLog("!BSD\n");
396 }
397 matching->release();
398 matching = NULL;
399
400 if( mountAttempts++)
401 {
402 IOLog("mount(%d) failed\n", mountAttempts);
403 IOSleep( 5 * 1000 );
404 }
405
406 str = (char *) IOMalloc( kMaxPathBuf + kMaxBootVar );
407 if( !str)
408 return( kIOReturnNoMemory );
409 rdBootVar = str + kMaxPathBuf;
410
411 if (!PE_parse_boot_argn("rd", rdBootVar, kMaxBootVar )
412 && !PE_parse_boot_argn("rootdev", rdBootVar, kMaxBootVar ))
413 rdBootVar[0] = 0;
414
415 do {
416 if( (regEntry = IORegistryEntry::fromPath( "/chosen", gIODTPlane ))) {
417 di_root_ramfile(regEntry);
418 data = OSDynamicCast(OSData, regEntry->getProperty( "root-matching" ));
419 if (data) {
420 matching = OSDynamicCast(OSDictionary, OSUnserializeXML((char *)data->getBytesNoCopy()));
421 if (matching) {
422 continue;
423 }
424 }
425
426 data = (OSData *) regEntry->getProperty( "boot-uuid" );
427 if( data) {
428 uuidStr = (const char*)data->getBytesNoCopy();
429 OSString *uuidString = OSString::withCString( uuidStr );
430
431 // match the boot-args boot-uuid processing below
432 if( uuidString) {
433 IOLog("rooting via boot-uuid from /chosen: %s\n", uuidStr);
434 IOService::publishResource( "boot-uuid", uuidString );
435 uuidString->release();
436 matching = IOUUIDMatching();
437 mediaProperty = "boot-uuid-media";
438 regEntry->release();
439 continue;
440 } else {
441 uuidStr = NULL;
442 }
443 }
444 regEntry->release();
445 }
446 } while( false );
447
448//
449// See if we have a RAMDisk property in /chosen/memory-map. If so, make it into a device.
450// It will become /dev/mdx, where x is 0-f.
451//
452
453 if(!didRam) { /* Have we already build this ram disk? */
454 didRam = 1; /* Remember we did this */
455 if((regEntry = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane ))) { /* Find the map node */
456 data = (OSData *)regEntry->getProperty("RAMDisk"); /* Find the ram disk, if there */
457 if(data) { /* We found one */
458 uintptr_t *ramdParms;
459 ramdParms = (uintptr_t *)data->getBytesNoCopy(); /* Point to the ram disk base and size */
460 (void)mdevadd(-1, ml_static_ptovirt(ramdParms[0]) >> 12, ramdParms[1] >> 12, 0); /* Initialize it and pass back the device number */
461 }
462 regEntry->release(); /* Toss the entry */
463 }
464 }
465
466//
467// Now check if we are trying to root on a memory device
468//
469
470 if((rdBootVar[0] == 'm') && (rdBootVar[1] == 'd') && (rdBootVar[3] == 0)) {
471 dchar = xchar = rdBootVar[2]; /* Get the actual device */
472 if((xchar >= '0') && (xchar <= '9')) xchar = xchar - '0'; /* If digit, convert */
473 else {
474 xchar = xchar & ~' '; /* Fold to upper case */
475 if((xchar >= 'A') && (xchar <= 'F')) { /* Is this a valid digit? */
476 xchar = (xchar & 0xF) + 9; /* Convert the hex digit */
477 dchar = dchar | ' '; /* Fold to lower case */
478 }
479 else xchar = -1; /* Show bogus */
480 }
481 if(xchar >= 0) { /* Do we have a valid memory device name? */
482 *root = mdevlookup(xchar); /* Find the device number */
483 if(*root >= 0) { /* Did we find one? */
484 rootName[0] = 'm'; /* Build root name */
485 rootName[1] = 'd'; /* Build root name */
486 rootName[2] = dchar; /* Build root name */
487 rootName[3] = 0; /* Build root name */
488 IOLog("BSD root: %s, major %d, minor %d\n", rootName, major(*root), minor(*root));
489 *oflags = 0; /* Show that this is not network */
490
491#if CONFIG_KDP_INTERACTIVE_DEBUGGING
492 /* retrieve final ramdisk range and initialize KDP variables */
493 if (mdevgetrange(xchar, &kdp_core_ramdisk_addr, &kdp_core_ramdisk_size) != 0) {
494 IOLog("Unable to retrieve range for root memory device %d\n", xchar);
495 kdp_core_ramdisk_addr = 0;
496 kdp_core_ramdisk_size = 0;
497 }
498#endif
499
500 goto iofrootx; /* Join common exit... */
501 }
502 panic("IOFindBSDRoot: specified root memory device, %s, has not been configured\n", rdBootVar); /* Not there */
503 }
504 }
505
506 if( (!matching) && rdBootVar[0] ) {
507 // by BSD name
508 look = rdBootVar;
509 if( look[0] == '*')
510 look++;
511
512 if ( strncmp( look, "en", strlen( "en" )) == 0 ) {
513 matching = IONetworkNamePrefixMatching( "en" );
514 } else if ( strncmp( look, "uuid", strlen( "uuid" )) == 0 ) {
515 char *uuid;
516 OSString *uuidString;
517
518 uuid = (char *)IOMalloc( kMaxBootVar );
519
520 if ( uuid ) {
521 if (!PE_parse_boot_argn( "boot-uuid", uuid, kMaxBootVar )) {
522 panic( "rd=uuid but no boot-uuid=<value> specified" );
523 }
524 uuidString = OSString::withCString( uuid );
525 if ( uuidString ) {
526 IOService::publishResource( "boot-uuid", uuidString );
527 uuidString->release();
528 IOLog( "\nWaiting for boot volume with UUID %s\n", uuid );
529 matching = IOUUIDMatching();
530 mediaProperty = "boot-uuid-media";
531 }
532 IOFree( uuid, kMaxBootVar );
533 }
534 } else {
535 matching = IOBSDNameMatching( look );
536 }
537 }
538
539 if( !matching) {
540 OSString * astring;
541 // Match any HFS media
542
543 matching = IOService::serviceMatching( "IOMedia" );
544 astring = OSString::withCStringNoCopy("Apple_HFS");
545 if ( astring ) {
546 matching->setObject("Content", astring);
547 astring->release();
548 }
549 }
550
551 if( gIOKitDebug & kIOWaitQuietBeforeRoot ) {
552 IOLog( "Waiting for matching to complete\n" );
553 IOService::getPlatform()->waitQuiet();
554 }
555
556 if( true && matching) {
557 OSSerialize * s = OSSerialize::withCapacity( 5 );
558
559 if( matching->serialize( s )) {
560 IOLog( "Waiting on %s\n", s->text() );
561 s->release();
562 }
563 }
564
565 do {
566 t.tv_sec = ROOTDEVICETIMEOUT;
567 t.tv_nsec = 0;
568 matching->retain();
569 service = IOService::waitForService( matching, &t );
570 if( (!service) || (mountAttempts == 10)) {
571 PE_display_icon( 0, "noroot");
572 IOLog( "Still waiting for root device\n" );
573
574 if( !debugInfoPrintedOnce) {
575 debugInfoPrintedOnce = true;
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 } while( !service);
589 matching->release();
590
591 if ( service && mediaProperty ) {
592 service = (IOService *)service->getProperty(mediaProperty);
593 }
594
595 mjr = 0;
596 mnr = 0;
597
598 // If the IOService we matched to is a subclass of IONetworkInterface,
599 // then make sure it has been registered with BSD and has a BSD name
600 // assigned.
601
602 if ( service
603 && service->metaCast( "IONetworkInterface" )
604 && !IORegisterNetworkInterface( service ) )
605 {
606 service = 0;
607 }
608
609 if( service) {
610
611 len = kMaxPathBuf;
612 service->getPath( str, &len, gIOServicePlane );
613 IOLog( "Got boot device = %s\n", str );
614
615 iostr = (OSString *) service->getProperty( kIOBSDNameKey );
616 if( iostr)
617 strlcpy( rootName, iostr->getCStringNoCopy(), rootNameSize );
618 off = (OSNumber *) service->getProperty( kIOBSDMajorKey );
619 if( off)
620 mjr = off->unsigned32BitValue();
621 off = (OSNumber *) service->getProperty( kIOBSDMinorKey );
622 if( off)
623 mnr = off->unsigned32BitValue();
624
625 if( service->metaCast( "IONetworkInterface" ))
626 flags |= 1;
627
628 } else {
629
630 IOLog( "Wait for root failed\n" );
631 strlcpy( rootName, "en0", rootNameSize );
632 flags |= 1;
633 }
634
635 IOLog( "BSD root: %s", rootName );
636 if( mjr)
637 IOLog(", major %d, minor %d\n", mjr, mnr );
638 else
639 IOLog("\n");
640
641 *root = makedev( mjr, mnr );
642 *oflags = flags;
643
644 IOFree( str, kMaxPathBuf + kMaxBootVar );
645
646iofrootx:
647 if( (gIOKitDebug & (kIOLogDTree | kIOLogServiceTree | kIOLogMemory)) && !debugInfoPrintedOnce) {
648
649 IOService::getPlatform()->waitQuiet();
650 if( gIOKitDebug & kIOLogDTree) {
651 IOLog("\nDT plane:\n");
652 IOPrintPlane( gIODTPlane );
653 }
654 if( gIOKitDebug & kIOLogServiceTree) {
655 IOLog("\nService plane:\n");
656 IOPrintPlane( gIOServicePlane );
657 }
658 if( gIOKitDebug & kIOLogMemory)
659 IOPrintMemory();
660 }
661
662 return( kIOReturnSuccess );
663}
664
665bool IORamDiskBSDRoot(void)
666{
667 char rdBootVar[kMaxBootVar];
668 if (PE_parse_boot_argn("rd", rdBootVar, kMaxBootVar )
669 || PE_parse_boot_argn("rootdev", rdBootVar, kMaxBootVar )) {
670 if((rdBootVar[0] == 'm') && (rdBootVar[1] == 'd') && (rdBootVar[3] == 0)) {
671 return true;
672 }
673 }
674 return false;
675}
676
677void IOSecureBSDRoot(const char * rootName)
678{
679#if CONFIG_EMBEDDED
680 int tmpInt;
681 IOReturn result;
682 IOPlatformExpert *pe;
683 OSDictionary *matching;
684 const OSSymbol *functionName = OSSymbol::withCStringNoCopy("SecureRootName");
685
686 matching = IOService::serviceMatching("IOPlatformExpert");
687 assert(matching);
688 pe = (IOPlatformExpert *) IOService::waitForMatchingService(matching, 30ULL * kSecondScale);
689 matching->release();
690 assert(pe);
691 // Returns kIOReturnNotPrivileged is the root device is not secure.
692 // Returns kIOReturnUnsupported if "SecureRootName" is not implemented.
693 result = pe->callPlatformFunction(functionName, false, (void *)rootName, (void *)0, (void *)0, (void *)0);
694 functionName->release();
695 OSSafeReleaseNULL(pe);
696
697 if (result == kIOReturnNotPrivileged) {
698 mdevremoveall();
699 } else if (result == kIOReturnSuccess) {
700 // If we are booting with a secure root, and we have the right
701 // boot-arg, we will want to panic on exception triage. This
702 // behavior is intended as a debug aid (we can look at why an
703 // exception occured in the kernel debugger).
704 if (PE_parse_boot_argn("-panic_on_exception_triage", &tmpInt, sizeof(tmpInt))) {
705 panic_on_exception_triage = 1;
706 }
707 }
708
709#endif // CONFIG_EMBEDDED
710}
711
712void *
713IOBSDRegistryEntryForDeviceTree(char * path)
714{
715 return (IORegistryEntry::fromPath(path, gIODTPlane));
716}
717
718void
719IOBSDRegistryEntryRelease(void * entry)
720{
721 IORegistryEntry * regEntry = (IORegistryEntry *)entry;
722
723 if (regEntry)
724 regEntry->release();
725 return;
726}
727
728const void *
729IOBSDRegistryEntryGetData(void * entry, char * property_name,
730 int * packet_length)
731{
732 OSData * data;
733 IORegistryEntry * regEntry = (IORegistryEntry *)entry;
734
735 data = (OSData *) regEntry->getProperty(property_name);
736 if (data) {
737 *packet_length = data->getLength();
738 return (data->getBytesNoCopy());
739 }
740 return (NULL);
741}
742
743kern_return_t IOBSDGetPlatformUUID( uuid_t uuid, mach_timespec_t timeout )
744{
745 IOService * resources;
746 OSString * string;
747
748 resources = IOService::waitForService( IOService::resourceMatching( kIOPlatformUUIDKey ), ( timeout.tv_sec || timeout.tv_nsec ) ? &timeout : 0 );
749 if ( resources == 0 ) return KERN_OPERATION_TIMED_OUT;
750
751 string = ( OSString * ) IOService::getPlatform( )->getProvider( )->getProperty( kIOPlatformUUIDKey );
752 if ( string == 0 ) return KERN_NOT_SUPPORTED;
753
754 uuid_parse( string->getCStringNoCopy( ), uuid );
755
756 return KERN_SUCCESS;
757}
758
759} /* extern "C" */
760
761/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
762
763#include <sys/conf.h>
764#include <sys/vnode.h>
765#include <sys/vnode_internal.h>
766#include <sys/fcntl.h>
767#include <IOKit/IOPolledInterface.h>
768#include <IOKit/IOBufferMemoryDescriptor.h>
769
770IOPolledFileIOVars * gIOPolledCoreFileVars;
771kern_return_t gIOPolledCoreFileOpenRet = kIOReturnNotReady;
772#if IOPOLLED_COREFILE
773
774static IOReturn
775IOOpenPolledCoreFile(const char * filename)
776{
777 IOReturn err;
778 unsigned int debug;
779 uint64_t corefile_size_bytes = 0;
780
781 if (gIOPolledCoreFileVars) return (kIOReturnBusy);
782 if (!IOPolledInterface::gMetaClass.getInstanceCount()) return (kIOReturnUnsupported);
783
784 debug = 0;
785 PE_parse_boot_argn("debug", &debug, sizeof (debug));
786 if (DB_DISABLE_LOCAL_CORE & debug) return (kIOReturnUnsupported);
787
788#if CONFIG_EMBEDDED
789 unsigned int requested_corefile_size = 0;
790 if (PE_parse_boot_argn("corefile_size_mb", &requested_corefile_size, sizeof(requested_corefile_size))) {
791 IOLog("Boot-args specify %d MB kernel corefile\n", requested_corefile_size);
792
793 corefile_size_bytes = (requested_corefile_size * 1024ULL * 1024ULL);
794 }
795#endif
796
797
798 do {
799#if defined(kIOCoreDumpLargeSize)
800 if (0 == corefile_size_bytes)
801 {
802 // If no custom size was requested and we're on a device with >3GB of DRAM, attempt
803 // to allocate a large corefile otherwise use a small file.
804 if (max_mem > (3 * 1024ULL * 1024ULL * 1024ULL))
805 {
806 corefile_size_bytes = kIOCoreDumpLargeSize;
807 err = IOPolledFileOpen(filename,
808 kIOPolledFileCreate,
809 corefile_size_bytes, kIOCoreDumpFreeSize,
810 NULL, 0,
811 &gIOPolledCoreFileVars, NULL, NULL, 0);
812 if (kIOReturnSuccess == err)
813 {
814 break;
815 }
816 else if (kIOReturnNoSpace == err)
817 {
818 IOLog("Failed to open corefile of size %llu MB (low disk space)",
819 (corefile_size_bytes / (1024ULL * 1024ULL)));
820 if (corefile_size_bytes == kIOCoreDumpMinSize)
821 {
822 gIOPolledCoreFileOpenRet = err;
823 return (err);
824 }
825 // Try to open a smaller corefile (set size and fall-through)
826 corefile_size_bytes = kIOCoreDumpMinSize;
827 }
828 else
829 {
830 IOLog("Failed to open corefile of size %llu MB (returned error 0x%x)\n",
831 (corefile_size_bytes / (1024ULL * 1024ULL)), err);
832 gIOPolledCoreFileOpenRet = err;
833 return (err);
834 }
835 }
836 else
837 {
838 corefile_size_bytes = kIOCoreDumpMinSize;
839 }
840 }
841#else /* defined(kIOCoreDumpLargeSize) */
842 if (0 == corefile_size_bytes)
843 {
844 corefile_size_bytes = kIOCoreDumpSize;
845 }
846#endif /* defined(kIOCoreDumpLargeSize) */
847 err = IOPolledFileOpen(filename,
848 kIOPolledFileCreate,
849 corefile_size_bytes, kIOCoreDumpFreeSize,
850 NULL, 0,
851 &gIOPolledCoreFileVars, NULL, NULL, 0);
852 if (kIOReturnSuccess != err)
853 {
854 IOLog("Failed to open corefile of size %llu MB (returned error 0x%x)\n",
855 (corefile_size_bytes / (1024ULL * 1024ULL)), err);
856 gIOPolledCoreFileOpenRet = err;
857 return (err);
858 }
859 } while (false);
860
861 err = IOPolledFilePollersSetup(gIOPolledCoreFileVars, kIOPolledPreflightCoreDumpState);
862 if (kIOReturnSuccess != err)
863 {
864 IOPolledFileClose(&gIOPolledCoreFileVars, NULL, NULL, 0, 0, 0);
865 IOLog("IOPolledFilePollersSetup for corefile failed with error: 0x%x\n", err);
866 gIOPolledCoreFileOpenRet = err;
867 }
868 else
869 {
870 IOLog("Opened corefile of size %llu MB\n", (corefile_size_bytes / (1024ULL * 1024ULL)));
871 }
872
873 return (err);
874}
875
876static void
877IOClosePolledCoreFile(void)
878{
879 gIOPolledCoreFileOpenRet = kIOReturnNotOpen;
880 IOPolledFilePollersClose(gIOPolledCoreFileVars, kIOPolledPostflightCoreDumpState);
881 IOPolledFileClose(&gIOPolledCoreFileVars, NULL, NULL, 0, 0, 0);
882}
883
884static thread_call_t gIOOpenPolledCoreFileTC;
885static IONotifier * gIOPolledCoreFileNotifier;
886static IONotifier * gIOPolledCoreFileInterestNotifier;
887
888static IOReturn
889KernelCoreMediaInterest(void * target, void * refCon,
890 UInt32 messageType, IOService * provider,
891 void * messageArgument, vm_size_t argSize )
892{
893 if (kIOMessageServiceIsTerminated == messageType)
894 {
895 gIOPolledCoreFileInterestNotifier->remove();
896 gIOPolledCoreFileInterestNotifier = 0;
897 IOClosePolledCoreFile();
898 }
899
900 return (kIOReturnSuccess);
901}
902
903static void
904OpenKernelCoreMedia(thread_call_param_t p0, thread_call_param_t p1)
905{
906 IOService * newService;
907 OSString * string;
908 char filename[16];
909
910 newService = (IOService *) p1;
911 do
912 {
913 if (gIOPolledCoreFileVars) break;
914 string = OSDynamicCast(OSString, newService->getProperty(kIOBSDNameKey));
915 if (!string) break;
916 snprintf(filename, sizeof(filename), "/dev/%s", string->getCStringNoCopy());
917 if (kIOReturnSuccess != IOOpenPolledCoreFile(filename)) break;
918 gIOPolledCoreFileInterestNotifier = newService->registerInterest(
919 gIOGeneralInterest, &KernelCoreMediaInterest, NULL, 0);
920 }
921 while (false);
922
923 newService->release();
924}
925
926static bool
927NewKernelCoreMedia(void * target, void * refCon,
928 IOService * newService,
929 IONotifier * notifier)
930{
931 static volatile UInt32 onlyOneCorePartition = 0;
932 do
933 {
934 if (!OSCompareAndSwap(0, 1, &onlyOneCorePartition)) break;
935 if (gIOPolledCoreFileVars) break;
936 if (!gIOOpenPolledCoreFileTC) break;
937 newService = newService->getProvider();
938 if (!newService) break;
939 newService->retain();
940 thread_call_enter1(gIOOpenPolledCoreFileTC, newService);
941 }
942 while (false);
943
944 return (false);
945}
946
947#endif /* IOPOLLED_COREFILE */
948
949extern "C" void
950IOBSDMountChange(struct mount * mp, uint32_t op)
951{
952#if IOPOLLED_COREFILE
953
954 OSDictionary * bsdMatching;
955 OSDictionary * mediaMatching;
956 OSString * string;
957
958 if (!gIOPolledCoreFileNotifier) do
959 {
960 if (!gIOOpenPolledCoreFileTC) gIOOpenPolledCoreFileTC = thread_call_allocate(&OpenKernelCoreMedia, NULL);
961 bsdMatching = IOService::serviceMatching("IOMediaBSDClient");
962 if (!bsdMatching) break;
963 mediaMatching = IOService::serviceMatching("IOMedia");
964 string = OSString::withCStringNoCopy("5361644D-6163-11AA-AA11-00306543ECAC");
965 if (!string || !mediaMatching) break;
966 mediaMatching->setObject("Content", string);
967 string->release();
968 bsdMatching->setObject(gIOParentMatchKey, mediaMatching);
969 mediaMatching->release();
970
971 gIOPolledCoreFileNotifier = IOService::addMatchingNotification(
972 gIOFirstMatchNotification, bsdMatching,
973 &NewKernelCoreMedia, NULL, NULL, -1000);
974 }
975 while (false);
976
977#if CONFIG_EMBEDDED
978 uint64_t flags;
979 char path[128];
980 int pathLen;
981 vnode_t vn;
982 int result;
983
984 switch (op)
985 {
986 case kIOMountChangeMount:
987 case kIOMountChangeDidResize:
988
989 if (gIOPolledCoreFileVars) break;
990 flags = vfs_flags(mp);
991 if (MNT_RDONLY & flags) break;
992 if (!(MNT_LOCAL & flags)) break;
993
994 vn = vfs_vnodecovered(mp);
995 if (!vn) break;
996 pathLen = sizeof(path);
997 result = vn_getpath(vn, &path[0], &pathLen);
998 vnode_put(vn);
999 if (0 != result) break;
1000 if (!pathLen) break;
1001#if defined(XNU_TARGET_OS_BRIDGE)
1002 // on bridgeOS systems we put the core in /private/var/internal. We don't
1003 // want to match with /private/var because /private/var/internal is often mounted
1004 // over /private/var
1005 if ((pathLen - 1) < (int) strlen("/private/var/internal")) break;
1006#endif
1007 if (0 != strncmp(path, kIOCoreDumpPath, pathLen - 1)) break;
1008 IOOpenPolledCoreFile(kIOCoreDumpPath);
1009 break;
1010
1011 case kIOMountChangeUnmount:
1012 case kIOMountChangeWillResize:
1013 if (gIOPolledCoreFileVars && (mp == kern_file_mount(gIOPolledCoreFileVars->fileRef)))
1014 {
1015 IOClosePolledCoreFile();
1016 }
1017 break;
1018 }
1019#endif /* CONFIG_EMBEDDED */
1020#endif /* IOPOLLED_COREFILE */
1021}
1022
1023/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1024
1025extern "C" boolean_t
1026IOTaskHasEntitlement(task_t task, const char * entitlement)
1027{
1028 OSObject * obj;
1029 obj = IOUserClient::copyClientEntitlement(task, entitlement);
1030 if (!obj) return (false);
1031 obj->release();
1032 return (obj != kOSBooleanFalse);
1033}
1034
1035