Merge "Don't depend on libbase result.h" into main (6c746778) · Commits · e / os / platform_frameworks_native

libs/binder/FdTrigger.h

+0 −1

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

		#include <memory>

		#include <android-base/result.h>
		#include <android-base/unique_fd.h>
		#include <utils/Errors.h>

libs/binder/OS.h

+1 −2

Original line number	Diff line number	Diff line
		@@ -18,14 +18,13 @@
		#include <stddef.h>
		#include <cstdint>

		#include <android-base/result.h>
		#include <android-base/unique_fd.h>
		#include <binder/RpcTransport.h>
		#include <utils/Errors.h>

		namespace android::binder::os {

		android::base::Result<void> setNonBlocking(android::base::borrowed_fd fd);
		status_t setNonBlocking(android::base::borrowed_fd fd);

		status_t getRandomBytes(uint8_t* data, size_t size);

libs/binder/OS_unix_base.cpp

+7 −7

Original line number	Diff line number	Diff line
		@@ -15,29 +15,29 @@
		*/

		#include "OS.h"
		#include "Utils.h"

		#include <android-base/file.h>
		#include <binder/RpcTransportRaw.h>
		#include <log/log.h>
		#include <string.h>

		using android::base::ErrnoError;
		using android::base::Result;

		namespace android::binder::os {

		// Linux kernel supports up to 253 (from SCM_MAX_FD) for unix sockets.
		constexpr size_t kMaxFdsPerMsg = 253;

		Result<void> setNonBlocking(android::base::borrowed_fd fd) {
		status_t setNonBlocking(android::base::borrowed_fd fd) {
		int flags = TEMP_FAILURE_RETRY(fcntl(fd.get(), F_GETFL));
		if (flags == -1) {
		return ErrnoError() << "Could not get flags for fd";
		PLOGE("Failed setNonBlocking: Could not get flags for fd");
		return -errno;
		}
		if (int ret = TEMP_FAILURE_RETRY(fcntl(fd.get(), F_SETFL, flags \| O_NONBLOCK)); ret == -1) {
		return ErrnoError() << "Could not set non-blocking flag for fd";
		PLOGE("Failed setNonBlocking: Could not set non-blocking flag for fd");
		return -errno;
		}
		return {};
		return OK;
		}

		status_t getRandomBytes(uint8_t* data, size_t size) {

libs/binder/ProcessState.cpp

+22 −23

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

		#include <binder/ProcessState.h>

		#include <android-base/result.h>
		#include <android-base/scopeguard.h>
		#include <android-base/strings.h>
		#include <binder/BpBinder.h>
		@@ -32,6 +31,7 @@
		#include <utils/Thread.h>

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

		#include <errno.h>
		@@ -512,31 +512,31 @@ String8 ProcessState::getDriverName() {
		return mDriverName;
		}

		static base::Result<int> open_driver(const char* driver) {
		int fd = open(driver, O_RDWR \| O_CLOEXEC);
		if (fd < 0) {
		return base::ErrnoError() << "Opening '" << driver << "' failed";
		static base::unique_fd open_driver(const char* driver) {
		auto fd = base::unique_fd(open(driver, O_RDWR \| O_CLOEXEC));
		if (!fd.ok()) {
		PLOGE("Opening '%s' failed", driver);
		return {};
		}
		int vers = 0;
		status_t result = ioctl(fd, BINDER_VERSION, &vers);
		int result = ioctl(fd.get(), BINDER_VERSION, &vers);
		if (result == -1) {
		close(fd);
		return base::ErrnoError() << "Binder ioctl to obtain version failed";
		PLOGE("Binder ioctl to obtain version failed");
		return {};
		}
		if (result != 0 \|\| vers != BINDER_CURRENT_PROTOCOL_VERSION) {
		close(fd);
		return base::Error() << "Binder driver protocol(" << vers
		<< ") does not match user space protocol("
		<< BINDER_CURRENT_PROTOCOL_VERSION
		<< ")! ioctl() return value: " << result;
		ALOGE("Binder driver protocol(%d) does not match user space protocol(%d)! "
		"ioctl() return value: %d",
		vers, BINDER_CURRENT_PROTOCOL_VERSION, result);
		return {};
		}
		size_t maxThreads = DEFAULT_MAX_BINDER_THREADS;
		result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);
		result = ioctl(fd.get(), BINDER_SET_MAX_THREADS, &maxThreads);
		if (result == -1) {
		ALOGE("Binder ioctl to set max threads failed: %s", strerror(errno));
		}
		uint32_t enable = DEFAULT_ENABLE_ONEWAY_SPAM_DETECTION;
		result = ioctl(fd, BINDER_ENABLE_ONEWAY_SPAM_DETECTION, &enable);
		result = ioctl(fd.get(), BINDER_ENABLE_ONEWAY_SPAM_DETECTION, &enable);
		if (result == -1) {
		ALOGE_IF(ProcessState::isDriverFeatureEnabled(
		ProcessState::DriverFeature::ONEWAY_SPAM_DETECTION),
		@@ -561,28 +561,27 @@ ProcessState::ProcessState(const char* driver)
		mThreadPoolStarted(false),
		mThreadPoolSeq(1),
		mCallRestriction(CallRestriction::NONE) {
		base::Result<int> opened = open_driver(driver);
		base::unique_fd opened = open_driver(driver);

		if (opened.ok()) {
		// mmap the binder, providing a chunk of virtual address space to receive transactions.
		mVMStart = mmap(nullptr, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE \| MAP_NORESERVE,
		opened.value(), 0);
		opened.get(), 0);
		if (mVMStart == MAP_FAILED) {
		close(opened.value());
		// sigh
		opened = base::Error()
		<< "Using " << driver << " failed: unable to mmap transaction memory.";
		ALOGE("Using %s failed: unable to mmap transaction memory.", driver);
		opened.reset();
		mDriverName.clear();
		}
		}

		#ifdef __ANDROID__
		LOG_ALWAYS_FATAL_IF(!opened.ok(), "Binder driver '%s' could not be opened. Terminating: %s",
		driver, opened.error().message().c_str());
		LOG_ALWAYS_FATAL_IF(!opened.ok(), "Binder driver '%s' could not be opened. Terminating.",
		driver);
		#endif

		if (opened.ok()) {
		mDriverFD = opened.value();
		mDriverFD = opened.release();
		}
		}

libs/binder/RpcServer.cpp

+1 −4

Original line number	Diff line number	Diff line
		@@ -230,10 +230,7 @@ status_t RpcServer::recvmsgSocketConnection(const RpcServer& server, RpcTranspor
		}

		unique_fd fd(std::move(std::get<unique_fd>(fds.back())));
		if (auto res = binder::os::setNonBlocking(fd); !res.ok()) {
		ALOGE("Failed setNonBlocking: %s", res.error().message().c_str());
		return res.error().code() == 0 ? UNKNOWN_ERROR : -res.error().code();
		}
		if (status_t res = binder::os::setNonBlocking(fd); res != OK) return res;

		*out = RpcTransportFd(std::move(fd));
		return OK;