126 lines
4.5 KiB
C++
126 lines
4.5 KiB
C++
//===-- common.h ------------------------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// This file contains code that is common between the crash handler and the
|
|
// GuardedPoolAllocator.
|
|
|
|
#ifndef GWP_ASAN_COMMON_H_
|
|
#define GWP_ASAN_COMMON_H_
|
|
|
|
#include "gwp_asan/definitions.h"
|
|
#include "gwp_asan/options.h"
|
|
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
namespace gwp_asan {
|
|
enum class Error {
|
|
UNKNOWN,
|
|
USE_AFTER_FREE,
|
|
DOUBLE_FREE,
|
|
INVALID_FREE,
|
|
BUFFER_OVERFLOW,
|
|
BUFFER_UNDERFLOW
|
|
};
|
|
|
|
const char *ErrorToString(const Error &E);
|
|
|
|
static constexpr uint64_t kInvalidThreadID = UINT64_MAX;
|
|
// Get the current thread ID, or kInvalidThreadID if failure. Note: This
|
|
// implementation is platform-specific.
|
|
uint64_t getThreadID();
|
|
|
|
// This struct contains all the metadata recorded about a single allocation made
|
|
// by GWP-ASan. If `AllocationMetadata.Addr` is zero, the metadata is non-valid.
|
|
struct AllocationMetadata {
|
|
// The number of bytes used to store a compressed stack frame. On 64-bit
|
|
// platforms, assuming a compression ratio of 50%, this should allow us to
|
|
// store ~64 frames per trace.
|
|
static constexpr size_t kStackFrameStorageBytes = 256;
|
|
|
|
// Maximum number of stack frames to collect on allocation/deallocation. The
|
|
// actual number of collected frames may be less than this as the stack
|
|
// frames are compressed into a fixed memory range.
|
|
static constexpr size_t kMaxTraceLengthToCollect = 128;
|
|
|
|
// Records the given allocation metadata into this struct.
|
|
void RecordAllocation(uintptr_t Addr, size_t RequestedSize);
|
|
// Record that this allocation is now deallocated.
|
|
void RecordDeallocation();
|
|
|
|
struct CallSiteInfo {
|
|
// Record the current backtrace to this callsite.
|
|
void RecordBacktrace(options::Backtrace_t Backtrace);
|
|
|
|
// The compressed backtrace to the allocation/deallocation.
|
|
uint8_t CompressedTrace[kStackFrameStorageBytes];
|
|
// The thread ID for this trace, or kInvalidThreadID if not available.
|
|
uint64_t ThreadID = kInvalidThreadID;
|
|
// The size of the compressed trace (in bytes). Zero indicates that no
|
|
// trace was collected.
|
|
size_t TraceSize = 0;
|
|
};
|
|
|
|
// The address of this allocation. If zero, the rest of this struct isn't
|
|
// valid, as the allocation has never occurred.
|
|
uintptr_t Addr = 0;
|
|
// Represents the actual size of the allocation.
|
|
size_t RequestedSize = 0;
|
|
|
|
CallSiteInfo AllocationTrace;
|
|
CallSiteInfo DeallocationTrace;
|
|
|
|
// Whether this allocation has been deallocated yet.
|
|
bool IsDeallocated = false;
|
|
};
|
|
|
|
// This holds the state that's shared between the GWP-ASan allocator and the
|
|
// crash handler. This, in conjunction with the Metadata array, forms the entire
|
|
// set of information required for understanding a GWP-ASan crash.
|
|
struct AllocatorState {
|
|
// Returns whether the provided pointer is a current sampled allocation that
|
|
// is owned by this pool.
|
|
GWP_ASAN_ALWAYS_INLINE bool pointerIsMine(const void *Ptr) const {
|
|
uintptr_t P = reinterpret_cast<uintptr_t>(Ptr);
|
|
return P < GuardedPagePoolEnd && GuardedPagePool <= P;
|
|
}
|
|
|
|
// Returns the address of the N-th guarded slot.
|
|
uintptr_t slotToAddr(size_t N) const;
|
|
|
|
// Returns the largest allocation that is supported by this pool.
|
|
size_t maximumAllocationSize() const;
|
|
|
|
// Gets the nearest slot to the provided address.
|
|
size_t getNearestSlot(uintptr_t Ptr) const;
|
|
|
|
// Returns whether the provided pointer is a guard page or not. The pointer
|
|
// must be within memory owned by this pool, else the result is undefined.
|
|
bool isGuardPage(uintptr_t Ptr) const;
|
|
|
|
// The number of guarded slots that this pool holds.
|
|
size_t MaxSimultaneousAllocations = 0;
|
|
|
|
// Pointer to the pool of guarded slots. Note that this points to the start of
|
|
// the pool (which is a guard page), not a pointer to the first guarded page.
|
|
uintptr_t GuardedPagePool = 0;
|
|
uintptr_t GuardedPagePoolEnd = 0;
|
|
|
|
// Cached page size for this system in bytes.
|
|
size_t PageSize = 0;
|
|
|
|
// The type and address of an internally-detected failure. For INVALID_FREE
|
|
// and DOUBLE_FREE, these errors are detected in GWP-ASan, which will set
|
|
// these values and terminate the process.
|
|
Error FailureType = Error::UNKNOWN;
|
|
uintptr_t FailureAddress = 0;
|
|
};
|
|
|
|
} // namespace gwp_asan
|
|
#endif // GWP_ASAN_COMMON_H_
|