Merge changes Ie15fcb8f,I0a895911 (c9c555b8) · Commits · e / os / android_system_core

base/Android.bp

+2 −0

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@ cc_library {
		"file.cpp",
		"logging.cpp",
		"parsenetaddress.cpp",
		"quick_exit.cpp",
		"stringprintf.cpp",
		"strings.cpp",
		"test_utils.cpp",
		@@ -71,6 +72,7 @@ cc_test {
		"logging_test.cpp",
		"parseint_test.cpp",
		"parsenetaddress_test.cpp",
		"quick_exit_test.cpp",
		"stringprintf_test.cpp",
		"strings_test.cpp",
		"test_main.cpp",

base/include/android-base/mutex.h

0 → 100644

+49 −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 <mutex>

		#include "android-base/macros.h"

		#if defined(_WIN32)
		#include <windows.h>

		namespace std {
		class mutex {
		public:
		mutex() {
		InitializeCriticalSection(&critical_section_);
		}
		~mutex() {
		DeleteCriticalSection(&critical_section_);
		}

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

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

		private:
		CRITICAL_SECTION critical_section_;
		DISALLOW_COPY_AND_ASSIGN(mutex);
		};
		} // namespace std
		#endif

base/include/android-base/quick_exit.h

0 → 100644

+34 −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 <stdlib.h>

		// Provide emulation for at_quick_exit/quick_exit on platforms that don't have it.
		namespace android {
		namespace base {

		// Bionic and glibc have quick_exit, Darwin and Windows don't.
		#if !defined(__linux__)
		void quick_exit(int exit_code) __attribute__((noreturn));
		int at_quick_exit(void (*func)());
		#else
		using ::at_quick_exit;
		using ::quick_exit;
		#endif
		}
		}

base/logging.cpp

+7 −53

Original line number	Diff line number	Diff line
		@@ -37,16 +37,14 @@

		#include <iostream>
		#include <limits>
		#include <mutex>
		#include <sstream>
		#include <string>
		#include <utility>
		#include <vector>

		#ifndef _WIN32
		#include <mutex>
		#endif

		#include "android-base/macros.h"
		#include "android-base/mutex.h"
		#include "android-base/strings.h"

		// Headers for LogMessage::LogLine.
		@@ -92,17 +90,11 @@ static thread_id GetThreadId() {
		}

		namespace {
		#ifndef _WIN32
		using std::mutex;
		using std::lock_guard;

		#if defined(__GLIBC__)
		const char* getprogname() {
		return program_invocation_short_name;
		}
		#endif

		#else
		#elif defined(_WIN32)
		const char* getprogname() {
		static bool first = true;
		static char progname[MAX_PATH] = {};
		@@ -121,51 +113,13 @@ const char* getprogname() {

		return progname;
		}

		class mutex {
		public:
		mutex() {
		InitializeCriticalSection(&critical_section_);
		}
		~mutex() {
		DeleteCriticalSection(&critical_section_);
		}

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

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

		private:
		CRITICAL_SECTION critical_section_;
		};

		template <typename LockT>
		class lock_guard {
		public:
		explicit lock_guard(LockT& lock) : lock_(lock) {
		lock_.lock();
		}

		~lock_guard() {
		lock_.unlock();
		}

		private:
		LockT& lock_;

		DISALLOW_COPY_AND_ASSIGN(lock_guard);
		};
		#endif
		} // namespace

		namespace android {
		namespace base {

		static auto& logging_lock = *new mutex();
		static auto& logging_lock = *new std::mutex();

		#ifdef __ANDROID__
		static auto& gLogger = *new LogFunction(LogdLogger());
		@@ -354,12 +308,12 @@ void InitLogging(char* argv[], LogFunction&& logger, AbortFunction&& aborter) {
		}

		void SetLogger(LogFunction&& logger) {
		lock_guard<mutex> lock(logging_lock);
		std::lock_guard<std::mutex> lock(logging_lock);
		gLogger = std::move(logger);
		}

		void SetAborter(AbortFunction&& aborter) {
		lock_guard<mutex> lock(logging_lock);
		std::lock_guard<std::mutex> lock(logging_lock);
		gAborter = std::move(aborter);
		}

		@@ -445,7 +399,7 @@ LogMessage::~LogMessage() {

		{
		// Do the actual logging with the lock held.
		lock_guard<mutex> lock(logging_lock);
		std::lock_guard<std::mutex> lock(logging_lock);
		if (msg.find('\n') == std::string::npos) {
		LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),
		data_->GetSeverity(), msg.c_str());

base/quick_exit.cpp

0 → 100644

+48 −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.
		*/

		#include "android-base/quick_exit.h"

		#if !defined(__linux__)

		#include <mutex>
		#include <vector>

		#include "android-base/mutex.h"

		namespace android {
		namespace base {

		static std::mutex quick_exit_mutex;
		static std::vector<void(*)()> quick_exit_handlers;

		void quick_exit(int exit_code) {
		std::lock_guard<std::mutex> lock(quick_exit_mutex);
		for (auto it = quick_exit_handlers.rbegin(); it != quick_exit_handlers.rend(); ++it) {
		(*it)();
		}
		_Exit(exit_code);
		}

		int at_quick_exit(void (*func)()) {
		std::lock_guard<std::mutex> lock(quick_exit_mutex);
		quick_exit_handlers.push_back(func);
		return 0;
		}

		} // namespace base
		} // namespace android
		#endif