static unsigned long _ossSSLThreadIdCallback(void)
{
unsigned long ret;
ret = (unsigned long)ossGetCurrentThreadID();
return ret;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSST, "ossStackTrace" )
void ossStackTrace( OSS_HANDPARMS, const CHAR *dumpDir )
{
PD_TRACE_ENTRY ( SDB_OSSST );
ossPrimitiveFileOp trapFile ;
CHAR fileName [ OSS_MAX_PATHSIZE ] = {0} ;
UINT32 strLen = 0 ;
oss_edu_data * pEduData = ossGetThreadEDUData() ;
sigset_t savemask, tmpmask ;
SINT32 prevNestedHandlerLevel = 0 ;
OSS_SIGFUNCPTR pPrevNestedHandler = NULL ;
pthread_sigmask( SIG_SETMASK, NULL, &savemask ) ;
sigemptyset( &tmpmask ) ;
sigaddset( &tmpmask, SIGSEGV ) ;
sigaddset( &tmpmask, SIGILL ) ;
sigaddset( &tmpmask, SIGTRAP ) ;
sigaddset( &tmpmask, SIGBUS ) ;
if ( NULL != pEduData )
{
OSS_GET_NESTED_HANDLER_LEVEL( pEduData, prevNestedHandlerLevel ) ;
pPrevNestedHandler = pEduData->ossEDUNestedSignalHandler ;
pEduData->ossEDUNestedSignalHandler =
(OSS_SIGFUNCPTR)ossNestedTrapHandler ;
OSS_CLEAR_NESTED_HANDLER_LEVEL( pEduData ) ;
if ( 0 == ossSetJump( pEduData->ossNestedSignalHanderJmpBuf, 1 ) )
{
pthread_sigmask( SIG_UNBLOCK, &tmpmask, NULL ) ;
}
else
{
trapFile.Close() ;
goto error ;
}
ossSnprintf ( fileName, OSS_MAX_PATHSIZE, "%d.%d.trap",
ossGetCurrentProcessID(),
ossGetCurrentThreadID() ) ;
if ( ossStrlen ( dumpDir ) + ossStrlen ( OSS_PRIMITIVE_FILE_SEP ) +
ossStrlen ( fileName ) > OSS_MAX_PATHSIZE )
{
PD_LOG ( PDERROR, "path + file name is too long" ) ;
goto error ;
}
ossMemset( fileName, 0, sizeof( fileName ) ) ;
strLen += ossSnprintf( fileName, sizeof( fileName ), "%s%s",
dumpDir, OSS_PRIMITIVE_FILE_SEP ) ;
ossSnprintf( fileName + strLen, sizeof(fileName) - strLen,
"%d.%d.trap",
ossGetCurrentProcessID(),
ossGetCurrentThreadID() ) ;
ossOneTimeOnly() ;
trapFile.Open( fileName ) ;
if ( trapFile.isValid() )
{
trapFile.seekToEnd () ;
ossDumpStackTrace( OSS_HANDARGS, &trapFile ) ;
}
trapFile.Close() ;
}
done :
if ( NULL != pEduData )
{
pEduData->ossEDUNestedSignalHandler = pPrevNestedHandler ;
OSS_SET_NESTED_HANDLER_LEVEL( pEduData, prevNestedHandlerLevel ) ;
}
pthread_sigmask( SIG_SETMASK, &savemask, NULL ) ;
PD_TRACE_EXIT ( SDB_OSSST );
return ;
error :
goto done ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSSTKTRA, "ossStackTrace" )
void ossStackTrace( LPEXCEPTION_POINTERS lpEP, const CHAR * dumpDir )
{
PD_TRACE_ENTRY ( SDB_OSSSTKTRA );
SYMBOL_INFO * pSymbol = NULL ;
HANDLE hProcess ;
void * stack[ OSS_MAX_BACKTRACE_FRAMES_SUPPORTED + 1 ] = { 0 } ;
CHAR pName[ OSS_FUNC_NAME_LEN_MAX + 1 ] ;
UINT32 frames = 0 ;
SYSTEM_INFO sysInfo = { 0 } ;
OSVERSIONINFOEX OSVerInfo={ 0 } ;
ossPrimitiveFileOp trapFile ;
CHAR fileName[ OSS_MAX_PATHSIZE + 1 ] = { 0 } ;
UINT32 StrLen = 0 ;
ossSnprintf ( fileName, OSS_MAX_PATHSIZE, "%d.%d.trap",
ossGetCurrentProcessID(),
ossGetCurrentThreadID() ) ;
if ( OSS_MAX_PATHSIZE <
ossStrlen ( dumpDir ) + ossStrlen ( OSS_PRIMITIVE_FILE_SEP ) +
ossStrlen ( fileName ) )
{
pdLog ( PDERROR, __FUNC__, __FILE__, __LINE__,
"path + file name is too long" ) ;
goto error ;
}
ossMemset( fileName, 0, sizeof( fileName ) ) ;
StrLen += ossSnprintf( fileName, sizeof( fileName ), "%s%s",
dumpDir, OSS_PRIMITIVE_FILE_SEP ) ;
ossSnprintf( fileName + StrLen, sizeof(fileName) - StrLen,
"%d.%d.trap",
ossGetCurrentProcessID(),
ossGetCurrentThreadID() ) ;
trapFile.Open( fileName ) ;
if ( trapFile.isValid() )
{
trapFile.seekToEnd () ;
trapFile.Write(" -------- System Information --------\n" ) ;
ossDumpSystemTime ( &trapFile ) ;
ossDumpDatabaseInfo ( &trapFile ) ;
GetSystemInfo( &sysInfo ) ;
switch( sysInfo.wProcessorArchitecture )
{
case PROCESSOR_ARCHITECTURE_INTEL:
trapFile.Write( "Processor : Intel x86\n" ) ;
break ;
case PROCESSOR_ARCHITECTURE_IA64:
trapFile.Write( "Processor : Intel IA64\n" ) ;
break ;
case PROCESSOR_ARCHITECTURE_AMD64:
trapFile.Write( "Processor : AMD 64\n") ;
break ;
default:
trapFile.Write( "Unknown processor architecture ") ;
}
trapFile.fWrite( " Number of processors: %u Page size: %u\n"
" Min application address: %lx"
" Max application address: %lx\n"
" Active processor mask: %u\n",
sysInfo.dwNumberOfProcessors,
sysInfo.dwPageSize,
sysInfo.lpMinimumApplicationAddress,
sysInfo.lpMaximumApplicationAddress,
sysInfo.dwActiveProcessorMask ) ;
OSVerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
GetVersionEx ( (OSVERSIONINFO*) &OSVerInfo ) ;
if ( OSVerInfo.dwMajorVersion == 6 )
{
if ( OSVerInfo.dwMinorVersion == 0 )
{
if ( OSVerInfo.wProductType == VER_NT_WORKSTATION )
{
trapFile.Write( "Windows Vista " ) ;
}
else
{
trapFile.Write( "Windows Server 2008 " ) ;
}
}
if ( OSVerInfo.dwMinorVersion == 1 )
{
if ( OSVerInfo.wProductType == VER_NT_WORKSTATION )
{
trapFile.Write( "Windows 7 " ) ;
}
else
{
trapFile.Write( "Windows Server 2008 " ) ;
}
}
}
if ( OSVerInfo.dwMajorVersion == 5 && OSVerInfo.dwMinorVersion == 2 )
{
if ( OSVerInfo.wProductType == VER_NT_WORKSTATION )
{
trapFile.Write( "Windows XP " ) ;
}
else
{
trapFile.Write( "Windows Server 2003 " ) ;
}
}
if ( OSVerInfo.dwMajorVersion == 5 && OSVerInfo.dwMinorVersion == 1 )
{
trapFile.Write("Windows XP ") ;
}
if ( OSVerInfo.dwMajorVersion == 5 && OSVerInfo.dwMinorVersion == 0 )
{
trapFile.Write("Windows 2000 ") ;
}
trapFile.fWrite( "%s ( %d.%d) Build:%d\n",
OSVerInfo.szCSDVersion,
OSVerInfo.dwMajorVersion,
OSVerInfo.dwMinorVersion,
OSVerInfo.dwBuildNumber ) ;
hProcess = GetCurrentProcess() ;
pSymbol = ( SYMBOL_INFO * )SDB_OSS_MALLOC(
sizeof( SYMBOL_INFO ) +
OSS_FUNC_NAME_LEN_MAX * sizeof( char ) ) ;
if ( NULL != pSymbol )
{
ossMemset( pSymbol, 0,
sizeof( SYMBOL_INFO ) +
OSS_FUNC_NAME_LEN_MAX * sizeof(char) ) ;
pSymbol->MaxNameLen = OSS_FUNC_NAME_LEN_MAX ;
pSymbol->SizeOfStruct = sizeof( SYMBOL_INFO ) ;
ossSymInitialize( hProcess, NULL, TRUE ) ;
if ( NULL != lpEP )
{
trapFile.Write( "-------- Registers --------\n" ) ;
#ifndef _WIN64
trapFile.fWrite( SEGREG,
lpEP->ContextRecord->SegGs,
lpEP->ContextRecord->SegFs,
lpEP->ContextRecord->SegEs,
lpEP->ContextRecord->SegDs ) ;
trapFile.fWrite( INTREG,
(void*)lpEP->ContextRecord->Edi,
(void*)lpEP->ContextRecord->Esi,
(void*)lpEP->ContextRecord->Eax,
(void*)lpEP->ContextRecord->Ebx,
(void*)lpEP->ContextRecord->Ecx,
(void*)lpEP->ContextRecord->Edx ) ;
trapFile.fWrite( CTXREG,
(void*)lpEP->ContextRecord->Ebp,
(void*)lpEP->ContextRecord->Eip,
(void*)lpEP->ContextRecord->Esp,
(void*)lpEP->ContextRecord->EFlags,
lpEP->ContextRecord->SegCs,
lpEP->ContextRecord->SegSs ) ;
#elif defined(_M_AMD64)
trapFile.fWrite( SEGREG,
lpEP->ContextRecord->SegGs,
lpEP->ContextRecord->SegFs,
lpEP->ContextRecord->SegEs,
lpEP->ContextRecord->SegDs ) ;
trapFile.fWrite( INTREG,
(void*)lpEP->ContextRecord->Rdi,
(void*)lpEP->ContextRecord->Rsi,
(void*)lpEP->ContextRecord->Rax,
(void*)lpEP->ContextRecord->Rbx,
(void*)lpEP->ContextRecord->Rcx,
(void*)lpEP->ContextRecord->Rdx,
(void*)lpEP->ContextRecord->R8,
(void*)lpEP->ContextRecord->R9,
(void*)lpEP->ContextRecord->R10,
(void*)lpEP->ContextRecord->R11,
(void*)lpEP->ContextRecord->R12,
(void*)lpEP->ContextRecord->R13,
(void*)lpEP->ContextRecord->R14,
(void*)lpEP->ContextRecord->R15 ) ;
trapFile.fWrite( CTXREG,
(void*)lpEP->ContextRecord->Rbp,
(void*)lpEP->ContextRecord->Rip,
(void*)lpEP->ContextRecord->Rsp,
(void*)lpEP->ContextRecord->EFlags,
lpEP->ContextRecord->SegCs,
lpEP->ContextRecord->SegSs ) ;
#endif
trapFile.fWrite( "-------- Point of failure --------\n" ) ;
ossMemset( pName, 0, sizeof( pName ) ) ;
ossGetSymbolNameFromAddress( hProcess,
(UINT64)lpEP->ExceptionRecord->ExceptionAddress,
pSymbol, pName, sizeof( pName ) ) ;
trapFile.fWrite( "%s\n", pName ) ;
} // if NULL != lpEP
trapFile.fWrite( "\n-------- Stack frames --------\n" ) ;
#ifndef _WIN64
if ( NULL != lpEP )
{
frames = ossWalkStackEx( lpEP,
0,
OSS_MAX_BACKTRACE_FRAMES_SUPPORTED,
stack ) ;
}
else
{
#endif
frames = ossWalkStack( 0,
OSS_MAX_BACKTRACE_FRAMES_SUPPORTED,
stack ) ;
#ifndef _WIN64
}
#endif
for ( UINT32 i = 0; i < frames; i++ )
{
ossMemset( pName, 0, sizeof( pName ) ) ;
ossGetSymbolNameFromAddress(
hProcess, (UINT64)stack[i], pSymbol, pName, sizeof( pName ) ) ;
trapFile.fWrite( "%3i: %s\n", i, pName ) ;
}
SDB_OSS_FREE( pSymbol ) ;
} // if NULL != pSymbol
}
error :
trapFile.Close() ;
PD_TRACE_EXIT ( SDB_OSSSTKTRA );
return ;
}
pmdEDUCB* pmdEDUMgr::getEDU()
{
return getEDU(ossGetCurrentThreadID());
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_PMDEDUUSERTRAPHNDL, "pmdEDUUserTrapHandler" )
void pmdEDUUserTrapHandler( OSS_HANDPARMS )
{
#if defined( SDB_ENGINE )
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB_PMDEDUUSERTRAPHNDL );
oss_edu_data * pEduData = NULL ;
const CHAR *dumpPath = ossGetTrapExceptionPath () ;
if ( !dumpPath )
{
goto done ;
}
pEduData = ossGetThreadEDUData() ;
if ( NULL == pEduData )
{
goto done ;
}
if ( OSS_AM_I_INSIDE_SIGNAL_HANDLER( pEduData ) )
{
goto done ;
}
OSS_ENTER_SIGNAL_HANDLER( pEduData ) ;
if ( signum == OSS_STACK_DUMP_SIGNAL )
{
PD_LOG ( PDEVENT, "Signal %d is received, "
"prepare to dump stack for all threads", signum ) ;
std::set<pthread_t>::iterator it ;
std::set<pthread_t> tidList ;
pmdGetKRCB()->getEDUMgr()->getEDUThreadID ( tidList ) ;
for ( it = tidList.begin(); it != tidList.end(); ++it )
{
if ( 0 == (*it) )
{
continue ;
}
rc = ossPThreadKill ( (*it), OSS_STACK_DUMP_SIGNAL_INTERNAL ) ;
if ( rc )
{
PD_LOG ( PDWARNING, "Failed to send signal %d to thread %llu, "
"errno = %d", OSS_STACK_DUMP_SIGNAL_INTERNAL,
(*it), ossGetLastError() ) ;
}
}
ossMemTrace ( dumpPath ) ;
}
else if ( signum == OSS_STACK_DUMP_SIGNAL_INTERNAL )
{
PD_LOG ( PDEVENT, "Signal %d is received, "
"prepare to dump stack for %u:%u", signum,
ossGetCurrentProcessID(),
ossGetCurrentThreadID() ) ;
ossStackTrace( OSS_HANDARGS, dumpPath ) ;
}
else
{
PD_LOG ( PDWARNING, "Unexpected signal is received: %d",
signum ) ;
}
OSS_LEAVE_SIGNAL_HANDLER( pEduData ) ;
done :
PD_TRACE1 ( SDB_PMDEDUUSERTRAPHNDL, PD_PACK_INT(rc) );
PD_TRACE_EXIT ( SDB_PMDEDUUSERTRAPHNDL ) ;
#endif // SDB_ENGINE
return ;
}
INT32 _SDB_KRCB::init ()
{
INT32 rc = SDB_OK ;
INT32 index = 0 ;
IControlBlock *pCB = NULL ;
_mainEDU.setName( "Main" ) ;
#if defined (_LINUX )
_mainEDU.setThreadID ( ossPThreadSelf() ) ;
#endif
_mainEDU.setTID ( ossGetCurrentThreadID() ) ;
if ( NULL == pmdGetThreadEDUCB() )
{
pmdDeclareEDUCB( &_mainEDU ) ;
}
// get hostname
rc = ossGetHostName( _hostName, OSS_MAX_HOSTNAME ) ;
PD_RC_CHECK( rc, PDERROR, "Failed to get host name, rc: %d", rc ) ;
_init = TRUE ;
// Init all registered cb
for ( index = 0 ; index < SDB_CB_MAX ; ++index )
{
pCB = _arrayCBs[ index ] ;
if ( !pCB )
{
continue ;
}
if ( SDB_OK != ( rc = pCB->init() ) )
{
PD_LOG( PDERROR, "Init cb[Type: %d, Name: %s] failed, rc: %d",
pCB->cbType(), pCB->cbName(), rc ) ;
goto error ;
}
}
// Activate all registered cb after initilization complete
for ( index = 0 ; index < SDB_CB_MAX ; ++index )
{
pCB = _arrayCBs[ index ] ;
if ( !pCB )
{
continue ;
}
if ( SDB_OK != ( rc = pCB->active() ) )
{
PD_LOG( PDERROR, "Active cb[Type: %d, Name: %s] failed, rc: %d",
pCB->cbType(), pCB->cbName(), rc ) ;
goto error ;
}
}
_isActive = TRUE ;
_curTime.sample() ;
done:
return rc ;
error:
goto done ;
}
