void ThreadTree::FixOverlappedMap(std::set<MapEntry*, MapComparator>* map_set, const MapEntry* map) {
for (auto it = map_set->begin(); it != map_set->end();) {
if ((*it)->start_addr >= map->get_end_addr()) {
// No more overlapped maps.
break;
}
if ((*it)->get_end_addr() <= map->start_addr) {
++it;
} else {
MapEntry* old = *it;
if (old->start_addr < map->start_addr) {
MapEntry* before = AllocateMap(MapEntry(old->start_addr, map->start_addr - old->start_addr,
old->pgoff, old->time, old->dso));
map_set->insert(before);
}
if (old->get_end_addr() > map->get_end_addr()) {
MapEntry* after = AllocateMap(
MapEntry(map->get_end_addr(), old->get_end_addr() - map->get_end_addr(),
map->get_end_addr() - old->start_addr + old->pgoff, old->time, old->dso));
map_set->insert(after);
}
it = map_set->erase(it);
}
}
}
void Graph::unweighted( const string & startName )
{
clearAll( );
const MapEntry & match = vertexMap.find( MapEntry( startName ) );
if( match == ITEM_NOT_FOUND )
{
cout << startName << " is not a vertex in this graph" << endl;
return;
}
Vertex *start = match.storedVertex;
Queue<Vertex *> q( numVertices );
q.enqueue( start ); start->dist = 0;
while( !q.isEmpty( ) )
{
Vertex *v = q.dequeue( );
ListItr<Vertex *> itr;
for( itr = v->adj.first( ); !itr.isPastEnd( ); itr.advance( ) )
{
Vertex *w = itr.retrieve( );
if( w->dist == INFINITY )
{
w->dist = v->dist + 1;
w->path = v;
q.enqueue( w );
}
}
}
}
void ThreadTree::AddThreadMap(int pid, int tid, uint64_t start_addr, uint64_t len, uint64_t pgoff,
uint64_t time, const std::string& filename) {
ThreadEntry* thread = FindThreadOrNew(pid, tid);
Dso* dso = FindUserDsoOrNew(filename);
MapEntry* map = AllocateMap(MapEntry(start_addr, len, pgoff, time, dso));
FixOverlappedMap(&thread->maps, map);
auto pair = thread->maps.insert(map);
CHECK(pair.second);
}
/**
* Register class for debug output
* @param name class name
* @param state initial enabled state
*/
void Tracer::registerClass(const QString& name, bool state, const QString &filePath)
{
if (!m_classes)
m_classes = new MapType;
QFileInfo fi(filePath);
QString dirName = fi.absolutePath();
QFileInfo f(dirName);
QString path = f.fileName();
(*m_classes)[name] = MapEntry(path, state);
}
void ThreadTree::AddKernelMap(uint64_t start_addr, uint64_t len, uint64_t pgoff, uint64_t time,
const std::string& filename) {
// kernel map len can be 0 when record command is not run in supervisor mode.
if (len == 0) {
return;
}
Dso* dso = FindKernelDsoOrNew(filename);
MapEntry* map = AllocateMap(MapEntry(start_addr, len, pgoff, time, dso));
FixOverlappedMap(&kernel_map_tree_, map);
auto pair = kernel_map_tree_.insert(map);
CHECK(pair.second);
}
void Graph::printPath( const string & destName ) const
{
const MapEntry & match = vertexMap.find( MapEntry( destName ) );
if( match == ITEM_NOT_FOUND )
{
cout << "Destination vertex not found" << endl;
return;
}
const Vertex & w = *match.storedVertex;
if( w.dist == INFINITY )
cout << destName << " is unreachable";
else
printPath( w );
cout << endl;
}
/**
* This method contains the core guts of the handling of QueryInterface calls
* that are delegated to us from the ICallInterceptor.
*
* @param aIid ID of the desired interface
* @param aOutInterceptor The resulting emulated vtable that corresponds to
* the interface specified by aIid.
*/
HRESULT
Interceptor::GetInterceptorForIID(REFIID aIid, void** aOutInterceptor)
{
if (!aOutInterceptor) {
return E_INVALIDARG;
}
if (aIid == IID_IUnknown) {
// Special case: When we see IUnknown, we just provide a reference to this
*aOutInterceptor = static_cast<IInterceptor*>(this);
AddRef();
return S_OK;
}
RefPtr<IUnknown> unkInterceptor;
IUnknown* interfaceForQILog = nullptr;
// (1) Check to see if we already have an existing interceptor for aIid.
{ // Scope for lock
MutexAutoLock lock(mMutex);
MapEntry* entry = Lookup(aIid);
if (entry) {
unkInterceptor = entry->mInterceptor;
interfaceForQILog = entry->mTargetInterface;
}
}
// (1a) A COM interceptor already exists for this interface, so all we need
// to do is run a QI on it.
if (unkInterceptor) {
// Technically we didn't actually execute a QI on the target interface, but
// for logging purposes we would like to record the fact that this interface
// was requested.
InterceptorLog::QI(S_OK, mTarget.get(), aIid, interfaceForQILog);
return unkInterceptor->QueryInterface(aIid, aOutInterceptor);
}
// (2) Obtain a new target interface.
// (2a) First, make sure that the target interface is available
// NB: We *MUST* query the correct interface! ICallEvents::Invoke casts its
// pvReceiver argument directly to the required interface! DO NOT assume
// that COM will use QI or upcast/downcast!
HRESULT hr;
STAUniquePtr<IUnknown> targetInterface;
IUnknown* rawTargetInterface = nullptr;
hr = QueryInterfaceTarget(aIid, (void**)&rawTargetInterface);
targetInterface.reset(rawTargetInterface);
InterceptorLog::QI(hr, mTarget.get(), aIid, targetInterface.get());
MOZ_ASSERT(SUCCEEDED(hr) || hr == E_NOINTERFACE);
if (FAILED(hr)) {
return hr;
}
// We *really* shouldn't be adding interceptors to proxies
MOZ_ASSERT(aIid != IID_IMarshal);
// (3) Create a new COM interceptor to that interface that delegates its
// IUnknown to |this|.
// Raise the refcount for stabilization purposes during aggregation
RefPtr<IUnknown> kungFuDeathGrip(static_cast<IUnknown*>(
static_cast<WeakReferenceSupport*>(this)));
hr = CreateInterceptor(aIid, kungFuDeathGrip, getter_AddRefs(unkInterceptor));
if (FAILED(hr)) {
return hr;
}
// (4) Obtain the interceptor's ICallInterceptor interface and register our
// event sink.
RefPtr<ICallInterceptor> interceptor;
hr = unkInterceptor->QueryInterface(IID_ICallInterceptor,
(void**)getter_AddRefs(interceptor));
if (FAILED(hr)) {
return hr;
}
hr = interceptor->RegisterSink(mEventSink);
if (FAILED(hr)) {
return hr;
}
// (5) Now that we have this new COM interceptor, insert it into the map.
{ // Scope for lock
MutexAutoLock lock(mMutex);
// We might have raced with another thread, so first check that we don't
// already have an entry for this
MapEntry* entry = Lookup(aIid);
if (entry && entry->mInterceptor) {
unkInterceptor = entry->mInterceptor;
} else {
// We're inserting unkInterceptor into the map but we still want to hang
// onto it locally so that we can QI it below.
unkInterceptor->AddRef();
// OTOH we must not touch the refcount for the target interface
// because we are just moving it into the map and its refcounting might
// not be thread-safe.
IUnknown* rawTargetInterface = targetInterface.release();
mInterceptorMap.AppendElement(MapEntry(aIid,
unkInterceptor,
rawTargetInterface));
}
}
return unkInterceptor->QueryInterface(aIid, aOutInterceptor);
}
Graph( ) : vertexMap( MapEntry( ) ), numVertices( 0 ) { }
