Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1460)

Unified Diff: content/browser/tracing/arc_tracing_agent.cc

Issue 2400163003: arc: enable Android tracing in verified-boot mode (Closed)
Patch Set: rebase to tot Created 3 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « content/browser/tracing/arc_tracing_agent.h ('k') | content/browser/tracing/tracing_controller_impl.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: content/browser/tracing/arc_tracing_agent.cc
diff --git a/content/browser/tracing/arc_tracing_agent.cc b/content/browser/tracing/arc_tracing_agent.cc
index d71cd647ae870308c2d5c68e3f600c2345115814..0df2e2cc6815ce01bf94ee5f7e1f860e33816bd2 100644
--- a/content/browser/tracing/arc_tracing_agent.cc
+++ b/content/browser/tracing/arc_tracing_agent.cc
@@ -4,24 +4,123 @@
#include "content/browser/tracing/arc_tracing_agent.h"
+#include <memory>
#include <string>
+#include <utility>
+#include <vector>
#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/files/file.h"
+#include "base/files/file_descriptor_watcher_posix.h"
#include "base/logging.h"
+#include "base/memory/ptr_util.h"
#include "base/memory/singleton.h"
-#include "base/threading/thread_checker.h"
+#include "base/memory/weak_ptr.h"
+#include "base/posix/unix_domain_socket_linux.h"
+#include "base/threading/sequenced_task_runner_handle.h"
#include "base/threading/thread_task_runner_handle.h"
+#include "base/time/time.h"
+#include "cc/base/ring_buffer.h"
+#include "content/public/browser/browser_thread.h"
namespace content {
namespace {
+// The maximum size used to store one trace event. The ad hoc trace format for
+// atrace is 1024 bytes. Here we add additional size as we're using JSON and
+// have additional data fields.
+constexpr size_t kArcTraceMessageLength = 1024 + 512;
+
constexpr char kArcTracingAgentName[] = "arc";
constexpr char kArcTraceLabel[] = "ArcTraceEvents";
-void OnStopTracing(bool success) {
- DLOG_IF(WARNING, !success) << "Failed to stop ARC tracing.";
-}
+// Number of events for the ring buffer.
+constexpr size_t kTraceEventBufferSize = 64000;
+
+// A helper class for reading trace data from the client side. We separate this
+// from |ArcTracingAgentImpl| to isolate the logic that runs on browser's IO
+// thread. All the functions in this class except for constructor, destructor,
+// and |GetWeakPtr| are expected to be run on browser's IO thread.
+class ArcTracingReader {
+ public:
+ using StopTracingCallback =
+ base::Callback<void(const scoped_refptr<base::RefCountedString>&)>;
+
+ ArcTracingReader() : weak_ptr_factory_(this) {}
+
+ void StartTracing(base::ScopedFD read_fd) {
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
+ read_fd_ = std::move(read_fd);
+ // We don't use the weak pointer returned by |GetWeakPtr| to avoid using it
+ // on different task runner. Instead, we use |base::Unretained| here as
+ // |fd_watcher_| is always destroyed before |this| is destroyed.
+ fd_watcher_ = base::FileDescriptorWatcher::WatchReadable(
+ read_fd_.get(), base::Bind(&ArcTracingReader::OnTraceDataAvailable,
+ base::Unretained(this)));
+ }
+
+ void OnTraceDataAvailable() {
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+ char buf[kArcTraceMessageLength];
+ std::vector<base::ScopedFD> unused_fds;
+ ssize_t n = base::UnixDomainSocket::RecvMsg(
+ read_fd_.get(), buf, kArcTraceMessageLength, &unused_fds);
+ // When EOF, return and do nothing. The clean up is done in StopTracing.
+ if (n == 0)
+ return;
+
+ if (n < 0) {
+ DPLOG(WARNING) << "Unexpected error while reading trace from client.";
+ // Do nothing here as StopTracing will do the clean up and the existing
+ // trace logs will be returned.
+ return;
+ }
+
+ if (n > static_cast<ssize_t>(kArcTraceMessageLength)) {
+ DLOG(WARNING) << "Unexpected data size when reading trace from client.";
+ return;
+ }
+ ring_buffer_.SaveToBuffer(std::string(buf, n));
+ }
+
+ void StopTracing(const StopTracingCallback& callback) {
+ DCHECK_CURRENTLY_ON(BrowserThread::IO);
+ fd_watcher_.reset();
+ read_fd_.reset();
+
+ bool append_comma = false;
+ std::string data;
+ for (auto it = ring_buffer_.Begin(); it; ++it) {
+ if (append_comma)
+ data.append(",");
+ else
+ append_comma = true;
+ data.append(**it);
+ }
+ ring_buffer_.Clear();
+
+ BrowserThread::PostTask(
+ BrowserThread::IO, FROM_HERE,
+ base::Bind(callback, base::RefCountedString::TakeString(&data)));
+ }
+
+ base::WeakPtr<ArcTracingReader> GetWeakPtr() {
+ return weak_ptr_factory_.GetWeakPtr();
+ }
+
+ private:
+ base::ScopedFD read_fd_;
+ std::unique_ptr<base::FileDescriptorWatcher::Controller> fd_watcher_;
+ cc::RingBuffer<std::string, kTraceEventBufferSize> ring_buffer_;
+ // NOTE: Weak pointers must be invalidated before all other member variables
+ // so it must be the last member.
+ base::WeakPtrFactory<ArcTracingReader> weak_ptr_factory_;
+
+ DISALLOW_COPY_AND_ASSIGN(ArcTracingReader);
+};
class ArcTracingAgentImpl : public ArcTracingAgent {
public:
@@ -32,10 +131,16 @@ class ArcTracingAgentImpl : public ArcTracingAgent {
void StartAgentTracing(const base::trace_event::TraceConfig& trace_config,
const StartAgentTracingCallback& callback) override {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
// delegate_ may be nullptr if ARC is not enabled on the system. In such
// case, simply do nothing.
- if (!delegate_) {
+ bool success = (delegate_ != nullptr);
+
+ base::ScopedFD write_fd, read_fd;
+ success = success && CreateSocketPair(&read_fd, &write_fd);
+
+ if (!success) {
// Use PostTask as the convention of TracingAgent. The caller expects
// callback to be called after this function returns.
base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ -43,27 +148,33 @@ class ArcTracingAgentImpl : public ArcTracingAgent {
return;
}
- delegate_->StartTracing(trace_config,
+ BrowserThread::PostTask(
+ BrowserThread::IO, FROM_HERE,
+ base::Bind(&ArcTracingReader::StartTracing, reader_.GetWeakPtr(),
+ base::Passed(&read_fd)));
+
+ delegate_->StartTracing(trace_config, std::move(write_fd),
base::Bind(callback, GetTracingAgentName()));
}
void StopAgentTracing(const StopAgentTracingCallback& callback) override {
- DCHECK(thread_checker_.CalledOnValidThread());
- if (delegate_)
- delegate_->StopTracing(base::Bind(OnStopTracing));
-
- // Trace data is collect via systrace (debugd) in dev-mode. Simply
- // return empty data here.
- std::string no_data;
- base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(callback, GetTracingAgentName(), GetTraceEventLabel(),
- base::RefCountedString::TakeString(&no_data)));
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+ if (is_stopping_) {
+ DLOG(WARNING) << "Already working on stopping ArcTracingAgent.";
+ return;
+ }
+ is_stopping_ = true;
+ if (delegate_) {
+ delegate_->StopTracing(
+ base::Bind(&ArcTracingAgentImpl::OnArcTracingStopped,
+ weak_ptr_factory_.GetWeakPtr(), callback));
+ }
}
// ArcTracingAgent overrides:
void SetDelegate(Delegate* delegate) override {
- DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
delegate_ = delegate;
}
@@ -76,11 +187,48 @@ class ArcTracingAgentImpl : public ArcTracingAgent {
// by the Singleton class.
friend struct base::DefaultSingletonTraits<ArcTracingAgentImpl>;
- ArcTracingAgentImpl() = default;
+ ArcTracingAgentImpl() : weak_ptr_factory_(this) {}
+
~ArcTracingAgentImpl() override = default;
+ void OnArcTracingStopped(const StopAgentTracingCallback& callback,
+ bool success) {
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
+ if (!success) {
+ DLOG(WARNING) << "Failed to stop ARC tracing.";
+ callback.Run(GetTracingAgentName(), GetTraceEventLabel(),
+ new base::RefCountedString());
+ is_stopping_ = false;
+ return;
+ }
+ BrowserThread::PostTask(
+ BrowserThread::IO, FROM_HERE,
+ base::Bind(&ArcTracingReader::StopTracing, reader_.GetWeakPtr(),
+ base::Bind(&ArcTracingAgentImpl::OnTracingReaderStopped,
+ weak_ptr_factory_.GetWeakPtr(), callback)));
+ }
+
+ void OnTracingReaderStopped(
+ const StopAgentTracingCallback& callback,
+ const scoped_refptr<base::RefCountedString>& data) {
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
+ callback.Run(GetTracingAgentName(), GetTraceEventLabel(), data);
+ is_stopping_ = false;
+ }
+
Delegate* delegate_ = nullptr; // Owned by ArcServiceLauncher.
- base::ThreadChecker thread_checker_;
+ // We use |reader_.GetWeakPtr()| when binding callbacks with its functions.
+ // Notes that the weak pointer returned by it can only be deferenced or
+ // invalided in the same task runner to avoid racing condition. The
+ // destruction of |reader_| is also a source of invalidation. However, we're
+ // lucky as we're using |ArcTracingAgentImpl| as a singleton, the
+ // destruction is always performed after all MessageLoops are destroyed, and
+ // thus there are no race conditions in such situation.
+ ArcTracingReader reader_;
+ bool is_stopping_ = false;
+ // NOTE: Weak pointers must be invalidated before all other member variables
+ // so it must be the last member.
+ base::WeakPtrFactory<ArcTracingAgentImpl> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(ArcTracingAgentImpl);
};
« no previous file with comments | « content/browser/tracing/arc_tracing_agent.h ('k') | content/browser/tracing/tracing_controller_impl.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698