Merge "Fixes ADB crash on Windows due to large number of connections." (de0b3218) · Commits · e / os / android_system_core

adb/sysdeps_win32.c

+190 −15

Original line number	Diff line number	Diff line
		@@ -1426,6 +1426,180 @@ event_looper_unhook( EventLooper looper, int fd, int events )
		}
		}

		/*
		* A fixer for WaitForMultipleObjects on condition that there are more than 64
		* handles to wait on.
		*
		* In cetain cases DDMS may establish more than 64 connections with ADB. For
		* instance, this may happen if there are more than 64 processes running on a
		* device, or there are multiple devices connected (including the emulator) with
		* the combined number of running processes greater than 64. In this case using
		* WaitForMultipleObjects to wait on connection events simply wouldn't cut,
		* because of the API limitations (64 handles max). So, we need to provide a way
		* to scale WaitForMultipleObjects to accept an arbitrary number of handles. The
		* easiest (and "Microsoft recommended") way to do that would be dividing the
		* handle array into chunks with the chunk size less than 64, and fire up as many
		* waiting threads as there are chunks. Then each thread would wait on a chunk of
		* handles, and will report back to the caller which handle has been set.
		* Here is the implementation of that algorithm.
		*/

		/* Number of handles to wait on in each wating thread. */
		#define WAIT_ALL_CHUNK_SIZE 63

		/* Descriptor for a wating thread */
		typedef struct WaitForAllParam {
		/* A handle to an event to signal when waiting is over. This handle is shared
		* accross all the waiting threads, so each waiting thread knows when any
		* other thread has exited, so it can exit too. */
		HANDLE main_event;
		/* Upon exit from a waiting thread contains the index of the handle that has
		* been signaled. The index is an absolute index of the signaled handle in
		* the original array. This pointer is shared accross all the waiting threads
		* and it's not guaranteed (due to a race condition) that when all the
		* waiting threads exit, the value contained here would indicate the first
		* handle that was signaled. This is fine, because the caller cares only
		* about any handle being signaled. It doesn't care about the order, nor
		* about the whole list of handles that were signaled. */
		LONG volatile *signaled_index;
		/* Array of handles to wait on in a waiting thread. */
		HANDLE* handles;
		/* Number of handles in 'handles' array to wait on. */
		int handles_count;
		/* Index inside the main array of the first handle in the 'handles' array. */
		int first_handle_index;
		/* Waiting thread handle. */
		HANDLE thread;
		} WaitForAllParam;

		/* Waiting thread routine. */
		static unsigned __stdcall
		_in_waiter_thread(void* arg)
		{
		HANDLE wait_on[WAIT_ALL_CHUNK_SIZE + 1];
		int res;
		WaitForAllParam* const param = (WaitForAllParam*)arg;

		/* We have to wait on the main_event in order to be notified when any of the
		* sibling threads is exiting. */
		wait_on[0] = param->main_event;
		/* The rest of the handles go behind the main event handle. */
		memcpy(wait_on + 1, param->handles, param->handles_count * sizeof(HANDLE));

		res = WaitForMultipleObjects(param->handles_count + 1, wait_on, FALSE, INFINITE);
		if (res > 0 && res < (param->handles_count + 1)) {
		/* One of the original handles got signaled. Save its absolute index into
		* the output variable. */
		InterlockedCompareExchange(param->signaled_index,
		res - 1L + param->first_handle_index, -1L);
		}

		/* Notify the caller (and the siblings) that the wait is over. */
		SetEvent(param->main_event);

		_endthreadex(0);
		return 0;
		}

		/* WaitForMultipeObjects fixer routine.
		* Param:
		* handles Array of handles to wait on.
		* handles_count Number of handles in the array.
		* Return:
		* (>= 0 && < handles_count) - Index of the signaled handle in the array, or
		* WAIT_FAILED on an error.
		*/
		static int
		_wait_for_all(HANDLE* handles, int handles_count)
		{
		WaitForAllParam* threads;
		HANDLE main_event;
		int chunks, chunk, remains;

		/* This variable is going to be accessed by several threads at the same time,
		* this is bound to fail randomly when the core is run on multi-core machines.
		* To solve this, we need to do the following (1 _and_ 2):
		* 1. Use the "volatile" qualifier to ensure the compiler doesn't optimize
		* out the reads/writes in this function unexpectedly.
		* 2. Ensure correct memory ordering. The "simple" way to do that is to wrap
		* all accesses inside a critical section. But we can also use
		* InterlockedCompareExchange() which always provide a full memory barrier
		* on Win32.
		*/
		volatile LONG sig_index = -1;

		/* Calculate number of chunks, and allocate thread param array. */
		chunks = handles_count / WAIT_ALL_CHUNK_SIZE;
		remains = handles_count % WAIT_ALL_CHUNK_SIZE;
		threads = (WaitForAllParam)malloc((chunks + (remains ? 1 : 0))
		sizeof(WaitForAllParam));
		if (threads == NULL) {
		D("Unable to allocate thread array for %d handles.", handles_count);
		return (int)WAIT_FAILED;
		}

		/* Create main event to wait on for all waiting threads. This is a "manualy
		* reset" event that will remain set once it was set. */
		main_event = CreateEvent(NULL, TRUE, FALSE, NULL);
		if (main_event == NULL) {
		D("Unable to create main event. Error: %d", GetLastError());
		free(threads);
		return (int)WAIT_FAILED;
		}

		/*
		* Initialize waiting thread parameters.
		*/

		for (chunk = 0; chunk < chunks; chunk++) {
		threads[chunk].main_event = main_event;
		threads[chunk].signaled_index = &sig_index;
		threads[chunk].first_handle_index = WAIT_ALL_CHUNK_SIZE * chunk;
		threads[chunk].handles = handles + threads[chunk].first_handle_index;
		threads[chunk].handles_count = WAIT_ALL_CHUNK_SIZE;
		}
		if (remains) {
		threads[chunk].main_event = main_event;
		threads[chunk].signaled_index = &sig_index;
		threads[chunk].first_handle_index = WAIT_ALL_CHUNK_SIZE * chunk;
		threads[chunk].handles = handles + threads[chunk].first_handle_index;
		threads[chunk].handles_count = remains;
		chunks++;
		}

		/* Start the waiting threads. */
		for (chunk = 0; chunk < chunks; chunk++) {
		/* Note that using adb_thread_create is not appropriate here, since we
		* need a handle to wait on for thread termination. */
		threads[chunk].thread = (HANDLE)_beginthreadex(NULL, 0, _in_waiter_thread,
		&threads[chunk], 0, NULL);
		if (threads[chunk].thread == NULL) {
		/* Unable to create a waiter thread. Collapse. */
		D("Unable to create a waiting thread %d of %d. errno=%d",
		chunk, chunks, errno);
		chunks = chunk;
		SetEvent(main_event);
		break;
		}
		}

		/* Wait on any of the threads to get signaled. */
		WaitForSingleObject(main_event, INFINITE);

		/* Wait on all the waiting threads to exit. */
		for (chunk = 0; chunk < chunks; chunk++) {
		WaitForSingleObject(threads[chunk].thread, INFINITE);
		CloseHandle(threads[chunk].thread);
		}

		CloseHandle(main_event);
		free(threads);


		const int ret = (int)InterlockedCompareExchange(&sig_index, -1, -1);
		return (ret >= 0) ? ret : (int)WAIT_FAILED;
		}

		static EventLooperRec win32_looper;

		static void fdevent_init(void)
		@@ -1525,10 +1699,11 @@ static void fdevent_process()

		D( "adb_win32: waiting for %d events\n", looper->htab_count );
		if (looper->htab_count > MAXIMUM_WAIT_OBJECTS) {
		D("handle count %d exceeds MAXIMUM_WAIT_OBJECTS, aborting!\n", looper->htab_count);
		abort();
		}
		D("handle count %d exceeds MAXIMUM_WAIT_OBJECTS.\n", looper->htab_count);
		wait_ret = _wait_for_all(looper->htab, looper->htab_count);
		} else {
		wait_ret = WaitForMultipleObjects( looper->htab_count, looper->htab, FALSE, INFINITE );
		}
		if (wait_ret == (int)WAIT_FAILED) {
		D( "adb_win32: wait failed, error %ld\n", GetLastError() );
		} else {