mirror of
https://github.com/ultimatepp/ultimatepp.git
synced 2026-05-15 14:16:07 -06:00
478 lines
10 KiB
C++
478 lines
10 KiB
C++
#include "Core.h"
|
|
|
|
NAMESPACE_UPP
|
|
|
|
#define LTIMING(x) // TIMING(x)
|
|
|
|
int msecs(int from) { return (int)GetTickCount() - from; }
|
|
|
|
#ifdef PLATFORM_WIN32
|
|
#include <mmsystem.h>
|
|
#endif
|
|
|
|
#ifdef PLATFORM_WIN32
|
|
static void sLogFile(char *fn, const char *app = ".log")
|
|
{
|
|
#ifdef PLATFORM_WINCE
|
|
wchar wfn[256];
|
|
::GetModuleFileName(NULL, wfn, 512);
|
|
strcpy(fn, FromSysChrSet(wfn));
|
|
#else
|
|
::GetModuleFileName(NULL, fn, 512);
|
|
#endif
|
|
char *e = fn + strlen(fn), *s = e;
|
|
while(s > fn && *--s != '\\' && *s != '.')
|
|
;
|
|
strcpy(*s == '.' ? s : e, app);
|
|
}
|
|
#endif
|
|
|
|
#ifdef PLATFORM_POSIX
|
|
const char *procexepath_();
|
|
extern char Argv0__[_MAX_PATH + 1];
|
|
|
|
static void sLogFile(char *fn, const char *app = ".log")
|
|
{
|
|
char *path = fn;
|
|
const char *ehome = getenv("HOME");
|
|
strcpy(fn, ehome ? ehome : "/root");
|
|
if(!*fn || (fn += strlen(fn))[-1] != '/')
|
|
*fn++ = '/';
|
|
*fn = '\0';
|
|
strcat(path, ".upp/");
|
|
const char *exe = procexepath_();
|
|
if(!exe) {
|
|
exe = Argv0__;
|
|
}
|
|
const char *q = strrchr(exe, '/');
|
|
if(q)
|
|
exe = q + 1;
|
|
if(!exe)
|
|
exe = "upp";
|
|
strcat(path, exe);
|
|
mkdir(path, 0755);
|
|
strcat(path, "/");
|
|
strcat(path, exe);
|
|
strcat(path, app);
|
|
}
|
|
#endif
|
|
|
|
static Stream *__logstream;
|
|
static char __logfilename[512];
|
|
static int __logfilesizelimit = 10000000;
|
|
static bool __logfilenodeleteonstartup = false;
|
|
|
|
void SetVppLogSizeLimit(int limit) { __logfilesizelimit = limit; }
|
|
void SetVppLogNoDeleteOnStartup() { __logfilenodeleteonstartup = true; }
|
|
|
|
static void sOpenVppLog(LogStream *s)
|
|
{
|
|
if(!*__logfilename)
|
|
sLogFile(__logfilename);
|
|
s->Create(__logfilename, __logfilenodeleteonstartup);
|
|
s->SetLimit(__logfilesizelimit);
|
|
}
|
|
|
|
LogStream& StdLogStream()
|
|
{
|
|
static LogStream *s;
|
|
ReadMemoryBarrier();
|
|
if(!s) {
|
|
static StaticCriticalSection lock;
|
|
lock.Enter();
|
|
if(!s) {
|
|
static byte lb[sizeof(LogStream)];
|
|
LogStream *strm = new(lb) LogStream;
|
|
sOpenVppLog(strm);
|
|
WriteMemoryBarrier();
|
|
s = strm;
|
|
}
|
|
lock.Leave();
|
|
}
|
|
return *s;
|
|
}
|
|
|
|
void StdLogSetup(dword options)
|
|
{
|
|
StdLogStream().SetOptions(options);
|
|
}
|
|
|
|
Stream& StdLog()
|
|
{
|
|
return StdLogStream();
|
|
}
|
|
|
|
void SetVppLog(Stream& log) {
|
|
__logstream = &log;
|
|
}
|
|
|
|
Stream& VppLog() {
|
|
if(!__logstream) __logstream = &StdLog();
|
|
return *__logstream;
|
|
}
|
|
|
|
void SetVppLogName(const String& file) {
|
|
strcpy(__logfilename, file);
|
|
sOpenVppLog(&StdLogStream());
|
|
}
|
|
|
|
void sTime(char *h, const char *ext)
|
|
{
|
|
Time t = GetSysTime();
|
|
char th[200];
|
|
sprintf(th, ".%d-%02d-%02d-%02d-%02d-%02d", t.year, t.month, t.day, t.hour, t.minute, t.second);
|
|
strcat(th, ext);
|
|
sLogFile(h, th);
|
|
}
|
|
|
|
bool snobuglog;
|
|
|
|
void DeactivateBugLog()
|
|
{
|
|
snobuglog = true;
|
|
}
|
|
|
|
Stream& BugLog()
|
|
{
|
|
if(snobuglog)
|
|
return NilStream();
|
|
static LogStream *s;
|
|
if(!s) {
|
|
INTERLOCKED
|
|
if(!s) {
|
|
static byte lb[sizeof(LogStream)];
|
|
s = new(lb) LogStream;
|
|
char h[200];
|
|
sTime(h, ".buglog");
|
|
s->Create(h, false);
|
|
}
|
|
}
|
|
return *s;
|
|
}
|
|
|
|
LogStream& UsrLogStream()
|
|
{
|
|
static LogStream *s;
|
|
if(!s) {
|
|
INTERLOCKED
|
|
if(!s) {
|
|
static byte lb[sizeof(LogStream)];
|
|
s = new(lb) LogStream;
|
|
char h[200];
|
|
sTime(h, ".usrlog");
|
|
s->Create(h, false);
|
|
}
|
|
}
|
|
return *s;
|
|
}
|
|
|
|
bool susrlog;
|
|
bool susrlogpersistent;
|
|
|
|
void ActivateUsrLog()
|
|
{
|
|
UsrLogStream();
|
|
susrlog = true;
|
|
}
|
|
|
|
void ActivatePersistentUsrLog()
|
|
{
|
|
ActivateUsrLog();
|
|
susrlogpersistent = true;
|
|
}
|
|
|
|
Stream& UsrLog()
|
|
{
|
|
return susrlog ? (Stream&)UsrLogStream() : NilStream();
|
|
}
|
|
|
|
Stream& UsrLog(const char *line)
|
|
{
|
|
if(!susrlog)
|
|
return NilStream();
|
|
return UsrLogStream() << line << "\r\n";
|
|
}
|
|
|
|
Stream& UsrLogT(int indent, const char *line)
|
|
{
|
|
if(!susrlog)
|
|
return NilStream();
|
|
Time tm = GetSysTime();
|
|
char h[256];
|
|
sprintf(h, "%02d:%02d:%02d ", tm.hour, tm.minute, tm.second);
|
|
Stream& s = UsrLogStream() << h;
|
|
while(indent--)
|
|
s << " ";
|
|
s << line << "\r\n";
|
|
return s;
|
|
}
|
|
|
|
Stream& UsrLogT(const char *line)
|
|
{
|
|
return UsrLogT(0, line);
|
|
}
|
|
|
|
bool IsUsrLog()
|
|
{
|
|
return susrlog;
|
|
}
|
|
|
|
void DeleteUsrLog()
|
|
{
|
|
if(susrlogpersistent) {
|
|
if(susrlog)
|
|
UsrLogStream() << "log is persistent";
|
|
}
|
|
else {
|
|
if(!UsrLogStream().Delete())
|
|
RLOG("Unable to delete UsrLog, " << GetLastErrorMessage());
|
|
susrlog = false;
|
|
}
|
|
}
|
|
|
|
void __LOGF__(const char *fmt, ...) {
|
|
char buffer[1024];
|
|
va_list argptr;
|
|
va_start(argptr, fmt);
|
|
vsprintf(buffer, fmt, argptr);
|
|
va_end(argptr);
|
|
VppLog().Put(buffer);
|
|
}
|
|
|
|
String GetTypeName(const char *s)
|
|
{
|
|
static const char _struct[] = "struct ", _class[] = "class ";
|
|
enum { LEN_S = sizeof(_struct) - 1, LEN_C = sizeof(_class) - 1 };
|
|
int len = (dword)strlen(s);
|
|
if(len > LEN_C && !memcmp(s, _class, LEN_C))
|
|
s += LEN_C;
|
|
else if(len > LEN_S && !memcmp(s, _struct, LEN_S))
|
|
s += LEN_S;
|
|
return s;
|
|
}
|
|
|
|
bool TimingInspector::active = true;
|
|
|
|
#if defined(PLATFORM_POSIX) || defined(PLATFORM_WINCE)
|
|
inline int tmGetTime() {
|
|
return GetTickCount();
|
|
}
|
|
#else
|
|
inline int tmGetTime() {
|
|
return timeGetTime();
|
|
}
|
|
#endif
|
|
|
|
static TimingInspector& s_zero()
|
|
{
|
|
static TimingInspector *s_zero = NULL;
|
|
static bool init = false;
|
|
if(!init) {
|
|
init = true;
|
|
static TimingInspector s_zero_;
|
|
s_zero = &s_zero_;
|
|
int w = GetTickCount();
|
|
while(GetTickCount() - w < 200)
|
|
TimingInspector::Routine __(*s_zero);
|
|
}
|
|
return *s_zero;
|
|
}
|
|
|
|
TimingInspector::TimingInspector(const char *_name) {
|
|
s_zero(); //!! atexit
|
|
name = _name ? _name : "";
|
|
start_time = 0;
|
|
all_count = call_count = max_nesting = nesting_depth = min_time = max_time = total_time = 0;
|
|
static bool init;
|
|
if(!init) {
|
|
#if defined(PLATFORM_WIN32) && !defined(PLATFORM_WINCE)
|
|
timeBeginPeriod(1);
|
|
#endif
|
|
init = true;
|
|
}
|
|
}
|
|
|
|
TimingInspector::~TimingInspector() {
|
|
Mutex::Lock __(mutex);
|
|
if(this == &s_zero()) return;
|
|
StdLog() << Dump() << "\r\n";
|
|
}
|
|
|
|
void TimingInspector::Start() {
|
|
Mutex::Lock __(mutex);
|
|
if(!active) return;
|
|
if(!nesting_depth++)
|
|
start_time = tmGetTime();
|
|
if(nesting_depth > max_nesting)
|
|
max_nesting = nesting_depth;
|
|
}
|
|
|
|
void TimingInspector::End() {
|
|
Mutex::Lock __(mutex);
|
|
if(!active) return;
|
|
all_count++;
|
|
if(!--nesting_depth) {
|
|
dword time = tmGetTime() - start_time;
|
|
total_time += time;
|
|
if(call_count++ == 0)
|
|
min_time = max_time = time;
|
|
else {
|
|
if(time < min_time)
|
|
min_time = time;
|
|
if(time > max_time)
|
|
max_time = time;
|
|
}
|
|
}
|
|
}
|
|
|
|
String TimingInspector::Dump() {
|
|
Mutex::Lock __(mutex);
|
|
String s = Sprintf("TIMING %-15s: ", name);
|
|
if(call_count == 0)
|
|
return s + "No active hit";
|
|
double tm = max(0.0, double(total_time) / call_count / 1000 -
|
|
double(s_zero().total_time) / s_zero().call_count / 1000);
|
|
return s
|
|
+ timeFormat(tm * call_count)
|
|
+ " - " + timeFormat(tm)
|
|
+ " (" + timeFormat((double)total_time / 1000) + " / "
|
|
+ Sprintf("%d )", call_count)
|
|
+ ", min: " + timeFormat((double)min_time / 1000)
|
|
+ ", max: " + timeFormat((double)max_time / 1000)
|
|
+ Sprintf(", nesting: %d - %d", max_nesting, all_count);
|
|
}
|
|
|
|
HitCountInspector::~HitCountInspector()
|
|
{
|
|
Mutex::Lock __(mutex);
|
|
RLOG("HITCOUNT " << name << ": hit count = " << hitcount);
|
|
}
|
|
|
|
void HexDump(Stream& s, const void *ptr, int size, int maxsize) {
|
|
char h[256];
|
|
sprintf(h, "Memory at %p, size 0x%X = %d\n", ptr, size, size);
|
|
s.Put(h);
|
|
#ifdef PLATFORM_WIN32
|
|
if(IsBadReadPtr(ptr, size)) {
|
|
s.Put(" <MEMORY ACCESS VIOLATION>\n");
|
|
return;
|
|
}
|
|
#endif
|
|
int a, b;
|
|
byte *q = (byte *)ptr;
|
|
a = 0;
|
|
if(size > maxsize) size = maxsize;
|
|
while(a < size) {
|
|
#ifdef CPU_64
|
|
uint64 aa = a + (uint64)ptr;
|
|
sprintf(h, "%+6d 0x%08X%08X ", a, (int)(aa >> 32), (int)aa);
|
|
s.Put(h);
|
|
#else
|
|
sprintf(h, "%+6d 0x%08X ", a, a + dword(ptr));
|
|
s.Put(h);
|
|
#endif
|
|
for(b = 0; b < 16; b++)
|
|
if(a + b < size) {
|
|
sprintf(h, "%02X ", q[a + b]);
|
|
s.Put(h);
|
|
}
|
|
else
|
|
s.Put(" ");
|
|
s.Put(" ");
|
|
for(b = 0; b < 16; b++)
|
|
if(a + b < size)
|
|
s.Put(q[a + b] < ' ' ? '.' : q[a + b]);
|
|
else
|
|
s.Put(' ');
|
|
a += 16;
|
|
s << '\n';
|
|
}
|
|
}
|
|
|
|
#if defined(PLATFORM_WIN32) && !defined(PLATFORM_WINCE)
|
|
|
|
template <class T>
|
|
void Put(HANDLE file, T& data) {
|
|
dword dummy;
|
|
WriteFile(file, &data, sizeof(data), &dummy, NULL);
|
|
}
|
|
|
|
static LPTOP_LEVEL_EXCEPTION_FILTER sPrev;
|
|
static dword sESP;
|
|
static char appInfo[20];
|
|
static char crashfilename[MAX_PATH];
|
|
|
|
void SetCrashFileName(const char *cfile)
|
|
{
|
|
ASSERT(strlen(cfile) < MAX_PATH);
|
|
strcpy(crashfilename, cfile);
|
|
}
|
|
|
|
LONG __stdcall sDumpHandler(LPEXCEPTION_POINTERS ep) {
|
|
SYSTEMTIME st;
|
|
GetLocalTime(&st);
|
|
if(!*crashfilename) {
|
|
::GetModuleFileName(NULL, crashfilename, 512);
|
|
wsprintf(crashfilename + strlen(crashfilename), ".%d-%02d-%02d-%02d-%02d-%02d%s.crash",
|
|
st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, appInfo);
|
|
}
|
|
HANDLE file = CreateFile(crashfilename, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
|
|
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN, NULL);
|
|
dword v = 1;
|
|
Put(file, v);
|
|
EXCEPTION_RECORD *er = ep->ExceptionRecord;
|
|
Put(file, er->ExceptionCode);
|
|
Put(file, er->ExceptionAddress);
|
|
Put(file, er->NumberParameters);
|
|
for(int i = 0; i < (int)er->NumberParameters; i++)
|
|
Put(file, er->ExceptionInformation[i]);
|
|
|
|
#ifdef CPU_AMD64
|
|
qword esp = ep->ContextRecord->Rsp;
|
|
#else
|
|
dword esp = ep->ContextRecord->Esp;
|
|
#endif
|
|
|
|
WriteFile(file, (void *) esp, (dword)(sESP - esp), &v, NULL);
|
|
/* dword base = ep->ContextRecord->Ebp;
|
|
for(;;) {
|
|
dword new_base = *(dword *)base;
|
|
dword caller = *(dword *)(base + 4);
|
|
Put(file, caller);
|
|
if(new_base < base)
|
|
break;
|
|
base = new_base;
|
|
}*/
|
|
CloseHandle(file);
|
|
char h[200];
|
|
sprintf(h, "CRASH: %d-%02d-%02d %02d:%02d:%02d code: 0x%X address: 0x%p",
|
|
st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond,
|
|
er->ExceptionCode, er->ExceptionAddress);
|
|
UsrLogT("============ CRASH ================================================");
|
|
UsrLogT(h);
|
|
BugLog() << h << "\r\n";
|
|
return sPrev ? (*sPrev)(ep) : 0 /*EXCEPTION_CONTINUE_SEARCH*/;
|
|
}
|
|
|
|
void InstallCrashDump(const char *info) {
|
|
memset(appInfo, 0, sizeof(appInfo));
|
|
if(info && *info) {
|
|
appInfo[0] = '.';
|
|
strncpy(appInfo + 1, info, sizeof(appInfo) - 1);
|
|
appInfo[sizeof(appInfo) - 1] = '\0';
|
|
}
|
|
if(!sPrev) {
|
|
sPrev = SetUnhandledExceptionFilter(sDumpHandler);
|
|
#ifndef CPU_AMD64
|
|
#ifdef COMPILER_MSC
|
|
__asm mov sESP, esp
|
|
#else
|
|
//todo
|
|
#endif
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
END_UPP_NAMESPACE
|