adb: retry connecting disconnected emulators instead of always looping. (b74c6498) · Commits · e / os / android_system_core

adb/adb.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -188,7 +188,7 @@ void put_apacket(apacket *p);


	void local_init(int port);		void local_init(int port);
	void local_connect(int port);		bool local_connect(int port);
	int local_connect_arbitrary_ports(int console_port, int adb_port, std::string* error);		int local_connect_arbitrary_ports(int console_port, int adb_port, std::string* error);

	// USB host/client interface.		// USB host/client interface.

adb/sysdeps/condition_variable.h

0 → 100644

+61 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2016 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.
			*/

			#pragma once

			#include <condition_variable>

			#include "sysdeps/mutex.h"

			#if defined(_WIN32)

			#include <windows.h>

			#include <android-base/macros.h>

			// The prebuilt version of mingw we use doesn't support condition_variable.
			// Therefore, implement our own using the Windows primitives.
			// Put them directly into the std namespace, so that when they're actually available, the build
			// breaks until they're removed.

			namespace std {

			class condition_variable {
			public:
			condition_variable() {
			InitializeConditionVariable(&cond_);
			}

			void wait(std::unique_lock<std::mutex>& lock) {
			std::mutex *m = lock.mutex();
			m->lock_count_--;
			SleepConditionVariableCS(&cond_, m->native_handle(), INFINITE);
			m->lock_count_++;
			}

			void notify_one() {
			WakeConditionVariable(&cond_);
			}

			private:
			CONDITION_VARIABLE cond_;

			DISALLOW_COPY_AND_ASSIGN(condition_variable);
			};

			}

			#endif // defined(_WIN32)

adb/sysdeps/mutex.h

+22 −9

Original line number	Original line	Diff line number	Diff line
	#pragma once

	/*		/*
	* Copyright (C) 2016 The Android Open Source Project		* Copyright (C) 2016 The Android Open Source Project
	*		*
	@@ -16,6 +14,7 @@
	* limitations under the License.		* limitations under the License.
	*/		*/

			#pragma once
	#if defined(_WIN32)		#if defined(_WIN32)

	#include <windows.h>		#include <windows.h>
	@@ -35,34 +34,42 @@ namespace std {
	// CRITICAL_SECTION is recursive, so just wrap it in a Mutex-compatible class.		// CRITICAL_SECTION is recursive, so just wrap it in a Mutex-compatible class.
	class recursive_mutex {		class recursive_mutex {
	public:		public:
			typedef CRITICAL_SECTION* native_handle_type;

	recursive_mutex() {		recursive_mutex() {
	InitializeCriticalSection(&mutex_);		InitializeCriticalSection(&cs_);
	}		}

	~recursive_mutex() {		~recursive_mutex() {
	DeleteCriticalSection(&mutex_);		DeleteCriticalSection(&cs_);
	}		}

	void lock() {		void lock() {
	EnterCriticalSection(&mutex_);		EnterCriticalSection(&cs_);
	}		}

	bool try_lock() {		bool try_lock() {
	return TryEnterCriticalSection(&mutex_);		return TryEnterCriticalSection(&cs_);
	}		}

	void unlock() {		void unlock() {
	LeaveCriticalSection(&mutex_);		LeaveCriticalSection(&cs_);
			}

			native_handle_type native_handle() {
			return &cs_;
	}		}

	private:		private:
	CRITICAL_SECTION mutex_;		CRITICAL_SECTION cs_;

	DISALLOW_COPY_AND_ASSIGN(recursive_mutex);		DISALLOW_COPY_AND_ASSIGN(recursive_mutex);
	};		};

	class mutex {		class mutex {
	public:		public:
			typedef CRITICAL_SECTION* native_handle_type;

	mutex() {		mutex() {
	}		}

	@@ -97,11 +104,17 @@ class mutex {
	return true;		return true;
	}		}

			native_handle_type native_handle() {
			return mutex_.native_handle();
			}

	private:		private:
	recursive_mutex mutex_;		recursive_mutex mutex_;
	size_t lock_count_ = 0;		size_t lock_count_ = 0;

			friend class condition_variable;
	};		};

	}		}

	#endif		#endif // defined(_WIN32)

adb/sysdeps_test.cpp

+20 −1

Original line number	Original line	Diff line number	Diff line
	@@ -20,6 +20,8 @@

	#include "adb_io.h"		#include "adb_io.h"
	#include "sysdeps.h"		#include "sysdeps.h"
			#include "sysdeps/condition_variable.h"
			#include "sysdeps/mutex.h"

	static void increment_atomic_int(void* c) {		static void increment_atomic_int(void* c) {
	sleep(1);		sleep(1);
	@@ -245,7 +247,6 @@ TEST_F(sysdeps_poll, fd_count) {
	}		}
	}		}

	#include "sysdeps/mutex.h"
	TEST(sysdeps_mutex, mutex_smoke) {		TEST(sysdeps_mutex, mutex_smoke) {
	static std::atomic<bool> finished(false);		static std::atomic<bool> finished(false);
	static std::mutex &m = *new std::mutex();		static std::mutex &m = *new std::mutex();
	@@ -301,3 +302,21 @@ TEST(sysdeps_mutex, recursive_mutex_smoke) {
	m.lock();		m.lock();
	m.unlock();		m.unlock();
	}		}

			TEST(sysdeps_condition_variable, smoke) {
			static std::mutex &m = *new std::mutex;
			static std::condition_variable &cond = *new std::condition_variable;
			static volatile bool flag = false;

			std::unique_lock<std::mutex> lock(m);
			adb_thread_create([](void*) {
			m.lock();
			flag = true;
			cond.notify_one();
			m.unlock();
			}, nullptr);

			while (!flag) {
			cond.wait(lock);
			}
			}

adb/transport.cpp

+5 −2

Original line number	Original line	Diff line number	Diff line
	@@ -952,6 +952,8 @@ int register_socket_transport(int s, const char *serial, int port, int local) {
	for (const auto& transport : pending_list) {		for (const auto& transport : pending_list) {
	if (transport->serial && strcmp(serial, transport->serial) == 0) {		if (transport->serial && strcmp(serial, transport->serial) == 0) {
	adb_mutex_unlock(&transport_lock);		adb_mutex_unlock(&transport_lock);
			VLOG(TRANSPORT) << "socket transport " << transport->serial
			<< " is already in pending_list and fails to register";
	delete t;		delete t;
	return -1;		return -1;
	}		}
	@@ -960,6 +962,8 @@ int register_socket_transport(int s, const char *serial, int port, int local) {
	for (const auto& transport : transport_list) {		for (const auto& transport : transport_list) {
	if (transport->serial && strcmp(serial, transport->serial) == 0) {		if (transport->serial && strcmp(serial, transport->serial) == 0) {
	adb_mutex_unlock(&transport_lock);		adb_mutex_unlock(&transport_lock);
			VLOG(TRANSPORT) << "socket transport " << transport->serial
			<< " is already in transport_list and fails to register";
	delete t;		delete t;
	return -1;		return -1;
	}		}
	@@ -992,8 +996,7 @@ atransport find_transport(const char serial) {
	void kick_all_tcp_devices() {		void kick_all_tcp_devices() {
	adb_mutex_lock(&transport_lock);		adb_mutex_lock(&transport_lock);
	for (auto& t : transport_list) {		for (auto& t : transport_list) {
	// TCP/IP devices have adb_port == 0.		if (t->IsTcpDevice()) {
	if (t->type == kTransportLocal && t->adb_port == 0) {
	// Kicking breaks the read_transport thread of this transport out of any read, then		// Kicking breaks the read_transport thread of this transport out of any read, then
	// the read_transport thread will notify the main thread to make this transport		// the read_transport thread will notify the main thread to make this transport
	// offline. Then the main thread will notify the write_transport thread to exit.		// offline. Then the main thread will notify the write_transport thread to exit.