// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSSYMINIT, "ossSymInitialize" )
UINT32 ossSymInitialize( HANDLE phProcess,
CHAR * pUserSearchPath,
BOOLEAN bInvadeProcess )
{
PD_TRACE_ENTRY ( SDB_OSSSYMINIT );
static BOOLEAN s_bSymInitialized = false ;
UINT32 rc = ERROR_SUCCESS ;
WaitForSingleObject( ossGetSysMutexHandle( _SymInitialize ), INFINITE ) ;
if ( ! s_bSymInitialized )
{
if ( SymInitialize( phProcess, pUserSearchPath, bInvadeProcess ) )
{
s_bSymInitialized = TRUE ;
}
else
{
rc = GetLastError() ;
}
}
ReleaseMutex ( ossGetSysMutexHandle( _SymInitialize ) ) ;
if ( ERROR_SUCCESS != rc )
{
SetLastError( rc ) ;
}
PD_TRACE1 ( SDB_OSSSYMINIT, PD_PACK_UINT(rc) );
PD_TRACE_EXIT ( SDB_OSSSYMINIT );
return rc ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_CATALOGCB_ALLOCGROUPID, "sdbCatalogueCB::AllocGroupID" )
UINT32 sdbCatalogueCB::AllocGroupID ()
{
INT32 i = 0;
UINT32 id = 0 ;
PD_TRACE_ENTRY ( SDB_CATALOGCB_ALLOCGROUPID ) ;
ossScopedLock _lock(&_GrpIDMutex, EXCLUSIVE) ;
while ( i++ < CAT_DATA_NODE_MAX_NUM )
{
if ( _iCurGrpId < CAT_DATA_GROUP_ID_BEGIN )
{
_iCurGrpId = CAT_DATA_GROUP_ID_BEGIN;
}
GRP_ID_MAP::const_iterator it = _grpIdMap.find( _iCurGrpId );
if ( it != _grpIdMap.end() )
{
_iCurGrpId++;
continue;
}
it = _deactiveGrpIdMap.find( _iCurGrpId );
if ( it != _deactiveGrpIdMap.end() )
{
_iCurGrpId++;
continue;
}
id = _iCurGrpId ;
goto done ;
}
id = CAT_INVALID_GROUPID ;
done :
PD_TRACE1 ( SDB_CATALOGCB_ALLOCGROUPID, PD_PACK_UINT ( id ) ) ;
PD_TRACE_EXIT ( SDB_CATALOGCB_ALLOCGROUPID ) ;
return id ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_CATALOGCB_GETAGROUPRAND, "sdbCatalogueCB::getAGroupRand" )
INT32 sdbCatalogueCB::getAGroupRand( INT32 &groupID )
{
INT32 rc = SDB_CAT_NO_NODEGROUP_INFO ;
PD_TRACE_ENTRY ( SDB_CATALOGCB_GETAGROUPRAND ) ;
ossScopedLock _lock( &_GrpIDMutex, EXCLUSIVE ) ;
UINT32 mapSize = _grpIdMap.size();
PD_TRACE1 ( SDB_CATALOGCB_GETAGROUPRAND,
PD_PACK_UINT ( mapSize ) ) ;
if ( mapSize > 0 )
{
UINT32 randNum = ossRand() % mapSize;
UINT32 i = 0;
GRP_ID_MAP::iterator iterMap = _grpIdMap.begin();
for ( ; i < randNum && iterMap!=_grpIdMap.end(); i++ )
{
++iterMap;
}
if ( iterMap != _grpIdMap.end() )
{
groupID = iterMap->first;
rc = SDB_OK ;
}
}
PD_TRACE_EXITRC ( SDB_CATALOGCB_GETAGROUPRAND, rc ) ;
return rc;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_CATALOGCB_INSERTGROUPID, "sdbCatalogueCB::insertGroupID" )
void sdbCatalogueCB::insertGroupID( UINT32 grpID, BOOLEAN isActive )
{
PD_TRACE_ENTRY ( SDB_CATALOGCB_INSERTGROUPID ) ;
PD_TRACE2 ( SDB_CATALOGCB_INSERTGROUPID,
PD_PACK_UINT ( grpID ),
PD_PACK_UINT ( isActive ) ) ;
if ( grpID >= CAT_DATA_GROUP_ID_BEGIN )
{
ossScopedLock _lock(&_GrpIDMutex, EXCLUSIVE) ;
if ( isActive )
{
_grpIdMap.insert( GRP_ID_MAP::value_type(grpID, grpID) );
}
else
{
_deactiveGrpIdMap.insert( GRP_ID_MAP::value_type(grpID, grpID) );
}
_iCurGrpId = _iCurGrpId > grpID ? _iCurGrpId : ++grpID ;
}
PD_TRACE_EXIT ( SDB_CATALOGCB_INSERTGROUPID ) ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_CATALOGCB_REMOVEGROUPID, "sdbCatalogueCB::removeGroupID" )
void sdbCatalogueCB::removeGroupID( UINT32 grpID )
{
PD_TRACE_ENTRY ( SDB_CATALOGCB_REMOVEGROUPID ) ;
PD_TRACE1 ( SDB_CATALOGCB_REMOVEGROUPID,
PD_PACK_UINT ( grpID ) ) ;
if ( grpID >= CAT_DATA_GROUP_ID_BEGIN )
{
ossScopedLock _lock(&_GrpIDMutex, EXCLUSIVE) ;
_grpIdMap.erase(grpID);
_deactiveGrpIdMap.erase( grpID );
}
PD_TRACE_EXIT ( SDB_CATALOGCB_REMOVEGROUPID ) ;
return ;
}
INT32 _ossModuleHandle::init ()
{
INT32 rc = SDB_OK ;
CHAR strPath [ 2*OSS_MAX_PATHSIZE + 1 ] = {0} ;
CHAR strModule [ OSS_MAX_PATHSIZE + 1 ] = {0} ;
OSS_MHANDLE handle = 0 ;
CHAR *p = NULL ;
#if defined (_WINDOWS)
UINT32 errorMode ;
#endif
PD_TRACE_ENTRY ( SDB_OSSMODULEHANDLE_INIT ) ;
if ( _moduleName[0] == '\0' )
{
PD_LOG ( PDERROR, "Module name can't be empty" ) ;
rc = SDB_INVALIDARG ;
goto error ;
}
PD_TRACE3 ( SDB_OSSMODULEHANDLE_INIT, PD_PACK_STRING(_moduleName),
PD_PACK_STRING(_libPath), PD_PACK_UINT(_flags) ) ;
ossStrncpy ( strModule, _moduleName, sizeof(strModule) ) ;
p = ossStrchr ( strModule, '(' ) ;
if ( p )
{
*p = '\0' ;
}
rc = patchModuleName( strModule, _moduleName, sizeof(_moduleName) );
PD_RC_CHECK ( rc, PDERROR, "Failed to patch module name, rc = %d", rc ) ;
if ( _libPath[0] )
{
INT32 pathLen = 0 ;
rc = ossAccess ( _libPath,
#if defined (_LINUX)
F_OK
#elif defined (_WINDOWS)
0
#endif
) ;
PD_RC_CHECK ( rc, PDERROR, "Failed to access path %s, rc = %d",
_libPath, rc ) ;
ossStrncat ( strPath, _libPath, sizeof(strPath) ) ;
pathLen = ossStrlen ( strPath ) ;
if ( strPath[pathLen-1] != OSS_FILE_SEP_CHAR )
{
if ( pathLen >= OSS_MAX_PATHSIZE )
{
PD_LOG ( PDERROR, "library path is too long: %s",
_libPath ) ;
rc = SDB_INVALIDARG ;
goto error ;
}
strPath[pathLen-1] = OSS_FILE_SEP_CHAR ;
strPath[pathLen] = '\0' ;
}
}
if ( ossStrlen ( strPath ) + ossStrlen ( _moduleName ) >= sizeof(strPath) )
{
PD_LOG ( PDERROR, "path + module name is too long: %s:%s",
strPath, _moduleName ) ;
rc = SDB_INVALIDARG ;
goto error ;
}
ossStrncat ( strPath, _moduleName, OSS_MAX_PATHSIZE ) ;
#if defined (_LINUX)
handle = dlopen ( strPath, _flags | RTLD_NOW ) ;
if ( !handle )
{
PD_LOG ( PDERROR, "Failed to load module %s, error = %s",
strPath, dlerror() ) ;
rc = SDB_SYS ;
goto error ;
}
_isInitialized = TRUE ;
_moduleHandle = handle ;
dlerror() ;
#elif defined (_WINDOWS)
errorMode = SetErrorMode ( SEM_NOOPENFILEERRORBOX |
SEM_FAILCRITICALERRORS ) ;
_moduleHandle = LoadLibrary ( (LPCTSTR)strPath ) ;
SetErrorMode ( errorMode ) ;
if ( NULL == _moduleHandle )
{
rc = ossGetLastError () ;
PD_LOG ( PDERROR, "Failed to load module %s, error = %d",
_moduleName, rc ) ;
OSSMODULEHANDLE_ERR(rc) ;
goto error ;
}
#endif
done :
PD_TRACE_EXITRC ( SDB_OSSMODULEHANDLE_INIT, rc ) ;
return rc ;
error :
_isInitialized = FALSE ;
_moduleHandle = OSS_MINVALIDHANDLE ;
goto done ;
}
