Merge changes from topic "libhealthloop" (d902e230) · Commits · e / os / android_hardware_interfaces

health/2.0/default/Android.bp

+5 −1

Original line number	Diff line number	Diff line
		@@ -31,7 +31,11 @@ cc_library_static {
		vendor_available: true,
		srcs: [
		"Health.cpp",
		"healthd_common.cpp",
		"healthd_common_adapter.cpp",
		],

		whole_static_libs: [
		"libhealthloop",
		],

		export_include_dirs: ["include"],

health/2.0/default/healthd_common_adapter.cpp

0 → 100644

+74 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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.
		*/

		// Support legacy functions in healthd/healthd.h using healthd_mode_ops.
		// New code should use HealthLoop directly instead.

		#include <memory>

		#include <cutils/klog.h>
		#include <health/HealthLoop.h>
		#include <health2/Health.h>
		#include <healthd/healthd.h>

		using android::hardware::health::HealthLoop;
		using android::hardware::health::V2_0::implementation::Health;

		struct healthd_mode_ops* healthd_mode_ops = nullptr;

		// Adapter of HealthLoop to use legacy healthd_mode_ops.
		class HealthLoopAdapter : public HealthLoop {
		public:
		// Expose internal functions, assuming clients calls them in the same thread
		// where StartLoop is called.
		int RegisterEvent(int fd, BoundFunction func, EventWakeup wakeup) {
		return HealthLoop::RegisterEvent(fd, func, wakeup);
		}
		void AdjustWakealarmPeriods(bool charger_online) {
		return HealthLoop::AdjustWakealarmPeriods(charger_online);
		}
		protected:
		void Init(healthd_config* config) override { healthd_mode_ops->init(config); }
		void Heartbeat() override { healthd_mode_ops->heartbeat(); }
		int PrepareToWait() override { return healthd_mode_ops->preparetowait(); }
		void ScheduleBatteryUpdate() override { Health::getImplementation()->update(); }
		};
		static std::unique_ptr<HealthLoopAdapter> health_loop;

		int healthd_register_event(int fd, void (*handler)(uint32_t), EventWakeup wakeup) {
		auto wrapped_handler = [handler](auto*, uint32_t epevents) { handler(epevents); };
		return health_loop->RegisterEvent(fd, wrapped_handler, wakeup);
		}

		void healthd_battery_update_internal(bool charger_online) {
		health_loop->AdjustWakealarmPeriods(charger_online);
		}

		int healthd_main() {
		if (!healthd_mode_ops) {
		KLOG_ERROR("healthd ops not set, exiting\n");
		exit(1);
		}

		health_loop = std::make_unique<HealthLoopAdapter>();

		int ret = health_loop->StartLoop();

		// Should not reach here. The following will exit().
		health_loop.reset();

		return ret;
		}

health/utils/libhealthloop/Android.bp

0 → 100644

+35 −0

Original line number	Diff line number	Diff line
		// Copyright (C) 2019 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.

		cc_library_static {
		name: "libhealthloop",
		vendor_available: true,
		recovery_available: true,
		srcs: [
		"HealthLoop.cpp",
		"utils.cpp",
		],
		shared_libs: [
		"libcutils",
		"libbase",
		],
		header_libs: [
		"libbatteryservice_headers",
		"libhealthd_headers",
		"libutils_headers",
		],
		export_include_dirs: [
		"include",
		],
		}

health/2.0/default/healthd_common.cpp→health/utils/libhealthloop/HealthLoop.cpp

+267 −0

Original line number	Diff line number	Diff line
		@@ -14,15 +14,11 @@
		* limitations under the License.
		*/

		#define LOG_TAG "android.hardware.health@2.0-impl"
		#define LOG_TAG "HealthLoop"
		#define KLOG_LEVEL 6

		#include <healthd/BatteryMonitor.h>
		#include <healthd/healthd.h>
		#include <health/HealthLoop.h>

		#include <batteryservice/BatteryService.h>
		#include <cutils/klog.h>
		#include <cutils/uevent.h>
		#include <errno.h>
		#include <libgen.h>
		#include <stdio.h>
		@@ -31,77 +27,65 @@
		#include <sys/epoll.h>
		#include <sys/timerfd.h>
		#include <unistd.h>

		#include <android-base/logging.h>
		#include <batteryservice/BatteryService.h>
		#include <cutils/klog.h>
		#include <cutils/uevent.h>
		#include <healthd/healthd.h>
		#include <utils/Errors.h>

		#include <health2/Health.h>
		#include <health/utils.h>

		using namespace android;

		// Periodic chores fast interval in seconds
		#define DEFAULT_PERIODIC_CHORES_INTERVAL_FAST (60 * 1)
		// Periodic chores fast interval in seconds
		#define DEFAULT_PERIODIC_CHORES_INTERVAL_SLOW (60 * 10)

		static struct healthd_config healthd_config = {
		.periodic_chores_interval_fast = DEFAULT_PERIODIC_CHORES_INTERVAL_FAST,
		.periodic_chores_interval_slow = DEFAULT_PERIODIC_CHORES_INTERVAL_SLOW,
		.batteryStatusPath = String8(String8::kEmptyString),
		.batteryHealthPath = String8(String8::kEmptyString),
		.batteryPresentPath = String8(String8::kEmptyString),
		.batteryCapacityPath = String8(String8::kEmptyString),
		.batteryVoltagePath = String8(String8::kEmptyString),
		.batteryTemperaturePath = String8(String8::kEmptyString),
		.batteryTechnologyPath = String8(String8::kEmptyString),
		.batteryCurrentNowPath = String8(String8::kEmptyString),
		.batteryCurrentAvgPath = String8(String8::kEmptyString),
		.batteryChargeCounterPath = String8(String8::kEmptyString),
		.batteryFullChargePath = String8(String8::kEmptyString),
		.batteryCycleCountPath = String8(String8::kEmptyString),
		.energyCounter = NULL,
		.boot_min_cap = 0,
		.screen_on = NULL,
		};

		static int eventct;
		static int epollfd;
		using namespace std::chrono_literals;

		#define POWER_SUPPLY_SUBSYSTEM "power_supply"

		static int uevent_fd;
		static int wakealarm_fd;
		namespace android {
		namespace hardware {
		namespace health {

		// -1 for no epoll timeout
		static int awake_poll_interval = -1;
		HealthLoop::HealthLoop() {
		InitHealthdConfig(&healthd_config_);
		awake_poll_interval_ = -1;
		wakealarm_wake_interval_ = healthd_config_.periodic_chores_interval_fast;
		}

		static int wakealarm_wake_interval = DEFAULT_PERIODIC_CHORES_INTERVAL_FAST;
		HealthLoop::~HealthLoop() {
		LOG(FATAL) << "HealthLoop cannot be destroyed";
		}

		using ::android::hardware::health::V2_0::implementation::Health;
		int HealthLoop::RegisterEvent(int fd, BoundFunction func, EventWakeup wakeup) {
		CHECK(!reject_event_register_);

		struct healthd_mode_ops* healthd_mode_ops = nullptr;
		auto* event_handler =
		event_handlers_
		.emplace_back(std::make_unique<EventHandler>(EventHandler{this, fd, func}))
		.get();

		int healthd_register_event(int fd, void (*handler)(uint32_t), EventWakeup wakeup) {
		struct epoll_event ev;

		ev.events = EPOLLIN;

		if (wakeup == EVENT_WAKEUP_FD) ev.events \|= EPOLLWAKEUP;

		ev.data.ptr = (void*)handler;
		if (epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev) == -1) {
		ev.data.ptr = reinterpret_cast<void*>(event_handler);

		if (epoll_ctl(epollfd_, EPOLL_CTL_ADD, fd, &ev) == -1) {
		KLOG_ERROR(LOG_TAG, "epoll_ctl failed; errno=%d\n", errno);
		return -1;
		}

		eventct++;
		return 0;
		}

		static void wakealarm_set_interval(int interval) {
		void HealthLoop::WakeAlarmSetInterval(int interval) {
		struct itimerspec itval;

		if (wakealarm_fd == -1) return;
		if (wakealarm_fd_ == -1) return;

		wakealarm_wake_interval = interval;
		wakealarm_wake_interval_ = interval;

		if (interval == -1) interval = 0;

		@@ -110,47 +94,46 @@ static void wakealarm_set_interval(int interval) {
		itval.it_value.tv_sec = interval;
		itval.it_value.tv_nsec = 0;

		if (timerfd_settime(wakealarm_fd, 0, &itval, NULL) == -1)
		if (timerfd_settime(wakealarm_fd_, 0, &itval, NULL) == -1)
		KLOG_ERROR(LOG_TAG, "wakealarm_set_interval: timerfd_settime failed\n");
		}

		void healthd_battery_update_internal(bool charger_online) {
		void HealthLoop::AdjustWakealarmPeriods(bool charger_online) {
		// Fast wake interval when on charger (watch for overheat);
		// slow wake interval when on battery (watch for drained battery).

		int new_wake_interval = charger_online ? healthd_config.periodic_chores_interval_fast
		: healthd_config.periodic_chores_interval_slow;
		int new_wake_interval = charger_online ? healthd_config_.periodic_chores_interval_fast
		: healthd_config_.periodic_chores_interval_slow;

		if (new_wake_interval != wakealarm_wake_interval) wakealarm_set_interval(new_wake_interval);
		if (new_wake_interval != wakealarm_wake_interval_) WakeAlarmSetInterval(new_wake_interval);

		// During awake periods poll at fast rate. If wake alarm is set at fast
		// rate then just use the alarm; if wake alarm is set at slow rate then
		// poll at fast rate while awake and let alarm wake up at slow rate when
		// asleep.

		if (healthd_config.periodic_chores_interval_fast == -1)
		awake_poll_interval = -1;
		if (healthd_config_.periodic_chores_interval_fast == -1)
		awake_poll_interval_ = -1;
		else
		awake_poll_interval = new_wake_interval == healthd_config.periodic_chores_interval_fast
		awake_poll_interval_ = new_wake_interval == healthd_config_.periodic_chores_interval_fast
		? -1
		: healthd_config.periodic_chores_interval_fast * 1000;
		}

		static void healthd_battery_update(void) {
		Health::getImplementation()->update();
		: healthd_config_.periodic_chores_interval_fast * 1000;
		}

		static void periodic_chores() {
		healthd_battery_update();
		void HealthLoop::PeriodicChores() {
		ScheduleBatteryUpdate();
		}

		// TODO(b/140330870): Use BPF instead.
		#define UEVENT_MSG_LEN 2048
		static void uevent_event(uint32_t /epevents/) {
		void HealthLoop::UeventEvent(uint32_t /epevents/) {
		// No need to lock because uevent_fd_ is guaranteed to be initialized.

		char msg[UEVENT_MSG_LEN + 2];
		char* cp;
		int n;

		n = uevent_kernel_multicast_recv(uevent_fd, msg, UEVENT_MSG_LEN);
		n = uevent_kernel_multicast_recv(uevent_fd_, msg, UEVENT_MSG_LEN);
		if (n <= 0) return;
		if (n >= UEVENT_MSG_LEN) /* overflow -- discard */
		return;
		@@ -161,7 +144,7 @@ static void uevent_event(uint32_t /epevents/) {

		while (*cp) {
		if (!strcmp(cp, "SUBSYSTEM=" POWER_SUPPLY_SUBSYSTEM)) {
		healthd_battery_update();
		ScheduleBatteryUpdate();
		break;
		}

		@@ -171,58 +154,63 @@ static void uevent_event(uint32_t /epevents/) {
		}
		}

		static void uevent_init(void) {
		uevent_fd = uevent_open_socket(64 * 1024, true);
		void HealthLoop::UeventInit(void) {
		uevent_fd_.reset(uevent_open_socket(64 * 1024, true));

		if (uevent_fd < 0) {
		if (uevent_fd_ < 0) {
		KLOG_ERROR(LOG_TAG, "uevent_init: uevent_open_socket failed\n");
		return;
		}

		fcntl(uevent_fd, F_SETFL, O_NONBLOCK);
		if (healthd_register_event(uevent_fd, uevent_event, EVENT_WAKEUP_FD))
		fcntl(uevent_fd_, F_SETFL, O_NONBLOCK);
		if (RegisterEvent(uevent_fd_, &HealthLoop::UeventEvent, EVENT_WAKEUP_FD))
		KLOG_ERROR(LOG_TAG, "register for uevent events failed\n");
		}

		static void wakealarm_event(uint32_t /epevents/) {
		void HealthLoop::WakeAlarmEvent(uint32_t /epevents/) {
		// No need to lock because wakealarm_fd_ is guaranteed to be initialized.

		unsigned long long wakeups;

		if (read(wakealarm_fd, &wakeups, sizeof(wakeups)) == -1) {
		if (read(wakealarm_fd_, &wakeups, sizeof(wakeups)) == -1) {
		KLOG_ERROR(LOG_TAG, "wakealarm_event: read wakealarm fd failed\n");
		return;
		}

		periodic_chores();
		PeriodicChores();
		}

		static void wakealarm_init(void) {
		wakealarm_fd = timerfd_create(CLOCK_BOOTTIME_ALARM, TFD_NONBLOCK);
		if (wakealarm_fd == -1) {
		void HealthLoop::WakeAlarmInit(void) {
		wakealarm_fd_.reset(timerfd_create(CLOCK_BOOTTIME_ALARM, TFD_NONBLOCK));
		if (wakealarm_fd_ == -1) {
		KLOG_ERROR(LOG_TAG, "wakealarm_init: timerfd_create failed\n");
		return;
		}

		if (healthd_register_event(wakealarm_fd, wakealarm_event, EVENT_WAKEUP_FD))
		if (RegisterEvent(wakealarm_fd_, &HealthLoop::WakeAlarmEvent, EVENT_WAKEUP_FD))
		KLOG_ERROR(LOG_TAG, "Registration of wakealarm event failed\n");

		wakealarm_set_interval(healthd_config.periodic_chores_interval_fast);
		WakeAlarmSetInterval(healthd_config_.periodic_chores_interval_fast);
		}

		static void healthd_mainloop(void) {
		void HealthLoop::MainLoop(void) {
		int nevents = 0;
		while (1) {
		reject_event_register_ = true;
		size_t eventct = event_handlers_.size();
		struct epoll_event events[eventct];
		int timeout = awake_poll_interval;
		int timeout = awake_poll_interval_;

		int mode_timeout;

		/* Don't wait for first timer timeout to run periodic chores */
		if (!nevents) periodic_chores();
		if (!nevents) PeriodicChores();

		healthd_mode_ops->heartbeat();
		Heartbeat();

		mode_timeout = healthd_mode_ops->preparetowait();
		mode_timeout = PrepareToWait();
		if (timeout < 0 \|\| (mode_timeout > 0 && mode_timeout < timeout)) timeout = mode_timeout;
		nevents = epoll_wait(epollfd, events, eventct, timeout);
		nevents = epoll_wait(epollfd_, events, eventct, timeout);
		if (nevents == -1) {
		if (errno == EINTR) continue;
		KLOG_ERROR(LOG_TAG, "healthd_mainloop: epoll_wait failed\n");
		@@ -230,44 +218,50 @@ static void healthd_mainloop(void) {
		}

		for (int n = 0; n < nevents; ++n) {
		if (events[n].data.ptr) ((void ()(int))events[n].data.ptr)(events[n].events);
		if (events[n].data.ptr) {
		auto* event_handler = reinterpret_cast<EventHandler*>(events[n].data.ptr);
		event_handler->func(event_handler->object, events[n].events);
		}
		}
		}

		return;
		}

		static int healthd_init() {
		epollfd = epoll_create1(EPOLL_CLOEXEC);
		if (epollfd == -1) {
		int HealthLoop::InitInternal() {
		epollfd_.reset(epoll_create1(EPOLL_CLOEXEC));
		if (epollfd_ == -1) {
		KLOG_ERROR(LOG_TAG, "epoll_create1 failed; errno=%d\n", errno);
		return -1;
		}

		healthd_mode_ops->init(&healthd_config);
		wakealarm_init();
		uevent_init();
		// Call subclass's init for any additional init steps.
		// Note that healthd_config_ is initialized before wakealarm_fd_; see
		// AdjustUeventWakealarmPeriods().
		Init(&healthd_config_);

		WakeAlarmInit();
		UeventInit();

		return 0;
		}

		int healthd_main() {
		int HealthLoop::StartLoop() {
		int ret;

		klog_set_level(KLOG_LEVEL);

		if (!healthd_mode_ops) {
		KLOG_ERROR("healthd ops not set, exiting\n");
		exit(1);
		}

		ret = healthd_init();
		ret = InitInternal();
		if (ret) {
		KLOG_ERROR("Initialization failed, exiting\n");
		exit(2);
		KLOG_ERROR(LOG_TAG, "Initialization failed, exiting\n");
		return 2;
		}

		healthd_mainloop();
		KLOG_ERROR("Main loop terminated, exiting\n");
		MainLoop();
		KLOG_ERROR(LOG_TAG, "Main loop terminated, exiting\n");
		return 3;
		}

		} // namespace health
		} // namespace hardware
		} // namespace android

health/utils/libhealthloop/include/health/HealthLoop.h

0 → 100644

+108 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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.
		*/
		#pragma once

		#include <memory>
		#include <mutex>
		#include <vector>

		#include <android-base/unique_fd.h>
		#include <healthd/healthd.h>

		namespace android {
		namespace hardware {
		namespace health {

		class HealthLoop {
		public:
		HealthLoop();

		// Client is responsible for holding this forever. Process will exit
		// when this is destroyed.
		virtual ~HealthLoop();

		// Initialize and start the main loop. This function does not exit unless
		// the process is interrupted.
		// Once the loop is started, event handlers are no longer allowed to be
		// registered.
		int StartLoop();

		protected:
		// healthd_mode_ops overrides. Note that healthd_mode_ops->battery_update
		// is missing because it is only used by BatteryMonitor.
		// Init is called right after epollfd_ is initialized (so RegisterEvent
		// is allowed) but before other things are initialized (so SetChargerOnline
		// is not allowed.)
		virtual void Init(healthd_config* config) = 0;
		virtual void Heartbeat() = 0;
		virtual int PrepareToWait() = 0;

		// Note that this is NOT healthd_mode_ops->battery_update(BatteryProperties*),
		// which is called by BatteryMonitor after values are fetched. This is the
		// implementation of healthd_battery_update(), which calls
		// the correct IHealth::update(),
		// which calls BatteryMonitor::update(), which calls
		// healthd_mode_ops->battery_update(BatteryProperties*).
		virtual void ScheduleBatteryUpdate() = 0;

		// Register an epoll event. When there is an event, \|func\| will be
		// called with \|this\| as the first argument and \|epevents\| as the second.
		// This may be called in a different thread from where StartLoop is called
		// (for obvious reasons; StartLoop never ends).
		// Once the loop is started, event handlers are no longer allowed to be
		// registered.
		using BoundFunction = std::function<void(HealthLoop, uint32_t / epevents */)>;
		int RegisterEvent(int fd, BoundFunction func, EventWakeup wakeup);

		// Helper for implementing ScheduleBatteryUpdate(). An implementation of
		// ScheduleBatteryUpdate should get charger_online from BatteryMonitor::update(),
		// then reset wake alarm interval by calling AdjustWakealarmPeriods.
		void AdjustWakealarmPeriods(bool charger_online);

		private:
		struct EventHandler {
		HealthLoop* object = nullptr;
		int fd;
		BoundFunction func;
		};

		int InitInternal();
		void MainLoop();
		void WakeAlarmInit();
		void WakeAlarmEvent(uint32_t);
		void UeventInit();
		void UeventEvent(uint32_t);
		void WakeAlarmSetInterval(int interval);
		void PeriodicChores();

		// These are fixed after InitInternal() is called.
		struct healthd_config healthd_config_;
		android::base::unique_fd wakealarm_fd_;
		android::base::unique_fd uevent_fd_;

		android::base::unique_fd epollfd_;
		std::vector<std::unique_ptr<EventHandler>> event_handlers_;
		int awake_poll_interval_; // -1 for no epoll timeout
		int wakealarm_wake_interval_;

		// If set to true, future RegisterEvent() will be rejected. This is to ensure all
		// events are registered before StartLoop().
		bool reject_event_register_ = false;
		};

		} // namespace health
		} // namespace hardware
		} // namespace android