tequilaOS/platform_system_core
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge changes I5fd3b25d,I6c039b32,I014d7ad2

Browse source 
* changes:
  adb: allow filtering by file in coverage/show.sh.
  adbd: don't use libc++_static.
  adb: split transport_local.cpp into client/daemon.
This commit is contained in:
Josh Gao 2020-04-23 21:53:08 +00:00 committed by Gerrit Code Review
commit a675727a81
4 changed files with 139 additions and 91 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
adb/Android.bp
View file

@ -171,7 +171,6 @@ libadb_srcs = [
"sysdeps/errno.cpp",
"transport.cpp",
"transport_fd.cpp",
"transport_local.cpp",
"types.cpp",
]
@ -217,6 +216,7 @@ cc_library_host_static {
"client/adb_wifi.cpp",
"client/usb_libusb.cpp",
"client/usb_dispatch.cpp",
"client/transport_local.cpp",
"client/transport_mdns.cpp",
"client/transport_usb.cpp",
"client/pairing/pairing_client.cpp",
@ -390,10 +390,11 @@ cc_library_static {
compile_multilib: "both",
srcs: libadb_srcs + libadb_linux_srcs + libadb_posix_srcs + [
"daemon/adb_wifi.cpp",
"daemon/auth.cpp",
"daemon/jdwp_service.cpp",
"daemon/logging.cpp",
"daemon/adb_wifi.cpp",
"daemon/transport_local.cpp",
],
generated_headers: ["platform_tools_version"],
@ -592,7 +593,6 @@ cc_library {
cc_binary {
name: "adbd",
defaults: ["adbd_defaults", "host_adbd_supported", "libadbd_binary_dependencies"],
stl: "libc++_static",
recovery_available: true,
apex_available: ["com.android.adbd"],

95
adb/transport_local.cpp → adb/client/transport_local.cpp
View file

@ -38,10 +38,6 @@
#include <android-base/thread_annotations.h>
#include <cutils/sockets.h>
#if !ADB_HOST
#include <android-base/properties.h>
#endif
#include "adb.h"
#include "adb_io.h"
#include "adb_unique_fd.h"
@ -49,8 +45,6 @@
#include "socket_spec.h"
#include "sysdeps/chrono.h"
#if ADB_HOST
// Android Wear has been using port 5601 in all of its documentation/tooling,
// but we search for emulators on ports [5554, 5555 + ADB_LOCAL_TRANSPORT_MAX].
// Avoid stomping on their port by restricting the active scanning range.
@ -76,9 +70,8 @@ static void adb_local_transport_max_port_env_override() {
// We keep a map from emulator port to transport.
// TODO: weak_ptr?
static auto& local_transports GUARDED_BY(local_transports_lock) =
*new std::unordered_map<int, atransport*>();
#endif /* ADB_HOST */
static std::unordered_map<int, atransport*> local_transports
[[clang::no_destroy]] GUARDED_BY(local_transports_lock);
bool local_connect(int port) {
std::string dummy;
@ -140,21 +133,19 @@ void connect_device(const std::string& address, std::string* response) {
}
}
int local_connect_arbitrary_ports(int console_port, int adb_port, std::string* error) {
unique_fd fd;
#if ADB_HOST
if (find_emulator_transport_by_adb_port(adb_port) != nullptr ||
find_emulator_transport_by_console_port(console_port) != nullptr) {
return -1;
}
const char *host = getenv("ADBHOST");
const char* host = getenv("ADBHOST");
if (host) {
fd.reset(network_connect(host, adb_port, SOCK_STREAM, 0, error));
}
#endif
if (fd < 0) {
fd.reset(network_loopback_client(adb_port, SOCK_STREAM, error));
}
@ -173,8 +164,6 @@ int local_connect_arbitrary_ports(int console_port, int adb_port, std::string* e
return -1;
}
#if ADB_HOST
static void PollAllLocalPortsForEmulator() {
// Try to connect to any number of running emulator instances.
for (int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT; port <= adb_local_transport_max_port;
@ -194,8 +183,8 @@ struct RetryPort {
// Retry emulators just kicked.
static std::vector<RetryPort>& retry_ports = *new std::vector<RetryPort>;
std::mutex &retry_ports_lock = *new std::mutex;
std::condition_variable &retry_ports_cond = *new std::condition_variable;
std::mutex& retry_ports_lock = *new std::mutex;
std::condition_variable& retry_ports_cond = *new std::condition_variable;
static void client_socket_thread(std::string_view) {
adb_thread_setname("client_socket_thread");
@ -220,7 +209,7 @@ static void client_socket_thread(std::string_view) {
std::vector<RetryPort> next_ports;
for (auto& port : ports) {
VLOG(TRANSPORT) << "retry port " << port.port << ", last retry_count "
<< port.retry_count;
<< port.retry_count;
if (local_connect(port.port)) {
VLOG(TRANSPORT) << "retry port " << port.port << " successfully";
continue;
@ -240,77 +229,12 @@ static void client_socket_thread(std::string_view) {
}
}
#else // !ADB_HOST
void server_socket_thread(std::function<unique_fd(std::string_view, std::string*)> listen_func,
std::string_view addr) {
adb_thread_setname("server socket");
unique_fd serverfd;
std::string error;
while (serverfd == -1) {
errno = 0;
serverfd = listen_func(addr, &error);
if (errno == EAFNOSUPPORT || errno == EINVAL || errno == EPROTONOSUPPORT) {
D("unrecoverable error: '%s'", error.c_str());
return;
} else if (serverfd < 0) {
D("server: cannot bind socket yet: %s", error.c_str());
std::this_thread::sleep_for(1s);
continue;
}
close_on_exec(serverfd.get());
}
while (true) {
D("server: trying to get new connection from fd %d", serverfd.get());
unique_fd fd(adb_socket_accept(serverfd, nullptr, nullptr));
if (fd >= 0) {
D("server: new connection on fd %d", fd.get());
close_on_exec(fd.get());
disable_tcp_nagle(fd.get());
std::string serial = android::base::StringPrintf("host-%d", fd.get());
// We don't care about port value in "register_socket_transport" as it is used
// only from ADB_HOST. "server_socket_thread" is never called from ADB_HOST.
register_socket_transport(
std::move(fd), std::move(serial), 0, 1,
[](atransport*) { return ReconnectResult::Abort; }, false);
}
}
D("transport: server_socket_thread() exiting");
}
#endif
#if !ADB_HOST
unique_fd adb_listen(std::string_view addr, std::string* error) {
return unique_fd{socket_spec_listen(addr, error, nullptr)};
}
#endif
void local_init(const std::string& addr) {
#if ADB_HOST
D("transport: local client init");
std::thread(client_socket_thread, addr).detach();
adb_local_transport_max_port_env_override();
#elif !defined(__ANDROID__)
// Host adbd.
D("transport: local server init");
std::thread(server_socket_thread, adb_listen, addr).detach();
#else
D("transport: local server init");
// For the adbd daemon in the system image we need to distinguish
// between the device, and the emulator.
if (addr.starts_with("tcp:") && use_qemu_goldfish()) {
std::thread(qemu_socket_thread, addr).detach();
} else {
std::thread(server_socket_thread, adb_listen, addr).detach();
}
#endif // !ADB_HOST
}
#if ADB_HOST
struct EmulatorConnection : public FdConnection {
EmulatorConnection(unique_fd fd, int local_port)
: FdConnection(std::move(fd)), local_port_(local_port) {}
@ -336,7 +260,7 @@ struct EmulatorConnection : public FdConnection {
/* Only call this function if you already hold local_transports_lock. */
static atransport* find_emulator_transport_by_adb_port_locked(int adb_port)
REQUIRES(local_transports_lock) {
REQUIRES(local_transports_lock) {
auto it = local_transports.find(adb_port);
if (it == local_transports.end()) {
return nullptr;
@ -352,7 +276,6 @@ atransport* find_emulator_transport_by_adb_port(int adb_port) {
atransport* find_emulator_transport_by_console_port(int console_port) {
return find_transport(getEmulatorSerialString(console_port).c_str());
}
#endif
std::string getEmulatorSerialString(int console_port) {
return android::base::StringPrintf("emulator-%d", console_port);
@ -363,7 +286,6 @@ int init_socket_transport(atransport* t, unique_fd fd, int adb_port, int local)
t->type = kTransportLocal;
#if ADB_HOST
// Emulator connection.
if (local) {
auto emulator_connection = std::make_unique<EmulatorConnection>(std::move(fd), adb_port);
@ -380,7 +302,6 @@ int init_socket_transport(atransport* t, unique_fd fd, int adb_port, int local)
return fail;
}
#endif
// Regular tcp connection.
auto fd_connection = std::make_unique<FdConnection>(std::move(fd));

12
adb/coverage/show.sh
View file

@ -5,8 +5,18 @@ set -euxo pipefail
OUTPUT_DIR=$(realpath $(dirname "$0"))
. "$OUTPUT_DIR"/include.sh
BASE_PATH=/proc/self/cwd/system/core/adb
PATHS=""
if [[ $# == 0 ]]; then
PATHS=$BASE_PATH
else
for arg in "$@"; do
PATHS="$PATHS $BASE_PATH/$arg"
done
fi
cd $ANDROID_BUILD_TOP
llvm-cov show --instr-profile="$OUTPUT_DIR"/adbd.profdata \
$ANDROID_PRODUCT_OUT/apex/com.android.adbd/bin/adbd \
/proc/self/cwd/system/core/adb \
$PATHS \
$ADB_TEST_BINARIES

117
adb/daemon/transport_local.cpp Normal file
View file

@ -0,0 +1,117 @@
/*
* Copyright (C) 2007 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.
*/
#define TRACE_TAG TRANSPORT
#include "sysdeps.h"
#include "transport.h"
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <thread>
#include <unordered_map>
#include <vector>
#include <android-base/parsenetaddress.h>
#include <android-base/stringprintf.h>
#include <android-base/thread_annotations.h>
#include <cutils/sockets.h>
#if !ADB_HOST
#include <android-base/properties.h>
#endif
#include "adb.h"
#include "adb_io.h"
#include "adb_unique_fd.h"
#include "adb_utils.h"
#include "socket_spec.h"
#include "sysdeps/chrono.h"
void server_socket_thread(std::function<unique_fd(std::string_view, std::string*)> listen_func,
std::string_view addr) {
adb_thread_setname("server socket");
unique_fd serverfd;
std::string error;
while (serverfd == -1) {
errno = 0;
serverfd = listen_func(addr, &error);
if (errno == EAFNOSUPPORT || errno == EINVAL || errno == EPROTONOSUPPORT) {
D("unrecoverable error: '%s'", error.c_str());
return;
} else if (serverfd < 0) {
D("server: cannot bind socket yet: %s", error.c_str());
std::this_thread::sleep_for(1s);
continue;
}
close_on_exec(serverfd.get());
}
while (true) {
D("server: trying to get new connection from fd %d", serverfd.get());
unique_fd fd(adb_socket_accept(serverfd, nullptr, nullptr));
if (fd >= 0) {
D("server: new connection on fd %d", fd.get());
close_on_exec(fd.get());
disable_tcp_nagle(fd.get());
std::string serial = android::base::StringPrintf("host-%d", fd.get());
// We don't care about port value in "register_socket_transport" as it is used
// only from ADB_HOST. "server_socket_thread" is never called from ADB_HOST.
register_socket_transport(
std::move(fd), std::move(serial), 0, 1,
[](atransport*) { return ReconnectResult::Abort; }, false);
}
}
D("transport: server_socket_thread() exiting");
}
unique_fd adb_listen(std::string_view addr, std::string* error) {
return unique_fd{socket_spec_listen(addr, error, nullptr)};
}
void local_init(const std::string& addr) {
#if !defined(__ANDROID__)
// Host adbd.
D("transport: local server init");
std::thread(server_socket_thread, adb_listen, addr).detach();
#else
D("transport: local server init");
// For the adbd daemon in the system image we need to distinguish
// between the device, and the emulator.
if (addr.starts_with("tcp:") && use_qemu_goldfish()) {
std::thread(qemu_socket_thread, addr).detach();
} else {
std::thread(server_socket_thread, adb_listen, addr).detach();
}
#endif // !ADB_HOST
}
int init_socket_transport(atransport* t, unique_fd fd, int adb_port, int local) {
t->type = kTransportLocal;
auto fd_connection = std::make_unique<FdConnection>(std::move(fd));
t->SetConnection(std::make_unique<BlockingConnectionAdapter>(std::move(fd_connection)));
return 0;
}