/*
* Copyright (C) 2017 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 DEBUG false // STOPSHIP if true
#include "Log.h"
#include "StatsService.h"
#include "stats_log_util.h"
#include "android-base/stringprintf.h"
#include "config/ConfigKey.h"
#include "config/ConfigManager.h"
#include "guardrail/StatsdStats.h"
#include "storage/StorageManager.h"
#include "subscriber/SubscriberReporter.h"
#include <android-base/file.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <binder/PermissionController.h>
#include <cutils/multiuser.h>
#include <dirent.h>
#include <frameworks/base/cmds/statsd/src/statsd_config.pb.h>
#include <frameworks/base/cmds/statsd/src/uid_data.pb.h>
#include <private/android_filesystem_config.h>
#include <statslog.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/system_properties.h>
#include <unistd.h>
#include <utils/Looper.h>
#include <utils/String16.h>
#include <chrono>
using namespace android;
using android::base::StringPrintf;
using android::util::FIELD_COUNT_REPEATED;
using android::util::FIELD_TYPE_INT64;
using android::util::FIELD_TYPE_MESSAGE;
using android::util::ProtoReader;
namespace android {
namespace os {
namespace statsd {
constexpr const char* kPermissionDump = "android.permission.DUMP";
constexpr const char* kPermissionUsage = "android.permission.PACKAGE_USAGE_STATS";
constexpr const char* kOpUsage = "android:get_usage_stats";
#define STATS_SERVICE_DIR "/data/misc/stats-service"
// for StatsDataDumpProto
const int FIELD_ID_REPORTS_LIST = 1;
static binder::Status ok() {
return binder::Status::ok();
}
static binder::Status exception(uint32_t code, const std::string& msg) {
ALOGE("%s (%d)", msg.c_str(), code);
return binder::Status::fromExceptionCode(code, String8(msg.c_str()));
}
binder::Status checkUid(uid_t expectedUid) {
uid_t uid = IPCThreadState::self()->getCallingUid();
if (uid == expectedUid || uid == AID_ROOT) {
return ok();
} else {
return exception(binder::Status::EX_SECURITY,
StringPrintf("UID %d is not expected UID %d", uid, expectedUid));
}
}
binder::Status checkDumpAndUsageStats(const String16& packageName) {
pid_t pid = IPCThreadState::self()->getCallingPid();
uid_t uid = IPCThreadState::self()->getCallingUid();
// Root, system, and shell always have access
if (uid == AID_ROOT || uid == AID_SYSTEM || uid == AID_SHELL) {
return ok();
}
// Caller must be granted these permissions
if (!checkCallingPermission(String16(kPermissionDump))) {
return exception(binder::Status::EX_SECURITY,
StringPrintf("UID %d / PID %d lacks permission %s", uid, pid, kPermissionDump));
}
if (!checkCallingPermission(String16(kPermissionUsage))) {
return exception(binder::Status::EX_SECURITY,
StringPrintf("UID %d / PID %d lacks permission %s", uid, pid, kPermissionUsage));
}
// Caller must also have usage stats op granted
PermissionController pc;
switch (pc.noteOp(String16(kOpUsage), uid, packageName)) {
case PermissionController::MODE_ALLOWED:
case PermissionController::MODE_DEFAULT:
return ok();
default:
return exception(binder::Status::EX_SECURITY,
StringPrintf("UID %d / PID %d lacks app-op %s", uid, pid, kOpUsage));
}
}
#define ENFORCE_UID(uid) { \
binder::Status status = checkUid((uid)); \
if (!status.isOk()) { \
return status; \
} \
}
#define ENFORCE_DUMP_AND_USAGE_STATS(packageName) { \
binder::Status status = checkDumpAndUsageStats(packageName); \
if (!status.isOk()) { \
return status; \
} \
}
StatsService::StatsService(const sp<Looper>& handlerLooper, shared_ptr<LogEventQueue> queue)
: mAnomalyAlarmMonitor(new AlarmMonitor(
MIN_DIFF_TO_UPDATE_REGISTERED_ALARM_SECS,
[](const sp<IStatsCompanionService>& sc, int64_t timeMillis) {
if (sc != nullptr) {
sc->setAnomalyAlarm(timeMillis);
StatsdStats::getInstance().noteRegisteredAnomalyAlarmChanged();
}
},
[](const sp<IStatsCompanionService>& sc) {
if (sc != nullptr) {
sc->cancelAnomalyAlarm();
StatsdStats::getInstance().noteRegisteredAnomalyAlarmChanged();
}
})),
mPeriodicAlarmMonitor(new AlarmMonitor(
MIN_DIFF_TO_UPDATE_REGISTERED_ALARM_SECS,
[](const sp<IStatsCompanionService>& sc, int64_t timeMillis) {
if (sc != nullptr) {
sc->setAlarmForSubscriberTriggering(timeMillis);
StatsdStats::getInstance().noteRegisteredPeriodicAlarmChanged();
}
},
[](const sp<IStatsCompanionService>& sc) {
if (sc != nullptr) {
sc->cancelAlarmForSubscriberTriggering();
StatsdStats::getInstance().noteRegisteredPeriodicAlarmChanged();
}
})),
mEventQueue(queue) {
mUidMap = UidMap::getInstance();
mPullerManager = new StatsPullerManager();
StatsPuller::SetUidMap(mUidMap);
mConfigManager = new ConfigManager();
mProcessor = new StatsLogProcessor(
mUidMap, mPullerManager, mAnomalyAlarmMonitor, mPeriodicAlarmMonitor,
getElapsedRealtimeNs(),
[this](const ConfigKey& key) {
sp<IStatsCompanionService> sc = getStatsCompanionService();
auto receiver = mConfigManager->GetConfigReceiver(key);
if (sc == nullptr) {
VLOG("Could not find StatsCompanionService");
return false;
} else if (receiver == nullptr) {
VLOG("Statscompanion could not find a broadcast receiver for %s",
key.ToString().c_str());
return false;
} else {
sc->sendDataBroadcast(receiver, mProcessor->getLastReportTimeNs(key));
return true;
}
},
[this](const int& uid, const vector<int64_t>& activeConfigs) {
auto receiver = mConfigManager->GetActiveConfigsChangedReceiver(uid);
sp<IStatsCompanionService> sc = getStatsCompanionService();
if (sc == nullptr) {
VLOG("Could not access statsCompanion");
return false;
} else if (receiver == nullptr) {
VLOG("Could not find receiver for uid %d", uid);
return false;
} else {
sc->sendActiveConfigsChangedBroadcast(receiver, activeConfigs);
VLOG("StatsService::active configs broadcast succeeded for uid %d" , uid);
return true;
}
});
mConfigManager->AddListener(mProcessor);
init_system_properties();
if (mEventQueue != nullptr) {
std::thread pushedEventThread([this] { readLogs(); });
pushedEventThread.detach();
}
}
StatsService::~StatsService() {
}
/* Runs on a dedicated thread to process pushed events. */
void StatsService::readLogs() {
// Read forever..... long live statsd
while (1) {
// Block until an event is available.
auto event = mEventQueue->waitPop();
// Pass it to StatsLogProcess to all configs/metrics
// At this point, the LogEventQueue is not blocked, so that the socketListener
// can read events from the socket and write to buffer to avoid data drop.
mProcessor->OnLogEvent(event.get());
// The ShellSubscriber is only used by shell for local debugging.
if (mShellSubscriber != nullptr) {
mShellSubscriber->onLogEvent(*event);
}
}
}
void StatsService::init_system_properties() {
mEngBuild = false;
const prop_info* buildType = __system_property_find("ro.build.type");
if (buildType != NULL) {
__system_property_read_callback(buildType, init_build_type_callback, this);
}
}
void StatsService::init_build_type_callback(void* cookie, const char* /*name*/, const char* value,
uint32_t serial) {
if (0 == strcmp("eng", value) || 0 == strcmp("userdebug", value)) {
reinterpret_cast<StatsService*>(cookie)->mEngBuild = true;
}
}
/**
* Implement our own because the default binder implementation isn't
* properly handling SHELL_COMMAND_TRANSACTION.
*/
status_t StatsService::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
uint32_t flags) {
switch (code) {
case SHELL_COMMAND_TRANSACTION: {
int in = data.readFileDescriptor();
int out = data.readFileDescriptor();
int err = data.readFileDescriptor();
int argc = data.readInt32();
Vector<String8> args;
for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
args.add(String8(data.readString16()));
}
sp<IShellCallback> shellCallback = IShellCallback::asInterface(data.readStrongBinder());
sp<IResultReceiver> resultReceiver =
IResultReceiver::asInterface(data.readStrongBinder());
err = command(in, out, err, args, resultReceiver);
resultReceiver->send(err);
return NO_ERROR;
}
default: { return BnStatsManager::onTransact(code, data, reply, flags); }
}
}
/**
* Write data from statsd.
* Format for statsdStats: adb shell dumpsys stats --metadata [-v] [--proto]
* Format for data report: adb shell dumpsys stats [anything other than --metadata] [--proto]
* Anything ending in --proto will be in proto format.
* Anything without --metadata as the first argument will be report information.
* (bugreports call "adb shell dumpsys stats --dump-priority NORMAL -a --proto")
* TODO: Come up with a more robust method of enacting <serviceutils/PriorityDumper.h>.
*/
status_t StatsService::dump(int fd, const Vector<String16>& args) {
if (!checkCallingPermission(String16(kPermissionDump))) {
return PERMISSION_DENIED;
}
int lastArg = args.size() - 1;
bool asProto = false;
if (lastArg >= 0 && !args[lastArg].compare(String16("--proto"))) { // last argument
asProto = true;
lastArg--;
}
if (args.size() > 0 && !args[0].compare(String16("--metadata"))) { // first argument
// Request is to dump statsd stats.
bool verbose = false;
if (lastArg >= 0 && !args[lastArg].compare(String16("-v"))) {
verbose = true;
lastArg--;
}
dumpStatsdStats(fd, verbose, asProto);
} else {
// Request is to dump statsd report data.
if (asProto) {
dumpIncidentSection(fd);
} else {
dprintf(fd, "Non-proto format of stats data dump not available; see proto version.\n");
}
}
return NO_ERROR;
}
/**
* Write debugging data about statsd in text or proto format.
*/
void StatsService::dumpStatsdStats(int out, bool verbose, bool proto) {
if (proto) {
vector<uint8_t> data;
StatsdStats::getInstance().dumpStats(&data, false); // does not reset statsdStats.
for (size_t i = 0; i < data.size(); i ++) {
dprintf(out, "%c", data[i]);
}
} else {
StatsdStats::getInstance().dumpStats(out);
mProcessor->dumpStates(out, verbose);
}
}
/**
* Write stats report data in StatsDataDumpProto incident section format.
*/
void StatsService::dumpIncidentSection(int out) {
ProtoOutputStream proto;
for (const ConfigKey& configKey : mConfigManager->GetAllConfigKeys()) {
uint64_t reportsListToken =
proto.start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_REPORTS_LIST);
mProcessor->onDumpReport(configKey, getElapsedRealtimeNs(),
true /* includeCurrentBucket */, false /* erase_data */,
ADB_DUMP,
FAST,
&proto);
proto.end(reportsListToken);
proto.flush(out);
proto.clear();
}
}
/**
* Implementation of the adb shell cmd stats command.
*/
status_t StatsService::command(int in, int out, int err, Vector<String8>& args,
sp<IResultReceiver> resultReceiver) {
uid_t uid = IPCThreadState::self()->getCallingUid();
if (uid != AID_ROOT && uid != AID_SHELL) {
return PERMISSION_DENIED;
}
const int argCount = args.size();
if (argCount >= 1) {
// adb shell cmd stats config ...
if (!args[0].compare(String8("config"))) {
return cmd_config(in, out, err, args);
}
if (!args[0].compare(String8("print-uid-map"))) {
return cmd_print_uid_map(out, args);
}
if (!args[0].compare(String8("dump-report"))) {
return cmd_dump_report(out, args);
}
if (!args[0].compare(String8("pull-source")) && args.size() > 1) {
return cmd_print_pulled_metrics(out, args);
}
if (!args[0].compare(String8("send-broadcast"))) {
return cmd_trigger_broadcast(out, args);
}
if (!args[0].compare(String8("print-stats"))) {
return cmd_print_stats(out, args);
}
if (!args[0].compare(String8("meminfo"))) {
return cmd_dump_memory_info(out);
}
if (!args[0].compare(String8("write-to-disk"))) {
return cmd_write_data_to_disk(out);
}
if (!args[0].compare(String8("log-app-breadcrumb"))) {
return cmd_log_app_breadcrumb(out, args);
}
if (!args[0].compare(String8("log-binary-push"))) {
return cmd_log_binary_push(out, args);
}
if (!args[0].compare(String8("clear-puller-cache"))) {
return cmd_clear_puller_cache(out);
}
if (!args[0].compare(String8("print-logs"))) {
return cmd_print_logs(out, args);
}
if (!args[0].compare(String8("send-active-configs"))) {
return cmd_trigger_active_config_broadcast(out, args);
}
if (!args[0].compare(String8("data-subscribe"))) {
if (mShellSubscriber == nullptr) {
mShellSubscriber = new ShellSubscriber(mUidMap, mPullerManager);
}
int timeoutSec = -1;
if (argCount >= 2) {
timeoutSec = atoi(args[1].c_str());
}
mShellSubscriber->startNewSubscription(in, out, resultReceiver, timeoutSec);
return NO_ERROR;
}
}
print_cmd_help(out);
return NO_ERROR;
}
void StatsService::print_cmd_help(int out) {
dprintf(out,
"usage: adb shell cmd stats print-stats-log [tag_required] "
"[timestamp_nsec_optional]\n");
dprintf(out, "\n");
dprintf(out, "\n");
dprintf(out, "usage: adb shell cmd stats meminfo\n");
dprintf(out, "\n");
dprintf(out, " Prints the malloc debug information. You need to run the following first: \n");
dprintf(out, " # adb shell stop\n");
dprintf(out, " # adb shell setprop libc.debug.malloc.program statsd \n");
dprintf(out, " # adb shell setprop libc.debug.malloc.options backtrace \n");
dprintf(out, " # adb shell start\n");
dprintf(out, "\n");
dprintf(out, "\n");
dprintf(out, "usage: adb shell cmd stats print-uid-map [PKG]\n");
dprintf(out, "\n");
dprintf(out, " Prints the UID, app name, version mapping.\n");
dprintf(out, " PKG Optional package name to print the uids of the package\n");
dprintf(out, "\n");
dprintf(out, "\n");
dprintf(out, "usage: adb shell cmd stats pull-source [int] \n");
dprintf(out, "\n");
dprintf(out, " Prints the output of a pulled metrics source (int indicates source)\n");
dprintf(out, "\n");
dprintf(out, "\n");
dprintf(out, "usage: adb shell cmd stats write-to-disk \n");
dprintf(out, "\n");
dprintf(out, " Flushes all data on memory to disk.\n");
dprintf(out, "\n");
dprintf(out, "\n");
dprintf(out, "usage: adb shell cmd stats log-app-breadcrumb [UID] LABEL STATE\n");
dprintf(out, " Writes an AppBreadcrumbReported event to the statslog buffer.\n");
dprintf(out, " UID The uid to use. It is only possible to pass a UID\n");
dprintf(out, " parameter on eng builds. If UID is omitted the calling\n");
dprintf(out, " uid is used.\n");
dprintf(out, " LABEL Integer in [0, 15], as per atoms.proto.\n");
dprintf(out, " STATE Integer in [0, 3], as per atoms.proto.\n");
dprintf(out, "\n");
dprintf(out, "\n");
dprintf(out,
"usage: adb shell cmd stats log-binary-push NAME VERSION STAGING ROLLBACK_ENABLED "
"LOW_LATENCY STATE EXPERIMENT_IDS\n");
dprintf(out, " Log a binary push state changed event.\n");
dprintf(out, " NAME The train name.\n");
dprintf(out, " VERSION The train version code.\n");
dprintf(out, " STAGING If this train requires a restart.\n");
dprintf(out, " ROLLBACK_ENABLED If rollback should be enabled for this install.\n");
dprintf(out, " LOW_LATENCY If the train requires low latency monitoring.\n");
dprintf(out, " STATE The status of the train push.\n");
dprintf(out, " Integer value of the enum in atoms.proto.\n");
dprintf(out, " EXPERIMENT_IDS Comma separated list of experiment ids.\n");
dprintf(out, " Leave blank for none.\n");
dprintf(out, "\n");
dprintf(out, "\n");
dprintf(out, "usage: adb shell cmd stats config remove [UID] [NAME]\n");
dprintf(out, "usage: adb shell cmd stats config update [UID] NAME\n");
dprintf(out, "\n");
dprintf(out, " Adds, updates or removes a configuration. The proto should be in\n");
dprintf(out, " wire-encoded protobuf format and passed via stdin. If no UID and name is\n");
dprintf(out, " provided, then all configs will be removed from memory and disk.\n");
dprintf(out, "\n");
dprintf(out, " UID The uid to use. It is only possible to pass the UID\n");
dprintf(out, " parameter on eng builds. If UID is omitted the calling\n");
dprintf(out, " uid is used.\n");
dprintf(out, " NAME The per-uid name to use\n");
dprintf(out, "\n");
dprintf(out, "\n *Note: If both UID and NAME are omitted then all configs will\n");
dprintf(out, "\n be removed from memory and disk!\n");
dprintf(out, "\n");
dprintf(out,
"usage: adb shell cmd stats dump-report [UID] NAME [--keep_data] "
"[--include_current_bucket] [--proto]\n");
dprintf(out, " Dump all metric data for a configuration.\n");
dprintf(out, " UID The uid of the configuration. It is only possible to pass\n");
dprintf(out, " the UID parameter on eng builds. If UID is omitted the\n");
dprintf(out, " calling uid is used.\n");
dprintf(out, " NAME The name of the configuration\n");
dprintf(out, " --keep_data Do NOT erase the data upon dumping it.\n");
dprintf(out, " --proto Print proto binary.\n");
dprintf(out, "\n");
dprintf(out, "\n");
dprintf(out, "usage: adb shell cmd stats send-broadcast [UID] NAME\n");
dprintf(out, " Send a broadcast that triggers the subscriber to fetch metrics.\n");
dprintf(out, " UID The uid of the configuration. It is only possible to pass\n");
dprintf(out, " the UID parameter on eng builds. If UID is omitted the\n");
dprintf(out, " calling uid is used.\n");
dprintf(out, " NAME The name of the configuration\n");
dprintf(out, "\n");
dprintf(out, "\n");
dprintf(out,
"usage: adb shell cmd stats send-active-configs [--uid=UID] [--configs] "
"[NAME1] [NAME2] [NAME3..]\n");
dprintf(out, " Send a broadcast that informs the subscriber of the current active configs.\n");
dprintf(out, " --uid=UID The uid of the configurations. It is only possible to pass\n");
dprintf(out, " the UID parameter on eng builds. If UID is omitted the\n");
dprintf(out, " calling uid is used.\n");
dprintf(out, " --configs Send the list of configs in the name list instead of\n");
dprintf(out, " the currently active configs\n");
dprintf(out, " NAME LIST List of configuration names to be included in the broadcast.\n");
dprintf(out, "\n");
dprintf(out, "\n");
dprintf(out, "usage: adb shell cmd stats print-stats\n");
dprintf(out, " Prints some basic stats.\n");
dprintf(out, " --proto Print proto binary instead of string format.\n");
dprintf(out, "\n");
dprintf(out, "\n");
dprintf(out, "usage: adb shell cmd stats clear-puller-cache\n");
dprintf(out, " Clear cached puller data.\n");
dprintf(out, "\n");
dprintf(out, "usage: adb shell cmd stats print-logs\n");
dprintf(out, " Only works on eng build\n");
}
status_t StatsService::cmd_trigger_broadcast(int out, Vector<String8>& args) {
string name;
bool good = false;
int uid;
const int argCount = args.size();
if (argCount == 2) {
// Automatically pick the UID
uid = IPCThreadState::self()->getCallingUid();
name.assign(args[1].c_str(), args[1].size());
good = true;
} else if (argCount == 3) {
good = getUidFromArgs(args, 1, uid);
if (!good) {
dprintf(out, "Invalid UID. Note that the metrics can only be dumped for "
"other UIDs on eng or userdebug builds.\n");
}
name.assign(args[2].c_str(), args[2].size());
}
if (!good) {
print_cmd_help(out);
return UNKNOWN_ERROR;
}
ConfigKey key(uid, StrToInt64(name));
auto receiver = mConfigManager->GetConfigReceiver(key);
sp<IStatsCompanionService> sc = getStatsCompanionService();
if (sc == nullptr) {
VLOG("Could not access statsCompanion");
} else if (receiver == nullptr) {
VLOG("Could not find receiver for %s, %s", args[1].c_str(), args[2].c_str())
} else {
sc->sendDataBroadcast(receiver, mProcessor->getLastReportTimeNs(key));
VLOG("StatsService::trigger broadcast succeeded to %s, %s", args[1].c_str(),
args[2].c_str());
}
return NO_ERROR;
}
status_t StatsService::cmd_trigger_active_config_broadcast(int out, Vector<String8>& args) {
const int argCount = args.size();
int uid;
vector<int64_t> configIds;
if (argCount == 1) {
// Automatically pick the uid and send a broadcast that has no active configs.
uid = IPCThreadState::self()->getCallingUid();
mProcessor->GetActiveConfigs(uid, configIds);
} else {
int curArg = 1;
if(args[curArg].find("--uid=") == 0) {
string uidArgStr(args[curArg].c_str());
string uidStr = uidArgStr.substr(6);
if (!getUidFromString(uidStr.c_str(), uid)) {
dprintf(out, "Invalid UID. Note that the config can only be set for "
"other UIDs on eng or userdebug builds.\n");
return UNKNOWN_ERROR;
}
curArg++;
} else {
uid = IPCThreadState::self()->getCallingUid();
}
if (curArg == argCount || args[curArg] != "--configs") {
VLOG("Reached end of args, or specify configs not set. Sending actual active configs,");
mProcessor->GetActiveConfigs(uid, configIds);
} else {
// Flag specified, use the given list of configs.
curArg++;
for (int i = curArg; i < argCount; i++) {
char* endp;
int64_t configID = strtoll(args[i].c_str(), &endp, 10);
if (endp == args[i].c_str() || *endp != '\0') {
dprintf(out, "Error parsing config ID.\n");
return UNKNOWN_ERROR;
}
VLOG("Adding config id %ld", static_cast<long>(configID));
configIds.push_back(configID);
}
}
}
auto receiver = mConfigManager->GetActiveConfigsChangedReceiver(uid);
sp<IStatsCompanionService> sc = getStatsCompanionService();
if (sc == nullptr) {
VLOG("Could not access statsCompanion");
} else if (receiver == nullptr) {
VLOG("Could not find receiver for uid %d", uid);
} else {
sc->sendActiveConfigsChangedBroadcast(receiver, configIds);
VLOG("StatsService::trigger active configs changed broadcast succeeded for uid %d" , uid);
}
return NO_ERROR;
}
status_t StatsService::cmd_config(int in, int out, int err, Vector<String8>& args) {
const int argCount = args.size();
if (argCount >= 2) {
if (args[1] == "update" || args[1] == "remove") {
bool good = false;
int uid = -1;
string name;
if (argCount == 3) {
// Automatically pick the UID
uid = IPCThreadState::self()->getCallingUid();
name.assign(args[2].c_str(), args[2].size());
good = true;
} else if (argCount == 4) {
good = getUidFromArgs(args, 2, uid);
if (!good) {
dprintf(err, "Invalid UID. Note that the config can only be set for "
"other UIDs on eng or userdebug builds.\n");
}
name.assign(args[3].c_str(), args[3].size());
} else if (argCount == 2 && args[1] == "remove") {
good = true;
}
if (!good) {
// If arg parsing failed, print the help text and return an error.
print_cmd_help(out);
return UNKNOWN_ERROR;
}
if (args[1] == "update") {
char* endp;
int64_t configID = strtoll(name.c_str(), &endp, 10);
if (endp == name.c_str() || *endp != '\0') {
dprintf(err, "Error parsing config ID.\n");
return UNKNOWN_ERROR;
}
// Read stream into buffer.
string buffer;
if (!android::base::ReadFdToString(in, &buffer)) {
dprintf(err, "Error reading stream for StatsConfig.\n");
return UNKNOWN_ERROR;
}
// Parse buffer.
StatsdConfig config;
if (!config.ParseFromString(buffer)) {
dprintf(err, "Error parsing proto stream for StatsConfig.\n");
return UNKNOWN_ERROR;
}
// Add / update the config.
mConfigManager->UpdateConfig(ConfigKey(uid, configID), config);
} else {
if (argCount == 2) {
cmd_remove_all_configs(out);
} else {
// Remove the config.
mConfigManager->RemoveConfig(ConfigKey(uid, StrToInt64(name)));
}
}
return NO_ERROR;
}
}
print_cmd_help(out);
return UNKNOWN_ERROR;
}
status_t StatsService::cmd_dump_report(int out, const Vector<String8>& args) {
if (mProcessor != nullptr) {
int argCount = args.size();
bool good = false;
bool proto = false;
bool includeCurrentBucket = false;
bool eraseData = true;
int uid;
string name;
if (!std::strcmp("--proto", args[argCount-1].c_str())) {
proto = true;
argCount -= 1;
}
if (!std::strcmp("--include_current_bucket", args[argCount-1].c_str())) {
includeCurrentBucket = true;
argCount -= 1;
}
if (!std::strcmp("--keep_data", args[argCount-1].c_str())) {
eraseData = false;
argCount -= 1;
}
if (argCount == 2) {
// Automatically pick the UID
uid = IPCThreadState::self()->getCallingUid();
name.assign(args[1].c_str(), args[1].size());
good = true;
} else if (argCount == 3) {
good = getUidFromArgs(args, 1, uid);
if (!good) {
dprintf(out, "Invalid UID. Note that the metrics can only be dumped for "
"other UIDs on eng or userdebug builds.\n");
}
name.assign(args[2].c_str(), args[2].size());
}
if (good) {
vector<uint8_t> data;
mProcessor->onDumpReport(ConfigKey(uid, StrToInt64(name)), getElapsedRealtimeNs(),
includeCurrentBucket, eraseData, ADB_DUMP,
NO_TIME_CONSTRAINTS,
&data);
if (proto) {
for (size_t i = 0; i < data.size(); i ++) {
dprintf(out, "%c", data[i]);
}
} else {
dprintf(out, "Non-proto stats data dump not currently supported.\n");
}
return android::OK;
} else {
// If arg parsing failed, print the help text and return an error.
print_cmd_help(out);
return UNKNOWN_ERROR;
}
} else {
dprintf(out, "Log processor does not exist...\n");
return UNKNOWN_ERROR;
}
}
status_t StatsService::cmd_print_stats(int out, const Vector<String8>& args) {
int argCount = args.size();
bool proto = false;
if (!std::strcmp("--proto", args[argCount-1].c_str())) {
proto = true;
argCount -= 1;
}
StatsdStats& statsdStats = StatsdStats::getInstance();
if (proto) {
vector<uint8_t> data;
statsdStats.dumpStats(&data, false); // does not reset statsdStats.
for (size_t i = 0; i < data.size(); i ++) {
dprintf(out, "%c", data[i]);
}
} else {
vector<ConfigKey> configs = mConfigManager->GetAllConfigKeys();
for (const ConfigKey& key : configs) {
dprintf(out, "Config %s uses %zu bytes\n", key.ToString().c_str(),
mProcessor->GetMetricsSize(key));
}
statsdStats.dumpStats(out);
}
return NO_ERROR;
}
status_t StatsService::cmd_print_uid_map(int out, const Vector<String8>& args) {
if (args.size() > 1) {
string pkg;
pkg.assign(args[1].c_str(), args[1].size());
auto uids = mUidMap->getAppUid(pkg);
dprintf(out, "%s -> [ ", pkg.c_str());
for (const auto& uid : uids) {
dprintf(out, "%d ", uid);
}
dprintf(out, "]\n");
} else {
mUidMap->printUidMap(out);
}
return NO_ERROR;
}
status_t StatsService::cmd_write_data_to_disk(int out) {
dprintf(out, "Writing data to disk\n");
mProcessor->WriteDataToDisk(ADB_DUMP, NO_TIME_CONSTRAINTS);
return NO_ERROR;
}
status_t StatsService::cmd_log_app_breadcrumb(int out, const Vector<String8>& args) {
bool good = false;
int32_t uid;
int32_t label;
int32_t state;
const int argCount = args.size();
if (argCount == 3) {
// Automatically pick the UID
uid = IPCThreadState::self()->getCallingUid();
label = atoi(args[1].c_str());
state = atoi(args[2].c_str());
good = true;
} else if (argCount == 4) {
good = getUidFromArgs(args, 1, uid);
if (!good) {
dprintf(out,
"Invalid UID. Note that selecting a UID for writing AppBreadcrumb can only be "
"done for other UIDs on eng or userdebug builds.\n");
}
label = atoi(args[2].c_str());
state = atoi(args[3].c_str());
}
if (good) {
dprintf(out, "Logging AppBreadcrumbReported(%d, %d, %d) to statslog.\n", uid, label, state);
android::util::stats_write(android::util::APP_BREADCRUMB_REPORTED, uid, label, state);
} else {
print_cmd_help(out);
return UNKNOWN_ERROR;
}
return NO_ERROR;
}
status_t StatsService::cmd_log_binary_push(int out, const Vector<String8>& args) {
// Security checks are done in the sendBinaryPushStateChanged atom.
const int argCount = args.size();
if (argCount != 7 && argCount != 8) {
dprintf(out, "Incorrect number of argument supplied\n");
return UNKNOWN_ERROR;
}
android::String16 trainName = android::String16(args[1].c_str());
int64_t trainVersion = strtoll(args[2].c_str(), nullptr, 10);
int options = 0;
if (args[3] == "1") {
options = options | IStatsManager::FLAG_REQUIRE_STAGING;
}
if (args[4] == "1") {
options = options | IStatsManager::FLAG_ROLLBACK_ENABLED;
}
if (args[5] == "1") {
options = options | IStatsManager::FLAG_REQUIRE_LOW_LATENCY_MONITOR;
}
int32_t state = atoi(args[6].c_str());
vector<int64_t> experimentIds;
if (argCount == 8) {
vector<string> experimentIdsString = android::base::Split(string(args[7].c_str()), ",");
for (string experimentIdString : experimentIdsString) {
int64_t experimentId = strtoll(experimentIdString.c_str(), nullptr, 10);
experimentIds.push_back(experimentId);
}
}
dprintf(out, "Logging BinaryPushStateChanged\n");
sendBinaryPushStateChangedAtom(trainName, trainVersion, options, state, experimentIds);
return NO_ERROR;
}
status_t StatsService::cmd_print_pulled_metrics(int out, const Vector<String8>& args) {
int s = atoi(args[1].c_str());
vector<shared_ptr<LogEvent> > stats;
if (mPullerManager->Pull(s, &stats)) {
for (const auto& it : stats) {
dprintf(out, "Pull from %d: %s\n", s, it->ToString().c_str());
}
dprintf(out, "Pull from %d: Received %zu elements\n", s, stats.size());
return NO_ERROR;
}
return UNKNOWN_ERROR;
}
status_t StatsService::cmd_remove_all_configs(int out) {
dprintf(out, "Removing all configs...\n");
VLOG("StatsService::cmd_remove_all_configs was called");
mConfigManager->RemoveAllConfigs();
StorageManager::deleteAllFiles(STATS_SERVICE_DIR);
return NO_ERROR;
}
status_t StatsService::cmd_dump_memory_info(int out) {
dprintf(out, "meminfo not available.\n");
return NO_ERROR;
}
status_t StatsService::cmd_clear_puller_cache(int out) {
IPCThreadState* ipc = IPCThreadState::self();
VLOG("StatsService::cmd_clear_puller_cache with Pid %i, Uid %i",
ipc->getCallingPid(), ipc->getCallingUid());
if (checkCallingPermission(String16(kPermissionDump))) {
int cleared = mPullerManager->ForceClearPullerCache();
dprintf(out, "Puller removed %d cached data!\n", cleared);
return NO_ERROR;
} else {
return PERMISSION_DENIED;
}
}
status_t StatsService::cmd_print_logs(int out, const Vector<String8>& args) {
IPCThreadState* ipc = IPCThreadState::self();
VLOG("StatsService::cmd_print_logs with Pid %i, Uid %i", ipc->getCallingPid(),
ipc->getCallingUid());
if (checkCallingPermission(String16(kPermissionDump))) {
bool enabled = true;
if (args.size() >= 2) {
enabled = atoi(args[1].c_str()) != 0;
}
mProcessor->setPrintLogs(enabled);
return NO_ERROR;
} else {
return PERMISSION_DENIED;
}
}
bool StatsService::getUidFromArgs(const Vector<String8>& args, size_t uidArgIndex, int32_t& uid) {
return getUidFromString(args[uidArgIndex].c_str(), uid);
}
bool StatsService::getUidFromString(const char* s, int32_t& uid) {
if (*s == '\0') {
return false;
}
char* endc = NULL;
int64_t longUid = strtol(s, &endc, 0);
if (*endc != '\0') {
return false;
}
int32_t goodUid = static_cast<int32_t>(longUid);
if (longUid < 0 || static_cast<uint64_t>(longUid) != static_cast<uid_t>(goodUid)) {
return false; // It was not of uid_t type.
}
uid = goodUid;
int32_t callingUid = IPCThreadState::self()->getCallingUid();
return mEngBuild // UserDebug/EngBuild are allowed to impersonate uids.
|| (callingUid == goodUid) // Anyone can 'impersonate' themselves.
|| (callingUid == AID_ROOT && goodUid == AID_SHELL); // ROOT can impersonate SHELL.
}
Status StatsService::informAllUidData(const ParcelFileDescriptor& fd) {
ENFORCE_UID(AID_SYSTEM);
// Read stream into buffer.
string buffer;
if (!android::base::ReadFdToString(fd.get(), &buffer)) {
return exception(Status::EX_ILLEGAL_ARGUMENT, "Failed to read all data from the pipe.");
}
// Parse buffer.
UidData uidData;
if (!uidData.ParseFromString(buffer)) {
return exception(Status::EX_ILLEGAL_ARGUMENT, "Error parsing proto stream for UidData.");
}
vector<String16> versionStrings;
vector<String16> installers;
vector<String16> packageNames;
vector<int32_t> uids;
vector<int64_t> versions;
const auto numEntries = uidData.app_info_size();
versionStrings.reserve(numEntries);
installers.reserve(numEntries);
packageNames.reserve(numEntries);
uids.reserve(numEntries);
versions.reserve(numEntries);
for (const auto& appInfo: uidData.app_info()) {
packageNames.emplace_back(String16(appInfo.package_name().c_str()));
uids.push_back(appInfo.uid());
versions.push_back(appInfo.version());
versionStrings.emplace_back(String16(appInfo.version_string().c_str()));
installers.emplace_back(String16(appInfo.installer().c_str()));
}
mUidMap->updateMap(getElapsedRealtimeNs(),
uids,
versions,
versionStrings,
packageNames,
installers);
VLOG("StatsService::informAllUidData UidData proto parsed successfully.");
return Status::ok();
}
Status StatsService::informOnePackage(const String16& app, int32_t uid, int64_t version,
const String16& version_string, const String16& installer) {
ENFORCE_UID(AID_SYSTEM);
VLOG("StatsService::informOnePackage was called");
mUidMap->updateApp(getElapsedRealtimeNs(), app, uid, version, version_string, installer);
return Status::ok();
}
Status StatsService::informOnePackageRemoved(const String16& app, int32_t uid) {
ENFORCE_UID(AID_SYSTEM);
VLOG("StatsService::informOnePackageRemoved was called");
mUidMap->removeApp(getElapsedRealtimeNs(), app, uid);
mConfigManager->RemoveConfigs(uid);
return Status::ok();
}
Status StatsService::informAnomalyAlarmFired() {
ENFORCE_UID(AID_SYSTEM);
VLOG("StatsService::informAnomalyAlarmFired was called");
int64_t currentTimeSec = getElapsedRealtimeSec();
std::unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>> alarmSet =
mAnomalyAlarmMonitor->popSoonerThan(static_cast<uint32_t>(currentTimeSec));
if (alarmSet.size() > 0) {
VLOG("Found an anomaly alarm that fired.");
mProcessor->onAnomalyAlarmFired(currentTimeSec * NS_PER_SEC, alarmSet);
} else {
VLOG("Cannot find an anomaly alarm that fired. Perhaps it was recently cancelled.");
}
return Status::ok();
}
Status StatsService::informAlarmForSubscriberTriggeringFired() {
ENFORCE_UID(AID_SYSTEM);
VLOG("StatsService::informAlarmForSubscriberTriggeringFired was called");
int64_t currentTimeSec = getElapsedRealtimeSec();
std::unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>> alarmSet =
mPeriodicAlarmMonitor->popSoonerThan(static_cast<uint32_t>(currentTimeSec));
if (alarmSet.size() > 0) {
VLOG("Found periodic alarm fired.");
mProcessor->onPeriodicAlarmFired(currentTimeSec * NS_PER_SEC, alarmSet);
} else {
ALOGW("Cannot find an periodic alarm that fired. Perhaps it was recently cancelled.");
}
return Status::ok();
}
Status StatsService::informPollAlarmFired() {
ENFORCE_UID(AID_SYSTEM);
VLOG("StatsService::informPollAlarmFired was called");
mProcessor->informPullAlarmFired(getElapsedRealtimeNs());
VLOG("StatsService::informPollAlarmFired succeeded");
return Status::ok();
}
Status StatsService::systemRunning() {
ENFORCE_UID(AID_SYSTEM);
// When system_server is up and running, schedule the dropbox task to run.
VLOG("StatsService::systemRunning");
sayHiToStatsCompanion();
return Status::ok();
}
Status StatsService::informDeviceShutdown() {
ENFORCE_UID(AID_SYSTEM);
VLOG("StatsService::informDeviceShutdown");
mProcessor->WriteDataToDisk(DEVICE_SHUTDOWN, FAST);
mProcessor->SaveActiveConfigsToDisk(getElapsedRealtimeNs());
return Status::ok();
}
void StatsService::sayHiToStatsCompanion() {
sp<IStatsCompanionService> statsCompanion = getStatsCompanionService();
if (statsCompanion != nullptr) {
VLOG("Telling statsCompanion that statsd is ready");
statsCompanion->statsdReady();
} else {
VLOG("Could not access statsCompanion");
}
}
Status StatsService::statsCompanionReady() {
ENFORCE_UID(AID_SYSTEM);
VLOG("StatsService::statsCompanionReady was called");
sp<IStatsCompanionService> statsCompanion = getStatsCompanionService();
if (statsCompanion == nullptr) {
return Status::fromExceptionCode(
Status::EX_NULL_POINTER,
"statscompanion unavailable despite it contacting statsd!");
}
VLOG("StatsService::statsCompanionReady linking to statsCompanion.");
IInterface::asBinder(statsCompanion)->linkToDeath(this);
mPullerManager->SetStatsCompanionService(statsCompanion);
mAnomalyAlarmMonitor->setStatsCompanionService(statsCompanion);
mPeriodicAlarmMonitor->setStatsCompanionService(statsCompanion);
SubscriberReporter::getInstance().setStatsCompanionService(statsCompanion);
return Status::ok();
}
void StatsService::Startup() {
mConfigManager->Startup();
mProcessor->LoadActiveConfigsFromDisk();
}
void StatsService::Terminate() {
ALOGI("StatsService::Terminating");
if (mProcessor != nullptr) {
mProcessor->WriteDataToDisk(TERMINATION_SIGNAL_RECEIVED, FAST);
mProcessor->SaveActiveConfigsToDisk(getElapsedRealtimeNs());
}
}
// Test only interface!!!
void StatsService::OnLogEvent(LogEvent* event) {
mProcessor->OnLogEvent(event);
if (mShellSubscriber != nullptr) {
mShellSubscriber->onLogEvent(*event);
}
}
Status StatsService::getData(int64_t key, const String16& packageName, vector<uint8_t>* output) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
IPCThreadState* ipc = IPCThreadState::self();
VLOG("StatsService::getData with Pid %i, Uid %i", ipc->getCallingPid(), ipc->getCallingUid());
ConfigKey configKey(ipc->getCallingUid(), key);
// The dump latency does not matter here since we do not include the current bucket, we do not
// need to pull any new data anyhow.
mProcessor->onDumpReport(configKey, getElapsedRealtimeNs(), false /* include_current_bucket*/,
true /* erase_data */, GET_DATA_CALLED, FAST, output);
return Status::ok();
}
Status StatsService::getMetadata(const String16& packageName, vector<uint8_t>* output) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
IPCThreadState* ipc = IPCThreadState::self();
VLOG("StatsService::getMetadata with Pid %i, Uid %i", ipc->getCallingPid(),
ipc->getCallingUid());
StatsdStats::getInstance().dumpStats(output, false); // Don't reset the counters.
return Status::ok();
}
Status StatsService::addConfiguration(int64_t key, const vector <uint8_t>& config,
const String16& packageName) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
IPCThreadState* ipc = IPCThreadState::self();
if (addConfigurationChecked(ipc->getCallingUid(), key, config)) {
return Status::ok();
} else {
ALOGE("Could not parse malformatted StatsdConfig");
return Status::fromExceptionCode(binder::Status::EX_ILLEGAL_ARGUMENT,
"config does not correspond to a StatsdConfig proto");
}
}
bool StatsService::addConfigurationChecked(int uid, int64_t key, const vector<uint8_t>& config) {
ConfigKey configKey(uid, key);
StatsdConfig cfg;
if (config.size() > 0) { // If the config is empty, skip parsing.
if (!cfg.ParseFromArray(&config[0], config.size())) {
return false;
}
}
mConfigManager->UpdateConfig(configKey, cfg);
return true;
}
Status StatsService::removeDataFetchOperation(int64_t key, const String16& packageName) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
IPCThreadState* ipc = IPCThreadState::self();
ConfigKey configKey(ipc->getCallingUid(), key);
mConfigManager->RemoveConfigReceiver(configKey);
return Status::ok();
}
Status StatsService::setDataFetchOperation(int64_t key,
const sp<android::IBinder>& intentSender,
const String16& packageName) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
IPCThreadState* ipc = IPCThreadState::self();
ConfigKey configKey(ipc->getCallingUid(), key);
mConfigManager->SetConfigReceiver(configKey, intentSender);
if (StorageManager::hasConfigMetricsReport(configKey)) {
VLOG("StatsService::setDataFetchOperation marking configKey %s to dump reports on disk",
configKey.ToString().c_str());
mProcessor->noteOnDiskData(configKey);
}
return Status::ok();
}
Status StatsService::setActiveConfigsChangedOperation(const sp<android::IBinder>& intentSender,
const String16& packageName,
vector<int64_t>* output) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
IPCThreadState* ipc = IPCThreadState::self();
int uid = ipc->getCallingUid();
mConfigManager->SetActiveConfigsChangedReceiver(uid, intentSender);
if (output != nullptr) {
mProcessor->GetActiveConfigs(uid, *output);
} else {
ALOGW("StatsService::setActiveConfigsChanged output was nullptr");
}
return Status::ok();
}
Status StatsService::removeActiveConfigsChangedOperation(const String16& packageName) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
IPCThreadState* ipc = IPCThreadState::self();
mConfigManager->RemoveActiveConfigsChangedReceiver(ipc->getCallingUid());
return Status::ok();
}
Status StatsService::removeConfiguration(int64_t key, const String16& packageName) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
IPCThreadState* ipc = IPCThreadState::self();
ConfigKey configKey(ipc->getCallingUid(), key);
mConfigManager->RemoveConfig(configKey);
SubscriberReporter::getInstance().removeConfig(configKey);
return Status::ok();
}
Status StatsService::setBroadcastSubscriber(int64_t configId,
int64_t subscriberId,
const sp<android::IBinder>& intentSender,
const String16& packageName) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
VLOG("StatsService::setBroadcastSubscriber called.");
IPCThreadState* ipc = IPCThreadState::self();
ConfigKey configKey(ipc->getCallingUid(), configId);
SubscriberReporter::getInstance()
.setBroadcastSubscriber(configKey, subscriberId, intentSender);
return Status::ok();
}
Status StatsService::unsetBroadcastSubscriber(int64_t configId,
int64_t subscriberId,
const String16& packageName) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
VLOG("StatsService::unsetBroadcastSubscriber called.");
IPCThreadState* ipc = IPCThreadState::self();
ConfigKey configKey(ipc->getCallingUid(), configId);
SubscriberReporter::getInstance()
.unsetBroadcastSubscriber(configKey, subscriberId);
return Status::ok();
}
Status StatsService::sendAppBreadcrumbAtom(int32_t label, int32_t state) {
// Permission check not necessary as it's meant for applications to write to
// statsd.
android::util::stats_write(util::APP_BREADCRUMB_REPORTED,
IPCThreadState::self()->getCallingUid(), label,
state);
return Status::ok();
}
Status StatsService::registerPullerCallback(int32_t atomTag,
const sp<android::os::IStatsPullerCallback>& pullerCallback,
const String16& packageName) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
VLOG("StatsService::registerPullerCallback called.");
mPullerManager->RegisterPullerCallback(atomTag, pullerCallback);
return Status::ok();
}
Status StatsService::unregisterPullerCallback(int32_t atomTag, const String16& packageName) {
ENFORCE_DUMP_AND_USAGE_STATS(packageName);
VLOG("StatsService::unregisterPullerCallback called.");
mPullerManager->UnregisterPullerCallback(atomTag);
return Status::ok();
}
Status StatsService::sendBinaryPushStateChangedAtom(const android::String16& trainNameIn,
const int64_t trainVersionCodeIn,
const int options,
const int32_t state,
const std::vector<int64_t>& experimentIdsIn) {
// Note: We skip the usage stats op check here since we do not have a package name.
// This is ok since we are overloading the usage_stats permission.
// This method only sends data, it does not receive it.
pid_t pid = IPCThreadState::self()->getCallingPid();
uid_t uid = IPCThreadState::self()->getCallingUid();
// Root, system, and shell always have access
if (uid != AID_ROOT && uid != AID_SYSTEM && uid != AID_SHELL) {
// Caller must be granted these permissions
if (!checkCallingPermission(String16(kPermissionDump))) {
return exception(binder::Status::EX_SECURITY,
StringPrintf("UID %d / PID %d lacks permission %s", uid, pid,
kPermissionDump));
}
if (!checkCallingPermission(String16(kPermissionUsage))) {
return exception(binder::Status::EX_SECURITY,
StringPrintf("UID %d / PID %d lacks permission %s", uid, pid,
kPermissionUsage));
}
}
bool readTrainInfoSuccess = false;
InstallTrainInfo trainInfoOnDisk;
readTrainInfoSuccess = StorageManager::readTrainInfo(trainInfoOnDisk);
bool resetExperimentIds = false;
int64_t trainVersionCode = trainVersionCodeIn;
std::string trainNameUtf8 = std::string(String8(trainNameIn).string());
if (readTrainInfoSuccess) {
// Keep the old train version if we received an empty version.
if (trainVersionCodeIn == -1) {
trainVersionCode = trainInfoOnDisk.trainVersionCode;
} else if (trainVersionCodeIn != trainInfoOnDisk.trainVersionCode) {
// Reset experiment ids if we receive a new non-empty train version.
resetExperimentIds = true;
}
// Keep the old train name if we received an empty train name.
if (trainNameUtf8.size() == 0) {
trainNameUtf8 = trainInfoOnDisk.trainName;
} else if (trainNameUtf8 != trainInfoOnDisk.trainName) {
// Reset experiment ids if we received a new valid train name.
resetExperimentIds = true;
}
// Reset if we received a different experiment id.
if (!experimentIdsIn.empty() &&
(trainInfoOnDisk.experimentIds.empty() ||
experimentIdsIn[0] != trainInfoOnDisk.experimentIds[0])) {
resetExperimentIds = true;
}
}
// Find the right experiment IDs
std::vector<int64_t> experimentIds;
if (resetExperimentIds || !readTrainInfoSuccess) {
experimentIds = experimentIdsIn;
} else {
experimentIds = trainInfoOnDisk.experimentIds;
}
if (!experimentIds.empty()) {
int64_t firstId = experimentIds[0];
switch (state) {
case android::util::BINARY_PUSH_STATE_CHANGED__STATE__INSTALL_SUCCESS:
experimentIds.push_back(firstId + 1);
break;
case android::util::BINARY_PUSH_STATE_CHANGED__STATE__INSTALLER_ROLLBACK_INITIATED:
experimentIds.push_back(firstId + 2);
break;
case android::util::BINARY_PUSH_STATE_CHANGED__STATE__INSTALLER_ROLLBACK_SUCCESS:
experimentIds.push_back(firstId + 3);
break;
}
}
// Flatten the experiment IDs to proto
vector<uint8_t> experimentIdsProtoBuffer;
writeExperimentIdsToProto(experimentIds, &experimentIdsProtoBuffer);
StorageManager::writeTrainInfo(trainVersionCode, trainNameUtf8, state, experimentIds);
userid_t userId = multiuser_get_user_id(uid);
bool requiresStaging = options & IStatsManager::FLAG_REQUIRE_STAGING;
bool rollbackEnabled = options & IStatsManager::FLAG_ROLLBACK_ENABLED;
bool requiresLowLatencyMonitor = options & IStatsManager::FLAG_REQUIRE_LOW_LATENCY_MONITOR;
LogEvent event(trainNameUtf8, trainVersionCode, requiresStaging, rollbackEnabled,
requiresLowLatencyMonitor, state, experimentIdsProtoBuffer, userId);
mProcessor->OnLogEvent(&event);
return Status::ok();
}
Status StatsService::sendWatchdogRollbackOccurredAtom(const int32_t rollbackTypeIn,
const android::String16& packageNameIn,
const int64_t packageVersionCodeIn) {
// Note: We skip the usage stats op check here since we do not have a package name.
// This is ok since we are overloading the usage_stats permission.
// This method only sends data, it does not receive it.
pid_t pid = IPCThreadState::self()->getCallingPid();
uid_t uid = IPCThreadState::self()->getCallingUid();
// Root, system, and shell always have access
if (uid != AID_ROOT && uid != AID_SYSTEM && uid != AID_SHELL) {
// Caller must be granted these permissions
if (!checkCallingPermission(String16(kPermissionDump))) {
return exception(binder::Status::EX_SECURITY,
StringPrintf("UID %d / PID %d lacks permission %s", uid, pid,
kPermissionDump));
}
if (!checkCallingPermission(String16(kPermissionUsage))) {
return exception(binder::Status::EX_SECURITY,
StringPrintf("UID %d / PID %d lacks permission %s", uid, pid,
kPermissionUsage));
}
}
android::util::stats_write(android::util::WATCHDOG_ROLLBACK_OCCURRED,
rollbackTypeIn, String8(packageNameIn).string(), packageVersionCodeIn);
// Fast return to save disk read.
if (rollbackTypeIn != android::util::WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_SUCCESS
&& rollbackTypeIn !=
android::util::WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_INITIATE) {
return Status::ok();
}
bool readTrainInfoSuccess = false;
InstallTrainInfo trainInfoOnDisk;
readTrainInfoSuccess = StorageManager::readTrainInfo(trainInfoOnDisk);
if (!readTrainInfoSuccess) {
return Status::ok();
}
std::vector<int64_t> experimentIds = trainInfoOnDisk.experimentIds;
if (experimentIds.empty()) {
return Status::ok();
}
switch (rollbackTypeIn) {
case android::util::WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_INITIATE:
experimentIds.push_back(experimentIds[0] + 4);
break;
case android::util::WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_SUCCESS:
experimentIds.push_back(experimentIds[0] + 5);
break;
}
StorageManager::writeTrainInfo(trainInfoOnDisk.trainVersionCode, trainInfoOnDisk.trainName,
trainInfoOnDisk.status, experimentIds);
return Status::ok();
}
Status StatsService::getRegisteredExperimentIds(std::vector<int64_t>* experimentIdsOut) {
uid_t uid = IPCThreadState::self()->getCallingUid();
// Caller must be granted these permissions
if (!checkCallingPermission(String16(kPermissionDump))) {
return exception(binder::Status::EX_SECURITY,
StringPrintf("UID %d lacks permission %s", uid, kPermissionDump));
}
if (!checkCallingPermission(String16(kPermissionUsage))) {
return exception(binder::Status::EX_SECURITY,
StringPrintf("UID %d lacks permission %s", uid, kPermissionUsage));
}
// TODO: add verifier permission
// Read the latest train info
InstallTrainInfo trainInfo;
if (!StorageManager::readTrainInfo(trainInfo)) {
// No train info means no experiment IDs, return an empty list
experimentIdsOut->clear();
return Status::ok();
}
// Copy the experiment IDs to the out vector
experimentIdsOut->assign(trainInfo.experimentIds.begin(), trainInfo.experimentIds.end());
return Status::ok();
}
hardware::Return<void> StatsService::reportSpeakerImpedance(
const SpeakerImpedance& speakerImpedance) {
android::util::stats_write(android::util::SPEAKER_IMPEDANCE_REPORTED,
speakerImpedance.speakerLocation, speakerImpedance.milliOhms);
return hardware::Void();
}
hardware::Return<void> StatsService::reportHardwareFailed(const HardwareFailed& hardwareFailed) {
android::util::stats_write(android::util::HARDWARE_FAILED, int32_t(hardwareFailed.hardwareType),
hardwareFailed.hardwareLocation, int32_t(hardwareFailed.errorCode));
return hardware::Void();
}
hardware::Return<void> StatsService::reportPhysicalDropDetected(
const PhysicalDropDetected& physicalDropDetected) {
android::util::stats_write(android::util::PHYSICAL_DROP_DETECTED,
int32_t(physicalDropDetected.confidencePctg), physicalDropDetected.accelPeak,
physicalDropDetected.freefallDuration);
return hardware::Void();
}
hardware::Return<void> StatsService::reportChargeCycles(const ChargeCycles& chargeCycles) {
std::vector<int32_t> buckets = chargeCycles.cycleBucket;
int initialSize = buckets.size();
for (int i = 0; i < 10 - initialSize; i++) {
buckets.push_back(-1); // Push -1 for buckets that do not exist.
}
android::util::stats_write(android::util::CHARGE_CYCLES_REPORTED, buckets[0], buckets[1],
buckets[2], buckets[3], buckets[4], buckets[5], buckets[6], buckets[7], buckets[8],
buckets[9]);
return hardware::Void();
}
hardware::Return<void> StatsService::reportBatteryHealthSnapshot(
const BatteryHealthSnapshotArgs& batteryHealthSnapshotArgs) {
android::util::stats_write(android::util::BATTERY_HEALTH_SNAPSHOT,
int32_t(batteryHealthSnapshotArgs.type), batteryHealthSnapshotArgs.temperatureDeciC,
batteryHealthSnapshotArgs.voltageMicroV, batteryHealthSnapshotArgs.currentMicroA,
batteryHealthSnapshotArgs.openCircuitVoltageMicroV,
batteryHealthSnapshotArgs.resistanceMicroOhm, batteryHealthSnapshotArgs.levelPercent);
return hardware::Void();
}
hardware::Return<void> StatsService::reportSlowIo(const SlowIo& slowIo) {
android::util::stats_write(android::util::SLOW_IO, int32_t(slowIo.operation), slowIo.count);
return hardware::Void();
}
hardware::Return<void> StatsService::reportBatteryCausedShutdown(
const BatteryCausedShutdown& batteryCausedShutdown) {
android::util::stats_write(android::util::BATTERY_CAUSED_SHUTDOWN,
batteryCausedShutdown.voltageMicroV);
return hardware::Void();
}
hardware::Return<void> StatsService::reportUsbPortOverheatEvent(
const UsbPortOverheatEvent& usbPortOverheatEvent) {
android::util::stats_write(android::util::USB_PORT_OVERHEAT_EVENT_REPORTED,
usbPortOverheatEvent.plugTemperatureDeciC, usbPortOverheatEvent.maxTemperatureDeciC,
usbPortOverheatEvent.timeToOverheat, usbPortOverheatEvent.timeToHysteresis,
usbPortOverheatEvent.timeToInactive);
return hardware::Void();
}
hardware::Return<void> StatsService::reportSpeechDspStat(
const SpeechDspStat& speechDspStat) {
android::util::stats_write(android::util::SPEECH_DSP_STAT_REPORTED,
speechDspStat.totalUptimeMillis, speechDspStat.totalDowntimeMillis,
speechDspStat.totalCrashCount, speechDspStat.totalRecoverCount);
return hardware::Void();
}
hardware::Return<void> StatsService::reportVendorAtom(const VendorAtom& vendorAtom) {
std::string reverseDomainName = (std::string) vendorAtom.reverseDomainName;
if (vendorAtom.atomId < 100000 || vendorAtom.atomId >= 200000) {
ALOGE("Atom ID %ld is not a valid vendor atom ID", (long) vendorAtom.atomId);
return hardware::Void();
}
if (reverseDomainName.length() > 50) {
ALOGE("Vendor atom reverse domain name %s is too long.", reverseDomainName.c_str());
return hardware::Void();
}
LogEvent event(getWallClockSec() * NS_PER_SEC, getElapsedRealtimeNs(), vendorAtom);
mProcessor->OnLogEvent(&event);
return hardware::Void();
}
void StatsService::binderDied(const wp <IBinder>& who) {
ALOGW("statscompanion service died");
StatsdStats::getInstance().noteSystemServerRestart(getWallClockSec());
if (mProcessor != nullptr) {
ALOGW("Reset statsd upon system server restarts.");
int64_t systemServerRestartNs = getElapsedRealtimeNs();
ProtoOutputStream proto;
mProcessor->WriteActiveConfigsToProtoOutputStream(systemServerRestartNs,
STATSCOMPANION_DIED, &proto);
mProcessor->WriteDataToDisk(STATSCOMPANION_DIED, FAST);
mProcessor->resetConfigs();
std::string serializedActiveConfigs;
if (proto.serializeToString(&serializedActiveConfigs)) {
ActiveConfigList activeConfigs;
if (activeConfigs.ParseFromString(serializedActiveConfigs)) {
mProcessor->SetConfigsActiveState(activeConfigs, systemServerRestartNs);
}
}
}
mAnomalyAlarmMonitor->setStatsCompanionService(nullptr);
mPeriodicAlarmMonitor->setStatsCompanionService(nullptr);
SubscriberReporter::getInstance().setStatsCompanionService(nullptr);
mPullerManager->SetStatsCompanionService(nullptr);
}
} // namespace statsd
} // namespace os
} // namespace android