Merge changes from topic 'adb_trace' (8e7c782e) · Commits · e / os / android_system_core

adb/adb_trace.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -58,4 +58,8 @@ extern int adb_trace_mask;
		void adb_trace_init(char**);
		void adb_trace_enable(AdbTrace trace_tag);

		#define ATRACE_TAG ATRACE_TAG_ADB
		#include <cutils/trace.h>
		#include <utils/Trace.h>

		#endif /* __ADB_TRACE_H */

adb/file_sync_service.cpp

+32 −6

Original line number	Diff line number	Diff line
		@@ -39,10 +39,13 @@

		#include "adb.h"
		#include "adb_io.h"
		#include "adb_trace.h"
		#include "adb_utils.h"
		#include "security_log_tags.h"
		#include "sysdeps/errno.h"

		using android::base::StringPrintf;

		static bool should_use_fs_config(const std::string& path) {
		// TODO: use fs_config to configure permissions on /data.
		return android::base::StartsWith(path, "/system/") \|\|
		@@ -152,7 +155,7 @@ static bool do_list(int s, const char* path) {
		if (!d) goto done;

		while ((de = readdir(d.get()))) {
		std::string filename(android::base::StringPrintf("%s/%s", path, de->d_name));
		std::string filename(StringPrintf("%s/%s", path, de->d_name));

		struct stat st;
		if (lstat(filename.c_str(), &st) == 0) {
		@@ -191,7 +194,7 @@ static bool SendSyncFail(int fd, const std::string& reason) {
		}

		static bool SendSyncFailErrno(int fd, const std::string& reason) {
		return SendSyncFail(fd, android::base::StringPrintf("%s: %s", reason.c_str(), strerror(errno)));
		return SendSyncFail(fd, StringPrintf("%s: %s", reason.c_str(), strerror(errno)));
		}

		static bool handle_send_file(int s, const char* path, uid_t uid, gid_t gid, uint64_t capabilities,
		@@ -433,9 +436,31 @@ static bool do_recv(int s, const char* path, std::vector<char>& buffer) {
		return WriteFdExactly(s, &msg.data, sizeof(msg.data));
		}

		static const char* sync_id_to_name(uint32_t id) {
		switch (id) {
		case ID_LSTAT_V1:
		return "lstat_v1";
		case ID_LSTAT_V2:
		return "lstat_v2";
		case ID_STAT_V2:
		return "stat_v2";
		case ID_LIST:
		return "list";
		case ID_SEND:
		return "send";
		case ID_RECV:
		return "recv";
		case ID_QUIT:
		return "quit";
		default:
		return "???";
		}
		}

		static bool handle_sync_command(int fd, std::vector<char>& buffer) {
		D("sync: waiting for request");

		ATRACE_CALL();
		SyncRequest request;
		if (!ReadFdExactly(fd, &request, sizeof(request))) {
		SendSyncFail(fd, "command read failure");
		@@ -453,9 +478,11 @@ static bool handle_sync_command(int fd, std::vector<char>& buffer) {
		}
		name[path_length] = 0;

		const char* id = reinterpret_cast<const char*>(&request.id);
		D("sync: '%.4s' '%s'", id, name);
		std::string id_name = sync_id_to_name(request.id);
		std::string trace_name = StringPrintf("%s(%s)", id_name.c_str(), name);
		ATRACE_NAME(trace_name.c_str());

		D("sync: %s('%s')", id_name.c_str(), name);
		switch (request.id) {
		case ID_LSTAT_V1:
		if (!do_lstat_v1(fd, name)) return false;
		@@ -476,8 +503,7 @@ static bool handle_sync_command(int fd, std::vector<char>& buffer) {
		case ID_QUIT:
		return false;
		default:
		SendSyncFail(
		fd, android::base::StringPrintf("unknown command '%.4s' (%08x)", id, request.id));
		SendSyncFail(fd, StringPrintf("unknown command %08x", request.id));
		return false;
		}

adb/transport.cpp

+175 −212

Original line number	Diff line number	Diff line
		@@ -37,6 +37,7 @@

		#include "adb.h"
		#include "adb_auth.h"
		#include "adb_trace.h"
		#include "adb_utils.h"
		#include "diagnose_usb.h"

		@@ -60,8 +61,7 @@ static std::string dump_packet(const char* name, const char* func, apacket* p) {

		for (n = 0; n < 4; n++) {
		int b = (command >> (n * 8)) & 255;
		if (b < 32 \|\| b >= 127)
		break;
		if (b < 32 \|\| b >= 127) break;
		cmd[n] = (char)b;
		}
		if (n == 4) {
		@@ -82,15 +82,14 @@ static std::string dump_packet(const char* name, const char* func, apacket* p) {
		else
		snprintf(arg1, sizeof arg1, "0x%x", p->msg.arg1);

		std::string result = android::base::StringPrintf("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ",
		name, func, cmd, arg0, arg1, len);
		std::string result = android::base::StringPrintf("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ", name,
		func, cmd, arg0, arg1, len);
		result += dump_hex(p->data, len);
		return result;
		}

		static int
		read_packet(int fd, const char* name, apacket** ppacket)
		{
		static int read_packet(int fd, const char* name, apacket** ppacket) {
		ATRACE_NAME("read_packet");
		char buff[8];
		if (!name) {
		snprintf(buff, sizeof buff, "fd=%d", fd);
		@@ -113,9 +112,8 @@ read_packet(int fd, const char* name, apacket** ppacket)
		return 0;
		}

		static int
		write_packet(int fd, const char* name, apacket** ppacket)
		{
		static int write_packet(int fd, const char* name, apacket** ppacket) {
		ATRACE_NAME("write_packet");
		char buff[8];
		if (!name) {
		snprintf(buff, sizeof buff, "fd=%d", fd);
		@@ -137,8 +135,7 @@ write_packet(int fd, const char* name, apacket** ppacket)
		return 0;
		}

		static void transport_socket_events(int fd, unsigned events, void *_t)
		{
		static void transport_socket_events(int fd, unsigned events, void* _t) {
		atransport* t = reinterpret_cast<atransport*>(_t);
		D("transport_socket_events(fd=%d, events=%04x,...)", fd, events);
		if (events & FDE_READ) {
		@@ -183,10 +180,10 @@ static void read_transport_thread(void* _t) {
		atransport* t = reinterpret_cast<atransport*>(_t);
		apacket* p;

		adb_thread_setname(android::base::StringPrintf("<-%s",
		(t->serial != nullptr ? t->serial : "transport")));
		D("%s: starting read_transport thread on fd %d, SYNC online (%d)",
		t->serial, t->fd, t->sync_token + 1);
		adb_thread_setname(
		android::base::StringPrintf("<-%s", (t->serial != nullptr ? t->serial : "transport")));
		D("%s: starting read_transport thread on fd %d, SYNC online (%d)", t->serial, t->fd,
		t->sync_token + 1);
		p = get_apacket();
		p->msg.command = A_SYNC;
		p->msg.arg0 = 1;
		@@ -200,21 +197,24 @@ static void read_transport_thread(void* _t) {

		D("%s: data pump started", t->serial);
		for (;;) {
		ATRACE_NAME("read_transport loop");
		p = get_apacket();

		if(t->read_from_remote(p, t) == 0){
		D("%s: received remote packet, sending to transport",
		t->serial);
		{
		ATRACE_NAME("read_transport read_remote");
		if (t->read_from_remote(p, t) != 0) {
		D("%s: remote read failed for transport", t->serial);
		put_apacket(p);
		break;
		}
		}

		D("%s: received remote packet, sending to transport", t->serial);
		if (write_packet(t->fd, t->serial, &p)) {
		put_apacket(p);
		D("%s: failed to write apacket to transport", t->serial);
		goto oops;
		}
		} else {
		D("%s: remote read failed for transport", t->serial);
		put_apacket(p);
		break;
		}
		}

		D("%s: SYNC offline for transport", t->serial);
		@@ -241,17 +241,17 @@ static void write_transport_thread(void* _t) {
		apacket* p;
		int active = 0;

		adb_thread_setname(android::base::StringPrintf("->%s",
		(t->serial != nullptr ? t->serial : "transport")));
		D("%s: starting write_transport thread, reading from fd %d",
		t->serial, t->fd);
		adb_thread_setname(
		android::base::StringPrintf("->%s", (t->serial != nullptr ? t->serial : "transport")));
		D("%s: starting write_transport thread, reading from fd %d", t->serial, t->fd);

		for (;;) {
		ATRACE_NAME("write_transport loop");
		if (read_packet(t->fd, t->serial, &p)) {
		D("%s: failed to read apacket from transport on fd %d",
		t->serial, t->fd );
		D("%s: failed to read apacket from transport on fd %d", t->serial, t->fd);
		break;
		}

		if (p->msg.command == A_SYNC) {
		if (p->msg.arg0 == 0) {
		D("%s: transport SYNC offline", t->serial);
		@@ -262,13 +262,13 @@ static void write_transport_thread(void* _t) {
		D("%s: transport SYNC online", t->serial);
		active = 1;
		} else {
		D("%s: transport ignoring SYNC %d != %d",
		t->serial, p->msg.arg1, t->sync_token);
		D("%s: transport ignoring SYNC %d != %d", t->serial, p->msg.arg1, t->sync_token);
		}
		}
		} else {
		if (active) {
		D("%s: transport got packet, sending to remote", t->serial);
		ATRACE_NAME("write_transport write_remote");
		t->write_to_remote(p, t);
		} else {
		D("%s: transport ignoring packet while offline", t->serial);
		@@ -296,7 +296,6 @@ static int transport_registration_send = -1;
		static int transport_registration_recv = -1;
		static fdevent transport_registration_fde;


		#if ADB_HOST

		/* this adds support required by the 'track-devices' service.
		@@ -313,9 +312,7 @@ struct device_tracker {
		/* linked list of all device trackers */
		static device_tracker* device_tracker_list;

		static void
		device_tracker_remove( device_tracker* tracker )
		{
		static void device_tracker_remove(device_tracker* tracker) {
		device_tracker** pnode = &device_tracker_list;
		device_tracker* node = *pnode;

		@@ -330,9 +327,7 @@ device_tracker_remove( device_tracker* tracker )
		}
		}

		static void
		device_tracker_close( asocket* socket )
		{
		static void device_tracker_close(asocket* socket) {
		device_tracker* tracker = (device_tracker*)socket;
		asocket* peer = socket->peer;

		@@ -345,9 +340,7 @@ device_tracker_close( asocket* socket )
		free(tracker);
		}

		static int
		device_tracker_enqueue( asocket* socket, apacket* p )
		{
		static int device_tracker_enqueue(asocket* socket, apacket* p) {
		/* you can't read from a device tracker, close immediately */
		put_apacket(p);
		device_tracker_close(socket);
		@@ -377,9 +370,7 @@ static void device_tracker_ready(asocket* socket) {
		}
		}

		asocket*
		create_device_tracker(void)
		{
		asocket* create_device_tracker(void) {
		device_tracker* tracker = reinterpret_cast<device_tracker>(calloc(1, sizeof(tracker)));
		if (tracker == nullptr) fatal("cannot allocate device tracker");

		@@ -396,7 +387,6 @@ create_device_tracker(void)
		return &tracker->socket;
		}


		// Call this function each time the transport list has changed.
		void update_transports() {
		std::string transports = list_transports(false);
		@@ -418,15 +408,12 @@ void update_transports() {

		#endif // ADB_HOST

		struct tmsg
		{
		struct tmsg {
		atransport* transport;
		int action;
		};

		static int
		transport_read_action(int fd, struct tmsg* m)
		{
		static int transport_read_action(int fd, struct tmsg* m) {
		char* p = (char*)m;
		int len = sizeof(*m);
		int r;
		@@ -444,9 +431,7 @@ transport_read_action(int fd, struct tmsg* m)
		return 0;
		}

		static int
		transport_write_action(int fd, struct tmsg* m)
		{
		static int transport_write_action(int fd, struct tmsg* m) {
		char* p = (char*)m;
		int len = sizeof(*m);
		int r;
		@@ -464,8 +449,7 @@ transport_write_action(int fd, struct tmsg* m)
		return 0;
		}

		static void transport_registration_func(int _fd, unsigned ev, void *data)
		{
		static void transport_registration_func(int _fd, unsigned ev, void* data) {
		tmsg m;
		int s[2];
		atransport* t;
		@@ -494,16 +478,11 @@ static void transport_registration_func(int _fd, unsigned ev, void *data)
		transport_list.remove(t);
		}

		if (t->product)
		free(t->product);
		if (t->serial)
		free(t->serial);
		if (t->model)
		free(t->model);
		if (t->device)
		free(t->device);
		if (t->devpath)
		free(t->devpath);
		if (t->product) free(t->product);
		if (t->serial) free(t->serial);
		if (t->model) free(t->model);
		if (t->device) free(t->device);
		if (t->devpath) free(t->devpath);

		delete t;

		@@ -525,10 +504,7 @@ static void transport_registration_func(int _fd, unsigned ev, void *data)
		t->transport_socket = s[0];
		t->fd = s[1];

		fdevent_install(&(t->transport_fde),
		t->transport_socket,
		transport_socket_events,
		t);
		fdevent_install(&(t->transport_fde), t->transport_socket, transport_socket_events, t);

		fdevent_set(&(t->transport_fde), FDE_READ);

		@@ -550,8 +526,7 @@ static void transport_registration_func(int _fd, unsigned ev, void *data)
		update_transports();
		}

		void init_transport_registration(void)
		{
		void init_transport_registration(void) {
		int s[2];

		if (adb_socketpair(s)) {
		@@ -562,17 +537,14 @@ void init_transport_registration(void)
		transport_registration_send = s[0];
		transport_registration_recv = s[1];

		fdevent_install(&transport_registration_fde,
		transport_registration_recv,
		transport_registration_func,
		0);
		fdevent_install(&transport_registration_fde, transport_registration_recv,
		transport_registration_func, 0);

		fdevent_set(&transport_registration_fde, FDE_READ);
		}

		/* the fdevent select pump is single threaded */
		static void register_transport(atransport *transport)
		{
		static void register_transport(atransport* transport) {
		tmsg m;
		m.transport = transport;
		m.action = 1;
		@@ -582,8 +554,7 @@ static void register_transport(atransport *transport)
		}
		}

		static void remove_transport(atransport *transport)
		{
		static void remove_transport(atransport* transport) {
		tmsg m;
		m.transport = transport;
		m.action = 0;
		@@ -593,7 +564,6 @@ static void remove_transport(atransport *transport)
		}
		}


		static void transport_unref(atransport* t) {
		CHECK(t != nullptr);

		@@ -609,37 +579,31 @@ static void transport_unref(atransport* t) {
		}
		}

		static int qual_match(const char *to_test,
		const char prefix, const char qual, bool sanitize_qual)
		{
		if (!to_test \|\| !*to_test)
		/* Return true if both the qual and to_test are null strings. */
		static int qual_match(const char* to_test, const char* prefix, const char* qual,
		bool sanitize_qual) {
		if (!to_test \|\| !to_test) / Return true if both the qual and to_test are null strings. */
		return !qual \|\| !*qual;

		if (!qual)
		return 0;
		if (!qual) return 0;

		if (prefix) {
		while (*prefix) {
		if (prefix++ != to_test++)
		return 0;
		if (prefix++ != to_test++) return 0;
		}
		}

		while (*qual) {
		char ch = *qual++;
		if (sanitize_qual && !isalnum(ch))
		ch = '_';
		if (ch != *to_test++)
		return 0;
		if (sanitize_qual && !isalnum(ch)) ch = '_';
		if (ch != *to_test++) return 0;
		}

		/* Everything matched so far. Return true if to_test is a NUL. /
		return !*to_test;
		}

		atransport* acquire_one_transport(TransportType type, const char* serial,
		bool* is_ambiguous, std::string* error_out) {
		atransport* acquire_one_transport(TransportType type, const char* serial, bool* is_ambiguous,
		std::string* error_out) {
		atransport* result = nullptr;

		if (serial) {
		@@ -737,15 +701,24 @@ void atransport::Kick() {

		const std::string atransport::connection_state_name() const {
		switch (connection_state) {
		case kCsOffline: return "offline";
		case kCsBootloader: return "bootloader";
		case kCsDevice: return "device";
		case kCsHost: return "host";
		case kCsRecovery: return "recovery";
		case kCsNoPerm: return UsbNoPermissionsShortHelpText();
		case kCsSideload: return "sideload";
		case kCsUnauthorized: return "unauthorized";
		default: return "unknown";
		case kCsOffline:
		return "offline";
		case kCsBootloader:
		return "bootloader";
		case kCsDevice:
		return "device";
		case kCsHost:
		return "host";
		case kCsRecovery:
		return "recovery";
		case kCsNoPerm:
		return UsbNoPermissionsShortHelpText();
		case kCsSideload:
		return "sideload";
		case kCsUnauthorized:
		return "unauthorized";
		default:
		return "unknown";
		}
		}

		@@ -771,9 +744,7 @@ constexpr char kFeatureStringDelimiter = ',';
		const FeatureSet& supported_features() {
		// Local static allocation to avoid global non-POD variables.
		static const FeatureSet* features = new FeatureSet{
		kFeatureShell2,
		kFeatureCmd,
		kFeatureStat2,
		kFeatureShell2, kFeatureCmd, kFeatureStat2,
		// Increment ADB_SERVER_VERSION whenever the feature list changes to
		// make sure that the adb client and server features stay in sync
		// (http://b/24370690).
		@@ -791,14 +762,12 @@ FeatureSet StringToFeatureSet(const std::string& features_string) {
		return FeatureSet();
		}

		auto names = android::base::Split(features_string,
		{kFeatureStringDelimiter});
		auto names = android::base::Split(features_string, {kFeatureStringDelimiter});
		return FeatureSet(names.begin(), names.end());
		}

		bool CanUseFeature(const FeatureSet& feature_set, const std::string& feature) {
		return feature_set.count(feature) > 0 &&
		supported_features().count(feature) > 0;
		return feature_set.count(feature) > 0 && supported_features().count(feature) > 0;
		}

		bool atransport::has_feature(const std::string& feature) const {
		@@ -841,8 +810,7 @@ bool atransport::MatchesTarget(const std::string& target) const {
		// Parse our \|serial\| and the given \|target\| to check if the hostnames and ports match.
		std::string serial_host, error;
		int serial_port = -1;
		if (android::base::ParseNetAddress(serial, &serial_host, &serial_port, nullptr,
		&error)) {
		if (android::base::ParseNetAddress(serial, &serial_host, &serial_port, nullptr, &error)) {
		// \|target\| may omit the port to default to ours.
		std::string target_host;
		int target_port = serial_port;
		@@ -863,8 +831,8 @@ bool atransport::MatchesTarget(const std::string& target) const {

		#if ADB_HOST

		static void append_transport_info(std::string* result, const char* key,
		const char* value, bool sanitize) {
		static void append_transport_info(std::string* result, const char* key, const char* value,
		bool sanitize) {
		if (value == nullptr \|\| *value == '\0') {
		return;
		}
		@@ -877,8 +845,7 @@ static void append_transport_info(std::string* result, const char* key,
		}
		}

		static void append_transport(const atransport* t, std::string* result,
		bool long_listing) {
		static void append_transport(const atransport* t, std::string* result, bool long_listing) {
		const char* serial = t->serial;
		if (!serial \|\| !serial[0]) {
		serial = "(no serial number)";
		@@ -889,8 +856,7 @@ static void append_transport(const atransport* t, std::string* result,
		*result += '\t';
		*result += t->connection_state_name();
		} else {
		android::base::StringAppendF(result, "%-22s %s", serial,
		t->connection_state_name().c_str());
		android::base::StringAppendF(result, "%-22s %s", serial, t->connection_state_name().c_str());

		append_transport_info(result, "", t->devpath, false);
		append_transport_info(result, "product:", t->product, false);
		@@ -998,12 +964,11 @@ void kick_all_tcp_devices() {

		#endif

		void register_usb_transport(usb_handle* usb, const char* serial,
		const char* devpath, unsigned writeable) {
		void register_usb_transport(usb_handle* usb, const char* serial, const char* devpath,
		unsigned writeable) {
		atransport* t = new atransport();

		D("transport: %p init'ing for usb_handle %p (sn='%s')", t, usb,
		serial ? serial : "");
		D("transport: %p init'ing for usb_handle %p (sn='%s')", t, usb, serial ? serial : "");
		init_usb_transport(t, usb, (writeable ? kCsOffline : kCsNoPerm));
		if (serial) {
		t->serial = strdup(serial);
		@@ -1024,21 +989,19 @@ void register_usb_transport(usb_handle* usb, const char* serial,
		// This should only be used for transports with connection_state == kCsNoPerm.
		void unregister_usb_transport(usb_handle* usb) {
		std::lock_guard<std::mutex> lock(transport_lock);
		transport_list.remove_if([usb](atransport* t) {
		return t->usb == usb && t->connection_state == kCsNoPerm;
		});
		transport_list.remove_if(
		[usb](atransport* t) { return t->usb == usb && t->connection_state == kCsNoPerm; });
		}

		int check_header(apacket p, atransport t)
		{
		int check_header(apacket* p, atransport* t) {
		if (p->msg.magic != (p->msg.command ^ 0xffffffff)) {
		VLOG(RWX) << "check_header(): invalid magic";
		return -1;
		}

		if (p->msg.data_length > t->get_max_payload()) {
		VLOG(RWX) << "check_header(): " << p->msg.data_length << " atransport::max_payload = "
		<< t->get_max_payload();
		VLOG(RWX) << "check_header(): " << p->msg.data_length
		<< " atransport::max_payload = " << t->get_max_payload();
		return -1;
		}

include/cutils/trace.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -71,7 +71,8 @@ __BEGIN_DECLS
		#define ATRACE_TAG_SYSTEM_SERVER (1<<19)
		#define ATRACE_TAG_DATABASE (1<<20)
		#define ATRACE_TAG_NETWORK (1<<21)
		#define ATRACE_TAG_LAST ATRACE_TAG_NETWORK
		#define ATRACE_TAG_ADB (1<<22)
		#define ATRACE_TAG_LAST ATRACE_TAG_ADB

		// Reserved for initialization.
		#define ATRACE_TAG_NOT_READY (1ULL<<63)

include/utils/Trace.h

+4 −4

Original line number	Diff line number	Diff line
		@@ -33,10 +33,10 @@

		// See <cutils/trace.h> for more ATRACE_* macros.

		// ATRACE_NAME traces the beginning and end of the current scope. To trace
		// the correct start and end times this macro should be declared first in the
		// scope body.
		#define ATRACE_NAME(name) android::ScopedTrace ___tracer(ATRACE_TAG, name)
		// ATRACE_NAME traces from its location until the end of its enclosing scope.
		#define _PASTE(x, y) x ## y
		#define PASTE(x, y) _PASTE(x,y)
		#define ATRACE_NAME(name) android::ScopedTrace PASTE(___tracer, __LINE__) (ATRACE_TAG, name)
		// ATRACE_CALL is an ATRACE_NAME that uses the current function name.
		#define ATRACE_CALL() ATRACE_NAME(__FUNCTION__)