Merge "libbinder: avoid global mutex every binder call" am: 2054ee3fee am:... (d0b5abbc) · Commits · e / os / platform_frameworks_native

libs/binder/ProcessState.cpp

+36 −24

Original line number	Diff line number	Diff line
		@@ -32,6 +32,7 @@

		#include <errno.h>
		#include <fcntl.h>
		#include <mutex>
		#include <stdio.h>
		#include <stdlib.h>
		#include <unistd.h>
		@@ -73,38 +74,49 @@ protected:

		sp<ProcessState> ProcessState::self()
		{
		Mutex::Autolock _l(gProcessMutex);
		if (gProcess != nullptr) {
		return gProcess;
		}
		gProcess = new ProcessState(kDefaultDriver);
		return gProcess;
		return init(kDefaultDriver, false /requireDefault/);
		}

		sp<ProcessState> ProcessState::initWithDriver(const char* driver)
		{
		Mutex::Autolock _l(gProcessMutex);
		if (gProcess != nullptr) {
		// Allow for initWithDriver to be called repeatedly with the same
		// driver.
		if (!strcmp(gProcess->getDriverName().c_str(), driver)) {
		return gProcess;
		return init(driver, true /requireDefault/);
		}

		sp<ProcessState> ProcessState::selfOrNull()
		{
		return init(nullptr, false /requireDefault/);
		}
		LOG_ALWAYS_FATAL("ProcessState was already initialized.");

		sp<ProcessState> ProcessState::init(const char *driver, bool requireDefault)
		{
		[[clang::no_destroy]] static sp<ProcessState> gProcess;
		[[clang::no_destroy]] static std::mutex gProcessMutex;

		if (driver == nullptr) {
		std::lock_guard<std::mutex> l(gProcessMutex);
		return gProcess;
		}

		[[clang::no_destroy]] static std::once_flag gProcessOnce;
		std::call_once(gProcessOnce, [&](){
		if (access(driver, R_OK) == -1) {
		ALOGE("Binder driver %s is unavailable. Using /dev/binder instead.", driver);
		driver = "/dev/binder";
		}

		std::lock_guard<std::mutex> l(gProcessMutex);
		gProcess = new ProcessState(driver);
		return gProcess;
		});

		if (requireDefault) {
		// Detect if we are trying to initialize with a different driver, and
		// consider that an error. ProcessState will only be initialized once above.
		LOG_ALWAYS_FATAL_IF(gProcess->getDriverName() != driver,
		"ProcessState was already initialized with %s,"
		" can't initialize with %s.",
		gProcess->getDriverName().c_str(), driver);
		}

		sp<ProcessState> ProcessState::selfOrNull()
		{
		Mutex::Autolock _l(gProcessMutex);
		return gProcess;
		}

libs/binder/Static.cpp

+0 −5

Original line number	Diff line number	Diff line
		@@ -68,9 +68,4 @@ TextOutput& alog(*new LogTextOutput());
		TextOutput& aout(*new FdTextOutput(STDOUT_FILENO));
		TextOutput& aerr(*new FdTextOutput(STDERR_FILENO));

		// ------------ ProcessState.cpp

		Mutex& gProcessMutex = *new Mutex;
		sp<ProcessState> gProcess;

		} // namespace android

libs/binder/Static.h

+0 −4

Original line number	Diff line number	Diff line
		@@ -27,8 +27,4 @@ namespace android {
		// For TextStream.cpp
		extern Vector<int32_t> gTextBuffers;

		// For ProcessState.cpp
		extern Mutex& gProcessMutex;
		extern sp<ProcessState> gProcess;

		} // namespace android

libs/binder/include/binder/ProcessState.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -42,6 +42,8 @@ public:
		* any call to ProcessState::self(). The default is /dev/vndbinder
		* for processes built with the VNDK and /dev/binder for those
		* which are not.
		*
		* If this is called with nullptr, the behavior is the same as selfOrNull.
		*/
		static sp<ProcessState> initWithDriver(const char *driver);

		@@ -90,6 +92,8 @@ public:
		void setCallRestriction(CallRestriction restriction);

		private:
		static sp<ProcessState> init(const char *defaultDriver, bool requireDefault);

		friend class IPCThreadState;

		explicit ProcessState(const char* driver);