669 lines
23 KiB
C++
669 lines
23 KiB
C++
/*
|
|
* 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.
|
|
*/
|
|
|
|
#include <pixelstats/SysfsCollector.h>
|
|
|
|
#define LOG_TAG "pixelstats-vendor"
|
|
|
|
#include <android-base/file.h>
|
|
#include <android-base/parseint.h>
|
|
#include <android-base/properties.h>
|
|
#include <android-base/strings.h>
|
|
#include <android/frameworks/stats/1.0/IStats.h>
|
|
#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h>
|
|
#include <utils/Log.h>
|
|
#include <utils/StrongPointer.h>
|
|
#include <utils/Timers.h>
|
|
|
|
#include <sys/timerfd.h>
|
|
#include <mntent.h>
|
|
#include <string>
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace google {
|
|
namespace pixel {
|
|
|
|
using android::sp;
|
|
using android::base::ReadFileToString;
|
|
using android::base::StartsWith;
|
|
using android::frameworks::stats::V1_0::ChargeCycles;
|
|
using android::frameworks::stats::V1_0::HardwareFailed;
|
|
using android::frameworks::stats::V1_0::IStats;
|
|
using android::frameworks::stats::V1_0::SlowIo;
|
|
using android::frameworks::stats::V1_0::SpeakerImpedance;
|
|
using android::frameworks::stats::V1_0::SpeechDspStat;
|
|
using android::frameworks::stats::V1_0::VendorAtom;
|
|
using android::hardware::google::pixel::PixelAtoms::BatteryCapacity;
|
|
using android::hardware::google::pixel::PixelAtoms::StorageUfsHealth;
|
|
using android::hardware::google::pixel::PixelAtoms::F2fsStatsInfo;
|
|
using android::hardware::google::pixel::PixelAtoms::ZramMmStat;
|
|
using android::hardware::google::pixel::PixelAtoms::ZramBdStat;
|
|
using android::hardware::google::pixel::PixelAtoms::BootStatsInfo;
|
|
|
|
SysfsCollector::SysfsCollector(const struct SysfsPaths &sysfs_paths)
|
|
: kSlowioReadCntPath(sysfs_paths.SlowioReadCntPath),
|
|
kSlowioWriteCntPath(sysfs_paths.SlowioWriteCntPath),
|
|
kSlowioUnmapCntPath(sysfs_paths.SlowioUnmapCntPath),
|
|
kSlowioSyncCntPath(sysfs_paths.SlowioSyncCntPath),
|
|
kCycleCountBinsPath(sysfs_paths.CycleCountBinsPath),
|
|
kImpedancePath(sysfs_paths.ImpedancePath),
|
|
kCodecPath(sysfs_paths.CodecPath),
|
|
kCodec1Path(sysfs_paths.Codec1Path),
|
|
kSpeechDspPath(sysfs_paths.SpeechDspPath),
|
|
kBatteryCapacityCC(sysfs_paths.BatteryCapacityCC),
|
|
kBatteryCapacityVFSOC(sysfs_paths.BatteryCapacityVFSOC),
|
|
kUFSLifetimeA(sysfs_paths.UFSLifetimeA),
|
|
kUFSLifetimeB(sysfs_paths.UFSLifetimeB),
|
|
kUFSLifetimeC(sysfs_paths.UFSLifetimeC),
|
|
kF2fsStatsPath(sysfs_paths.F2fsStatsPath),
|
|
kUserdataBlockProp(sysfs_paths.UserdataBlockProp),
|
|
kZramMmStatPath("/sys/block/zram0/mm_stat"),
|
|
kZramBdStatPath("/sys/block/zram0/bd_stat"),
|
|
kEEPROMPath(sysfs_paths.EEPROMPath) {}
|
|
|
|
bool SysfsCollector::ReadFileToInt(const std::string &path, int *val) {
|
|
return ReadFileToInt(path.c_str(), val);
|
|
}
|
|
|
|
bool SysfsCollector::ReadFileToInt(const char *const path, int *val) {
|
|
std::string file_contents;
|
|
|
|
if (!ReadFileToString(path, &file_contents)) {
|
|
ALOGE("Unable to read %s - %s", path, strerror(errno));
|
|
return false;
|
|
} else if (StartsWith(file_contents, "0x")) {
|
|
if (sscanf(file_contents.c_str(), "0x%x", val) != 1) {
|
|
ALOGE("Unable to convert %s to hex - %s", path, strerror(errno));
|
|
return false;
|
|
}
|
|
} else if (sscanf(file_contents.c_str(), "%d", val) != 1) {
|
|
ALOGE("Unable to convert %s to int - %s", path, strerror(errno));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Read the contents of kCycleCountBinsPath and report them via IStats HAL.
|
|
* The contents are expected to be N buckets total, the nth of which indicates the
|
|
* number of times battery %-full has been increased with the n/N% full bucket.
|
|
*/
|
|
void SysfsCollector::logBatteryChargeCycles() {
|
|
std::string file_contents;
|
|
int val;
|
|
std::vector<int> charge_cycles;
|
|
if (kCycleCountBinsPath == nullptr || strlen(kCycleCountBinsPath) == 0) {
|
|
ALOGV("Battery charge cycle path not specified");
|
|
return;
|
|
}
|
|
if (!ReadFileToString(kCycleCountBinsPath, &file_contents)) {
|
|
ALOGE("Unable to read battery charge cycles %s - %s", kCycleCountBinsPath, strerror(errno));
|
|
return;
|
|
}
|
|
|
|
std::stringstream stream(file_contents);
|
|
while (stream >> val) {
|
|
charge_cycles.push_back(val);
|
|
}
|
|
ChargeCycles cycles;
|
|
cycles.cycleBucket = charge_cycles;
|
|
|
|
std::replace(file_contents.begin(), file_contents.end(), ' ', ',');
|
|
stats_->reportChargeCycles(cycles);
|
|
}
|
|
|
|
/**
|
|
* Read the contents of kEEPROMPath and report them.
|
|
*/
|
|
void SysfsCollector::logBatteryEEPROM() {
|
|
if (kEEPROMPath == nullptr || strlen(kEEPROMPath) == 0) {
|
|
ALOGV("Battery EEPROM path not specified");
|
|
return;
|
|
}
|
|
|
|
battery_EEPROM_reporter_.checkAndReport(kEEPROMPath);
|
|
}
|
|
|
|
/**
|
|
* Check the codec for failures over the past 24hr.
|
|
*/
|
|
void SysfsCollector::logCodecFailed() {
|
|
std::string file_contents;
|
|
if (kCodecPath == nullptr || strlen(kCodecPath) == 0) {
|
|
ALOGV("Audio codec path not specified");
|
|
return;
|
|
}
|
|
if (!ReadFileToString(kCodecPath, &file_contents)) {
|
|
ALOGE("Unable to read codec state %s - %s", kCodecPath, strerror(errno));
|
|
return;
|
|
}
|
|
if (file_contents == "0") {
|
|
return;
|
|
} else {
|
|
HardwareFailed failed = {.hardwareType = HardwareFailed::HardwareType::CODEC,
|
|
.hardwareLocation = 0,
|
|
.errorCode = HardwareFailed::HardwareErrorCode::COMPLETE};
|
|
stats_->reportHardwareFailed(failed);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check the codec1 for failures over the past 24hr.
|
|
*/
|
|
void SysfsCollector::logCodec1Failed() {
|
|
std::string file_contents;
|
|
if (kCodec1Path == nullptr || strlen(kCodec1Path) == 0) {
|
|
ALOGV("Audio codec1 path not specified");
|
|
return;
|
|
}
|
|
if (!ReadFileToString(kCodec1Path, &file_contents)) {
|
|
ALOGE("Unable to read codec1 state %s - %s", kCodec1Path, strerror(errno));
|
|
return;
|
|
}
|
|
if (file_contents == "0") {
|
|
return;
|
|
} else {
|
|
ALOGE("%s report hardware fail", kCodec1Path);
|
|
HardwareFailed failed = {.hardwareType = HardwareFailed::HardwareType::CODEC,
|
|
.hardwareLocation = 1,
|
|
.errorCode = HardwareFailed::HardwareErrorCode::COMPLETE};
|
|
stats_->reportHardwareFailed(failed);
|
|
}
|
|
}
|
|
|
|
void SysfsCollector::reportSlowIoFromFile(const char *path,
|
|
const SlowIo::IoOperation &operation_s) {
|
|
std::string file_contents;
|
|
if (path == nullptr || strlen(path) == 0) {
|
|
ALOGV("slow_io path not specified");
|
|
return;
|
|
}
|
|
if (!ReadFileToString(path, &file_contents)) {
|
|
ALOGE("Unable to read slowio %s - %s", path, strerror(errno));
|
|
return;
|
|
} else {
|
|
int32_t slow_io_count = 0;
|
|
if (sscanf(file_contents.c_str(), "%d", &slow_io_count) != 1) {
|
|
ALOGE("Unable to parse %s from file %s to int.", file_contents.c_str(), path);
|
|
} else if (slow_io_count > 0) {
|
|
SlowIo slowio = {.operation = operation_s, .count = slow_io_count};
|
|
stats_->reportSlowIo(slowio);
|
|
}
|
|
// Clear the stats
|
|
if (!android::base::WriteStringToFile("0", path, true)) {
|
|
ALOGE("Unable to clear SlowIO entry %s - %s", path, strerror(errno));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check for slow IO operations.
|
|
*/
|
|
void SysfsCollector::logSlowIO() {
|
|
reportSlowIoFromFile(kSlowioReadCntPath, SlowIo::IoOperation::READ);
|
|
reportSlowIoFromFile(kSlowioWriteCntPath, SlowIo::IoOperation::WRITE);
|
|
reportSlowIoFromFile(kSlowioUnmapCntPath, SlowIo::IoOperation::UNMAP);
|
|
reportSlowIoFromFile(kSlowioSyncCntPath, SlowIo::IoOperation::SYNC);
|
|
}
|
|
|
|
/**
|
|
* Report the last-detected impedance of left & right speakers.
|
|
*/
|
|
void SysfsCollector::logSpeakerImpedance() {
|
|
std::string file_contents;
|
|
if (kImpedancePath == nullptr || strlen(kImpedancePath) == 0) {
|
|
ALOGV("Audio impedance path not specified");
|
|
return;
|
|
}
|
|
if (!ReadFileToString(kImpedancePath, &file_contents)) {
|
|
ALOGE("Unable to read impedance path %s", kImpedancePath);
|
|
return;
|
|
}
|
|
|
|
float left, right;
|
|
if (sscanf(file_contents.c_str(), "%g,%g", &left, &right) != 2) {
|
|
ALOGE("Unable to parse speaker impedance %s", file_contents.c_str());
|
|
return;
|
|
}
|
|
SpeakerImpedance left_obj = {.speakerLocation = 0,
|
|
.milliOhms = static_cast<int32_t>(left * 1000)};
|
|
SpeakerImpedance right_obj = {.speakerLocation = 1,
|
|
.milliOhms = static_cast<int32_t>(right * 1000)};
|
|
stats_->reportSpeakerImpedance(left_obj);
|
|
stats_->reportSpeakerImpedance(right_obj);
|
|
}
|
|
|
|
/**
|
|
* Report the Speech DSP state.
|
|
*/
|
|
void SysfsCollector::logSpeechDspStat() {
|
|
std::string file_contents;
|
|
if (kSpeechDspPath == nullptr || strlen(kSpeechDspPath) == 0) {
|
|
ALOGV("Speech DSP path not specified");
|
|
return;
|
|
}
|
|
if (!ReadFileToString(kSpeechDspPath, &file_contents)) {
|
|
ALOGE("Unable to read speech dsp path %s", kSpeechDspPath);
|
|
return;
|
|
}
|
|
|
|
int32_t uptime = 0, downtime = 0, crashcount = 0, recovercount = 0;
|
|
if (sscanf(file_contents.c_str(), "%d,%d,%d,%d", &uptime, &downtime, &crashcount,
|
|
&recovercount) != 4) {
|
|
ALOGE("Unable to parse speech dsp stat %s", file_contents.c_str());
|
|
return;
|
|
}
|
|
|
|
ALOGD("SpeechDSP uptime %d downtime %d crashcount %d recovercount %d", uptime, downtime,
|
|
crashcount, recovercount);
|
|
SpeechDspStat dspstat = {.totalUptimeMillis = uptime,
|
|
.totalDowntimeMillis = downtime,
|
|
.totalCrashCount = crashcount,
|
|
.totalRecoverCount = recovercount};
|
|
|
|
stats_->reportSpeechDspStat(dspstat);
|
|
}
|
|
|
|
void SysfsCollector::logBatteryCapacity() {
|
|
std::string file_contents;
|
|
if (kBatteryCapacityCC == nullptr || strlen(kBatteryCapacityCC) == 0) {
|
|
ALOGV("Battery Capacity CC path not specified");
|
|
return;
|
|
}
|
|
if (kBatteryCapacityVFSOC == nullptr || strlen(kBatteryCapacityVFSOC) == 0) {
|
|
ALOGV("Battery Capacity VFSOC path not specified");
|
|
return;
|
|
}
|
|
int delta_cc_sum, delta_vfsoc_sum;
|
|
if (!ReadFileToInt(kBatteryCapacityCC, &delta_cc_sum) ||
|
|
!ReadFileToInt(kBatteryCapacityVFSOC, &delta_vfsoc_sum))
|
|
return;
|
|
|
|
// Load values array
|
|
std::vector<VendorAtom::Value> values(2);
|
|
VendorAtom::Value tmp;
|
|
tmp.intValue(delta_cc_sum);
|
|
values[BatteryCapacity::kDeltaCcSumFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(delta_vfsoc_sum);
|
|
values[BatteryCapacity::kDeltaVfsocSumFieldNumber - kVendorAtomOffset] = tmp;
|
|
|
|
// Send vendor atom to IStats HAL
|
|
VendorAtom event = {.reverseDomainName = PixelAtoms::ReverseDomainNames().pixel(),
|
|
.atomId = PixelAtoms::Ids::BATTERY_CAPACITY,
|
|
.values = values};
|
|
Return<void> ret = stats_->reportVendorAtom(event);
|
|
if (!ret.isOk())
|
|
ALOGE("Unable to report ChargeStats to Stats service");
|
|
}
|
|
|
|
void SysfsCollector::logUFSLifetime() {
|
|
std::string file_contents;
|
|
if (kUFSLifetimeA == nullptr || strlen(kUFSLifetimeA) == 0) {
|
|
ALOGV("UFS lifetimeA path not specified");
|
|
return;
|
|
}
|
|
if (kUFSLifetimeB == nullptr || strlen(kUFSLifetimeB) == 0) {
|
|
ALOGV("UFS lifetimeB path not specified");
|
|
return;
|
|
}
|
|
if (kUFSLifetimeC == nullptr || strlen(kUFSLifetimeC) == 0) {
|
|
ALOGV("UFS lifetimeC path not specified");
|
|
return;
|
|
}
|
|
|
|
int lifetimeA = 0, lifetimeB = 0, lifetimeC = 0;
|
|
if (!ReadFileToInt(kUFSLifetimeA, &lifetimeA) ||
|
|
!ReadFileToInt(kUFSLifetimeB, &lifetimeB) ||
|
|
!ReadFileToInt(kUFSLifetimeC, &lifetimeC)) {
|
|
ALOGE("Unable to read UFS lifetime : %s", strerror(errno));
|
|
return;
|
|
}
|
|
|
|
// Load values array
|
|
std::vector<VendorAtom::Value> values(3);
|
|
VendorAtom::Value tmp;
|
|
tmp.intValue(lifetimeA);
|
|
values[StorageUfsHealth::kLifetimeAFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(lifetimeB);
|
|
values[StorageUfsHealth::kLifetimeBFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(lifetimeC);
|
|
values[StorageUfsHealth::kLifetimeCFieldNumber - kVendorAtomOffset] = tmp;
|
|
|
|
|
|
// Send vendor atom to IStats HAL
|
|
VendorAtom event = {.reverseDomainName = PixelAtoms::ReverseDomainNames().pixel(),
|
|
.atomId = PixelAtoms::Ids::STORAGE_UFS_HEALTH,
|
|
.values = values};
|
|
Return<void> ret = stats_->reportVendorAtom(event);
|
|
if (!ret.isOk()) {
|
|
ALOGE("Unable to report UfsHealthStat to Stats service");
|
|
}
|
|
}
|
|
|
|
static std::string getUserDataBlock() {
|
|
std::unique_ptr<std::FILE, int (*)(std::FILE*)> fp(setmntent("/proc/mounts", "re"), endmntent);
|
|
if (fp == nullptr) {
|
|
ALOGE("Error opening /proc/mounts");
|
|
return "";
|
|
}
|
|
|
|
mntent* mentry;
|
|
while ((mentry = getmntent(fp.get())) != nullptr) {
|
|
if (strcmp(mentry->mnt_dir, "/data") == 0) {
|
|
return std::string(basename(mentry->mnt_fsname));
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
void SysfsCollector::logF2fsStats() {
|
|
int dirty, free, cp_calls_fg, gc_calls_fg, moved_block_fg, vblocks;
|
|
int cp_calls_bg, gc_calls_bg, moved_block_bg;
|
|
|
|
if (kF2fsStatsPath == nullptr) {
|
|
ALOGE("F2fs stats path not specified");
|
|
return;
|
|
}
|
|
|
|
std::string userdataBlock = getUserDataBlock();
|
|
|
|
if (!ReadFileToInt(kF2fsStatsPath + (userdataBlock + "/dirty_segments"), &dirty)) {
|
|
ALOGV("Unable to read dirty segments");
|
|
}
|
|
|
|
if (!ReadFileToInt(kF2fsStatsPath + (userdataBlock + "/free_segments"), &free)) {
|
|
ALOGV("Unable to read free segments");
|
|
}
|
|
|
|
if (!ReadFileToInt(kF2fsStatsPath + (userdataBlock + "/cp_foreground_calls"), &cp_calls_fg)) {
|
|
ALOGV("Unable to read cp_foreground_calls");
|
|
}
|
|
|
|
if (!ReadFileToInt(kF2fsStatsPath + (userdataBlock + "/cp_background_calls"), &cp_calls_bg)) {
|
|
ALOGV("Unable to read cp_background_calls");
|
|
}
|
|
|
|
if (!ReadFileToInt(kF2fsStatsPath + (userdataBlock + "/gc_foreground_calls"), &gc_calls_fg)) {
|
|
ALOGV("Unable to read gc_foreground_calls");
|
|
}
|
|
|
|
if (!ReadFileToInt(kF2fsStatsPath + (userdataBlock + "/gc_background_calls"), &gc_calls_bg)) {
|
|
ALOGV("Unable to read gc_background_calls");
|
|
}
|
|
|
|
if (!ReadFileToInt(kF2fsStatsPath + (userdataBlock + "/moved_blocks_foreground"), &moved_block_fg)) {
|
|
ALOGV("Unable to read moved_blocks_foreground");
|
|
}
|
|
|
|
if (!ReadFileToInt(kF2fsStatsPath + (userdataBlock + "/moved_blocks_background"), &moved_block_bg)) {
|
|
ALOGV("Unable to read moved_blocks_background");
|
|
}
|
|
|
|
if (!ReadFileToInt(kF2fsStatsPath + (userdataBlock + "/avg_vblocks"), &vblocks)) {
|
|
ALOGV("Unable to read avg_vblocks");
|
|
}
|
|
|
|
// Load values array
|
|
std::vector<VendorAtom::Value> values(9);
|
|
VendorAtom::Value tmp;
|
|
tmp.intValue(dirty);
|
|
values[F2fsStatsInfo::kDirtySegmentsFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(free);
|
|
values[F2fsStatsInfo::kFreeSegmentsFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(cp_calls_fg);
|
|
values[F2fsStatsInfo::kCpCallsFgFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(cp_calls_bg);
|
|
values[F2fsStatsInfo::kCpCallsBgFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(gc_calls_fg);
|
|
values[F2fsStatsInfo::kGcCallsFgFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(gc_calls_bg);
|
|
values[F2fsStatsInfo::kGcCallsBgFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(moved_block_fg);
|
|
values[F2fsStatsInfo::kMovedBlocksFgFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(moved_block_bg);
|
|
values[F2fsStatsInfo::kMovedBlocksBgFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(vblocks);
|
|
values[F2fsStatsInfo::kValidBlocksFieldNumber - kVendorAtomOffset] = tmp;
|
|
|
|
// Send vendor atom to IStats HAL
|
|
VendorAtom event = {.reverseDomainName = PixelAtoms::ReverseDomainNames().pixel(),
|
|
.atomId = PixelAtoms::Ids::F2FS_STATS,
|
|
.values = values};
|
|
Return<void> ret = stats_->reportVendorAtom(event);
|
|
if (!ret.isOk()) {
|
|
ALOGE("Unable to report F2fs stats to Stats service");
|
|
}
|
|
}
|
|
|
|
void SysfsCollector::reportZramMmStat() {
|
|
std::string file_contents;
|
|
if (!kZramMmStatPath) {
|
|
ALOGV("ZramMmStat path not specified");
|
|
return;
|
|
}
|
|
|
|
if (!ReadFileToString(kZramMmStatPath, &file_contents)) {
|
|
ALOGE("Unable to ZramMmStat %s - %s", kZramMmStatPath, strerror(errno));
|
|
return;
|
|
} else {
|
|
int64_t orig_data_size = 0;
|
|
int64_t compr_data_size = 0;
|
|
int64_t mem_used_total = 0;
|
|
int64_t mem_limit = 0;
|
|
int64_t max_used_total = 0;
|
|
int64_t same_pages = 0;
|
|
int64_t pages_compacted = 0;
|
|
int64_t huge_pages = 0;
|
|
|
|
if (sscanf(file_contents.c_str(), "%lu %lu %lu %lu %lu %lu %lu %lu",
|
|
&orig_data_size, &compr_data_size, &mem_used_total, &mem_limit,
|
|
&max_used_total, &same_pages, &pages_compacted, &huge_pages) != 8) {
|
|
ALOGE("Unable to parse ZramMmStat %s from file %s to int.",
|
|
file_contents.c_str(), kZramMmStatPath);
|
|
}
|
|
|
|
// Load values array
|
|
std::vector<VendorAtom::Value> values(5);
|
|
VendorAtom::Value tmp;
|
|
tmp.intValue(orig_data_size);
|
|
values[ZramMmStat::kOrigDataSizeFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(compr_data_size);
|
|
values[ZramMmStat::kComprDataSizeFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(mem_used_total);
|
|
values[ZramMmStat::kMemUsedTotalFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(same_pages);
|
|
values[ZramMmStat::kSamePagesFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(huge_pages);
|
|
values[ZramMmStat::kHugePagesFieldNumber - kVendorAtomOffset] = tmp;
|
|
|
|
// Send vendor atom to IStats HAL
|
|
VendorAtom event = {.reverseDomainName = PixelAtoms::ReverseDomainNames().pixel(),
|
|
.atomId = PixelAtoms::Ids::ZRAM_MM_STAT,
|
|
.values = values};
|
|
Return<void> ret = stats_->reportVendorAtom(event);
|
|
if (!ret.isOk())
|
|
ALOGE("Zram Unable to report ZramMmStat to Stats service");
|
|
}
|
|
}
|
|
|
|
void SysfsCollector::reportZramBdStat() {
|
|
std::string file_contents;
|
|
if (!kZramBdStatPath) {
|
|
ALOGV("ZramBdStat path not specified");
|
|
return;
|
|
}
|
|
|
|
if (!ReadFileToString(kZramBdStatPath, &file_contents)) {
|
|
ALOGE("Unable to ZramBdStat %s - %s", kZramBdStatPath, strerror(errno));
|
|
return;
|
|
} else {
|
|
int64_t bd_count = 0;
|
|
int64_t bd_reads = 0;
|
|
int64_t bd_writes = 0;
|
|
|
|
if (sscanf(file_contents.c_str(), "%lu %lu %lu",
|
|
&bd_count, &bd_reads, &bd_writes) != 3) {
|
|
ALOGE("Unable to parse ZramBdStat %s from file %s to int.",
|
|
file_contents.c_str(), kZramBdStatPath);
|
|
}
|
|
|
|
// Load values array
|
|
std::vector<VendorAtom::Value> values(3);
|
|
VendorAtom::Value tmp;
|
|
tmp.intValue(bd_count);
|
|
values[ZramBdStat::kBdCountFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(bd_reads);
|
|
values[ZramBdStat::kBdReadsFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(bd_writes);
|
|
values[ZramBdStat::kBdWritesFieldNumber - kVendorAtomOffset] = tmp;
|
|
|
|
// Send vendor atom to IStats HAL
|
|
VendorAtom event = {.reverseDomainName = PixelAtoms::ReverseDomainNames().pixel(),
|
|
.atomId = PixelAtoms::Ids::ZRAM_BD_STAT,
|
|
.values = values};
|
|
Return<void> ret = stats_->reportVendorAtom(event);
|
|
if (!ret.isOk())
|
|
ALOGE("Zram Unable to report ZramBdStat to Stats service");
|
|
}
|
|
}
|
|
|
|
void SysfsCollector::logZramStats() {
|
|
reportZramMmStat();
|
|
reportZramBdStat();
|
|
}
|
|
|
|
void SysfsCollector::logBootStats() {
|
|
int mounted_time_sec = 0;
|
|
|
|
if (kF2fsStatsPath == nullptr) {
|
|
ALOGE("F2fs stats path not specified");
|
|
return;
|
|
}
|
|
|
|
std::string userdataBlock = getUserDataBlock();
|
|
|
|
if (!ReadFileToInt(kF2fsStatsPath + (userdataBlock + "/mounted_time_sec"), &mounted_time_sec)) {
|
|
ALOGV("Unable to read mounted_time_sec");
|
|
return;
|
|
}
|
|
|
|
int fsck_time_ms = android::base::GetIntProperty("ro.boottime.init.fsck.data", 0);
|
|
int checkpoint_time_ms = android::base::GetIntProperty("ro.boottime.init.mount.data", 0);
|
|
|
|
if (fsck_time_ms == 0 && checkpoint_time_ms == 0) {
|
|
ALOGV("Not yet initialized");
|
|
return;
|
|
}
|
|
|
|
// Load values array
|
|
std::vector<VendorAtom::Value> values(3);
|
|
VendorAtom::Value tmp;
|
|
tmp.intValue(mounted_time_sec);
|
|
values[BootStatsInfo::kMountedTimeSecFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(fsck_time_ms / 1000);
|
|
values[BootStatsInfo::kFsckTimeSecFieldNumber - kVendorAtomOffset] = tmp;
|
|
tmp.intValue(checkpoint_time_ms / 1000);
|
|
values[BootStatsInfo::kCheckpointTimeSecFieldNumber - kVendorAtomOffset] = tmp;
|
|
|
|
// Send vendor atom to IStats HAL
|
|
VendorAtom event = {.reverseDomainName = PixelAtoms::ReverseDomainNames().pixel(),
|
|
.atomId = PixelAtoms::Ids::BOOT_STATS,
|
|
.values = values};
|
|
Return<void> ret = stats_->reportVendorAtom(event);
|
|
if (!ret.isOk()) {
|
|
ALOGE("Unable to report Boot stats to Stats service");
|
|
} else {
|
|
log_once_reported = true;
|
|
}
|
|
}
|
|
|
|
void SysfsCollector::logAll() {
|
|
stats_ = IStats::tryGetService();
|
|
if (!stats_) {
|
|
ALOGE("Unable to connect to Stats service");
|
|
return;
|
|
}
|
|
|
|
// Collect once per service init; can be multiple due to service reinit
|
|
if (!log_once_reported) {
|
|
logBootStats();
|
|
}
|
|
logBatteryChargeCycles();
|
|
logCodecFailed();
|
|
logCodec1Failed();
|
|
logSlowIO();
|
|
logSpeakerImpedance();
|
|
logSpeechDspStat();
|
|
logBatteryCapacity();
|
|
logUFSLifetime();
|
|
logF2fsStats();
|
|
logZramStats();
|
|
logBatteryEEPROM();
|
|
|
|
stats_.clear();
|
|
}
|
|
|
|
/**
|
|
* Loop forever collecting stats from sysfs nodes and reporting them via
|
|
* IStats.
|
|
*/
|
|
void SysfsCollector::collect(void) {
|
|
int timerfd = timerfd_create(CLOCK_BOOTTIME, 0);
|
|
if (timerfd < 0) {
|
|
ALOGE("Unable to create timerfd - %s", strerror(errno));
|
|
return;
|
|
}
|
|
|
|
// Sleep for 30 seconds on launch to allow codec driver to load.
|
|
sleep(30);
|
|
|
|
// Collect first set of stats on boot.
|
|
logAll();
|
|
|
|
// Collect stats every 24hrs after.
|
|
struct itimerspec period;
|
|
const int kSecondsPerDay = 60 * 60 * 24;
|
|
period.it_interval.tv_sec = kSecondsPerDay;
|
|
period.it_interval.tv_nsec = 0;
|
|
period.it_value.tv_sec = kSecondsPerDay;
|
|
period.it_value.tv_nsec = 0;
|
|
|
|
if (timerfd_settime(timerfd, 0, &period, NULL)) {
|
|
ALOGE("Unable to set 24hr timer - %s", strerror(errno));
|
|
return;
|
|
}
|
|
|
|
while (1) {
|
|
int readval;
|
|
do {
|
|
char buf[8];
|
|
errno = 0;
|
|
readval = read(timerfd, buf, sizeof(buf));
|
|
} while (readval < 0 && errno == EINTR);
|
|
if (readval < 0) {
|
|
ALOGE("Timerfd error - %s\n", strerror(errno));
|
|
return;
|
|
}
|
|
logAll();
|
|
}
|
|
}
|
|
|
|
} // namespace pixel
|
|
} // namespace google
|
|
} // namespace hardware
|
|
} // namespace android
|