mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-06 09:05:45 +00:00
3d3d26fb09
The existing deadlock detector code uses the trace-malloc stack walking facilities, which is problematic for a few reasons. 1. It is only available in builds with --enable-trace-malloc, which is not in the default build configuration. 2. It tries to capture a symbolicated stack trace every time that a lock is acquired or released, which is really slow. This patch changes the deadlock detector to use the XPCOM stack walking and symbolification facilities, and avoids the symbolification until the point where we need to print out the call stack, which makes the deadlock detector a lot faster than it currently is in trace-malloc builds.
348 lines
9.8 KiB
C++
348 lines
9.8 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: sw=4 ts=4 et :
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
|
#ifndef mozilla_BlockingResourceBase_h
|
|
#define mozilla_BlockingResourceBase_h
|
|
|
|
#include "prlog.h"
|
|
|
|
#include "nscore.h"
|
|
#include "nsDebug.h"
|
|
#include "nsError.h"
|
|
#include "nsTraceRefcnt.h"
|
|
|
|
#ifdef DEBUG
|
|
#include "prinit.h"
|
|
#include "prthread.h"
|
|
|
|
#include "nsStringGlue.h"
|
|
|
|
#include "mozilla/DeadlockDetector.h"
|
|
#include "nsXPCOM.h"
|
|
#endif
|
|
|
|
//
|
|
// This header is not meant to be included by client code.
|
|
//
|
|
|
|
namespace mozilla {
|
|
|
|
|
|
/**
|
|
* BlockingResourceBase
|
|
* Base class of resources that might block clients trying to acquire them.
|
|
* Does debugging and deadlock detection in DEBUG builds.
|
|
**/
|
|
class NS_COM_GLUE BlockingResourceBase
|
|
{
|
|
public:
|
|
// Needs to be kept in sync with kResourceTypeNames.
|
|
enum BlockingResourceType { eMutex, eReentrantMonitor, eCondVar };
|
|
|
|
/**
|
|
* kResourceTypeName
|
|
* Human-readable version of BlockingResourceType enum.
|
|
*/
|
|
static const char* const kResourceTypeName[];
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
private:
|
|
// forward declaration for the following typedef
|
|
struct DeadlockDetectorEntry;
|
|
|
|
// ``DDT'' = ``Deadlock Detector Type''
|
|
typedef DeadlockDetector<DeadlockDetectorEntry> DDT;
|
|
|
|
/**
|
|
* DeadlockDetectorEntry
|
|
* We free BlockingResources, but we never free entries in the
|
|
* deadlock detector. This struct outlives its BlockingResource
|
|
* and preserves all the state needed to print subsequent
|
|
* error messages.
|
|
*
|
|
* These objects are owned by the deadlock detector.
|
|
*/
|
|
struct DeadlockDetectorEntry
|
|
{
|
|
DeadlockDetectorEntry(const char* aName,
|
|
BlockingResourceType aType) :
|
|
mName(aName),
|
|
mType(aType),
|
|
mAcquisitionContext(CallStack::NullCallStack())
|
|
{
|
|
NS_ABORT_IF_FALSE(mName, "Name must be nonnull");
|
|
}
|
|
|
|
/**
|
|
* Print
|
|
* Write a description of this blocking resource to |out|. If
|
|
* the resource appears to be currently acquired, the current
|
|
* acquisition context is printed and true is returned.
|
|
* Otherwise, we print the context from |aFirstSeen|, the
|
|
* first acquisition from which the code calling |Print()|
|
|
* became interested in us, and return false. |Print()| can
|
|
* be forced to print the context from |aFirstSeen| regardless
|
|
* by passing |aPrintFirstSeenCx=true|.
|
|
*
|
|
* *NOT* thread safe. Reads |mAcquisitionContext| without
|
|
* synchronization, but this will not cause correctness
|
|
* problems.
|
|
*
|
|
* FIXME bug 456272: hack alert: because we can't write call
|
|
* contexts into strings, all info is written to stderr, but
|
|
* only some info is written into |out|
|
|
*/
|
|
bool Print(const DDT::ResourceAcquisition& aFirstSeen,
|
|
nsACString& out,
|
|
bool aPrintFirstSeenCx=false) const;
|
|
|
|
/**
|
|
* mName
|
|
* A descriptive name for this resource. Used in error
|
|
* messages etc.
|
|
*/
|
|
const char* mName;
|
|
/**
|
|
* mType
|
|
* The more specific type of this resource. Used to implement
|
|
* special semantics (e.g., reentrancy of monitors).
|
|
**/
|
|
BlockingResourceType mType;
|
|
/**
|
|
* mAcquisitionContext
|
|
* The calling context from which this resource was acquired, or
|
|
* |CallStack::NullCallStack()| if it is currently free (or freed).
|
|
*/
|
|
CallStack mAcquisitionContext;
|
|
};
|
|
|
|
protected:
|
|
/**
|
|
* BlockingResourceBase
|
|
* Initialize this blocking resource. Also hooks the resource into
|
|
* instrumentation code.
|
|
*
|
|
* Thread safe.
|
|
*
|
|
* @param aName A meaningful, unique name that can be used in
|
|
* error messages, et al.
|
|
* @param aType The specific type of |this|, if any.
|
|
**/
|
|
BlockingResourceBase(const char* aName, BlockingResourceType aType);
|
|
|
|
~BlockingResourceBase();
|
|
|
|
/**
|
|
* CheckAcquire
|
|
*
|
|
* Thread safe.
|
|
*
|
|
* @param aCallContext the client's calling context from which the
|
|
* original acquisition request was made.
|
|
**/
|
|
void CheckAcquire(const CallStack& aCallContext);
|
|
|
|
/**
|
|
* Acquire
|
|
*
|
|
* *NOT* thread safe. Requires ownership of underlying resource.
|
|
*
|
|
* @param aCallContext the client's calling context from which the
|
|
* original acquisition request was made.
|
|
**/
|
|
void Acquire(const CallStack& aCallContext); //NS_NEEDS_RESOURCE(this)
|
|
|
|
/**
|
|
* Release
|
|
* Remove this resource from the current thread's acquisition chain.
|
|
* The resource does not have to be at the front of the chain, although
|
|
* it is confusing to release resources in a different order than they
|
|
* are acquired. This generates a warning.
|
|
*
|
|
* *NOT* thread safe. Requires ownership of underlying resource.
|
|
**/
|
|
void Release(); //NS_NEEDS_RESOURCE(this)
|
|
|
|
/**
|
|
* PrintCycle
|
|
* Append to |out| detailed information about the circular
|
|
* dependency in |cycle|. Returns true if it *appears* that this
|
|
* cycle may represent an imminent deadlock, but this is merely a
|
|
* heuristic; the value returned may be a false positive or false
|
|
* negative.
|
|
*
|
|
* *NOT* thread safe. Calls |Print()|.
|
|
*
|
|
* FIXME bug 456272 hack alert: because we can't write call
|
|
* contexts into strings, all info is written to stderr, but only
|
|
* some info is written into |out|
|
|
*/
|
|
static bool PrintCycle(const DDT::ResourceAcquisitionArray* cycle,
|
|
nsACString& out);
|
|
|
|
/**
|
|
* ResourceChainFront
|
|
*
|
|
* Thread safe.
|
|
*
|
|
* @return the front of the resource acquisition chain, i.e., the last
|
|
* resource acquired.
|
|
*/
|
|
static BlockingResourceBase* ResourceChainFront()
|
|
{
|
|
return (BlockingResourceBase*)
|
|
PR_GetThreadPrivate(sResourceAcqnChainFrontTPI);
|
|
}
|
|
|
|
/**
|
|
* ResourceChainPrev
|
|
*
|
|
* *NOT* thread safe. Requires ownership of underlying resource.
|
|
*/
|
|
static BlockingResourceBase*
|
|
ResourceChainPrev(const BlockingResourceBase* aResource)
|
|
{
|
|
return aResource->mChainPrev;
|
|
} //NS_NEEDS_RESOURCE(this)
|
|
|
|
/**
|
|
* ResourceChainAppend
|
|
* Set |this| to the front of the resource acquisition chain, and link
|
|
* |this| to |aPrev|.
|
|
*
|
|
* *NOT* thread safe. Requires ownership of underlying resource.
|
|
*/
|
|
void ResourceChainAppend(BlockingResourceBase* aPrev)
|
|
{
|
|
mChainPrev = aPrev;
|
|
PR_SetThreadPrivate(sResourceAcqnChainFrontTPI, this);
|
|
} //NS_NEEDS_RESOURCE(this)
|
|
|
|
/**
|
|
* ResourceChainRemove
|
|
* Remove |this| from the front of the resource acquisition chain.
|
|
*
|
|
* *NOT* thread safe. Requires ownership of underlying resource.
|
|
*/
|
|
void ResourceChainRemove()
|
|
{
|
|
NS_ASSERTION(this == ResourceChainFront(), "not at chain front");
|
|
PR_SetThreadPrivate(sResourceAcqnChainFrontTPI, mChainPrev);
|
|
} //NS_NEEDS_RESOURCE(this)
|
|
|
|
/**
|
|
* GetAcquisitionContext
|
|
* Return the calling context from which this resource was acquired,
|
|
* or CallStack::NullCallStack() if it's currently free.
|
|
*
|
|
* *NOT* thread safe. Requires ownership of underlying resource.
|
|
*/
|
|
CallStack
|
|
GetAcquisitionContext()
|
|
{
|
|
return mDDEntry->mAcquisitionContext;
|
|
}
|
|
|
|
/**
|
|
* SetAcquisitionContext
|
|
* Set the calling context from which this resource was acquired.
|
|
*
|
|
* *NOT* thread safe. Requires ownership of underlying resource.
|
|
*/
|
|
void
|
|
SetAcquisitionContext(CallStack aAcquisitionContext)
|
|
{
|
|
mDDEntry->mAcquisitionContext = aAcquisitionContext;
|
|
}
|
|
|
|
/**
|
|
* mChainPrev
|
|
* A series of resource acquisitions creates a chain of orders. This
|
|
* chain is implemented as a linked list; |mChainPrev| points to the
|
|
* resource most recently Acquire()'d before this one.
|
|
**/
|
|
BlockingResourceBase* mChainPrev;
|
|
|
|
private:
|
|
/**
|
|
* mDDEntry
|
|
* The key for this BlockingResourceBase in the deadlock detector.
|
|
*/
|
|
DeadlockDetectorEntry* mDDEntry;
|
|
|
|
/**
|
|
* sCallOnce
|
|
* Ensures static members are initialized only once, and in a
|
|
* thread-safe way.
|
|
*/
|
|
static PRCallOnceType sCallOnce;
|
|
|
|
/**
|
|
* sResourceAcqnChainFrontTPI
|
|
* Thread-private index to the front of each thread's resource
|
|
* acquisition chain.
|
|
*/
|
|
static unsigned sResourceAcqnChainFrontTPI;
|
|
|
|
/**
|
|
* sDeadlockDetector
|
|
* Does as named.
|
|
*/
|
|
static DDT* sDeadlockDetector;
|
|
|
|
/**
|
|
* InitStatics
|
|
* Inititialize static members of BlockingResourceBase that can't
|
|
* be statically initialized.
|
|
*
|
|
* *NOT* thread safe.
|
|
*/
|
|
static PRStatus InitStatics() {
|
|
PR_NewThreadPrivateIndex(&sResourceAcqnChainFrontTPI, 0);
|
|
sDeadlockDetector = new DDT();
|
|
if (!sDeadlockDetector)
|
|
NS_RUNTIMEABORT("can't allocate deadlock detector");
|
|
return PR_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* Shutdown
|
|
* Free static members.
|
|
*
|
|
* *NOT* thread safe.
|
|
*/
|
|
static void Shutdown() {
|
|
delete sDeadlockDetector;
|
|
sDeadlockDetector = 0;
|
|
}
|
|
|
|
# ifdef MOZILLA_INTERNAL_API
|
|
// so it can call BlockingResourceBase::Shutdown()
|
|
friend void LogTerm();
|
|
# endif // ifdef MOZILLA_INTERNAL_API
|
|
|
|
#else // non-DEBUG implementation
|
|
|
|
BlockingResourceBase(const char* aName, BlockingResourceType aType)
|
|
{
|
|
}
|
|
|
|
~BlockingResourceBase()
|
|
{
|
|
}
|
|
|
|
#endif
|
|
};
|
|
|
|
|
|
} // namespace mozilla
|
|
|
|
|
|
#endif // mozilla_BlockingResourceBase_h
|