stackTrace.h

Go to the documentation of this file.

// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
// Modified by Jeremy Retailleau.
 
#ifndef PXR_ARCH_STACK_TRACE_H
#define PXR_ARCH_STACK_TRACE_H
 
 
#include "./api.h"
#include "./defines.h"
 
#include <inttypes.h>
#include <stdio.h>
#include <functional>
#include <vector>
#include <string>
#include <iosfwd>
#include <ctime>
 
namespace pxr {
 
ARCH_API
void ArchLogFatalProcessState(const char* reason,
                              const char* message = nullptr,
                              const char* extraLogMsg = nullptr);
 
ARCH_API
void ArchLogCurrentProcessState(const char* reason,
                                const char* message = nullptr,
                                const char* extraLogMsg = nullptr);
 
ARCH_API
void ArchSetProcessStateLogCommand(const char* command, 
                                   const char *const argv[],
                                   const char* const fatalArgv[]);
 
ARCH_API
bool ArchIsAppCrashing();
 
ARCH_API
void ArchLogSessionInfo(const char *crashStackTrace=NULL);
 
ARCH_API
void ArchSetLogSession(const char* command,
                       const char* const argv[],
                       const char* const crashArgv[]);
 
ARCH_API
void ArchEnableSessionLogging();
 
ARCH_API
void ArchPrintStackTrace(FILE *fout,
                         const std::string& programName,
                         const std::string& reason);
 
ARCH_API
void ArchPrintStackTrace(FILE *fout, const std::string& reason);
 
ARCH_API
void ArchPrintStackTrace(std::ostream& out,
                         const std::string& programName,
                         const std::string& reason);
 
ARCH_API
void ArchPrintStackTrace(std::ostream& out, const std::string& reason);
 
typedef std::function<std::string(uintptr_t address)> ArchStackTraceCallback;
 
ARCH_API
void ArchSetStackTraceCallback(const ArchStackTraceCallback& cb);
 
ARCH_API
void ArchGetStackTraceCallback(ArchStackTraceCallback* cb);
 
ARCH_API
time_t ArchGetAppLaunchTime();
 
ARCH_API 
void ArchSetFatalStackLogging(bool flag);
 
ARCH_API
bool ArchGetFatalStackLogging();
 
ARCH_API
void ArchSetProgramNameForErrors(const char * progName);
 
ARCH_API
const char * ArchGetProgramNameForErrors();
 
ARCH_API
void ArchSetProgramInfoForErrors( const std::string& key, const std::string& value );
 
ARCH_API
std::string ArchGetProgramInfoForErrors(const std::string& key);
 
ARCH_API
void ArchSetExtraLogInfoForErrors(const std::string &key,
                                  std::vector<std::string> const *lines);
 
ARCH_API
void ArchLogStackTrace(const std::string& progName,
                       const std::string& reason,
                       bool fatal = false,
                       const std::string& sessionLog = "");
 
ARCH_API
void ArchLogStackTrace(const std::string& reason,
                       bool fatal = false, 
                       const std::string& sessionLog = "");
 
ARCH_API
std::vector<std::string> ArchGetStackTrace(size_t maxDepth);
 
 
ARCH_API
void ArchGetStackFrames(size_t maxDepth, std::vector<uintptr_t> *frames);
 
ARCH_API
size_t ArchGetStackFrames(size_t maxDepth, uintptr_t *frames);
 
ARCH_API
void ArchGetStackFrames(size_t maxDepth, size_t numFramesToSkipAtTop,
                        std::vector<uintptr_t> *frames);
 
ARCH_API
size_t ArchGetStackFrames(size_t maxDepth, size_t numFramesToSkipAtTop,
                          uintptr_t *frames);
 
 
ARCH_API
void ArchPrintStackFrames(std::ostream& out,
                          const std::vector<uintptr_t> &frames,
                          bool skipUnknownFrames = false);
 
typedef void (*ArchCrashHandlerSystemCB)(void* userData);
 
ARCH_API
int ArchCrashHandlerSystemv(const char* pathname, char *const argv[],
                int timeout, ArchCrashHandlerSystemCB callback, 
                void* userData);
 
#if defined(ARCH_OS_DARWIN)
// macOS has no ETIME. ECANCELED seems to have about the closest meaning to
// the actual error here. The operation is timing out, not being explicitly
// canceled, but it is canceled.
#ifndef ETIME
#define ETIME ECANCELED
#endif  // end ETIME
#endif  // end ARCH_OS_DARWIN
 
}  // namespace pxr
 
#endif  // PXR_ARCH_STACK_TRACE_H