OSSet * IOGUIDPartitionScheme::scan(SInt32 * score)
{
//
// Scan the provider media for a GUID partition map. Returns the set
// of media objects representing each of the partitions (the retain for
// the set is passed to the caller), or null should no partition map be
// found. The default probe score can be adjusted up or down, based on
// the confidence of the scan.
//
IOBufferMemoryDescriptor * buffer = 0;
IOByteCount bufferSize = 0;
UInt32 fdiskID = 0;
disk_blk0 * fdiskMap = 0;
UInt64 gptBlock = 0;
UInt32 gptCheck = 0;
UInt32 gptCount = 0;
UInt32 gptID = 0;
gpt_ent * gptMap = 0;
UInt32 gptSize = 0;
UInt32 headerCheck = 0;
gpt_hdr * headerMap = 0;
UInt32 headerSize = 0;
IOMedia * media = getProvider();
UInt64 mediaBlockSize = media->getPreferredBlockSize();
bool mediaIsOpen = false;
OSSet * partitions = 0;
IOReturn status = kIOReturnError;
// Determine whether this media is formatted.
if ( media->isFormatted() == false ) goto scanErr;
// Determine whether this media has an appropriate block size.
if ( (mediaBlockSize % sizeof(disk_blk0)) ) goto scanErr;
// Allocate a buffer large enough to hold one map, rounded to a media block.
bufferSize = IORound(sizeof(disk_blk0), mediaBlockSize);
buffer = IOBufferMemoryDescriptor::withCapacity(
/* capacity */ bufferSize,
/* withDirection */ kIODirectionIn );
if ( buffer == 0 ) goto scanErr;
// Allocate a set to hold the set of media objects representing partitions.
partitions = OSSet::withCapacity(8);
if ( partitions == 0 ) goto scanErr;
// Open the media with read access.
mediaIsOpen = open(this, 0, kIOStorageAccessReader);
if ( mediaIsOpen == false ) goto scanErr;
// Read the protective map into our buffer.
status = media->read(this, 0, buffer);
if ( status != kIOReturnSuccess ) goto scanErr;
fdiskMap = (disk_blk0 *) buffer->getBytesNoCopy();
// Determine whether the protective map signature is present.
if ( OSSwapLittleToHostInt16(fdiskMap->signature) != DISK_SIGNATURE )
{
goto scanErr;
}
// Scan for valid partition entries in the protective map.
for ( unsigned index = 0; index < DISK_NPART; index++ )
{
if ( fdiskMap->parts[index].systid )
{
if ( fdiskMap->parts[index].systid == 0xEE )
{
if ( fdiskID ) goto scanErr;
fdiskID = index + 1;
}
}
}
if ( fdiskID == 0 ) goto scanErr;
// Read the partition header into our buffer.
status = media->read(this, mediaBlockSize, buffer);
if ( status != kIOReturnSuccess ) goto scanErr;
headerMap = (gpt_hdr *) buffer->getBytesNoCopy();
// Determine whether the partition header signature is present.
if ( memcmp(headerMap->hdr_sig, GPT_HDR_SIG, strlen(GPT_HDR_SIG)) )
{
goto scanErr;
}
// Determine whether the partition header size is valid.
headerCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_self);
headerSize = OSSwapLittleToHostInt32(headerMap->hdr_size);
if ( headerSize < offsetof(gpt_hdr, padding) )
{
goto scanErr;
}
if ( headerSize > mediaBlockSize )
{
goto scanErr;
}
// Determine whether the partition header checksum is valid.
headerMap->hdr_crc_self = 0;
if ( crc32(0, headerMap, headerSize) != headerCheck )
{
goto scanErr;
}
// Determine whether the partition entry size is valid.
gptCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_table);
gptSize = OSSwapLittleToHostInt32(headerMap->hdr_entsz);
if ( gptSize < sizeof(gpt_ent) )
{
goto scanErr;
}
if ( gptSize > UINT16_MAX )
{
goto scanErr;
}
// Determine whether the partition entry count is valid.
gptBlock = OSSwapLittleToHostInt64(headerMap->hdr_lba_table);
gptCount = OSSwapLittleToHostInt32(headerMap->hdr_entries);
if ( gptCount > UINT16_MAX )
{
goto scanErr;
}
// Allocate a buffer large enough to hold one map, rounded to a media block.
buffer->release();
bufferSize = IORound(gptCount * gptSize, mediaBlockSize);
buffer = IOBufferMemoryDescriptor::withCapacity(
/* capacity */ bufferSize,
/* withDirection */ kIODirectionIn );
if ( buffer == 0 ) goto scanErr;
// Read the partition header into our buffer.
status = media->read(this, gptBlock * mediaBlockSize, buffer);
if ( status != kIOReturnSuccess ) goto scanErr;
gptMap = (gpt_ent *) buffer->getBytesNoCopy();
// Determine whether the partition entry checksum is valid.
if ( crc32(0, gptMap, gptCount * gptSize) != gptCheck )
{
goto scanErr;
}
// Scan for valid partition entries in the partition map.
for ( gptID = 1; gptID <= gptCount; gptID++ )
{
gptMap = (gpt_ent *) ( ((UInt8 *) buffer->getBytesNoCopy()) +
(gptID * gptSize) - gptSize );
uuid_unswap( gptMap->ent_type );
uuid_unswap( gptMap->ent_uuid );
if ( isPartitionUsed( gptMap ) )
{
// Determine whether the partition is corrupt (fatal).
if ( isPartitionCorrupt( gptMap, gptID ) )
{
goto scanErr;
}
// Determine whether the partition is invalid (skipped).
if ( isPartitionInvalid( gptMap, gptID ) )
{
continue;
}
// Create a media object to represent this partition.
IOMedia * newMedia = instantiateMediaObject( gptMap, gptID );
if ( newMedia )
{
partitions->setObject(newMedia);
newMedia->release();
}
}
}
// Release our resources.
close(this);
buffer->release();
return partitions;
scanErr:
// Release our resources.
if ( mediaIsOpen ) close(this);
if ( partitions ) partitions->release();
if ( buffer ) buffer->release();
return 0;
}
bool
AppleFileSystemDriver::mediaNotificationHandler(
void * target, void * ref,
IOService * service,
IONotifier * notifier)
{
AppleFileSystemDriver * fs;
IOMedia * media;
IOReturn status = kIOReturnError;
OSString * contentHint;
const char * contentStr;
VolumeUUID volumeUUID;
OSString * uuidProperty;
uuid_t uuid;
bool matched = false;
DEBUG_LOG("%s[%p]::%s -> '%s'\n", kClassName, target, __func__, service->getName());
do {
fs = OSDynamicCast( AppleFileSystemDriver, (IOService *)target );
if (fs == 0) break;
media = OSDynamicCast( IOMedia, service );
if (media == 0) break;
// i.e. does it know how big it is / have a block size
if ( media->isFormatted() == false ) break;
// If the media already has a UUID property, try that first.
uuidProperty = OSDynamicCast( OSString, media->getProperty("UUID") );
if (uuidProperty != NULL) {
if (fs->_uuidString && uuidProperty->isEqualTo(fs->_uuidString)) {
VERBOSE_LOG("existing UUID property matched\n");
matched = true;
break;
}
}
// only IOMedia's with content hints are interesting
contentHint = OSDynamicCast( OSString, media->getProperty(kIOMediaContentHintKey) );
if (contentHint == NULL) break;
contentStr = contentHint->getCStringNoCopy();
if (contentStr == NULL) break;
// probe based on content hint
if ( strcmp(contentStr, "Apple_HFS" ) == 0 ||
strcmp(contentStr, "Apple_HFSX" ) == 0 ||
strcmp(contentStr, "Apple_Boot" ) == 0 ||
strcmp(contentStr, "Apple_Recovery" ) == 0 ||
strcmp(contentStr, "48465300-0000-11AA-AA11-00306543ECAC" ) == 0 || /* APPLE_HFS_UUID */
strcmp(contentStr, "426F6F74-0000-11AA-AA11-00306543ECAC" ) == 0 || /* APPLE_BOOT_UUID */
strcmp(contentStr, "5265636F-7665-11AA-AA11-00306543ECAC" ) == 0 ) { /* APPLE_RECOVERY_UUID */
status = readHFSUUID( media, (void **)&volumeUUID );
} else {
DEBUG_LOG("contentStr %s\n", contentStr);
break;
}
if (status != kIOReturnSuccess) {
break;
}
if (createUUIDFromName( kFSUUIDNamespaceSHA1,
volumeUUID.bytes, kVolumeUUIDValueLength,
uuid ) != kIOReturnSuccess) {
break;
}
#if VERBOSE
OSString *str = createStringFromUUID(uuid);
OSString *bsdn = OSDynamicCast(OSString,media->getProperty("BSD Name"));
if (str) {
IOLog(" UUID %s found on volume '%s' (%s)\n", str->getCStringNoCopy(),
media->getName(), bsdn ? bsdn->getCStringNoCopy():"");
str->release();
}
#endif
if (fs->_uuid) {
if ( uuid_compare(uuid, fs->_uuid) == 0 ) {
VERBOSE_LOG(" UUID matched on volume %s\n", media->getName());
matched = true;
}
}
} while (false);
if (matched) {
// prevent more notifications, if notifier is available
if (fs->_notifier != NULL) {
fs->_notifier->remove();
fs->_notifier = NULL;
}
DEBUG_LOG("%s::%s publishing boot-uuid-media '%s'\n", kClassName, __func__, media->getName());
IOService::publishResource( kBootUUIDMediaKey, media );
// Now that our job is done, get rid of the matching property
// and kill the driver.
fs->getResourceService()->removeProperty( kBootUUIDKey );
fs->terminate( kIOServiceRequired );
// Drop the retain for asynchronous notification
fs->release( );
VERBOSE_LOG("%s[%p]::%s returning TRUE\n", kClassName, target, __func__);
return true;
}
DEBUG_LOG("%s[%p]::%s returning false\n", kClassName, target, __func__);
#if DEBUG
//IOSleep(5000);
#endif
return false;
}
OSSet * IOFDiskPartitionScheme::scan(SInt32 * score)
{
//
// Scan the provider media for an FDisk partition map. Returns the set
// of media objects representing each of the partitions (the retain for
// the set is passed to the caller), or null should no partition map be
// found. The default probe score can be adjusted up or down, based on
// the confidence of the scan.
//
IOBufferMemoryDescriptor * buffer = 0;
UInt32 bufferSize = 0;
UInt32 fdiskBlock = 0;
UInt32 fdiskBlockExtn = 0;
UInt32 fdiskBlockNext = 0;
UInt32 fdiskID = 0;
disk_blk0 * fdiskMap = 0;
IOMedia * media = getProvider();
UInt64 mediaBlockSize = media->getPreferredBlockSize();
bool mediaIsOpen = false;
OSSet * partitions = 0;
IOReturn status = kIOReturnError;
// Determine whether this media is formatted.
if ( media->isFormatted() == false ) goto scanErr;
// Determine whether this media has an appropriate block size.
if ( (mediaBlockSize % sizeof(disk_blk0)) ) goto scanErr;
// Allocate a buffer large enough to hold one map, rounded to a media block.
bufferSize = IORound(sizeof(disk_blk0), mediaBlockSize);
buffer = IOBufferMemoryDescriptor::withCapacity(
/* capacity */ bufferSize,
/* withDirection */ kIODirectionIn );
if ( buffer == 0 ) goto scanErr;
// Allocate a set to hold the set of media objects representing partitions.
partitions = OSSet::withCapacity(4);
if ( partitions == 0 ) goto scanErr;
// Open the media with read access.
mediaIsOpen = open(this, 0, kIOStorageAccessReader);
if ( mediaIsOpen == false ) goto scanErr;
// Scan the media for FDisk partition map(s).
do
{
// Read the next FDisk map into our buffer.
status = media->read(this, fdiskBlock * mediaBlockSize, buffer);
if ( status != kIOReturnSuccess ) goto scanErr;
fdiskMap = (disk_blk0 *) buffer->getBytesNoCopy();
// Determine whether the partition map signature is present.
if ( OSSwapLittleToHostInt16(fdiskMap->signature) != DISK_SIGNATURE )
{
goto scanErr;
}
// Scan for valid partition entries in the partition map.
fdiskBlockNext = 0;
for ( unsigned index = 0; index < DISK_NPART; index++ )
{
// Determine whether this is an extended (vs. data) partition.
if ( isPartitionExtended(fdiskMap->parts + index) ) // (extended)
{
// If peer extended partitions exist, we accept only the first.
if ( fdiskBlockNext == 0 ) // (no peer extended partition)
{
fdiskBlockNext = fdiskBlockExtn +
OSSwapLittleToHostInt32(
/* data */ fdiskMap->parts[index].relsect );
if ( fdiskBlockNext * mediaBlockSize >= media->getSize() )
{
fdiskBlockNext = 0; // (exceeds confines of media)
}
}
}
else if ( isPartitionUsed(fdiskMap->parts + index) ) // (data)
{
// Prepare this partition's ID.
fdiskID = ( fdiskBlock == 0 ) ? (index + 1) : (fdiskID + 1);
// Determine whether the partition is corrupt (fatal).
if ( isPartitionCorrupt(
/* partition */ fdiskMap->parts + index,
/* partitionID */ fdiskID,
/* fdiskBlock */ fdiskBlock ) )
{
goto scanErr;
}
// Determine whether the partition is invalid (skipped).
if ( isPartitionInvalid(
/* partition */ fdiskMap->parts + index,
/* partitionID */ fdiskID,
/* fdiskBlock */ fdiskBlock ) )
{
continue;
}
// Create a media object to represent this partition.
IOMedia * newMedia = instantiateMediaObject(
/* partition */ fdiskMap->parts + index,
/* partitionID */ fdiskID,
/* fdiskBlock */ fdiskBlock );
if ( newMedia )
{
partitions->setObject(newMedia);
newMedia->release();
}
}
}
// Prepare for first extended partition, if any.
if ( fdiskBlock == 0 )
{
fdiskID = DISK_NPART;
fdiskBlockExtn = fdiskBlockNext;
}
} while ( (fdiskBlock = fdiskBlockNext) );
// Release our resources.
close(this);
buffer->release();
return partitions;
scanErr:
// Release our resources.
if ( mediaIsOpen ) close(this);
if ( partitions ) partitions->release();
if ( buffer ) buffer->release();
return 0;
}
