blob: 08f32d2025c6dcbef67e017c9d895bcf2ac8337d (
plain)
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
|
// Copyright 2019 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.
#include "base/debug/task_trace.h"
#include "base/ranges/algorithm.h"
#include "build/build_config.h"
#if defined(OS_ANDROID)
#include <android/log.h>
#endif // OS_ANDROID
#include <iostream>
#include <sstream>
#if defined(OS_ANDROID)
#include "base/no_destructor.h"
#endif
#include "base/pending_task.h"
#include "base/task/common/task_annotator.h"
namespace base {
namespace debug {
namespace {
#if defined(OS_ANDROID)
// Android sends stdout and stderr to /dev/null; logging should be done through
// the __android_log_write() function. Here we create an override of
// std::stringbuf that writes to the Android log.
class AndroidErrBuffer : public std::stringbuf {
protected:
int sync() override {
__android_log_write(ANDROID_LOG_ERROR, "chromium", str().c_str());
return 0;
}
};
std::ostream& DefaultOutputStream() {
static NoDestructor<AndroidErrBuffer> buf;
static NoDestructor<std::ostream> out(buf.get());
return *out;
}
#else
// Use stderr by default.
std::ostream& DefaultOutputStream() {
return std::cerr;
}
#endif // OS_ANDROID
} // namespace
TaskTrace::TaskTrace() {
const PendingTask* current_task = TaskAnnotator::CurrentTaskForThread();
if (!current_task)
return;
std::array<const void*, PendingTask::kTaskBacktraceLength + 1> task_trace;
task_trace[0] = current_task->posted_from.program_counter();
ranges::copy(current_task->task_backtrace, task_trace.begin() + 1);
size_t length = 0;
while (length < task_trace.size() && task_trace[length])
++length;
if (length == 0)
return;
stack_trace_.emplace(task_trace.data(), length);
trace_overflow_ = current_task->task_backtrace_overflow;
}
bool TaskTrace::empty() const {
return !stack_trace_.has_value();
}
void TaskTrace::Print() const {
OutputToStream(&DefaultOutputStream());
}
void TaskTrace::OutputToStream(std::ostream* os) const {
*os << "Task trace:" << std::endl;
if (!stack_trace_) {
*os << "No active task.";
return;
}
*os << *stack_trace_;
if (trace_overflow_) {
*os << "Task trace buffer limit hit, update "
"PendingTask::kTaskBacktraceLength to increase."
<< std::endl;
}
}
std::string TaskTrace::ToString() const {
std::stringstream stream;
OutputToStream(&stream);
return stream.str();
}
base::span<const void* const> TaskTrace::AddressesForTesting() const {
if (empty())
return {};
size_t count = 0;
const void* const* addresses = stack_trace_->Addresses(&count);
return {addresses, count};
}
std::ostream& operator<<(std::ostream& os, const TaskTrace& task_trace) {
task_trace.OutputToStream(&os);
return os;
}
} // namespace debug
} // namespace base
|
