host/exynos/exynos_daemon.cc - platform/system/chre - Git at Google

 /*
  * Copyright (C) 2022 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 "exynos_daemon.h"
 #include <sys/epoll.h>
 #include <utils/SystemClock.h>
 #include <array>
 #include <csignal>
 #include "chre_host/file_stream.h"

 // Aliased for consistency with the way these symbols are referenced in
 // CHRE-side code
 namespace fbs = ::chre::fbs;

 namespace android {
 namespace chre {

 namespace {

 int createEpollFd(int fdToEpoll) {
   struct epoll_event event;
   event.data.fd = fdToEpoll;
   event.events = EPOLLIN | EPOLLWAKEUP;
   int epollFd = epoll_create1(EPOLL_CLOEXEC);
   if (epoll_ctl(epollFd, EPOLL_CTL_ADD, event.data.fd, &event) != 0) {
     LOGE("Failed to add control interface to msg read fd errno: %s",
          strerror(errno));
     epollFd = -1;
   }
   return epollFd;
 }

 }  // anonymous namespace

 ExynosDaemon::ExynosDaemon() : mLpmaHandler(true /* LPMA enabled */) {
   // TODO(b/235631242): Implement this.
 }

 bool ExynosDaemon::init() {
   constexpr size_t kMaxTimeSyncRetries = 5;
   constexpr useconds_t kTimeSyncRetryDelayUs = 50000;  // 50 ms
   bool success = false;
   mNativeThreadHandle = 0;
   siginterrupt(SIGINT, true);
   std::signal(SIGINT, signalHandler);
   if ((mCommsReadFd = open(kCommsDeviceFilename, O_RDONLY | O_CLOEXEC)) < 0) {
     LOGE("Read FD open failed: %s", strerror(errno));
   } else if ((mCommsWriteFd =
                   open(kCommsDeviceFilename, O_WRONLY | O_CLOEXEC)) < 0) {
     LOGE("Write FD open failed: %s", strerror(errno));
   } else {
     mProcessThreadRunning = true;
     mIncomingMsgProcessThread =
         std::thread([&] { this->processIncomingMsgs(); });
     mNativeThreadHandle = mIncomingMsgProcessThread.native_handle();

     if (!sendTimeSyncWithRetry(kMaxTimeSyncRetries, kTimeSyncRetryDelayUs,
                                true /* logOnError */)) {
       LOGE("Failed to send initial time sync message");
     } else {
       loadPreloadedNanoapps();
       success = true;
       LOGD("CHRE daemon initialized successfully");
     }
   }
   return success;
 }

 void ExynosDaemon::deinit() {
   stopMsgProcessingThread();

   close(mCommsWriteFd);
   mCommsWriteFd = kInvalidFd;

   close(mCommsReadFd);
   mCommsReadFd = kInvalidFd;
 }

 void ExynosDaemon::run() {
   constexpr char kChreSocketName[] = "chre";
   auto serverCb = [&](uint16_t clientId, void *data, size_t len) {
     sendMessageToChre(clientId, data, len);
   };

   mServer.run(kChreSocketName, true /* allowSocketCreation */, serverCb);
 }

 void ExynosDaemon::stopMsgProcessingThread() {
   if (mProcessThreadRunning) {
     mProcessThreadRunning = false;
     pthread_kill(mNativeThreadHandle, SIGINT);
     if (mIncomingMsgProcessThread.joinable()) {
       mIncomingMsgProcessThread.join();
     }
   }
 }

 void ExynosDaemon::processIncomingMsgs() {
   std::array<uint8_t, kIpcMsgSizeMax> message;
   int epollFd = createEpollFd(mCommsReadFd);

   while (mProcessThreadRunning) {
     struct epoll_event retEvent;
     int nEvents = epoll_wait(epollFd, &retEvent, 1 /* maxEvents */,
                              -1 /* infinite timeout */);
     if (nEvents < 0) {
       // epoll_wait will get interrupted if the CHRE daemon is shutting down,
       // check this condition before logging an error.
       if (mProcessThreadRunning) {
         LOGE("Epolling failed: %s", strerror(errno));
       }
     } else if (nEvents == 0) {
       LOGW("Epoll returned with 0 FDs ready despite no timeout (errno: %s)",
            strerror(errno));
     } else {
       int bytesRead = read(mCommsReadFd, message.data(), message.size());
       if (bytesRead < 0) {
         LOGE("Failed to read from fd: %s", strerror(errno));
       } else if (bytesRead == 0) {
         LOGE("Read 0 bytes from fd");
       } else {
         onMessageReceived(message.data(), bytesRead);
       }
     }
   }
 }

 bool ExynosDaemon::doSendMessage(void *data, size_t length) {
   bool success = false;
   if (length > kIpcMsgSizeMax) {
     LOGE("Msg size %zu larger than max msg size %zu", length, kIpcMsgSizeMax);
   } else {
     ssize_t rv = write(mCommsWriteFd, data, length);

     if (rv < 0) {
       LOGE("Failed to send message: %s", strerror(errno));
     } else if (rv != length) {
       LOGW("Msg send data loss: %zd of %zu bytes were written", rv, length);
     } else {
       success = true;
     }
   }
   return success;
 }

 int64_t ExynosDaemon::getTimeOffset(bool *success) {
   // TODO(b/235631242): Implement this.
   *success = false;
   return 0;
 }

 void ExynosDaemon::loadPreloadedNanoapp(const std::string &directory,
                                         const std::string &name,
                                         uint32_t transactionId) {
   std::vector<uint8_t> headerBuffer;
   std::vector<uint8_t> nanoappBuffer;

   std::string headerFilename = directory + "/" + name + ".napp_header";
   std::string nanoappFilename = directory + "/" + name + ".so";

   if (readFileContents(headerFilename.c_str(), headerBuffer) &&
       readFileContents(nanoappFilename.c_str(), nanoappBuffer) &&
       !loadNanoapp(headerBuffer, nanoappBuffer, transactionId)) {
     LOGE("Failed to load nanoapp: '%s'", name.c_str());
   }
 }

 bool ExynosDaemon::loadNanoapp(const std::vector<uint8_t> &header,
                                const std::vector<uint8_t> &nanoapp,
                                uint32_t transactionId) {
   // This struct comes from build/build_template.mk and must not be modified.
   // Refer to that file for more details.
   struct NanoAppBinaryHeader {
     uint32_t headerVersion;
     uint32_t magic;
     uint64_t appId;
     uint32_t appVersion;
     uint32_t flags;
     uint64_t hwHubType;
     uint8_t targetChreApiMajorVersion;
     uint8_t targetChreApiMinorVersion;
     uint8_t reserved[6];
   } __attribute__((packed));

   bool success = false;
   if (header.size() != sizeof(NanoAppBinaryHeader)) {
     LOGE("Header size mismatch");
   } else {
     // The header blob contains the struct above.
     const auto *appHeader =
         reinterpret_cast<const NanoAppBinaryHeader *>(header.data());

     // Build the target API version from major and minor.
     uint32_t targetApiVersion = (appHeader->targetChreApiMajorVersion << 24) |
                                 (appHeader->targetChreApiMinorVersion << 16);

     success = sendFragmentedNanoappLoad(
         appHeader->appId, appHeader->appVersion, appHeader->flags,
         targetApiVersion, nanoapp.data(), nanoapp.size(), transactionId);
   }

   return success;
 }

 bool ExynosDaemon::sendFragmentedNanoappLoad(
     uint64_t appId, uint32_t appVersion, uint32_t appFlags,
     uint32_t appTargetApiVersion, const uint8_t *appBinary, size_t appSize,
     uint32_t transactionId) {
   std::vector<uint8_t> binary(appSize);
   std::copy(appBinary, appBinary + appSize, binary.begin());

   FragmentedLoadTransaction transaction(transactionId, appId, appVersion,
                                         appFlags, appTargetApiVersion, binary);

   bool success = true;

   while (success && !transaction.isComplete()) {
     // Pad the builder to avoid allocation churn.
     const auto &fragment = transaction.getNextRequest();
     flatbuffers::FlatBufferBuilder builder(fragment.binary.size() + 128);
     HostProtocolHost::encodeFragmentedLoadNanoappRequest(
         builder, fragment, true /* respondBeforeStart */);
     success = sendFragmentAndWaitOnResponse(transactionId, builder,
                                             fragment.fragmentId, appId);
   }

   return success;
 }

 bool ExynosDaemon::sendFragmentAndWaitOnResponse(
     uint32_t transactionId, flatbuffers::FlatBufferBuilder &builder,
     uint32_t fragmentId, uint64_t appId) {
   bool success = true;
   std::unique_lock<std::mutex> lock(mPreloadedNanoappsMutex);

   mPreloadedNanoappPendingTransaction = {
       .transactionId = transactionId,
       .fragmentId = fragmentId,
       .nanoappId = appId,
   };
   mPreloadedNanoappPending = sendMessageToChre(
       kHostClientIdDaemon, builder.GetBufferPointer(), builder.GetSize());
   if (!mPreloadedNanoappPending) {
     LOGE("Failed to send nanoapp fragment");
     success = false;
   } else {
     std::chrono::seconds timeout(2);
     bool signaled = mPreloadedNanoappsCond.wait_for(
         lock, timeout, [this] { return !mPreloadedNanoappPending; });

     if (!signaled) {
       LOGE("Nanoapp fragment load timed out");
       success = false;
     }
   }
   return success;
 }

 void ExynosDaemon::handleDaemonMessage(const uint8_t *message) {
   std::unique_ptr<fbs::MessageContainerT> container =
       fbs::UnPackMessageContainer(message);
   if (container->message.type != fbs::ChreMessage::LoadNanoappResponse) {
     LOGE("Invalid message from CHRE directed to daemon");
   } else {
     const auto *response = container->message.AsLoadNanoappResponse();
     std::unique_lock<std::mutex> lock(mPreloadedNanoappsMutex);

     if (!mPreloadedNanoappPending) {
       LOGE("Received nanoapp load response with no pending load");
     } else if (mPreloadedNanoappPendingTransaction.transactionId !=
                response->transaction_id) {
       LOGE("Received nanoapp load response with invalid transaction id");
     } else if (mPreloadedNanoappPendingTransaction.fragmentId !=
                response->fragment_id) {
       LOGE("Received nanoapp load response with invalid fragment id");
     } else if (!response->success) {
 #ifdef CHRE_DAEMON_METRIC_ENABLED
       std::vector<VendorAtomValue> values(3);
       values[0].set<VendorAtomValue::longValue>(
           mPreloadedNanoappPendingTransaction.nanoappId);
       values[1].set<VendorAtomValue::intValue>(
           Atoms::ChreHalNanoappLoadFailed::TYPE_PRELOADED);
       values[2].set<VendorAtomValue::intValue>(
           Atoms::ChreHalNanoappLoadFailed::REASON_ERROR_GENERIC);
       const VendorAtom atom{
           .atomId = Atoms::CHRE_HAL_NANOAPP_LOAD_FAILED,
           .values{std::move(values)},
       };
       ChreDaemonBase::reportMetric(atom);
 #endif  // CHRE_DAEMON_METRIC_ENABLED

     } else {
       mPreloadedNanoappPending = false;
     }

     mPreloadedNanoappsCond.notify_all();
   }
 }

 }  // namespace chre
 }  // namespace android
	/*
	* Copyright (C) 2022 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 "exynos_daemon.h"
	#include <sys/epoll.h>
	#include <utils/SystemClock.h>
	#include <array>
	#include <csignal>
	#include "chre_host/file_stream.h"

	// Aliased for consistency with the way these symbols are referenced in
	// CHRE-side code
	namespace fbs = ::chre::fbs;

	namespace android {
	namespace chre {

	namespace {

	int createEpollFd(int fdToEpoll) {
	struct epoll_event event;
	event.data.fd = fdToEpoll;
	event.events = EPOLLIN \| EPOLLWAKEUP;
	int epollFd = epoll_create1(EPOLL_CLOEXEC);
	if (epoll_ctl(epollFd, EPOLL_CTL_ADD, event.data.fd, &event) != 0) {
	LOGE("Failed to add control interface to msg read fd errno: %s",
	strerror(errno));
	epollFd = -1;
	}
	return epollFd;
	}

	} // anonymous namespace

	ExynosDaemon::ExynosDaemon() : mLpmaHandler(true /* LPMA enabled */) {
	// TODO(b/235631242): Implement this.
	}

	bool ExynosDaemon::init() {
	constexpr size_t kMaxTimeSyncRetries = 5;
	constexpr useconds_t kTimeSyncRetryDelayUs = 50000; // 50 ms
	bool success = false;
	mNativeThreadHandle = 0;
	siginterrupt(SIGINT, true);
	std::signal(SIGINT, signalHandler);
	if ((mCommsReadFd = open(kCommsDeviceFilename, O_RDONLY \| O_CLOEXEC)) < 0) {
	LOGE("Read FD open failed: %s", strerror(errno));
	} else if ((mCommsWriteFd =
	open(kCommsDeviceFilename, O_WRONLY \| O_CLOEXEC)) < 0) {
	LOGE("Write FD open failed: %s", strerror(errno));
	} else {
	mProcessThreadRunning = true;
	mIncomingMsgProcessThread =
	std::thread([&] { this->processIncomingMsgs(); });
	mNativeThreadHandle = mIncomingMsgProcessThread.native_handle();

	if (!sendTimeSyncWithRetry(kMaxTimeSyncRetries, kTimeSyncRetryDelayUs,
	true /* logOnError */)) {
	LOGE("Failed to send initial time sync message");
	} else {
	loadPreloadedNanoapps();
	success = true;
	LOGD("CHRE daemon initialized successfully");
	}
	}
	return success;
	}

	void ExynosDaemon::deinit() {
	stopMsgProcessingThread();

	close(mCommsWriteFd);
	mCommsWriteFd = kInvalidFd;

	close(mCommsReadFd);
	mCommsReadFd = kInvalidFd;
	}

	void ExynosDaemon::run() {
	constexpr char kChreSocketName[] = "chre";
	auto serverCb = [&](uint16_t clientId, void *data, size_t len) {
	sendMessageToChre(clientId, data, len);
	};

	mServer.run(kChreSocketName, true /* allowSocketCreation */, serverCb);
	}

	void ExynosDaemon::stopMsgProcessingThread() {
	if (mProcessThreadRunning) {
	mProcessThreadRunning = false;
	pthread_kill(mNativeThreadHandle, SIGINT);
	if (mIncomingMsgProcessThread.joinable()) {
	mIncomingMsgProcessThread.join();
	}
	}
	}

	void ExynosDaemon::processIncomingMsgs() {
	std::array<uint8_t, kIpcMsgSizeMax> message;
	int epollFd = createEpollFd(mCommsReadFd);

	while (mProcessThreadRunning) {
	struct epoll_event retEvent;
	int nEvents = epoll_wait(epollFd, &retEvent, 1 /* maxEvents */,
	-1 /* infinite timeout */);
	if (nEvents < 0) {
	// epoll_wait will get interrupted if the CHRE daemon is shutting down,
	// check this condition before logging an error.
	if (mProcessThreadRunning) {
	LOGE("Epolling failed: %s", strerror(errno));
	}
	} else if (nEvents == 0) {
	LOGW("Epoll returned with 0 FDs ready despite no timeout (errno: %s)",
	strerror(errno));
	} else {
	int bytesRead = read(mCommsReadFd, message.data(), message.size());
	if (bytesRead < 0) {
	LOGE("Failed to read from fd: %s", strerror(errno));
	} else if (bytesRead == 0) {
	LOGE("Read 0 bytes from fd");
	} else {
	onMessageReceived(message.data(), bytesRead);
	}
	}
	}
	}

	bool ExynosDaemon::doSendMessage(void *data, size_t length) {
	bool success = false;
	if (length > kIpcMsgSizeMax) {
	LOGE("Msg size %zu larger than max msg size %zu", length, kIpcMsgSizeMax);
	} else {
	ssize_t rv = write(mCommsWriteFd, data, length);

	if (rv < 0) {
	LOGE("Failed to send message: %s", strerror(errno));
	} else if (rv != length) {
	LOGW("Msg send data loss: %zd of %zu bytes were written", rv, length);
	} else {
	success = true;
	}
	}
	return success;
	}

	int64_t ExynosDaemon::getTimeOffset(bool *success) {
	// TODO(b/235631242): Implement this.
	*success = false;
	return 0;
	}

	void ExynosDaemon::loadPreloadedNanoapp(const std::string &directory,
	const std::string &name,
	uint32_t transactionId) {
	std::vector<uint8_t> headerBuffer;
	std::vector<uint8_t> nanoappBuffer;

	std::string headerFilename = directory + "/" + name + ".napp_header";
	std::string nanoappFilename = directory + "/" + name + ".so";

	if (readFileContents(headerFilename.c_str(), headerBuffer) &&
	readFileContents(nanoappFilename.c_str(), nanoappBuffer) &&
	!loadNanoapp(headerBuffer, nanoappBuffer, transactionId)) {
	LOGE("Failed to load nanoapp: '%s'", name.c_str());
	}
	}

	bool ExynosDaemon::loadNanoapp(const std::vector<uint8_t> &header,
	const std::vector<uint8_t> &nanoapp,
	uint32_t transactionId) {
	// This struct comes from build/build_template.mk and must not be modified.
	// Refer to that file for more details.
	struct NanoAppBinaryHeader {
	uint32_t headerVersion;
	uint32_t magic;
	uint64_t appId;
	uint32_t appVersion;
	uint32_t flags;
	uint64_t hwHubType;
	uint8_t targetChreApiMajorVersion;
	uint8_t targetChreApiMinorVersion;
	uint8_t reserved[6];
	} __attribute__((packed));

	bool success = false;
	if (header.size() != sizeof(NanoAppBinaryHeader)) {
	LOGE("Header size mismatch");
	} else {
	// The header blob contains the struct above.
	const auto *appHeader =
	reinterpret_cast<const NanoAppBinaryHeader *>(header.data());

	// Build the target API version from major and minor.
	uint32_t targetApiVersion = (appHeader->targetChreApiMajorVersion << 24) \|
	(appHeader->targetChreApiMinorVersion << 16);

	success = sendFragmentedNanoappLoad(
	appHeader->appId, appHeader->appVersion, appHeader->flags,
	targetApiVersion, nanoapp.data(), nanoapp.size(), transactionId);
	}

	return success;
	}

	bool ExynosDaemon::sendFragmentedNanoappLoad(
	uint64_t appId, uint32_t appVersion, uint32_t appFlags,
	uint32_t appTargetApiVersion, const uint8_t *appBinary, size_t appSize,
	uint32_t transactionId) {
	std::vector<uint8_t> binary(appSize);
	std::copy(appBinary, appBinary + appSize, binary.begin());

	FragmentedLoadTransaction transaction(transactionId, appId, appVersion,
	appFlags, appTargetApiVersion, binary);

	bool success = true;

	while (success && !transaction.isComplete()) {
	// Pad the builder to avoid allocation churn.
	const auto &fragment = transaction.getNextRequest();
	flatbuffers::FlatBufferBuilder builder(fragment.binary.size() + 128);
	HostProtocolHost::encodeFragmentedLoadNanoappRequest(
	builder, fragment, true /* respondBeforeStart */);
	success = sendFragmentAndWaitOnResponse(transactionId, builder,
	fragment.fragmentId, appId);
	}

	return success;
	}

	bool ExynosDaemon::sendFragmentAndWaitOnResponse(
	uint32_t transactionId, flatbuffers::FlatBufferBuilder &builder,
	uint32_t fragmentId, uint64_t appId) {
	bool success = true;
	std::unique_lock<std::mutex> lock(mPreloadedNanoappsMutex);

	mPreloadedNanoappPendingTransaction = {
	.transactionId = transactionId,
	.fragmentId = fragmentId,
	.nanoappId = appId,
	};
	mPreloadedNanoappPending = sendMessageToChre(
	kHostClientIdDaemon, builder.GetBufferPointer(), builder.GetSize());
	if (!mPreloadedNanoappPending) {
	LOGE("Failed to send nanoapp fragment");
	success = false;
	} else {
	std::chrono::seconds timeout(2);
	bool signaled = mPreloadedNanoappsCond.wait_for(
	lock, timeout, [this] { return !mPreloadedNanoappPending; });

	if (!signaled) {
	LOGE("Nanoapp fragment load timed out");
	success = false;
	}
	}
	return success;
	}

	void ExynosDaemon::handleDaemonMessage(const uint8_t *message) {
	std::unique_ptr<fbs::MessageContainerT> container =
	fbs::UnPackMessageContainer(message);
	if (container->message.type != fbs::ChreMessage::LoadNanoappResponse) {
	LOGE("Invalid message from CHRE directed to daemon");
	} else {
	const auto *response = container->message.AsLoadNanoappResponse();
	std::unique_lock<std::mutex> lock(mPreloadedNanoappsMutex);

	if (!mPreloadedNanoappPending) {
	LOGE("Received nanoapp load response with no pending load");
	} else if (mPreloadedNanoappPendingTransaction.transactionId !=
	response->transaction_id) {
	LOGE("Received nanoapp load response with invalid transaction id");
	} else if (mPreloadedNanoappPendingTransaction.fragmentId !=
	response->fragment_id) {
	LOGE("Received nanoapp load response with invalid fragment id");
	} else if (!response->success) {
	#ifdef CHRE_DAEMON_METRIC_ENABLED
	std::vector<VendorAtomValue> values(3);
	values[0].set<VendorAtomValue::longValue>(
	mPreloadedNanoappPendingTransaction.nanoappId);
	values[1].set<VendorAtomValue::intValue>(
	Atoms::ChreHalNanoappLoadFailed::TYPE_PRELOADED);
	values[2].set<VendorAtomValue::intValue>(
	Atoms::ChreHalNanoappLoadFailed::REASON_ERROR_GENERIC);
	const VendorAtom atom{
	.atomId = Atoms::CHRE_HAL_NANOAPP_LOAD_FAILED,
	.values{std::move(values)},
	};
	ChreDaemonBase::reportMetric(atom);
	#endif // CHRE_DAEMON_METRIC_ENABLED

	} else {
	mPreloadedNanoappPending = false;
	}

	mPreloadedNanoappsCond.notify_all();
	}
	}

	} // namespace chre
	} // namespace android