Merge "adb: retry connecting disconnected emulators instead of always looping." am: 50e91fec0e (16dad488) · Commits · e / os / android_system_core

adb/adb.h

+1 −1

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


		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);

		// USB host/client interface.

0 → 100644

+61 −0

Original line number	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)

+22 −9

Original line number	Diff line number	Diff line
		#pragma once

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

		#pragma once
		#if defined(_WIN32)

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

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

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

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

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

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

		native_handle_type native_handle() {
		return &cs_;
		}

		private:
		CRITICAL_SECTION mutex_;
		CRITICAL_SECTION cs_;

		DISALLOW_COPY_AND_ASSIGN(recursive_mutex);
		};

		class mutex {
		public:
		typedef CRITICAL_SECTION* native_handle_type;

		mutex() {
		}

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

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

		private:
		recursive_mutex mutex_;
		size_t lock_count_ = 0;

		friend class condition_variable;
		};

		}

		#endif
		#endif // defined(_WIN32)

+20 −1

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

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

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

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

+5 −2

Original line number	Diff line number	Diff line
		@@ -950,6 +950,8 @@ int register_socket_transport(int s, const char *serial, int port, int local) {
		for (const auto& transport : pending_list) {
		if (transport->serial && strcmp(serial, transport->serial) == 0) {
		adb_mutex_unlock(&transport_lock);
		VLOG(TRANSPORT) << "socket transport " << transport->serial
		<< " is already in pending_list and fails to register";
		delete t;
		return -1;
		}
		@@ -958,6 +960,8 @@ int register_socket_transport(int s, const char *serial, int port, int local) {
		for (const auto& transport : transport_list) {
		if (transport->serial && strcmp(serial, transport->serial) == 0) {
		adb_mutex_unlock(&transport_lock);
		VLOG(TRANSPORT) << "socket transport " << transport->serial
		<< " is already in transport_list and fails to register";
		delete t;
		return -1;
		}
		@@ -990,8 +994,7 @@ atransport find_transport(const char serial) {
		void kick_all_tcp_devices() {
		adb_mutex_lock(&transport_lock);
		for (auto& t : transport_list) {
		// TCP/IP devices have adb_port == 0.
		if (t->type == kTransportLocal && t->adb_port == 0) {
		if (t->IsTcpDevice()) {
		// 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
		// offline. Then the main thread will notify the write_transport thread to exit.