RailDataProvider.cpp

/*
 * Copyright (C) 2018 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 LOG_TAG "libpixelpowerstats"

#include <algorithm>
#include <thread>
#include <exception>
#include <inttypes.h>
#include <stdlib.h>
#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/properties.h>
#include <android-base/strings.h>
#include <android-base/stringprintf.h>
#include "RailDataProvider.h"

namespace android {
namespace hardware {
namespace google {
namespace pixel {
namespace powerstats {

#define MAX_FILE_PATH_LEN 128
#define MAX_DEVICE_NAME_LEN 64
#define MAX_QUEUE_SIZE 8192

constexpr char kIioDirRoot[] = "/sys/bus/iio/devices/";
constexpr char kDeviceName[] = "microchip,pac1934";
constexpr char kDeviceType[] = "iio:device";
constexpr uint32_t MAX_SAMPLING_RATE = 10;
constexpr uint64_t WRITE_TIMEOUT_NS = 1000000000;

void RailDataProvider::findIioPowerMonitorNodes() {
  struct dirent *ent;
  int fd;
  char devName[MAX_DEVICE_NAME_LEN];
  char filePath[MAX_FILE_PATH_LEN];
  DIR *iioDir = opendir(kIioDirRoot);
  if (!iioDir) {
    ALOGE("Error opening directory: %s, error: %d", kIioDirRoot, errno);
    return;
  }
  while (ent = readdir(iioDir), ent) {
    if (strcmp(ent->d_name, ".") != 0 &&
        strcmp(ent->d_name, "..") != 0 &&
        strlen(ent->d_name) > strlen(kDeviceType) &&
        strncmp(ent->d_name, kDeviceType, strlen(kDeviceType)) == 0) {

      snprintf(filePath, MAX_FILE_PATH_LEN, "%s/%s", ent->d_name, "name");
      fd = openat(dirfd(iioDir), filePath, O_RDONLY);
      if (fd < 0) {
        ALOGW("Failed to open directory: %s, error: %d", filePath, errno);
        continue;
      }
      if (read(fd, devName, MAX_DEVICE_NAME_LEN) < 0) {
        ALOGW("Failed to read device name from file: %s(%d)",
              filePath, fd);
        close(fd);
        continue;
      }

      if (strncmp(devName, kDeviceName, strlen(kDeviceName)) == 0) {
        snprintf(filePath, MAX_FILE_PATH_LEN, "%s/%s", kIioDirRoot, ent->d_name);
        mOdpm.devicePaths.push_back(filePath);
      }
      close(fd);
    }
  }
  closedir(iioDir);
  return;
}

size_t RailDataProvider::parsePowerRails() {
  std::string data;
  std::string railFileName;
  std::string spsFileName;
  uint32_t index = 0;
  unsigned long samplingRate;
  for (const auto &path : mOdpm.devicePaths) {
    railFileName = path + "/enabled_rails";
    spsFileName = path + "/sampling_rate";
    if (!android::base::ReadFileToString(spsFileName, &data)) {
      ALOGW("Error reading file: %s", spsFileName.c_str());
      continue;
    }
    samplingRate = strtoul(data.c_str(), NULL, 10);
    if (!samplingRate || samplingRate == ULONG_MAX) {
      ALOGE("Error parsing: %s", spsFileName.c_str());
      break;
    }
    if (!android::base::ReadFileToString(railFileName, &data)) {
      ALOGW("Error reading file: %s", railFileName.c_str());
      continue;
    }
    std::istringstream railNames(data);
    std::string line;
    while (std::getline(railNames, line)) {
      std::vector<std::string> words = android::base::Split(line, ":");
      if (words.size() == 2) {
        mOdpm.railsInfo.emplace(words[0],
                           RailData {
                             .devicePath = path,
                             .index = index,
                             .subsysName = words[1],
                             .samplingRate = static_cast<uint32_t>(samplingRate)
                           });
        index++;
      } else {
        ALOGW("Unexpected format in file: %s", railFileName.c_str());
      }
    }
  }
  return index;
}

int RailDataProvider::parseIioEnergyNode(std::string devName) {
   int ret = 0;
   std::string data;
   std::string fileName = devName + "/energy_value";
   if (!android::base::ReadFileToString(fileName, &data)) {
     ALOGE("Error reading file: %s", fileName.c_str());
     return -1;
   }

   std::istringstream energyData(data);
   std::string line;
   uint64_t timestamp = 0;
   bool timestampRead = false;
   while (std::getline(energyData, line)) {
     std::vector<std::string> words = android::base::Split(line, ",");
     if (timestampRead == false) {
       if (words.size() == 1) {
         timestamp = strtoull(words[0].c_str(), NULL, 10);
         if (timestamp == 0 || timestamp == ULLONG_MAX) {
           ALOGW("Potentially wrong timestamp: %" PRIu64, timestamp);
         }
         timestampRead = true;
       }
     } else if (words.size() == 2) {
         std::string railName = words[0];
         if (mOdpm.railsInfo.count(railName) != 0) {
           size_t index = mOdpm.railsInfo[railName].index;
           mOdpm.reading[index].index = index;
           mOdpm.reading[index].timestamp = timestamp;
           mOdpm.reading[index].energy = strtoull(words[1].c_str(), NULL, 10);
           if (mOdpm.reading[index].energy == ULLONG_MAX) {
             ALOGW("Potentially wrong energy value: %" PRIu64,
                   mOdpm.reading[index].energy);
           }
         }
     } else {
       ALOGW("Unexpected format in file: %s", fileName.c_str());
       ret = -1;
       break;
     }
   }
   return ret;
}

Status RailDataProvider::parseIioEnergyNodes() {
  Status ret = Status::SUCCESS;
  if (mOdpm.hwEnabled == false) {
    return Status::NOT_SUPPORTED;
  }

  for (const auto &devicePath : mOdpm.devicePaths) {
    if(parseIioEnergyNode(devicePath) < 0) {
      ALOGE("Error in parsing power stats");
      ret = Status::FILESYSTEM_ERROR;
      break;
    }
  }
  return ret;
}

RailDataProvider::RailDataProvider() {
    findIioPowerMonitorNodes();
    size_t numRails = parsePowerRails();
    if (mOdpm.devicePaths.empty() || numRails == 0) {
      mOdpm.hwEnabled = false;
    } else {
      mOdpm.hwEnabled = true;
      mOdpm.reading.resize(numRails);
    }
}

Return<void> RailDataProvider::getRailInfo(IPowerStats::getRailInfo_cb _hidl_cb) {
  hidl_vec<RailInfo> rInfo;
  Status ret = Status::SUCCESS;
  size_t index;
  std::lock_guard<std::mutex> _lock(mOdpm.mLock);
  if (mOdpm.hwEnabled == false) {
    ALOGI("getRailInfo not supported");
    _hidl_cb(rInfo, Status::NOT_SUPPORTED);
    return Void();
  }
  rInfo.resize(mOdpm.railsInfo.size());
  for (const auto& railData : mOdpm.railsInfo) {
    index = railData.second.index;
    rInfo[index].railName = railData.first;
    rInfo[index].subsysName = railData.second.subsysName;
    rInfo[index].index = index;
    rInfo[index].samplingRate = railData.second.samplingRate;
  }
  _hidl_cb(rInfo, ret);
  return Void();
}

Return<void> RailDataProvider::getEnergyData(const hidl_vec<uint32_t>& railIndices, IPowerStats::getEnergyData_cb _hidl_cb) {
  hidl_vec<EnergyData> eVal;
  std::lock_guard<std::mutex> _lock(mOdpm.mLock);
  Status ret = parseIioEnergyNodes();

  if (ret != Status::SUCCESS) {
    _hidl_cb(eVal, ret);
    return Void();
  }

  if (railIndices.size() == 0) {
    eVal.resize(mOdpm.railsInfo.size());
    memcpy(&eVal[0], &mOdpm.reading[0], mOdpm.reading.size() * sizeof(EnergyData));
  } else {
    eVal.resize(railIndices.size());
    int i = 0;
    for (const auto &railIndex : railIndices) {
      if (railIndex >= mOdpm.reading.size()) {
        ret = Status::INVALID_INPUT;
        eVal.resize(0);
        break;
      }
      memcpy(&eVal[i], &mOdpm.reading[railIndex], sizeof(EnergyData));
      i++;
    }
  }
  _hidl_cb(eVal, ret);
  return Void();
}

Return<void> RailDataProvider::streamEnergyData(uint32_t timeMs, uint32_t samplingRate,
                                IPowerStats::streamEnergyData_cb _hidl_cb) {
  std::lock_guard<std::mutex> _lock(mOdpm.mLock);
  if (mOdpm.fmqSynchronized != nullptr) {
    _hidl_cb(MessageQueueSync::Descriptor(),
             0, 0, Status::INSUFFICIENT_RESOURCES);
    return Void();
  }
  uint32_t sps = std::min(samplingRate, MAX_SAMPLING_RATE);
  uint32_t numSamples = timeMs * sps / 1000;
  mOdpm.fmqSynchronized.reset(new (std::nothrow) MessageQueueSync(MAX_QUEUE_SIZE, true));
  if (mOdpm.fmqSynchronized == nullptr || mOdpm.fmqSynchronized->isValid() == false) {
    mOdpm.fmqSynchronized = nullptr;
    _hidl_cb(MessageQueueSync::Descriptor(),
             0, 0, Status::INSUFFICIENT_RESOURCES);
    return Void();
  }
  std::thread pollThread = std::thread([this, sps, numSamples]() {
    uint64_t sleepTimeUs = 1000000/sps;
    uint32_t currSamples = 0;
    while (currSamples < numSamples) {
      mOdpm.mLock.lock();
      if (parseIioEnergyNodes() == Status::SUCCESS) {
        mOdpm.fmqSynchronized->writeBlocking(&mOdpm.reading[0],
                                             mOdpm.reading.size(), WRITE_TIMEOUT_NS);
        mOdpm.mLock.unlock();
        currSamples++;
        if (usleep(sleepTimeUs) < 0) {
          ALOGW("Sleep interrupted");
          break;
        }
      } else {
        mOdpm.mLock.unlock();
        break;
      }
    }
    mOdpm.mLock.lock();
    mOdpm.fmqSynchronized = nullptr;
    mOdpm.mLock.unlock();
    return;
  });
  pollThread.detach();
  _hidl_cb(*(mOdpm.fmqSynchronized)->getDesc(), numSamples,
           mOdpm.reading.size(), Status::SUCCESS);
  return Void();
}

}  // namespace powerstats
}  // namespace pixel
}  // namespace google
}  // namespace hardware
}  // namespace android