1 // Copyright 2015 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
6 #define BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
10 #include "base/atomicops.h"
11 #include "base/containers/hash_tables.h"
12 #include "base/memory/ref_counted.h"
13 #include "base/memory/singleton.h"
14 #include "base/synchronization/lock.h"
15 #include "base/timer/timer.h"
16 #include "base/trace_event/memory_dump_request_args.h"
17 #include "base/trace_event/process_memory_dump.h"
18 #include "base/trace_event/trace_event.h"
22 class SingleThreadTaskRunner
;
24 namespace trace_event
{
26 class MemoryDumpManagerDelegate
;
27 class MemoryDumpProvider
;
28 class MemoryDumpSessionState
;
30 // This is the interface exposed to the rest of the codebase to deal with
31 // memory tracing. The main entry point for clients is represented by
32 // RequestDumpPoint(). The extension by Un(RegisterDumpProvider).
33 class BASE_EXPORT MemoryDumpManager
: public TraceLog::EnabledStateObserver
{
35 static const char* const kTraceCategoryForTesting
;
37 // This value is returned as the tracing id of the child processes by
38 // GetTracingProcessId() when tracing is not enabled.
39 static const uint64 kInvalidTracingProcessId
;
41 static MemoryDumpManager
* GetInstance();
43 // Invoked once per process to register the TraceLog observer.
46 // See the lifetime and thread-safety requirements on the delegate below in
47 // the |MemoryDumpManagerDelegate| docstring.
48 void SetDelegate(MemoryDumpManagerDelegate
* delegate
);
50 // MemoryDumpManager does NOT take memory ownership of |mdp|, which is
51 // expected to either be a singleton or unregister itself.
52 // If the optional |task_runner| argument is non-null, all the calls to the
53 // |mdp| will be issues on the given thread. Otherwise, the |mdp| should be
54 // able to handle calls on arbitrary threads.
55 void RegisterDumpProvider(
56 MemoryDumpProvider
* mdp
,
57 const scoped_refptr
<SingleThreadTaskRunner
>& task_runner
);
58 void RegisterDumpProvider(MemoryDumpProvider
* mdp
);
59 void UnregisterDumpProvider(MemoryDumpProvider
* mdp
);
61 // Requests a memory dump. The dump might happen or not depending on the
62 // filters and categories specified when enabling tracing.
63 // The optional |callback| is executed asynchronously, on an arbitrary thread,
64 // to notify about the completion of the global dump (i.e. after all the
65 // processes have dumped) and its success (true iff all the dumps were
67 void RequestGlobalDump(MemoryDumpType dump_type
,
68 const MemoryDumpCallback
& callback
);
70 // Same as above (still asynchronous), but without callback.
71 void RequestGlobalDump(MemoryDumpType dump_type
);
73 // TraceLog::EnabledStateObserver implementation.
74 void OnTraceLogEnabled() override
;
75 void OnTraceLogDisabled() override
;
77 // Returns the MemoryDumpSessionState object, which is shared by all the
78 // ProcessMemoryDump and MemoryAllocatorDump instances through all the tracing
80 const scoped_refptr
<MemoryDumpSessionState
>& session_state() const {
81 return session_state_
;
84 // Returns a unique id for identifying the processes. The id can be
85 // retrieved by child processes only when tracing is enabled. This is
86 // intended to express cross-process sharing of memory dumps on the
87 // child-process side, without having to know its own child process id.
88 uint64
GetTracingProcessId() const;
90 // Returns the name for a the allocated_objects dump. Use this to declare
91 // suballocator dumps from other dump providers.
92 // It should not return nullptr after the manager has been initialized.
93 const char* system_allocator_pool_name() const {
94 return system_allocator_pool_name_
;
98 friend struct DefaultDeleter
<MemoryDumpManager
>; // For the testing instance.
99 friend struct DefaultSingletonTraits
<MemoryDumpManager
>;
100 friend class MemoryDumpManagerDelegate
;
101 friend class MemoryDumpManagerTest
;
102 FRIEND_TEST_ALL_PREFIXES(MemoryDumpManagerTest
, DisableFailingDumpers
);
104 // Descriptor struct used to hold information about registered MDPs. It is
105 // deliberately copyable, in order to allow it to be used as std::set value.
106 struct MemoryDumpProviderInfo
{
107 MemoryDumpProviderInfo(
108 MemoryDumpProvider
* dump_provider
,
109 const scoped_refptr
<SingleThreadTaskRunner
>& task_runner
);
110 ~MemoryDumpProviderInfo();
112 // Define a total order based on the thread (i.e. |task_runner|) affinity,
113 // so that all MDP belonging to the same thread are adjacent in the set.
114 bool operator<(const MemoryDumpProviderInfo
& other
) const;
116 MemoryDumpProvider
* const dump_provider
;
117 scoped_refptr
<SingleThreadTaskRunner
> task_runner
; // Optional.
119 // For fail-safe logic (auto-disable failing MDPs). These fields are mutable
120 // as can be safely changed without impacting the order within the set.
121 mutable int consecutive_failures
;
122 mutable bool disabled
;
125 using MemoryDumpProviderInfoSet
= std::set
<MemoryDumpProviderInfo
>;
127 // Holds the state of a process memory dump that needs to be carried over
128 // across threads in order to fulfil an asynchronous CreateProcessDump()
129 // request. At any time exactly one thread owns a ProcessMemoryDumpAsyncState.
130 struct ProcessMemoryDumpAsyncState
{
131 ProcessMemoryDumpAsyncState(
132 MemoryDumpRequestArgs req_args
,
133 MemoryDumpProviderInfoSet::iterator next_dump_provider
,
134 const scoped_refptr
<MemoryDumpSessionState
>& session_state
,
135 MemoryDumpCallback callback
);
136 ~ProcessMemoryDumpAsyncState();
138 // The ProcessMemoryDump container, where each dump provider will dump its
139 // own MemoryAllocatorDump(s) upon the OnMemoryDump() call.
140 ProcessMemoryDump process_memory_dump
;
142 // The arguments passed to the initial CreateProcessDump() request.
143 const MemoryDumpRequestArgs req_args
;
145 // The |dump_providers_| iterator to the next dump provider that should be
146 // invoked (or dump_providers_.end() if at the end of the sequence).
147 MemoryDumpProviderInfoSet::iterator next_dump_provider
;
149 // Callback passed to the initial call to CreateProcessDump().
150 MemoryDumpCallback callback
;
152 // The thread on which FinalizeDumpAndAddToTrace() (and hence |callback|)
153 // should be invoked. This is the thread on which the initial
154 // CreateProcessDump() request was called.
155 const scoped_refptr
<SingleThreadTaskRunner
> task_runner
;
158 DISALLOW_COPY_AND_ASSIGN(ProcessMemoryDumpAsyncState
);
161 static const int kMaxConsecutiveFailuresCount
;
164 ~MemoryDumpManager() override
;
166 static void SetInstanceForTesting(MemoryDumpManager
* instance
);
167 static void FinalizeDumpAndAddToTrace(
168 scoped_ptr
<ProcessMemoryDumpAsyncState
> pmd_async_state
);
169 static void AbortDumpLocked(MemoryDumpCallback callback
,
170 scoped_refptr
<SingleThreadTaskRunner
> task_runner
,
173 // Internal, used only by MemoryDumpManagerDelegate.
174 // Creates a memory dump for the current process and appends it to the trace.
175 // |callback| will be invoked asynchronously upon completion on the same
176 // thread on which CreateProcessDump() was called.
177 void CreateProcessDump(const MemoryDumpRequestArgs
& args
,
178 const MemoryDumpCallback
& callback
);
180 // Continues the ProcessMemoryDump started by CreateProcessDump(), hopping
181 // across threads as needed as specified by MDPs in RegisterDumpProvider().
182 void ContinueAsyncProcessDump(
183 scoped_ptr
<ProcessMemoryDumpAsyncState
> pmd_async_state
);
185 // An ordererd set of registered MemoryDumpProviderInfo(s), sorted by thread
186 // affinity (MDPs belonging to the same thread are adjacent).
187 MemoryDumpProviderInfoSet dump_providers_
;
189 // Flag used to signal that some provider was removed from |dump_providers_|
190 // and therefore the current memory dump (if any) should be aborted.
191 bool did_unregister_dump_provider_
;
193 // Shared among all the PMDs to keep state scoped to the tracing session.
194 scoped_refptr
<MemoryDumpSessionState
> session_state_
;
196 MemoryDumpManagerDelegate
* delegate_
; // Not owned.
198 // Protects from concurrent accesses to the |dump_providers_*| and |delegate_|
199 // to guard against disabling logging while dumping on another thread.
202 // Optimization to avoid attempting any memory dump (i.e. to not walk an empty
203 // dump_providers_enabled_ list) when tracing is not enabled.
204 subtle::AtomicWord memory_tracing_enabled_
;
206 // For time-triggered periodic dumps.
207 RepeatingTimer
<MemoryDumpManager
> periodic_dump_timer_
;
209 // The unique id of the child process. This is created only for tracing and is
210 // expected to be valid only when tracing is enabled.
211 uint64 tracing_process_id_
;
213 // Name of the allocated_objects dump.
214 const char* system_allocator_pool_name_
;
216 // Skips the auto-registration of the core dumpers during Initialize().
217 bool skip_core_dumpers_auto_registration_for_testing_
;
219 DISALLOW_COPY_AND_ASSIGN(MemoryDumpManager
);
222 // The delegate is supposed to be long lived (read: a Singleton) and thread
223 // safe (i.e. should expect calls from any thread and handle thread hopping).
224 class BASE_EXPORT MemoryDumpManagerDelegate
{
226 virtual void RequestGlobalMemoryDump(const MemoryDumpRequestArgs
& args
,
227 const MemoryDumpCallback
& callback
) = 0;
229 // Determines whether the MemoryDumpManager instance should be the master
230 // (the ones which initiates and coordinates the multiprocess dumps) or not.
231 virtual bool IsCoordinatorProcess() const = 0;
233 // Returns tracing process id of the current process. This is used by
234 // MemoryDumpManager::GetTracingProcessId.
235 virtual uint64
GetTracingProcessId() const = 0;
238 MemoryDumpManagerDelegate() {}
239 virtual ~MemoryDumpManagerDelegate() {}
241 void CreateProcessDump(const MemoryDumpRequestArgs
& args
,
242 const MemoryDumpCallback
& callback
) {
243 MemoryDumpManager::GetInstance()->CreateProcessDump(args
, callback
);
247 DISALLOW_COPY_AND_ASSIGN(MemoryDumpManagerDelegate
);
250 } // namespace trace_event
253 #endif // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_