xNO_INLINE static void_t onInfo(int_t a_signal, siginfo_t *a_info, void_t *a_context) { xTEST_EQ(a_signal, a_info->si_signo); xUNUSED((ucontext_t *)a_context); xTRACE_FUNC; Trace() << Signal::infoDescription(*a_info) << "\n"; Trace() << Signal::decription(0) << "\n"; FileLog log(FileLog::lsDefaultMb); log.setFilePath(xT("crash.log")); std::ctstring_t msg = Format::str( xT("Crash info:\n\n") xT("Signal:\n{}\n\n") xT("StackTrace:\n{}"), Signal::infoDescription(*a_info), StackTrace().toString()); log.write(xT("%s\n"), msg.c_str()); std::tcout << StackTrace().toString() << std::endl; Application::exit(EXIT_FAILURE); }
void *operator new(size_t bytes) { if (gInstrumented) { if (!gExpectAllocations) { // Only flag the first unexpected allocation, so we don't end up // with thousands of failures. gInstrumented = false; std::cout << "***************************************" << std::endl; std::cout << "Unexpected memory allocation. Call stack:" << std::endl; std::cout << StackTrace().toString() << std::endl; std::cout << "***************************************" << std::endl; RCF_CHECK(0 && "Unexpected memory allocation."); } ++gnAllocations; } return malloc(bytes); }
static void_t onSignals(int a_signal) { Trace() << xFUNCTION << "\nStack trace:\n " << StackTrace().toString(); switch (a_signal) { case SIGABRT: Trace() << "Caught SIGABRT: usually caused by an abort() or assert()"; break; case SIGFPE: Trace() << "Caught SIGFPE: arithmetic exception, such as divide by zero"; break; case SIGILL: Trace() << "Caught SIGILL: illegal instruction"; break; case SIGINT: Trace() << "Caught SIGINT: interactive attention signal, probably a ctrl+c"; break; case SIGSEGV: Trace() << "Caught SIGSEGV: segfault"; break; case SIGTERM: default: Trace() << "Caught SIGTERM: a termination request was sent to the program"; break; } ::_exit(EXIT_FAILURE); }
void psLinearMovement::SetPosition (const csVector3& pos, float yrot, const iSector* sector) { if (!sector) { StackTrace("Setting position without sector"); } // Debug4(LOG_CELPERSIST,0,"DEBUG: psLinearMovement::SetPosition %s current transform: %s scale %f \n", mesh->QueryObject()->GetName(), mesh->GetMovable()->GetTransform().Description().GetData(),scale); // Position and Sector mesh->GetMovable ()->SetPosition ((iSector *)sector,pos); // at first loading scale may not be yet set if (scale>0) { // Rotation and scale csMatrix3 rotMatrix = (csMatrix3) csYRotMatrix3 (yrot); csMatrix3 scaleMatrix = csMatrix3 (1/scale,0,0, 0,1/scale,0, 0,0,1/scale); mesh->GetMovable ()->GetTransform ().SetO2T (scaleMatrix*rotMatrix); } else { // Rotation only csMatrix3 rotMatrix = (csMatrix3) csYRotMatrix3 (yrot); mesh->GetMovable ()->GetTransform ().SetO2T (rotMatrix); } mesh->GetMovable ()->UpdateMove (); }
void i_lexit ( TExitLevel exit_level, int linenum, const char *filename, const char *functionname) { if (exit_level==df) exit_level= DEFAULT_EXIT_LEVEL; if (exit_level!=success && exit_level!=th) std::cerr<<ioscc::green<<"------"<<std::endl <<ioscc::green<<"the program is terminated"<<std::endl <<ioscc::green<<" at "<<ioscc::blue<<filename<<ioscc::green<<":" <<ioscc::blue<<linenum<<ioscc::green<<":"<<std::endl <<ioscc::green<<" within the function: "<<ioscc::blue<<functionname<<std::endl; switch (exit_level) { case success : std::exit(EXIT_SUCCESS); case qfail : std::exit(EXIT_FAILURE); case btfail : std::cerr<<"backtrace:"<<std::endl; StackTrace(); std::exit(EXIT_FAILURE); case abort : std::abort(); case th : throw TException(linenum,filename,functionname); default : std::cerr<<"improper usage of lexit(exit_level); invalid exit_level: " <<static_cast<int>(exit_level)<<std::endl; std::exit(EXIT_FAILURE); } }
//--------------------------------------------------------------------------- static TStrings * __fastcall StackInfoListToStrings( TJclStackInfoList * StackInfoList) { std::unique_ptr<TStrings> StackTrace(new TStringList()); StackInfoList->AddToStrings(StackTrace.get(), true, false, true, false); // get rid of __fastcall declarations that are included in .map StackTrace->Text = ReplaceStr(StackTrace->Text, L"__fastcall ", L""); return StackTrace.release(); }
void CrashHandler(int sig) { /* Reinstall default handler to prevent race conditions */ signal(sig, SIG_DFL); /* Print the stack trace */ StackTrace(); /* And exit because we may have corrupted the internal * memory allocation lists. Use abort() if we want to * generate a core dump. */ _exit(EXIT_FAILURE); }
void HttpConnection::handshakeComplete(Socket *) { TRACE("handshakeComplete() socketState=%s", socket_->state_str()); if (socket_->state() == Socket::Operational) watchInput(worker_->server_.maxReadIdle()); else { TRACE("handshakeComplete(): handshake failed\n%s", StackTrace().c_str()); close(); } }
/* ============ idInterpreter::Error Aborts the currently executing function ============ */ void idInterpreter::Error( char *fmt, ... ) const { va_list argptr; char text[ 1024 ]; va_start( argptr, fmt ); vsprintf( text, fmt, argptr ); va_end( argptr ); StackTrace(); if( ( instructionPointer >= 0 ) && ( instructionPointer < gameLocal.program.NumStatements() ) ) { statement_t &line = gameLocal.program.GetStatement( instructionPointer ); common->Error( "%s(%d): Thread '%s': %s\n", gameLocal.program.GetFilename( line.file ), line.linenumber, thread->GetThreadName(), text ); } else { common->Error( "Thread '%s': %s\n", thread->GetThreadName(), text ); } }
int crtAllocationHook( int allocType, void *userData, size_t size, int blockType, long requestNumber, const unsigned char *filename, // Can't be UNICODE int lineNumber) { // Check for unexpected memory allocations. if ( gInstrumented && (allocType == _HOOK_ALLOC || allocType == _HOOK_REALLOC) && !gExpectAllocations) { // Only flag the first unexpected allocation, so we don't end up // with thousands of failures. gInstrumented = false; // If we do want to track further allocations, uncomment this. //gInstrumented = true; std::cout << "***************************************" << std::endl; std::cout << "Unexpected memory allocation. Call stack:" << std::endl; std::cout << StackTrace().toString() << std::endl; std::cout << "***************************************" << std::endl; RCF_CHECK(0 && "Unexpected memory allocation."); } if (allocType == _HOOK_ALLOC || allocType == _HOOK_REALLOC) { ++gnAllocations; } return pfnOldCrtAllocHook( allocType, userData, size, blockType, requestNumber, filename, lineNumber); }
/** Closes this HttpConnection, possibly deleting this object (or propagating delayed delete). */ void HttpConnection::close() { TRACE(1, "close()"); TRACE(2, "Stack Trace:%s\n", StackTrace().c_str()); if (isClosed()) // XXX should we treat this as a bug? return; flags_ |= IsClosed; if (status_ == SendingReplyDone) { // usercode has issued a request->finish() but it didn't come to finalize it yet. request_->finalize(); } status_ = Undefined; unref(); // <-- this refers to ref() in start() }
//--------------------------------------------------------------------------- static void __fastcall DoExceptNotify(TObject * ExceptObj, void * ExceptAddr, bool OSException, void * BaseOfStack) { if (ExceptObj != NULL) { Exception * E = dynamic_cast<Exception *>(ExceptObj); if ((E != NULL) && IsInternalException(E)) // optimization { DoExceptionStackTrace(ExceptObj, ExceptAddr, OSException, BaseOfStack); TJclStackInfoList * StackInfoList = JclLastExceptStackList(); if (ALWAYS_TRUE(StackInfoList != NULL)) { std::unique_ptr<TStrings> StackTrace(StackInfoListToStrings(StackInfoList)); DWORD ThreadID = GetCurrentThreadId(); TGuard Guard(StackTraceCriticalSection.get()); TStackTraceMap::iterator Iterator = StackTraceMap.find(ThreadID); if (Iterator != StackTraceMap.end()) { Iterator->second->Add(L""); Iterator->second->AddStrings(StackTrace.get()); } else { StackTraceMap.insert(std::make_pair(ThreadID, StackTrace.release())); } // this chains so that JclLastExceptStackList() returns NULL the next time // for the current thread delete StackInfoList; } } } }
PyObject * wipe_StackTrace(PyObject * self, PyObject * args) { ULONG ulFramePointer; ULONG ulStackPointer; ULONG ulProgramCounter; ULONG ulFrames; EXTSTACKTRACE taFrames[1024]; PyObject * ptFrameList = NULL; PyObject * ptFrame = NULL; ULONG i; if (!PyArg_ParseTuple(args, "kkk", &ulFramePointer, &ulStackPointer, &ulProgramCounter)) { return NULL; } ptFrameList = Py_BuildValue("[]"); ulFrames = StackTrace(ulFramePointer, ulStackPointer, ulProgramCounter, taFrames, 1024); for (i = 0; i < ulFrames; i++) { ptFrame = Py_BuildValue("(kkkN)", taFrames[i].FramePointer, taFrames[i].ProgramCounter, taFrames[i].ReturnAddress, Py_BuildValue("(kkkk)", taFrames[i].Args[0], taFrames[i].Args[1], taFrames[i].Args[2], taFrames[i].Args[3])); PyList_Append(ptFrameList, ptFrame); // PyList_Append adds a ref Py_DECREF(ptFrame); } return ptFrameList; }
void psLinearMovement::SetFullPosition (const csVector3& pos, float yrot, const iSector* sector) { // Position csVector3 newpos; if (!sector) { StackTrace("Setting position without sector"); } newpos = pos; mesh->GetMovable ()->SetPosition ((iSector *)sector, newpos); // Rotation csMatrix3 matrix = (csMatrix3) csYRotMatrix3 (yrot); // @@@ Not correct if anchor is transformed!!! mesh->GetMovable ()->GetTransform ().SetO2T (matrix); // Sector mesh->GetMovable ()->UpdateMove (); }
VOID DoStackTrace( ULONG FramePointer, ULONG StackPointer, ULONG InstructionPointer, ULONG NumFrames, ULONG TraceType ) { LPSTACKFRAME StackFrames; DWORD FrameCount; DWORD i; DWORD displacement; CHAR symbuf[512]; USHORT StdCallArgs; if (NumFrames == 0) { NumFrames = 20; } StackFrames = malloc( sizeof(STACKFRAME) * NumFrames ); if (!StackFrames) { dprintf( "could not allocate memory for stack trace\n" ); return; } FrameCount = StackTrace( FramePointer, StackPointer, InstructionPointer, StackFrames, NumFrames, 0 ); if (FrameCount == 0) { dprintf( "could not fetch any stack frames\n" ); return; } #if defined(TARGET_i386) dprintf( "ChildEBP RetAddr" ); if (TraceType) { dprintf(" Args to Child"); } dprintf("\n"); #else if (TraceType==1) { dprintf("\nCallee-SP Arguments to Callee Call Site\n\n"); } else { dprintf("\nCallee-SP Return-RA Call Site\n\n"); } #endif for (i=0; i<FrameCount; i++) { GetSymbolStdCall( StackFrames[i].AddrPC.Offset, symbuf, &displacement, &StdCallArgs ); #if defined(TARGET_i386) dprintf( "%08x %08x ", StackFrames[i].AddrFrame.Offset, StackFrames[i].AddrReturn.Offset ); if (TraceType > 0) { dprintf( "%08x %08x %08x ", StackFrames[i].Params[0], StackFrames[i].Params[1], StackFrames[i].Params[2] ); } if (*symbuf) { dprintf( "%s", symbuf ); if (displacement) { dprintf("+"); } } if (displacement) { dprintf("0x%x", displacement); } if (TraceType == 2 && !StackFrames[i].FuncTableEntry) { if (StdCallArgs != 0xffff) { dprintf(" [Stdcall: %d]", StdCallArgs); } } else if (TraceType == 2 && StackFrames[i].FuncTableEntry) { PFPO_DATA pFpoData = (PFPO_DATA)StackFrames[i].FuncTableEntry; switch (pFpoData->cbFrame) { case FRAME_FPO: if (pFpoData->fHasSEH) { dprintf("(FPO: [SEH])"); } else { dprintf(" (FPO:"); if (pFpoData->fUseBP) { dprintf(" [EBP 0x%08x]", SAVE_EBP(StackFrames[i])); } dprintf(" [%d,%d,%d])", pFpoData->cdwParams, pFpoData->cdwLocals, pFpoData->cbRegs); } break; case FRAME_NONFPO: dprintf("(FPO: [Non-Fpo]" ); break; #ifdef KERNEL case FRAME_TRAP: dprintf(" (FPO: [%d,%d] TrapFrame%s @ %08lx)", pFpoData->cdwParams, pFpoData->cdwLocals, TRAP_EDITED(StackFrames[i]) ? "" : "-EDITED", SAVE_TRAP(StackFrames[i]) ); break; case FRAME_TSS: dprintf(" (FPO: TaskGate %lx:0)", TRAP_TSS(StackFrames[i])); break; #endif default: dprintf("(UKNOWN FPO TYPE)"); break; } } dprintf( "\n" ); #else if (TraceType == 1) { dprintf( " %08lx : ", StackFrames[i].AddrFrame.Offset ); } else { dprintf( " %08lx %08lx : ", StackFrames[i].AddrFrame.Offset, StackFrames[i].AddrReturn.Offset ); } if (TraceType == 1) { dprintf( "%08lx %08lx %08lx %08lx ", StackFrames[i].Params[0], StackFrames[i].Params[1], StackFrames[i].Params[2], StackFrames[i].Params[3] ); } dprintf( "%s", symbuf ); if (displacement) { dprintf("+0x%lx ", displacement); } dprintf( "\n" ); #endif } free( StackFrames ); return; }
LONG __stdcall DCUnhandledExceptionFilter( LPEXCEPTION_POINTERS e ) { #ifdef __DEBUG MessageBox(NULL, _T("If you would like to debug DCUnhandledExceptionFilter - attach to this process now"), _T(APPNAME), MB_OK); #endif Lock l(cs); if(recursion++ > 30) exit(-1); #ifndef _DEBUG #if _MSC_VER == 1200 __pfnDliFailureHook = FailHook; #elif _MSC_VER == 1300 || _MSC_VER == 1310 || _MSC_VER == 1400 __pfnDliFailureHook2 = FailHook; #else #error Unknown Compiler version #endif // The release version loads the dll and pdb:s here... InitSymInfo(Text::toT(Util::getDataPath()).c_str()); #endif TCHAR pdbPath[MAX_PATH]; GetModuleFileName(NULL, pdbPath, sizeof(pdbPath)); TCHAR* dotPtr = _tcschr(pdbPath, '.'); if (dotPtr != NULL) { _tcscpy(dotPtr, _T(".pdb")); } if (GetFileAttributes(pdbPath) == INVALID_FILE_ATTRIBUTES) { // No debug symbols, we're not interested... ::MessageBox(WinUtil::mainWnd, _T(APPNAME) _T(" has crashed and you don't have .PDB file installed. Hence, I can't find out why it crashed, so don't report this as a bug unless you find a solution..."), _T(APPNAME) _T(" has crashed"), MB_OK); #ifndef _DEBUG exit(1); #else return EXCEPTION_CONTINUE_SEARCH; #endif } File f(Util::getConfigPath() + "exceptioninfo.txt", File::WRITE, File::OPEN | File::CREATE); f.setEndPos(0); char buf[DEBUG_BUFSIZE]; sprintf(buf, "Code: %x (%s)\r\n" "Version: %d (%s)\r\n", e->ExceptionRecord->ExceptionCode, getExceptionName(e->ExceptionRecord->ExceptionCode), BUILDID, Util::getCompileDate().c_str()); tstring exceptioninfo = Text::toT(buf); f.write(buf, strlen(buf)); OSVERSIONINFOEX ver; WinUtil::getVersionInfo(ver); const char *productType; if (ver.wProductType == VER_NT_DOMAIN_CONTROLLER) { productType = "domain controller"; } else if (ver.wProductType == VER_NT_SERVER) { productType = "server"; } else if (ver.wProductType == VER_NT_WORKSTATION) { productType = "workstation"; } else { productType = "unknown product type"; } sprintf(buf, "OS Version: %d.%d build %d service pack %d %s\r\n", (DWORD)ver.dwMajorVersion, (DWORD)ver.dwMinorVersion, (DWORD)ver.dwBuildNumber, (DWORD)ver.wServicePackMajor, productType); exceptioninfo += Text::toT(buf); f.write(buf, strlen(buf)); time_t now; time(&now); strftime(buf, DEBUG_BUFSIZE, "Time: %Y-%m-%d %H:%M:%S\r\n", localtime(&now)); exceptioninfo += Text::toT(buf); f.write(buf, strlen(buf)); #if 0 WinUtil::exceptioninfo += LIT(_T("TTH: ")); WinUtil::exceptioninfo += Text::toT(tth); WinUtil::exceptioninfo += LIT(_T("\r\n\r\n")); #endif f.write(LIT("\r\n")); exceptioninfo += _T("\r\n"); // !SMT! sprintf(buf, "exception code %08X at eip=%08X, nested: %08X\r\n" "eax=%08X ebx=%08X ecx=%08X edx=%08X\r\n" "esi=%08X edi=%08X ebp=%08X esp=%08X\r\n", e->ExceptionRecord->ExceptionCode, e->ExceptionRecord->ExceptionAddress, e->ExceptionRecord->ExceptionRecord, e->ContextRecord->Eax, e->ContextRecord->Ebx, e->ContextRecord->Ecx, e->ContextRecord->Edx, e->ContextRecord->Esi, e->ContextRecord->Edi, e->ContextRecord->Ebp, e->ContextRecord->Esp); exceptioninfo += Text::toT(buf); f.write(buf, strlen(buf)); const tstring trace = StackTrace(GetCurrentThread(), e->ContextRecord); f.write(LIT("\r\n")); f.write(Text::fromT(trace)); f.close(); #if 0 memcpy(&CurrExceptionRecord, e->ExceptionRecord, sizeof(EXCEPTION_RECORD)); memcpy(&CurrContext, e->ContextRecord, sizeof(CONTEXT)); #endif exceptioninfo += _T("\r\n"); exceptioninfo += trace; Sounds::PlaySound(SettingsManager::SOUND_EXC); if (WinUtil::mainWnd != NULL) { NOTIFYICONDATA m_nid = {0}; m_nid.cbSize = sizeof(NOTIFYICONDATA); m_nid.hWnd = WinUtil::mainWnd; m_nid.uID = 0; m_nid.uFlags = NIF_INFO; m_nid.uTimeout = 5000; m_nid.dwInfoFlags = NIIF_WARNING; _tcsncpy(m_nid.szInfo, _T("exceptioninfo.txt was generated"), 255); _tcsncpy(m_nid.szInfoTitle, _T(APPNAME) _T(" has crashed"), 63); Shell_NotifyIcon(NIM_MODIFY, &m_nid); } CExceptionDlg dlg(exceptioninfo); int iLastExceptionDlgResult = dlg.DoModal(WinUtil::mainWnd); if (iLastExceptionDlgResult == IDCANCEL) { ExitProcess(1); } #ifndef _DEBUG UninitSymInfo(); return EXCEPTION_CONTINUE_EXECUTION; #else return EXCEPTION_CONTINUE_SEARCH; #endif }
/* Callback for the exception handler * Parameters: * e - The exception information * Returns: * EXCEPTION_EXECUTE_HANDLER to terminate the process * Side Effects: * unrealircd.PID.core is created * If not running in service mode, a message box is displayed, * else output is written to service.log */ LONG __stdcall ExceptionFilter(EXCEPTION_POINTERS *e) { MEMORYSTATUS memStats; char file[512], text[1024], minidumpf[512]; FILE *fd; time_t timet = time(NULL); #ifndef NOMINIDUMP HANDLE hDump; HMODULE hDll = NULL; #endif sprintf(file, "unrealircd.%d.core", getpid()); fd = fopen(file, "w"); GlobalMemoryStatus(&memStats); fprintf(fd, "Generated at %s\n%s (%d.%d.%d)\n%s[%s%s%s] (%s)\n" "-----------------\nMemory Information:\n" "\tPhysical: (Available:%ldMB/Total:%ldMB)\n" "\tVirtual: (Available:%ldMB/Total:%ldMB)\n" "-----------------\nException:\n\t%s\n-----------------\n" "Backup Buffer:\n\t%s\n-----------------\nRegisters:\n" "%s-----------------\nStack Trace:\n%s", asctime(gmtime(&timet)), OSName, VerInfo.dwMajorVersion, VerInfo.dwMinorVersion, VerInfo.dwBuildNumber, IRCDTOTALVERSION, serveropts, extraflags ? extraflags : "", tainted ? "3" : "", buildid, memStats.dwAvailPhys/1048576, memStats.dwTotalPhys/1048576, memStats.dwAvailVirtual/1048576, memStats.dwTotalVirtual/1048576, GetException(e->ExceptionRecord->ExceptionCode), backupbuf, GetRegisters(e->ContextRecord), StackTrace(e)); sprintf(text, "UnrealIRCd has encountered a fatal error. Debugging information has been dumped to %s.", file); fclose(fd); #ifndef NOMINIDUMP hDll = LoadLibrary("DBGHELP.DLL"); if (hDll) { MINIDUMPWRITEDUMP pDump = (MINIDUMPWRITEDUMP)GetProcAddress(hDll, "MiniDumpWriteDump"); if (pDump) { MINIDUMP_EXCEPTION_INFORMATION ExInfo; sprintf(minidumpf, "unrealircd.%d.mdmp", getpid()); hDump = CreateFile(minidumpf, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hDump != INVALID_HANDLE_VALUE) { ExInfo.ThreadId = GetCurrentThreadId(); ExInfo.ExceptionPointers = e; ExInfo.ClientPointers = 0; if (pDump(GetCurrentProcess(), GetCurrentProcessId(), hDump, MiniDumpNormal, &ExInfo, NULL, NULL)) { sprintf(text, "UnrealIRCd has encountered a fatal error. Debugging information has been dumped to %s and %s.", file, minidumpf); } CloseHandle(hDump); } sprintf(minidumpf, "unrealircd.%d.full.mdmp", getpid()); hDump = CreateFile(minidumpf, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hDump != INVALID_HANDLE_VALUE) { ExInfo.ThreadId = GetCurrentThreadId(); ExInfo.ExceptionPointers = e; ExInfo.ClientPointers = 0; CloseHandle(hDump); } } } #endif if (!IsService) { MessageBox(NULL, text, "Fatal Error", MB_OK); StartCrashReporter(); } else { FILE *fd = fopen("service.log", "a"); if (fd) { fprintf(fd, "UnrealIRCd has encountered a fatal error. Debugging information " "has been dumped to unrealircd.%d.core, please file a bug and upload " "this file to http://bugs.unrealircd.org/.", getpid()); fclose(fd); } } CleanUp(); return EXCEPTION_EXECUTE_HANDLER; }
Exception::Exception(const std::string& err, const std::string &file, int line) throw() { _trace.push_back(StackTrace(err, file, line)); }
// Do the actual move int psLinearMovement::MoveV (float delta) { if (velBody < SMALL_EPSILON && velWorld < SMALL_EPSILON && (!colldet || colldet->IsOnGround ())) return PS_MOVE_DONTMOVE; // didn't move anywhere int ret = PS_MOVE_SUCCEED; iMovable* movable = mesh->GetMovable (); if (movable->GetSectors ()->GetCount () <= 0) return PS_MOVE_DONTMOVE; // didn't move anywhere csMatrix3 mat; // To test collision detection we use absolute position and transformation // (this is relevant if we are anchored). Later on we will correct that. csReversibleTransform fulltransf = movable->GetFullTransform (); mat = fulltransf.GetT2O (); csVector3 worldVel (fulltransf.This2OtherRelative (velBody) + velWorld); csVector3 oldpos (fulltransf.GetOrigin ()); csVector3 newpos (worldVel*delta + oldpos); csVector3 bufpos = newpos; float dist = (newpos - oldpos).Norm (); // @@@ Magodra: In some cases the newpos seams to be invalid. Not sure about // the reason, but the FollowSegment function will not work later // in this function. So check for that condidtion, give warning, // and halt the movement. if (CS::IsNaN(newpos.x) || CS::IsNaN(newpos.y) || CS::IsNaN(newpos.z)) { printf("From old position %s ",toString(oldpos,movable->GetSectors()->Get(0)).GetDataSafe()); StackTrace("LinearMovement to a NAN position."); return PS_MOVE_DONTMOVE; // didn't move anywhere } // Check for collisions and adjust position if (colldet) { if (!colldet->AdjustForCollisions (oldpos, newpos, worldVel, delta, movable)) { ret = PS_MOVE_FAIL; newpos = oldpos; } else { // check if we collided, did move less than 9/10 of the distance if ((newpos - bufpos).Norm () > dist/10.0) { ret = PS_MOVE_PARTIAL; } } } csVector3 origNewpos = newpos; bool mirror = false; // Update position to account for portals iSector* new_sector = movable->GetSectors ()->Get (0); iSector* old_sector = new_sector; // @@@ Jorrit: had to do this add! // We need to measure slightly above the position of the actor or else // we won't really cross a portal. float height5 = (bottomSize.y + topSize.y) / 10.0f; newpos.y += height5; csMatrix3 id; csOrthoTransform transform_oldpos (id, oldpos + csVector3 (0.0f, height5, 0.0f)); new_sector = new_sector->FollowSegment (transform_oldpos, newpos, mirror, PS_LINMOVE_FOLLOW_ONLY_PORTALS); newpos.y -= height5; if (new_sector != old_sector) movable->SetSector (new_sector); portalDisplaced += newpos - origNewpos; if(!IsOnGround ()) { //printf("Applying gravity: velY: %g.\n", velWorld.y); // gravity! move down! velWorld.y -= gravity * delta; /* * Terminal velocity * ((120 miles/hour / 3600 second/hour) * 5280 feet/mile) * / 3.28 feet/meter = 53.65 m/s */ // The body velocity is figured in here too. if (velWorld.y < 0) { if (fulltransf.This2OtherRelative (velBody).y + velWorld.y < -(ABS_MAX_FREEFALL_VELOCITY)) velWorld.y = -(ABS_MAX_FREEFALL_VELOCITY) - fulltransf.This2OtherRelative (velBody).y; if (velWorld.y > 0) { // printf("Reset other y %g\n", fulltransf.This2OtherRelative (velBody).y); velWorld.y = 0; } } } else { if(velWorld.y < 0) { velWorld.y = 0; } if (hugGround) HugGround (newpos, new_sector); } // Move to the new position. If we have an anchor we have to convert // the new position from absolute to relative. movable->GetTransform ().SetOrigin (newpos); movable->GetTransform ().SetT2O( movable->GetTransform ().GetT2O () * transform_oldpos.GetT2O ()); if (colldet) { // Part 4: Add us to all nearby sectors. mesh->PlaceMesh (); } movable->UpdateMove (); return ret; }
static void_t onTerminate() { Trace() << xFUNCTION << "\nStack trace:\n" << StackTrace().toString(); // std::abort(); // forces abnormal termination }
extern "C" void __stdcall StackTraceVB(int numSkip, int depth, TraceCallbackFunction pFunction, CONTEXT *pContext, void *data) { StackTrace(numSkip, depth, pFunction, pContext, data); }
void TraceProcessState(const TargetInfo& ti) { std::printf("ghd: Attempting to run stack trace\n"); // Initialize atos late to reduce startup time and make sure our child // has actually run exec() std::auto_ptr<SymbolManager> symbol = std::auto_ptr<SymbolManager>(new SymbolManager(ti.m_pid)); // List of threads thread_act_port_array_t thread_list; mach_msg_type_number_t thread_count; if (task_threads(ti.m_task_port, &thread_list, &thread_count) != KERN_SUCCESS) assert(!"Can't obtain thread list"); for (uint thread_idx=0; thread_idx<thread_count; thread_idx++) { // Query thread scheduling etc. information thread_basic_info tbi; mach_msg_type_number_t thread_info_count = THREAD_BASIC_INFO_COUNT; if (thread_info(thread_list[thread_idx], THREAD_BASIC_INFO, (thread_info_t) &tbi, &thread_info_count) != KERN_SUCCESS) { assert(!"thread_info() failed"); } // Only show threads which were running, remove to show all threads if (tbi.flags & TH_FLAGS_SWAPPED) continue; std::printf("ghd: ---------------\n"); std::printf("ghd: Thread %i of %i\n", thread_idx + 1, thread_count); std::printf("ghd: ---------------\n"); std::printf("ghd: Status - "); switch (tbi.run_state) { case TH_STATE_RUNNING: std::printf("Running"); break; case TH_STATE_STOPPED: std::printf("Stopped"); break; case TH_STATE_WAITING: std::printf("Waiting"); break; case TH_STATE_UNINTERRUPTIBLE: std::printf("Uninterruptible"); break; case TH_STATE_HALTED: std::printf("Halted"); break; default: std::printf("(Unknown)"); break; } if (tbi.flags & TH_FLAGS_SWAPPED) std::printf(" (swapped out)"); if (tbi.flags & TH_FLAGS_IDLE) std::printf(" (idle)"); std::printf("\n"); // Query thread exception information x86_exception_state32_t x86es32; mach_msg_type_number_t exception_state_count32 = x86_EXCEPTION_STATE32_COUNT; if (thread_get_state(thread_list[thread_idx], x86_EXCEPTION_STATE32, (thread_state_t) &x86es32, &exception_state_count32) != KERN_SUCCESS) { assert(!"thread_get_state() failed"); } const char *trap_err_str = ""; switch (x86es32.__trapno) { case EXC_I386_DIVERR : trap_err_str = " (EXC_I386_DIVERR - divide by 0 error)"; break; case EXC_I386_SGLSTP : trap_err_str = " (EXC_I386_SGLSTP - single step)"; break; case EXC_I386_NMIFLT : trap_err_str = " (EXC_I386_NMIFLT - NMI)"; break; case EXC_I386_BPTFLT : trap_err_str = " (EXC_I386_BPTFLT - breakpoint fault)"; break; case EXC_I386_INTOFLT : trap_err_str = " (EXC_I386_INTOFLT - INTO overflow fault)"; break; case EXC_I386_BOUNDFLT : trap_err_str = " (EXC_I386_BOUNDFLT - BOUND instruction fault)"; break; case EXC_I386_INVOPFLT : trap_err_str = " (EXC_I386_INVOPFLT - invalid opcode fault)"; break; case EXC_I386_NOEXTFLT : trap_err_str = " (EXC_I386_NOEXTFLT - extension not available fault)"; break; case EXC_I386_DBLFLT : trap_err_str = " (EXC_I386_DBLFLT - double fault)"; break; case EXC_I386_EXTOVRFLT: trap_err_str = " (EXC_I386_EXTOVRFLT - extension overrun fault)"; break; case EXC_I386_INVTSSFLT: trap_err_str = " (EXC_I386_INVTSSFLT - invalid TSS fault)"; break; case EXC_I386_SEGNPFLT : trap_err_str = " (EXC_I386_SEGNPFLT - segment not present fault)"; break; case EXC_I386_STKFLT : trap_err_str = " (EXC_I386_STKFLT - stack fault)"; break; case EXC_I386_GPFLT : trap_err_str = " (EXC_I386_GPFLT - general protection fault)"; break; case EXC_I386_PGFLT : trap_err_str = " (EXC_I386_PGFLT - page fault)"; break; case EXC_I386_EXTERRFLT: trap_err_str = " (EXC_I386_EXTERRFLT - extension error fault)"; break; case EXC_I386_ALIGNFLT : trap_err_str = " (EXC_I386_ALIGNFLT - alignment fault)"; break; case EXC_I386_ENDPERR : trap_err_str = " (EXC_I386_ENDPERR - emulated extension error flt)"; break; case EXC_I386_ENOEXTFLT: trap_err_str = " (EXC_I386_ENOEXTFLT - emulated ext not present)"; break; } std::printf("ghd: ExceptionState - trapno: %u%s, err: %u, faultvaddr: 0x%x\n", x86es32.__trapno, trap_err_str, x86es32.__err, x86es32.__faultvaddr); // Query thread registers x86_thread_state32_t x86ts32; mach_msg_type_number_t thread_state_count32 = x86_THREAD_STATE32_COUNT; if (thread_get_state(thread_list[thread_idx], x86_THREAD_STATE32, (thread_state_t) &x86ts32, &thread_state_count32) != KERN_SUCCESS) { assert(!"thread_get_state() failed"); } std::printf("ghd: Registers\n" \ "ghd: eax: %u, ebx: %u, ecx: %u, edx: %u, edi: %u, esi: %u, ebp: 0x%x\n" \ "ghd: esp: 0x%x, ss: %u, eflags: %u, eip: 0x%x <%s>, cs: %u, ds: %u\n" \ "ghd: es: %u, fs: %u, gs: %u\n", x86ts32.__eax, x86ts32.__ebx, x86ts32.__ecx, x86ts32.__edx, x86ts32.__edi, x86ts32.__esi, x86ts32.__ebp, x86ts32.__esp, x86ts32.__ss, x86ts32.__eflags, x86ts32.__eip, symbol->SymbolIDToName(symbol->AddressToSymbolID(x86ts32.__eip)), x86ts32.__cs, x86ts32.__ds, x86ts32.__es, x86ts32.__fs, x86ts32.__gs); // Traverse stack StackTrace(ti, symbol.get(), x86ts32.__ebp, x86ts32.__eip); } // Cleanup std::printf("ghd: Stack trace done, exiting\n"); DeallocateThreadList(thread_list, thread_count); }