IOService * IOPMPagingPlexus::findProvider ( IOService * mediaObject )
{
IORegistryEntry * node = mediaObject;
if ( mediaObject == NULL ) {
return NULL;
}
while ( node ) {
if ( node->inPlane(gIOPowerPlane) ) {
return (IOService *)node;
}
node = node->getParentEntry(gIOServicePlane);
}
return NULL;
}
/*
* Copyright (c) 1998-2013 Apple Inc. All rights reserved.
*
* @APPLE_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
* 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.
*
* The 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, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
#include <IOKit/IODeviceTreeSupport.h>
#include <IOKit/IOMessage.h>
#include <IOKit/storage/IOPartitionScheme.h>
#define super IOStorage
OSDefineMetaClassAndStructors(IOPartitionScheme, IOStorage)
#ifndef __LP64__
extern IOStorageAttributes gIOStorageAttributesUnsupported;
#endif /* !__LP64__ */
static SInt32 partitionComparison( const OSMetaClassBase * object1,
const OSMetaClassBase * object2,
void * context )
{
//
// Internal comparison routine for sorting partitions in an ordered set.
//
UInt64 base1 = ( ( IOMedia * ) object1 )->getBase( );
UInt64 base2 = ( ( IOMedia * ) object2 )->getBase( );
#if TARGET_OS_EMBEDDED
OSString * uuid1 = OSDynamicCast( OSString, ( ( IOMedia * ) object1 )->getProperty( kIOMediaUUIDKey ) );
OSString * uuid2 = OSDynamicCast( OSString, ( ( IOMedia * ) object2 )->getProperty( kIOMediaUUIDKey ) );
if ( uuid1 || uuid2 )
{
if ( uuid1 == 0 ) return -1;
if ( uuid2 == 0 ) return 1;
return strcmp( uuid2->getCStringNoCopy( ), uuid1->getCStringNoCopy( ) );
}
#endif /* TARGET_OS_EMBEDDED */
if ( base1 < base2 ) return 1;
if ( base1 > base2 ) return -1;
return 0;
}
IOMedia * IOPartitionScheme::getProvider() const
{
//
// Obtain this object's provider. We override the superclass's method
// to return a more specific subclass of OSObject -- an IOMedia. This
// method serves simply as a convenience to subclass developers.
//
return (IOMedia *) IOService::getProvider();
}
bool IOPartitionScheme::init(OSDictionary * properties)
{
//
// Initialize this object's minimal state.
//
if (super::init(properties) == false) return false;
_openLevel = kIOStorageAccessNone;
_openReaders = OSSet::withCapacity(16);
_openReaderWriters = OSSet::withCapacity(16);
if (_openReaders == 0 || _openReaderWriters == 0) return false;
return true;
}
void IOPartitionScheme::free()
{
//
// Free all of this object's outstanding resources.
//
if (_openReaders) _openReaders->release();
if (_openReaderWriters) _openReaderWriters->release();
super::free();
}
bool IOPartitionScheme::handleOpen(IOService * client,
IOOptionBits options,
void * argument)
{
//
// The handleOpen method grants or denies permission to access this object
// to an interested client. The argument is an IOStorageAccess value that
// specifies the level of access desired -- reader or reader-writer.
//
// This method can be invoked to upgrade or downgrade the access level for
// an existing client as well. The previous access level will prevail for
// upgrades that fail, of course. A downgrade should never fail. If the
// new access level should be the same as the old for a given client, this
// method will do nothing and return success. In all cases, one, singular
// close-per-client is expected for all opens-per-client received.
//
// This implementation replaces the IOService definition of handleOpen().
//
// We are guaranteed that no other opens or closes will be processed until
// we make our decision, change our state, and return from this method.
//
IOStorageAccess access = (uintptr_t) argument;
IOStorageAccess level;
assert(client);
assert( access == kIOStorageAccessReader ||
access == kIOStorageAccessReaderWriter );
//
// A partition scheme multiplexes the opens it receives from several clients
// and sends one open to the level below that satisfies the highest level of
// access.
//
unsigned writers = _openReaderWriters->getCount();
if (_openReaderWriters->containsObject(client)) writers--;
if (access == kIOStorageAccessReaderWriter) writers++;
level = (writers) ? kIOStorageAccessReaderWriter : kIOStorageAccessReader;
//
// Determine whether the levels below us accept this open or not (we avoid
// the open if the required access is the access we already hold).
//
if ( _openLevel != level )
{
IOStorage * provider;
provider = OSDynamicCast( IOStorage, getProvider( ) );
if ( provider )
{
bool success;
level = ( level | kIOStorageAccessSharedLock );
success = provider->open( this, options, level );
level = ( level & kIOStorageAccessReaderWriter );
if ( success == false )
{
return false;
}
}
}
//
// Process the open.
//
if (access == kIOStorageAccessReader)
{
_openReaders->setObject(client);
_openReaderWriters->removeObject(client); // (for a downgrade)
}
else // (access == kIOStorageAccessReaderWriter)
{
_openReaderWriters->setObject(client);
_openReaders->removeObject(client); // (for an upgrade)
}
_openLevel = level;
return true;
}
bool IOPartitionScheme::handleIsOpen(const IOService * client) const
{
//
// The handleIsOpen method determines whether the specified client, or any
// client if none is specificed, presently has an open on this object.
//
// This implementation replaces the IOService definition of handleIsOpen().
//
// We are guaranteed that no other opens or closes will be processed until
// we return from this method.
//
if (client == 0) return (_openLevel != kIOStorageAccessNone);
return ( _openReaderWriters->containsObject(client) ||
_openReaders->containsObject(client) );
}
void IOPartitionScheme::handleClose(IOService * client, IOOptionBits options)
{
//
// The handleClose method closes the client's access to this object.
//
// This implementation replaces the IOService definition of handleClose().
//
// We are guaranteed that no other opens or closes will be processed until
// we change our state and return from this method.
//
assert(client);
//
// Process the close.
//
if (_openReaderWriters->containsObject(client)) // (is it a reader-writer?)
{
_openReaderWriters->removeObject(client);
}
else if (_openReaders->containsObject(client)) // (is the client a reader?)
{
_openReaders->removeObject(client);
}
else // (is the client is an imposter?)
{
assert(0);
return;
}
//
// Reevaluate the open we have on the level below us. If no opens remain,
// we close, or if no reader-writer remains, but readers do, we downgrade.
//
IOStorageAccess level;
if (_openReaderWriters->getCount()) level = kIOStorageAccessReaderWriter;
else if (_openReaders->getCount()) level = kIOStorageAccessReader;
else level = kIOStorageAccessNone;
if ( _openLevel != level )
{
IOStorage * provider;
provider = OSDynamicCast( IOStorage, getProvider( ) );
if ( provider )
{
if ( level == kIOStorageAccessNone )
{
provider->close( this, options );
}
else
{
bool success;
level = ( level | kIOStorageAccessSharedLock );
success = provider->open( this, 0, level );
level = ( level & kIOStorageAccessReaderWriter );
assert( success );
}
}
_openLevel = level;
}
}
void IOPartitionScheme::read(IOService * client,
UInt64 byteStart,
IOMemoryDescriptor * buffer,
IOStorageAttributes * attributes,
IOStorageCompletion * completion)
{
//
// Read data from the storage object at the specified byte offset into the
// specified buffer, asynchronously. When the read completes, the caller
// will be notified via the specified completion action.
//
// The buffer will be retained for the duration of the read.
//
// For simple partition schemes, the default behavior is to simply pass the
// read through to the provider media. More complex partition schemes such
// as RAID will need to do extra processing here.
//
#ifndef __LP64__
if ( IOStorage::_expansionData )
{
if ( attributes == &gIOStorageAttributesUnsupported )
{
attributes = NULL;
}
else
{
IOStorage::read( client, byteStart, buffer, attributes, completion );
return;
}
}
#endif /* !__LP64__ */
getProvider( )->read( this, byteStart, buffer, attributes, completion );
}
void IOPartitionScheme::write(IOService * client,
UInt64 byteStart,
IOMemoryDescriptor * buffer,
IOStorageAttributes * attributes,
IOStorageCompletion * completion)
{
//
// Write data into the storage object at the specified byte offset from the
// specified buffer, asynchronously. When the write completes, the caller
// will be notified via the specified completion action.
//
// The buffer will be retained for the duration of the write.
//
// For simple partition schemes, the default behavior is to simply pass the
// write through to the provider media. More complex partition schemes such
// as RAID will need to do extra processing here.
//
#ifndef __LP64__
if ( IOStorage::_expansionData )
{
if ( attributes == &gIOStorageAttributesUnsupported )
{
attributes = NULL;
}
else
{
IOStorage::write( client, byteStart, buffer, attributes, completion );
return;
}
}
#endif /* !__LP64__ */
getProvider( )->write( this, byteStart, buffer, attributes, completion );
}
IOReturn IOPartitionScheme::synchronizeCache(IOService * client)
{
//
// Flush the cached data in the storage object, if any, synchronously.
//
return getProvider()->synchronizeCache(this);
}
IOReturn IOPartitionScheme::unmap(IOService * client,
IOStorageExtent * extents,
UInt32 extentsCount,
UInt32 options)
{
//
// Delete unused data from the storage object at the specified byte offsets,
// synchronously.
//
return getProvider( )->unmap( this, extents, extentsCount, options );
}
bool IOPartitionScheme::lockPhysicalExtents(IOService * client)
{
//
// Lock the contents of the storage object against relocation temporarily,
// for the purpose of getting physical extents.
//
return getProvider( )->lockPhysicalExtents( this );
}
IOStorage * IOPartitionScheme::copyPhysicalExtent(IOService * client,
UInt64 * byteStart,
UInt64 * byteCount)
{
//
// Convert the specified byte offset into a physical byte offset, relative
// to a physical storage object. This call should only be made within the
// context of lockPhysicalExtents().
//
return getProvider( )->copyPhysicalExtent( this, byteStart, byteCount );
}
void IOPartitionScheme::unlockPhysicalExtents(IOService * client)
{
//
// Unlock the contents of the storage object for relocation again. This
// call must balance a successful call to lockPhysicalExtents().
//
getProvider( )->unlockPhysicalExtents( this );
}
#ifdef __LP64__
bool IOPartitionScheme::attachMediaObjectToDeviceTree(IOMedia * media)
#else /* !__LP64__ */
bool IOPartitionScheme::attachMediaObjectToDeviceTree(IOMedia * media,
IOOptionBits options)
#endif /* !__LP64__ */
{
//
// Attach the given media object to the device tree plane.
//
IORegistryEntry * parent = this;
while ( (parent = parent->getParentEntry(gIOServicePlane)) )
{
if ( parent->inPlane(gIODTPlane) )
{
char location[ 32 ];
const char * locationOfParent = parent->getLocation(gIODTPlane);
const char * nameOfParent = parent->getName(gIODTPlane);
if ( locationOfParent == 0 ) break;
if ( OSDynamicCast(IOMedia, parent) == 0 ) break;
parent = parent->getParentEntry(gIODTPlane);
if ( parent == 0 ) break;
if ( media->attachToParent(parent, gIODTPlane) == false ) break;
strlcpy(location, locationOfParent, sizeof(location));
if ( strchr(location, ':') ) *(strchr(location, ':') + 1) = 0;
strlcat(location, media->getLocation(), sizeof(location) - strlen(location));
media->setLocation(location, gIODTPlane);
media->setName(nameOfParent, gIODTPlane);
return true;
}
}
return false;
}