Merge "Fix base::Subprocess move ctor and operator="
diff --git a/include/perfetto/ext/ipc/client.h b/include/perfetto/ext/ipc/client.h
index 72c3e73..bf8242f 100644
--- a/include/perfetto/ext/ipc/client.h
+++ b/include/perfetto/ext/ipc/client.h
@@ -45,6 +45,7 @@
class Client {
public:
static std::unique_ptr<Client> CreateInstance(const char* socket_name,
+ bool socket_retry,
base::TaskRunner*);
virtual ~Client();
diff --git a/include/perfetto/ext/tracing/ipc/producer_ipc_client.h b/include/perfetto/ext/tracing/ipc/producer_ipc_client.h
index 5469ded..23a85d6 100644
--- a/include/perfetto/ext/tracing/ipc/producer_ipc_client.h
+++ b/include/perfetto/ext/tracing/ipc/producer_ipc_client.h
@@ -36,6 +36,16 @@
// src/tracing/ipc/producer/producer_ipc_client_impl.cc
class PERFETTO_EXPORT ProducerIPCClient {
public:
+ enum class ConnectionFlags {
+ // Fails immediately with OnConnect(false) if the service connection cannot
+ // be established.
+ kDefault = 0,
+
+ // Keeps retrying with exponential backoff indefinitely. The caller will
+ // never see an OnConnect(false).
+ kRetryIfUnreachable = 1,
+ };
+
// Connects to the producer port of the Service listening on the given
// |service_sock_name|. If the connection is successful, the OnConnect()
// method will be invoked asynchronously on the passed Producer interface. If
@@ -61,7 +71,8 @@
size_t shared_memory_size_hint_bytes = 0,
size_t shared_memory_page_size_hint_bytes = 0,
std::unique_ptr<SharedMemory> shm = nullptr,
- std::unique_ptr<SharedMemoryArbiter> shm_arbiter = nullptr);
+ std::unique_ptr<SharedMemoryArbiter> shm_arbiter = nullptr,
+ ConnectionFlags = ConnectionFlags::kDefault);
protected:
ProducerIPCClient() = delete;
diff --git a/src/ipc/client_impl.cc b/src/ipc/client_impl.cc
index c569eb4..f694547 100644
--- a/src/ipc/client_impl.cc
+++ b/src/ipc/client_impl.cc
@@ -38,16 +38,21 @@
// static
std::unique_ptr<Client> Client::CreateInstance(const char* socket_name,
+ bool socket_retry,
base::TaskRunner* task_runner) {
- std::unique_ptr<Client> client(new ClientImpl(socket_name, task_runner));
+ std::unique_ptr<Client> client(
+ new ClientImpl(socket_name, socket_retry, task_runner));
return client;
}
-ClientImpl::ClientImpl(const char* socket_name, base::TaskRunner* task_runner)
- : task_runner_(task_runner), weak_ptr_factory_(this) {
- sock_ = base::UnixSocket::Connect(socket_name, this, task_runner,
- base::SockFamily::kUnix,
- base::SockType::kStream);
+ClientImpl::ClientImpl(const char* socket_name,
+ bool socket_retry,
+ base::TaskRunner* task_runner)
+ : socket_name_(socket_name),
+ socket_retry_(socket_retry),
+ task_runner_(task_runner),
+ weak_ptr_factory_(this) {
+ TryConnect();
}
ClientImpl::~ClientImpl() {
@@ -57,6 +62,12 @@
nullptr); // The base::UnixSocket* ptr is not used in OnDisconnect().
}
+void ClientImpl::TryConnect() {
+ sock_ = base::UnixSocket::Connect(socket_name_, this, task_runner_,
+ base::SockFamily::kUnix,
+ base::SockType::kStream);
+}
+
void ClientImpl::BindService(base::WeakPtr<ServiceProxy> service_proxy) {
if (!service_proxy)
return;
@@ -129,6 +140,22 @@
}
void ClientImpl::OnConnect(base::UnixSocket*, bool connected) {
+ if (!connected && socket_retry_) {
+ socket_backoff_ms_ =
+ (socket_backoff_ms_ < 10000) ? socket_backoff_ms_ + 1000 : 30000;
+ PERFETTO_DLOG(
+ "Connection to traced's UNIX socket failed, retrying in %u seconds",
+ socket_backoff_ms_ / 1000);
+ auto weak_this = weak_ptr_factory_.GetWeakPtr();
+ task_runner_->PostDelayedTask(
+ [weak_this] {
+ if (weak_this)
+ static_cast<ClientImpl&>(*weak_this).TryConnect();
+ },
+ socket_backoff_ms_);
+ return;
+ }
+
// Drain the BindService() calls that were queued before establishig the
// connection with the host.
for (base::WeakPtr<ServiceProxy>& service_proxy : queued_bindings_) {
diff --git a/src/ipc/client_impl.h b/src/ipc/client_impl.h
index ff9c7bc..3947823 100644
--- a/src/ipc/client_impl.h
+++ b/src/ipc/client_impl.h
@@ -46,7 +46,7 @@
class ClientImpl : public Client, public base::UnixSocket::EventListener {
public:
- ClientImpl(const char* socket_name, base::TaskRunner*);
+ ClientImpl(const char* socket_name, bool socket_retry, base::TaskRunner*);
~ClientImpl() override;
// Client implementation.
@@ -81,6 +81,7 @@
ClientImpl(const ClientImpl&) = delete;
ClientImpl& operator=(const ClientImpl&) = delete;
+ void TryConnect();
bool SendFrame(const Frame&, int fd = -1);
void OnFrameReceived(const Frame&);
void OnBindServiceReply(QueuedRequest,
@@ -89,6 +90,9 @@
const protos::gen::IPCFrame_InvokeMethodReply&);
bool invoking_method_reply_ = false;
+ const char* socket_name_ = nullptr;
+ bool socket_retry_ = false;
+ uint32_t socket_backoff_ms_ = 0;
std::unique_ptr<base::UnixSocket> sock_;
base::TaskRunner* const task_runner_;
RequestID last_request_id_ = 0;
diff --git a/src/ipc/client_impl_unittest.cc b/src/ipc/client_impl_unittest.cc
index 183fbf0..61437af 100644
--- a/src/ipc/client_impl_unittest.cc
+++ b/src/ipc/client_impl_unittest.cc
@@ -205,7 +205,8 @@
void SetUp() override {
task_runner_.reset(new base::TestTaskRunner());
host_.reset(new FakeHost(task_runner_.get()));
- cli_ = Client::CreateInstance(kSockName, task_runner_.get());
+ cli_ =
+ Client::CreateInstance(kSockName, /*retry=*/false, task_runner_.get());
}
void TearDown() override {
diff --git a/src/ipc/test/ipc_integrationtest.cc b/src/ipc/test/ipc_integrationtest.cc
index b681f95..fe778b4 100644
--- a/src/ipc/test/ipc_integrationtest.cc
+++ b/src/ipc/test/ipc_integrationtest.cc
@@ -81,7 +81,7 @@
auto on_connect = task_runner_.CreateCheckpoint("on_connect");
EXPECT_CALL(svc_proxy_events_, OnConnect()).WillOnce(Invoke(on_connect));
std::unique_ptr<Client> cli =
- Client::CreateInstance(kSockName, &task_runner_);
+ Client::CreateInstance(kSockName, /*retry=*/false, &task_runner_);
std::unique_ptr<GreeterProxy> svc_proxy(new GreeterProxy(&svc_proxy_events_));
cli->BindService(svc_proxy->GetWeakPtr());
task_runner_.RunUntilCheckpoint("on_connect");
diff --git a/src/profiling/memory/BUILD.gn b/src/profiling/memory/BUILD.gn
index 5dd107c..4ad81ac 100644
--- a/src/profiling/memory/BUILD.gn
+++ b/src/profiling/memory/BUILD.gn
@@ -90,6 +90,15 @@
sources = [ "client_ext_standalone.cc" ]
}
+shared_library("heapprofd_standalone_client_noop") {
+ deps = [ "../../../gn:default_deps" ]
+ ldflags = [
+ "-Wl,--version-script",
+ rebase_path("heapprofd_client_api.map.txt", root_build_dir),
+ ]
+ sources = [ "client_ext_noop.cc" ]
+}
+
shared_library("heapprofd_client_api") {
configs -= [ "//gn/standalone:android_liblog" ]
if (perfetto_build_with_android) {
diff --git a/src/profiling/memory/client_ext_noop.cc b/src/profiling/memory/client_ext_noop.cc
new file mode 100644
index 0000000..1d2a98d
--- /dev/null
+++ b/src/profiling/memory/client_ext_noop.cc
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "perfetto/profiling/memory/client_ext.h"
+
+#include <inttypes.h>
+
+__attribute__((visibility("default"))) uint32_t heapprofd_register_heap(
+ const HeapprofdHeapInfo*,
+ size_t) {
+ return 0;
+}
+
+__attribute__((visibility("default"))) bool
+heapprofd_report_allocation(uint32_t, uint64_t, uint64_t) {
+ return false;
+}
+
+__attribute__((visibility("default"))) void heapprofd_report_free(uint32_t,
+ uint64_t) {}
+
+__attribute__((visibility("default"))) bool heapprofd_init_session(
+ void* (*)(size_t),
+ void (*)(void*)) {
+ return false;
+}
diff --git a/src/traced/probes/probes_producer.cc b/src/traced/probes/probes_producer.cc
index 69072c7..58389b8 100644
--- a/src/traced/probes/probes_producer.cc
+++ b/src/traced/probes/probes_producer.cc
@@ -129,7 +129,6 @@
// to reset all the data sources. Trying to handle that manually is going to
// be error prone. What we do here is simply destroying the instance and
// recreating it again.
- // TODO(hjd): Add e2e test for this.
base::TaskRunner* task_runner = task_runner_;
const char* socket_name = socket_name_;
diff --git a/src/tracing/internal/system_tracing_backend.cc b/src/tracing/internal/system_tracing_backend.cc
index 987f956..cbc53c8 100644
--- a/src/tracing/internal/system_tracing_backend.cc
+++ b/src/tracing/internal/system_tracing_backend.cc
@@ -40,7 +40,8 @@
auto endpoint = ProducerIPCClient::Connect(
GetProducerSocket(), args.producer, args.producer_name, args.task_runner,
TracingService::ProducerSMBScrapingMode::kEnabled,
- args.shmem_size_hint_bytes, args.shmem_page_size_hint_bytes);
+ args.shmem_size_hint_bytes, args.shmem_page_size_hint_bytes, nullptr,
+ nullptr, ProducerIPCClient::ConnectionFlags::kRetryIfUnreachable);
PERFETTO_CHECK(endpoint);
return endpoint;
}
diff --git a/src/tracing/internal/tracing_muxer_impl.cc b/src/tracing/internal/tracing_muxer_impl.cc
index 7511018..c0e6d4a 100644
--- a/src/tracing/internal/tracing_muxer_impl.cc
+++ b/src/tracing/internal/tracing_muxer_impl.cc
@@ -86,8 +86,15 @@
void TracingMuxerImpl::ProducerImpl::OnDisconnect() {
PERFETTO_DCHECK_THREAD(thread_checker_);
connected_ = false;
- // TODO: handle more graceful.
- PERFETTO_ELOG("Cannot connect to traced. Is it running?");
+ // TODO: handle more gracefully. Right now we only handle the case of retrying
+ // when not being able to reach the service in the first place (this is
+ // handled transparently by ProducerIPCClientImpl).
+ // If the connection is dropped afterwards (e.g., traced crashes), instead, we
+ // don't recover from that. In order to handle that we would have to reconnect
+ // and re-register all the data sources.
+ PERFETTO_ELOG(
+ "The connection to the tracing service dropped. Tracing will no longer "
+ "work until this process is restarted");
}
void TracingMuxerImpl::ProducerImpl::OnTracingSetup() {
diff --git a/src/tracing/ipc/consumer/consumer_ipc_client_impl.cc b/src/tracing/ipc/consumer/consumer_ipc_client_impl.cc
index 7d60e5e..336b2af 100644
--- a/src/tracing/ipc/consumer/consumer_ipc_client_impl.cc
+++ b/src/tracing/ipc/consumer/consumer_ipc_client_impl.cc
@@ -46,7 +46,9 @@
Consumer* consumer,
base::TaskRunner* task_runner)
: consumer_(consumer),
- ipc_channel_(ipc::Client::CreateInstance(service_sock_name, task_runner)),
+ ipc_channel_(ipc::Client::CreateInstance(service_sock_name,
+ /*retry=*/false,
+ task_runner)),
consumer_port_(this /* event_listener */),
weak_ptr_factory_(this) {
ipc_channel_->BindService(consumer_port_.GetWeakPtr());
diff --git a/src/tracing/ipc/producer/producer_ipc_client_impl.cc b/src/tracing/ipc/producer/producer_ipc_client_impl.cc
index 58fc05d..244d7df 100644
--- a/src/tracing/ipc/producer/producer_ipc_client_impl.cc
+++ b/src/tracing/ipc/producer/producer_ipc_client_impl.cc
@@ -47,13 +47,14 @@
size_t shared_memory_size_hint_bytes,
size_t shared_memory_page_size_hint_bytes,
std::unique_ptr<SharedMemory> shm,
- std::unique_ptr<SharedMemoryArbiter> shm_arbiter) {
+ std::unique_ptr<SharedMemoryArbiter> shm_arbiter,
+ ConnectionFlags conn_flags) {
return std::unique_ptr<TracingService::ProducerEndpoint>(
- new ProducerIPCClientImpl(service_sock_name, producer, producer_name,
- task_runner, smb_scraping_mode,
- shared_memory_size_hint_bytes,
- shared_memory_page_size_hint_bytes,
- std::move(shm), std::move(shm_arbiter)));
+ new ProducerIPCClientImpl(
+ service_sock_name, producer, producer_name, task_runner,
+ smb_scraping_mode, shared_memory_size_hint_bytes,
+ shared_memory_page_size_hint_bytes, std::move(shm),
+ std::move(shm_arbiter), conn_flags));
}
ProducerIPCClientImpl::ProducerIPCClientImpl(
@@ -65,10 +66,14 @@
size_t shared_memory_size_hint_bytes,
size_t shared_memory_page_size_hint_bytes,
std::unique_ptr<SharedMemory> shm,
- std::unique_ptr<SharedMemoryArbiter> shm_arbiter)
+ std::unique_ptr<SharedMemoryArbiter> shm_arbiter,
+ ProducerIPCClient::ConnectionFlags conn_flags)
: producer_(producer),
task_runner_(task_runner),
- ipc_channel_(ipc::Client::CreateInstance(service_sock_name, task_runner)),
+ ipc_channel_(ipc::Client::CreateInstance(
+ service_sock_name,
+ conn_flags == ProducerIPCClient::ConnectionFlags::kRetryIfUnreachable,
+ task_runner)),
producer_port_(this /* event_listener */),
shared_memory_(std::move(shm)),
shared_memory_arbiter_(std::move(shm_arbiter)),
diff --git a/src/tracing/ipc/producer/producer_ipc_client_impl.h b/src/tracing/ipc/producer/producer_ipc_client_impl.h
index 2995d38..64d9742 100644
--- a/src/tracing/ipc/producer/producer_ipc_client_impl.h
+++ b/src/tracing/ipc/producer/producer_ipc_client_impl.h
@@ -51,16 +51,16 @@
class ProducerIPCClientImpl : public TracingService::ProducerEndpoint,
public ipc::ServiceProxy::EventListener {
public:
- ProducerIPCClientImpl(
- const char* service_sock_name,
- Producer*,
- const std::string& producer_name,
- base::TaskRunner*,
- TracingService::ProducerSMBScrapingMode,
- size_t shared_memory_size_hint_bytes = 0,
- size_t shared_memory_page_size_hint_bytes = 0,
- std::unique_ptr<SharedMemory> shm = nullptr,
- std::unique_ptr<SharedMemoryArbiter> shm_arbiter = nullptr);
+ ProducerIPCClientImpl(const char* service_sock_name,
+ Producer*,
+ const std::string& producer_name,
+ base::TaskRunner*,
+ TracingService::ProducerSMBScrapingMode,
+ size_t shared_memory_size_hint_bytes,
+ size_t shared_memory_page_size_hint_bytes,
+ std::unique_ptr<SharedMemory> shm,
+ std::unique_ptr<SharedMemoryArbiter> shm_arbiter,
+ ProducerIPCClient::ConnectionFlags);
~ProducerIPCClientImpl() override;
// TracingService::ProducerEndpoint implementation.
diff --git a/tools/heap_profile b/tools/heap_profile
index a595e8c..812b8fa 100755
--- a/tools/heap_profile
+++ b/tools/heap_profile
@@ -89,11 +89,9 @@
config {{
name: "android.heapprofd"
heapprofd_config {{
-
shmem_size_bytes: {shmem_size}
sampling_interval_bytes: {interval}
{target_cfg}
-{continuous_dump_cfg}
}}
}}
}}
@@ -156,10 +154,10 @@
parser.add_argument(
"-d",
"--duration",
- help="Duration of profile (ms). "
- "Default 7 days.",
+ help="Duration of profile (ms). 0 to run until interrupted. "
+ "Default: until interrupted by user.",
type=int,
- default=604800000)
+ default=0)
# This flag is a no-op now. We never start heapprofd explicitly using system
# properties.
parser.add_argument(
@@ -296,21 +294,23 @@
target_cfg = ""
if not args.no_block_client:
- target_cfg += "block_client: true\n"
+ target_cfg += CFG_INDENT + "block_client: true\n"
if args.block_client_timeout:
- target_cfg += "block_client_timeout_us: %s\n" % args.block_client_timeout
+ target_cfg += (
+ CFG_INDENT + "block_client_timeout_us: %s\n" % args.block_client_timeout
+ )
if args.idle_allocations:
- target_cfg += "idle_allocations: true\n"
+ target_cfg += CFG_INDENT + "idle_allocations: true\n"
if args.no_startup:
- target_cfg += "no_startup: true\n"
+ target_cfg += CFG_INDENT + "no_startup: true\n"
if args.no_running:
- target_cfg += "no_running: true\n"
+ target_cfg += CFG_INDENT + "no_running: true\n"
if args.dump_at_max:
- target_cfg += "dump_at_max: true\n"
+ target_cfg += CFG_INDENT + "dump_at_max: true\n"
if args.disable_fork_teardown:
- target_cfg += "disable_fork_teardown: true\n"
+ target_cfg += CFG_INDENT + "disable_fork_teardown: true\n"
if args.all_heaps:
- target_cfg += "all_heaps: true\n"
+ target_cfg += CFG_INDENT + "all_heaps: true\n"
if args.pid:
for pid in args.pid.split(','):
try:
@@ -318,19 +318,36 @@
except ValueError:
print("FATAL: invalid PID %s" % pid, file=sys.stderr)
fail = True
- target_cfg += '{}pid: {}\n'.format(CFG_INDENT, pid)
+ target_cfg += CFG_INDENT + 'pid: {}\n'.format(pid)
if args.name:
for name in args.name.split(','):
- target_cfg += '{}process_cmdline: "{}"\n'.format(CFG_INDENT, name)
+ target_cfg += CFG_INDENT + 'process_cmdline: "{}"\n'.format(name)
if args.heaps:
for heap in args.heaps.split(','):
- target_cfg += '{}heaps: "{}"\n'.format(CFG_INDENT, heap)
+ target_cfg += CFG_INDENT + 'heaps: "{}"\n'.format(heap)
if fail:
parser.print_help()
return 1
trace_to_text_binary = args.trace_to_text_binary
+
+ if args.continuous_dump:
+ target_cfg += CONTINUOUS_DUMP.format(dump_interval=args.continuous_dump)
+ cfg = CFG.format(
+ interval=args.interval,
+ duration=args.duration,
+ target_cfg=target_cfg,
+ shmem_size=args.shmem_size)
+ if not args.no_versions:
+ cfg += PACKAGES_LIST_CFG
+
+ if args.print_config:
+ print(cfg)
+ return 0
+
+ # Do this AFTER print_config so we do not download trace_to_text only to
+ # print out the config.
if trace_to_text_binary is None:
platform = None
if sys.platform.startswith('linux'):
@@ -343,23 +360,6 @@
trace_to_text_binary = load_trace_to_text(platform)
- continuous_dump_cfg = ""
- if args.continuous_dump:
- continuous_dump_cfg = CONTINUOUS_DUMP.format(
- dump_interval=args.continuous_dump)
- cfg = CFG.format(
- interval=args.interval,
- duration=args.duration,
- target_cfg=target_cfg,
- continuous_dump_cfg=continuous_dump_cfg,
- shmem_size=args.shmem_size)
- if not args.no_versions:
- cfg += PACKAGES_LIST_CFG
-
- if args.print_config:
- print(cfg)
- return 0
-
# TODO(fmayer): Maybe feature detect whether we can remove traces instead of
# this.
uuid_trace = release_or_newer('R')
