IOSCSITargetDevice.cpp [plain text]
#include <libkern/OSByteOrder.h>
#include <IOKit/IOMessage.h>
#include <IOKit/IOKitKeys.h>
#include <IOKit/IOMemoryDescriptor.h>
#include "SCSITaskDefinition.h"
#include "SCSIPrimaryCommands.h"
#include "IOSCSITargetDevice.h"
#include <IOKit/scsi/SCSICmds_INQUIRY_Definitions.h>
#define DEBUG 0
#define DEBUG_ASSERT_COMPONENT_NAME_STRING "SCSI Target Device"
#if DEBUG
#define SCSI_TARGET_DEVICE_DEBUGGING_LEVEL 3
#endif
#include "IOSCSIArchitectureModelFamilyDebugging.h"
#if ( SCSI_TARGET_DEVICE_DEBUGGING_LEVEL >= 1 )
#define PANIC_NOW(x) IOPanic x
#else
#define PANIC_NOW(x)
#endif
#if ( SCSI_TARGET_DEVICE_DEBUGGING_LEVEL >= 2 )
#define ERROR_LOG(x) IOLog x
#else
#define ERROR_LOG(x)
#endif
#if ( SCSI_TARGET_DEVICE_DEBUGGING_LEVEL >= 3 )
#define STATUS_LOG(x) IOLog x
#else
#define STATUS_LOG(x)
#endif
#define super IOSCSIPrimaryCommandsDevice
OSDefineMetaClassAndStructors ( IOSCSITargetDevice, IOSCSIPrimaryCommandsDevice );
#define kTURMaxRetries 1
#define kMaxInquiryAttempts 2
#define kStandardInquiryDataHeaderSize 5
#define kVitalProductsInquiryDataHeaderSize 4
#if 0
#pragma mark -
#pragma mark ₯ Public Methods
#pragma mark -
#endif
bool
IOSCSITargetDevice::handleOpen ( IOService * client,
IOOptionBits options,
void * arg )
{
bool result = false;
require_nonzero ( fClients, ErrorExit );
require_nonzero ( OSDynamicCast ( IOSCSILogicalUnitNub, client ), ErrorExit );
result = fClients->setObject ( client );
ErrorExit:
return result;
}
void
IOSCSITargetDevice::handleClose ( IOService * client,
IOOptionBits options )
{
require_nonzero ( fClients, Exit );
if ( fClients->containsObject ( client ) )
{
fClients->removeObject ( client );
if ( ( fClients->getCount ( ) == 0 ) && isInactive ( ) )
{
message ( kIOMessageServiceIsRequestingClose, getProvider ( ), 0 );
}
}
Exit:
return;
}
bool
IOSCSITargetDevice::handleIsOpen ( const IOService * client ) const
{
bool result = false;
require_nonzero ( fClients, CallSuperClassError );
if ( ( client == NULL ) && ( fClients->getCount ( ) != 0 ) )
{
result = true;
}
else
{
result = fClients->containsObject ( client );
}
return result;
CallSuperClassError:
result = super::handleIsOpen ( client );
return result;
}
#if 0
#pragma mark -
#pragma mark ₯ Protected Methods - Methods used by this class and subclasses
#pragma mark -
#endif
bool
IOSCSITargetDevice::InitializeDeviceSupport ( void )
{
bool result = false;
RetrieveCharacteristicsFromProvider ( );
result = DetermineTargetCharacteristics ( );
return result;
}
void
IOSCSITargetDevice::StartDeviceSupport ( void )
{
UInt64 countLU;
UInt64 loopLU;
bool supportsREPORTLUNS = false;
countLU = DetermineMaximumLogicalUnitNumber ( );
fClients = OSSet::withCapacity ( countLU + 1 );
#if 0
if ( fTargetANSIVersion >= kINQUIRY_ANSI_VERSION_SCSI_SPC_Compliant )
{
UInt32 luCount[2];
if ( RetrieveReportLUNsData ( 0, ( UInt8 * ) luCount, 8 ) == true )
{
}
}
#endif
if ( supportsREPORTLUNS == false )
{
for ( loopLU = 0; loopLU <= countLU; loopLU++ )
{
CreateLogicalUnit ( loopLU );
}
}
registerService ( );
}
void
IOSCSITargetDevice::SuspendDeviceSupport ( void )
{
}
void
IOSCSITargetDevice::ResumeDeviceSupport ( void )
{
}
void
IOSCSITargetDevice::StopDeviceSupport ( void )
{
}
void
IOSCSITargetDevice::TerminateDeviceSupport ( void )
{
}
UInt32
IOSCSITargetDevice::GetNumberOfPowerStateTransitions ( void )
{
return 0;
}
bool
IOSCSITargetDevice::ClearNotReadyStatus ( void )
{
return true;
}
#if 0
#pragma mark -
#pragma mark ₯ Power Management Utility Methods
#pragma mark -
#endif
UInt32
IOSCSITargetDevice::GetInitialPowerState ( void )
{
return 0;
}
void
IOSCSITargetDevice::HandlePowerChange ( void )
{
}
void
IOSCSITargetDevice::HandleCheckPowerState ( void )
{
}
void
IOSCSITargetDevice::TicklePowerManager ( void )
{
}
void
IOSCSITargetDevice::RetrieveCharacteristicsFromProvider ( void )
{
OSDictionary * characterDict = NULL;
OSObject * obj = NULL;
fDefaultInquiryCount = 0;
obj = GetProtocolDriver ( )->getProperty ( kIOPropertySCSIDeviceCharacteristicsKey );
if ( obj != NULL )
{
characterDict = OSDynamicCast ( OSDictionary, obj );
if ( characterDict != NULL )
{
setProperty ( kIOPropertySCSIDeviceCharacteristicsKey, characterDict );
if ( characterDict->getObject ( kIOPropertySCSIInquiryLengthKey ) != NULL )
{
OSNumber * defaultInquiry = NULL;
STATUS_LOG ( ( "%s: Get Inquiry Length property.\n", getName ( ) ) );
obj = characterDict->getObject ( kIOPropertySCSIInquiryLengthKey );
defaultInquiry = OSDynamicCast ( OSNumber, obj );
if ( defaultInquiry != NULL )
{
fDefaultInquiryCount = defaultInquiry->unsigned32BitValue ( );
}
}
}
}
STATUS_LOG ( ( "%s: default inquiry count is: %d\n", getName ( ), fDefaultInquiryCount ) );
obj = GetProtocolDriver ( )->getProperty ( kIOPropertyProtocolCharacteristicsKey );
characterDict = OSDynamicCast ( OSDictionary, obj );
if ( characterDict == NULL )
{
characterDict = OSDictionary::withCapacity ( 1 );
}
else
{
characterDict->retain ( );
}
if ( characterDict != NULL )
{
obj = GetProtocolDriver ( )->getProperty ( kIOPropertyPhysicalInterconnectTypeKey );
if ( obj != NULL )
{
characterDict->setObject ( kIOPropertyPhysicalInterconnectTypeKey, obj );
}
obj = GetProtocolDriver ( )->getProperty ( kIOPropertyPhysicalInterconnectLocationKey );
if ( obj != NULL )
{
characterDict->setObject ( kIOPropertyPhysicalInterconnectLocationKey, obj );
}
setProperty ( kIOPropertyProtocolCharacteristicsKey, characterDict );
#if 0
obj = GetProtocolDriver ( )->getProperty ( kIOPropertySCSIProtocolMultiInitKey );
if ( obj != NULL )
{
}
#endif
characterDict->release ( );
}
}
#if 0
#pragma mark -
#pragma mark ₯ Target Related Member Routines
#pragma mark -
#endif
bool
IOSCSITargetDevice::DetermineTargetCharacteristics ( void )
{
UInt8 inqData[255] = { 0 };
UInt8 inqDataCount = 0;
bool result = false;
result = VerifyTargetPresence ( );
require_string ( result, ErrorExit, "Target presence could not be verified" );
if ( fDefaultInquiryCount != 0 )
{
inqDataCount = fDefaultInquiryCount;
}
else
{
SCSICmd_INQUIRY_StandardDataAll * stdData = NULL;
result = RetrieveDefaultINQUIRYData ( 0, inqData, kStandardInquiryDataHeaderSize + 1 );
require_string ( result, ErrorExit, "Target INQUIRY data could not be retrieved" );
stdData = ( SCSICmd_INQUIRY_StandardDataAll * ) inqData;
inqDataCount = stdData->ADDITIONAL_LENGTH + kStandardInquiryDataHeaderSize;
}
result = RetrieveDefaultINQUIRYData ( 0, inqData, inqDataCount );
require_string ( result, ErrorExit, "Target INQUIRY data could not be retrieved" );
result = IsProtocolServiceSupported ( kSCSIProtocolFeature_SubmitDefaultInquiryData, NULL );
if ( result == true )
{
HandleProtocolServiceFeature ( kSCSIProtocolFeature_SubmitDefaultInquiryData,
( void * ) inqData );
}
SetCharacteristicsFromINQUIRY ( ( SCSICmd_INQUIRY_StandardDataAll * ) inqData );
result = RetrieveINQUIRYDataPage ( 0, inqData, 0, kVitalProductsInquiryDataHeaderSize );
if ( result == true )
{
UInt8 loop;
bool pagefound = false;
RetrieveINQUIRYDataPage ( 0, inqData, 0, inqData[3] + kVitalProductsInquiryDataHeaderSize );
for ( loop = kVitalProductsInquiryDataHeaderSize; loop < ( inqData[3] + kVitalProductsInquiryDataHeaderSize ); loop++ )
{
if ( inqData[loop] == kINQUIRY_Page83_PageCode )
{
pagefound = true;
break;
}
}
if ( pagefound == true )
{
PublishDeviceIdentification ( );
}
}
result = true;
ErrorExit:
return result;
}
bool
IOSCSITargetDevice::VerifyTargetPresence ( void )
{
SCSITaskIdentifier request = NULL;
bool presenceVerified = false;
UInt8 TURCount = 0;
request = GetSCSITask ( );
require_nonzero ( request, ErrorExit );
do
{
SCSIServiceResponse serviceResponse = kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE;
TEST_UNIT_READY ( request, 0x00 );
serviceResponse = SendCommand ( request, 0 );
if ( serviceResponse == kSCSIServiceResponse_TASK_COMPLETE )
{
if ( GetTaskStatus ( request ) == kSCSITaskStatus_CHECK_CONDITION )
{
bool validSense = false;
SCSI_Sense_Data senseBuffer = { 0 };
validSense = GetAutoSenseData ( request, &senseBuffer, sizeof ( senseBuffer ) );
if ( validSense == false )
{
IOMemoryDescriptor * bufferDesc = NULL;
bufferDesc = IOMemoryDescriptor::withAddress ( ( void * ) &senseBuffer,
sizeof ( SCSI_Sense_Data ),
kIODirectionIn );
if ( bufferDesc != NULL )
{
REQUEST_SENSE ( request, bufferDesc, kSenseDefaultSize, 0 );
serviceResponse = SendCommand ( request, 0 );
bufferDesc->release ( );
}
}
}
presenceVerified = true;
}
TURCount++;
} while ( ( presenceVerified == false ) && ( TURCount < kTURMaxRetries ) );
ReleaseSCSITask ( request );
ErrorExit:
return presenceVerified;
}
bool
IOSCSITargetDevice::SetCharacteristicsFromINQUIRY (
SCSICmd_INQUIRY_StandardDataAll * inquiryBuffer )
{
OSString * string = NULL;
int index = 0;
char tempString[17];
fTargetPeripheralDeviceType = ( inquiryBuffer->PERIPHERAL_DEVICE_TYPE & kINQUIRY_PERIPHERAL_TYPE_Mask );
fTargetANSIVersion = ( inquiryBuffer->VERSION & kINQUIRY_ANSI_VERSION_Mask );
#if 0
fTargetHasHiSup = ( inquiryBuffer->RESPONSE_DATA_FORMAT & kINQUIRY_Byte3_HISUP_Mask );
fTargetHasSCCS = ( inquiryBuffer->SCCSReserved & kINQUIRY_Byte5_SCCS_Mask );
fTargetHasEncServs = ( inquiryBuffer->flags1 & kINQUIRY_Byte6_ENCSERV_Mask );
fTargetHasMultiPorts = ( inquiryBuffer->flags1 & kINQUIRY_Byte6_MULTIP_Mask );;
fTargetHasMChanger = ( inquiryBuffer->flags1 & kINQUIRY_Byte6_MCHNGR_Mask );;
#endif
setProperty ( kIOPropertySCSIPeripheralDeviceType,
( UInt64 ) fTargetPeripheralDeviceType,
kIOPropertySCSIPeripheralDeviceTypeSize );
for ( index = 0; index < kINQUIRY_VENDOR_IDENTIFICATION_Length; index++ )
{
tempString[index] = inquiryBuffer->VENDOR_IDENTIFICATION[index];
}
tempString[index] = 0;
for ( index = kINQUIRY_VENDOR_IDENTIFICATION_Length - 1; index != 0; index-- )
{
if ( tempString[index] != ' ' )
{
tempString[index + 1] = '\0';
break;
}
}
string = OSString::withCString ( tempString );
if ( string != NULL )
{
setProperty ( kIOPropertySCSIVendorIdentification, string );
string->release ( );
string = NULL;
}
for ( index = 0; index < kINQUIRY_PRODUCT_IDENTIFICATION_Length; index++ )
{
tempString[index] = inquiryBuffer->PRODUCT_IDENTIFICATION[index];
}
tempString[index] = 0;
for ( index = kINQUIRY_PRODUCT_IDENTIFICATION_Length - 1; index != 0; index-- )
{
if ( tempString[index] != ' ' )
{
tempString[index+1] = '\0';
break;
}
}
string = OSString::withCString ( tempString );
if ( string != NULL )
{
setProperty ( kIOPropertySCSIProductIdentification, string );
string->release ( );
string = NULL;
}
for ( index = 0; index < kINQUIRY_PRODUCT_REVISION_LEVEL_Length; index++ )
{
tempString[index] = inquiryBuffer->PRODUCT_REVISION_LEVEL[index];
}
tempString[index] = 0;
for ( index = kINQUIRY_PRODUCT_REVISION_LEVEL_Length - 1; index != 0; index-- )
{
if ( tempString[index] != ' ' )
{
tempString[index+1] = '\0';
break;
}
}
string = OSString::withCString ( tempString );
if ( string != NULL )
{
setProperty ( kIOPropertySCSIProductRevisionLevel, string );
string->release ( );
string = NULL;
}
return true;
}
#if 0
#pragma mark -
#pragma mark ₯ Logical Unit Related Member Routines
#pragma mark -
#endif
bool
IOSCSITargetDevice::RetrieveReportLUNsData (
SCSILogicalUnitNumber logicalUnit,
UInt8 * dataBuffer,
UInt8 dataSize )
{
SCSIServiceResponse serviceResponse = kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE;
IOMemoryDescriptor * bufferDesc = NULL;
SCSITaskIdentifier request = NULL;
bool result = false;
bufferDesc = IOMemoryDescriptor::withAddress ( ( void * ) dataBuffer,
dataSize,
kIODirectionIn );
require_nonzero ( bufferDesc, ErrorExit );
request = GetSCSITask ( );
require_nonzero ( request, ReleaseBuffer );
if ( REPORT_LUNS ( request, bufferDesc, dataSize, 0 ) == true )
{
serviceResponse = SendCommand ( request, 0 );
if ( ( serviceResponse == kSCSIServiceResponse_TASK_COMPLETE ) &&
( GetTaskStatus ( request ) == kSCSITaskStatus_GOOD ) )
{
result = true;
}
}
ReleaseSCSITask ( request );
request = NULL;
ReleaseBuffer:
require_nonzero_quiet ( bufferDesc, ErrorExit );
bufferDesc->release ( );
bufferDesc = NULL;
ErrorExit:
return result;
}
UInt64
IOSCSITargetDevice::DetermineMaximumLogicalUnitNumber ( void )
{
UInt32 protocolLUNCount = 0;
bool supported = false;
supported = IsProtocolServiceSupported (
kSCSIProtocolFeature_GetMaximumLogicalUnitNumber,
( void * ) &protocolLUNCount );
if ( supported == false )
{
protocolLUNCount = 0;
}
return protocolLUNCount;
}
bool
IOSCSITargetDevice::VerifyLogicalUnitPresence (
SCSILogicalUnitNumber theLogicalUnit )
{
return false;
}
bool
IOSCSITargetDevice::CreateLogicalUnit ( SCSILogicalUnitNumber theLogicalUnit )
{
bool result = false;
IOSCSILogicalUnitNub * nub = NULL;
nub = OSTypeAlloc ( IOSCSILogicalUnitNub );
require_nonzero ( nub, ErrorExit );
result = nub->init ( 0 );
require ( result, ReleaseNub );
nub->SetLogicalUnitNumber ( ( UInt8 ) theLogicalUnit );
result = nub->attach ( this );
require ( result, ReleaseNub );
result = nub->start ( this );
require_action ( result, ReleaseNub, nub->detach ( this ) );
ReleaseNub:
require_nonzero_quiet ( nub, ErrorExit );
nub->release ( );
nub = NULL;
ErrorExit:
return result;
}
#if 0
#pragma mark -
#pragma mark ₯ INQUIRY Utility Member Routines
#pragma mark -
#endif
bool
IOSCSITargetDevice::RetrieveDefaultINQUIRYData (
SCSILogicalUnitNumber logicalUnit,
UInt8 * inquiryBuffer,
UInt8 inquirySize )
{
SCSIServiceResponse serviceResponse = kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE;
IOMemoryDescriptor * bufferDesc = NULL;
SCSITaskIdentifier request = NULL;
int index = 0;
bool result = false;
bufferDesc = IOMemoryDescriptor::withAddress ( ( void * ) inquiryBuffer,
inquirySize,
kIODirectionIn );
require_nonzero ( bufferDesc, ErrorExit );
request = GetSCSITask ( );
require_nonzero ( request, ReleaseBuffer );
for ( index = 0; index < kMaxInquiryAttempts; index++ )
{
result = INQUIRY ( request, bufferDesc, 0, 0, 0, inquirySize, 0 );
require ( result, ReleaseTask );
serviceResponse = SendCommand ( request, 0 );
if ( ( serviceResponse == kSCSIServiceResponse_TASK_COMPLETE ) &&
( GetTaskStatus ( request ) == kSCSITaskStatus_GOOD ) )
{
result = true;
break;
}
else
{
result = false;
IOSleep ( 1000 );
}
}
ReleaseTask:
require_nonzero_quiet ( request, ReleaseBuffer );
ReleaseSCSITask ( request );
request = NULL;
ReleaseBuffer:
require_nonzero_quiet ( bufferDesc, ReleaseBuffer );
bufferDesc->release ( );
bufferDesc = NULL;
ErrorExit:
return result;
}
bool
IOSCSITargetDevice::RetrieveINQUIRYDataPage (
SCSILogicalUnitNumber logicalUnit,
UInt8 * inquiryBuffer,
UInt8 inquiryPage,
UInt8 inquirySize )
{
SCSIServiceResponse serviceResponse = kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE;
SCSITaskIdentifier request = NULL;
IOMemoryDescriptor * bufferDesc = NULL;
bool result = false;
bufferDesc = IOMemoryDescriptor::withAddress ( ( void * ) inquiryBuffer,
inquirySize,
kIODirectionIn );
require_nonzero ( bufferDesc, ErrorExit );
request = GetSCSITask ( );
require_nonzero ( request, ReleaseBuffer );
if ( INQUIRY (
request,
bufferDesc,
0,
1,
inquiryPage,
inquirySize,
0 ) == true )
{
serviceResponse = SendCommand ( request, 0 );
if ( ( serviceResponse == kSCSIServiceResponse_TASK_COMPLETE ) &&
( GetTaskStatus ( request ) == kSCSITaskStatus_GOOD ) )
{
result = true;
}
}
ReleaseSCSITask ( request );
ReleaseBuffer:
require_nonzero_quiet ( bufferDesc, ErrorExit );
bufferDesc->release ( );
bufferDesc = NULL;
ErrorExit:
return result;
}
void
IOSCSITargetDevice::PublishDeviceIdentification ( void )
{
OSArray * deviceIDs = NULL;
UInt8 inqData[255] = { 0 };
UInt8 inqDataCount = 0;
UInt8 deviceIDCount = 0;
bool result = false;
result = RetrieveINQUIRYDataPage ( 0, inqData, kINQUIRY_Page83_PageCode, kVitalProductsInquiryDataHeaderSize );
require ( result, ErrorExit );
require_nonzero ( inqData[3], ErrorExit );
result = RetrieveINQUIRYDataPage ( 0, inqData, kINQUIRY_Page83_PageCode, inqData[3] + kVitalProductsInquiryDataHeaderSize );
require ( result, ErrorExit );
deviceIDs = OSArray::withCapacity ( 1 );
require_nonzero ( deviceIDs, ErrorExit );
inqDataCount = kVitalProductsInquiryDataHeaderSize;
while ( inqDataCount < ( inqData[3] + kVitalProductsInquiryDataHeaderSize ) )
{
UInt8 idSize;
OSDictionary * idDictionary;
OSNumber * numString = NULL;
UInt8 codeSet = 0;
deviceIDCount++;
idDictionary = OSDictionary::withCapacity ( 1 );
require_nonzero ( idDictionary, ReleaseDeviceIDs );
codeSet = inqData[inqDataCount] & 0x0F;
numString = OSNumber::withNumber ( codeSet, 8 );
if ( numString != NULL )
{
idDictionary->setObject ( kIOPropertySCSIINQUIRYDeviceIdCodeSet, numString );
numString->release ( );
numString = NULL;
}
numString = OSNumber::withNumber ( inqData[inqDataCount + 1] & kINQUIRY_Page83_CodeSetMask, 8 );
if ( numString != NULL )
{
idDictionary->setObject ( kIOPropertySCSIINQUIRYDeviceIdType, numString );
numString->release ( );
numString = NULL;
}
numString = OSNumber::withNumber ( ( inqData[inqDataCount + 1] >> 4 ) & 0x03, 8 );
if ( numString != NULL )
{
idDictionary->setObject ( kIOPropertySCSIINQUIRYDeviceIdAssociation, numString );
numString->release ( );
numString = NULL;
}
inqDataCount += 3;
idSize = inqData[inqDataCount];
inqDataCount++;
if ( codeSet == kINQUIRY_Page83_CodeSetASCIIData )
{
OSString * charString = NULL;
char idString[255] = { 0 };
for ( UInt8 i = 0; i < idSize; i++ )
{
idString[i] = inqData[inqDataCount + i];
}
charString = OSString::withCString ( idString );
if ( charString != NULL )
{
idDictionary->setObject ( kIOPropertySCSIINQUIRYDeviceIdentifier, charString );
charString->release ( );
charString = NULL;
}
}
else
{
OSData * idData = NULL;
idData = OSData::withBytes ( &inqData[inqDataCount], idSize );
if ( idData != NULL )
{
idDictionary->setObject ( kIOPropertySCSIINQUIRYDeviceIdentifier, idData );
idData->release ( );
idData = NULL;
}
}
inqDataCount += idSize;
if ( deviceIDs->ensureCapacity ( deviceIDCount ) == deviceIDCount )
{
deviceIDs->setObject ( idDictionary );
}
idDictionary->release ( );
idDictionary = NULL;
}
setProperty ( kIOPropertySCSIINQUIRYDeviceIdentification, deviceIDs );
ReleaseDeviceIDs:
require_nonzero_quiet ( deviceIDs, ErrorExit );
deviceIDs->release ( );
deviceIDs = NULL;
ErrorExit:
return;
}
#if 0
#pragma mark -
#pragma mark ₯ VTable Padding
#pragma mark -
#endif
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 1 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 2 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 3 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 4 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 5 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 6 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 7 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 8 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 9 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 10 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 11 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 12 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 13 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 14 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 15 );
OSMetaClassDefineReservedUnused ( IOSCSITargetDevice, 16 );