thermal/utils/thermal_watcher.cpp - platform/hardware/google/pixel - 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.
  */

 #define ATRACE_TAG (ATRACE_TAG_THERMAL | ATRACE_TAG_HAL)

 #include "thermal_watcher.h"

 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <cutils/uevent.h>
 #include <dirent.h>
 #include <linux/netlink.h>
 #include <linux/thermal.h>
 #include <sys/inotify.h>
 #include <sys/resource.h>
 #include <sys/types.h>
 #include <utils/Trace.h>

 #include <chrono>
 #include <fstream>

 #include "../thermal-helper.h"

 namespace aidl {
 namespace android {
 namespace hardware {
 namespace thermal {
 namespace implementation {

 namespace {

 static int nlErrorHandle(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg) {
     int *ret = reinterpret_cast<int *>(arg);
     *ret = err->error;
     LOG(ERROR) << __func__ << "nl_groups: " << nla->nl_groups << ", nl_pid: " << nla->nl_pid;

     return NL_STOP;
 }

 static int nlFinishHandle(struct nl_msg *msg, void *arg) {
     int *ret = reinterpret_cast<int *>(arg);
     *ret = 1;
     struct nlmsghdr *nlh = nlmsg_hdr(msg);

     LOG(VERBOSE) << __func__ << ": nlmsg type: " << nlh->nlmsg_type;

     return NL_OK;
 }

 static int nlAckHandle(struct nl_msg *msg, void *arg) {
     int *ret = reinterpret_cast<int *>(arg);
     *ret = 1;
     struct nlmsghdr *nlh = nlmsg_hdr(msg);

     LOG(VERBOSE) << __func__ << ": nlmsg type: " << nlh->nlmsg_type;

     return NL_OK;
 }

 static int nlSeqCheckHandle(struct nl_msg *msg, void *arg) {
     int *ret = reinterpret_cast<int *>(arg);
     *ret = 1;
     struct nlmsghdr *nlh = nlmsg_hdr(msg);

     LOG(VERBOSE) << __func__ << ": nlmsg type: " << nlh->nlmsg_type;

     return NL_OK;
 }

 struct HandlerArgs {
     const char *group;
     int id;
 };

 static int nlSendMsg(struct nl_sock *sock, struct nl_msg *msg,
                      int (*rx_handler)(struct nl_msg *, void *), void *data) {
     int err, done = 0;

     std::unique_ptr<nl_cb, decltype(&nl_cb_put)> cb(nl_cb_alloc(NL_CB_DEFAULT), nl_cb_put);

     err = nl_send_auto_complete(sock, msg);
     if (err < 0)
         return err;

     err = 0;
     nl_cb_err(cb.get(), NL_CB_CUSTOM, nlErrorHandle, &err);
     nl_cb_set(cb.get(), NL_CB_FINISH, NL_CB_CUSTOM, nlFinishHandle, &done);
     nl_cb_set(cb.get(), NL_CB_ACK, NL_CB_CUSTOM, nlAckHandle, &done);

     if (rx_handler != NULL)
         nl_cb_set(cb.get(), NL_CB_VALID, NL_CB_CUSTOM, rx_handler, data);

     while (err == 0 && done == 0) nl_recvmsgs(sock, cb.get());

     return err;
 }

 static int nlFamilyHandle(struct nl_msg *msg, void *arg) {
     struct HandlerArgs *grp = reinterpret_cast<struct HandlerArgs *>(arg);
     struct nlattr *tb[CTRL_ATTR_MAX + 1];
     struct genlmsghdr *gnlh = (struct genlmsghdr *)nlmsg_data(nlmsg_hdr(msg));
     struct nlattr *mcgrp;
     int rem_mcgrp;

     nla_parse(tb, CTRL_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL);

     if (!tb[CTRL_ATTR_MCAST_GROUPS]) {
         LOG(ERROR) << __func__ << "Multicast group not found";
         return -1;
     }

     nla_for_each_nested(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], rem_mcgrp) {
         struct nlattr *tb_mcgrp[CTRL_ATTR_MCAST_GRP_MAX + 1];

         nla_parse(tb_mcgrp, CTRL_ATTR_MCAST_GRP_MAX, reinterpret_cast<nlattr *>(nla_data(mcgrp)),
                   nla_len(mcgrp), NULL);

         if (!tb_mcgrp[CTRL_ATTR_MCAST_GRP_NAME] || !tb_mcgrp[CTRL_ATTR_MCAST_GRP_ID])
             continue;

         if (strncmp(reinterpret_cast<char *>(nla_data(tb_mcgrp[CTRL_ATTR_MCAST_GRP_NAME])),
                     grp->group, nla_len(tb_mcgrp[CTRL_ATTR_MCAST_GRP_NAME])) != 0)
             continue;

         grp->id = nla_get_u32(tb_mcgrp[CTRL_ATTR_MCAST_GRP_ID]);

         break;
     }

     return 0;
 }

 static int nlGetMulticastId(struct nl_sock *sock, const char *family, const char *group) {
     int err = 0, ctrlid;
     struct HandlerArgs grp = {
             .group = group,
             .id = -ENOENT,
     };

     std::unique_ptr<nl_msg, decltype(&nlmsg_free)> msg(nlmsg_alloc(), nlmsg_free);

     ctrlid = genl_ctrl_resolve(sock, "nlctrl");

     genlmsg_put(msg.get(), 0, 0, ctrlid, 0, 0, CTRL_CMD_GETFAMILY, 0);

     nla_put_string(msg.get(), CTRL_ATTR_FAMILY_NAME, family);

     err = nlSendMsg(sock, msg.get(), nlFamilyHandle, &grp);
     if (err)
         return err;

     err = grp.id;
     LOG(INFO) << group << " multicast_id: " << grp.id;

     return err;
 }

 static bool socketAddMembership(struct nl_sock *sock, const char *group) {
     int mcid = nlGetMulticastId(sock, THERMAL_GENL_FAMILY_NAME, group);
     if (mcid < 0) {
         LOG(ERROR) << "Failed to get multicast id: " << group;
         return false;
     }

     if (nl_socket_add_membership(sock, mcid)) {
         LOG(ERROR) << "Failed to add netlink socket membership: " << group;
         return false;
     }

     LOG(INFO) << "Added netlink socket membership: " << group;
     return true;
 }

 static int handleEvent(struct nl_msg *n, void *arg) {
     struct nlmsghdr *nlh = nlmsg_hdr(n);
     struct genlmsghdr *glh = genlmsg_hdr(nlh);
     struct nlattr *attrs[THERMAL_GENL_ATTR_MAX + 1];
     int *tz_id = reinterpret_cast<int *>(arg);

     genlmsg_parse(nlh, 0, attrs, THERMAL_GENL_ATTR_MAX, NULL);

     if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_UP) {
         LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_UP";
         if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
             LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
             *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
         }
         if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID])
             LOG(INFO) << "Thermal zone trip id: "
                       << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]);
     }

     if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_DOWN) {
         LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_DOWN";
         if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
             LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
             *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
         }
         if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID])
             LOG(INFO) << "Thermal zone trip id: "
                       << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]);
     }

     if (glh->cmd == THERMAL_GENL_EVENT_TZ_GOV_CHANGE) {
         LOG(INFO) << "THERMAL_GENL_EVENT_TZ_GOV_CHANGE";
         if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
             LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
             *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
         }
         if (attrs[THERMAL_GENL_ATTR_GOV_NAME])
             LOG(INFO) << "Governor name: " << nla_get_string(attrs[THERMAL_GENL_ATTR_GOV_NAME]);
     }

     if (glh->cmd == THERMAL_GENL_EVENT_TZ_CREATE) {
         LOG(INFO) << "THERMAL_GENL_EVENT_TZ_CREATE";
         if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
             LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
             *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
         }
         if (attrs[THERMAL_GENL_ATTR_TZ_NAME])
             LOG(INFO) << "Thermal zone name: " << nla_get_string(attrs[THERMAL_GENL_ATTR_TZ_NAME]);
     }

     if (glh->cmd == THERMAL_GENL_EVENT_TZ_DELETE) {
         LOG(INFO) << "THERMAL_GENL_EVENT_TZ_DELETE";
         if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
             LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
             *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
         }
     }

     if (glh->cmd == THERMAL_GENL_EVENT_TZ_DISABLE) {
         LOG(INFO) << "THERMAL_GENL_EVENT_TZ_DISABLE";
         if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
             LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
             *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
         }
     }

     if (glh->cmd == THERMAL_GENL_EVENT_TZ_ENABLE) {
         LOG(INFO) << "THERMAL_GENL_EVENT_TZ_ENABLE";
         if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
             LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
             *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
         }
     }

     if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_CHANGE) {
         LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_CHANGE";
         if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
             LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
             *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
         }
         if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID])
             LOG(INFO) << "Trip id:: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]);
         if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE])
             LOG(INFO) << "Trip type: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE]);
         if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP])
             LOG(INFO) << "Trip temp: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP]);
         if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST])
             LOG(INFO) << "Trip hyst: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST]);
     }

     if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_ADD) {
         LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_ADD";
         if (attrs[THERMAL_GENL_ATTR_TZ_ID])
             LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
         if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID])
             LOG(INFO) << "Trip id:: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]);
         if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE])
             LOG(INFO) << "Trip type: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE]);
         if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP])
             LOG(INFO) << "Trip temp: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP]);
         if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST])
             LOG(INFO) << "Trip hyst: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST]);
     }

     if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_DELETE) {
         LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_DELETE";
         if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
             LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
             *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
         }
         if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID])
             LOG(INFO) << "Trip id:: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]);
     }

     if (glh->cmd == THERMAL_GENL_EVENT_CDEV_STATE_UPDATE) {
         LOG(INFO) << "THERMAL_GENL_EVENT_CDEV_STATE_UPDATE";
         if (attrs[THERMAL_GENL_ATTR_CDEV_ID])
             LOG(INFO) << "Cooling device id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_ID]);
         if (attrs[THERMAL_GENL_ATTR_CDEV_CUR_STATE])
             LOG(INFO) << "Cooling device current state: "
                       << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_CUR_STATE]);
     }

     if (glh->cmd == THERMAL_GENL_EVENT_CDEV_ADD) {
         LOG(INFO) << "THERMAL_GENL_EVENT_CDEV_ADD";
         if (attrs[THERMAL_GENL_ATTR_CDEV_NAME])
             LOG(INFO) << "Cooling device name: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_NAME]);
         if (attrs[THERMAL_GENL_ATTR_CDEV_ID])
             LOG(INFO) << "Cooling device id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_ID]);
         if (attrs[THERMAL_GENL_ATTR_CDEV_MAX_STATE])
             LOG(INFO) << "Cooling device max state: "
                       << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_MAX_STATE]);
     }

     if (glh->cmd == THERMAL_GENL_EVENT_CDEV_DELETE) {
         LOG(INFO) << "THERMAL_GENL_EVENT_CDEV_DELETE";
         if (attrs[THERMAL_GENL_ATTR_CDEV_ID])
             LOG(INFO) << "Cooling device id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_ID]);
     }

     if (glh->cmd == THERMAL_GENL_SAMPLING_TEMP) {
         LOG(INFO) << "THERMAL_GENL_SAMPLING_TEMP";
         if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
             LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
             *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
         }
         if (attrs[THERMAL_GENL_ATTR_TZ_TEMP])
             LOG(INFO) << "Thermal zone temp: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TEMP]);
     }

     return 0;
 }

 }  // namespace

 void ThermalWatcher::registerFilesToWatch(const std::set<std::string> &sensors_to_watch) {
     LOG(INFO) << "Uevent register file to watch...";
     monitored_sensors_.insert(sensors_to_watch.begin(), sensors_to_watch.end());

     uevent_fd_.reset((TEMP_FAILURE_RETRY(uevent_open_socket(64 * 1024, true))));
     if (uevent_fd_.get() < 0) {
         LOG(ERROR) << "failed to open uevent socket";
         return;
     }

     fcntl(uevent_fd_, F_SETFL, O_NONBLOCK);

     looper_->addFd(uevent_fd_.get(), 0, ::android::Looper::EVENT_INPUT, nullptr, nullptr);
     sleep_ms_ = std::chrono::milliseconds(0);
     last_update_time_ = boot_clock::now();
 }

 void ThermalWatcher::registerFilesToWatchNl(const std::set<std::string> &sensors_to_watch) {
     LOG(INFO) << "Thermal genl register file to watch...";
     monitored_sensors_.insert(sensors_to_watch.begin(), sensors_to_watch.end());

     sk_thermal = nl_socket_alloc();
     if (!sk_thermal) {
         LOG(ERROR) << "nl_socket_alloc failed";
         return;
     }

     if (genl_connect(sk_thermal)) {
         LOG(ERROR) << "genl_connect failed: sk_thermal";
         return;
     }

     thermal_genl_fd_.reset(nl_socket_get_fd(sk_thermal));
     if (thermal_genl_fd_.get() < 0) {
         LOG(ERROR) << "Failed to create thermal netlink socket";
         return;
     }

     if (!socketAddMembership(sk_thermal, THERMAL_GENL_EVENT_GROUP_NAME)) {
         return;
     }

     /*
      * Currently, only the update_temperature() will send thermal genl samlping events
      * from kernel. To avoid thermal-hal busy because samlping events are sent
      * too frequently, ignore thermal genl samlping events until we figure out how to use it.
      *
     if (!socketAddMembership(sk_thermal, THERMAL_GENL_SAMPLING_GROUP_NAME)) {
         return;
     }
     */

     fcntl(thermal_genl_fd_, F_SETFL, O_NONBLOCK);
     looper_->addFd(thermal_genl_fd_.get(), 0, ::android::Looper::EVENT_INPUT, nullptr, nullptr);
     sleep_ms_ = std::chrono::milliseconds(0);
     last_update_time_ = boot_clock::now();
 }

 bool ThermalWatcher::startWatchingDeviceFiles() {
     if (cb_) {
         auto ret = this->run("FileWatcherThread", -10);
         if (ret != ::android::NO_ERROR) {
             LOG(ERROR) << "ThermalWatcherThread start fail";
             return false;
         } else {
             LOG(INFO) << "ThermalWatcherThread started";
             return true;
         }
     }
     return false;
 }
 void ThermalWatcher::parseUevent(std::set<std::string> *sensors_set) {
     bool thermal_event = false;
     constexpr int kUeventMsgLen = 2048;
     char msg[kUeventMsgLen + 2];
     char *cp;

     while (true) {
         int n = uevent_kernel_multicast_recv(uevent_fd_.get(), msg, kUeventMsgLen);
         if (n <= 0) {
             if (errno != EAGAIN && errno != EWOULDBLOCK) {
                 LOG(ERROR) << "Error reading from Uevent Fd";
             }
             break;
         }

         if (n >= kUeventMsgLen) {
             LOG(ERROR) << "Uevent overflowed buffer, discarding";
             continue;
         }

         msg[n] = '\0';
         msg[n + 1] = '\0';

         cp = msg;
         while (*cp) {
             std::string uevent = cp;
             auto findSubSystemThermal = uevent.find("SUBSYSTEM=thermal");
             if (!thermal_event) {
                 if (::android::base::StartsWith(uevent, "SUBSYSTEM=")) {
                     if (findSubSystemThermal != std::string::npos) {
                         thermal_event = true;
                     } else {
                         break;
                     }
                 }
             } else {
                 auto start_pos = uevent.find("NAME=");
                 if (start_pos != std::string::npos) {
                     start_pos += 5;
                     std::string name = uevent.substr(start_pos);
                     if (monitored_sensors_.find(name) != monitored_sensors_.end()) {
                         sensors_set->insert(name);
                     }
                     break;
                 }
             }
             while (*cp++) {
             }
         }
     }
 }

 // TODO(b/175367921): Consider for potentially adding more type of event in the function
 // instead of just add the sensors to the list.
 void ThermalWatcher::parseGenlink(std::set<std::string> *sensors_set) {
     int err = 0, done = 0, tz_id = -1;

     std::unique_ptr<nl_cb, decltype(&nl_cb_put)> cb(nl_cb_alloc(NL_CB_DEFAULT), nl_cb_put);

     nl_cb_err(cb.get(), NL_CB_CUSTOM, nlErrorHandle, &err);
     nl_cb_set(cb.get(), NL_CB_FINISH, NL_CB_CUSTOM, nlFinishHandle, &done);
     nl_cb_set(cb.get(), NL_CB_ACK, NL_CB_CUSTOM, nlAckHandle, &done);
     nl_cb_set(cb.get(), NL_CB_SEQ_CHECK, NL_CB_CUSTOM, nlSeqCheckHandle, &done);
     nl_cb_set(cb.get(), NL_CB_VALID, NL_CB_CUSTOM, handleEvent, &tz_id);

     while (!done && !err) {
         nl_recvmsgs(sk_thermal, cb.get());

         if (tz_id < 0) {
             break;
         }

         std::string name;
         if (getThermalZoneTypeById(tz_id, &name) &&
             monitored_sensors_.find(name) != monitored_sensors_.end()) {
             sensors_set->insert(name);
         }
     }
 }

 void ThermalWatcher::wake() {
     looper_->wake();
 }

 bool ThermalWatcher::threadLoop() {
     LOG(VERBOSE) << "ThermalWatcher polling...";

     int fd;
     std::set<std::string> sensors;

     auto time_elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(boot_clock::now() -
                                                                                  last_update_time_);

     if (time_elapsed_ms < sleep_ms_ &&
         looper_->pollOnce(sleep_ms_.count(), &fd, nullptr, nullptr) >= 0) {
         ATRACE_NAME("ThermalWatcher::threadLoop - receive event");
         if (fd != uevent_fd_.get() && fd != thermal_genl_fd_.get()) {
             return true;
         } else if (fd == thermal_genl_fd_.get()) {
             parseGenlink(&sensors);
         } else if (fd == uevent_fd_.get()) {
             parseUevent(&sensors);
         }
         // Ignore cb_ if uevent is not from monitored sensors
         if (sensors.size() == 0) {
             return true;
         }
     }

     sleep_ms_ = cb_(sensors);
     last_update_time_ = boot_clock::now();
     return true;
 }

 }  // namespace implementation
 }  // namespace thermal
 }  // namespace hardware
 }  // namespace android
 }  // namespace aidl
	/*
	* 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.
	*/

	#define ATRACE_TAG (ATRACE_TAG_THERMAL \| ATRACE_TAG_HAL)

	#include "thermal_watcher.h"

	#include <android-base/file.h>
	#include <android-base/logging.h>
	#include <android-base/stringprintf.h>
	#include <android-base/strings.h>
	#include <cutils/uevent.h>
	#include <dirent.h>
	#include <linux/netlink.h>
	#include <linux/thermal.h>
	#include <sys/inotify.h>
	#include <sys/resource.h>
	#include <sys/types.h>
	#include <utils/Trace.h>

	#include <chrono>
	#include <fstream>

	#include "../thermal-helper.h"

	namespace aidl {
	namespace android {
	namespace hardware {
	namespace thermal {
	namespace implementation {

	namespace {

	static int nlErrorHandle(struct sockaddr_nl nla, struct nlmsgerr err, void *arg) {
	int ret = reinterpret_cast<int >(arg);
	*ret = err->error;
	LOG(ERROR) << __func__ << "nl_groups: " << nla->nl_groups << ", nl_pid: " << nla->nl_pid;

	return NL_STOP;
	}

	static int nlFinishHandle(struct nl_msg msg, void arg) {
	int ret = reinterpret_cast<int >(arg);
	*ret = 1;
	struct nlmsghdr *nlh = nlmsg_hdr(msg);

	LOG(VERBOSE) << __func__ << ": nlmsg type: " << nlh->nlmsg_type;

	return NL_OK;
	}

	static int nlAckHandle(struct nl_msg msg, void arg) {
	int ret = reinterpret_cast<int >(arg);
	*ret = 1;
	struct nlmsghdr *nlh = nlmsg_hdr(msg);

	LOG(VERBOSE) << __func__ << ": nlmsg type: " << nlh->nlmsg_type;

	return NL_OK;
	}

	static int nlSeqCheckHandle(struct nl_msg msg, void arg) {
	int ret = reinterpret_cast<int >(arg);
	*ret = 1;
	struct nlmsghdr *nlh = nlmsg_hdr(msg);

	LOG(VERBOSE) << __func__ << ": nlmsg type: " << nlh->nlmsg_type;

	return NL_OK;
	}

	struct HandlerArgs {
	const char *group;
	int id;
	};

	static int nlSendMsg(struct nl_sock sock, struct nl_msg msg,
	int (rx_handler)(struct nl_msg , void ), void data) {
	int err, done = 0;

	std::unique_ptr<nl_cb, decltype(&nl_cb_put)> cb(nl_cb_alloc(NL_CB_DEFAULT), nl_cb_put);

	err = nl_send_auto_complete(sock, msg);
	if (err < 0)
	return err;

	err = 0;
	nl_cb_err(cb.get(), NL_CB_CUSTOM, nlErrorHandle, &err);
	nl_cb_set(cb.get(), NL_CB_FINISH, NL_CB_CUSTOM, nlFinishHandle, &done);
	nl_cb_set(cb.get(), NL_CB_ACK, NL_CB_CUSTOM, nlAckHandle, &done);

	if (rx_handler != NULL)
	nl_cb_set(cb.get(), NL_CB_VALID, NL_CB_CUSTOM, rx_handler, data);

	while (err == 0 && done == 0) nl_recvmsgs(sock, cb.get());

	return err;
	}

	static int nlFamilyHandle(struct nl_msg msg, void arg) {
	struct HandlerArgs grp = reinterpret_cast<struct HandlerArgs >(arg);
	struct nlattr *tb[CTRL_ATTR_MAX + 1];
	struct genlmsghdr gnlh = (struct genlmsghdr )nlmsg_data(nlmsg_hdr(msg));
	struct nlattr *mcgrp;
	int rem_mcgrp;

	nla_parse(tb, CTRL_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL);

	if (!tb[CTRL_ATTR_MCAST_GROUPS]) {
	LOG(ERROR) << __func__ << "Multicast group not found";
	return -1;
	}

	nla_for_each_nested(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], rem_mcgrp) {
	struct nlattr *tb_mcgrp[CTRL_ATTR_MCAST_GRP_MAX + 1];

	nla_parse(tb_mcgrp, CTRL_ATTR_MCAST_GRP_MAX, reinterpret_cast<nlattr *>(nla_data(mcgrp)),
	nla_len(mcgrp), NULL);

	if (!tb_mcgrp[CTRL_ATTR_MCAST_GRP_NAME] \|\| !tb_mcgrp[CTRL_ATTR_MCAST_GRP_ID])
	continue;

	if (strncmp(reinterpret_cast<char *>(nla_data(tb_mcgrp[CTRL_ATTR_MCAST_GRP_NAME])),
	grp->group, nla_len(tb_mcgrp[CTRL_ATTR_MCAST_GRP_NAME])) != 0)
	continue;

	grp->id = nla_get_u32(tb_mcgrp[CTRL_ATTR_MCAST_GRP_ID]);

	break;
	}

	return 0;
	}

	static int nlGetMulticastId(struct nl_sock sock, const char family, const char *group) {
	int err = 0, ctrlid;
	struct HandlerArgs grp = {
	.group = group,
	.id = -ENOENT,
	};

	std::unique_ptr<nl_msg, decltype(&nlmsg_free)> msg(nlmsg_alloc(), nlmsg_free);

	ctrlid = genl_ctrl_resolve(sock, "nlctrl");

	genlmsg_put(msg.get(), 0, 0, ctrlid, 0, 0, CTRL_CMD_GETFAMILY, 0);

	nla_put_string(msg.get(), CTRL_ATTR_FAMILY_NAME, family);

	err = nlSendMsg(sock, msg.get(), nlFamilyHandle, &grp);
	if (err)
	return err;

	err = grp.id;
	LOG(INFO) << group << " multicast_id: " << grp.id;

	return err;
	}

	static bool socketAddMembership(struct nl_sock sock, const char group) {
	int mcid = nlGetMulticastId(sock, THERMAL_GENL_FAMILY_NAME, group);
	if (mcid < 0) {
	LOG(ERROR) << "Failed to get multicast id: " << group;
	return false;
	}

	if (nl_socket_add_membership(sock, mcid)) {
	LOG(ERROR) << "Failed to add netlink socket membership: " << group;
	return false;
	}

	LOG(INFO) << "Added netlink socket membership: " << group;
	return true;
	}

	static int handleEvent(struct nl_msg n, void arg) {
	struct nlmsghdr *nlh = nlmsg_hdr(n);
	struct genlmsghdr *glh = genlmsg_hdr(nlh);
	struct nlattr *attrs[THERMAL_GENL_ATTR_MAX + 1];
	int tz_id = reinterpret_cast<int >(arg);

	genlmsg_parse(nlh, 0, attrs, THERMAL_GENL_ATTR_MAX, NULL);

	if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_UP) {
	LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_UP";
	if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
	LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	*tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	}
	if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID])
	LOG(INFO) << "Thermal zone trip id: "
	<< nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]);
	}

	if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_DOWN) {
	LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_DOWN";
	if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
	LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	*tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	}
	if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID])
	LOG(INFO) << "Thermal zone trip id: "
	<< nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]);
	}

	if (glh->cmd == THERMAL_GENL_EVENT_TZ_GOV_CHANGE) {
	LOG(INFO) << "THERMAL_GENL_EVENT_TZ_GOV_CHANGE";
	if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
	LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	*tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	}
	if (attrs[THERMAL_GENL_ATTR_GOV_NAME])
	LOG(INFO) << "Governor name: " << nla_get_string(attrs[THERMAL_GENL_ATTR_GOV_NAME]);
	}

	if (glh->cmd == THERMAL_GENL_EVENT_TZ_CREATE) {
	LOG(INFO) << "THERMAL_GENL_EVENT_TZ_CREATE";
	if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
	LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	*tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	}
	if (attrs[THERMAL_GENL_ATTR_TZ_NAME])
	LOG(INFO) << "Thermal zone name: " << nla_get_string(attrs[THERMAL_GENL_ATTR_TZ_NAME]);
	}

	if (glh->cmd == THERMAL_GENL_EVENT_TZ_DELETE) {
	LOG(INFO) << "THERMAL_GENL_EVENT_TZ_DELETE";
	if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
	LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	*tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	}
	}

	if (glh->cmd == THERMAL_GENL_EVENT_TZ_DISABLE) {
	LOG(INFO) << "THERMAL_GENL_EVENT_TZ_DISABLE";
	if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
	LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	*tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	}
	}

	if (glh->cmd == THERMAL_GENL_EVENT_TZ_ENABLE) {
	LOG(INFO) << "THERMAL_GENL_EVENT_TZ_ENABLE";
	if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
	LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	*tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	}
	}

	if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_CHANGE) {
	LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_CHANGE";
	if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
	LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	*tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	}
	if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID])
	LOG(INFO) << "Trip id:: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]);
	if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE])
	LOG(INFO) << "Trip type: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE]);
	if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP])
	LOG(INFO) << "Trip temp: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP]);
	if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST])
	LOG(INFO) << "Trip hyst: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST]);
	}

	if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_ADD) {
	LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_ADD";
	if (attrs[THERMAL_GENL_ATTR_TZ_ID])
	LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID])
	LOG(INFO) << "Trip id:: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]);
	if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE])
	LOG(INFO) << "Trip type: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE]);
	if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP])
	LOG(INFO) << "Trip temp: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP]);
	if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST])
	LOG(INFO) << "Trip hyst: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST]);
	}

	if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_DELETE) {
	LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_DELETE";
	if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
	LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	*tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	}
	if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID])
	LOG(INFO) << "Trip id:: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]);
	}

	if (glh->cmd == THERMAL_GENL_EVENT_CDEV_STATE_UPDATE) {
	LOG(INFO) << "THERMAL_GENL_EVENT_CDEV_STATE_UPDATE";
	if (attrs[THERMAL_GENL_ATTR_CDEV_ID])
	LOG(INFO) << "Cooling device id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_ID]);
	if (attrs[THERMAL_GENL_ATTR_CDEV_CUR_STATE])
	LOG(INFO) << "Cooling device current state: "
	<< nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_CUR_STATE]);
	}

	if (glh->cmd == THERMAL_GENL_EVENT_CDEV_ADD) {
	LOG(INFO) << "THERMAL_GENL_EVENT_CDEV_ADD";
	if (attrs[THERMAL_GENL_ATTR_CDEV_NAME])
	LOG(INFO) << "Cooling device name: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_NAME]);
	if (attrs[THERMAL_GENL_ATTR_CDEV_ID])
	LOG(INFO) << "Cooling device id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_ID]);
	if (attrs[THERMAL_GENL_ATTR_CDEV_MAX_STATE])
	LOG(INFO) << "Cooling device max state: "
	<< nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_MAX_STATE]);
	}

	if (glh->cmd == THERMAL_GENL_EVENT_CDEV_DELETE) {
	LOG(INFO) << "THERMAL_GENL_EVENT_CDEV_DELETE";
	if (attrs[THERMAL_GENL_ATTR_CDEV_ID])
	LOG(INFO) << "Cooling device id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_ID]);
	}

	if (glh->cmd == THERMAL_GENL_SAMPLING_TEMP) {
	LOG(INFO) << "THERMAL_GENL_SAMPLING_TEMP";
	if (attrs[THERMAL_GENL_ATTR_TZ_ID]) {
	LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	*tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
	}
	if (attrs[THERMAL_GENL_ATTR_TZ_TEMP])
	LOG(INFO) << "Thermal zone temp: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TEMP]);
	}

	return 0;
	}

	} // namespace

	void ThermalWatcher::registerFilesToWatch(const std::set<std::string> &sensors_to_watch) {
	LOG(INFO) << "Uevent register file to watch...";
	monitored_sensors_.insert(sensors_to_watch.begin(), sensors_to_watch.end());

	uevent_fd_.reset((TEMP_FAILURE_RETRY(uevent_open_socket(64 * 1024, true))));
	if (uevent_fd_.get() < 0) {
	LOG(ERROR) << "failed to open uevent socket";
	return;
	}

	fcntl(uevent_fd_, F_SETFL, O_NONBLOCK);

	looper_->addFd(uevent_fd_.get(), 0, ::android::Looper::EVENT_INPUT, nullptr, nullptr);
	sleep_ms_ = std::chrono::milliseconds(0);
	last_update_time_ = boot_clock::now();
	}

	void ThermalWatcher::registerFilesToWatchNl(const std::set<std::string> &sensors_to_watch) {
	LOG(INFO) << "Thermal genl register file to watch...";
	monitored_sensors_.insert(sensors_to_watch.begin(), sensors_to_watch.end());

	sk_thermal = nl_socket_alloc();
	if (!sk_thermal) {
	LOG(ERROR) << "nl_socket_alloc failed";
	return;
	}

	if (genl_connect(sk_thermal)) {
	LOG(ERROR) << "genl_connect failed: sk_thermal";
	return;
	}

	thermal_genl_fd_.reset(nl_socket_get_fd(sk_thermal));
	if (thermal_genl_fd_.get() < 0) {
	LOG(ERROR) << "Failed to create thermal netlink socket";
	return;
	}

	if (!socketAddMembership(sk_thermal, THERMAL_GENL_EVENT_GROUP_NAME)) {
	return;
	}

	/*
	* Currently, only the update_temperature() will send thermal genl samlping events
	* from kernel. To avoid thermal-hal busy because samlping events are sent
	* too frequently, ignore thermal genl samlping events until we figure out how to use it.
	*
	if (!socketAddMembership(sk_thermal, THERMAL_GENL_SAMPLING_GROUP_NAME)) {
	return;
	}
	*/

	fcntl(thermal_genl_fd_, F_SETFL, O_NONBLOCK);
	looper_->addFd(thermal_genl_fd_.get(), 0, ::android::Looper::EVENT_INPUT, nullptr, nullptr);
	sleep_ms_ = std::chrono::milliseconds(0);
	last_update_time_ = boot_clock::now();
	}

	bool ThermalWatcher::startWatchingDeviceFiles() {
	if (cb_) {
	auto ret = this->run("FileWatcherThread", -10);
	if (ret != ::android::NO_ERROR) {
	LOG(ERROR) << "ThermalWatcherThread start fail";
	return false;
	} else {
	LOG(INFO) << "ThermalWatcherThread started";
	return true;
	}
	}
	return false;
	}
	void ThermalWatcher::parseUevent(std::set<std::string> *sensors_set) {
	bool thermal_event = false;
	constexpr int kUeventMsgLen = 2048;
	char msg[kUeventMsgLen + 2];
	char *cp;

	while (true) {
	int n = uevent_kernel_multicast_recv(uevent_fd_.get(), msg, kUeventMsgLen);
	if (n <= 0) {
	if (errno != EAGAIN && errno != EWOULDBLOCK) {
	LOG(ERROR) << "Error reading from Uevent Fd";
	}
	break;
	}

	if (n >= kUeventMsgLen) {
	LOG(ERROR) << "Uevent overflowed buffer, discarding";
	continue;
	}

	msg[n] = '\0';
	msg[n + 1] = '\0';

	cp = msg;
	while (*cp) {
	std::string uevent = cp;
	auto findSubSystemThermal = uevent.find("SUBSYSTEM=thermal");
	if (!thermal_event) {
	if (::android::base::StartsWith(uevent, "SUBSYSTEM=")) {
	if (findSubSystemThermal != std::string::npos) {
	thermal_event = true;
	} else {
	break;
	}
	}
	} else {
	auto start_pos = uevent.find("NAME=");
	if (start_pos != std::string::npos) {
	start_pos += 5;
	std::string name = uevent.substr(start_pos);
	if (monitored_sensors_.find(name) != monitored_sensors_.end()) {
	sensors_set->insert(name);
	}
	break;
	}
	}
	while (*cp++) {
	}
	}
	}
	}

	// TODO(b/175367921): Consider for potentially adding more type of event in the function
	// instead of just add the sensors to the list.
	void ThermalWatcher::parseGenlink(std::set<std::string> *sensors_set) {
	int err = 0, done = 0, tz_id = -1;

	std::unique_ptr<nl_cb, decltype(&nl_cb_put)> cb(nl_cb_alloc(NL_CB_DEFAULT), nl_cb_put);

	nl_cb_err(cb.get(), NL_CB_CUSTOM, nlErrorHandle, &err);
	nl_cb_set(cb.get(), NL_CB_FINISH, NL_CB_CUSTOM, nlFinishHandle, &done);
	nl_cb_set(cb.get(), NL_CB_ACK, NL_CB_CUSTOM, nlAckHandle, &done);
	nl_cb_set(cb.get(), NL_CB_SEQ_CHECK, NL_CB_CUSTOM, nlSeqCheckHandle, &done);
	nl_cb_set(cb.get(), NL_CB_VALID, NL_CB_CUSTOM, handleEvent, &tz_id);

	while (!done && !err) {
	nl_recvmsgs(sk_thermal, cb.get());

	if (tz_id < 0) {
	break;
	}

	std::string name;
	if (getThermalZoneTypeById(tz_id, &name) &&
	monitored_sensors_.find(name) != monitored_sensors_.end()) {
	sensors_set->insert(name);
	}
	}
	}

	void ThermalWatcher::wake() {
	looper_->wake();
	}

	bool ThermalWatcher::threadLoop() {
	LOG(VERBOSE) << "ThermalWatcher polling...";

	int fd;
	std::set<std::string> sensors;

	auto time_elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(boot_clock::now() -
	last_update_time_);

	if (time_elapsed_ms < sleep_ms_ &&
	looper_->pollOnce(sleep_ms_.count(), &fd, nullptr, nullptr) >= 0) {
	ATRACE_NAME("ThermalWatcher::threadLoop - receive event");
	if (fd != uevent_fd_.get() && fd != thermal_genl_fd_.get()) {
	return true;
	} else if (fd == thermal_genl_fd_.get()) {
	parseGenlink(&sensors);
	} else if (fd == uevent_fd_.get()) {
	parseUevent(&sensors);
	}
	// Ignore cb_ if uevent is not from monitored sensors
	if (sensors.size() == 0) {
	return true;
	}
	}

	sleep_ms_ = cb_(sensors);
	last_update_time_ = boot_clock::now();
	return true;
	}

	} // namespace implementation
	} // namespace thermal
	} // namespace hardware
	} // namespace android
	} // namespace aidl