SCSIParallelWorkLoop *
SCSIParallelWorkLoop::Create ( const char * lockGroupName )
{
SCSIParallelWorkLoop * workLoop = NULL;
workLoop = OSTypeAlloc ( SCSIParallelWorkLoop );
require_nonzero ( workLoop, ErrorExit );
require ( workLoop->InitWithLockGroupName ( lockGroupName ), ReleaseWorkLoop );
return workLoop;
ReleaseWorkLoop:
require_nonzero ( workLoop, ErrorExit );
workLoop->release ( );
workLoop = NULL;
ErrorExit:
return workLoop;
}
SCSIParallelTimer *
SCSIParallelTimer::CreateTimerEventSource ( OSObject * owner, Action action )
{
SCSIParallelTimer * timer = NULL;
timer = OSTypeAlloc ( SCSIParallelTimer );
require_nonzero ( timer, ErrorExit );
require ( timer->Init ( owner, action ), FreeTimer );
return timer;
FreeTimer:
require_nonzero ( timer, ErrorExit );
timer->release ( );
timer = NULL;
ErrorExit:
return timer;
}
AppleSCSIPDT03Emulator *
AppleSCSIPDT03Emulator::Create ( void )
{
AppleSCSIPDT03Emulator * logicalUnit = NULL;
bool result = false;
STATUS_LOG ( ( "AppleSCSIPDT03Emulator::Create\n" ) );
logicalUnit = OSTypeAlloc ( AppleSCSIPDT03Emulator );
require_nonzero ( logicalUnit, ErrorExit );
result = logicalUnit->init ( );
require ( result, ReleaseLogicalUnit );
return logicalUnit;
ReleaseLogicalUnit:
logicalUnit->release ( );
ErrorExit:
return NULL;
}
SCSIPathSet *
SCSIPathSet::withCapacity ( unsigned int capacity )
{
SCSIPathSet * set = NULL;
bool result = false;
STATUS_LOG ( ( "+SCSIPathSet::withCapacity\n" ) );
set = OSTypeAlloc ( SCSIPathSet );
require_nonzero ( set, ErrorExit );
result = set->initWithCapacity ( capacity );
require ( result, ReleaseSet );
return set;
ReleaseSet:
require_nonzero_quiet ( set, ErrorExit );
set->release ( );
set = NULL;
ErrorExit:
return set;
}
bool
SCSIPressurePathManager::AddPath ( IOSCSIProtocolServices * interface )
{
bool result = false;
SCSITargetDevicePath * path = NULL;
OSDictionary * dict = NULL;
PortBandwidthGlobals * bw = NULL;
STATUS_LOG ( ( "SCSIPressurePathManager::AddPath\n" ) );
require_nonzero ( interface, ErrorExit );
path = SCSITargetDevicePath::Create ( this, interface );
require_nonzero ( path, ErrorExit );
bw = PortBandwidthGlobals::GetSharedInstance ( );
bw->AddSCSIPort ( path->GetDomainIdentifier ( )->unsigned32BitValue ( ) );
STATUS_LOG ( ( "Registering callback handler\n" ) );
interface->RegisterSCSITaskCompletionRoutine ( &SCSITargetDevicePathManager::PathTaskCallback );
dict = path->GetStatistics ( );
STATUS_LOG ( ( "Got path stats, count = %ld\n", dict->getCount ( ) ) );
fStatistics->setObject ( dict );
STATUS_LOG ( ( "fStatistics array has %ld members\n", fStatistics->getCount ( ) ) );
IOLockLock ( fLock );
result = fPathSet->setObject ( path );
IOLockUnlock ( fLock );
path->release ( );
path = NULL;
ErrorExit:
return result;
}
void
SCSIPressurePathManager::ActivatePath ( IOSCSIProtocolServices * interface )
{
bool result = false;
SCSITargetDevicePath * path = NULL;
STATUS_LOG ( ( "SCSIPressurePathManager::ActivatePath\n" ) );
require_nonzero ( interface, ErrorExit );
IOLockLock ( fLock );
result = fInactivePathSet->member ( interface );
if ( result == true )
{
path = fInactivePathSet->getObjectWithInterface ( interface );
if ( path != NULL )
{
path->retain ( );
path->Activate ( );
fInactivePathSet->removeObject ( interface );
fPathSet->setObject ( path );
path->release ( );
path = NULL;
}
}
else
{
result = fPathSet->member ( interface );
if ( result == false )
{
IOLockUnlock ( fLock );
AddPath ( interface );
goto Exit;
}
}
IOLockUnlock ( fLock );
ErrorExit:
Exit:
return;
}
bool
SCSIParallelWorkLoop::InitWithLockGroupName ( const char * lockGroupName )
{
bool result = false;
fLockGroup = lck_grp_alloc_init ( lockGroupName, LCK_GRP_ATTR_NULL );
require_nonzero ( fLockGroup, ErrorExit );
// Allocate the gateLock before calling the super class. This allows
// us to profile contention on our workloop lock.
gateLock = IORecursiveLockAllocWithLockGroup ( fLockGroup );
result = super::init ( );
ErrorExit:
return result;
}
SCSIPressurePathManager *
SCSIPressurePathManager::Create ( IOSCSITargetDevice * target,
IOSCSIProtocolServices * initialPath )
{
SCSIPressurePathManager * manager = NULL;
bool result = false;
STATUS_LOG ( ( "+SCSIPressurePathManager::Create\n" ) );
manager = OSTypeAlloc ( SCSIPressurePathManager );
require_nonzero ( manager, ErrorExit );
result = manager->InitializePathManagerForTarget ( target, initialPath );
require ( result, ReleasePathManager );
STATUS_LOG ( ( "-SCSIPressurePathManager::Create, manager = %p\n", manager ) );
return manager;
ReleasePathManager:
require_nonzero_quiet ( manager, ErrorExit );
manager->release ( );
manager = NULL;
ErrorExit:
STATUS_LOG ( ( "-SCSIPressurePathManager::Create, manager = NULL\n" ) );
return manager;
}
bool
SCSIPressurePathManager::InitializePathManagerForTarget (
IOSCSITargetDevice * target,
IOSCSIProtocolServices * initialPath )
{
bool result = false;
STATUS_LOG ( ( "SCSIPressurePathManager::InitializePathManagerForTarget\n" ) );
result = super::InitializePathManagerForTarget ( target, initialPath );
require ( result, ErrorExit );
STATUS_LOG ( ( "called super\n" ) );
fLock = IOLockAlloc ( );
require_nonzero ( fLock, ErrorExit );
STATUS_LOG ( ( "allocated lock\n" ) );
fPathSet = SCSIPathSet::withCapacity ( 1 );
require_nonzero ( fPathSet, FreeLock );
fInactivePathSet = SCSIPathSet::withCapacity ( 1 );
require_nonzero ( fInactivePathSet, ReleasePathSet );
STATUS_LOG ( ( "allocated path set, adding intial path\n" ) );
result = AddPath ( initialPath );
require ( result, ReleaseInactivePathSet );
STATUS_LOG ( ( "added intial path, ready to go\n" ) );
STATUS_LOG ( ( "Called AddPath, fStatistics array has %ld members\n", fStatistics->getCount ( ) ) );
target->setProperty ( kIOPropertyPathStatisticsKey, fStatistics );
result = true;
return result;
ReleaseInactivePathSet:
require_nonzero_quiet ( fInactivePathSet, ReleasePathSet );
fInactivePathSet->release ( );
fInactivePathSet = NULL;
ReleasePathSet:
require_nonzero_quiet ( fPathSet, FreeLock );
fPathSet->release ( );
fPathSet = NULL;
FreeLock:
require_nonzero_quiet ( fLock, ErrorExit );
IOLockFree ( fLock );
fLock = NULL;
ErrorExit:
result = false;
return result;
}
