livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge LGPL

Tank_Master 2014-05-16 23:45:13 -07:00
parent 540fe492c9 829f4bdfd2
commit 1f644a8901
43 changed files with 1825 additions and 951 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.hgtags
View File

@ -515,3 +515,4 @@ dcb4981ce255841b6083d8f65444b65d5a733a17 3.7.1-release
b842534cb4d76c9ef87676a62b1d2d19e79c015f 3.7.2-release
962d3f98955bfc7310a7867c8cbc3df075e54aa9 3.7.3-release
d076568ff7883b41c149e6afb421f39c29dbfe2b 3.7.4-release
fc066b82343fca51f9c1b8eda0abc6bee9bb4503 3.7.5-release

4
autobuild.xml
View File

@ -1046,9 +1046,9 @@
<key>archive</key>
<map>
<key>hash</key>
<string>d812a6dfcabe6528198a3191068dac09</string>
<string>a1e519d08c507c12f9d412b2ae8328c8</string>
<key>url</key>
<string>http://automated-builds-secondlife-com.s3.amazonaws.com/hg/repo/3p-google-breakpad/rev/273073/arch/CYGWIN/installer/google_breakpad-0.0.0-rev1099-windows-20130329.tar.bz2</string>
<string>http://automated-builds-secondlife-com.s3.amazonaws.com/hg/repo/3p-google-breakpad/rev/279804/arch/CYGWIN/installer/google_breakpad-0.0.0-rev1099-windows-20130813.tar.bz2</string>
</map>
<key>name</key>
<string>windows</string>

2
indra/cmake/GoogleBreakpad.cmake
View File

@ -16,7 +16,7 @@ else (STANDALONE)
set(BREAKPAD_EXCEPTION_HANDLER_LIBRARIES breakpad_client)
endif (LINUX)
if (WINDOWS)
set(BREAKPAD_EXCEPTION_HANDLER_LIBRARIES exception_handler crash_generation_client common)
set(BREAKPAD_EXCEPTION_HANDLER_LIBRARIES exception_handler crash_generation_client crash_generation_server common)
endif (WINDOWS)
# yes, this does look dumb, no, it's not incorrect
#

11
indra/linux_crash_logger/linux_crash_logger.cpp
View File

@ -26,6 +26,7 @@
#include "linden_common.h"
#include "llcrashloggerlinux.h"
#include "llsdutil.h"
int main(int argc, char **argv)
{
@ -34,6 +35,16 @@ int main(int argc, char **argv)
LLCrashLoggerLinux app;
app.parseCommandOptions(argc, argv);
LLSD options = LLApp::instance()->getOptionData(
LLApp::PRIORITY_COMMAND_LINE);
//LLApp::PRIORITY_RUNTIME_OVERRIDE);
if (!(options.has("pid") && options.has("dumpdir")))
{
llwarns << "Insufficient parameters to crash report." << llendl;
}
if (! app.init())
{
llwarns << "Unable to initialize application." << llendl;

1
indra/linux_crash_logger/llcrashloggerlinux.cpp
View File

@ -150,6 +150,7 @@ bool LLCrashLoggerLinux::mainLoop()
bool LLCrashLoggerLinux::cleanup()
{
commonCleanup();
mKeyMaster.releaseMaster();
return true;
}

286
indra/llcommon/llapp.cpp
View File

@ -60,6 +60,7 @@
#endif
// </FS:ND>
#include "stringize.h"
//
// Signal handling
@ -67,6 +68,8 @@
// Windows uses structured exceptions, so it's handled a bit differently.
//
#if LL_WINDOWS
#include "windows.h"
LONG WINAPI default_windows_exception_handler(struct _EXCEPTION_POINTERS *exception_infop);
BOOL ConsoleCtrlHandler(DWORD fdwCtrlType);
bool windows_post_minidump_callback(const wchar_t* dump_path,
@ -93,7 +96,9 @@ void default_unix_signal_handler(int signum, siginfo_t *info, void *);
// </FS:ND>
bool unix_minidump_callback(const google_breakpad::MinidumpDescriptor& minidump_desc, void* context, bool succeeded);
static bool unix_minidump_callback(const google_breakpad::MinidumpDescriptor& minidump_desc,
void* context,
bool succeeded);
#else
// Called by breakpad exception handler after the minidump has been generated.
bool unix_post_minidump_callback(const char *dump_dir,
@ -131,11 +136,6 @@ BOOL LLApp::sLogInSignal = FALSE;
LLApp::EAppStatus LLApp::sStatus = LLApp::APP_STATUS_STOPPED; // Keeps track of application status
LLAppErrorHandler LLApp::sErrorHandler = NULL;
BOOL LLApp::sErrorThreadRunning = FALSE;
#if !LL_WINDOWS
LLApp::child_map LLApp::sChildMap;
LLAtomicU32* LLApp::sSigChildCount = NULL;
LLAppChildCallback LLApp::sDefaultChildCallback = NULL;
#endif
LLApp::LLApp() : mThreadErrorp(NULL)
@ -150,11 +150,6 @@ void LLApp::commonCtor()
LLCommon::initClass();
#if !LL_WINDOWS
// This must be initialized before the error handler.
sSigChildCount = new LLAtomicU32(0);
#endif
// initialize the options structure. We need to make this an array
// because the structured data will not auto-allocate if we
// reference an invalid location with the [] operator.
@ -171,12 +166,13 @@ void LLApp::commonCtor()
// Set the application to this instance.
sApplication = this;
mExceptionHandler = 0;
// initialize the buffer to write the minidump filename to
// (this is used to avoid allocating memory in the crash handler)
memset(minidump_path, 0, MAX_MINDUMP_PATH_LENGTH);
memset(mMinidumpPath, 0, MAX_MINDUMP_PATH_LENGTH);
mCrashReportPipeStr = L"\\\\.\\pipe\\LLCrashReporterPipe";
}
LLApp::LLApp(LLErrorThread *error_thread) :
@ -188,10 +184,6 @@ LLApp::LLApp(LLErrorThread *error_thread) :
LLApp::~LLApp()
{
#if !LL_WINDOWS
delete sSigChildCount;
sSigChildCount = NULL;
#endif
// reclaim live file memory
std::for_each(mLiveFiles.begin(), mLiveFiles.end(), DeletePointer());
@ -266,6 +258,20 @@ bool LLApp::parseCommandOptions(int argc, char** argv)
}
++ii;
value.assign(argv[ii]);
#if LL_WINDOWS
//Windows changed command line parsing. Deal with it.
S32 slen = value.length() - 1;
S32 start = 0;
S32 end = slen;
if (argv[ii][start]=='"')start++;
if (argv[ii][end]=='"')end--;
if (start!=0 || end!=slen)
{
value = value.substr (start,end);
}
#endif
commands[name] = value;
}
setOptionData(PRIORITY_COMMAND_LINE, commands);
@ -310,6 +316,32 @@ void LLApp::stepFrame()
mRunner.run();
}
#if LL_WINDOWS
//The following code is needed for 32-bit apps on 64-bit windows to keep it from eating
//crashes. It is a lovely undocumented 'feature' in SP1 of Windows 7. An excellent
//in-depth article on the issue may be found here: http://randomascii.wordpress.com/2012/07/05/when-even-crashing-doesn-work/
void EnableCrashingOnCrashes()
{
typedef BOOL (WINAPI *tGetPolicy)(LPDWORD lpFlags);
typedef BOOL (WINAPI *tSetPolicy)(DWORD dwFlags);
const DWORD EXCEPTION_SWALLOWING = 0x1;
HMODULE kernel32 = LoadLibraryA("kernel32.dll");
tGetPolicy pGetPolicy = (tGetPolicy)GetProcAddress(kernel32,
"GetProcessUserModeExceptionPolicy");
tSetPolicy pSetPolicy = (tSetPolicy)GetProcAddress(kernel32,
"SetProcessUserModeExceptionPolicy");
if (pGetPolicy && pSetPolicy)
{
DWORD dwFlags;
if (pGetPolicy(&dwFlags))
{
// Turn off the filter
pSetPolicy(dwFlags & ~EXCEPTION_SWALLOWING);
}
}
}
#endif
//void LLApp::setupErrorHandling()
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-12 (Catznip-2.6.0a) | Added: Catznip-2.4.0a
@ -320,7 +352,10 @@ void LLApp::setupErrorHandling(EMiniDumpType minidump_type)
// occasionally checks to see if the app is in an error state, and sees if it needs to be run.
#if LL_WINDOWS
#if LL_SEND_CRASH_REPORTS
EnableCrashingOnCrashes();
// This sets a callback to handle w32 signals to the console window.
// The viewer shouldn't be affected, sicne its a windowed app.
SetConsoleCtrlHandler( (PHANDLER_ROUTINE) ConsoleCtrlHandler, TRUE);
@ -329,27 +364,61 @@ void LLApp::setupErrorHandling(EMiniDumpType minidump_type)
if(mExceptionHandler == 0)
{
llwarns << "adding breakpad exception handler" << llendl;
// mExceptionHandler = new google_breakpad::ExceptionHandler(
// L"C:\\Temp\\", 0, windows_post_minidump_callback, 0, google_breakpad::ExceptionHandler::HANDLER_ALL);
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-12 (Catznip-2.6.0a) | Added: Catznip-2.4.0a
U32 maskMiniDumpType = MiniDumpNormal | MiniDumpFilterModulePaths;
switch (minidump_type)
std::wstring wpipe_name;
wpipe_name = mCrashReportPipeStr + wstringize(getPid());
const std::wstring wdump_path(wstringize(mDumpPath));
int retries = 30;
for (; retries > 0; --retries)
{
case MINIDUMP_MINIMAL:
maskMiniDumpType |= MiniDumpFilterMemory;
if (mExceptionHandler != 0) delete mExceptionHandler;
// <FS:ND> Reapply patch from Catznip to allow different types of minidumps
U32 maskMiniDumpType = MiniDumpNormal | MiniDumpFilterModulePaths;
switch (minidump_type)
{
case MINIDUMP_MINIMAL:
maskMiniDumpType |= MiniDumpFilterMemory;
break;
case MINIDUMP_EXTENDED:
maskMiniDumpType |= MiniDumpWithDataSegs | MiniDumpWithIndirectlyReferencedMemory;
break;
case MINIDUMP_NORMAL:
default:
case MINIDUMP_EXTENDED:
maskMiniDumpType |= MiniDumpWithDataSegs | MiniDumpWithIndirectlyReferencedMemory;
break;
case MINIDUMP_NORMAL:
default:
break;
}
// </FS:ND>
mExceptionHandler = new google_breakpad::ExceptionHandler(
wdump_path,
NULL, //No filter
windows_post_minidump_callback,
0,
google_breakpad::ExceptionHandler::HANDLER_ALL,
// MiniDumpNormal, //Generate a 'normal' minidump.
(MINIDUMP_TYPE)maskMiniDumpType, // <FS:ND/> Pass custom minidump type from prefs to breakpad.
wpipe_name.c_str(),
NULL); //No custom client info.
if (mExceptionHandler->IsOutOfProcess())
{
LL_INFOS("CRASHREPORT") << "Successfully attached to Out of Process exception handler." << LL_ENDL;
break;
}
else
{
LL_WARNS("CRASHREPORT") << "Unable to attach to Out of Process exception handler. " << retries << " retries remaining." << LL_ENDL;
::Sleep(100); //Wait a tick and try again.
}
}
mExceptionHandler = new google_breakpad::ExceptionHandler(
L"C:\\Temp\\", 0, windows_post_minidump_callback, 0, google_breakpad::ExceptionHandler::HANDLER_ALL,
(MINIDUMP_TYPE)maskMiniDumpType, (wchar_t const*)0, NULL);
// [/SL:KB]
if (retries == 0) LL_WARNS("CRASHREPORT") << "Unable to attach to Out of Process exception handler." << LL_ENDL;
if (mExceptionHandler)
{
mExceptionHandler->set_handle_debug_exceptions(true);
}
}
#endif
#else
@ -399,14 +468,17 @@ void LLApp::setupErrorHandling(EMiniDumpType minidump_type)
if(installHandler && (mExceptionHandler == 0))
{
std::string dumpPath = "/tmp/";
mExceptionHandler = new google_breakpad::ExceptionHandler(dumpPath, 0, &unix_post_minidump_callback, 0, true, 0);
mExceptionHandler = new google_breakpad::ExceptionHandler(mDumpPath, 0, &unix_post_minidump_callback, 0, true, 0);
}
#elif LL_LINUX
if(installHandler && (mExceptionHandler == 0))
{
google_breakpad::MinidumpDescriptor desc("/tmp");
new google_breakpad::ExceptionHandler(desc, 0, &unix_minidump_callback, 0, true, 0);
if (mDumpPath.empty())
{
mDumpPath = "/tmp";
}
google_breakpad::MinidumpDescriptor desc(mDumpPath);
mExceptionHandler = new google_breakpad::ExceptionHandler(desc, NULL, unix_minidump_callback, NULL, true, -1);
}
#endif
@ -462,25 +534,38 @@ void LLApp::setError()
void LLApp::setMiniDumpDir(const std::string &path)
{
if (path.empty())
{
mDumpPath = "/tmp";
}
else
{
mDumpPath = path;
}
if(mExceptionHandler == 0) return;
#ifdef LL_WINDOWS
// <FS:ND> Make sure to pass a proper unicode string to breapad. path is UTF8, not MBCS
// wchar_t buffer[MAX_MINDUMP_PATH_LENGTH];
// mbstowcs(buffer, path.c_str(), MAX_MINDUMP_PATH_LENGTH);
// mbstowcs(buffer, mDumpPath.c_str(), MAX_MINDUMP_PATH_LENGTH);
// mExceptionHandler->set_dump_path(std::wstring(buffer));
mExceptionHandler->set_dump_path( utf8str_to_utf16str(path) );
mExceptionHandler->set_dump_path( utf8str_to_utf16str(mDumpPath) );
// </FS:ND>
#elif LL_LINUX
google_breakpad::MinidumpDescriptor desc(path);
//google_breakpad::MinidumpDescriptor desc("/tmp"); //path works in debug fails in production inside breakpad lib so linux gets a little less stack reporting until it is patched.
google_breakpad::MinidumpDescriptor desc(mDumpPath); //path works in debug fails in production inside breakpad lib so linux gets a little less stack reporting until it is patched.
mExceptionHandler->set_minidump_descriptor(desc);
#else
mExceptionHandler->set_dump_path(path);
mExceptionHandler->set_dump_path(mDumpPath);
#endif
}
void LLApp::setDebugFileNames(const std::string &path)
{
mStaticDebugFileName = path + "static_debug_info.log";
mDynamicDebugFileName = path + "dynamic_debug_info.log";
}
void LLApp::writeMiniDump()
{
if(mExceptionHandler == 0) return;
@ -557,34 +642,11 @@ bool LLApp::isCrashloggerDisabled()
return (sDisableCrashlogger == TRUE);
}
#if !LL_WINDOWS
// static
U32 LLApp::getSigChildCount()
{
if (sSigChildCount)
{
return U32(*sSigChildCount);
}
return 0;
}
// static
void LLApp::incSigChildCount()
{
if (sSigChildCount)
{
(*sSigChildCount)++;
}
}
#endif
// static
int LLApp::getPid()
{
#if LL_WINDOWS
return 0;
return GetCurrentProcessId();
#else
return getpid();
#endif
@ -660,43 +722,6 @@ BOOL ConsoleCtrlHandler(DWORD fdwCtrlType)
}
#else //!LL_WINDOWS
void LLApp::setChildCallback(pid_t pid, LLAppChildCallback callback)
{
LLChildInfo child_info;
child_info.mCallback = callback;
LLApp::sChildMap[pid] = child_info;
}
void LLApp::setDefaultChildCallback(LLAppChildCallback callback)
{
LLApp::sDefaultChildCallback = callback;
}
pid_t LLApp::fork()
{
fflush(NULL); // flush all buffers before the child inherits them
pid_t pid = ::fork();
if( pid < 0 )
{
int system_error = errno;
llwarns << "Unable to fork! Operating system error code: "
<< system_error << llendl;
}
else if (pid == 0)
{
// Sleep a bit to allow the parent to set up child callbacks.
ms_sleep(10);
// We need to disable signal handling, because we don't have a
// signal handling thread anymore.
setupErrorHandling();
}
else
{
llinfos << "Forked child process " << pid << llendl;
}
return pid;
}
void setup_signals()
{
@ -797,19 +822,6 @@ void default_unix_signal_handler(int signum, siginfo_t *info, void *)
llinfos << "Signal handler - Got SIGCHLD from " << info->si_pid << llendl;
}
// Check result code for all child procs for which we've
// registered callbacks THIS WILL NOT WORK IF SIGCHLD IS SENT
// w/o killing the child (Go, launcher!)
// TODO: Now that we're using SIGACTION, we can actually
// implement the launcher behavior to determine who sent the
// SIGCHLD even if it doesn't result in child termination
if (LLApp::sChildMap.count(info->si_pid))
{
LLApp::sChildMap[info->si_pid].mGotSigChild = TRUE;
}
LLApp::incSigChildCount();
return;
case SIGABRT:
// Abort just results in termination of the app, no funky error handling.
@ -930,21 +942,26 @@ bool unix_minidump_callback(const google_breakpad::MinidumpDescriptor& minidump_
// heap allocations in a crash handler.
// path format: <dump_dir>/<minidump_id>.dmp
int dirPathLength = strlen(minidump_desc.path());
//HACK: *path points to the buffer in getMiniDumpFilename which has already allocated space
//to avoid doing allocation during crash.
char * path = LLApp::instance()->getMiniDumpFilename();
int dir_path_len = strlen(path);
// The path must not be truncated.
llassert((dirPathLength + 5) <= LLApp::MAX_MINDUMP_PATH_LENGTH);
S32 remaining = LLApp::MAX_MINDUMP_PATH_LENGTH - dir_path_len;
llassert( (remaining - strlen(minidump_desc.path())) > 5);
char * path = LLApp::instance()->getMiniDumpFilename();
S32 remaining = LLApp::MAX_MINDUMP_PATH_LENGTH;
strncpy(path, minidump_desc.path(), remaining);
remaining -= dirPathLength;
path += dirPathLength;
if (remaining > 0 && dirPathLength > 0 && path[-1] != '/')
path += dir_path_len;
if (dir_path_len > 0 && path[-1] != '/')
{
*path++ = '/';
--remaining;
}
strncpy(path, minidump_desc.path(), remaining);
llinfos << "generated minidump: " << LLApp::instance()->getMiniDumpFilename() << llendl;
LLApp::runErrorHandler();
@ -992,7 +1009,7 @@ bool unix_post_minidump_callback(const char *dump_dir,
strncpy(path, ".dmp", remaining);
}
llinfos << "generated minidump: " << LLApp::instance()->getMiniDumpFilename() << llendl;
llinfos << "generated minidump: " << path << llendl;
LLApp::runErrorHandler();
#ifndef LL_RELEASE_FOR_DOWNLOAD
@ -1049,11 +1066,12 @@ bool windows_post_minidump_callback(const wchar_t* dump_path,
{
// <FS:ND> Convert all path to UTF8 and not MBCS. Having some path in MBCS and some in UTF8 is a source of great joy
// and bugs. Stick with one standard, that is UTF8.
// char * path = LLApp::instance()->getMiniDumpFilename();
// S32 remaining = LLApp::MAX_MINDUMP_PATH_LENGTH;
// size_t bytesUsed;
//
// LL_INFOS("MINIDUMPCALLBACK") << "Dump file was generated." << LL_ENDL;
// bytesUsed = wcstombs(path, dump_path, static_cast<size_t>(remaining));
// remaining -= bytesUsed;
// path += bytesUsed;
@ -1074,14 +1092,14 @@ bool windows_post_minidump_callback(const wchar_t* dump_path,
// }
char *pOut( LLApp::instance()->getMiniDumpFilename() );
bool hasOverflow(false);
bool hasOverflow( false );
S32 bufferLength( LLApp::MAX_MINDUMP_PATH_LENGTH );
hasOverflow = nd::strings::convertString( dump_path, pOut, bufferLength );
if( !hasOverflow && bufferLength < LLApp::MAX_MINDUMP_PATH_LENGTH && bufferLength > 1 && pOut[-1] != '\\' && pOut[-1] != '/' )
{
*pOut++ = '\\';
--bufferLength;
*pOut++ = '\\';
--bufferLength;
}
if( !hasOverflow )
@ -1098,8 +1116,8 @@ bool windows_post_minidump_callback(const wchar_t* dump_path,
else if( hasOverflow )
LLApp::instance()->getMiniDumpFilename()[ 0 ] = 0;
// <FS:ND>
// </FS:ND>
llinfos << "generated minidump: " << LLApp::instance()->getMiniDumpFilename() << llendl;
// *NOTE:Mani - this code is stolen from LLApp, where its never actually used.
//OSMessageBox("Attach Debugger Now", "Error", OSMB_OK);

50
indra/llcommon/llapp.h
View File

@ -31,7 +31,6 @@
#include "llrun.h"
#include "llsd.h"
#include "lloptioninterface.h"
// Forward declarations
template <typename Type> class LLAtomic32;
typedef LLAtomic32<U32> LLAtomicU32;
@ -42,7 +41,6 @@ class LLLiveFile;
#endif
typedef void (*LLAppErrorHandler)();
typedef void (*LLAppChildCallback)(int pid, bool exited, int status);
#if !LL_WINDOWS
extern S32 LL_SMACKDOWN_SIGNAL;
@ -51,13 +49,6 @@ extern S32 LL_HEARTBEAT_SIGNAL;
// Clear all of the signal handlers (which we want to do for the child process when we fork
void clear_signals();
class LLChildInfo
{
public:
LLChildInfo() : mGotSigChild(FALSE), mCallback(NULL) {}
BOOL mGotSigChild;
LLAppChildCallback mCallback;
};
#endif
namespace google_breakpad {
@ -206,10 +197,6 @@ public:
static bool isQuitting();
static bool isError();
static bool isExiting(); // Either quitting or error (app is exiting, cleanly or not)
#if !LL_WINDOWS
static U32 getSigChildCount();
static void incSigChildCount();
#endif
static int getPid();
/** @name Error handling methods */
@ -246,32 +233,16 @@ public:
// change the directory where Breakpad minidump files are written to
void setMiniDumpDir(const std::string &path);
void setDebugFileNames(const std::string &path);
// Return the Google Breakpad minidump filename after a crash.
char *getMiniDumpFilename() { return minidump_path; }
char *getMiniDumpFilename() { return mMinidumpPath; }
std::string* getStaticDebugFile() { return &mStaticDebugFileName; }
std::string* getDynamicDebugFile() { return &mDynamicDebugFileName; }
// Write out a Google Breakpad minidump file.
void writeMiniDump();
#if !LL_WINDOWS
//
// Child process handling (Unix only for now)
//
// Set a callback to be run on exit of a child process
// WARNING! This callback is run from the signal handler due to
// Linux threading requiring waitpid() to be called from the thread that spawned the process.
// At some point I will make this more behaved, but I'm not going to fix this right now - djs
void setChildCallback(pid_t pid, LLAppChildCallback callback);
// The child callback to run if no specific handler is set
void setDefaultChildCallback(LLAppChildCallback callback);
// Fork and do the proper signal handling/error handling mojo
// *NOTE: You need to make sure your signal handling callback is
// correct after you fork, because not all threads are duplicated
// when you fork!
pid_t fork();
#endif
/**
* @brief Get a reference to the application runner
@ -294,13 +265,9 @@ protected:
static EAppStatus sStatus; // Reflects current application status
static BOOL sErrorThreadRunning; // Set while the error thread is running
static BOOL sDisableCrashlogger; // Let the OS handle crashes for us.
std::wstring mCrashReportPipeStr; //Name of pipe to use for crash reporting.
#if !LL_WINDOWS
static LLAtomicU32* sSigChildCount; // Number of SIGCHLDs received.
typedef std::map<pid_t, LLChildInfo> child_map; // Map key is a PID
static child_map sChildMap;
static LLAppChildCallback sDefaultChildCallback;
#endif
std::string mDumpPath; //output path for google breakpad. Dependency workaround.
/**
* @brief This method is called once a frame to do once a frame tasks.
@ -311,7 +278,10 @@ private:
void startErrorThread();
// Contains the filename of the minidump file after a crash.
char minidump_path[MAX_MINDUMP_PATH_LENGTH];
char mMinidumpPath[MAX_MINDUMP_PATH_LENGTH];
std::string mStaticDebugFileName;
std::string mDynamicDebugFileName;
// *NOTE: On Windows, we need a routine to reset the structured
// exception handler when some evil driver has taken it over for

71
indra/llcommon/llerrorthread.cpp
View File

@ -109,79 +109,8 @@ void LLErrorThread::run()
llinfos << "thread_error - Waiting for an error" << llendl;
S32 counter = 0;
#if !LL_WINDOWS
U32 last_sig_child_count = 0;
#endif
while (! (LLApp::isError() || LLApp::isStopped()))
{
#if !LL_WINDOWS
// Check whether or not the main thread had a sig child we haven't handled.
U32 current_sig_child_count = LLApp::getSigChildCount();
if (last_sig_child_count != current_sig_child_count)
{
int status = 0;
pid_t child_pid = 0;
last_sig_child_count = current_sig_child_count;
if (LLApp::sLogInSignal)
{
llinfos << "thread_error handling SIGCHLD #" << current_sig_child_count << llendl;
}
for (LLApp::child_map::iterator iter = LLApp::sChildMap.begin(); iter != LLApp::sChildMap.end();)
{
child_pid = iter->first;
LLChildInfo &child_info = iter->second;
// check the status of *all* children, in case we missed a signal
if (0 != waitpid(child_pid, &status, WNOHANG))
{
bool exited = false;
int exit_status = -1;
get_child_status(status, exit_status, exited, LLApp::sLogInSignal);
if (child_info.mCallback)
{
if (LLApp::sLogInSignal)
{
llinfos << "Signal handler - Running child callback" << llendl;
}
child_info.mCallback(child_pid, exited, status);
}
LLApp::sChildMap.erase(iter++);
}
else
{
// Child didn't terminate, yet we got a sigchild somewhere...
if (child_info.mGotSigChild && child_info.mCallback)
{
child_info.mCallback(child_pid, false, 0);
}
child_info.mGotSigChild = FALSE;
iter++;
}
}
// check the status of *all* children, in case we missed a signal
// Same as above, but use the default child callback
while(0 < (child_pid = waitpid( -1, &status, WNOHANG )))
{
if (0 != waitpid(child_pid, &status, WNOHANG))
{
bool exited = false;
int exit_status = -1;
get_child_status(status, exit_status, exited, LLApp::sLogInSignal);
if (LLApp::sDefaultChildCallback)
{
if (LLApp::sLogInSignal)
{
llinfos << "Signal handler - Running default child callback" << llendl;
}
LLApp::sDefaultChildCallback(child_pid, true, status);
}
}
}
}
#endif
ms_sleep(10);
counter++;
}

31
indra/llcommon/llfile.cpp
View File

@ -265,6 +265,37 @@ int LLFile::rename(const std::string& filename, const std::string& newname)
return warnif(STRINGIZE("rename to '" << newname << "' from"), filename, rc);
}
bool LLFile::copy(const std::string from, const std::string to)
{
bool copied = false;
LLFILE* in = LLFile::fopen(from, "rb"); /* Flawfinder: ignore */
if (in)
{
LLFILE* out = LLFile::fopen(to, "wb"); /* Flawfinder: ignore */
if (out)
{
char buf[16384]; /* Flawfinder: ignore */
size_t readbytes;
bool write_ok = true;
while(write_ok && (readbytes = fread(buf, 1, 16384, in))) /* Flawfinder: ignore */
{
if (fwrite(buf, 1, readbytes, out) != readbytes)
{
LL_WARNS("LLFile") << "Short write" << LL_ENDL;
write_ok = false;
}
}
if ( write_ok )
{
copied = true;
}
fclose(out);
}
fclose(in);
}
return copied;
}
int LLFile::stat(const std::string& filename, llstat* filestatus)
{
#if LL_WINDOWS

2
indra/llcommon/llfile.h
View File

@ -75,6 +75,8 @@ public:
static int rmdir(const std::string& filename);
static int remove(const std::string& filename);
static int rename(const std::string& filename,const std::string& newname);
static bool copy(const std::string from, const std::string to);
static int stat(const std::string& filename,llstat* file_status);
static bool isdir(const std::string& filename);
static bool isfile(const std::string& filename);

5
indra/llcommon/llstring.h
View File

@ -518,10 +518,13 @@ LL_COMMON_API S32 wchar_to_utf8chars(llwchar inchar, char* outchars);
LL_COMMON_API std::string wstring_to_utf8str(const LLWString &utf32str, S32 len);
LL_COMMON_API std::string wstring_to_utf8str(const LLWString &utf32str);
LL_COMMON_API std::string utf16str_to_utf8str(const llutf16string &utf16str, S32 len);
LL_COMMON_API std::string utf16str_to_utf8str(const llutf16string &utf16str);
#if LL_WINDOWS
inline std::string wstring_to_utf8str(const llutf16string &utf16str) { return utf16str_to_utf8str(utf16str);}
#endif
// Length of this UTF32 string in bytes when transformed to UTF8
LL_COMMON_API S32 wstring_utf8_length(const LLWString& wstr);

51
indra/llcommon/stringize.h
View File

@ -31,18 +31,61 @@
#include <sstream>
#include <boost/lambda/lambda.hpp>
#include <llstring.h>
/**
* stringize(item) encapsulates an idiom we use constantly, using
* gstringize(item) encapsulates an idiom we use constantly, using
* operator<<(std::ostringstream&, TYPE) followed by std::ostringstream::str()
* or their wstring equivalents
* to render a string expressing some item.
*/
template <typename CHARTYPE, typename T>
std::basic_string<CHARTYPE> gstringize(const T& item)
{
std::basic_ostringstream<CHARTYPE> out;
out << item;
return out.str();
}
/**
*partial specialization of stringize for handling wstring
*TODO: we should have similar specializations for wchar_t[] but not until it is needed.
*/
inline std::string stringize(const std::wstring& item)
{
llwarns << "WARNING: Possible narrowing" << llendl;
std::string s;
s = wstring_to_utf8str(item);
return gstringize<char>(s);
}
/**
* Specialization of gstringize for std::string return types
*/
template <typename T>
std::string stringize(const T& item)
{
std::ostringstream out;
out << item;
return out.str();
return gstringize<char>(item);
}
/**
* Specialization for generating wstring from string.
* Both a convenience function and saves a miniscule amount of overhead.
*/
inline std::wstring wstringize(const std::string& item)
{
return gstringize<wchar_t>(item.c_str());
}
/**
* Specialization of gstringize for std::wstring return types
*/
template <typename T>
std::wstring wstringize(const T& item)
{
return gstringize<wchar_t>(item);
}
/**

20
indra/llcommon/tests/stringize_test.cpp
View File

@ -67,6 +67,8 @@ namespace tut
llsd["i"] = i;
llsd["d"] = d;
llsd["abc"] = abc;
def = L"def ghi";
}
char c;
@ -76,6 +78,7 @@ namespace tut
float f;
double d;
std::string abc;
std::wstring def;
LLSD llsd;
};
typedef test_group<stringize_data> stringize_group;
@ -92,6 +95,7 @@ namespace tut
ensure_equals(stringize(f), "3.14159");
ensure_equals(stringize(d), "3.14159");
ensure_equals(stringize(abc), "abc def");
ensure_equals(stringize(def), "def ghi"); //Will generate llwarns due to narrowing.
ensure_equals(stringize(llsd), "{'abc':'abc def','d':r3.14159,'i':i34}");
}
@ -101,4 +105,20 @@ namespace tut
ensure_equals(STRINGIZE("c is " << c), "c is c");
ensure_equals(STRINGIZE(std::setprecision(4) << d), "3.142");
}
template<> template<>
void stringize_object::test<3>()
{
//Tests rely on validity of wstring_to_utf8str()
ensure_equals(wstring_to_utf8str(wstringize(c)), wstring_to_utf8str(L"c"));
ensure_equals(wstring_to_utf8str(wstringize(s)), wstring_to_utf8str(L"17"));
ensure_equals(wstring_to_utf8str(wstringize(i)), wstring_to_utf8str(L"34"));
ensure_equals(wstring_to_utf8str(wstringize(l)), wstring_to_utf8str(L"68"));
ensure_equals(wstring_to_utf8str(wstringize(f)), wstring_to_utf8str(L"3.14159"));
ensure_equals(wstring_to_utf8str(wstringize(d)), wstring_to_utf8str(L"3.14159"));
ensure_equals(wstring_to_utf8str(wstringize(abc)), wstring_to_utf8str(L"abc def"));
ensure_equals(wstring_to_utf8str(wstringize(abc)), wstring_to_utf8str(wstringize(abc.c_str())));
ensure_equals(wstring_to_utf8str(wstringize(def)), wstring_to_utf8str(L"def ghi"));
// ensure_equals(wstring_to_utf8str(wstringize(llsd)), wstring_to_utf8str(L"{'abc':'abc def','d':r3.14159,'i':i34}"));
}
} // namespace tut

2
indra/llcrashlogger/CMakeLists.txt
View File

@ -23,6 +23,7 @@ include_directories(SYSTEM
set(llcrashlogger_SOURCE_FILES
llcrashlogger.cpp
llcrashlock.cpp
llcrashlookup.cpp
)
@ -30,6 +31,7 @@ set(llcrashlogger_HEADER_FILES
CMakeLists.txt
llcrashlogger.h
llcrashlock.h
llcrashlookup.h
)

209
indra/llcrashlogger/llcrashlock.cpp Normal file
View File

@ -0,0 +1,209 @@
/**
* @file llformat.cpp
* @date January 2007
* @brief string formatting utility
*
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#include "linden_common.h"
#include "llcrashlock.h"
#include "lldir.h"
#include "llsd.h"
#include "llsdserialize.h"
#include "llnametable.h"
#include "llframetimer.h"
#include <boost/filesystem.hpp>
#include <string>
#include <iostream>
#include <stdio.h>
#if LL_WINDOWS //For windows platform.
#include <windows.h>
#include <TlHelp32.h>
namespace {
inline DWORD getpid() {
return GetCurrentProcessId();
}
}
bool LLCrashLock::isProcessAlive(U32 pid, const std::string& pname)
{
std::wstring wpname;
wpname = std::wstring(pname.begin(), pname.end());
HANDLE snapshot;
PROCESSENTRY32 pe32;
bool matched = false;
snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (snapshot == INVALID_HANDLE_VALUE)
{
return false;
}
else
{
pe32.dwSize = sizeof(PROCESSENTRY32);
if (Process32First(snapshot, &pe32))
{
do {
std::wstring wexecname = pe32.szExeFile;
std::string execname = std::string(wexecname.begin(), wexecname.end());
if (!wpname.compare(pe32.szExeFile))
{
if (pid == (U32)pe32.th32ProcessID)
{
matched = true;
break;
}
}
} while (Process32Next(snapshot, &pe32));
}
}
CloseHandle(snapshot);
return matched;
}
#else //Everyone Else
bool LLCrashLock::isProcessAlive(U32 pid, const std::string& pname)
{
//Will boost.process ever become a reality?
std::stringstream cmd;
cmd << "pgrep '" << pname << "' | grep '^" << pid << "$'";
return (!system(cmd.str().c_str()));
}
#endif //Everyone else.
LLCrashLock::LLCrashLock() : mCleanUp(true), mWaitingPID(0)
{
}
void LLCrashLock::setCleanUp(bool cleanup)
{
mCleanUp = cleanup; //Allow cleanup to be disabled for debugging.
}
LLSD LLCrashLock::getLockFile(std::string filename)
{
LLSD lock_sd = LLSD::emptyMap();
llifstream ifile(filename);
if (ifile.is_open())
{
LLSDSerialize::fromXML(lock_sd, ifile);
ifile.close();
}
return lock_sd;
}
bool LLCrashLock::putLockFile(std::string filename, const LLSD& data)
{
bool result = true;
llofstream ofile(filename);
if (!LLSDSerialize::toXML(data,ofile))
{
result=false;
}
ofile.close();
return result;
}
bool LLCrashLock::requestMaster( F32 timeout )
{
if (mMaster.empty())
{
mMaster = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
"crash_master.lock");
}
LLSD lock_sd=getLockFile(mMaster);
if (lock_sd.has("pid"))
{
mWaitingPID = lock_sd["pid"].asInteger();
if ( isProcessAlive(mWaitingPID, gDirUtilp->getExecutableFilename()) )
{
mTimer.resetWithExpiry(timeout);
return false;
}
}
U32 pid = getpid();
lock_sd["pid"] = (LLSD::Integer)pid;
return putLockFile(mMaster,lock_sd);
}
bool LLCrashLock::checkMaster()
{
if (mWaitingPID)
{
return (!isProcessAlive(mWaitingPID, gDirUtilp->getExecutableFilename()));
}
return false;
}
bool LLCrashLock::isWaiting()
{
return !mTimer.hasExpired();
}
void LLCrashLock::releaseMaster()
{
//Yeeeeeeehaw
unlink(mMaster.c_str());
}
LLSD LLCrashLock::getProcessList()
{
if (mDumpTable.empty())
{
mDumpTable= gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
"crash_table.lock");
}
return getLockFile(mDumpTable);
}
//static
bool LLCrashLock::fileExists(std::string filename)
{
return boost::filesystem::exists(filename.c_str());
}
void LLCrashLock::cleanupProcess(std::string proc_dir)
{
boost::filesystem::remove_all(proc_dir);
}
bool LLCrashLock::putProcessList(const LLSD& proc_sd)
{
return putLockFile(mDumpTable,proc_sd);
}

73
indra/llcrashlogger/llcrashlock.h Normal file
View File

@ -0,0 +1,73 @@
/**
* @file llpidlock.h
* @brief Maintainence of disk locking files for crash reporting
*
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#ifndef LL_CRASHLOCK_H
#define LL_CRASHLOCK_H
#include "llframetimer.h"
class LLSD;
#if !LL_WINDOWS //For non-windows platforms.
#include <signal.h>
#endif
//Crash reporter will now be kicked off by the viewer but otherwise
//run independent of the viewer.
class LLCrashLock
{
public:
LLCrashLock();
bool requestMaster( F32 timeout=300.0); //Wait until timeout for master lock.
bool checkMaster(); //True if available. False if not.
void releaseMaster( ); //Release master lockfile.
bool isLockPresent(std::string filename); //Check if lockfile exists.
bool isProcessAlive(U32 pid, const std::string& pname); //Check if pid is alive.
bool isWaiting(); //Waiting for master lock to be released.
LLSD getProcessList(); //Get next process pid/dir pairs
void cleanupProcess(std::string proc_dir); //Remove from list, clean up working dir.
bool putProcessList(const LLSD& processlist); //Write pid/dir pairs back to disk.
static bool fileExists(std::string filename);
//getters
S32 getPID();
//setters
void setCleanUp(bool cleanup=true);
void setSaveName(std::string savename);
private:
LLSD getLockFile(std::string filename);
bool putLockFile(std::string filename, const LLSD& data);
bool mCleanUp;
std::string mMaster;
std::string mDumpTable;
U32 mWaitingPID; //The process we're waiting on if any.
LLFrameTimer mTimer;
};
#endif // LL_CRASHLOCK_H

497
indra/llcrashlogger/llcrashlogger.cpp
View File

@ -23,12 +23,14 @@
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#include <cstdio>
#include <cstdlib>
#include <sstream>
#include <map>
#include "llcrashlogger.h"
#include "llcrashlock.h"
#include "linden_common.h"
#include "llstring.h"
#include "indra_constants.h" // CRASH_BEHAVIOR_...
@ -43,7 +45,7 @@
#include "llhttpclient.h"
#include "llsdserialize.h"
#include "llproxy.h"
// [SL:KB] - Patch: Viewer-CrashLookup | Checked: 2011-03-24 (Catznip-2.6.0a) | Added: Catznip-2.6.0a
#ifdef LL_WINDOWS
#include <shellapi.h>
@ -74,13 +76,6 @@ public:
virtual void result(const LLSD& content)
{
// [SL:KB] - Patch: Viewer-CrashLookup | Checked: 2011-03-24 (Catznip-2.6.0a) | Added: Catznip-2.6.0a
if ( (content.has("crash_link")) && (!content["crash_link"].asString().empty()) )
{
((LLCrashLogger*)LLCrashLogger::instance())->setCrashInformationLink(content["crash_link"].asString());
}
// [/SL:KB]
gBreak = true;
gSent = true;
}
@ -96,14 +91,11 @@ LLCrashLogger::LLCrashLogger() :
mSentCrashLogs(false),
mCrashHost("")
{
// Set up generic error handling
setupErrorHandling();
}
LLCrashLogger::~LLCrashLogger()
{
delete gServicePump;
gServicePump = NULL;
}
// TRIM_SIZE must remain larger than LINE_SEARCH_SIZE.
@ -160,12 +152,9 @@ std::string getStartupStateFromLog(std::string& sllog)
return startup_state;
}
void LLCrashLogger::gatherFiles()
bool LLCrashLogger::readDebugFromXML(LLSD& dest, const std::string& filename )
{
updateApplication("Gathering logs...");
// Figure out the filename of the debug log
std::string db_file_name = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"debug_info.log");
std::string db_file_name = gDirUtilp->getExpandedFilename(LL_PATH_DUMP,filename);
// <FS:ND> Properly handle unicode path on Windows. Maybe could use a llifstream instead of ifdef?
@ -174,24 +163,71 @@ void LLCrashLogger::gatherFiles()
#ifdef LL_WINDOWS
std::ifstream debug_log_file( utf8str_to_utf16str( db_file_name ).c_str());
#else
std::ifstream debug_log_file(db_file_name.c_str());
std::ifstream debug_log_file(db_file_name.c_str());
#endif
// </FS:ND>
// Look for it in the debug_info.log file
if (debug_log_file.is_open())
{
LLSDSerialize::fromXML(mDebugLog, debug_log_file);
LLSDSerialize::fromXML(dest, debug_log_file);
debug_log_file.close();
return true;
}
return false;
}
void LLCrashLogger::mergeLogs( LLSD src_sd )
{
LLSD::map_iterator iter = src_sd.beginMap();
LLSD::map_iterator end = src_sd.endMap();
for( ; iter != end; ++iter)
{
mDebugLog[iter->first] = iter->second;
}
}
bool LLCrashLogger::readMinidump(std::string minidump_path)
{
size_t length=0;
std::ifstream minidump_stream(minidump_path.c_str(), std::ios_base::in | std::ios_base::binary);
if(minidump_stream.is_open())
{
minidump_stream.seekg(0, std::ios::end);
length = (size_t)minidump_stream.tellg();
minidump_stream.seekg(0, std::ios::beg);
LLSD::Binary data;
data.resize(length);
minidump_stream.read(reinterpret_cast<char *>(&(data[0])),length);
minidump_stream.close();
mCrashInfo["Minidump"] = data;
}
return (length>0?true:false);
}
void LLCrashLogger::gatherFiles()
{
updateApplication("Gathering logs...");
LLSD static_sd;
LLSD dynamic_sd;
bool has_logs = readDebugFromXML( static_sd, "static_debug_info.log" );
has_logs |= readDebugFromXML( dynamic_sd, "dynamic_debug_info.log" );
if ( has_logs )
{
mDebugLog = static_sd;
mergeLogs(dynamic_sd);
mCrashInPreviousExec = mDebugLog["CrashNotHandled"].asBoolean();
mFileMap["SecondLifeLog"] = mDebugLog["SLLog"].asString();
mFileMap["SettingsXml"] = mDebugLog["SettingsFilename"].asString();
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-27 (Catznip-2.6.0a) | Added: Catznip-2.4.0f
// Remove the settings.xml path after we've retrieved it since it could contain the OS user name
mDebugLog.erase("SettingsFilename");
// [/SL:KB]
if(mDebugLog.has("CAFilename"))
{
LLCurl::setCAFile(mDebugLog["CAFilename"].asString());
@ -204,26 +240,19 @@ void LLCrashLogger::gatherFiles()
llinfos << "Using log file from debug log " << mFileMap["SecondLifeLog"] << llendl;
llinfos << "Using settings file from debug log " << mFileMap["SettingsXml"] << llendl;
}
/*
else
{
// Figure out the filename of the second life log
LLCurl::setCAFile(gDirUtilp->getCAFile());
mFileMap["SecondLifeLog"] = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"SecondLife.log");
mFileMap["SettingsXml"] = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS,"settings.xml");
}
*/
// else
// {
// // Figure out the filename of the second life log
// LLCurl::setCAFile(gDirUtilp->getCAFile());
//
// mFileMap["SecondLifeLog"] = gDirUtilp->getExpandedFilename(LL_PATH_DUMP,"SecondLife.log");
// mFileMap["SettingsXml"] = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS,"settings.xml");
// }
if(mCrashInPreviousExec)
{
// Restarting after freeze.
// Replace the log file ext with .old, since the
// instance that launched this process has overwritten
// SecondLife.log
std::string log_filename = mFileMap["SecondLifeLog"];
log_filename.replace(log_filename.size() - 4, 4, ".old");
mFileMap["SecondLifeLog"] = log_filename;
}
// if (!gDirUtilp->fileExists(mFileMap["SecondLifeLog"]) ) //We would prefer to get this from the per-run but here's our fallback.
// {
// mFileMap["SecondLifeLog"] = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"SecondLife.old");
// }
gatherPlatformSpecificFiles();
@ -236,105 +265,138 @@ void LLCrashLogger::gatherFiles()
// Crash log receiver has been manually configured.
mCrashHost = mDebugLog["CrashHostUrl"].asString();
}
/*
else if(mDebugLog.has("CurrentSimHost"))
{
mCrashHost = "https://";
mCrashHost += mDebugLog["CurrentSimHost"].asString();
mCrashHost += ":12043/crash/report";
}
else if(mDebugLog.has("GridName"))
{
// This is a 'little' hacky, but its the best simple solution.
std::string grid_host = mDebugLog["GridName"].asString();
LLStringUtil::toLower(grid_host);
mCrashHost = "https://login.";
mCrashHost += grid_host;
mCrashHost += ".lindenlab.com:12043/crash/report";
}
*/
// <FS:ND> Might hardcode mCrashHost to crashlogs.phoenixviewer.com if unset
// <FS:ND> Do not send out crash reports to Linden Labs. They won't have much use for them without symbols.
// else if(mDebugLog.has("CurrentSimHost"))
// {
// mCrashHost = "https://";
// mCrashHost += mDebugLog["CurrentSimHost"].asString();
// mCrashHost += ":12043/crash/report";
// }
// else if(mDebugLog.has("GridName"))
// {
// // This is a 'little' hacky, but its the best simple solution.
// std::string grid_host = mDebugLog["GridName"].asString();
// LLStringUtil::toLower(grid_host);
// mCrashHost = "https://login.";
// mCrashHost += grid_host;
// mCrashHost += ".lindenlab.com:12043/crash/report";
// }
// Use login servers as the alternate, since they are already load balanced and have a known name
// mAltCrashHost = "https://login.agni.lindenlab.com:12043/crash/report";
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-14 (Catznip-2.6.0a) | Added: Catznip-2.4.0a
mAltCrashHost = "";
// [/SL:KB]
// mAltCrashHost = "https://login.agni.lindenlab.com:12043/crash/report";
// mCrashInfo["DebugLog"] = mDebugLog;
mFileMap["StatsLog"] = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"stats.log");
// </FS:ND>
mCrashInfo["DebugLog"] = mDebugLog;
mFileMap["StatsLog"] = gDirUtilp->getExpandedFilename(LL_PATH_DUMP,"stats.log");
updateApplication("Encoding files...");
/*
for(std::map<std::string, std::string>::iterator itr = mFileMap.begin(); itr != mFileMap.end(); ++itr)
{
std::ifstream f((*itr).second.c_str());
if(!f.is_open())
{
std::cout << "Can't find file " << (*itr).second << std::endl;
continue;
}
std::stringstream s;
s << f.rdbuf();
// <FS:ND> We're not using this. We do not send a LLSD xml with all data embedded.
std::string crash_info = s.str();
if(itr->first == "SecondLifeLog")
{
if(!mCrashInfo["DebugLog"].has("StartupState"))
{
mCrashInfo["DebugLog"]["StartupState"] = getStartupStateFromLog(crash_info);
}
trimSLLog(crash_info);
}
// for(std::map<std::string, std::string>::iterator itr = mFileMap.begin(); itr != mFileMap.end(); ++itr)
// {
// std::ifstream f((*itr).second.c_str());
// if(!f.is_open())
// {
// LL_INFOS("CRASHREPORT") << "Can't find file " << (*itr).second << LL_ENDL;
// continue;
// }
// std::stringstream s;
// s << f.rdbuf();
mCrashInfo[(*itr).first] = LLStringFn::strip_invalid_xml(rawstr_to_utf8(crash_info));
}
*/
// std::string crash_info = s.str();
// if(itr->first == "SecondLifeLog")
// {
// if(!mCrashInfo["DebugLog"].has("StartupState"))
// {
// mCrashInfo["DebugLog"]["StartupState"] = getStartupStateFromLog(crash_info);
// }
// trimSLLog(crash_info);
// }
// mCrashInfo[(*itr).first] = LLStringFn::strip_invalid_xml(rawstr_to_utf8(crash_info));
// }
// </FS:ND>
std::string minidump_path;
// Add minidump as binary.
std::string minidump_path = mDebugLog["MinidumpPath"];
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2011-03-24 (Catznip-2.6.0a) | Modified: Catznip-2.6.0a
if (gDirUtilp->fileExists(minidump_path))
bool has_minidump = mDebugLog.has("MinidumpPath");
if (has_minidump)
{
mFileMap["Minidump"] = minidump_path;
if (mCrashLookup)
{
mCrashLookup->initFromDump(minidump_path);
}
// Remove the minidump path after we've retrieved it since it could contain the OS user name
mDebugLog.erase("MinidumpPath");
minidump_path = mDebugLog["MinidumpPath"].asString();
}
// Include debug_info.log as part of CrashReport.log
mCrashInfo["DebugLog"] = mDebugLog;
// [/SL:KB]
/*
if(minidump_path != "")
if (has_minidump)
{
std::ifstream minidump_stream(minidump_path.c_str(), std::ios_base::in | std::ios_base::binary);
if(minidump_stream.is_open())
{
minidump_stream.seekg(0, std::ios::end);
size_t length = (size_t)minidump_stream.tellg();
minidump_stream.seekg(0, std::ios::beg);
LLSD::Binary data;
data.resize(length);
minidump_stream.read(reinterpret_cast<char *>(&(data[0])),length);
minidump_stream.close();
mCrashInfo["Minidump"] = data;
}
has_minidump = readMinidump(minidump_path);
}
mCrashInfo["DebugLog"].erase("MinidumpPath");
*/
if (!has_minidump) //Viewer was probably so hosed it couldn't write remaining data. Try brute force.
{
//Look for a filename at least 30 characters long in the dump dir which contains the characters MDMP as the first 4 characters in the file.
typedef std::vector<std::string> vec;
std::string pathname = gDirUtilp->getExpandedFilename(LL_PATH_DUMP,"");
vec file_vec = gDirUtilp->getFilesInDir(pathname);
for(vec::const_iterator iter=file_vec.begin(); iter!=file_vec.end(); ++iter)
{
if ( ( iter->length() > 30 ) && (iter->rfind(".dmp") == (iter->length()-4) ) )
{
std::string fullname = pathname + *iter;
std::ifstream fdat( fullname.c_str(), std::ifstream::binary);
if (fdat)
{
char buf[5];
fdat.read(buf,4);
fdat.close();
if (!strncmp(buf,"MDMP",4))
{
minidump_path = *iter;
has_minidump = readMinidump(fullname);
mDebugLog["MinidumpPath"] = fullname;
if (has_minidump)
{
break;
}
}
}
}
}
}
// <FS:ND> Put minidump file into mFileMap. Otherwise it does not get uploaded to the crashlog server.
if( has_minidump )
{
std::string fullName = mDebugLog["MinidumpPath"];
std::string dmpName( fullName );
if( dmpName.size() )
{
size_t nStart( dmpName.size()-1 );
for( std::string::reverse_iterator itr = dmpName.rbegin(); itr != dmpName.rend(); ++itr )
{
if( *itr == '/' || *itr == '\\' )
break;
--nStart;
}
dmpName = dmpName.substr( nStart+1 );
}
mFileMap[ dmpName ] = fullName;
}
// </FS:ND>
}
LLSD LLCrashLogger::constructPostData()
{
LLSD ret;
return mCrashInfo;
}
@ -499,23 +561,22 @@ bool LLCrashLogger::runCrashLogPost(std::string host, LLSD data, std::string msg
return gSent;
}
bool LLCrashLogger::sendCrashLogs()
bool LLCrashLogger::sendCrashLog(std::string dump_dir)
{
gDirUtilp->setDumpDir( dump_dir );
// std::string dump_path = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
// "SecondLifeCrashReport");
std::string dump_path = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "FirestormCrashReport");
std::string report_file = dump_path + ".log";
gatherFiles();
LLSD post_data;
post_data = constructPostData();
updateApplication("Sending reports...");
// std::string dump_path = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
// "SecondLifeCrashReport");
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-14 (Catznip-2.6.0a) | Added: Catznip-2.4.0a
std::string dump_path = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
"FirestormCrashReport");
// [/SL:KB]
std::string report_file = dump_path + ".log";
#ifdef LL_WINDOWS
std::ofstream out_file( utf8str_to_utf16str(report_file).c_str() );
#else
@ -524,50 +585,100 @@ bool LLCrashLogger::sendCrashLogs()
LLSDSerialize::toPrettyXML(post_data, out_file);
out_file.close();
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-14 (Catznip-2.6.0a) | Added: Catznip-2.4.0a
mFileMap["CrashReportLog"] = report_file;
// [/SL:KB]
bool sent = false;
//*TODO: Translate
if(mCrashHost != "")
{
sent = runCrashLogPost(mCrashHost, post_data, std::string("Sending to server"), 3, 5);
}
// <FS:ND> We do not send to mAltCrashHost ever.
// if(!sent)
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-14 (Catznip-2.6.0a) | Added: Catznip-2.4.0a
if ( (!sent) && (!mAltCrashHost.empty()) )
// [/SL:KB]
{
sent = runCrashLogPost(mAltCrashHost, post_data, std::string("Sending to alternate server"), 3, 5);
}
// if(!sent)
// {
// sent = runCrashLogPost(mAltCrashHost, post_data, std::string("Sending to alternate server"), 3, 5);
// }
// </FS:ND>
mSentCrashLogs = sent;
return sent;
}
// [SL:KB] - Patch: Viewer-CrashLookup | Checked: 2011-03-24 (Catznip-2.6.0a) | Added: Catznip-2.6.0a
if (!mCrashLink.empty())
{
#if LL_WINDOWS && LL_SEND_CRASH_REPORTS
if (IDYES == MessageBox(NULL, L"Additional information is available about this crash. Display?", L"Crash Information", MB_YESNO))
{
wchar_t wstrCrashLink[512];
mbstowcs_s(NULL, wstrCrashLink, 512, mCrashLink.c_str(), _TRUNCATE);
bool LLCrashLogger::sendCrashLogs()
{
//pertinent code from below moved into a subroutine.
LLSD locks = mKeyMaster.getProcessList();
LLSD newlocks = LLSD::emptyArray();
SHELLEXECUTEINFO sei = {0};
sei.cbSize = sizeof(SHELLEXECUTEINFO);
sei.fMask = SEE_MASK_NOASYNC;
sei.lpVerb = L"open";
sei.lpFile = wstrCrashLink;
ShellExecuteEx(&sei);
}
#endif // LL_WINDOWS && LL_SEND_CRASH_REPORTS
}
// [/SL:KB]
LLSD opts = getOptionData(PRIORITY_COMMAND_LINE);
LLSD rec;
return true;
if ( opts.has("pid") && opts.has("dumpdir") && opts.has("procname") )
{
rec["pid"]=opts["pid"];
rec["dumpdir"]=opts["dumpdir"];
rec["procname"]=opts["procname"];
}
// <FS:ND> Try to send the current crash right away, if that fails queue it for next time.
if( rec && rec.has("dumpdir") )
if( !sendCrashLog( rec["dumpdir"].asString() ) )
newlocks.append(rec);
// </FS:ND>
if (locks.isArray())
{
for (LLSD::array_iterator lock=locks.beginArray();
lock !=locks.endArray();
++lock)
{
if ( (*lock).has("pid") && (*lock).has("dumpdir") && (*lock).has("procname") )
{
if ( mKeyMaster.isProcessAlive( (*lock)["pid"].asInteger(), (*lock)["procname"].asString() ) )
{
newlocks.append(*lock);
}
else
{
//TODO: This is a hack but I didn't want to include boost in another file or retest everything related to lldir
if (LLCrashLock::fileExists((*lock)["dumpdir"].asString()))
{
//the viewer cleans up the log directory on clean shutdown
//but is ignorant of the locking table.
if (!sendCrashLog((*lock)["dumpdir"].asString()))
{
newlocks.append(*lock); //Failed to send log so don't delete it.
}
else
{
//mCrashInfo["DebugLog"].erase("MinidumpPath");
mKeyMaster.cleanupProcess((*lock)["dumpdir"].asString());
}
}
}
}
else
{
llwarns << "Discarding corrupted entry from lock table." << llendl;
}
}
}
// <FS:ND> We want this appended right away, or this crash only gets send the next time the crashreporter runs.
// if (rec)
// {
// newlocks.append(rec);
// }
// </FS:ND>
mKeyMaster.putProcessList(newlocks);
return true;
}
void LLCrashLogger::updateApplication(const std::string& message)
@ -600,44 +711,62 @@ bool LLCrashLogger::init()
// Rename current log file to ".old"
std::string old_log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "crashreport.log.old");
std::string log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "crashreport.log");
LLFile::rename(log_file.c_str(), old_log_file.c_str());
#if LL_WINDOWS
LLAPRFile::remove(old_log_file);
#endif
LLFile::rename(log_file.c_str(), old_log_file.c_str());
// Set the log file to crashreport.log
LLError::logToFile(log_file);
mCrashSettings.declareS32("CrashSubmitBehavior", CRASH_BEHAVIOR_ALWAYS_SEND,
LLError::logToFile(log_file); //NOTE: Until this line, LL_INFOS LL_WARNS, etc are blown to the ether.
// Handle locking
bool locked = mKeyMaster.requestMaster(); //Request master locking file. wait time is defaulted to 300S
while (!locked && mKeyMaster.isWaiting())
{
LL_INFOS("CRASHREPORT") << "Waiting for lock." << LL_ENDL;
#if LL_WINDOWS
Sleep(1000);
#else
sleep(1);
#endif
locked = mKeyMaster.checkMaster();
}
if (!locked)
{
LL_WARNS("CRASHREPORT") << "Unable to get master lock. Another crash reporter may be hung." << LL_ENDL;
return false;
}
mCrashSettings.declareS32("CrashSubmitBehavior", CRASH_BEHAVIOR_ALWAYS_SEND,
"Controls behavior when viewer crashes "
"(0 = ask before sending crash report, "
"1 = always send crash report, "
"2 = never send crash report)");
llinfos << "Loading crash behavior setting" << llendl;
mCrashBehavior = loadCrashBehaviorSetting();
// llinfos << "Loading crash behavior setting" << llendl;
// mCrashBehavior = loadCrashBehaviorSetting();
// If user doesn't want to send, bail out
if (mCrashBehavior == CRASH_BEHAVIOR_NEVER_SEND)
{
llinfos << "Crash behavior is never_send, quitting" << llendl;
return false;
}
gServicePump = new LLPumpIO(gAPRPoolp);
gServicePump->prime(gAPRPoolp);
LLHTTPClient::setPump(*gServicePump);
//If we've opened the crash logger, assume we can delete the marker file if it exists
if( gDirUtilp )
{
std::string marker_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
"SecondLife.exec_marker");
LLAPRFile::remove( marker_file );
}
return true;
}
// For cleanup code common to all platforms.
void LLCrashLogger::commonCleanup()
{
LLError::logToFile(""); //close crashreport.log
LLProxy::cleanupClass();
}

13
indra/llcrashlogger/llcrashlogger.h
View File

@ -33,6 +33,7 @@
#include "llapp.h"
#include "llsd.h"
#include "llcontrol.h"
#include "llcrashlock.h"
// [SL:KB] - Patch: Viewer-CrashLookup | Checked: 2011-03-24 (Catznip-2.6.0a) | Added: Catznip-2.6.0a
#include "llcrashlookup.h"
// [/SL:KB]
@ -43,9 +44,13 @@ public:
LLCrashLogger();
virtual ~LLCrashLogger();
S32 loadCrashBehaviorSetting();
bool readDebugFromXML(LLSD& dest, const std::string& filename );
void gatherFiles();
void mergeLogs( LLSD src_sd );
virtual void gatherPlatformSpecificFiles() {}
bool saveCrashBehaviorSetting(S32 crash_behavior);
bool sendCrashLog(std::string dump_dir);
bool sendCrashLogs();
LLSD constructPostData();
virtual void updateApplication(const std::string& message = LLStringUtil::null);
@ -56,10 +61,8 @@ public:
void setUserText(const std::string& text) { mCrashInfo["UserNotes"] = text; }
S32 getCrashBehavior() { return mCrashBehavior; }
bool runCrashLogPost(std::string host, LLSD data, std::string msg, int retries, int timeout);
// [SL:KB] - Patch: Viewer-CrashLookup | Checked: 2011-03-24 (Catznip-2.6.0a) | Added: Catznip-2.6.0a
std::string getCrashInformationLink() { return mCrashLink; }
void setCrashInformationLink(const std::string& strCrashLink) { mCrashLink = strCrashLink; }
// [/SL:KB]
bool readMinidump(std::string minidump_path);
protected:
S32 mCrashBehavior;
BOOL mCrashInPreviousExec;
@ -70,12 +73,12 @@ protected:
LLSD mCrashInfo;
// [SL:KB] - Patch: Viewer-CrashLookup | Checked: 2011-03-24 (Catznip-2.6.0a) | Added: Catznip-2.6.0a
LLCrashLookup* mCrashLookup;
std::string mCrashLink;
// [/SL:KB]
std::string mCrashHost;
std::string mAltCrashHost;
LLSD mDebugLog;
bool mSentCrashLogs;
LLCrashLock mKeyMaster;
};
#endif //LLCRASHLOGGER_H

88
indra/llvfs/lldir.cpp
View File

@ -42,6 +42,7 @@
#include "lldiriterator.h"
#include "stringize.h"
#include <boost/filesystem.hpp>
#include <boost/foreach.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
@ -76,6 +77,7 @@ const char
*LLDir::SKINBASE = "";
static const char* const empty = "";
std::string LLDir::sDumpDir = "";
LLDir::LLDir()
: mAppName(""),
@ -101,7 +103,32 @@ LLDir::~LLDir()
{
}
std::vector<std::string> LLDir::getFilesInDir(const std::string &dirname)
{
//Returns a vector of fullpath filenames.
boost::filesystem::path p (dirname);
std::vector<std::string> v;
if (exists(p))
{
if (is_directory(p))
{
boost::filesystem::directory_iterator end_iter;
for (boost::filesystem::directory_iterator dir_itr(p);
dir_itr != end_iter;
++dir_itr)
{
if (boost::filesystem::is_regular_file(dir_itr->status()))
{
v.push_back(dir_itr->path().filename().string());
}
}
}
}
return v;
}
S32 LLDir::deleteFilesInDir(const std::string &dirname, const std::string &mask)
{
if (!fileExists(dirname)) return 0;
@ -162,6 +189,34 @@ S32 LLDir::deleteFilesInDir(const std::string &dirname, const std::string &mask)
return count;
}
U32 LLDir::deleteDirAndContents(const std::string& dir_name)
{
//Removes the directory and its contents. Returns number of files deleted.
U32 num_deleted = 0;
try
{
boost::filesystem::path dir_path(dir_name);
if (boost::filesystem::exists (dir_path))
{
if (!boost::filesystem::is_empty (dir_path))
{ // Directory has content
num_deleted = boost::filesystem::remove_all (dir_path);
}
else
{ // Directory is empty
boost::filesystem::remove (dir_path);
}
}
}
catch (boost::filesystem::filesystem_error &er)
{
llwarns << "Failed to delete " << dir_name << " with error " << er.code().message() << llendl;
}
return num_deleted;
}
const std::string LLDir::findFile(const std::string &filename,
const std::string& searchPath1,
const std::string& searchPath2,
@ -248,11 +303,36 @@ const std::string &LLDir::getLindenUserDir() const
return mLindenUserDir;
}
const std::string &LLDir::getChatLogsDir() const
const std::string& LLDir::getChatLogsDir() const
{
return mChatLogsDir;
}
void LLDir::setDumpDir( const std::string& path )
{
LLDir::sDumpDir = path;
if (! sDumpDir.empty() && sDumpDir.rbegin() == mDirDelimiter.rbegin() )
{
sDumpDir.erase(sDumpDir.size() -1);
}
}
const std::string &LLDir::getDumpDir() const
{
if (sDumpDir.empty() )
{
LLUUID uid;
uid.generate();
sDumpDir = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "")
+ "dump-" + uid.asString();
dir_exists_or_crash(sDumpDir);
}
return LLDir::sDumpDir;
}
const std::string &LLDir::getPerAccountChatLogsDir() const
{
return mPerAccountChatLogsDir;
@ -461,6 +541,10 @@ std::string LLDir::getExpandedFilename(ELLPath location, const std::string& subd
prefix = getCacheDir();
break;
case LL_PATH_DUMP:
prefix=getDumpDir();
break;
case LL_PATH_USER_SETTINGS:
prefix = add(getOSUserAppDir(), "user_settings");
break;

14
indra/llvfs/lldir.h
View File

@ -53,14 +53,15 @@ typedef enum ELLPath
LL_PATH_EXECUTABLE = 16,
LL_PATH_DEFAULT_SKIN = 17,
LL_PATH_FONTS = 18,
LL_PATH_DUMP = 19,
// [SL:KB] - Patch: Viewer-Skins | mS: 2010-10-19 (Catznip-2.4)
LL_PATH_TOP_SKINTHEME = 19,
LL_PATH_TOP_SKINTHEME = 20,
// [/SL:KB]
// <FS:TT> Firestorm data
LL_PATH_FS_RESOURCES = 20,
LL_PATH_FS_RESOURCES = 21,
// </FS:TT>
// <FS:Ansariel> Sound cache
LL_PATH_FS_SOUND_CACHE = 21,
LL_PATH_FS_SOUND_CACHE = 22,
// </FS:Ansariel>
LL_PATH_LAST
} ELLPath;
@ -80,7 +81,8 @@ class LLDir
const std::string& app_read_only_data_dir = "") = 0;
virtual S32 deleteFilesInDir(const std::string &dirname, const std::string &mask);
U32 deleteDirAndContents(const std::string& dir_name);
std::vector<std::string> getFilesInDir(const std::string &dirname);
// pure virtual functions
virtual U32 countFilesInDir(const std::string &dirname, const std::string &mask) = 0;
@ -130,6 +132,7 @@ class LLDir
const std::string &getOSUserAppDir() const; // Location of the os-specific user app dir
const std::string &getLindenUserDir() const; // Location of the Linden user dir.
const std::string &getChatLogsDir() const; // Location of the chat logs dir.
const std::string &getDumpDir() const; // Location of the per-run dump dir.
const std::string &getPerAccountChatLogsDir() const; // Location of the per account chat logs dir.
const std::string &getTempDir() const; // Common temporary directory
const std::string getCacheDir(bool get_default = false) const; // Location of the cache.
@ -223,6 +226,8 @@ class LLDir
// For producing safe download file names from potentially unsafe ones
static std::string getScrubbedFileName(const std::string uncleanFileName);
static std::string getForbiddenFileChars();
void setDumpDir( const std::string& path );
virtual void setChatLogsDir(const std::string &path); // Set the chat logs dir to this user's dir
// <FS:CR> Seperate user directories per grid on OS build
@ -311,6 +316,7 @@ protected:
std::vector<std::string> mSearchSkinDirs;
std::string mLanguage; // Current viewer language
std::string mLLPluginDir; // Location for plugins and plugin shell
static std::string sDumpDir; // Per-run crash report subdir of log directory.
std::string mUserName; // Current user name
// <FS:Ansariel> Sound cache
std::string mSoundCacheDir; // Sound cache

2
indra/llvfs/lldir_mac.cpp
View File

@ -134,7 +134,7 @@ LLDir_Mac::LLDir_Mac()
{
mOSCacheDir = *cachedir;
//Aura TODO: This changes from ~/Library/Cache/Secondlife to ~/Library/Cache/com.app.secondlife/Secondlife. Last dir level could go away.
//TODO: This changes from ~/Library/Cache/Secondlife to ~/Library/Cache/com.app.secondlife/Secondlife. Last dir level could go away.
CreateDirectory(mOSCacheDir, secondLifeString, NULL);
}

5
indra/llvfs/llpidlock.cpp
View File

@ -274,3 +274,8 @@ void LLPidLock::setSaveName(std::string savename)
{
LLPidLockFile::instance().mSaveName=savename;
}
S32 LLPidLock::getPID()
{
return (S32)getpid();
}

27
indra/llvfs/llpidlock.h
View File

@ -39,21 +39,22 @@ namespace LLPidLock
{
void initClass(); // { (void) LLPidLockFile::instance(); }
bool requestLock( LLNameTable<void *> *name_table=NULL, bool autosave=TRUE,
bool force_immediate=FALSE, F32 timeout=300.0);
bool checkLock();
void releaseLock();
bool isClean();
bool requestLock( LLNameTable<void *> *name_table=NULL, bool autosave=TRUE,
bool force_immediate=FALSE, F32 timeout=300.0);
bool checkLock();
void releaseLock();
bool isClean();
//getters
LLNameTable<void *> * getNameTable();
bool getAutosave();
bool getClean();
std::string getSaveName();
//getters
LLNameTable<void *> * getNameTable();
bool getAutosave();
bool getClean();
std::string getSaveName();
S32 getPID();
//setters
void setClean(bool clean);
void setSaveName(std::string savename);
//setters
void setClean(bool clean);
void setSaveName(std::string savename);
};
#endif // LL_PIDLOCK_H

1
indra/mac_crash_logger/llcrashloggermac.cpp
View File

@ -89,5 +89,6 @@ bool LLCrashLoggerMac::mainLoop()
bool LLCrashLoggerMac::cleanup()
{
commonCleanup();
mKeyMaster.releaseMaster();
return true;
}

11
indra/mac_crash_logger/mac_crash_logger.cpp
View File

@ -27,6 +27,7 @@
#include "linden_common.h"
#include "llcrashloggermac.h"
#include "indra_constants.h"
#include "llpidlock.h"
#include <iostream>
@ -35,6 +36,14 @@ int main(int argc, char **argv)
LLCrashLoggerMac app;
app.parseCommandOptions(argc, argv);
LLSD options = LLApp::instance()->getOptionData(
LLApp::PRIORITY_COMMAND_LINE);
if (!(options.has("pid") && options.has("dumpdir")))
{
llwarns << "Insufficient parameters to crash report." << llendl;
}
if (! app.init())
{
llwarns << "Unable to initialize application." << llendl;
@ -44,9 +53,7 @@ int main(int argc, char **argv)
{
// return NSApplicationMain(argc, (const char **)argv);
}
app.mainLoop();
app.cleanup();
llinfos << "Crash reporter finished normally." << llendl;

2
indra/newview/CMakeLists.txt
View File

@ -1545,6 +1545,8 @@ endif (LEAPMOTION)
if (DARWIN)
LIST(APPEND viewer_SOURCE_FILES llappviewermacosx.cpp)
LIST(APPEND viewer_SOURCE_FILES llappviewermacosx-objc.mm)
LIST(APPEND viewer_SOURCE_FILES llappviewermacosx-objc.h)
LIST(APPEND viewer_SOURCE_FILES llfilepicker_mac.mm)
LIST(APPEND viewer_HEADER_FILES llfilepicker_mac.h)

492
indra/newview/llappviewer.cpp
View File

@ -762,16 +762,36 @@ LLAppViewer::LLAppViewer() :
llerrs << "Oh no! An instance of LLAppViewer already exists! LLAppViewer is sort of like a singleton." << llendl;
}
// setupErrorHandling();
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-12 (Catznip-2.6.0a) | Added: Catznip-2.4.0a
EMiniDumpType minidump_type = MINIDUMP_NORMAL;
if (gSavedSettings.controlExists("SaveMiniDumpType"))
minidump_type = (LLApp::EMiniDumpType)gSavedSettings.getU32("SaveMiniDumpType");
mDumpPath ="";
// Need to do this initialization before we do anything else, since anything
// that touches files should really go through the lldir API
// <FS:ND> Init our custom directories, not from SecondLife
setupErrorHandling(minidump_type);
// [/SL:KB]
// gDirUtilp->initAppDirs("SecondLife");
#ifdef ND_BUILD64BIT_ARCH
gDirUtilp->initAppDirs("Firestorm_x64");
#else
gDirUtilp->initAppDirs("Firestorm");
#endif
// </FS:ND>
//
// IMPORTANT! Do NOT put anything that will write
// into the log files during normal startup until AFTER
// we run the "program crashed last time" error handler below.
//
sInstance = this;
gLoggedInTime.stop();
initLoggingAndGetLastDuration();
processMarkerFiles();
//
// OK to write stuff to logs now, we've now crash reported if necessary
//
LLLoginInstance::instance().setUpdaterService(mUpdater.get());
LLLoginInstance::instance().setPlatformInfo(gPlatform, getOSInfo().getOSVersionString());
@ -785,9 +805,9 @@ LLAppViewer::~LLAppViewer()
LLLoginInstance::instance().setUpdaterService(0);
destroyMainloopTimeout();
// If we got to this destructor somehow, the app didn't hang.
removeMarkerFile();
removeMarkerFiles();
}
class LLUITranslationBridge : public LLTranslationBridge
@ -801,16 +821,23 @@ public:
bool LLAppViewer::init()
{
// <FS:ND> Breakpad merge, setup minidump type from Catznip.
// setupErrorHandling();
EMiniDumpType minidump_type = MINIDUMP_NORMAL;
if (gSavedSettings.controlExists("SaveMiniDumpType"))
minidump_type = (LLApp::EMiniDumpType)gSavedSettings.getU32("SaveMiniDumpType");
setupErrorHandling( minidump_type );
// </FS:ND>
nd::allocstats::startUp(); // <FS:ND/> start collecting alloc stats
nd::mallocstats::startUp(); // <FS:ND/> start collecting alloc stats
//
// Start of the application
//
// IMPORTANT! Do NOT put anything that will write
// into the log files during normal startup until AFTER
// we run the "program crashed last time" error handler below.
//
LLFastTimer::reset();
@ -828,14 +855,7 @@ bool LLAppViewer::init()
//initialize particle index pool
LLVOPartGroup::initClass();
// Need to do this initialization before we do anything else, since anything
// that touches files should really go through the lldir API
#ifdef ND_BUILD64BIT_ARCH
gDirUtilp->initAppDirs("Firestorm_x64");
#else
gDirUtilp->initAppDirs("Firestorm");
#endif
// set skin search path to default, will be overridden later
// this allows simple skinned file lookups to work
@ -844,9 +864,7 @@ bool LLAppViewer::init()
// [/SL:KB]
// gDirUtilp->setSkinFolder("default", "en");
initLoggingAndGetLastDuration();
processMarkerFiles();
// initLoggingAndGetLastDuration();
//
// OK to write stuff to logs now, we've now crash reported if necessary
@ -922,7 +940,6 @@ bool LLAppViewer::init()
LLFile::rmdir(per_user_dir_glob + "browser_profile");
}
// </FS>
init_default_trans_args();
if (!initConfiguration())
@ -935,11 +952,13 @@ bool LLAppViewer::init()
LLCoros::instance().setStackSize(gSavedSettings.getS32("CoroutineStackSize"));
LLPrivateMemoryPoolManager::initClass((BOOL)gSavedSettings.getBOOL("MemoryPrivatePoolEnabled"), (U32)gSavedSettings.getU32("MemoryPrivatePoolSize")*1024*1024) ;
// write Google Breakpad minidump files to our log directory
std::string logdir = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "");
logdir += gDirUtilp->getDirDelimiter();
// write Google Breakpad minidump files to a per-run dump directory to avoid multiple viewer issues.
std::string logdir = gDirUtilp->getExpandedFilename(LL_PATH_DUMP, "");
mDumpPath = logdir;
setMiniDumpDir(logdir);
logdir += gDirUtilp->getDirDelimiter();
setDebugFileNames(logdir);
// Although initLoggingAndGetLastDuration() is the right place to mess with
// setFatalFunction(), we can't query gSavedSettings until after
@ -2079,7 +2098,7 @@ bool LLAppViewer::cleanup()
gAudiop->setStreamingAudioImpl(NULL);
// shut down the audio subsystem
gAudiop->shutdown();
gAudiop->shutdown();
delete gAudiop;
gAudiop = NULL;
@ -2291,8 +2310,6 @@ bool LLAppViewer::cleanup()
// <FS:Ansariel> Sound cache
gDirUtilp->deleteFilesInDir(gDirUtilp->getExpandedFilename(LL_PATH_FS_SOUND_CACHE, ""), "*.*");
}
removeMarkerFile(); // Any crashes from here on we'll just have to ignore
writeDebugInfo();
@ -2449,10 +2466,14 @@ bool LLAppViewer::cleanup()
ll_close_fail_log();
removeMarkerFiles();
MEM_TRACK_RELEASE
llinfos << "Goodbye!" << llendflush;
removeDumpDir();
// return 0;
return true;
}
@ -2577,7 +2598,7 @@ void LLAppViewer::initLoggingAndGetLastDuration()
// Get name of the log file
std::string log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
"Firestorm.log");
/*
/*
* Before touching any log files, compute the duration of the last run
* by comparing the ctime of the previous start marker file with the ctime
* of the last log file.
@ -3047,17 +3068,17 @@ bool LLAppViewer::initConfiguration()
{
llwarns << "Failed --set " << name << ": setting name unknown." << llendl;
}
}
}
}
}
if (clp.hasOption("logevents")) {
LLViewerEventRecorder::instance().setEventLoggingOn();
LLViewerEventRecorder::instance().setEventLoggingOn();
}
std::string CmdLineChannel(gSavedSettings.getString("CmdLineChannel"));
if(! CmdLineChannel.empty())
{
{
LLVersionInfo::resetChannel(CmdLineChannel);
}
@ -3069,16 +3090,16 @@ bool LLAppViewer::initConfiguration()
LLFastTimer::sLog = TRUE;
LLFastTimer::sLogName = std::string("performance");
}
std::string test_name(gSavedSettings.getString("LogMetrics"));
if (! test_name.empty())
{
{
LLFastTimer::sMetricLog = TRUE ;
// '--logmetrics' is specified with a named test metric argument so the data gathering is done only on that test
// In the absence of argument, every metric would be gathered (makes for a rather slow run and hard to decipher report...)
llinfos << "'--logmetrics' argument : " << test_name << llendl;
LLFastTimer::sLogName = test_name;
}
}
if (clp.hasOption("graphicslevel"))
{
@ -3087,14 +3108,14 @@ bool LLAppViewer::initConfiguration()
// that value for validity.
U32 graphicslevel = gSavedSettings.getU32("RenderQualityPerformance");
if (LLFeatureManager::instance().isValidGraphicsLevel(graphicslevel))
{
{
// graphicslevel is valid: save it and engage it later. Capture
// the requested value separately from the settings variable
// because, if this is the first run, LLViewerWindow's constructor
// will call LLFeatureManager::applyRecommendedSettings(), which
// overwrites this settings variable!
mForceGraphicsLevel = graphicslevel;
}
}
}
LLFastTimerView::sAnalyzePerformance = gSavedSettings.getBOOL("AnalyzePerformance");
@ -3133,7 +3154,7 @@ bool LLAppViewer::initConfiguration()
// but rather it belongs into the gridmanager)
std::string CmdLineLoginLocation(gSavedSettings.getString("CmdLineLoginLocation"));
if(! CmdLineLoginLocation.empty())
{
{
start_slurl = CmdLineLoginLocation;
// <FS:Ansariel> FIRE-11586: Restore grid manager workaround (grid is still empty here!)
//LLStartUp::setStartSLURL(start_slurl);
@ -3158,11 +3179,11 @@ bool LLAppViewer::initConfiguration()
//if (sendURLToOtherInstance(start_slurl.getSLURLString()))
if (sendURLToOtherInstance(CmdLineLoginLocation))
// </FS:Ansariel>
{
{
// successfully handed off URL to existing instance, exit
return false;
}
}
}
// <FS:TT> Hacking to save the skin and theme for future use.
@ -3202,19 +3223,6 @@ bool LLAppViewer::initConfiguration()
// <FS:Ansariel> MaxFPS Viewer-Chui merge error
//mYieldTime = gSavedSettings.getS32("YieldTime");
// Read skin/branding settings if specified.
//if (! gDirUtilp->getSkinDir().empty() )
//{
// std::string skin_def_file = gDirUtilp->findSkinnedFilename("skin.xml");
// LLXmlTree skin_def_tree;
// if (!skin_def_tree.parseFile(skin_def_file))
// {
// llerrs << "Failed to parse skin definition." << llendl;
// }
//}
// Display splash screen. Must be after above check for previous
// crash as this dialog is always frontmost.
std::string splash_msg;
@ -3298,10 +3306,6 @@ bool LLAppViewer::initConfiguration()
disable_voice->setValue(LLSD(TRUE), DO_NOT_PERSIST);
}
}
else
{
checkForCrash();
}
// NextLoginLocation is set from the command line option
std::string nextLoginLocation = gSavedSettings.getString( "NextLoginLocation" );
@ -3497,26 +3501,26 @@ namespace {
{
LL_WARNS("UpdaterService") << "no info url supplied - defaulting to hard coded release notes pattern" << LL_ENDL;
// truncate version at the rightmost '.'
std::string version_short(data["version"]);
size_t short_length = version_short.rfind('.');
if (short_length != std::string::npos)
{
version_short.resize(short_length);
}
// truncate version at the rightmost '.'
std::string version_short(data["version"]);
size_t short_length = version_short.rfind('.');
if (short_length != std::string::npos)
{
version_short.resize(short_length);
}
LLUIString relnotes_url("[RELEASE_NOTES_BASE_URL][CHANNEL_URL]/[VERSION_SHORT]");
relnotes_url.setArg("[VERSION_SHORT]", version_short);
LLUIString relnotes_url("[RELEASE_NOTES_BASE_URL][CHANNEL_URL]/[VERSION_SHORT]");
relnotes_url.setArg("[VERSION_SHORT]", version_short);
// *TODO thread the update service's response through to this point
std::string const & channel = LLVersionInfo::getChannel();
boost::shared_ptr<char> channel_escaped(curl_escape(channel.c_str(), channel.size()), &curl_free);
// *TODO thread the update service's response through to this point
std::string const & channel = LLVersionInfo::getChannel();
boost::shared_ptr<char> channel_escaped(curl_escape(channel.c_str(), channel.size()), &curl_free);
relnotes_url.setArg("[CHANNEL_URL]", channel_escaped.get());
relnotes_url.setArg("[RELEASE_NOTES_BASE_URL]", LLTrans::getString("RELEASE_NOTES_BASE_URL"));
relnotes_url.setArg("[CHANNEL_URL]", channel_escaped.get());
relnotes_url.setArg("[RELEASE_NOTES_BASE_URL]", LLTrans::getString("RELEASE_NOTES_BASE_URL"));
substitutions["INFO_URL"] = relnotes_url.getString();
}
LLNotificationsUtil::add(notification_name, substitutions, LLSD(), apply_callback);
}
@ -3616,19 +3620,6 @@ void LLAppViewer::initUpdater()
updater_pump.listen("notify_update", &notify_update);
}
void LLAppViewer::checkForCrash(void)
{
#if LL_SEND_CRASH_REPORTS
if (gLastExecEvent == LAST_EXEC_FROZE)
{
llinfos << "Last execution froze, sending a crash report." << llendl;
bool report_freeze = true;
handleCrashReporting(report_freeze);
}
#endif // LL_SEND_CRASH_REPORTS
}
//
// This function decides whether the client machine meets the minimum requirements to
// run in a maximized window, per the consensus of davep, boa and nyx on 3/30/2011.
@ -3717,7 +3708,7 @@ bool LLAppViewer::initWindow()
LLFeatureManager::getInstance()->setGraphicsLevel(*mForceGraphicsLevel, false);
gSavedSettings.setU32("RenderQualityPerformance", *mForceGraphicsLevel);
}
// Set this flag in case we crash while initializing GL
gSavedSettings.setBOOL("RenderInitError", TRUE);
gSavedSettings.saveToFile( gSavedSettings.getString("ClientSettingsFile"), TRUE );
@ -3767,12 +3758,21 @@ bool LLAppViewer::initWindow()
return true;
}
void LLAppViewer::writeDebugInfo()
void LLAppViewer::writeDebugInfo(bool isStatic)
{
std::string debug_filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"debug_info.log");
llinfos << "Opening debug file " << debug_filename << llendl;
llofstream out_file(debug_filename);
LLSDSerialize::toPrettyXML(gDebugInfo, out_file);
//Try to do the minimum when writing data during a crash.
std::string* debug_filename;
debug_filename = ( isStatic
? getStaticDebugFile()
: getDynamicDebugFile() );
llinfos << "Opening debug file " << *debug_filename << llendl;
llofstream out_file(*debug_filename);
isStatic ? LLSDSerialize::toPrettyXML(gDebugInfo, out_file)
: LLSDSerialize::toPrettyXML(gDebugInfo["Dynamic"], out_file);
out_file.close();
}
@ -4054,7 +4054,6 @@ std::string LLAppViewer::getViewerInfoString() const
return support.str();
}
void LLAppViewer::cleanupSavedSettings()
{
gSavedSettings.setBOOL("MouseSun", FALSE);
@ -4103,7 +4102,25 @@ void LLAppViewer::removeCacheFiles(const std::string& file_mask)
void LLAppViewer::writeSystemInfo()
{
gDebugInfo["SLLog"] = LLError::logFileName();
if (! gDebugInfo.has("Dynamic") )
gDebugInfo["Dynamic"] = LLSD::emptyMap();
// <FS:ND> set filename to Firestorm.log
// #if LL_WINDOWS
// gDebugInfo["SLLog"] = gDirUtilp->getExpandedFilename(LL_PATH_DUMP,"SecondLife.log");
// #else
// //Not ideal but sufficient for good reporting.
// gDebugInfo["SLLog"] = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"SecondLife.old"); //LLError::logFileName();
// #endif
#if LL_WINDOWS
gDebugInfo["SLLog"] = gDirUtilp->getExpandedFilename(LL_PATH_DUMP,"Firestorm.log");
#else
//Not ideal but sufficient for good reporting.
gDebugInfo["SLLog"] = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"Firestorm.old"); //LLError::logFileName();
#endif
// </FS:ND>
gDebugInfo["ClientInfo"]["Name"] = LLVersionInfo::getChannel();
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2011-05-08 (Catznip-2.6.0a) | Added: Catznip-2.6.0a
@ -4179,9 +4196,60 @@ void LLAppViewer::writeSystemInfo()
LL_INFOS("SystemInfo") << "OS: " << getOSInfo().getOSStringSimple() << LL_ENDL;
LL_INFOS("SystemInfo") << "OS info: " << getOSInfo() << LL_ENDL;
// <FS:ND> Breakpad merge. Only include SettingsFile if the user selected this in prefs. Path from Catznip
// gDebugInfo["SettingsFilename"] = gSavedSettings.getString("ClientSettingsFile");
if (gCrashSettings.getBOOL("CrashSubmitSettings"))
gDebugInfo["SettingsFilename"] = gSavedSettings.getString("ClientSettingsFile");
// </FS:ND>
gDebugInfo["ViewerExePath"] = gDirUtilp->getExecutablePathAndName();
gDebugInfo["CurrentPath"] = gDirUtilp->getCurPath();
gDebugInfo["FirstLogin"] = (LLSD::Boolean) gAgent.isFirstLogin();
gDebugInfo["FirstRunThisInstall"] = gSavedSettings.getBOOL("FirstRunThisInstall");
gDebugInfo["StartupState"] = LLStartUp::getStartupStateString();
writeDebugInfo(); // Save out debug_info.log early, in case of crash.
}
#ifdef LL_WINDOWS
//For whatever reason, in Windows when using OOP server for breakpad, the callback to get the
//name of the dump file is not getting triggered by the breakpad library. Unfortunately they
//also didn't see fit to provide a simple query request across the pipe to get this name either.
//Since we are putting our output in a runtime generated directory and we know the header data in
//the dump format, we can however use the following hack to identify our file.
// TODO make this a member function.
void getFileList()
{
std::stringstream filenames;
typedef std::vector<std::string> vec;
std::string pathname = gDirUtilp->getExpandedFilename(LL_PATH_DUMP,"");
vec file_vec = gDirUtilp->getFilesInDir(pathname);
for(vec::const_iterator iter=file_vec.begin(); iter!=file_vec.end(); ++iter)
{
filenames << *iter << " ";
if ( ( iter->length() > 30 ) && (iter->rfind(".dmp") == (iter->length()-4) ) )
{
std::string fullname = pathname + *iter;
std::ifstream fdat( fullname.c_str(), std::ifstream::binary);
if (fdat)
{
char buf[5];
fdat.read(buf,4);
fdat.close();
if (!strncmp(buf,"MDMP",4))
{
gDebugInfo["Dynamic"]["MinidumpPath"] = fullname;
break;
}
}
}
}
filenames << std::endl;
gDebugInfo["Dynamic"]["DumpDirContents"] = filenames.str();
}
#endif
void LLAppViewer::handleViewerCrash()
{
llinfos << "Handle viewer crash entry." << llendl;
@ -4217,99 +4285,51 @@ void LLAppViewer::handleViewerCrash()
std::string crashHostUrl = gSavedSettings.get<std::string>("CrashHostUrl");
if(crashHostUrl != "")
{
gDebugInfo["CrashHostUrl"] = crashHostUrl;
gDebugInfo["Dynamic"]["CrashHostUrl"] = crashHostUrl;
}
//We already do this in writeSystemInfo(), but we do it again here to make /sure/ we have a version
//to check against no matter what
gDebugInfo["ClientInfo"]["Name"] = LLVersionInfo::getChannel();
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2011-05-08 (Catznip-2.6.0a) | Added: Catznip-2.6.0a
gDebugInfo["ClientInfo"]["Version"] = LLVersionInfo::getVersion();
gDebugInfo["ClientInfo"]["Platform"] = LLVersionInfo::getBuildPlatform();
// [/SL:KB]
gDebugInfo["ClientInfo"]["MajorVersion"] = LLVersionInfo::getMajor();
gDebugInfo["ClientInfo"]["MinorVersion"] = LLVersionInfo::getMinor();
gDebugInfo["ClientInfo"]["PatchVersion"] = LLVersionInfo::getPatch();
gDebugInfo["ClientInfo"]["BuildVersion"] = LLVersionInfo::getBuild();
// <FS:ND> Add which flavor of FS generated an error
#ifdef OPENSIM
gDebugInfo["ClientInfo"]["Flavor"] = "oss";
#else
gDebugInfo["ClientInfo"]["Flavor"] = "hvk";
#endif
// </FS:ND>
/*
LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
if ( parcel && parcel->getMusicURL()[0])
{
gDebugInfo["ParcelMusicURL"] = parcel->getMusicURL();
gDebugInfo["Dynamic"]["ParcelMusicURL"] = parcel->getMusicURL();
}
if ( parcel && parcel->getMediaURL()[0])
{
gDebugInfo["ParcelMediaURL"] = parcel->getMediaURL();
gDebugInfo["Dynamic"]["ParcelMediaURL"] = parcel->getMediaURL();
}
*/
// gDebugInfo["SettingsFilename"] = gSavedSettings.getString("ClientSettingsFile");
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-16 (Catznip-2.6.0a) | Added: Catznip-2.4.0b
if (gCrashSettings.getBOOL("CrashSubmitSettings"))
{
// Only include settings.xml if the user consented
gDebugInfo["SettingsFilename"] = gSavedSettings.getString("ClientSettingsFile");
}
// [/SL:KB]
// gDebugInfo["CAFilename"] = gDirUtilp->getCAFile();
// gDebugInfo["ViewerExePath"] = gDirUtilp->getExecutablePathAndName();
// gDebugInfo["CurrentPath"] = gDirUtilp->getCurPath();
gDebugInfo["SessionLength"] = F32(LLFrameTimer::getElapsedSeconds());
gDebugInfo["StartupState"] = LLStartUp::getStartupStateString();
gDebugInfo["RAMInfo"]["Allocated"] = (LLSD::Integer) LLMemory::getCurrentRSS() >> 10;
gDebugInfo["FirstLogin"] = (LLSD::Boolean) gAgent.isFirstLogin();
gDebugInfo["FirstRunThisInstall"] = gSavedSettings.getBOOL("FirstRunThisInstall");
char *minidump_file = pApp->getMiniDumpFilename();
if(minidump_file && minidump_file[0] != 0)
{
gDebugInfo["MinidumpPath"] = minidump_file;
}
gDebugInfo["Dynamic"]["SessionLength"] = F32(LLFrameTimer::getElapsedSeconds());
gDebugInfo["Dynamic"]["RAMInfo"]["Allocated"] = (LLSD::Integer) LLMemory::getCurrentRSS() >> 10;
if(gLogoutInProgress)
{
gDebugInfo["LastExecEvent"] = LAST_EXEC_LOGOUT_CRASH;
gDebugInfo["Dynamic"]["LastExecEvent"] = LAST_EXEC_LOGOUT_CRASH;
}
else
{
gDebugInfo["LastExecEvent"] = gLLErrorActivated ? LAST_EXEC_LLERROR_CRASH : LAST_EXEC_OTHER_CRASH;
gDebugInfo["Dynamic"]["LastExecEvent"] = gLLErrorActivated ? LAST_EXEC_LLERROR_CRASH : LAST_EXEC_OTHER_CRASH;
}
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-14 (Catznip-2.6.0a) | Added: Catznip-2.4.0a
// Current host and region would expose too much information, but do track the last server version
gDebugInfo["LastVersionChannel"] = gLastVersionChannel;
// [/SL:KB]
/*
if(gAgent.getRegion())
{
gDebugInfo["CurrentSimHost"] = gAgent.getRegionHost().getHostName();
gDebugInfo["CurrentRegion"] = gAgent.getRegion()->getName();
gDebugInfo["Dynamic"]["CurrentSimHost"] = gAgent.getRegionHost().getHostName();
gDebugInfo["Dynamic"]["CurrentRegion"] = gAgent.getRegion()->getName();
const LLVector3& loc = gAgent.getPositionAgent();
gDebugInfo["CurrentLocationX"] = loc.mV[0];
gDebugInfo["CurrentLocationY"] = loc.mV[1];
gDebugInfo["CurrentLocationZ"] = loc.mV[2];
gDebugInfo["Dynamic"]["CurrentLocationX"] = loc.mV[0];
gDebugInfo["Dynamic"]["CurrentLocationY"] = loc.mV[1];
gDebugInfo["Dynamic"]["CurrentLocationZ"] = loc.mV[2];
}
*/
if(LLAppViewer::instance()->mMainloopTimeout)
{
gDebugInfo["MainloopTimeoutState"] = LLAppViewer::instance()->mMainloopTimeout->getState();
gDebugInfo["Dynamic"]["MainloopTimeoutState"] = LLAppViewer::instance()->mMainloopTimeout->getState();
}
// The crash is being handled here so set this value to false.
// Otherwise the crash logger will think this crash was a freeze.
gDebugInfo["CrashNotHandled"] = (LLSD::Boolean)false;
gDebugInfo["Dynamic"]["CrashNotHandled"] = (LLSD::Boolean)false;
//Write out the crash status file
//Use marker file style setup, as that's the simplest, especially since
@ -4317,9 +4337,9 @@ void LLAppViewer::handleViewerCrash()
if (gDirUtilp)
{
std::string crash_marker_file_name = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
gLLErrorActivated
? LLERROR_MARKER_FILE_NAME
: ERROR_MARKER_FILE_NAME);
gLLErrorActivated
? LLERROR_MARKER_FILE_NAME
: ERROR_MARKER_FILE_NAME);
LLAPRFile crash_marker_file ;
crash_marker_file.open(crash_marker_file_name, LL_APR_WB);
if (crash_marker_file.getFileHandle())
@ -4330,17 +4350,35 @@ void LLAppViewer::handleViewerCrash()
else
{
LL_WARNS("MarkerFile") << "Cannot create error marker file " << crash_marker_file_name << LL_ENDL;
}
}
}
else
{
LL_WARNS("MarkerFile") << "No gDirUtilp with which to create error marker file name" << LL_ENDL;
}
#ifdef LL_WINDOWS
Sleep(200);
#endif
char *minidump_file = pApp->getMiniDumpFilename();
if(minidump_file && minidump_file[0] != 0)
{
gDebugInfo["Dynamic"]["MinidumpPath"] = minidump_file;
}
#ifdef LL_WINDOWS
else
{
getFileList();
}
#endif
gDebugInfo["Dynamic"]["CrashType"]="crash";
if (gMessageSystem && gDirUtilp)
{
std::string filename;
filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "stats.log");
filename = gDirUtilp->getExpandedFilename(LL_PATH_DUMP, "stats.log");
llofstream file(filename, llofstream::binary);
if(file.good())
{
@ -4356,29 +4394,10 @@ void LLAppViewer::handleViewerCrash()
gMessageSystem->stopLogging();
}
// if (LLWorld::instanceExists()) LLWorld::getInstance()->getInfo(gDebugInfo);
if (LLWorld::instanceExists()) LLWorld::getInstance()->getInfo(gDebugInfo["Dynamic"]);
// Close the debug file
pApp->writeDebugInfo();
LLError::logToFile("");
// Remove the marker file, since otherwise we'll spawn a process that'll keep it locked
if(gDebugInfo["LastExecEvent"].asInteger() == LAST_EXEC_LOGOUT_CRASH)
{
pApp->removeMarkerFile(true);
}
else
{
pApp->removeMarkerFile(false);
}
#if LL_SEND_CRASH_REPORTS
// Call to pure virtual, handled by platform specific llappviewer instance.
pApp->handleCrashReporting();
#endif
return;
pApp->writeDebugInfo(false); //false answers the isStatic question with the least overhead.
}
// static
@ -4475,7 +4494,7 @@ void LLAppViewer::processMarkerFiles()
}
if (mSecondInstance)
{
{
LL_INFOS("MarkerFile") << "Exec marker '"<< mMarkerFileName << "' owned by another instance" << LL_ENDL;
}
else if (marker_is_same_version)
@ -4489,7 +4508,7 @@ void LLAppViewer::processMarkerFiles()
{
LL_INFOS("MarkerFile") << "Exec marker '"<< mMarkerFileName << "' found, but versions did not match" << LL_ENDL;
}
}
}
else // marker did not exist... last exec (if any) did not freeze
{
// Create the marker file for this execution & lock it; it will be deleted on a clean exit
@ -4543,12 +4562,12 @@ void LLAppViewer::processMarkerFiles()
{
gLastExecEvent = LAST_EXEC_LOGOUT_CRASH;
LL_INFOS("MarkerFile") << "LLError marker '"<< llerror_marker_file << "' crashed, setting LastExecEvent to LOGOUT_CRASH" << LL_ENDL;
}
else
{
}
else
{
gLastExecEvent = LAST_EXEC_LLERROR_CRASH;
LL_INFOS("MarkerFile") << "LLError marker '"<< llerror_marker_file << "' crashed, setting LastExecEvent to LLERROR_CRASH" << LL_ENDL;
}
}
}
else
{
@ -4561,54 +4580,51 @@ void LLAppViewer::processMarkerFiles()
if(LLAPRFile::isExist(error_marker_file, NULL, LL_APR_RB))
{
if (markerIsSameVersion(error_marker_file))
{
if (gLastExecEvent == LAST_EXEC_LOGOUT_FROZE)
{
if (gLastExecEvent == LAST_EXEC_LOGOUT_FROZE)
{
gLastExecEvent = LAST_EXEC_LOGOUT_CRASH;
LL_INFOS("MarkerFile") << "Error marker '"<< error_marker_file << "' crashed, setting LastExecEvent to LOGOUT_CRASH" << LL_ENDL;
}
else
{
gLastExecEvent = LAST_EXEC_OTHER_CRASH;
LL_INFOS("MarkerFile") << "Error marker '"<< error_marker_file << "' crashed, setting LastExecEvent to " << gLastExecEvent << LL_ENDL;
}
}
else
{
gLastExecEvent = LAST_EXEC_OTHER_CRASH;
LL_INFOS("MarkerFile") << "Error marker '"<< error_marker_file << "' crashed, setting LastExecEvent to " << gLastExecEvent << LL_ENDL;
}
}
else
{
LL_INFOS("MarkerFile") << "Error marker '"<< error_marker_file << "' marker found, but versions did not match" << LL_ENDL;
}
LLAPRFile::remove(error_marker_file);
}
}
void LLAppViewer::removeMarkerFile(bool leave_logout_marker)
void LLAppViewer::removeMarkerFiles()
{
if (!mSecondInstance)
{
LL_DEBUGS("MarkerFile") << (leave_logout_marker?"leave":"remove") <<" logout" << LL_ENDL;
if (mMarkerFile.getFileHandle())
{
LL_DEBUGS("MarkerFile") << "removing exec marker '"<<mMarkerFileName<<"'"<< LL_ENDL;
mMarkerFile.close() ;
LLAPRFile::remove( mMarkerFileName );
}
else
{
LL_WARNS("MarkerFile") << "marker '"<<mMarkerFileName<<"' not open"<< LL_ENDL;
}
if (!leave_logout_marker)
{
if (mLogoutMarkerFile.getFileHandle())
if (mMarkerFile.getFileHandle())
{
LL_DEBUGS("MarkerFile") << "removing logout marker '"<<mLogoutMarkerFileName<<"'"<< LL_ENDL;
mLogoutMarkerFile.close();
mMarkerFile.close() ;
LLAPRFile::remove( mMarkerFileName );
LL_DEBUGS("MarkerFile") << "removed exec marker '"<<mMarkerFileName<<"'"<< LL_ENDL;
}
else
{
LL_WARNS("MarkerFile") << "logout marker '"<<mLogoutMarkerFileName<<"' not open"<< LL_ENDL;
LL_WARNS("MarkerFile") << "marker '"<<mMarkerFileName<<"' not open"<< LL_ENDL;
}
if (mLogoutMarkerFile.getFileHandle())
{
mLogoutMarkerFile.close();
LLAPRFile::remove( mLogoutMarkerFileName );
LL_DEBUGS("MarkerFile") << "removed logout marker '"<<mLogoutMarkerFileName<<"'"<< LL_ENDL;
}
else
{
LL_WARNS("MarkerFile") << "logout marker '"<<mLogoutMarkerFileName<<"' not open"<< LL_ENDL;
}
LLAPRFile::remove( mLogoutMarkerFileName );
}
}
else
{
@ -4616,6 +4632,14 @@ void LLAppViewer::removeMarkerFile(bool leave_logout_marker)
}
}
void LLAppViewer::removeDumpDir()
{
//Call this routine only on clean exit. Crash reporter will clean up
//its locking table for us.
std::string dump_dir = gDirUtilp->getExpandedFilename(LL_PATH_DUMP, "");
gDirUtilp->deleteDirAndContents(dump_dir);
}
void LLAppViewer::forceQuit()
{
LLApp::setQuitting();
@ -4633,7 +4657,7 @@ void LLAppViewer::fastQuit(S32 error_code)
// figure out the error code
S32 final_error_code = error_code ? error_code : (S32)isError();
// this isn't a crash
removeMarkerFile();
removeMarkerFiles();
// get outta here
_exit(final_error_code);
}
@ -5918,20 +5942,26 @@ void LLAppViewer::sendLogoutRequest()
{
//Set internal status variables and marker files before actually starting the logout process
gLogoutInProgress = TRUE;
mLogoutMarkerFileName = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,LOGOUT_MARKER_FILE_NAME);
LLAPRFile outfile ;
mLogoutMarkerFile.open(mLogoutMarkerFileName, LL_APR_WB);
if (mLogoutMarkerFile.getFileHandle())
if (!mSecondInstance)
{
LL_INFOS("MarkerFile") << "Created logout marker file '"<< mLogoutMarkerFileName << "' " << LL_ENDL;
recordMarkerVersion(outfile);
mLogoutMarkerFileName = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,LOGOUT_MARKER_FILE_NAME);
mLogoutMarkerFile.open(mLogoutMarkerFileName, LL_APR_WB);
if (mLogoutMarkerFile.getFileHandle())
{
LL_INFOS("MarkerFile") << "Created logout marker file '"<< mLogoutMarkerFileName << "' " << LL_ENDL;
recordMarkerVersion(mLogoutMarkerFile);
}
else
{
LL_WARNS("MarkerFile") << "Cannot create logout marker file " << mLogoutMarkerFileName << LL_ENDL;
}
}
else
{
LL_WARNS("MarkerFile") << "Cannot create logout marker file " << mLogoutMarkerFileName << LL_ENDL;
}
LL_INFOS("MarkerFile") << "Did not logout marker file because this is a second instance" << LL_ENDL;
}
LLMessageSystem* msg = gMessageSystem;
msg->newMessageFast(_PREHASH_LogoutRequest);
msg->nextBlockFast(_PREHASH_AgentData);
@ -6351,7 +6381,6 @@ void LLAppViewer::handleLoginComplete()
#endif
// </FS:ND>
/*
LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
if ( parcel && parcel->getMusicURL()[0])
{
@ -6361,7 +6390,6 @@ void LLAppViewer::handleLoginComplete()
{
gDebugInfo["ParcelMediaURL"] = parcel->getMediaURL();
}
*/
// gDebugInfo["SettingsFilename"] = gSavedSettings.getString("ClientSettingsFile");
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-16 (Catznip-2.6.0a) | Added: Catznip-2.4.0b
@ -6503,7 +6531,7 @@ void LLAppViewer::launchUpdater()
LL_DEBUGS("AppInit") << "Calling updater: " << LLAppViewer::sUpdaterInfo->mUpdateExePath << " " << LLAppViewer::sUpdaterInfo->mParams.str() << LL_ENDL;
//Explicitly remove the marker file, otherwise we pass the lock onto the child process and things get weird.
LLAppViewer::instance()->removeMarkerFile(); // In case updater fails
LLAppViewer::instance()->removeMarkerFiles(); // In case updater fails
// *NOTE:Mani The updater is spawned as the last thing before the WinMain exit.
// see LLAppViewerWin32.cpp

8
indra/newview/llappviewer.h
View File

@ -47,7 +47,6 @@ class LLLeapMotionController; // [FS:CR]
extern LLFastTimer::DeclareTimer FTM_FRAME;
class LLAppViewer : public LLApp
{
public:
@ -83,7 +82,7 @@ public:
bool quitRequested() { return mQuitRequested; }
bool logoutRequestSent() { return mLogoutRequestSent; }
void writeDebugInfo();
void writeDebugInfo(bool isStatic=true);
const LLOSInfo& getOSInfo() const { return mSysOSInfo; }
@ -96,7 +95,7 @@ public:
virtual bool restoreErrorTrap() = 0; // Require platform specific override to reset error handling mechanism.
// return false if the error trap needed restoration.
virtual void handleCrashReporting(bool reportFreeze = false) = 0; // What to do with crash report?
virtual void initCrashReporting(bool reportFreeze = false) = 0; // What to do with crash report?
static void handleViewerCrash(); // Hey! The viewer crashed. Do this, soon.
void checkForCrash();
@ -124,8 +123,9 @@ public:
void loadNameCache();
void saveNameCache();
void removeMarkerFile(bool leave_logout_marker = false);
void removeMarkerFiles();
void removeDumpDir();
// LLAppViewer testing helpers.
// *NOTE: These will potentially crash the viewer. Only for debugging.
virtual void forceErrorLLError();

112
indra/newview/llappviewerlinux.cpp
View File

@ -58,12 +58,15 @@ namespace
void (*gOldTerminateHandler)() = NULL;
}
static void exceptionTerminateHandler()
{
// reinstall default terminate() handler in case we re-terminate.
if (gOldTerminateHandler) std::set_terminate(gOldTerminateHandler);
// treat this like a regular viewer crash, with nice stacktrace etc.
LLAppViewer::handleViewerCrash();
long *null_ptr;
null_ptr = 0;
*null_ptr = 0xDEADBEEF; //Force an exception that will trigger breakpad.
// we've probably been killed-off before now, but...
gOldTerminateHandler(); // call old terminate() handler
}
@ -130,7 +133,17 @@ bool LLAppViewerLinux::init()
if (!g_thread_supported ()) g_thread_init (NULL);
#endif
return LLAppViewer::init();
bool success = LLAppViewer::init();
#if LL_SEND_CRASH_REPORTS
if (success)
{
LLAppViewer* pApp = LLAppViewer::instance();
pApp->initCrashReporting();
}
#endif
return success;
}
bool LLAppViewerLinux::restoreErrorTrap()
@ -335,7 +348,7 @@ bool LLAppViewerLinux::sendURLToOtherInstance(const std::string& url)
}
#endif // LL_DBUS_ENABLED
void LLAppViewerLinux::handleCrashReporting(bool reportFreeze)
void LLAppViewerLinux::initCrashReporting(bool reportFreeze)
{
std::string cmd =gDirUtilp->getExecutableDir();
cmd += gDirUtilp->getDirDelimiter();
@ -347,69 +360,52 @@ void LLAppViewerLinux::handleCrashReporting(bool reportFreeze)
# error Unknown platform
#endif
if(reportFreeze)
{
char* const cmdargv[] =
{(char*)cmd.c_str(),
(char*)"-previous",
NULL};
std::stringstream pid_str;
pid_str << LLApp::getPid();
std::string logdir = gDirUtilp->getExpandedFilename(LL_PATH_DUMP, "");
std::string appname = gDirUtilp->getExecutableFilename();
// launch the actual crash logger
const char * cmdargv[] =
{cmd.c_str(),
"-user",
(char*)LLGridManager::getInstance()->getGridId().c_str(),
"-name",
LLAppViewer::instance()->getSecondLifeTitle().c_str(),
"-pid",
pid_str.str().c_str(),
"-dumpdir",
logdir.c_str(),
"-procname",
appname.c_str(),
NULL};
fflush(NULL);
fflush(NULL); // flush all buffers before the child inherits them
pid_t pid = fork();
if (pid == 0)
{ // child
execv(cmd.c_str(), cmdargv); /* Flawfinder: Ignore */
llwarns << "execv failure when trying to start " << cmd << llendl;
_exit(1); // avoid atexit()
} else {
if (pid > 0)
{
// wait for child proc to die
int childExitStatus;
waitpid(pid, &childExitStatus, 0);
} else {
llwarns << "fork failure." << llendl;
}
}
}
pid_t pid = fork();
if (pid == 0)
{ // child
execv(cmd.c_str(), (char* const*) cmdargv); /* Flawfinder: ignore */
llwarns << "execv failure when trying to start " << cmd << llendl;
_exit(1); // avoid atexit()
}
else
{
// launch the actual crash logger
const char * cmdargv[] =
{cmd.c_str(),
"-user",
(char*)LLGridManager::getInstance()->getGridId().c_str(),
"-name",
LLAppViewer::instance()->getSecondLifeTitle().c_str(),
NULL};
fflush(NULL);
pid_t pid = fork();
if (pid == 0)
{ // child
execv(cmd.c_str(), (char* const*) cmdargv); /* Flawfinder: ignore */
llwarns << "execv failure when trying to start " << cmd << llendl;
_exit(1); // avoid atexit()
if (pid > 0)
{
// DO NOT wait for child proc to die; we want
// the logger to outlive us while we quit to
// free up the screen/keyboard/etc.
////int childExitStatus;
////waitpid(pid, &childExitStatus, 0);
}
else
{
if (pid > 0)
{
// DO NOT wait for child proc to die; we want
// the logger to outlive us while we quit to
// free up the screen/keyboard/etc.
////int childExitStatus;
////waitpid(pid, &childExitStatus, 0);
}
else
{
llwarns << "fork failure." << llendl;
}
llwarns << "fork failure." << llendl;
}
// Sometimes signals don't seem to quit the viewer. Also, we may
// have been called explicitly instead of from a signal handler.
// Make sure we exit so as to not totally confuse the user.
_exit(1); // avoid atexit(), else we may re-crash in dtors.
}
// Sometimes signals don't seem to quit the viewer. Also, we may
// have been called explicitly instead of from a signal handler.
// Make sure we exit so as to not totally confuse the user.
//_exit(1); // avoid atexit(), else we may re-crash in dtors.
}
bool LLAppViewerLinux::beingDebugged()

2
indra/newview/llappviewerlinux.h
View File

@ -61,7 +61,7 @@ protected:
virtual bool beingDebugged();
virtual bool restoreErrorTrap();
virtual void handleCrashReporting(bool reportFreeze);
virtual void initCrashReporting(bool reportFreeze);
virtual void initLoggingAndGetLastDuration();
virtual bool initParseCommandLine(LLCommandLineParser& clp);

36
indra/newview/llappviewermacosx-objc.h Normal file
View File

@ -0,0 +1,36 @@
/**
* @file llappviewermacosx.h
* @brief The LLAppViewerMacOSX class declaration
*
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#ifndef LL_LLAPPVIEWERMACOSX_OBJC_H
#define LL_LLAPPVIEWERMACOSX_OBJC_H
#include <string>
#include <vector>
//Why? Because BOOL
void launchApplication(const std::string* app_name, const std::vector<std::string>* args);
#endif // LL_LLAPPVIEWERMACOSX_OBJC_H

73
indra/newview/llappviewermacosx-objc.mm Normal file
View File

@ -0,0 +1,73 @@
/**
* @file llappviewermacosx-objc.mm
* @brief Functions related to LLAppViewerMacOSX that must be expressed in obj-c
*
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#if !defined LL_DARWIN
#error "Use only with Mac OS X"
#endif
#import <Cocoa/Cocoa.h>
#include <iostream>
#include "llappviewermacosx-objc.h"
void launchApplication(const std::string* app_name, const std::vector<std::string>* args)
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
if (app_name->empty()) return;
NSMutableString* app_name_ns = [NSMutableString stringWithString:[[NSBundle mainBundle] resourcePath]]; //Path to resource dir
[app_name_ns appendFormat:@"/%@", [NSString stringWithCString:app_name->c_str()
encoding:[NSString defaultCStringEncoding]]];
NSMutableArray *args_ns = nil;
args_ns = [[NSMutableArray alloc] init];
for (int i=0; i < args->size(); ++i)
{
NSLog(@"Adding string %s", (*args)[i].c_str());
[args_ns addObject:
[NSString stringWithCString:(*args)[i].c_str()
encoding:[NSString defaultCStringEncoding]]];
}
NSTask *task = [[NSTask alloc] init];
NSBundle *bundle = [NSBundle bundleWithPath:[[NSWorkspace sharedWorkspace] fullPathForApplication:app_name_ns]];
[task setLaunchPath:[bundle executablePath]];
[task setArguments:args_ns];
[task launch];
// NSWorkspace *workspace = [NSWorkspace sharedWorkspace];
// NSURL *url = [NSURL fileURLWithPath:[workspace fullPathForApplication:app_name_ns]];
//
// NSError *error = nil;
// [workspace launchApplicationAtURL:url options:0 configuration:[NSDictionary dictionaryWithObject:args_ns forKey:NSWorkspaceLaunchConfigurationArguments] error:&error];
//TODO Handle error
[pool release];
return;
}

183
indra/newview/llappviewermacosx.cpp
View File

@ -32,6 +32,9 @@
#define LL_CARBON_CRASH_HANDLER 1
#include "llwindowmacosx.h"
#include "llappviewermacosx-objc.h"
#include "llappviewermacosx.h"
#include "llwindowmacosx-objc.h"
#include "llcommandlineparser.h"
@ -45,6 +48,9 @@
#ifdef LL_CARBON_CRASH_HANDLER
#include <Carbon/Carbon.h>
#endif
#include <vector>
#include <exception>
#include "lldir.h"
#include <signal.h>
#include <CoreAudio/CoreAudio.h> // for systemwide mute
@ -56,7 +62,6 @@ namespace
// They are not used immediately by the app.
int gArgC;
char** gArgV;
bool sCrashReporterIsRunning = false;
LLAppViewerMacOSX* gViewerAppPtr;
#ifdef LL_CARBON_CRASH_HANDLER
OSErr AEQuitHandler(const AppleEvent *messagein, AppleEvent *reply, long refIn)
@ -68,6 +73,20 @@ namespace
return(result);
}
#endif
void (*gOldTerminateHandler)() = NULL;
}
static void exceptionTerminateHandler()
{
// reinstall default terminate() handler in case we re-terminate.
if (gOldTerminateHandler) std::set_terminate(gOldTerminateHandler);
// treat this like a regular viewer crash, with nice stacktrace etc.
long *null_ptr;
null_ptr = 0;
*null_ptr = 0xDEADBEEF; //Force an exception that will trigger breakpad.
//LLAppViewer::handleViewerCrash();
// we've probably been killed-off before now, but...
gOldTerminateHandler(); // call old terminate() handler
}
bool initViewer()
@ -83,19 +102,21 @@ bool initViewer()
<< gDirUtilp->getAppRODataDir() << ": " << strerror(errno)
<< llendl;
}
gViewerAppPtr = new LLAppViewerMacOSX();
// install unexpected exception handler
gOldTerminateHandler = std::set_terminate(exceptionTerminateHandler);
gViewerAppPtr->setErrorHandler(LLAppViewer::handleViewerCrash);
bool ok = gViewerAppPtr->init();
if(!ok)
{
llwarns << "Application init failed." << llendl;
}
return ok;
}
@ -121,7 +142,8 @@ void cleanupViewer()
{
if(!LLApp::isError())
{
gViewerAppPtr->cleanup();
if (gViewerAppPtr)
gViewerAppPtr->cleanup();
}
delete gViewerAppPtr;
@ -146,7 +168,17 @@ LLAppViewerMacOSX::~LLAppViewerMacOSX()
bool LLAppViewerMacOSX::init()
{
return LLAppViewer::init();
bool success = LLAppViewer::init();
#if LL_SEND_CRASH_REPORTS
if (success)
{
LLAppViewer* pApp = LLAppViewer::instance();
pApp->initCrashReporting();
}
#endif
return success;
}
// MacOSX may add and addition command line arguement for the process serial number.
@ -263,132 +295,17 @@ bool LLAppViewerMacOSX::restoreErrorTrap()
return reset_count == 0;
}
#ifdef LL_CARBON_CRASH_HANDLER
static OSStatus CarbonEventHandler(EventHandlerCallRef inHandlerCallRef,
EventRef inEvent,
void* inUserData)
void LLAppViewerMacOSX::initCrashReporting(bool reportFreeze)
{
ProcessSerialNumber psn;
GetEventParameter(inEvent,
kEventParamProcessID,
typeProcessSerialNumber,
NULL,
sizeof(psn),
NULL,
&psn);
if( GetEventKind(inEvent) == kEventAppTerminated )
{
Boolean matching_psn = FALSE;
OSErr os_result = SameProcess(&psn, (ProcessSerialNumber*)inUserData, &matching_psn);
if(os_result >= 0 && matching_psn)
{
sCrashReporterIsRunning = false;
QuitApplicationEventLoop();
}
}
return noErr;
}
#endif
void LLAppViewerMacOSX::handleCrashReporting(bool reportFreeze)
{
#ifdef LL_CARBON_CRASH_HANDLER
// This used to use fork&exec, but is switched to LSOpenApplication to
// Make sure the crash reporter launches in front of the SL window.
std::string command_str;
//command_str = "open Second Life.app/Contents/Resources/mac-crash-logger.app";
command_str = "mac-crash-logger.app/Contents/MacOS/mac-crash-logger";
CFURLRef urlRef = CFURLCreateFromFileSystemRepresentation(NULL, (UInt8*)command_str.c_str(), strlen(command_str.c_str()), FALSE);
// FSRef apparently isn't deprecated.
// There's other funcitonality that depends on it existing as well that isn't deprecated.
// There doesn't seem to be much to directly verify what the status of FSRef is, outside of some documentation pointing at FSRef being valid, and other documentation pointing to everything in Files.h being deprecated.
// We'll assume it isn't for now, since all non-deprecated functions that use it seem to assume similar.
FSRef appRef;
Boolean pathstatus = CFURLGetFSRef(urlRef, &appRef);
OSStatus os_result = noErr;
if(pathstatus == true)
{
LSApplicationParameters appParams;
memset(&appParams, 0, sizeof(appParams));
appParams.version = 0;
appParams.flags = kLSLaunchNoParams | kLSLaunchStartClassic;
appParams.application = &appRef;
if(reportFreeze)
{
// Make sure freeze reporting launches the crash logger synchronously, lest
// Log files get changed by SL while the logger is running.
// *NOTE:Mani A better way - make a copy of the data that the crash reporter will send
// and let SL go about its business. This way makes the mac work like windows and linux
// and is the smallest patch for the issue.
sCrashReporterIsRunning = false;
ProcessSerialNumber o_psn;
static EventHandlerRef sCarbonEventsRef = NULL;
static const EventTypeSpec kEvents[] =
{
{ kEventClassApplication, kEventAppTerminated }
};
// Install the handler to detect crash logger termination
InstallEventHandler(GetApplicationEventTarget(),
(EventHandlerUPP) CarbonEventHandler,
GetEventTypeCount(kEvents),
kEvents,
&o_psn,
&sCarbonEventsRef
);
// Remove, temporarily the quit handler - which has *crash* behavior before
// the mainloop gets running!
AERemoveEventHandler(kCoreEventClass,
kAEQuitApplication,
NewAEEventHandlerUPP(AEQuitHandler),
false);
// Launch the crash reporter.
os_result = LSOpenApplication(&appParams, &o_psn);
if(os_result >= 0)
{
sCrashReporterIsRunning = true;
}
while(sCrashReporterIsRunning)
{
RunApplicationEventLoop();
}
// Re-install the apps quit handler.
AEInstallEventHandler(kCoreEventClass,
kAEQuitApplication,
NewAEEventHandlerUPP(AEQuitHandler),
0,
false);
// Remove the crash reporter quit handler.
RemoveEventHandler(sCarbonEventsRef);
}
else
{
appParams.flags |= kLSLaunchAsync;
clear_signals();
ProcessSerialNumber o_psn;
os_result = LSOpenApplication(&appParams, &o_psn);
}
}
#endif
std::string command_str = "mac-crash-logger.app";
std::stringstream pid_str;
pid_str << LLApp::getPid();
std::string logdir = gDirUtilp->getExpandedFilename(LL_PATH_DUMP, "");
std::string appname = gDirUtilp->getExecutableFilename();
std::string str[] = { "-pid", pid_str.str(), "-dumpdir", logdir, "-procname", appname.c_str() };
std::vector< std::string > args( str, str + ( sizeof ( str ) / sizeof ( std::string ) ) );
launchApplication(&command_str, &args);
}
std::string LLAppViewerMacOSX::generateSerialNumber()

2
indra/newview/llappviewermacosx.h
View File

@ -48,7 +48,7 @@ public:
protected:
virtual bool restoreErrorTrap();
virtual void handleCrashReporting(bool reportFreeze);
virtual void initCrashReporting(bool reportFreeze);
std::string generateSerialNumber();
virtual bool initParseCommandLine(LLCommandLineParser& clp);

94
indra/newview/llappviewerwin32.cpp Executable file → Normal file
View File

@ -65,6 +65,33 @@
#include "llwindebug.h"
#endif
#include "stringize.h"
#include <exception>
namespace
{
void (*gOldTerminateHandler)() = NULL;
}
static void exceptionTerminateHandler()
{
// reinstall default terminate() handler in case we re-terminate.
if (gOldTerminateHandler) std::set_terminate(gOldTerminateHandler);
// treat this like a regular viewer crash, with nice stacktrace etc.
long *null_ptr;
null_ptr = 0;
*null_ptr = 0xDEADBEEF; //Force an exception that will trigger breakpad.
//LLAppViewer::handleViewerCrash();
// we've probably been killed-off before now, but...
gOldTerminateHandler(); // call old terminate() handler
}
LONG WINAPI catchallCrashHandler(EXCEPTION_POINTERS * /*ExceptionInfo*/)
{
llwarns << "Hit last ditch-effort attempt to catch crash." << llendl;
exceptionTerminateHandler();
return 0;
}
// *FIX:Mani - This hack is to fix a linker issue with libndofdev.lib
// The lib was compiled under VS2005 - in VS2003 we need to remap assert
@ -239,8 +266,14 @@ int APIENTRY WINMAIN(HINSTANCE hInstance,
LLAppViewerWin32* viewer_app_ptr = new LLAppViewerWin32(lpCmdLine);
gOldTerminateHandler = std::set_terminate(exceptionTerminateHandler);
viewer_app_ptr->setErrorHandler(LLAppViewer::handleViewerCrash);
#if LL_SEND_CRASH_REPORTS
// ::SetUnhandledExceptionFilter(catchallCrashHandler);
#endif
// Set a debug info flag to indicate if multiple instances are running.
bool found_other_instance = !create_app_mutex();
gDebugInfo["FoundOtherInstanceAtStartup"] = LLSD::Boolean(found_other_instance);
@ -491,7 +524,19 @@ bool LLAppViewerWin32::init()
LLWinDebug::instance().init();
#endif
return LLAppViewer::init();
#if LL_WINDOWS
#if LL_SEND_CRASH_REPORTS
LLAppViewer* pApp = LLAppViewer::instance();
pApp->initCrashReporting();
#endif
#endif
bool success = LLAppViewer::init();
return success;
}
bool LLAppViewerWin32::cleanup()
@ -640,26 +685,53 @@ bool LLAppViewerWin32::restoreErrorTrap()
//return LLWinDebug::checkExceptionHandler();
}
void LLAppViewerWin32::handleCrashReporting(bool reportFreeze)
void LLAppViewerWin32::initCrashReporting(bool reportFreeze)
{
const char* logger_name = "win_crash_logger.exe";
std::string exe_path = gDirUtilp->getExecutableDir();
exe_path += gDirUtilp->getDirDelimiter();
exe_path += logger_name;
const char* arg_str = logger_name;
std::string logdir = gDirUtilp->getExpandedFilename(LL_PATH_DUMP, "");
std::string appname = gDirUtilp->getExecutableFilename();
// *NOTE:Mani - win_crash_logger.exe no longer parses command line options.
if(reportFreeze)
S32 slen = logdir.length() -1;
S32 end = slen;
while (logdir.at(end) == '/' || logdir.at(end) == '\\') end--;
if (slen !=end)
{
// Spawn crash logger.
// NEEDS to wait until completion, otherwise log files will get smashed.
_spawnl(_P_WAIT, exe_path.c_str(), arg_str, NULL);
logdir = logdir.substr(0,end+1);
}
else
//std::string arg_str = "\"" + exe_path + "\" -dumpdir \"" + logdir + "\" -procname \"" + appname + "\" -pid " + stringize(LLApp::getPid());
//_spawnl(_P_NOWAIT, exe_path.c_str(), arg_str.c_str(), NULL);
std::string arg_str = "\"" + exe_path + "\" -dumpdir \"" + logdir + "\" -procname \"" + appname + "\" -pid " + stringize(LLApp::getPid());
STARTUPINFO startInfo={sizeof(startInfo)};
PROCESS_INFORMATION processInfo;
std::wstring exe_wstr;
exe_wstr=wstringize(exe_path);
std::wstring arg_wstr;
arg_wstr=wstringize(arg_str);
LL_INFOS("CrashReport") << "Creating crash reporter process " << exe_path << " with params: " << arg_str << LL_ENDL;
if(CreateProcess(exe_wstr.c_str(),
&arg_wstr[0], // Application arguments
0,
0,
FALSE,
CREATE_DEFAULT_ERROR_MODE,
0,
0, // Working directory
&startInfo,
&processInfo) == FALSE)
// Could not start application -> call 'GetLastError()'
{
_spawnl(_P_NOWAIT, exe_path.c_str(), arg_str, NULL);
}
LL_WARNS("CrashReport Launch") << "CreateProcess failed " << GetLastError() << LL_ENDL;
return;
}
}
//virtual

2
indra/newview/llappviewerwin32.h Executable file → Normal file
View File

@ -50,7 +50,7 @@ protected:
virtual bool initParseCommandLine(LLCommandLineParser& clp);
virtual bool restoreErrorTrap();
virtual void handleCrashReporting(bool reportFreeze);
virtual void initCrashReporting(bool reportFreeze);
virtual bool sendURLToOtherInstance(const std::string& url);

35
indra/newview/llfloaterspellchecksettings.cpp
View File

@ -315,12 +315,12 @@ void LLFloaterSpellCheckerImport::onBtnOK()
else
{
std::string settings_dic = LLSpellChecker::getDictionaryUserPath() + mDictionaryBasename + ".dic";
if ( copyFile( dict_dic, settings_dic ) )
if ( LLFile::copy( dict_dic, settings_dic ) )
{
if (gDirUtilp->fileExists(dict_aff))
{
std::string settings_aff = LLSpellChecker::getDictionaryUserPath() + mDictionaryBasename + ".aff";
if (copyFile( dict_aff, settings_aff ))
if ( LLFile::copy( dict_aff, settings_aff ))
{
imported = true;
}
@ -393,37 +393,6 @@ void LLFloaterSpellCheckerImport::onBtnOK()
closeFloater(false);
}
bool LLFloaterSpellCheckerImport::copyFile(const std::string from, const std::string to)
{
bool copied = false;
LLFILE* in = LLFile::fopen(from, "rb"); /* Flawfinder: ignore */
if (in)
{
LLFILE* out = LLFile::fopen(to, "wb"); /* Flawfinder: ignore */
if (out)
{
char buf[16384]; /* Flawfinder: ignore */
size_t readbytes;
bool write_ok = true;
while(write_ok && (readbytes = fread(buf, 1, 16384, in))) /* Flawfinder: ignore */
{
if (fwrite(buf, 1, readbytes, out) != readbytes)
{
LL_WARNS("SpellCheck") << "Short write" << LL_ENDL;
write_ok = false;
}
}
if ( write_ok )
{
copied = true;
}
fclose(out);
}
}
fclose(in);
return copied;
}
std::string LLFloaterSpellCheckerImport::parseXcuFile(const std::string& file_path) const
{
LLXMLNodePtr xml_root;

1
indra/newview/llfloaterspellchecksettings.h
View File

@ -61,7 +61,6 @@ protected:
void onBtnBrowse();
void onBtnCancel();
void onBtnOK();
bool copyFile(const std::string from, const std::string to);
std::string parseXcuFile(const std::string& file_path) const;
std::string mDictionaryDir;

3
indra/newview/llstartup.cpp
View File

@ -4179,7 +4179,8 @@ bool process_login_success_response(U32 &first_sim_size_x, U32 &first_sim_size_y
{
success = true;
}
LLAppViewer* pApp = LLAppViewer::instance();
pApp->writeDebugInfo(); //Write our static data now that we have username, session_id, etc.
return success;
}

3
indra/win_crash_logger/CMakeLists.txt
View File

@ -13,6 +13,7 @@ include(LLWindow)
include(LLXML)
include(Linking)
include(LLSharedLibs)
include(GoogleBreakpad)
include_directories(
${LLCOMMON_INCLUDE_DIRS}
@ -21,6 +22,7 @@ include_directories(
${LLWINDOW_INCLUDE_DIRS}
${LLXML_INCLUDE_DIRS}
${LLVFS_INCLUDE_DIRS}
${BREAKPAD_INCLUDE_DIRECTORIES}
)
include_directories(SYSTEM
${LLCOMMON_SYSTEM_INCLUDE_DIRS}
@ -71,6 +73,7 @@ find_library(DXGUID_LIBRARY dxguid ${DIRECTX_LIBRARY_DIR})
add_executable(windows-crash-logger WIN32 ${win_crash_logger_SOURCE_FILES})
target_link_libraries(windows-crash-logger
${BREAKPAD_EXCEPTION_HANDLER_LIBRARIES}
${LLCRASHLOGGER_LIBRARIES}
${LLWINDOW_LIBRARIES}
${LLVFS_LIBRARIES}

205
indra/win_crash_logger/llcrashloggerwindows.cpp Executable file → Normal file
View File

@ -45,6 +45,13 @@
#include "lldxhardware.h"
#include "lldir.h"
#include "llsdserialize.h"
#include "llsdutil.h"
#include "stringize.h"
#ifndef ND_NO_BREAKPAD
#include <client/windows/crash_generation/crash_generation_server.h>
#include <client/windows/crash_generation/client_info.h>
#endif
#define MAX_LOADSTRING 100
#define MAX_STRING 2048
@ -67,6 +74,7 @@ BOOL gFirstDialog = TRUE; // Are we currently handling the Send/Don't Send dialo
std::stringstream gDXInfo;
bool gSendLogs = false;
LLCrashLoggerWindows* LLCrashLoggerWindows::sInstance = NULL;
//Conversion from char* to wchar*
//Replacement for ATL macros, doesn't allocate memory
@ -243,6 +251,10 @@ LRESULT CALLBACK WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam
LLCrashLoggerWindows::LLCrashLoggerWindows(void)
{
if (LLCrashLoggerWindows::sInstance==NULL)
{
sInstance = this;
}
// [SL:KB] - Patch: Viewer-CrashLookup | Checked: 2011-03-24 (Catznip-2.6.0a) | Added: Catznip-2.6.0a
#ifdef LL_SEND_CRASH_REPORTS
mCrashLookup = new LLCrashLookupWindows();
@ -252,20 +264,200 @@ LLCrashLoggerWindows::LLCrashLoggerWindows(void)
LLCrashLoggerWindows::~LLCrashLoggerWindows(void)
{
// [SL:KB] - Patch: Viewer-CrashLookup | Checked: 2011-03-24 (Catznip-2.6.0a) | Added: Catznip-2.6.0a
sInstance = NULL;
delete mCrashLookup;
// [/SL:KB]
}
bool LLCrashLoggerWindows::getMessageWithTimeout(MSG *msg, UINT to)
{
bool res;
UINT_PTR timerID = SetTimer(NULL, NULL, to, NULL);
res = GetMessage(msg, NULL, 0, 0);
KillTimer(NULL, timerID);
if (!res)
return false;
if (msg->message == WM_TIMER && msg->hwnd == NULL && msg->wParam == 1)
return false; //TIMEOUT! You could call SetLastError() or something...
return true;
}
int LLCrashLoggerWindows::processingLoop() {
const int millisecs=1000;
int retries = 0;
const int max_retries = 60;
LL_DEBUGS("CRASHREPORT") << "Entering processing loop for OOP server" << LL_ENDL;
LLSD options = getOptionData( LLApp::PRIORITY_COMMAND_LINE );
MSG msg;
bool result;
while (1)
{
result = getMessageWithTimeout(&msg, millisecs);
if ( result )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if ( retries < max_retries ) //Wait up to 1 minute for the viewer to say hello.
{
if (mClientsConnected == 0)
{
LL_DEBUGS("CRASHREPORT") << "Waiting for client to connect." << LL_ENDL;
++retries;
}
else
{
LL_INFOS("CRASHREPORT") << "Client has connected!" << LL_ENDL;
retries = max_retries;
}
}
else
{
if (mClientsConnected == 0)
{
break;
}
if (!mKeyMaster.isProcessAlive(mPID, mProcName) )
{
break;
}
}
}
llinfos << "session ending.." << llendl;
std::string per_run_dir = options["dumpdir"].asString();
// <FS:ND> Correct logfile for FS
// std::string per_run_file = per_run_dir + "\\SecondLife.log";
// std::string log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"SecondLife.log");
std::string per_run_file = per_run_dir + "\\Firestorm.log";
std::string log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"Firestorm.log");
// </FS:ND>
if (gDirUtilp->fileExists(per_run_dir))
{
LL_INFOS ("CRASHREPORT") << "Copying " << log_file << " to " << per_run_file << llendl;
LLFile::copy(log_file, per_run_file);
}
return 0;
}
void LLCrashLoggerWindows::OnClientConnected(void* context,
const google_breakpad::ClientInfo* client_info)
{
sInstance->mClientsConnected++;
#ifndef ND_NO_BREAKPAD
LL_INFOS("CRASHREPORT") << "Client connected. pid = " << client_info->pid() << " total clients " << sInstance->mClientsConnected << LL_ENDL;
#endif
}
void LLCrashLoggerWindows::OnClientExited(void* context,
const google_breakpad::ClientInfo* client_info)
{
sInstance->mClientsConnected--;
#ifndef ND_NO_BREAKPAD
LL_INFOS("CRASHREPORT") << "Client disconnected. pid = " << client_info->pid() << " total clients " << sInstance->mClientsConnected << LL_ENDL;
#endif
}
void LLCrashLoggerWindows::OnClientDumpRequest(void* context,
const google_breakpad::ClientInfo* client_info,
const std::wstring* file_path)
{
if (!file_path)
{
llwarns << "dump with no file path" << llendl;
return;
}
if (!client_info)
{
llwarns << "dump with no client info" << llendl;
return;
}
LLCrashLoggerWindows* self = static_cast<LLCrashLoggerWindows*>(context);
if (!self)
{
llwarns << "dump with no context" << llendl;
return;
}
//DWORD pid = client_info->pid();
}
bool LLCrashLoggerWindows::initCrashServer()
{
#ifndef ND_NO_BREAKPAD
//For Breakpad on Windows we need a full Out of Process service to get good data.
//This routine starts up the service on a named pipe that the viewer will then
//communicate with.
using namespace google_breakpad;
LLSD options = getOptionData( LLApp::PRIORITY_COMMAND_LINE );
std::string dump_path = options["dumpdir"].asString();
mClientsConnected = 0;
mPID = options["pid"].asInteger();
mProcName = options["procname"].asString();
//Generate a quasi-uniq name for the named pipe. For our purposes
//this is unique-enough with least hassle. Worst case for duplicate name
//is a second instance of the viewer will not do crash reporting.
std::wstring wpipe_name;
wpipe_name = mCrashReportPipeStr + std::wstring(wstringize(mPID));
std::wstring wdump_path( wstringize(dump_path) );
//Pipe naming conventions: http://msdn.microsoft.com/en-us/library/aa365783%28v=vs.85%29.aspx
mCrashHandler = new CrashGenerationServer( wpipe_name,
NULL,
&LLCrashLoggerWindows::OnClientConnected, this,
/*NULL, NULL, */ &LLCrashLoggerWindows::OnClientDumpRequest, this,
&LLCrashLoggerWindows::OnClientExited, this,
NULL, NULL,
true, &wdump_path);
if (!mCrashHandler) {
//Failed to start the crash server.
llwarns << "Failed to init crash server." << llendl;
return false;
}
// Start servicing clients.
if (!mCrashHandler->Start()) {
llwarns << "Failed to start crash server." << llendl;
return false;
}
LL_INFOS("CRASHREPORT") << "Initialized OOP server with pipe named " << stringize(wpipe_name) << LL_ENDL;
#else
LL_INFOS("CRASHREPORT") << "Crashreporting is disabled" << LL_ENDL;
#endif
return true;
}
bool LLCrashLoggerWindows::init(void)
{
bool ok = LLCrashLogger::init();
if(!ok) return false;
initCrashServer();
/*
mbstowcs( gProductName, mProductName.c_str(), LL_ARRAY_SIZE(gProductName) );
gProductName[ LL_ARRY_SIZE(gProductName) - 1 ] = 0;
swprintf(gProductName, L"Second Life");
swprintf(gProductName, L"Second Life");
*/
llinfos << "Loading dialogs" << llendl;
@ -302,21 +494,16 @@ void LLCrashLoggerWindows::gatherPlatformSpecificFiles()
SetCursor(gCursorWait);
// At this point we're responsive enough the user could click the close button
SetCursor(gCursorArrow);
// mDebugLog["DisplayDeviceInfo"] = gDXHardware.getDisplayInfo();
// [SL:KB] - Patch: Viewer-CrashReporting | Checked: 2010-11-14 (Catznip-2.6.0a) | Added: Catznip-2.4.0a
mCrashInfo["DisplayDeviceInfo"] = gDXHardware.getDisplayInfo();
// [/SL:KB]
//mDebugLog["DisplayDeviceInfo"] = gDXHardware.getDisplayInfo(); //Not initialized.
}
bool LLCrashLoggerWindows::mainLoop()
{
llinfos << "CrashSubmitBehavior is " << mCrashBehavior << llendl;
// Note: parent hwnd is 0 (the desktop). No dlg proc. See Petzold (5th ed) HexCalc example, Chapter 11, p529
// win_crash_logger.rc has been edited by hand.
// Dialogs defined with CLASS "WIN_CRASH_LOGGER" (must be same as szWindowClass)
gProductName = mProductName;
gHwndProgress = CreateDialog(hInst, MAKEINTRESOURCE(IDD_PROGRESS), 0, NULL);
ProcessCaption(gHwndProgress);
ShowWindow(gHwndProgress, SW_HIDE );
@ -385,5 +572,7 @@ bool LLCrashLoggerWindows::cleanup()
}
PostQuitMessage(0);
commonCleanup();
mKeyMaster.releaseMaster();
return true;
}

34
indra/win_crash_logger/llcrashloggerwindows.h Executable file → Normal file
View File

@ -31,20 +31,54 @@
#include "windows.h"
#include "llstring.h"
class LLSD;
namespace google_breakpad {
class CrashGenerationServer;
class ClientInfo;
}
class LLCrashLoggerWindows : public LLCrashLogger
{
public:
LLCrashLoggerWindows(void);
~LLCrashLoggerWindows(void);
static LLCrashLoggerWindows* sInstance;
virtual bool init();
virtual bool mainLoop();
virtual void updateApplication(const std::string& message = LLStringUtil::null);
virtual bool cleanup();
virtual void gatherPlatformSpecificFiles();
void setHandle(HINSTANCE hInst) { mhInst = hInst; }
int clients_connected() const {
return mClientsConnected;
}
bool getMessageWithTimeout(MSG *msg, UINT to);
// Starts the processing loop. This function does not return unless the
// user is logging off or the user closes the crash service window. The
// return value is a good number to pass in ExitProcess().
int processingLoop();
private:
void ProcessDlgItemText(HWND hWnd, int nIDDlgItem);
void ProcessCaption(HWND hWnd);
bool initCrashServer();
google_breakpad::CrashGenerationServer* mCrashHandler;
static void OnClientConnected(void* context,
const google_breakpad::ClientInfo* client_info);
static void OnClientDumpRequest(
void* context,
const google_breakpad::ClientInfo* client_info,
const std::wstring* file_path);
static void OnClientExited(void* context,
const google_breakpad::ClientInfo* client_info);
int mClientsConnected;
int mPID;
std::string mProcName;
HINSTANCE mhInst;
};

12
indra/win_crash_logger/win_crash_logger.cpp
View File

@ -34,18 +34,24 @@ int APIENTRY WinMain(HINSTANCE hInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
llinfos << "Starting crash reporter." << llendl;
llinfos << "Starting crash reporter with args" << &lpCmdLine << llendl;
LLCrashLoggerWindows app;
app.setHandle(hInstance);
app.parseCommandOptions(__argc, __argv);
LLSD options = LLApp::instance()->getOptionData(
LLApp::PRIORITY_COMMAND_LINE);
if (!(options.has("pid") && options.has("dumpdir")))
{
llwarns << "Insufficient parameters to crash report." << llendl;
}
if (! app.init())
{
llwarns << "Unable to initialize application." << llendl;
return -1;
return 1;
}
app.processingLoop();
app.mainLoop();
app.cleanup();
llinfos << "Crash reporter finished normally." << llendl;