Migrate from libutils SystemClock.h to std::chrono (1d46f583) · Commits · e / devices / smdk4412 / android_frameworks_native

libs/binder/ActivityManager.cpp

+7 −6

Original line number	Original line	Diff line number	Diff line
	@@ -23,10 +23,10 @@
	#include <binder/IServiceManager.h>		#include <binder/IServiceManager.h>
	#include <binder/ProcessState.h>		#include <binder/ProcessState.h>

	#include <utils/SystemClock.h>

	namespace android {		namespace android {

			using namespace std::chrono_literals;

	ActivityManager::ActivityManager()		ActivityManager::ActivityManager()
	{		{
	}		}
	@@ -43,15 +43,16 @@ sp<IActivityManager> ActivityManager::getService()
	}		}
	} else {		} else {
	ALOGI("Thread pool not started. Polling for activity service.");		ALOGI("Thread pool not started. Polling for activity service.");
	int64_t startTime = 0;		auto startTime = std::chrono::steady_clock::now().min();
	while (service == nullptr \|\| !IInterface::asBinder(service)->isBinderAlive()) {		while (service == nullptr \|\| !IInterface::asBinder(service)->isBinderAlive()) {
	sp<IBinder> binder = defaultServiceManager()->checkService(String16("activity"));		sp<IBinder> binder = defaultServiceManager()->checkService(String16("activity"));
	if (binder == nullptr) {		if (binder == nullptr) {
	// Wait for the activity service to come back...		// Wait for the activity service to come back...
	if (startTime == 0) {		if (startTime == startTime.min()) {
	startTime = uptimeMillis();		startTime = std::chrono::steady_clock::now();
	ALOGI("Waiting for activity service");		ALOGI("Waiting for activity service");
	} else if ((uptimeMillis() - startTime) > 1000000) {		} else if (std::chrono::steady_clock::now() - startTime > 1000s) {
			// TODO(b/342453147): timeout of 1000s = 16min and 40s doesn't seem intended
	ALOGW("Waiting too long for activity service, giving up");		ALOGW("Waiting too long for activity service, giving up");
	service = nullptr;		service = nullptr;
	break;		break;

libs/binder/IPCThreadState.cpp

+12 −8

Original line number	Original line	Diff line number	Diff line
	@@ -25,7 +25,6 @@
	#include <cutils/sched_policy.h>		#include <cutils/sched_policy.h>
	#include <utils/CallStack.h>		#include <utils/CallStack.h>
	#include <utils/Log.h>		#include <utils/Log.h>
	#include <utils/SystemClock.h>

	#include <atomic>		#include <atomic>
	#include <errno.h>		#include <errno.h>
	@@ -38,6 +37,7 @@
	#include <sys/resource.h>		#include <sys/resource.h>
	#include <unistd.h>		#include <unistd.h>

			#include "Utils.h"
	#include "binder_module.h"		#include "binder_module.h"

	#if LOG_NDEBUG		#if LOG_NDEBUG
	@@ -65,6 +65,8 @@

	namespace android {		namespace android {

			using namespace std::chrono_literals;

	// Static const and functions will be optimized out if not used,		// Static const and functions will be optimized out if not used,
	// when LOG_NDEBUG and references in IF_LOG_COMMANDS() are optimized out.		// when LOG_NDEBUG and references in IF_LOG_COMMANDS() are optimized out.
	static const char* kReturnStrings[] = {		static const char* kReturnStrings[] = {
	@@ -647,8 +649,9 @@ status_t IPCThreadState::getAndExecuteCommand()

	size_t newThreadsCount = mProcess->mExecutingThreadsCount.fetch_add(1) + 1;		size_t newThreadsCount = mProcess->mExecutingThreadsCount.fetch_add(1) + 1;
	if (newThreadsCount >= mProcess->mMaxThreads) {		if (newThreadsCount >= mProcess->mMaxThreads) {
	int64_t expected = 0;		auto expected = ProcessState::never();
	mProcess->mStarvationStartTimeMs.compare_exchange_strong(expected, uptimeMillis());		mProcess->mStarvationStartTime
			.compare_exchange_strong(expected, std::chrono::steady_clock::now());
	}		}

	result = executeCommand(cmd);		result = executeCommand(cmd);
	@@ -656,12 +659,13 @@ status_t IPCThreadState::getAndExecuteCommand()
	size_t maxThreads = mProcess->mMaxThreads;		size_t maxThreads = mProcess->mMaxThreads;
	newThreadsCount = mProcess->mExecutingThreadsCount.fetch_sub(1) - 1;		newThreadsCount = mProcess->mExecutingThreadsCount.fetch_sub(1) - 1;
	if (newThreadsCount < maxThreads) {		if (newThreadsCount < maxThreads) {
	size_t starvationStartTimeMs = mProcess->mStarvationStartTimeMs.exchange(0);		auto starvationStartTime =
	if (starvationStartTimeMs != 0) {		mProcess->mStarvationStartTime.exchange(ProcessState::never());
	int64_t starvationTimeMs = uptimeMillis() - starvationStartTimeMs;		if (starvationStartTime != ProcessState::never()) {
	if (starvationTimeMs > 100) {		auto starvationTime = std::chrono::steady_clock::now() - starvationStartTime;
			if (starvationTime > 100ms) {
	ALOGE("binder thread pool (%zu threads) starved for %" PRId64 " ms", maxThreads,		ALOGE("binder thread pool (%zu threads) starved for %" PRId64 " ms", maxThreads,
	starvationTimeMs);		to_ms(starvationTime));
	}		}
	}		}
	}		}

libs/binder/IServiceManager.cpp

+17 −14

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

	#include <inttypes.h>		#include <inttypes.h>
	#include <unistd.h>		#include <unistd.h>
			#include <chrono>
	#include <condition_variable>		#include <condition_variable>

	#include <android-base/properties.h>		#include <android-base/properties.h>
	@@ -30,7 +31,6 @@
	#include <binder/Parcel.h>		#include <binder/Parcel.h>
	#include <utils/Log.h>		#include <utils/Log.h>
	#include <utils/String8.h>		#include <utils/String8.h>
	#include <utils/SystemClock.h>

	#ifndef __ANDROID_VNDK__		#ifndef __ANDROID_VNDK__
	#include <binder/IPermissionController.h>		#include <binder/IPermissionController.h>
	@@ -48,9 +48,12 @@
	#endif		#endif

	#include "Static.h"		#include "Static.h"
			#include "Utils.h"

	namespace android {		namespace android {

			using namespace std::chrono_literals;

	using AidlRegistrationCallback = IServiceManager::LocalRegistrationCallback;		using AidlRegistrationCallback = IServiceManager::LocalRegistrationCallback;

	using AidlServiceManager = android::os::IServiceManager;		using AidlServiceManager = android::os::IServiceManager;
	@@ -194,16 +197,16 @@ bool checkPermission(const String16& permission, pid_t pid, uid_t uid, bool logP
	pc = gPermissionController;		pc = gPermissionController;
	gPermissionControllerLock.unlock();		gPermissionControllerLock.unlock();

	int64_t startTime = 0;		auto startTime = std::chrono::steady_clock::now().min();

	while (true) {		while (true) {
	if (pc != nullptr) {		if (pc != nullptr) {
	bool res = pc->checkPermission(permission, pid, uid);		bool res = pc->checkPermission(permission, pid, uid);
	if (res) {		if (res) {
	if (startTime != 0) {		if (startTime != startTime.min()) {
	ALOGI("Check passed after %d seconds for %s from uid=%d pid=%d",		const auto waitTime = std::chrono::steady_clock::now() - startTime;
	(int)((uptimeMillis() - startTime) / 1000), String8(permission).c_str(),		ALOGI("Check passed after %" PRIu64 "ms for %s from uid=%d pid=%d",
	uid, pid);		to_ms(waitTime), String8(permission).c_str(), uid, pid);
	}		}
	return res;		return res;
	}		}
	@@ -229,8 +232,8 @@ bool checkPermission(const String16& permission, pid_t pid, uid_t uid, bool logP
	sp<IBinder> binder = defaultServiceManager()->checkService(_permission);		sp<IBinder> binder = defaultServiceManager()->checkService(_permission);
	if (binder == nullptr) {		if (binder == nullptr) {
	// Wait for the permission controller to come back...		// Wait for the permission controller to come back...
	if (startTime == 0) {		if (startTime == startTime.min()) {
	startTime = uptimeMillis();		startTime = std::chrono::steady_clock::now();
	ALOGI("Waiting to check permission %s from uid=%d pid=%d",		ALOGI("Waiting to check permission %s from uid=%d pid=%d",
	String8(permission).c_str(), uid, pid);		String8(permission).c_str(), uid, pid);
	}		}
	@@ -287,8 +290,8 @@ sp<IBinder> ServiceManagerShim::getService(const String16& name) const

	const bool isVendorService =		const bool isVendorService =
	strcmp(ProcessState::self()->getDriverName().c_str(), "/dev/vndbinder") == 0;		strcmp(ProcessState::self()->getDriverName().c_str(), "/dev/vndbinder") == 0;
	constexpr int64_t timeout = 5000;		constexpr auto timeout = 5s;
	int64_t startTime = uptimeMillis();		const auto startTime = std::chrono::steady_clock::now();
	// Vendor code can't access system properties		// Vendor code can't access system properties
	if (!gSystemBootCompleted && !isVendorService) {		if (!gSystemBootCompleted && !isVendorService) {
	#ifdef __ANDROID__		#ifdef __ANDROID__
	@@ -306,15 +309,16 @@ sp<IBinder> ServiceManagerShim::getService(const String16& name) const
	ProcessState::self()->getDriverName().c_str());		ProcessState::self()->getDriverName().c_str());

	int n = 0;		int n = 0;
	while (uptimeMillis() - startTime < timeout) {		while (std::chrono::steady_clock::now() - startTime < timeout) {
	n++;		n++;
	usleep(1000*sleepTime);		usleep(1000*sleepTime);

	sp<IBinder> svc = checkService(name);		sp<IBinder> svc = checkService(name);
	if (svc != nullptr) {		if (svc != nullptr) {
	ALOGI("Waiting for service '%s' on '%s' successful after waiting %" PRIi64 "ms",		const auto waitTime = std::chrono::steady_clock::now() - startTime;
			ALOGI("Waiting for service '%s' on '%s' successful after waiting %" PRIu64 "ms",
	String8(name).c_str(), ProcessState::self()->getDriverName().c_str(),		String8(name).c_str(), ProcessState::self()->getDriverName().c_str(),
	uptimeMillis() - startTime);		to_ms(waitTime));
	return svc;		return svc;
	}		}
	}		}
	@@ -416,7 +420,6 @@ sp<IBinder> ServiceManagerShim::waitForService(const String16& name16)
	// that another thread serves the callback, and we never get a		// that another thread serves the callback, and we never get a
	// command, so we hang indefinitely.		// command, so we hang indefinitely.
	std::unique_lock<std::mutex> lock(waiter->mMutex);		std::unique_lock<std::mutex> lock(waiter->mMutex);
	using std::literals::chrono_literals::operator""s;
	waiter->mCv.wait_for(lock, 1s, [&] {		waiter->mCv.wait_for(lock, 1s, [&] {
	return waiter->mBinder != nullptr;		return waiter->mBinder != nullptr;
	});		});

libs/binder/PermissionController.cpp

+6 −6

Original line number	Original line	Diff line number	Diff line
	@@ -19,10 +19,10 @@
	#include <binder/Binder.h>		#include <binder/Binder.h>
	#include <binder/IServiceManager.h>		#include <binder/IServiceManager.h>

	#include <utils/SystemClock.h>

	namespace android {		namespace android {

			using namespace std::chrono_literals;

	PermissionController::PermissionController()		PermissionController::PermissionController()
	{		{
	}		}
	@@ -30,16 +30,16 @@ PermissionController::PermissionController()
	sp<IPermissionController> PermissionController::getService()		sp<IPermissionController> PermissionController::getService()
	{		{
	std::lock_guard<Mutex> scoped_lock(mLock);		std::lock_guard<Mutex> scoped_lock(mLock);
	int64_t startTime = 0;		auto startTime = std::chrono::steady_clock::now().min();
	sp<IPermissionController> service = mService;		sp<IPermissionController> service = mService;
	while (service == nullptr \|\| !IInterface::asBinder(service)->isBinderAlive()) {		while (service == nullptr \|\| !IInterface::asBinder(service)->isBinderAlive()) {
	sp<IBinder> binder = defaultServiceManager()->checkService(String16("permission"));		sp<IBinder> binder = defaultServiceManager()->checkService(String16("permission"));
	if (binder == nullptr) {		if (binder == nullptr) {
	// Wait for the activity service to come back...		// Wait for the activity service to come back...
	if (startTime == 0) {		if (startTime == startTime.min()) {
	startTime = uptimeMillis();		startTime = std::chrono::steady_clock::now();
	ALOGI("Waiting for permission service");		ALOGI("Waiting for permission service");
	} else if ((uptimeMillis() - startTime) > 10000) {		} else if (std::chrono::steady_clock::now() - startTime > 10s) {
	ALOGW("Waiting too long for permission service, giving up");		ALOGW("Waiting too long for permission service, giving up");
	service = nullptr;		service = nullptr;
	break;		break;

libs/binder/ProcessState.cpp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -555,7 +555,7 @@ ProcessState::ProcessState(const char* driver)
	mMaxThreads(DEFAULT_MAX_BINDER_THREADS),		mMaxThreads(DEFAULT_MAX_BINDER_THREADS),
	mCurrentThreads(0),		mCurrentThreads(0),
	mKernelStartedThreads(0),		mKernelStartedThreads(0),
	mStarvationStartTimeMs(0),		mStarvationStartTime(never()),
	mForked(false),		mForked(false),
	mThreadPoolStarted(false),		mThreadPoolStarted(false),
	mThreadPoolSeq(1),		mThreadPoolSeq(1),