blob: 941aad4987e614da171e2b6fa3472fbabe711cab [file] [log] [blame]
// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Parts of this module come from:
// by Dan Moulding.
// by Jochen Kalmbach
#include <windows.h>
#include <dbghelp.h>
#include <functional>
#include <map>
#include <string>
#include "base/logging.h"
#include "base/synchronization/lock.h"
#include "tools/memory_watcher/memory_watcher.h"
// The CallStack Class
// A stack where memory has been allocated.
class CallStack {
// Initialize for tracing CallStacks.
static bool Initialize();
virtual ~CallStack() {}
// Get a hash for this CallStack.
// Identical stack traces will have matching hashes.
int32 hash() { return hash_; }
// Get a unique ID for this CallStack.
// No two CallStacks will ever have the same ID. The ID is a monotonically
// increasing number. Newer CallStacks always have larger IDs.
int32 id() { return id_; }
// Retrieves the frame at the specified index.
DWORD_PTR frame(int32 index) {
DCHECK(index < frame_count_ && index >= 0);
return frames_[index];
// Compares the CallStack to another CallStack
// for equality. Two CallStacks are equal if they are the same size and if
// every frame in each is identical to the corresponding frame in the other.
bool IsEqual(const CallStack &target);
typedef std::basic_string<char, std::char_traits<char>,
PrivateHookAllocator<char> > PrivateAllocatorString;
// Convert the callstack to a string stored in output.
void CallStack::ToString(PrivateAllocatorString* output);
bool Valid() const { return valid_; }
// The maximum number of frames to trace.
static const int kMaxTraceFrames = 32;
// Pushes a frame's program counter onto the CallStack.
void AddFrame(DWORD_PTR programcounter);
// Traces the stack, starting from this function, up to kMaxTraceFrames
// frames.
bool GetStackTrace();
// Functions for manipulating the frame list.
void ClearFrames();
// Dynamically load the DbgHelp library and supporting routines that we
// will use.
static bool LoadDbgHelp();
static void LockDbgHelp() {
active_thread_id_ = GetCurrentThreadId();
static void UnlockDbgHelp() {
active_thread_id_ = 0;
class AutoDbgHelpLock {
AutoDbgHelpLock() {
~AutoDbgHelpLock() {
// Check to see if this thread is already processing a stack.
bool LockedRecursionDetected() const;
// According to
// "All DbgHelp functions, such as this one, are single threaded. Therefore,
// calls from more than one thread to this function will likely result in
// unexpected behavior or memory corruption. To avoid this, you must
// synchromize all concurrent calls from one thread to this function."
// dbghelp_lock_ is used to serialize access across all calls to the DbgHelp
// library. This may be overly conservative (serializing them all together),
// but does guarantee correctness.
static base::Lock dbghelp_lock_;
// Record the fact that dbghelp has been loaded.
// Changes to this variable are protected by dbghelp_lock_.
// It will only changes once... from false to true.
static bool dbghelp_loaded_;
// To prevent infinite recursion due to unexpected side effects in libraries,
// we track the thread_id of the thread currently holding the dbghelp_lock_.
// We avoid re-aquiring said lock and return an !valid_ instance when we
// detect recursion.
static DWORD active_thread_id_;
int frame_count_; // Current size (in frames)
DWORD_PTR frames_[kMaxTraceFrames];
int32 hash_;
int32 id_;
// Indicate is this is a valid stack.
// This is false if recursion precluded a real stack generation.
bool valid_;
// Cache ProgramCounter -> Symbol lookups.
// This cache is not thread safe.
typedef std::map<int32, PrivateAllocatorString, std::less<int32>,
PrivateHookAllocator<int32> > SymbolCache;
static SymbolCache* symbol_cache_;
// An AllocationStack is a type of CallStack which represents a CallStack where
// memory has been allocated. This class is also a list item, so that it can
// be easilly allocated and deallocated from its static singly-linked-list of
// free instances.
class AllocationStack : public CallStack {
explicit AllocationStack(int32 size)
: next_(NULL), size_(size), CallStack() {}
// We maintain a freelist of the AllocationStacks.
void* operator new(size_t s);
void operator delete(void*p);
int32 size() const { return size_; }
AllocationStack* next_; // Pointer used when on the freelist.
int32 size_; // Size of block allocated.
static AllocationStack* freelist_;
static base::Lock freelist_lock_;