Merge "Merge Android 12" (6042b45f) · Commits · e / os / android_system_core

init/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -448,6 +448,7 @@ cc_test {

		srcs: [
		"devices_test.cpp",
		"epoll_test.cpp",
		"firmware_handler_test.cpp",
		"init_test.cpp",
		"keychords_test.cpp",

init/epoll.cpp

+7 −5

Original line number	Diff line number	Diff line
		@@ -38,11 +38,12 @@ Result<void> Epoll::Open() {
		return {};
		}

		Result<void> Epoll::RegisterHandler(int fd, std::function<void()> handler, uint32_t events) {
		Result<void> Epoll::RegisterHandler(int fd, Handler handler, uint32_t events) {
		if (!events) {
		return Error() << "Must specify events";
		}
		auto [it, inserted] = epoll_handlers_.emplace(fd, std::move(handler));
		auto sp = std::make_shared<decltype(handler)>(std::move(handler));
		auto [it, inserted] = epoll_handlers_.emplace(fd, std::move(sp));
		if (!inserted) {
		return Error() << "Cannot specify two epoll handlers for a given FD";
		}
		@@ -69,7 +70,7 @@ Result<void> Epoll::UnregisterHandler(int fd) {
		return {};
		}

		Result<std::vector<std::function<void()>*>> Epoll::Wait(
		Result<std::vector<std::shared_ptr<Epoll::Handler>>> Epoll::Wait(
		std::optional<std::chrono::milliseconds> timeout) {
		int timeout_ms = -1;
		if (timeout && timeout->count() < INT_MAX) {
		@@ -81,9 +82,10 @@ Result<std::vector<std::function<void()>*>> Epoll::Wait(
		if (num_events == -1) {
		return ErrnoError() << "epoll_wait failed";
		}
		std::vector<std::function<void()>*> pending_functions;
		std::vector<std::shared_ptr<Handler>> pending_functions;
		for (int i = 0; i < num_events; ++i) {
		pending_functions.emplace_back(reinterpret_cast<std::function<void()>*>(ev[i].data.ptr));
		auto sp = reinterpret_cast<std::shared_ptr<Handler>>(ev[i].data.ptr);
		pending_functions.emplace_back(std::move(sp));
		}

		return pending_functions;

init/epoll.h

+6 −3

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@
		#include <chrono>
		#include <functional>
		#include <map>
		#include <memory>
		#include <optional>
		#include <vector>

		@@ -36,15 +37,17 @@ class Epoll {
		public:
		Epoll();

		typedef std::function<void()> Handler;

		Result<void> Open();
		Result<void> RegisterHandler(int fd, std::function<void()> handler, uint32_t events = EPOLLIN);
		Result<void> RegisterHandler(int fd, Handler handler, uint32_t events = EPOLLIN);
		Result<void> UnregisterHandler(int fd);
		Result<std::vector<std::function<void()>*>> Wait(
		Result<std::vector<std::shared_ptr<Handler>>> Wait(
		std::optional<std::chrono::milliseconds> timeout);

		private:
		android::base::unique_fd epoll_fd_;
		std::map<int, std::function<void()>> epoll_handlers_;
		std::map<int, std::shared_ptr<Handler>> epoll_handlers_;
		};

		} // namespace init

init/epoll_test.cpp

0 → 100644

+76 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 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 "epoll.h"

		#include <sys/unistd.h>

		#include <unordered_set>

		#include <android-base/file.h>
		#include <gtest/gtest.h>

		namespace android {
		namespace init {

		std::unordered_set<void*> sValidObjects;

		class CatchDtor final {
		public:
		CatchDtor() { sValidObjects.emplace(this); }
		CatchDtor(const CatchDtor&) { sValidObjects.emplace(this); }
		~CatchDtor() {
		auto iter = sValidObjects.find(this);
		if (iter != sValidObjects.end()) {
		sValidObjects.erase(iter);
		}
		}
		};

		TEST(epoll, UnregisterHandler) {
		Epoll epoll;
		ASSERT_RESULT_OK(epoll.Open());

		int fds[2];
		ASSERT_EQ(pipe(fds), 0);

		CatchDtor catch_dtor;
		bool handler_invoked;
		auto handler = [&, catch_dtor]() -> void {
		auto result = epoll.UnregisterHandler(fds[0]);
		ASSERT_EQ(result.ok(), !handler_invoked);
		handler_invoked = true;
		ASSERT_NE(sValidObjects.find((void*)&catch_dtor), sValidObjects.end());
		};

		epoll.RegisterHandler(fds[0], std::move(handler));

		uint8_t byte = 0xee;
		ASSERT_TRUE(android::base::WriteFully(fds[1], &byte, sizeof(byte)));

		auto results = epoll.Wait({});
		ASSERT_RESULT_OK(results);
		ASSERT_EQ(results->size(), size_t(1));

		for (const auto& function : *results) {
		(*function)();
		(*function)();
		}
		ASSERT_TRUE(handler_invoked);
		}

		} // namespace init
		} // namespace android

libutils/String16.cpp

+37 −77

Original line number	Diff line number	Diff line
		@@ -199,100 +199,60 @@ status_t String16::setTo(const char16_t* other, size_t len)
		return NO_MEMORY;
		}

		status_t String16::append(const String16& other)
		{
		const size_t myLen = size();
		const size_t otherLen = other.size();
		if (myLen == 0) {
		setTo(other);
		return OK;
		} else if (otherLen == 0) {
		return OK;
		status_t String16::append(const String16& other) {
		return append(other.string(), other.size());
		}

		if (myLen >= SIZE_MAX / sizeof(char16_t) - otherLen) {
		android_errorWriteLog(0x534e4554, "73826242");
		abort();
		}
		status_t String16::append(const char16_t* chrs, size_t otherLen) {
		const size_t myLen = size();

		SharedBuffer* buf =
		static_cast<SharedBuffer>(editResize((myLen + otherLen + 1) sizeof(char16_t)));
		if (buf) {
		char16_t* str = (char16_t*)buf->data();
		memcpy(str+myLen, other, (otherLen+1)*sizeof(char16_t));
		mString = str;
		return OK;
		}
		return NO_MEMORY;
		}
		if (myLen == 0) return setTo(chrs, otherLen);

		status_t String16::append(const char16_t* chrs, size_t otherLen)
		{
		const size_t myLen = size();
		if (myLen == 0) {
		setTo(chrs, otherLen);
		return OK;
		} else if (otherLen == 0) {
		return OK;
		}
		if (otherLen == 0) return OK;

		if (myLen >= SIZE_MAX / sizeof(char16_t) - otherLen) {
		android_errorWriteLog(0x534e4554, "73826242");
		abort();
		}
		size_t size = myLen;
		if (__builtin_add_overflow(size, otherLen, &size) \|\|
		__builtin_add_overflow(size, 1, &size) \|\|
		__builtin_mul_overflow(size, sizeof(char16_t), &size)) return NO_MEMORY;

		SharedBuffer* buf =
		static_cast<SharedBuffer>(editResize((myLen + otherLen + 1) sizeof(char16_t)));
		if (buf) {
		char16_t* str = (char16_t*)buf->data();
		SharedBuffer* buf = static_cast<SharedBuffer*>(editResize(size));
		if (!buf) return NO_MEMORY;

		char16_t* str = static_cast<char16_t*>(buf->data());
		memcpy(str + myLen, chrs, otherLen * sizeof(char16_t));
		str[myLen + otherLen] = 0;
		mString = str;
		return OK;
		}
		return NO_MEMORY;
		}

		status_t String16::insert(size_t pos, const char16_t* chrs)
		{
		status_t String16::insert(size_t pos, const char16_t* chrs) {
		return insert(pos, chrs, strlen16(chrs));
		}

		status_t String16::insert(size_t pos, const char16_t* chrs, size_t len)
		{
		status_t String16::insert(size_t pos, const char16_t* chrs, size_t otherLen) {
		const size_t myLen = size();
		if (myLen == 0) {
		return setTo(chrs, len);
		return OK;
		} else if (len == 0) {
		return OK;
		}

		if (myLen == 0) return setTo(chrs, otherLen);

		if (otherLen == 0) return OK;

		if (pos > myLen) pos = myLen;

		#if 0
		printf("Insert in to %s: pos=%d, len=%d, myLen=%d, chrs=%s\n",
		String8(*this).string(), pos,
		len, myLen, String8(chrs, len).string());
		#endif
		size_t size = myLen;
		if (__builtin_add_overflow(size, otherLen, &size) \|\|
		__builtin_add_overflow(size, 1, &size) \|\|
		__builtin_mul_overflow(size, sizeof(char16_t), &size)) return NO_MEMORY;

		SharedBuffer* buf =
		static_cast<SharedBuffer>(editResize((myLen + len + 1) sizeof(char16_t)));
		if (buf) {
		char16_t* str = (char16_t*)buf->data();
		if (pos < myLen) {
		memmove(str+pos+len, str+pos, (myLen-pos)*sizeof(char16_t));
		}
		memcpy(str+pos, chrs, len*sizeof(char16_t));
		str[myLen+len] = 0;
		SharedBuffer* buf = static_cast<SharedBuffer*>(editResize(size));
		if (!buf) return NO_MEMORY;

		char16_t* str = static_cast<char16_t*>(buf->data());
		if (pos < myLen) memmove(str + pos + otherLen, str + pos, (myLen - pos) * sizeof(char16_t));
		memcpy(str + pos, chrs, otherLen * sizeof(char16_t));
		str[myLen + otherLen] = 0;
		mString = str;
		#if 0
		printf("Result (%d chrs): %s\n", size(), String8(*this).string());
		#endif
		return OK;
		}
		return NO_MEMORY;
		}

		ssize_t String16::findFirst(char16_t c) const
		{