1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
/* 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 ProcessedStack_h__
#define ProcessedStack_h__
#include <vector>
#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "mozilla/ipc/MessageChannel.h"
#include "mozilla/Vector.h"
#include "nsStringFwd.h"
#if defined(MOZ_GECKO_PROFILER)
# include "shared-libraries.h"
#endif // MOZ_GECKO_PROFILER
namespace mozilla {
namespace Telemetry {
// This class represents a stack trace and the modules referenced in that trace.
// It is designed to be easy to read and write to disk or network and doesn't
// include any logic on how to collect or read the information it stores.
class ProcessedStack {
public:
ProcessedStack();
size_t GetStackSize() const;
size_t GetNumModules() const;
struct Frame {
// The offset of this program counter in its module or an absolute pc.
uintptr_t mOffset;
// The index to pass to GetModule to get the module this program counter
// was in.
uint16_t mModIndex;
};
struct Module {
// The file name, /foo/bar/libxul.so for example.
// It can contain unicode characters.
nsString mName;
nsCString mBreakpadId;
bool operator==(const Module& other) const;
};
const Frame& GetFrame(unsigned aIndex) const;
void AddFrame(const Frame& aFrame);
const Module& GetModule(unsigned aIndex) const;
void AddModule(const Module& aFrame);
void Clear();
private:
std::vector<Module> mModules;
std::vector<Frame> mStack;
};
// Get the current list of loaded modules, filter and pair it to the provided
// stack. We let the caller collect the stack since different callers have
// different needs (current thread X main thread, stopping the thread, etc).
ProcessedStack GetStackAndModules(const std::vector<uintptr_t>& aPCs);
// This class optimizes repeated calls to GetStackAndModules.
class BatchProcessedStackGenerator {
public:
BatchProcessedStackGenerator();
ProcessedStack GetStackAndModules(const std::vector<uintptr_t>& aPCs);
template <typename AllocatorPolicy>
ProcessedStack GetStackAndModules(
const Vector<void*, 0, AllocatorPolicy>& aPCs) {
return GetStackAndModules(reinterpret_cast<const uintptr_t*>(aPCs.begin()),
reinterpret_cast<const uintptr_t*>(aPCs.end()));
}
private:
ProcessedStack GetStackAndModules(const uintptr_t* aBegin,
const uintptr_t* aEnd);
#if defined(MOZ_GECKO_PROFILER)
SharedLibraryInfo mSortedRawModules;
#endif
};
} // namespace Telemetry
} // namespace mozilla
namespace IPC {
template <>
struct ParamTraits<mozilla::Telemetry::ProcessedStack::Module> {
typedef mozilla::Telemetry::ProcessedStack::Module paramType;
static void Write(MessageWriter* aWriter, const paramType& aParam) {
WriteParam(aWriter, aParam.mName);
WriteParam(aWriter, aParam.mBreakpadId);
}
static bool Read(MessageReader* aReader, paramType* aResult) {
if (!ReadParam(aReader, &aResult->mName)) {
return false;
}
if (!ReadParam(aReader, &aResult->mBreakpadId)) {
return false;
}
return true;
}
};
template <>
struct ParamTraits<mozilla::Telemetry::ProcessedStack::Frame> {
typedef mozilla::Telemetry::ProcessedStack::Frame paramType;
static void Write(MessageWriter* aWriter, const paramType& aParam) {
WriteParam(aWriter, aParam.mOffset);
WriteParam(aWriter, aParam.mModIndex);
}
static bool Read(MessageReader* aReader, paramType* aResult) {
if (!ReadParam(aReader, &aResult->mOffset)) {
return false;
}
if (!ReadParam(aReader, &aResult->mModIndex)) {
return false;
}
return true;
}
};
} // namespace IPC
#endif // ProcessedStack_h__
|
