adb: add implementations of mutex, recursive_mutex. (903b749f) · Commits · e / os / android_system_core

adb/sysdeps/mutex.h

0 → 100644

+107 −0

Original line number	Diff line number	Diff line
		#pragma once

		/*
		* 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.
		*/

		#if defined(_WIN32)

		#include <windows.h>

		#include <android-base/macros.h>

		#include "adb.h"

		// The prebuilt version of mingw we use doesn't support mutex or recursive_mutex.
		// 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.

		#include <mutex>
		namespace std {

		// CRITICAL_SECTION is recursive, so just wrap it in a Mutex-compatible class.
		class recursive_mutex {
		public:
		recursive_mutex() {
		InitializeCriticalSection(&mutex_);
		}

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

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

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

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

		private:
		CRITICAL_SECTION mutex_;

		DISALLOW_COPY_AND_ASSIGN(recursive_mutex);
		};

		class mutex {
		public:
		mutex() {
		}

		~mutex() {
		}

		void lock() {
		mutex_.lock();
		if (++lock_count_ != 1) {
		fatal("non-recursive mutex locked reentrantly");
		}
		}

		void unlock() {
		if (--lock_count_ != 0) {
		fatal("non-recursive mutex unlock resulted in unexpected lock count: %d", lock_count_);
		}
		mutex_.unlock();
		}

		bool try_lock() {
		if (!mutex_.try_lock()) {
		return false;
		}

		if (lock_count_ != 0) {
		mutex_.unlock();
		return false;
		}

		++lock_count_;
		return true;
		}

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

		}

		#endif

adb/sysdeps_test.cpp

+57 −0

Original line number	Diff line number	Diff line
		@@ -244,3 +244,60 @@ TEST_F(sysdeps_poll, fd_count) {
		adb_close(fd);
		}
		}

		#include "sysdeps/mutex.h"
		TEST(sysdeps_mutex, mutex_smoke) {
		static std::atomic<bool> finished(false);
		static std::mutex &m = *new std::mutex();
		m.lock();
		ASSERT_FALSE(m.try_lock());
		adb_thread_create([](void*) {
		ASSERT_FALSE(m.try_lock());
		m.lock();
		finished.store(true);
		adb_sleep_ms(200);
		m.unlock();
		}, nullptr);

		ASSERT_FALSE(finished.load());
		adb_sleep_ms(100);
		ASSERT_FALSE(finished.load());
		m.unlock();
		adb_sleep_ms(100);
		m.lock();
		ASSERT_TRUE(finished.load());
		m.unlock();
		}

		// Our implementation on Windows aborts on double lock.
		#if defined(_WIN32)
		TEST(sysdeps_mutex, mutex_reentrant_lock) {
		std::mutex &m = *new std::mutex();

		m.lock();
		ASSERT_FALSE(m.try_lock());
		EXPECT_DEATH(m.lock(), "non-recursive mutex locked reentrantly");
		}
		#endif

		TEST(sysdeps_mutex, recursive_mutex_smoke) {
		static std::recursive_mutex &m = *new std::recursive_mutex();

		m.lock();
		ASSERT_TRUE(m.try_lock());
		m.unlock();

		adb_thread_create([](void*) {
		ASSERT_FALSE(m.try_lock());
		m.lock();
		adb_sleep_ms(500);
		m.unlock();
		}, nullptr);

		adb_sleep_ms(100);
		m.unlock();
		adb_sleep_ms(100);
		ASSERT_FALSE(m.try_lock());
		m.lock();
		m.unlock();
		}