Merge "Revert "Move tracing calls to libbinder_ndk"" into main am: 00e8bb88bc (880171a5) · Commits · e / os / android_frameworks_native

libs/binder/OS.h

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -27,7 +27,6 @@ namespace android::binder::os {
	LIBBINDER_EXPORTED void trace_begin(uint64_t tag, const char* name);		LIBBINDER_EXPORTED void trace_begin(uint64_t tag, const char* name);
	LIBBINDER_EXPORTED void trace_end(uint64_t tag);		LIBBINDER_EXPORTED void trace_end(uint64_t tag);
	LIBBINDER_EXPORTED void trace_int(uint64_t tag, const char* name, int32_t value);		LIBBINDER_EXPORTED void trace_int(uint64_t tag, const char* name, int32_t value);
	LIBBINDER_EXPORTED uint64_t get_trace_enabled_tags();

	status_t setNonBlocking(borrowed_fd fd);		status_t setNonBlocking(borrowed_fd fd);

libs/binder/OS_android.cpp

+0 −4

Original line number	Original line	Diff line number	Diff line
	@@ -48,10 +48,6 @@ void trace_int(uint64_t tag, const char* name, int32_t value) {
	atrace_int(tag, name, value);		atrace_int(tag, name, value);
	}		}

	uint64_t get_trace_enabled_tags() {
	return atrace_enabled_tags;
	}

	} // namespace os		} // namespace os

	// Legacy trace symbol. To be removed once all of downstream rebuilds.		// Legacy trace symbol. To be removed once all of downstream rebuilds.

libs/binder/OS_non_android_linux.cpp

+0 −4

Original line number	Original line	Diff line number	Diff line
	@@ -41,10 +41,6 @@ void trace_end(uint64_t) {}

	void trace_int(uint64_t, const char*, int32_t) {}		void trace_int(uint64_t, const char*, int32_t) {}

	uint64_t get_trace_enabled_tags() {
	return 0;
	}

	uint64_t GetThreadId() {		uint64_t GetThreadId() {
	return syscall(__NR_gettid);		return syscall(__NR_gettid);
	}		}

libs/binder/include/binder/Trace.h

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -42,7 +42,6 @@ namespace os {
	void trace_begin(uint64_t tag, const char* name);		void trace_begin(uint64_t tag, const char* name);
	void trace_end(uint64_t tag);		void trace_end(uint64_t tag);
	void trace_int(uint64_t tag, const char* name, int32_t value);		void trace_int(uint64_t tag, const char* name, int32_t value);
	uint64_t get_trace_enabled_tags();
	} // namespace os		} // namespace os

	class LIBBINDER_EXPORTED ScopedTrace {		class LIBBINDER_EXPORTED ScopedTrace {

libs/binder/ndk/ibinder.cpp

+1 −132

Original line number	Original line	Diff line number	Diff line
	@@ -18,10 +18,8 @@
	#include <android/binder_ibinder_platform.h>		#include <android/binder_ibinder_platform.h>
	#include <android/binder_stability.h>		#include <android/binder_stability.h>
	#include <android/binder_status.h>		#include <android/binder_status.h>
	#include <binder/Functional.h>
	#include <binder/IPCThreadState.h>		#include <binder/IPCThreadState.h>
	#include <binder/IResultReceiver.h>		#include <binder/IResultReceiver.h>
	#include <binder/Trace.h>
	#if __has_include(<private/android_filesystem_config.h>)		#if __has_include(<private/android_filesystem_config.h>)
	#include <private/android_filesystem_config.h>		#include <private/android_filesystem_config.h>
	#endif		#endif
	@@ -42,23 +40,6 @@ using ::android::statusToString;
	using ::android::String16;		using ::android::String16;
	using ::android::String8;		using ::android::String8;
	using ::android::wp;		using ::android::wp;
	using ::android::binder::impl::make_scope_guard;
	using ::android::binder::impl::scope_guard;
	using ::android::binder::os::get_trace_enabled_tags;
	using ::android::binder::os::trace_begin;
	using ::android::binder::os::trace_end;

	// transaction codes for getInterfaceHash and getInterfaceVersion are defined
	// in file : system/tools/aidl/aidl.cpp
	static constexpr int kGetInterfaceVersionId = 0x00fffffe;
	static const char* kInterfaceVersion = "getInterfaceVersion";
	static constexpr int kGetInterfaceHashId = 0x00fffffd;
	static const char* kInterfaceHash = "getInterfaceHash";
	static const char* kNdkTrace = "AIDL::ndk::";
	static const char* kServerTrace = "::server";
	static const char* kClientTrace = "::client";
	static const char* kSeparator = "::";
	static const char* kUnknownCode = "Unknown_Transaction_Code:";

	namespace ABBinderTag {		namespace ABBinderTag {

	@@ -109,51 +90,6 @@ static std::string SanitizeString(const String16& str) {
	return sanitized;		return sanitized;
	}		}

	const std::string getMethodName(const AIBinder_Class* clazz, transaction_code_t code) {
	// TODO(b/150155678) - Move getInterfaceHash and getInterfaceVersion to libbinder and remove
	// hardcoded cases.
	if (code <= clazz->getTransactionCodeToFunctionLength() && code >= FIRST_CALL_TRANSACTION) {
	// Codes have FIRST_CALL_TRANSACTION as added offset. Subtract to access function name
	return clazz->getFunctionName(code);
	} else if (code == kGetInterfaceVersionId) {
	return kInterfaceVersion;
	} else if (code == kGetInterfaceHashId) {
	return kInterfaceHash;
	}
	return kUnknownCode + std::to_string(code);
	}

	const std::string getTraceSectionName(const AIBinder_Class* clazz, transaction_code_t code,
	bool isServer) {
	if (clazz == nullptr) {
	ALOGE("class associated with binder is null. Class is needed to add trace with interface "
	"name and function name");
	return kNdkTrace;
	}

	const std::string descriptor = clazz->getInterfaceDescriptorUtf8();
	const std::string methodName = getMethodName(clazz, code);

	size_t traceSize =
	strlen(kNdkTrace) + descriptor.size() + strlen(kSeparator) + methodName.size();
	traceSize += isServer ? strlen(kServerTrace) : strlen(kClientTrace);

	std::string trace;
	// reserve to avoid repeated allocations
	trace.reserve(traceSize);

	trace += kNdkTrace;
	trace += clazz->getInterfaceDescriptorUtf8();
	trace += kSeparator;
	trace += methodName;
	trace += isServer ? kServerTrace : kClientTrace;

	LOG_ALWAYS_FATAL_IF(trace.size() != traceSize, "Trace size mismatch. Expected %zu, got %zu",
	traceSize, trace.size());

	return trace;
	}

	bool AIBinder::associateClass(const AIBinder_Class* clazz) {		bool AIBinder::associateClass(const AIBinder_Class* clazz) {
	if (clazz == nullptr) return false;		if (clazz == nullptr) return false;

	@@ -267,17 +203,6 @@ status_t ABBinder::dump(int fd, const ::android::Vector<String16>& args) {

	status_t ABBinder::onTransact(transaction_code_t code, const Parcel& data, Parcel* reply,		status_t ABBinder::onTransact(transaction_code_t code, const Parcel& data, Parcel* reply,
	binder_flags_t flags) {		binder_flags_t flags) {
	std::string sectionName;
	bool tracingEnabled = get_trace_enabled_tags() & ATRACE_TAG_AIDL;
	if (tracingEnabled) {
	sectionName = getTraceSectionName(getClass(), code, true /isServer/);
	trace_begin(ATRACE_TAG_AIDL, sectionName.c_str());
	}

	scope_guard guard = make_scope_guard([&]() {
	if (tracingEnabled) trace_end(ATRACE_TAG_AIDL);
	});

	if (isUserCommand(code)) {		if (isUserCommand(code)) {
	if (getClass()->writeHeader && !data.checkInterface(this)) {		if (getClass()->writeHeader && !data.checkInterface(this)) {
	return STATUS_BAD_TYPE;		return STATUS_BAD_TYPE;
	@@ -460,31 +385,6 @@ AIBinder_Class::AIBinder_Class(const char* interfaceDescriptor, AIBinder_Class_o
	mInterfaceDescriptor(interfaceDescriptor),		mInterfaceDescriptor(interfaceDescriptor),
	mWideInterfaceDescriptor(interfaceDescriptor) {}		mWideInterfaceDescriptor(interfaceDescriptor) {}

	bool AIBinder_Class::setTransactionCodeMap(const char** transactionCodeMap, size_t length) {
	if (mTransactionCodeToFunction != nullptr) {
	ALOGE("mTransactionCodeToFunction is already set!");
	return false;
	}
	mTransactionCodeToFunction = transactionCodeMap;
	mTransactionCodeToFunctionLength = length;
	return true;
	}

	const char* AIBinder_Class::getFunctionName(transaction_code_t code) const {
	if (mTransactionCodeToFunction == nullptr) {
	ALOGE("mTransactionCodeToFunction is not set!");
	return nullptr;
	}

	if (code < FIRST_CALL_TRANSACTION \|\|
	code - FIRST_CALL_TRANSACTION >= mTransactionCodeToFunctionLength) {
	ALOGE("Function name for requested code not found!");
	return nullptr;
	}

	return mTransactionCodeToFunction[code - FIRST_CALL_TRANSACTION];
	}

	AIBinder_Class* AIBinder_Class_define(const char* interfaceDescriptor,		AIBinder_Class* AIBinder_Class_define(const char* interfaceDescriptor,
	AIBinder_Class_onCreate onCreate,		AIBinder_Class_onCreate onCreate,
	AIBinder_Class_onDestroy onDestroy,		AIBinder_Class_onDestroy onDestroy,
	@@ -504,24 +404,6 @@ void AIBinder_Class_setOnDump(AIBinder_Class* clazz, AIBinder_onDump onDump) {
	clazz->onDump = onDump;		clazz->onDump = onDump;
	}		}

	void AIBinder_Class_setTransactionCodeToFunctionNameMap(AIBinder_Class* clazz,
	const char** transactionCodeToFunction,
	size_t length) {
	LOG_ALWAYS_FATAL_IF(clazz == nullptr \|\| transactionCodeToFunction == nullptr,
	"Valid clazz and transactionCodeToFunction are needed to set code to "
	"function mapping.");
	LOG_ALWAYS_FATAL_IF(!clazz->setTransactionCodeMap(transactionCodeToFunction, length),
	"Failed to set transactionCodeToFunction to clazz! Is "
	"transactionCodeToFunction already set?");
	}

	const char* AIBinder_Class_getFunctionName(AIBinder_Class* clazz, transaction_code_t code) {
	LOG_ALWAYS_FATAL_IF(
	clazz == nullptr,
	"Valid clazz is needed to get function name for requested transaction code");
	return clazz->getFunctionName(code);
	}

	void AIBinder_Class_disableInterfaceTokenHeader(AIBinder_Class* clazz) {		void AIBinder_Class_disableInterfaceTokenHeader(AIBinder_Class* clazz) {
	LOG_ALWAYS_FATAL_IF(clazz == nullptr, "disableInterfaceTokenHeader requires non-null clazz");		LOG_ALWAYS_FATAL_IF(clazz == nullptr, "disableInterfaceTokenHeader requires non-null clazz");

	@@ -852,19 +734,6 @@ static void DestroyParcel(AParcel** parcel) {

	binder_status_t AIBinder_transact(AIBinder* binder, transaction_code_t code, AParcel** in,		binder_status_t AIBinder_transact(AIBinder* binder, transaction_code_t code, AParcel** in,
	AParcel** out, binder_flags_t flags) {		AParcel** out, binder_flags_t flags) {
	const AIBinder_Class* clazz = binder ? binder->getClass() : nullptr;

	std::string sectionName;
	bool tracingEnabled = get_trace_enabled_tags() & ATRACE_TAG_AIDL;
	if (tracingEnabled) {
	sectionName = getTraceSectionName(clazz, code, false /isServer/);
	trace_begin(ATRACE_TAG_AIDL, sectionName.c_str());
	}

	scope_guard guard = make_scope_guard([&]() {
	if (tracingEnabled) trace_end(ATRACE_TAG_AIDL);
	});

	if (in == nullptr) {		if (in == nullptr) {
	ALOGE("%s: requires non-null in parameter", __func__);		ALOGE("%s: requires non-null in parameter", __func__);
	return STATUS_UNEXPECTED_NULL;		return STATUS_UNEXPECTED_NULL;