GT2/Ejectable/node_modules/hermes-engine/android/include/hermes/Public/CrashManager.h

97 lines
3.5 KiB
C
Raw Normal View History

2021-08-16 00:14:59 +00:00
/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#ifndef HERMES_PUBLIC_CRASHMANAGER_H
#define HERMES_PUBLIC_CRASHMANAGER_H
#include <cstddef>
#include <functional>
namespace hermes {
namespace vm {
/// A CrashManager provides functions that determine what memory and data is
/// included in dumps in case of crashes.
class CrashManager {
public:
/// CallbackKey is the type of an identifier for a callback supplied to the
/// CrashManager.
using CallbackKey = int;
/// Type for the callback function invoked on crash. The fd supplied is a raw
/// file stream an implementation should write a JSON object to.
using CallbackFunc = std::function<void(int fd)>;
/// Registers some memory to be included in any crash dump that occurs.
/// \param mem A pointer to allocated memory. It must be unregistered
/// before being freed.
/// \param length The number of bytes the memory controls.
virtual void registerMemory(void *mem, size_t length) = 0;
/// Unregisters some memory from being included in any crash dump that occurs.
virtual void unregisterMemory(void *mem) = 0;
/// Registers custom data to be included in any crash dump that occurs.
/// Calling \c setCustomData on the same key twice will overwrite the previous
/// value.
/// \param key A tag to look for in the custom data output. Distinguishes
/// between multiple values.
/// \param val The value to store for the given key.
virtual void setCustomData(const char *key, const char *val) = 0;
/// If the given \p key has an associated custom data string, remove the
/// association.
virtual void removeCustomData(const char *key) = 0;
/// Registers a function to be called after a crash has occurred. This
/// function can examine memory and serialize this to a JSON output stream.
/// Implmentations decide where the stream is routed to.
/// \param callback A function to called after a crash.
/// \return A CallbackKey representing the function you provided. Pass this
/// key into unregisterCallback when it that callback is no longer needed.
virtual CallbackKey registerCallback(CallbackFunc callback) = 0;
/// Unregisters a previously registered callback. After this function returns,
/// the previously registered function will not be executed by this
/// CrashManager during a crash.
virtual void unregisterCallback(CallbackKey key) = 0;
/// the heap information.
struct HeapInformation {
/// The amount of memory that is currently in use
size_t used_{0};
/// The amount of memory that can currently be allocated
/// before a full GC is triggered.
size_t size_{0};
};
/// Record the heap information.
/// \param heapInfo The current heap information
virtual void setHeapInfo(const HeapInformation &heapInfo) = 0;
virtual ~CrashManager() {}
};
/// A CrashManager that does nothing.
class NopCrashManager final : public CrashManager {
public:
void registerMemory(void *, size_t) override {}
void unregisterMemory(void *) override {}
void setCustomData(const char *, const char *) override {}
void removeCustomData(const char *) override {}
CallbackKey registerCallback(CallbackFunc /*callback*/) override {
return 0;
}
void unregisterCallback(CallbackKey /*key*/) override {}
void setHeapInfo(const HeapInformation & /*heapInfo*/) override {}
~NopCrashManager() {}
};
} // namespace vm
} // namespace hermes
#endif