diff options
Diffstat (limited to 'src/client/linux/handler/exception_handler.h')
-rw-r--r-- | src/client/linux/handler/exception_handler.h | 92 |
1 files changed, 39 insertions, 53 deletions
diff --git a/src/client/linux/handler/exception_handler.h b/src/client/linux/handler/exception_handler.h index 4bc8ba72..c339b7dd 100644 --- a/src/client/linux/handler/exception_handler.h +++ b/src/client/linux/handler/exception_handler.h @@ -42,6 +42,7 @@ #include "client/linux/android_ucontext.h" #endif #include "client/linux/crash_generation/crash_generation_client.h" +#include "client/linux/handler/minidump_descriptor.h" #include "client/linux/minidump_writer/minidump_writer.h" #include "common/using_std_string.h" #include "google_breakpad/common/minidump_format.h" @@ -51,8 +52,6 @@ struct sigaction; namespace google_breakpad { -class ExceptionHandler; - // ExceptionHandler // // ExceptionHandler can write a minidump file when an exception occurs, @@ -71,17 +70,18 @@ class ExceptionHandler; // use different minidump callbacks for different call sites. // // In either case, a callback function is called when a minidump is written, -// which receives the unqiue id of the minidump. The caller can use this -// id to collect and write additional application state, and to launch an -// external crash-reporting application. +// which receives the full path or file descriptor of the minidump. The +// caller can collect and write additional application state to that minidump, +// and launch an external crash-reporting application. // // Caller should try to make the callbacks as crash-friendly as possible, // it should avoid use heap memory allocation as much as possible. + class ExceptionHandler { public: // A callback function to run before Breakpad performs any substantial // processing of an exception. A FilterCallback is called before writing - // a minidump. context is the parameter supplied by the user as + // a minidump. |context| is the parameter supplied by the user as // callback_context when the handler was created. // // If a FilterCallback returns true, Breakpad will continue processing, @@ -91,10 +91,10 @@ class ExceptionHandler { typedef bool (*FilterCallback)(void *context); // A callback function to run after the minidump has been written. - // minidump_id is a unique id for the dump, so the minidump - // file is <dump_path>\<minidump_id>.dmp. context is the parameter supplied - // by the user as callback_context when the handler was created. succeeded - // indicates whether a minidump file was successfully written. + // |descriptor| contains the file descriptor or file path containing the + // minidump. |context| is the parameter supplied by the user as + // callback_context when the handler was created. |succeeded| indicates + // whether a minidump file was successfully written. // // If an exception occurred and the callback returns true, Breakpad will // treat the exception as fully-handled, suppressing any other handlers from @@ -106,9 +106,8 @@ class ExceptionHandler { // should normally return the value of |succeeded|, or when they wish to // not report an exception of handled, false. Callbacks will rarely want to // return true directly (unless |succeeded| is true). - typedef bool (*MinidumpCallback)(const char *dump_path, - const char *minidump_id, - void *context, + typedef bool (*MinidumpCallback)(const MinidumpDescriptor& descriptor, + void* context, bool succeeded); // In certain cases, a user may wish to handle the generation of the minidump @@ -121,52 +120,52 @@ class ExceptionHandler { void* context); // Creates a new ExceptionHandler instance to handle writing minidumps. - // Before writing a minidump, the optional filter callback will be called. + // Before writing a minidump, the optional |filter| callback will be called. // Its return value determines whether or not Breakpad should write a - // minidump. Minidump files will be written to dump_path, and the optional - // callback is called after writing the dump file, as described above. + // minidump. The minidump content will be written to the file path or file + // descriptor from |descriptor|, and the optional |callback| is called after + // writing the dump file, as described above. // If install_handler is true, then a minidump will be written whenever // an unhandled exception occurs. If it is false, minidumps will only // be written when WriteMinidump is called. - ExceptionHandler(const string &dump_path, - FilterCallback filter, MinidumpCallback callback, + // If |server_fd| is valid, the minidump is generated out-of-process. If it + // is -1, in-process generation will always be used. + ExceptionHandler(const MinidumpDescriptor& descriptor, + FilterCallback filter, + MinidumpCallback callback, void *callback_context, - bool install_handler); - - // Creates a new ExceptionHandler instance that can attempt to - // perform out-of-process dump generation if server_fd is valid. If - // server_fd is invalid, in-process dump generation will be - // used. See the above ctor for a description of the other - // parameters. - ExceptionHandler(const string& dump_path, - FilterCallback filter, MinidumpCallback callback, - void* callback_context, bool install_handler, const int server_fd); - ~ExceptionHandler(); - // Get and set the minidump path. - string dump_path() const { return dump_path_; } - void set_dump_path(const string &dump_path) { - dump_path_ = dump_path; - dump_path_c_ = dump_path_.c_str(); - UpdateNextID(); + const MinidumpDescriptor& minidump_descriptor() const { + return minidump_descriptor_; } void set_crash_handler(HandlerCallback callback) { crash_handler_ = callback; } - // Writes a minidump immediately. This can be used to capture the - // execution state independently of a crash. Returns true on success. + // Writes a minidump immediately. This can be used to capture the execution + // state independently of a crash. + // Returns true on success. + // If the ExceptionHandler has been created with a path, a new file is + // generated for each minidump. The file path can be retrieved in the + // MinidumpDescriptor passed to the MinidumpCallback or by accessing the + // MinidumpDescriptor directly from the ExceptionHandler (with + // minidump_descriptor()). + // If the ExceptionHandler has been created with a file descriptor, the file + // descriptor is repositioned to its beginning and the previous generated + // minidump is overwritten. + // Note that this method is not supposed to be called from a compromised + // context as it uses the heap. bool WriteMinidump(); // Convenience form of WriteMinidump which does not require an // ExceptionHandler instance. - static bool WriteMinidump(const string &dump_path, + static bool WriteMinidump(const string& dump_path, MinidumpCallback callback, - void *callback_context); + void* callback_context); // This structure is passed to minidump_writer.h:WriteMinidump via an opaque // blob. It shouldn't be needed in any user code. @@ -195,8 +194,6 @@ class ExceptionHandler { size_t file_offset); private: - void Init(const string &dump_path, - const int server_fd); bool InstallHandlers(); void UninstallHandlers(); void PreresolveSymbols(); @@ -204,7 +201,6 @@ class ExceptionHandler { void SendContinueSignalToChild(); void WaitForContinueSignal(); - void UpdateNextID(); static void SignalHandler(int sig, siginfo_t* info, void* uc); bool HandleSignal(int sig, siginfo_t* info, void* uc); static int ThreadEntry(void* arg); @@ -217,18 +213,8 @@ class ExceptionHandler { scoped_ptr<CrashGenerationClient> crash_generation_client_; - string dump_path_; - string next_minidump_path_; - string next_minidump_id_; - - // Pointers to C-string representations of the above. These are set - // when the above are set so we can avoid calling c_str during - // an exception. - const char* dump_path_c_; - const char* next_minidump_path_c_; - const char* next_minidump_id_c_; + MinidumpDescriptor minidump_descriptor_; - const bool handler_installed_; HandlerCallback crash_handler_; // The global exception handler stack. This is need becuase there may exist |