Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 1 | /* |
yro | 0feae94 | 2017-11-15 14:38:48 -0800 | [diff] [blame] | 2 | * Copyright (C) 2017 The Android Open Source Project |
Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Tej Singh | 484524a | 2018-02-01 15:10:05 -0800 | [diff] [blame] | 17 | #define DEBUG false // STOPSHIP if true |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 18 | #include "Log.h" |
Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 19 | |
| 20 | #include "StatsService.h" |
Yangster-mac | 330af58 | 2018-02-08 15:24:38 -0800 | [diff] [blame] | 21 | #include "stats_log_util.h" |
Yao Chen | 8d9989b | 2017-11-18 18:54:50 -0800 | [diff] [blame] | 22 | #include "android-base/stringprintf.h" |
David Chen | adaf8b3 | 2017-11-03 15:42:08 -0700 | [diff] [blame] | 23 | #include "config/ConfigKey.h" |
| 24 | #include "config/ConfigManager.h" |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 25 | #include "guardrail/StatsdStats.h" |
yro | 947fbce | 2017-11-15 22:50:23 -0800 | [diff] [blame] | 26 | #include "storage/StorageManager.h" |
Bookatz | c697797 | 2018-01-16 16:55:05 -0800 | [diff] [blame] | 27 | #include "subscriber/SubscriberReporter.h" |
Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 28 | |
David Chen | 0656b7a | 2017-09-13 15:53:39 -0700 | [diff] [blame] | 29 | #include <android-base/file.h> |
Tej Singh | 53f9dee | 2019-04-30 17:45:54 -0700 | [diff] [blame] | 30 | #include <android-base/strings.h> |
Chenjie Yu | 6b1667c | 2019-01-18 10:09:33 -0800 | [diff] [blame] | 31 | #include <cutils/multiuser.h> |
David Chen | 0656b7a | 2017-09-13 15:53:39 -0700 | [diff] [blame] | 32 | #include <frameworks/base/cmds/statsd/src/statsd_config.pb.h> |
Max Dashouk | 11e0d40 | 2019-05-16 16:58:07 -0700 | [diff] [blame] | 33 | #include <frameworks/base/cmds/statsd/src/uid_data.pb.h> |
Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 34 | #include <private/android_filesystem_config.h> |
Jeffrey Huang | 74fc435 | 2020-03-06 15:18:33 -0800 | [diff] [blame] | 35 | #include <statslog_statsd.h> |
Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 36 | #include <stdio.h> |
Yao Chen | 482d272 | 2017-09-12 13:25:43 -0700 | [diff] [blame] | 37 | #include <stdlib.h> |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 38 | #include <sys/system_properties.h> |
Yao Chen | ef99c4f | 2017-09-22 16:26:54 -0700 | [diff] [blame] | 39 | #include <unistd.h> |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 40 | #include <utils/String16.h> |
Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 41 | |
| 42 | using namespace android; |
| 43 | |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 44 | using android::base::StringPrintf; |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 45 | using android::util::FIELD_COUNT_REPEATED; |
| 46 | using android::util::FIELD_TYPE_MESSAGE; |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 47 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 48 | using Status = ::ndk::ScopedAStatus; |
| 49 | |
Bookatz | 906a35c | 2017-09-20 15:26:44 -0700 | [diff] [blame] | 50 | namespace android { |
| 51 | namespace os { |
| 52 | namespace statsd { |
| 53 | |
David Chen | adaf8b3 | 2017-11-03 15:42:08 -0700 | [diff] [blame] | 54 | constexpr const char* kPermissionDump = "android.permission.DUMP"; |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 55 | |
Tej Singh | 10458ec | 2020-03-17 11:04:02 -0700 | [diff] [blame] | 56 | constexpr const char* kPermissionRegisterPullAtom = "android.permission.REGISTER_STATS_PULL_ATOM"; |
| 57 | |
yro | 03faf09 | 2017-12-12 00:17:50 -0800 | [diff] [blame] | 58 | #define STATS_SERVICE_DIR "/data/misc/stats-service" |
David Chen | adaf8b3 | 2017-11-03 15:42:08 -0700 | [diff] [blame] | 59 | |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 60 | // for StatsDataDumpProto |
| 61 | const int FIELD_ID_REPORTS_LIST = 1; |
| 62 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 63 | static Status exception(int32_t code, const std::string& msg) { |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 64 | ALOGE("%s (%d)", msg.c_str(), code); |
Tej Singh | 10458ec | 2020-03-17 11:04:02 -0700 | [diff] [blame] | 65 | return Status::fromExceptionCodeWithMessage(code, msg.c_str()); |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 66 | } |
| 67 | |
Ruchir Rastogi | 0563e3b | 2020-01-28 17:43:13 -0800 | [diff] [blame] | 68 | static bool checkPermission(const char* permission) { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 69 | pid_t pid = AIBinder_getCallingPid(); |
| 70 | uid_t uid = AIBinder_getCallingUid(); |
Jonathan Nguyen | a0e6de1 | 2020-01-28 18:33:55 -0800 | [diff] [blame] | 71 | return checkPermissionForIds(permission, pid, uid); |
Ruchir Rastogi | 0563e3b | 2020-01-28 17:43:13 -0800 | [diff] [blame] | 72 | } |
| 73 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 74 | Status checkUid(uid_t expectedUid) { |
| 75 | uid_t uid = AIBinder_getCallingUid(); |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 76 | if (uid == expectedUid || uid == AID_ROOT) { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 77 | return Status::ok(); |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 78 | } else { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 79 | return exception(EX_SECURITY, |
| 80 | StringPrintf("UID %d is not expected UID %d", uid, expectedUid)); |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 81 | } |
| 82 | } |
| 83 | |
| 84 | #define ENFORCE_UID(uid) { \ |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 85 | Status status = checkUid((uid)); \ |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 86 | if (!status.isOk()) { \ |
| 87 | return status; \ |
| 88 | } \ |
| 89 | } |
| 90 | |
Yao Chen | 0f86186 | 2019-03-27 11:51:15 -0700 | [diff] [blame] | 91 | StatsService::StatsService(const sp<Looper>& handlerLooper, shared_ptr<LogEventQueue> queue) |
| 92 | : mAnomalyAlarmMonitor(new AlarmMonitor( |
| 93 | MIN_DIFF_TO_UPDATE_REGISTERED_ALARM_SECS, |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 94 | [](const shared_ptr<IStatsCompanionService>& sc, int64_t timeMillis) { |
Yao Chen | 0f86186 | 2019-03-27 11:51:15 -0700 | [diff] [blame] | 95 | if (sc != nullptr) { |
| 96 | sc->setAnomalyAlarm(timeMillis); |
| 97 | StatsdStats::getInstance().noteRegisteredAnomalyAlarmChanged(); |
| 98 | } |
| 99 | }, |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 100 | [](const shared_ptr<IStatsCompanionService>& sc) { |
Yao Chen | 0f86186 | 2019-03-27 11:51:15 -0700 | [diff] [blame] | 101 | if (sc != nullptr) { |
| 102 | sc->cancelAnomalyAlarm(); |
| 103 | StatsdStats::getInstance().noteRegisteredAnomalyAlarmChanged(); |
| 104 | } |
| 105 | })), |
| 106 | mPeriodicAlarmMonitor(new AlarmMonitor( |
| 107 | MIN_DIFF_TO_UPDATE_REGISTERED_ALARM_SECS, |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 108 | [](const shared_ptr<IStatsCompanionService>& sc, int64_t timeMillis) { |
Yao Chen | 0f86186 | 2019-03-27 11:51:15 -0700 | [diff] [blame] | 109 | if (sc != nullptr) { |
| 110 | sc->setAlarmForSubscriberTriggering(timeMillis); |
| 111 | StatsdStats::getInstance().noteRegisteredPeriodicAlarmChanged(); |
| 112 | } |
| 113 | }, |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 114 | [](const shared_ptr<IStatsCompanionService>& sc) { |
Yao Chen | 0f86186 | 2019-03-27 11:51:15 -0700 | [diff] [blame] | 115 | if (sc != nullptr) { |
| 116 | sc->cancelAlarmForSubscriberTriggering(); |
| 117 | StatsdStats::getInstance().noteRegisteredPeriodicAlarmChanged(); |
| 118 | } |
| 119 | })), |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 120 | mEventQueue(queue), |
Tej Singh | e678cb7 | 2020-04-14 16:23:30 -0700 | [diff] [blame] | 121 | mBootCompleteTrigger({kBootCompleteTag, kUidMapReceivedTag, kAllPullersRegisteredTag}, |
| 122 | [this]() { mProcessor->onStatsdInitCompleted(getElapsedRealtimeNs()); }), |
Tej Singh | 769f35f | 2020-04-11 03:39:12 -0700 | [diff] [blame] | 123 | mStatsCompanionServiceDeathRecipient( |
| 124 | AIBinder_DeathRecipient_new(StatsService::statsCompanionServiceDied)) { |
Yao Chen | 4ce0729 | 2019-02-13 13:06:36 -0800 | [diff] [blame] | 125 | mUidMap = UidMap::getInstance(); |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 126 | mPullerManager = new StatsPullerManager(); |
Chenjie Yu | 80f9112 | 2018-01-31 20:24:50 -0800 | [diff] [blame] | 127 | StatsPuller::SetUidMap(mUidMap); |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 128 | mConfigManager = new ConfigManager(); |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 129 | mProcessor = new StatsLogProcessor( |
| 130 | mUidMap, mPullerManager, mAnomalyAlarmMonitor, mPeriodicAlarmMonitor, |
Chenjie Yu | c7939cb | 2019-02-04 17:25:45 -0800 | [diff] [blame] | 131 | getElapsedRealtimeNs(), |
| 132 | [this](const ConfigKey& key) { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 133 | shared_ptr<IPendingIntentRef> receiver = mConfigManager->GetConfigReceiver(key); |
Jeffrey Huang | ad21374 | 2019-12-16 13:50:06 -0800 | [diff] [blame] | 134 | if (receiver == nullptr) { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 135 | VLOG("Could not find a broadcast receiver for %s", key.ToString().c_str()); |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 136 | return false; |
Jeffrey Huang | ad21374 | 2019-12-16 13:50:06 -0800 | [diff] [blame] | 137 | } else if (receiver->sendDataBroadcast( |
| 138 | mProcessor->getLastReportTimeNs(key)).isOk()) { |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 139 | return true; |
Jeffrey Huang | ad21374 | 2019-12-16 13:50:06 -0800 | [diff] [blame] | 140 | } else { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 141 | VLOG("Failed to send a broadcast for receiver %s", key.ToString().c_str()); |
Jeffrey Huang | ad21374 | 2019-12-16 13:50:06 -0800 | [diff] [blame] | 142 | return false; |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 143 | } |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 144 | }, |
| 145 | [this](const int& uid, const vector<int64_t>& activeConfigs) { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 146 | shared_ptr<IPendingIntentRef> receiver = |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 147 | mConfigManager->GetActiveConfigsChangedReceiver(uid); |
| 148 | if (receiver == nullptr) { |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 149 | VLOG("Could not find receiver for uid %d", uid); |
| 150 | return false; |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 151 | } else if (receiver->sendActiveConfigsChangedBroadcast(activeConfigs).isOk()) { |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 152 | VLOG("StatsService::active configs broadcast succeeded for uid %d" , uid); |
| 153 | return true; |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 154 | } else { |
| 155 | VLOG("StatsService::active configs broadcast failed for uid %d" , uid); |
| 156 | return false; |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 157 | } |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 158 | }); |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 159 | |
Tej Singh | 9ec159a | 2019-11-14 11:59:48 -0800 | [diff] [blame] | 160 | mUidMap->setListener(mProcessor); |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 161 | mConfigManager->AddListener(mProcessor); |
| 162 | |
| 163 | init_system_properties(); |
Yao Chen | 0f86186 | 2019-03-27 11:51:15 -0700 | [diff] [blame] | 164 | |
| 165 | if (mEventQueue != nullptr) { |
| 166 | std::thread pushedEventThread([this] { readLogs(); }); |
| 167 | pushedEventThread.detach(); |
| 168 | } |
Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 169 | } |
| 170 | |
Yao Chen | ef99c4f | 2017-09-22 16:26:54 -0700 | [diff] [blame] | 171 | StatsService::~StatsService() { |
Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 172 | } |
| 173 | |
Yao Chen | 0f86186 | 2019-03-27 11:51:15 -0700 | [diff] [blame] | 174 | /* Runs on a dedicated thread to process pushed events. */ |
| 175 | void StatsService::readLogs() { |
| 176 | // Read forever..... long live statsd |
| 177 | while (1) { |
| 178 | // Block until an event is available. |
| 179 | auto event = mEventQueue->waitPop(); |
| 180 | // Pass it to StatsLogProcess to all configs/metrics |
| 181 | // At this point, the LogEventQueue is not blocked, so that the socketListener |
| 182 | // can read events from the socket and write to buffer to avoid data drop. |
| 183 | mProcessor->OnLogEvent(event.get()); |
| 184 | // The ShellSubscriber is only used by shell for local debugging. |
| 185 | if (mShellSubscriber != nullptr) { |
| 186 | mShellSubscriber->onLogEvent(*event); |
| 187 | } |
| 188 | } |
| 189 | } |
| 190 | |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 191 | void StatsService::init_system_properties() { |
| 192 | mEngBuild = false; |
| 193 | const prop_info* buildType = __system_property_find("ro.build.type"); |
| 194 | if (buildType != NULL) { |
| 195 | __system_property_read_callback(buildType, init_build_type_callback, this); |
| 196 | } |
David Chen | 0656b7a | 2017-09-13 15:53:39 -0700 | [diff] [blame] | 197 | } |
| 198 | |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 199 | void StatsService::init_build_type_callback(void* cookie, const char* /*name*/, const char* value, |
| 200 | uint32_t serial) { |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 201 | if (0 == strcmp("eng", value) || 0 == strcmp("userdebug", value)) { |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 202 | reinterpret_cast<StatsService*>(cookie)->mEngBuild = true; |
| 203 | } |
| 204 | } |
| 205 | |
| 206 | /** |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 207 | * Write data from statsd. |
| 208 | * Format for statsdStats: adb shell dumpsys stats --metadata [-v] [--proto] |
| 209 | * Format for data report: adb shell dumpsys stats [anything other than --metadata] [--proto] |
| 210 | * Anything ending in --proto will be in proto format. |
| 211 | * Anything without --metadata as the first argument will be report information. |
| 212 | * (bugreports call "adb shell dumpsys stats --dump-priority NORMAL -a --proto") |
| 213 | * TODO: Come up with a more robust method of enacting <serviceutils/PriorityDumper.h>. |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 214 | */ |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 215 | status_t StatsService::dump(int fd, const char** args, uint32_t numArgs) { |
Ruchir Rastogi | 0563e3b | 2020-01-28 17:43:13 -0800 | [diff] [blame] | 216 | if (!checkPermission(kPermissionDump)) { |
Tej Singh | dd83d70 | 2018-04-10 17:24:50 -0700 | [diff] [blame] | 217 | return PERMISSION_DENIED; |
| 218 | } |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 219 | |
| 220 | int lastArg = numArgs - 1; |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 221 | bool asProto = false; |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 222 | if (lastArg >= 0 && string(args[lastArg]) == "--proto") { // last argument |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 223 | asProto = true; |
| 224 | lastArg--; |
Yao Chen | 884c8c1 | 2018-01-26 10:36:25 -0800 | [diff] [blame] | 225 | } |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 226 | if (numArgs > 0 && string(args[0]) == "--metadata") { // first argument |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 227 | // Request is to dump statsd stats. |
| 228 | bool verbose = false; |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 229 | if (lastArg >= 0 && string(args[lastArg]) == "-v") { |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 230 | verbose = true; |
| 231 | lastArg--; |
| 232 | } |
| 233 | dumpStatsdStats(fd, verbose, asProto); |
| 234 | } else { |
| 235 | // Request is to dump statsd report data. |
| 236 | if (asProto) { |
| 237 | dumpIncidentSection(fd); |
| 238 | } else { |
| 239 | dprintf(fd, "Non-proto format of stats data dump not available; see proto version.\n"); |
| 240 | } |
Tej Singh | 41b3f9a | 2018-04-03 17:06:35 -0700 | [diff] [blame] | 241 | } |
Yao Chen | 884c8c1 | 2018-01-26 10:36:25 -0800 | [diff] [blame] | 242 | |
Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 243 | return NO_ERROR; |
| 244 | } |
| 245 | |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 246 | /** |
Tej Singh | 41b3f9a | 2018-04-03 17:06:35 -0700 | [diff] [blame] | 247 | * Write debugging data about statsd in text or proto format. |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 248 | */ |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 249 | void StatsService::dumpStatsdStats(int out, bool verbose, bool proto) { |
Tej Singh | 41b3f9a | 2018-04-03 17:06:35 -0700 | [diff] [blame] | 250 | if (proto) { |
| 251 | vector<uint8_t> data; |
| 252 | StatsdStats::getInstance().dumpStats(&data, false); // does not reset statsdStats. |
| 253 | for (size_t i = 0; i < data.size(); i ++) { |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 254 | dprintf(out, "%c", data[i]); |
Tej Singh | 41b3f9a | 2018-04-03 17:06:35 -0700 | [diff] [blame] | 255 | } |
| 256 | } else { |
| 257 | StatsdStats::getInstance().dumpStats(out); |
| 258 | mProcessor->dumpStates(out, verbose); |
| 259 | } |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 260 | } |
| 261 | |
| 262 | /** |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 263 | * Write stats report data in StatsDataDumpProto incident section format. |
| 264 | */ |
| 265 | void StatsService::dumpIncidentSection(int out) { |
| 266 | ProtoOutputStream proto; |
| 267 | for (const ConfigKey& configKey : mConfigManager->GetAllConfigKeys()) { |
| 268 | uint64_t reportsListToken = |
| 269 | proto.start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_REPORTS_LIST); |
| 270 | mProcessor->onDumpReport(configKey, getElapsedRealtimeNs(), |
| 271 | true /* includeCurrentBucket */, false /* erase_data */, |
Olivier Gaillard | 6c75ecd | 2019-02-20 09:57:33 +0000 | [diff] [blame] | 272 | ADB_DUMP, |
| 273 | FAST, |
| 274 | &proto); |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 275 | proto.end(reportsListToken); |
| 276 | proto.flush(out); |
Bookatz | c71d901 | 2018-12-19 12:28:38 -0800 | [diff] [blame] | 277 | proto.clear(); |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 278 | } |
| 279 | } |
| 280 | |
| 281 | /** |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 282 | * Implementation of the adb shell cmd stats command. |
| 283 | */ |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 284 | status_t StatsService::handleShellCommand(int in, int out, int err, const char** argv, |
| 285 | uint32_t argc) { |
| 286 | uid_t uid = AIBinder_getCallingUid(); |
Stanislav Zholnin | d7674c2 | 2020-02-17 17:48:12 +0000 | [diff] [blame] | 287 | if (uid != AID_ROOT && uid != AID_SHELL) { |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 288 | return PERMISSION_DENIED; |
| 289 | } |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 290 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 291 | Vector<String8> utf8Args; |
| 292 | utf8Args.setCapacity(argc); |
| 293 | for (uint32_t i = 0; i < argc; i++) { |
| 294 | utf8Args.push(String8(argv[i])); |
| 295 | } |
| 296 | |
| 297 | if (argc >= 1) { |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 298 | // adb shell cmd stats config ... |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 299 | if (!utf8Args[0].compare(String8("config"))) { |
| 300 | return cmd_config(in, out, err, utf8Args); |
David Chen | 0656b7a | 2017-09-13 15:53:39 -0700 | [diff] [blame] | 301 | } |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 302 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 303 | if (!utf8Args[0].compare(String8("print-uid-map"))) { |
| 304 | return cmd_print_uid_map(out, utf8Args); |
David Chen | de70169 | 2017-10-05 13:16:02 -0700 | [diff] [blame] | 305 | } |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 306 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 307 | if (!utf8Args[0].compare(String8("dump-report"))) { |
| 308 | return cmd_dump_report(out, utf8Args); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 309 | } |
David Chen | 1481fe1 | 2017-10-16 13:16:34 -0700 | [diff] [blame] | 310 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 311 | if (!utf8Args[0].compare(String8("pull-source")) && argc > 1) { |
| 312 | return cmd_print_pulled_metrics(out, utf8Args); |
David Chen | 1481fe1 | 2017-10-16 13:16:34 -0700 | [diff] [blame] | 313 | } |
David Chen | adaf8b3 | 2017-11-03 15:42:08 -0700 | [diff] [blame] | 314 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 315 | if (!utf8Args[0].compare(String8("send-broadcast"))) { |
| 316 | return cmd_trigger_broadcast(out, utf8Args); |
David Chen | 1d7b0cd | 2017-11-15 14:20:04 -0800 | [diff] [blame] | 317 | } |
| 318 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 319 | if (!utf8Args[0].compare(String8("print-stats"))) { |
| 320 | return cmd_print_stats(out, utf8Args); |
David Chen | adaf8b3 | 2017-11-03 15:42:08 -0700 | [diff] [blame] | 321 | } |
yro | 87d983c | 2017-11-14 21:31:43 -0800 | [diff] [blame] | 322 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 323 | if (!utf8Args[0].compare(String8("meminfo"))) { |
Yao Chen | 8d9989b | 2017-11-18 18:54:50 -0800 | [diff] [blame] | 324 | return cmd_dump_memory_info(out); |
| 325 | } |
yro | 947fbce | 2017-11-15 22:50:23 -0800 | [diff] [blame] | 326 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 327 | if (!utf8Args[0].compare(String8("write-to-disk"))) { |
yro | 947fbce | 2017-11-15 22:50:23 -0800 | [diff] [blame] | 328 | return cmd_write_data_to_disk(out); |
| 329 | } |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 330 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 331 | if (!utf8Args[0].compare(String8("log-app-breadcrumb"))) { |
| 332 | return cmd_log_app_breadcrumb(out, utf8Args); |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 333 | } |
Chenjie Yu | fa22d65 | 2018-02-05 14:37:48 -0800 | [diff] [blame] | 334 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 335 | if (!utf8Args[0].compare(String8("log-binary-push"))) { |
| 336 | return cmd_log_binary_push(out, utf8Args); |
Tej Singh | 53f9dee | 2019-04-30 17:45:54 -0700 | [diff] [blame] | 337 | } |
| 338 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 339 | if (!utf8Args[0].compare(String8("clear-puller-cache"))) { |
Chenjie Yu | fa22d65 | 2018-02-05 14:37:48 -0800 | [diff] [blame] | 340 | return cmd_clear_puller_cache(out); |
| 341 | } |
Yao Chen | 876889c | 2018-05-02 11:16:16 -0700 | [diff] [blame] | 342 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 343 | if (!utf8Args[0].compare(String8("print-logs"))) { |
| 344 | return cmd_print_logs(out, utf8Args); |
Yao Chen | 876889c | 2018-05-02 11:16:16 -0700 | [diff] [blame] | 345 | } |
Ruchir Rastogi | e92edba | 2020-04-22 15:37:32 -0700 | [diff] [blame] | 346 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 347 | if (!utf8Args[0].compare(String8("send-active-configs"))) { |
| 348 | return cmd_trigger_active_config_broadcast(out, utf8Args); |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 349 | } |
Ruchir Rastogi | e92edba | 2020-04-22 15:37:32 -0700 | [diff] [blame] | 350 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 351 | if (!utf8Args[0].compare(String8("data-subscribe"))) { |
Tej Singh | c9250ce | 2019-09-20 19:28:53 -0700 | [diff] [blame] | 352 | { |
| 353 | std::lock_guard<std::mutex> lock(mShellSubscriberMutex); |
| 354 | if (mShellSubscriber == nullptr) { |
| 355 | mShellSubscriber = new ShellSubscriber(mUidMap, mPullerManager); |
| 356 | } |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 357 | } |
Yao Chen | 35cb8d6 | 2019-01-03 16:49:14 -0800 | [diff] [blame] | 358 | int timeoutSec = -1; |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 359 | if (argc >= 2) { |
| 360 | timeoutSec = atoi(utf8Args[1].c_str()); |
Yao Chen | 35cb8d6 | 2019-01-03 16:49:14 -0800 | [diff] [blame] | 361 | } |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 362 | mShellSubscriber->startNewSubscription(in, out, timeoutSec); |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 363 | return NO_ERROR; |
| 364 | } |
Joe Onorato | 2cbc2cc | 2017-08-30 17:03:23 -0700 | [diff] [blame] | 365 | } |
Joe Onorato | 2cbc2cc | 2017-08-30 17:03:23 -0700 | [diff] [blame] | 366 | |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 367 | print_cmd_help(out); |
Joe Onorato | 2cbc2cc | 2017-08-30 17:03:23 -0700 | [diff] [blame] | 368 | return NO_ERROR; |
| 369 | } |
| 370 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 371 | void StatsService::print_cmd_help(int out) { |
| 372 | dprintf(out, |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 373 | "usage: adb shell cmd stats print-stats-log [tag_required] " |
| 374 | "[timestamp_nsec_optional]\n"); |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 375 | dprintf(out, "\n"); |
| 376 | dprintf(out, "\n"); |
| 377 | dprintf(out, "usage: adb shell cmd stats meminfo\n"); |
| 378 | dprintf(out, "\n"); |
| 379 | dprintf(out, " Prints the malloc debug information. You need to run the following first: \n"); |
| 380 | dprintf(out, " # adb shell stop\n"); |
| 381 | dprintf(out, " # adb shell setprop libc.debug.malloc.program statsd \n"); |
| 382 | dprintf(out, " # adb shell setprop libc.debug.malloc.options backtrace \n"); |
| 383 | dprintf(out, " # adb shell start\n"); |
| 384 | dprintf(out, "\n"); |
| 385 | dprintf(out, "\n"); |
| 386 | dprintf(out, "usage: adb shell cmd stats print-uid-map [PKG]\n"); |
| 387 | dprintf(out, "\n"); |
| 388 | dprintf(out, " Prints the UID, app name, version mapping.\n"); |
| 389 | dprintf(out, " PKG Optional package name to print the uids of the package\n"); |
| 390 | dprintf(out, "\n"); |
| 391 | dprintf(out, "\n"); |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 392 | dprintf(out, "usage: adb shell cmd stats pull-source ATOM_TAG [PACKAGE] \n"); |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 393 | dprintf(out, "\n"); |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 394 | dprintf(out, " Prints the output of a pulled atom\n"); |
| 395 | dprintf(out, " UID The atom to pull\n"); |
| 396 | dprintf(out, " PACKAGE The package to pull from. Default is AID_SYSTEM\n"); |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 397 | dprintf(out, "\n"); |
| 398 | dprintf(out, "\n"); |
| 399 | dprintf(out, "usage: adb shell cmd stats write-to-disk \n"); |
| 400 | dprintf(out, "\n"); |
| 401 | dprintf(out, " Flushes all data on memory to disk.\n"); |
| 402 | dprintf(out, "\n"); |
| 403 | dprintf(out, "\n"); |
| 404 | dprintf(out, "usage: adb shell cmd stats log-app-breadcrumb [UID] LABEL STATE\n"); |
| 405 | dprintf(out, " Writes an AppBreadcrumbReported event to the statslog buffer.\n"); |
| 406 | dprintf(out, " UID The uid to use. It is only possible to pass a UID\n"); |
| 407 | dprintf(out, " parameter on eng builds. If UID is omitted the calling\n"); |
| 408 | dprintf(out, " uid is used.\n"); |
| 409 | dprintf(out, " LABEL Integer in [0, 15], as per atoms.proto.\n"); |
| 410 | dprintf(out, " STATE Integer in [0, 3], as per atoms.proto.\n"); |
| 411 | dprintf(out, "\n"); |
| 412 | dprintf(out, "\n"); |
Tej Singh | 53f9dee | 2019-04-30 17:45:54 -0700 | [diff] [blame] | 413 | dprintf(out, |
| 414 | "usage: adb shell cmd stats log-binary-push NAME VERSION STAGING ROLLBACK_ENABLED " |
| 415 | "LOW_LATENCY STATE EXPERIMENT_IDS\n"); |
| 416 | dprintf(out, " Log a binary push state changed event.\n"); |
| 417 | dprintf(out, " NAME The train name.\n"); |
| 418 | dprintf(out, " VERSION The train version code.\n"); |
| 419 | dprintf(out, " STAGING If this train requires a restart.\n"); |
| 420 | dprintf(out, " ROLLBACK_ENABLED If rollback should be enabled for this install.\n"); |
| 421 | dprintf(out, " LOW_LATENCY If the train requires low latency monitoring.\n"); |
| 422 | dprintf(out, " STATE The status of the train push.\n"); |
| 423 | dprintf(out, " Integer value of the enum in atoms.proto.\n"); |
| 424 | dprintf(out, " EXPERIMENT_IDS Comma separated list of experiment ids.\n"); |
| 425 | dprintf(out, " Leave blank for none.\n"); |
| 426 | dprintf(out, "\n"); |
| 427 | dprintf(out, "\n"); |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 428 | dprintf(out, "usage: adb shell cmd stats config remove [UID] [NAME]\n"); |
| 429 | dprintf(out, "usage: adb shell cmd stats config update [UID] NAME\n"); |
| 430 | dprintf(out, "\n"); |
| 431 | dprintf(out, " Adds, updates or removes a configuration. The proto should be in\n"); |
| 432 | dprintf(out, " wire-encoded protobuf format and passed via stdin. If no UID and name is\n"); |
| 433 | dprintf(out, " provided, then all configs will be removed from memory and disk.\n"); |
| 434 | dprintf(out, "\n"); |
| 435 | dprintf(out, " UID The uid to use. It is only possible to pass the UID\n"); |
| 436 | dprintf(out, " parameter on eng builds. If UID is omitted the calling\n"); |
| 437 | dprintf(out, " uid is used.\n"); |
| 438 | dprintf(out, " NAME The per-uid name to use\n"); |
| 439 | dprintf(out, "\n"); |
| 440 | dprintf(out, "\n *Note: If both UID and NAME are omitted then all configs will\n"); |
| 441 | dprintf(out, "\n be removed from memory and disk!\n"); |
| 442 | dprintf(out, "\n"); |
| 443 | dprintf(out, |
Bookatz | 3e90658 | 2018-12-10 17:26:58 -0800 | [diff] [blame] | 444 | "usage: adb shell cmd stats dump-report [UID] NAME [--keep_data] " |
| 445 | "[--include_current_bucket] [--proto]\n"); |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 446 | dprintf(out, " Dump all metric data for a configuration.\n"); |
| 447 | dprintf(out, " UID The uid of the configuration. It is only possible to pass\n"); |
| 448 | dprintf(out, " the UID parameter on eng builds. If UID is omitted the\n"); |
| 449 | dprintf(out, " calling uid is used.\n"); |
| 450 | dprintf(out, " NAME The name of the configuration\n"); |
Bookatz | 3e90658 | 2018-12-10 17:26:58 -0800 | [diff] [blame] | 451 | dprintf(out, " --keep_data Do NOT erase the data upon dumping it.\n"); |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 452 | dprintf(out, " --proto Print proto binary.\n"); |
| 453 | dprintf(out, "\n"); |
| 454 | dprintf(out, "\n"); |
| 455 | dprintf(out, "usage: adb shell cmd stats send-broadcast [UID] NAME\n"); |
| 456 | dprintf(out, " Send a broadcast that triggers the subscriber to fetch metrics.\n"); |
| 457 | dprintf(out, " UID The uid of the configuration. It is only possible to pass\n"); |
| 458 | dprintf(out, " the UID parameter on eng builds. If UID is omitted the\n"); |
| 459 | dprintf(out, " calling uid is used.\n"); |
| 460 | dprintf(out, " NAME The name of the configuration\n"); |
| 461 | dprintf(out, "\n"); |
| 462 | dprintf(out, "\n"); |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 463 | dprintf(out, |
| 464 | "usage: adb shell cmd stats send-active-configs [--uid=UID] [--configs] " |
| 465 | "[NAME1] [NAME2] [NAME3..]\n"); |
| 466 | dprintf(out, " Send a broadcast that informs the subscriber of the current active configs.\n"); |
| 467 | dprintf(out, " --uid=UID The uid of the configurations. It is only possible to pass\n"); |
| 468 | dprintf(out, " the UID parameter on eng builds. If UID is omitted the\n"); |
| 469 | dprintf(out, " calling uid is used.\n"); |
| 470 | dprintf(out, " --configs Send the list of configs in the name list instead of\n"); |
| 471 | dprintf(out, " the currently active configs\n"); |
| 472 | dprintf(out, " NAME LIST List of configuration names to be included in the broadcast.\n"); |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 473 | dprintf(out, "\n"); |
| 474 | dprintf(out, "\n"); |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 475 | dprintf(out, "usage: adb shell cmd stats print-stats\n"); |
| 476 | dprintf(out, " Prints some basic stats.\n"); |
| 477 | dprintf(out, " --proto Print proto binary instead of string format.\n"); |
| 478 | dprintf(out, "\n"); |
| 479 | dprintf(out, "\n"); |
| 480 | dprintf(out, "usage: adb shell cmd stats clear-puller-cache\n"); |
| 481 | dprintf(out, " Clear cached puller data.\n"); |
| 482 | dprintf(out, "\n"); |
| 483 | dprintf(out, "usage: adb shell cmd stats print-logs\n"); |
| 484 | dprintf(out, " Only works on eng build\n"); |
David Chen | adaf8b3 | 2017-11-03 15:42:08 -0700 | [diff] [blame] | 485 | } |
| 486 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 487 | status_t StatsService::cmd_trigger_broadcast(int out, Vector<String8>& args) { |
David Chen | 1d7b0cd | 2017-11-15 14:20:04 -0800 | [diff] [blame] | 488 | string name; |
| 489 | bool good = false; |
| 490 | int uid; |
| 491 | const int argCount = args.size(); |
| 492 | if (argCount == 2) { |
| 493 | // Automatically pick the UID |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 494 | uid = AIBinder_getCallingUid(); |
David Chen | 1d7b0cd | 2017-11-15 14:20:04 -0800 | [diff] [blame] | 495 | name.assign(args[1].c_str(), args[1].size()); |
| 496 | good = true; |
| 497 | } else if (argCount == 3) { |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 498 | good = getUidFromArgs(args, 1, uid); |
| 499 | if (!good) { |
| 500 | dprintf(out, "Invalid UID. Note that the metrics can only be dumped for " |
| 501 | "other UIDs on eng or userdebug builds.\n"); |
David Chen | 1d7b0cd | 2017-11-15 14:20:04 -0800 | [diff] [blame] | 502 | } |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 503 | name.assign(args[2].c_str(), args[2].size()); |
David Chen | 1d7b0cd | 2017-11-15 14:20:04 -0800 | [diff] [blame] | 504 | } |
| 505 | if (!good) { |
| 506 | print_cmd_help(out); |
| 507 | return UNKNOWN_ERROR; |
| 508 | } |
David Chen | d37bc23 | 2018-04-12 18:05:11 -0700 | [diff] [blame] | 509 | ConfigKey key(uid, StrToInt64(name)); |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 510 | shared_ptr<IPendingIntentRef> receiver = mConfigManager->GetConfigReceiver(key); |
Jeffrey Huang | ad21374 | 2019-12-16 13:50:06 -0800 | [diff] [blame] | 511 | if (receiver == nullptr) { |
| 512 | VLOG("Could not find receiver for %s, %s", args[1].c_str(), args[2].c_str()); |
| 513 | return UNKNOWN_ERROR; |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 514 | } else if (receiver->sendDataBroadcast(mProcessor->getLastReportTimeNs(key)).isOk()) { |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 515 | VLOG("StatsService::trigger broadcast succeeded to %s, %s", args[1].c_str(), |
| 516 | args[2].c_str()); |
Jeffrey Huang | ad21374 | 2019-12-16 13:50:06 -0800 | [diff] [blame] | 517 | } else { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 518 | VLOG("StatsService::trigger broadcast failed to %s, %s", args[1].c_str(), args[2].c_str()); |
Jeffrey Huang | ad21374 | 2019-12-16 13:50:06 -0800 | [diff] [blame] | 519 | return UNKNOWN_ERROR; |
yro | 4d889e6 | 2017-11-17 15:44:48 -0800 | [diff] [blame] | 520 | } |
David Chen | adaf8b3 | 2017-11-03 15:42:08 -0700 | [diff] [blame] | 521 | return NO_ERROR; |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 522 | } |
| 523 | |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 524 | status_t StatsService::cmd_trigger_active_config_broadcast(int out, Vector<String8>& args) { |
| 525 | const int argCount = args.size(); |
| 526 | int uid; |
| 527 | vector<int64_t> configIds; |
| 528 | if (argCount == 1) { |
| 529 | // Automatically pick the uid and send a broadcast that has no active configs. |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 530 | uid = AIBinder_getCallingUid(); |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 531 | mProcessor->GetActiveConfigs(uid, configIds); |
| 532 | } else { |
| 533 | int curArg = 1; |
| 534 | if(args[curArg].find("--uid=") == 0) { |
| 535 | string uidArgStr(args[curArg].c_str()); |
| 536 | string uidStr = uidArgStr.substr(6); |
| 537 | if (!getUidFromString(uidStr.c_str(), uid)) { |
| 538 | dprintf(out, "Invalid UID. Note that the config can only be set for " |
| 539 | "other UIDs on eng or userdebug builds.\n"); |
| 540 | return UNKNOWN_ERROR; |
| 541 | } |
| 542 | curArg++; |
| 543 | } else { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 544 | uid = AIBinder_getCallingUid(); |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 545 | } |
| 546 | if (curArg == argCount || args[curArg] != "--configs") { |
| 547 | VLOG("Reached end of args, or specify configs not set. Sending actual active configs,"); |
| 548 | mProcessor->GetActiveConfigs(uid, configIds); |
| 549 | } else { |
| 550 | // Flag specified, use the given list of configs. |
| 551 | curArg++; |
| 552 | for (int i = curArg; i < argCount; i++) { |
| 553 | char* endp; |
| 554 | int64_t configID = strtoll(args[i].c_str(), &endp, 10); |
| 555 | if (endp == args[i].c_str() || *endp != '\0') { |
| 556 | dprintf(out, "Error parsing config ID.\n"); |
| 557 | return UNKNOWN_ERROR; |
| 558 | } |
| 559 | VLOG("Adding config id %ld", static_cast<long>(configID)); |
| 560 | configIds.push_back(configID); |
| 561 | } |
| 562 | } |
| 563 | } |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 564 | shared_ptr<IPendingIntentRef> receiver = mConfigManager->GetActiveConfigsChangedReceiver(uid); |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 565 | if (receiver == nullptr) { |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 566 | VLOG("Could not find receiver for uid %d", uid); |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 567 | return UNKNOWN_ERROR; |
| 568 | } else if (receiver->sendActiveConfigsChangedBroadcast(configIds).isOk()) { |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 569 | VLOG("StatsService::trigger active configs changed broadcast succeeded for uid %d" , uid); |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 570 | } else { |
| 571 | VLOG("StatsService::trigger active configs changed broadcast failed for uid %d", uid); |
| 572 | return UNKNOWN_ERROR; |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 573 | } |
| 574 | return NO_ERROR; |
| 575 | } |
| 576 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 577 | status_t StatsService::cmd_config(int in, int out, int err, Vector<String8>& args) { |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 578 | const int argCount = args.size(); |
| 579 | if (argCount >= 2) { |
| 580 | if (args[1] == "update" || args[1] == "remove") { |
| 581 | bool good = false; |
| 582 | int uid = -1; |
| 583 | string name; |
| 584 | |
| 585 | if (argCount == 3) { |
| 586 | // Automatically pick the UID |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 587 | uid = AIBinder_getCallingUid(); |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 588 | name.assign(args[2].c_str(), args[2].size()); |
| 589 | good = true; |
| 590 | } else if (argCount == 4) { |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 591 | good = getUidFromArgs(args, 2, uid); |
| 592 | if (!good) { |
| 593 | dprintf(err, "Invalid UID. Note that the config can only be set for " |
| 594 | "other UIDs on eng or userdebug builds.\n"); |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 595 | } |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 596 | name.assign(args[3].c_str(), args[3].size()); |
yro | e5f8292 | 2018-01-22 18:37:27 -0800 | [diff] [blame] | 597 | } else if (argCount == 2 && args[1] == "remove") { |
| 598 | good = true; |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 599 | } |
| 600 | |
| 601 | if (!good) { |
| 602 | // If arg parsing failed, print the help text and return an error. |
| 603 | print_cmd_help(out); |
| 604 | return UNKNOWN_ERROR; |
| 605 | } |
| 606 | |
| 607 | if (args[1] == "update") { |
yro | 255f72e | 2018-02-26 15:15:17 -0800 | [diff] [blame] | 608 | char* endp; |
| 609 | int64_t configID = strtoll(name.c_str(), &endp, 10); |
| 610 | if (endp == name.c_str() || *endp != '\0') { |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 611 | dprintf(err, "Error parsing config ID.\n"); |
yro | 255f72e | 2018-02-26 15:15:17 -0800 | [diff] [blame] | 612 | return UNKNOWN_ERROR; |
| 613 | } |
| 614 | |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 615 | // Read stream into buffer. |
| 616 | string buffer; |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 617 | if (!android::base::ReadFdToString(in, &buffer)) { |
| 618 | dprintf(err, "Error reading stream for StatsConfig.\n"); |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 619 | return UNKNOWN_ERROR; |
| 620 | } |
| 621 | |
| 622 | // Parse buffer. |
| 623 | StatsdConfig config; |
| 624 | if (!config.ParseFromString(buffer)) { |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 625 | dprintf(err, "Error parsing proto stream for StatsConfig.\n"); |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 626 | return UNKNOWN_ERROR; |
| 627 | } |
| 628 | |
| 629 | // Add / update the config. |
yro | 255f72e | 2018-02-26 15:15:17 -0800 | [diff] [blame] | 630 | mConfigManager->UpdateConfig(ConfigKey(uid, configID), config); |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 631 | } else { |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 632 | if (argCount == 2) { |
| 633 | cmd_remove_all_configs(out); |
| 634 | } else { |
| 635 | // Remove the config. |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 636 | mConfigManager->RemoveConfig(ConfigKey(uid, StrToInt64(name))); |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 637 | } |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 638 | } |
| 639 | |
| 640 | return NO_ERROR; |
| 641 | } |
David Chen | 0656b7a | 2017-09-13 15:53:39 -0700 | [diff] [blame] | 642 | } |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 643 | print_cmd_help(out); |
| 644 | return UNKNOWN_ERROR; |
| 645 | } |
| 646 | |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 647 | status_t StatsService::cmd_dump_report(int out, const Vector<String8>& args) { |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 648 | if (mProcessor != nullptr) { |
Chenjie Yu | b236c86 | 2017-11-28 22:20:44 -0800 | [diff] [blame] | 649 | int argCount = args.size(); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 650 | bool good = false; |
Chenjie Yu | b236c86 | 2017-11-28 22:20:44 -0800 | [diff] [blame] | 651 | bool proto = false; |
Chenjie Yu | bd1a28f | 2018-07-17 14:55:19 -0700 | [diff] [blame] | 652 | bool includeCurrentBucket = false; |
Bookatz | 3e90658 | 2018-12-10 17:26:58 -0800 | [diff] [blame] | 653 | bool eraseData = true; |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 654 | int uid; |
| 655 | string name; |
Chenjie Yu | b236c86 | 2017-11-28 22:20:44 -0800 | [diff] [blame] | 656 | if (!std::strcmp("--proto", args[argCount-1].c_str())) { |
| 657 | proto = true; |
| 658 | argCount -= 1; |
| 659 | } |
Chenjie Yu | bd1a28f | 2018-07-17 14:55:19 -0700 | [diff] [blame] | 660 | if (!std::strcmp("--include_current_bucket", args[argCount-1].c_str())) { |
| 661 | includeCurrentBucket = true; |
| 662 | argCount -= 1; |
| 663 | } |
Bookatz | 3e90658 | 2018-12-10 17:26:58 -0800 | [diff] [blame] | 664 | if (!std::strcmp("--keep_data", args[argCount-1].c_str())) { |
| 665 | eraseData = false; |
| 666 | argCount -= 1; |
| 667 | } |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 668 | if (argCount == 2) { |
| 669 | // Automatically pick the UID |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 670 | uid = AIBinder_getCallingUid(); |
Yao Chen | 5154a37 | 2017-10-30 22:57:06 -0700 | [diff] [blame] | 671 | name.assign(args[1].c_str(), args[1].size()); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 672 | good = true; |
| 673 | } else if (argCount == 3) { |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 674 | good = getUidFromArgs(args, 1, uid); |
| 675 | if (!good) { |
| 676 | dprintf(out, "Invalid UID. Note that the metrics can only be dumped for " |
| 677 | "other UIDs on eng or userdebug builds.\n"); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 678 | } |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 679 | name.assign(args[2].c_str(), args[2].size()); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 680 | } |
| 681 | if (good) { |
David Chen | 1d7b0cd | 2017-11-15 14:20:04 -0800 | [diff] [blame] | 682 | vector<uint8_t> data; |
David Chen | 926fc75 | 2018-02-23 13:31:43 -0800 | [diff] [blame] | 683 | mProcessor->onDumpReport(ConfigKey(uid, StrToInt64(name)), getElapsedRealtimeNs(), |
Olivier Gaillard | 6c75ecd | 2019-02-20 09:57:33 +0000 | [diff] [blame] | 684 | includeCurrentBucket, eraseData, ADB_DUMP, |
| 685 | NO_TIME_CONSTRAINTS, |
| 686 | &data); |
Chenjie Yu | b236c86 | 2017-11-28 22:20:44 -0800 | [diff] [blame] | 687 | if (proto) { |
| 688 | for (size_t i = 0; i < data.size(); i ++) { |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 689 | dprintf(out, "%c", data[i]); |
Chenjie Yu | b236c86 | 2017-11-28 22:20:44 -0800 | [diff] [blame] | 690 | } |
| 691 | } else { |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 692 | dprintf(out, "Non-proto stats data dump not currently supported.\n"); |
Chenjie Yu | b236c86 | 2017-11-28 22:20:44 -0800 | [diff] [blame] | 693 | } |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 694 | return android::OK; |
| 695 | } else { |
| 696 | // If arg parsing failed, print the help text and return an error. |
| 697 | print_cmd_help(out); |
| 698 | return UNKNOWN_ERROR; |
| 699 | } |
| 700 | } else { |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 701 | dprintf(out, "Log processor does not exist...\n"); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 702 | return UNKNOWN_ERROR; |
| 703 | } |
| 704 | } |
| 705 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 706 | status_t StatsService::cmd_print_stats(int out, const Vector<String8>& args) { |
Tej Singh | 41b3f9a | 2018-04-03 17:06:35 -0700 | [diff] [blame] | 707 | int argCount = args.size(); |
| 708 | bool proto = false; |
| 709 | if (!std::strcmp("--proto", args[argCount-1].c_str())) { |
| 710 | proto = true; |
| 711 | argCount -= 1; |
David Chen | 1d7b0cd | 2017-11-15 14:20:04 -0800 | [diff] [blame] | 712 | } |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 713 | StatsdStats& statsdStats = StatsdStats::getInstance(); |
Tej Singh | 41b3f9a | 2018-04-03 17:06:35 -0700 | [diff] [blame] | 714 | if (proto) { |
| 715 | vector<uint8_t> data; |
| 716 | statsdStats.dumpStats(&data, false); // does not reset statsdStats. |
| 717 | for (size_t i = 0; i < data.size(); i ++) { |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 718 | dprintf(out, "%c", data[i]); |
Tej Singh | 41b3f9a | 2018-04-03 17:06:35 -0700 | [diff] [blame] | 719 | } |
| 720 | |
| 721 | } else { |
| 722 | vector<ConfigKey> configs = mConfigManager->GetAllConfigKeys(); |
| 723 | for (const ConfigKey& key : configs) { |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 724 | dprintf(out, "Config %s uses %zu bytes\n", key.ToString().c_str(), |
Tej Singh | 41b3f9a | 2018-04-03 17:06:35 -0700 | [diff] [blame] | 725 | mProcessor->GetMetricsSize(key)); |
| 726 | } |
| 727 | statsdStats.dumpStats(out); |
| 728 | } |
David Chen | 1d7b0cd | 2017-11-15 14:20:04 -0800 | [diff] [blame] | 729 | return NO_ERROR; |
| 730 | } |
| 731 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 732 | status_t StatsService::cmd_print_uid_map(int out, const Vector<String8>& args) { |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 733 | if (args.size() > 1) { |
| 734 | string pkg; |
| 735 | pkg.assign(args[1].c_str(), args[1].size()); |
| 736 | auto uids = mUidMap->getAppUid(pkg); |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 737 | dprintf(out, "%s -> [ ", pkg.c_str()); |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 738 | for (const auto& uid : uids) { |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 739 | dprintf(out, "%d ", uid); |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 740 | } |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 741 | dprintf(out, "]\n"); |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 742 | } else { |
| 743 | mUidMap->printUidMap(out); |
| 744 | } |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 745 | return NO_ERROR; |
David Chen | 0656b7a | 2017-09-13 15:53:39 -0700 | [diff] [blame] | 746 | } |
| 747 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 748 | status_t StatsService::cmd_write_data_to_disk(int out) { |
| 749 | dprintf(out, "Writing data to disk\n"); |
Olivier Gaillard | 6c75ecd | 2019-02-20 09:57:33 +0000 | [diff] [blame] | 750 | mProcessor->WriteDataToDisk(ADB_DUMP, NO_TIME_CONSTRAINTS); |
yro | 947fbce | 2017-11-15 22:50:23 -0800 | [diff] [blame] | 751 | return NO_ERROR; |
| 752 | } |
| 753 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 754 | status_t StatsService::cmd_log_app_breadcrumb(int out, const Vector<String8>& args) { |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 755 | bool good = false; |
| 756 | int32_t uid; |
| 757 | int32_t label; |
| 758 | int32_t state; |
| 759 | const int argCount = args.size(); |
| 760 | if (argCount == 3) { |
| 761 | // Automatically pick the UID |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 762 | uid = AIBinder_getCallingUid(); |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 763 | label = atoi(args[1].c_str()); |
| 764 | state = atoi(args[2].c_str()); |
| 765 | good = true; |
| 766 | } else if (argCount == 4) { |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 767 | good = getUidFromArgs(args, 1, uid); |
| 768 | if (!good) { |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 769 | dprintf(out, |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 770 | "Invalid UID. Note that selecting a UID for writing AppBreadcrumb can only be " |
| 771 | "done for other UIDs on eng or userdebug builds.\n"); |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 772 | } |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 773 | label = atoi(args[2].c_str()); |
| 774 | state = atoi(args[3].c_str()); |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 775 | } |
| 776 | if (good) { |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 777 | dprintf(out, "Logging AppBreadcrumbReported(%d, %d, %d) to statslog.\n", uid, label, state); |
Jeffrey Huang | 74fc435 | 2020-03-06 15:18:33 -0800 | [diff] [blame] | 778 | android::os::statsd::util::stats_write( |
| 779 | android::os::statsd::util::APP_BREADCRUMB_REPORTED, uid, label, state); |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 780 | } else { |
| 781 | print_cmd_help(out); |
| 782 | return UNKNOWN_ERROR; |
| 783 | } |
| 784 | return NO_ERROR; |
| 785 | } |
| 786 | |
Tej Singh | 53f9dee | 2019-04-30 17:45:54 -0700 | [diff] [blame] | 787 | status_t StatsService::cmd_log_binary_push(int out, const Vector<String8>& args) { |
| 788 | // Security checks are done in the sendBinaryPushStateChanged atom. |
| 789 | const int argCount = args.size(); |
| 790 | if (argCount != 7 && argCount != 8) { |
| 791 | dprintf(out, "Incorrect number of argument supplied\n"); |
| 792 | return UNKNOWN_ERROR; |
| 793 | } |
Jonathan Nguyen | a0e6de1 | 2020-01-28 18:33:55 -0800 | [diff] [blame] | 794 | string trainName = string(args[1].c_str()); |
Tej Singh | 53f9dee | 2019-04-30 17:45:54 -0700 | [diff] [blame] | 795 | int64_t trainVersion = strtoll(args[2].c_str(), nullptr, 10); |
Tej Singh | 53f9dee | 2019-04-30 17:45:54 -0700 | [diff] [blame] | 796 | int32_t state = atoi(args[6].c_str()); |
| 797 | vector<int64_t> experimentIds; |
| 798 | if (argCount == 8) { |
| 799 | vector<string> experimentIdsString = android::base::Split(string(args[7].c_str()), ","); |
| 800 | for (string experimentIdString : experimentIdsString) { |
| 801 | int64_t experimentId = strtoll(experimentIdString.c_str(), nullptr, 10); |
| 802 | experimentIds.push_back(experimentId); |
| 803 | } |
| 804 | } |
| 805 | dprintf(out, "Logging BinaryPushStateChanged\n"); |
Jonathan Nguyen | a0e6de1 | 2020-01-28 18:33:55 -0800 | [diff] [blame] | 806 | vector<uint8_t> experimentIdBytes; |
| 807 | writeExperimentIdsToProto(experimentIds, &experimentIdBytes); |
| 808 | LogEvent event(trainName, trainVersion, args[3], args[4], args[5], state, experimentIdBytes, 0); |
| 809 | mProcessor->OnLogEvent(&event); |
Tej Singh | 53f9dee | 2019-04-30 17:45:54 -0700 | [diff] [blame] | 810 | return NO_ERROR; |
| 811 | } |
| 812 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 813 | status_t StatsService::cmd_print_pulled_metrics(int out, const Vector<String8>& args) { |
David Chen | 1481fe1 | 2017-10-16 13:16:34 -0700 | [diff] [blame] | 814 | int s = atoi(args[1].c_str()); |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 815 | vector<int32_t> uids; |
| 816 | if (args.size() > 2) { |
| 817 | string package = string(args[2].c_str()); |
| 818 | auto it = UidMap::sAidToUidMapping.find(package); |
| 819 | if (it != UidMap::sAidToUidMapping.end()) { |
| 820 | uids.push_back(it->second); |
| 821 | } else { |
| 822 | set<int32_t> uids_set = mUidMap->getAppUid(package); |
| 823 | uids.insert(uids.end(), uids_set.begin(), uids_set.end()); |
| 824 | } |
| 825 | } else { |
| 826 | uids.push_back(AID_SYSTEM); |
| 827 | } |
| 828 | vector<shared_ptr<LogEvent>> stats; |
Tej Singh | 7b975a8 | 2020-05-11 11:05:08 -0700 | [diff] [blame] | 829 | if (mPullerManager->Pull(s, uids, getElapsedRealtimeNs(), &stats)) { |
Chenjie Yu | 5305e1d | 2017-10-31 13:49:36 -0700 | [diff] [blame] | 830 | for (const auto& it : stats) { |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 831 | dprintf(out, "Pull from %d: %s\n", s, it->ToString().c_str()); |
Chenjie Yu | 5305e1d | 2017-10-31 13:49:36 -0700 | [diff] [blame] | 832 | } |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 833 | dprintf(out, "Pull from %d: Received %zu elements\n", s, stats.size()); |
Chenjie Yu | 5305e1d | 2017-10-31 13:49:36 -0700 | [diff] [blame] | 834 | return NO_ERROR; |
David Chen | 1481fe1 | 2017-10-16 13:16:34 -0700 | [diff] [blame] | 835 | } |
Chenjie Yu | 5305e1d | 2017-10-31 13:49:36 -0700 | [diff] [blame] | 836 | return UNKNOWN_ERROR; |
David Chen | 1481fe1 | 2017-10-16 13:16:34 -0700 | [diff] [blame] | 837 | } |
| 838 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 839 | status_t StatsService::cmd_remove_all_configs(int out) { |
| 840 | dprintf(out, "Removing all configs...\n"); |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 841 | VLOG("StatsService::cmd_remove_all_configs was called"); |
| 842 | mConfigManager->RemoveAllConfigs(); |
yro | 947fbce | 2017-11-15 22:50:23 -0800 | [diff] [blame] | 843 | StorageManager::deleteAllFiles(STATS_SERVICE_DIR); |
yro | 87d983c | 2017-11-14 21:31:43 -0800 | [diff] [blame] | 844 | return NO_ERROR; |
| 845 | } |
| 846 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 847 | status_t StatsService::cmd_dump_memory_info(int out) { |
| 848 | dprintf(out, "meminfo not available.\n"); |
Yao Chen | 8d9989b | 2017-11-18 18:54:50 -0800 | [diff] [blame] | 849 | return NO_ERROR; |
| 850 | } |
| 851 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 852 | status_t StatsService::cmd_clear_puller_cache(int out) { |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 853 | VLOG("StatsService::cmd_clear_puller_cache with Pid %i, Uid %i", |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 854 | AIBinder_getCallingPid(), AIBinder_getCallingUid()); |
Ruchir Rastogi | 0563e3b | 2020-01-28 17:43:13 -0800 | [diff] [blame] | 855 | if (checkPermission(kPermissionDump)) { |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 856 | int cleared = mPullerManager->ForceClearPullerCache(); |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 857 | dprintf(out, "Puller removed %d cached data!\n", cleared); |
Chenjie Yu | fa22d65 | 2018-02-05 14:37:48 -0800 | [diff] [blame] | 858 | return NO_ERROR; |
| 859 | } else { |
| 860 | return PERMISSION_DENIED; |
| 861 | } |
Chenjie Yu | e72252b | 2018-02-01 13:19:35 -0800 | [diff] [blame] | 862 | } |
| 863 | |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 864 | status_t StatsService::cmd_print_logs(int out, const Vector<String8>& args) { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 865 | VLOG("StatsService::cmd_print_logs with Pid %i, Uid %i", AIBinder_getCallingPid(), |
| 866 | AIBinder_getCallingUid()); |
Ruchir Rastogi | 0563e3b | 2020-01-28 17:43:13 -0800 | [diff] [blame] | 867 | if (checkPermission(kPermissionDump)) { |
Yao Chen | 876889c | 2018-05-02 11:16:16 -0700 | [diff] [blame] | 868 | bool enabled = true; |
| 869 | if (args.size() >= 2) { |
| 870 | enabled = atoi(args[1].c_str()) != 0; |
| 871 | } |
| 872 | mProcessor->setPrintLogs(enabled); |
| 873 | return NO_ERROR; |
| 874 | } else { |
| 875 | return PERMISSION_DENIED; |
| 876 | } |
| 877 | } |
| 878 | |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 879 | bool StatsService::getUidFromArgs(const Vector<String8>& args, size_t uidArgIndex, int32_t& uid) { |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 880 | return getUidFromString(args[uidArgIndex].c_str(), uid); |
| 881 | } |
| 882 | |
| 883 | bool StatsService::getUidFromString(const char* s, int32_t& uid) { |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 884 | if (*s == '\0') { |
| 885 | return false; |
| 886 | } |
| 887 | char* endc = NULL; |
| 888 | int64_t longUid = strtol(s, &endc, 0); |
| 889 | if (*endc != '\0') { |
| 890 | return false; |
| 891 | } |
| 892 | int32_t goodUid = static_cast<int32_t>(longUid); |
| 893 | if (longUid < 0 || static_cast<uint64_t>(longUid) != static_cast<uid_t>(goodUid)) { |
| 894 | return false; // It was not of uid_t type. |
| 895 | } |
| 896 | uid = goodUid; |
| 897 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 898 | int32_t callingUid = AIBinder_getCallingUid(); |
Bookatz | d238657 | 2018-12-14 15:53:14 -0800 | [diff] [blame] | 899 | return mEngBuild // UserDebug/EngBuild are allowed to impersonate uids. |
| 900 | || (callingUid == goodUid) // Anyone can 'impersonate' themselves. |
| 901 | || (callingUid == AID_ROOT && goodUid == AID_SHELL); // ROOT can impersonate SHELL. |
| 902 | } |
| 903 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 904 | Status StatsService::informAllUidData(const ScopedFileDescriptor& fd) { |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 905 | ENFORCE_UID(AID_SYSTEM); |
Max Dashouk | 11e0d40 | 2019-05-16 16:58:07 -0700 | [diff] [blame] | 906 | // Read stream into buffer. |
| 907 | string buffer; |
| 908 | if (!android::base::ReadFdToString(fd.get(), &buffer)) { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 909 | return exception(EX_ILLEGAL_ARGUMENT, "Failed to read all data from the pipe."); |
Max Dashouk | 11e0d40 | 2019-05-16 16:58:07 -0700 | [diff] [blame] | 910 | } |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 911 | |
Max Dashouk | 11e0d40 | 2019-05-16 16:58:07 -0700 | [diff] [blame] | 912 | // Parse buffer. |
| 913 | UidData uidData; |
| 914 | if (!uidData.ParseFromString(buffer)) { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 915 | return exception(EX_ILLEGAL_ARGUMENT, "Error parsing proto stream for UidData."); |
Max Dashouk | 11e0d40 | 2019-05-16 16:58:07 -0700 | [diff] [blame] | 916 | } |
David Chen | de70169 | 2017-10-05 13:16:02 -0700 | [diff] [blame] | 917 | |
Max Dashouk | 11e0d40 | 2019-05-16 16:58:07 -0700 | [diff] [blame] | 918 | vector<String16> versionStrings; |
| 919 | vector<String16> installers; |
| 920 | vector<String16> packageNames; |
| 921 | vector<int32_t> uids; |
| 922 | vector<int64_t> versions; |
| 923 | |
| 924 | const auto numEntries = uidData.app_info_size(); |
| 925 | versionStrings.reserve(numEntries); |
| 926 | installers.reserve(numEntries); |
| 927 | packageNames.reserve(numEntries); |
| 928 | uids.reserve(numEntries); |
| 929 | versions.reserve(numEntries); |
| 930 | |
| 931 | for (const auto& appInfo: uidData.app_info()) { |
| 932 | packageNames.emplace_back(String16(appInfo.package_name().c_str())); |
| 933 | uids.push_back(appInfo.uid()); |
| 934 | versions.push_back(appInfo.version()); |
| 935 | versionStrings.emplace_back(String16(appInfo.version_string().c_str())); |
| 936 | installers.emplace_back(String16(appInfo.installer().c_str())); |
| 937 | } |
| 938 | |
| 939 | mUidMap->updateMap(getElapsedRealtimeNs(), |
| 940 | uids, |
| 941 | versions, |
| 942 | versionStrings, |
| 943 | packageNames, |
| 944 | installers); |
| 945 | |
Tej Singh | e678cb7 | 2020-04-14 16:23:30 -0700 | [diff] [blame] | 946 | mBootCompleteTrigger.markComplete(kUidMapReceivedTag); |
Max Dashouk | 11e0d40 | 2019-05-16 16:58:07 -0700 | [diff] [blame] | 947 | VLOG("StatsService::informAllUidData UidData proto parsed successfully."); |
David Chen | de70169 | 2017-10-05 13:16:02 -0700 | [diff] [blame] | 948 | return Status::ok(); |
| 949 | } |
| 950 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 951 | Status StatsService::informOnePackage(const string& app, int32_t uid, int64_t version, |
| 952 | const string& versionString, const string& installer) { |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 953 | ENFORCE_UID(AID_SYSTEM); |
David Chen | de70169 | 2017-10-05 13:16:02 -0700 | [diff] [blame] | 954 | |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 955 | VLOG("StatsService::informOnePackage was called"); |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 956 | String16 utf16App = String16(app.c_str()); |
| 957 | String16 utf16VersionString = String16(versionString.c_str()); |
| 958 | String16 utf16Installer = String16(installer.c_str()); |
| 959 | |
| 960 | mUidMap->updateApp(getElapsedRealtimeNs(), utf16App, uid, version, utf16VersionString, |
| 961 | utf16Installer); |
David Chen | de70169 | 2017-10-05 13:16:02 -0700 | [diff] [blame] | 962 | return Status::ok(); |
| 963 | } |
| 964 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 965 | Status StatsService::informOnePackageRemoved(const string& app, int32_t uid) { |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 966 | ENFORCE_UID(AID_SYSTEM); |
David Chen | de70169 | 2017-10-05 13:16:02 -0700 | [diff] [blame] | 967 | |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 968 | VLOG("StatsService::informOnePackageRemoved was called"); |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 969 | String16 utf16App = String16(app.c_str()); |
| 970 | mUidMap->removeApp(getElapsedRealtimeNs(), utf16App, uid); |
yro | 0192402 | 2018-02-20 18:20:49 -0800 | [diff] [blame] | 971 | mConfigManager->RemoveConfigs(uid); |
David Chen | de70169 | 2017-10-05 13:16:02 -0700 | [diff] [blame] | 972 | return Status::ok(); |
| 973 | } |
| 974 | |
Yao Chen | ef99c4f | 2017-09-22 16:26:54 -0700 | [diff] [blame] | 975 | Status StatsService::informAnomalyAlarmFired() { |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 976 | ENFORCE_UID(AID_SYSTEM); |
| 977 | |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 978 | VLOG("StatsService::informAnomalyAlarmFired was called"); |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 979 | int64_t currentTimeSec = getElapsedRealtimeSec(); |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 980 | std::unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>> alarmSet = |
| 981 | mAnomalyAlarmMonitor->popSoonerThan(static_cast<uint32_t>(currentTimeSec)); |
| 982 | if (alarmSet.size() > 0) { |
Bookatz | 66fe061 | 2018-02-07 18:51:48 -0800 | [diff] [blame] | 983 | VLOG("Found an anomaly alarm that fired."); |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 984 | mProcessor->onAnomalyAlarmFired(currentTimeSec * NS_PER_SEC, alarmSet); |
Bookatz | 66fe061 | 2018-02-07 18:51:48 -0800 | [diff] [blame] | 985 | } else { |
| 986 | VLOG("Cannot find an anomaly alarm that fired. Perhaps it was recently cancelled."); |
| 987 | } |
Bookatz | 1b0b114 | 2017-09-08 11:58:42 -0700 | [diff] [blame] | 988 | return Status::ok(); |
| 989 | } |
| 990 | |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 991 | Status StatsService::informAlarmForSubscriberTriggeringFired() { |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 992 | ENFORCE_UID(AID_SYSTEM); |
| 993 | |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 994 | VLOG("StatsService::informAlarmForSubscriberTriggeringFired was called"); |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 995 | int64_t currentTimeSec = getElapsedRealtimeSec(); |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 996 | std::unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>> alarmSet = |
| 997 | mPeriodicAlarmMonitor->popSoonerThan(static_cast<uint32_t>(currentTimeSec)); |
| 998 | if (alarmSet.size() > 0) { |
| 999 | VLOG("Found periodic alarm fired."); |
| 1000 | mProcessor->onPeriodicAlarmFired(currentTimeSec * NS_PER_SEC, alarmSet); |
| 1001 | } else { |
| 1002 | ALOGW("Cannot find an periodic alarm that fired. Perhaps it was recently cancelled."); |
| 1003 | } |
| 1004 | return Status::ok(); |
| 1005 | } |
| 1006 | |
Yao Chen | ef99c4f | 2017-09-22 16:26:54 -0700 | [diff] [blame] | 1007 | Status StatsService::informPollAlarmFired() { |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1008 | ENFORCE_UID(AID_SYSTEM); |
| 1009 | |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 1010 | VLOG("StatsService::informPollAlarmFired was called"); |
Yangster-mac | 15f6bbc | 2018-04-08 11:52:26 -0700 | [diff] [blame] | 1011 | mProcessor->informPullAlarmFired(getElapsedRealtimeNs()); |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 1012 | VLOG("StatsService::informPollAlarmFired succeeded"); |
Bookatz | 1b0b114 | 2017-09-08 11:58:42 -0700 | [diff] [blame] | 1013 | return Status::ok(); |
| 1014 | } |
| 1015 | |
Yao Chen | ef99c4f | 2017-09-22 16:26:54 -0700 | [diff] [blame] | 1016 | Status StatsService::systemRunning() { |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1017 | ENFORCE_UID(AID_SYSTEM); |
Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 1018 | |
| 1019 | // When system_server is up and running, schedule the dropbox task to run. |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 1020 | VLOG("StatsService::systemRunning"); |
Bookatz | b487b55 | 2017-09-18 11:26:01 -0700 | [diff] [blame] | 1021 | sayHiToStatsCompanion(); |
Joe Onorato | 5dcbc6c | 2017-08-29 15:13:58 -0700 | [diff] [blame] | 1022 | return Status::ok(); |
| 1023 | } |
| 1024 | |
Yangster-mac | 892f3d3 | 2018-05-02 14:16:48 -0700 | [diff] [blame] | 1025 | Status StatsService::informDeviceShutdown() { |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1026 | ENFORCE_UID(AID_SYSTEM); |
Chenjie Yu | e36018b | 2018-04-16 15:18:30 -0700 | [diff] [blame] | 1027 | VLOG("StatsService::informDeviceShutdown"); |
Olivier Gaillard | 6c75ecd | 2019-02-20 09:57:33 +0000 | [diff] [blame] | 1028 | mProcessor->WriteDataToDisk(DEVICE_SHUTDOWN, FAST); |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 1029 | mProcessor->SaveActiveConfigsToDisk(getElapsedRealtimeNs()); |
Jeffrey Huang | b8f5403 | 2020-03-23 13:42:42 -0700 | [diff] [blame] | 1030 | mProcessor->SaveMetadataToDisk(getWallClockNs(), getElapsedRealtimeNs()); |
yro | 947fbce | 2017-11-15 22:50:23 -0800 | [diff] [blame] | 1031 | return Status::ok(); |
| 1032 | } |
| 1033 | |
Yao Chen | ef99c4f | 2017-09-22 16:26:54 -0700 | [diff] [blame] | 1034 | void StatsService::sayHiToStatsCompanion() { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1035 | shared_ptr<IStatsCompanionService> statsCompanion = getStatsCompanionService(); |
Bookatz | b487b55 | 2017-09-18 11:26:01 -0700 | [diff] [blame] | 1036 | if (statsCompanion != nullptr) { |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 1037 | VLOG("Telling statsCompanion that statsd is ready"); |
Bookatz | b487b55 | 2017-09-18 11:26:01 -0700 | [diff] [blame] | 1038 | statsCompanion->statsdReady(); |
| 1039 | } else { |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 1040 | VLOG("Could not access statsCompanion"); |
Bookatz | b487b55 | 2017-09-18 11:26:01 -0700 | [diff] [blame] | 1041 | } |
| 1042 | } |
| 1043 | |
Yao Chen | ef99c4f | 2017-09-22 16:26:54 -0700 | [diff] [blame] | 1044 | Status StatsService::statsCompanionReady() { |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1045 | ENFORCE_UID(AID_SYSTEM); |
| 1046 | |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 1047 | VLOG("StatsService::statsCompanionReady was called"); |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1048 | shared_ptr<IStatsCompanionService> statsCompanion = getStatsCompanionService(); |
Bookatz | b487b55 | 2017-09-18 11:26:01 -0700 | [diff] [blame] | 1049 | if (statsCompanion == nullptr) { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1050 | return exception(EX_NULL_POINTER, |
| 1051 | "StatsCompanion unavailable despite it contacting statsd."); |
Bookatz | b487b55 | 2017-09-18 11:26:01 -0700 | [diff] [blame] | 1052 | } |
yro | 74fed97 | 2017-11-27 14:42:42 -0800 | [diff] [blame] | 1053 | VLOG("StatsService::statsCompanionReady linking to statsCompanion."); |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1054 | AIBinder_linkToDeath(statsCompanion->asBinder().get(), |
| 1055 | mStatsCompanionServiceDeathRecipient.get(), this); |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 1056 | mPullerManager->SetStatsCompanionService(statsCompanion); |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 1057 | mAnomalyAlarmMonitor->setStatsCompanionService(statsCompanion); |
| 1058 | mPeriodicAlarmMonitor->setStatsCompanionService(statsCompanion); |
Bookatz | b487b55 | 2017-09-18 11:26:01 -0700 | [diff] [blame] | 1059 | return Status::ok(); |
| 1060 | } |
| 1061 | |
Jeffrey Huang | d8f5330 | 2020-04-06 18:09:55 -0700 | [diff] [blame] | 1062 | Status StatsService::bootCompleted() { |
| 1063 | ENFORCE_UID(AID_SYSTEM); |
| 1064 | |
| 1065 | VLOG("StatsService::bootCompleted was called"); |
Tej Singh | e678cb7 | 2020-04-14 16:23:30 -0700 | [diff] [blame] | 1066 | mBootCompleteTrigger.markComplete(kBootCompleteTag); |
Jeffrey Huang | d8f5330 | 2020-04-06 18:09:55 -0700 | [diff] [blame] | 1067 | return Status::ok(); |
| 1068 | } |
| 1069 | |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 1070 | void StatsService::Startup() { |
| 1071 | mConfigManager->Startup(); |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 1072 | mProcessor->LoadActiveConfigsFromDisk(); |
Jeffrey Huang | 475677e | 2020-03-30 19:52:07 -0700 | [diff] [blame] | 1073 | mProcessor->LoadMetadataFromDisk(getWallClockNs(), getElapsedRealtimeNs()); |
Bookatz | 906a35c | 2017-09-20 15:26:44 -0700 | [diff] [blame] | 1074 | } |
| 1075 | |
Yangster-mac | 97e7d20 | 2018-10-09 11:05:39 -0700 | [diff] [blame] | 1076 | void StatsService::Terminate() { |
| 1077 | ALOGI("StatsService::Terminating"); |
| 1078 | if (mProcessor != nullptr) { |
Olivier Gaillard | 6c75ecd | 2019-02-20 09:57:33 +0000 | [diff] [blame] | 1079 | mProcessor->WriteDataToDisk(TERMINATION_SIGNAL_RECEIVED, FAST); |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 1080 | mProcessor->SaveActiveConfigsToDisk(getElapsedRealtimeNs()); |
Jeffrey Huang | b8f5403 | 2020-03-23 13:42:42 -0700 | [diff] [blame] | 1081 | mProcessor->SaveMetadataToDisk(getWallClockNs(), getElapsedRealtimeNs()); |
Yangster-mac | 97e7d20 | 2018-10-09 11:05:39 -0700 | [diff] [blame] | 1082 | } |
| 1083 | } |
| 1084 | |
Yao Chen | 0f86186 | 2019-03-27 11:51:15 -0700 | [diff] [blame] | 1085 | // Test only interface!!! |
Yao Chen | 3ff3a49 | 2018-08-06 16:17:37 -0700 | [diff] [blame] | 1086 | void StatsService::OnLogEvent(LogEvent* event) { |
| 1087 | mProcessor->OnLogEvent(event); |
Yao Chen | a80e5c0 | 2018-09-04 13:55:29 -0700 | [diff] [blame] | 1088 | if (mShellSubscriber != nullptr) { |
| 1089 | mShellSubscriber->onLogEvent(*event); |
| 1090 | } |
Bookatz | 906a35c | 2017-09-20 15:26:44 -0700 | [diff] [blame] | 1091 | } |
| 1092 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1093 | Status StatsService::getData(int64_t key, const int32_t callingUid, vector<int8_t>* output) { |
Jeffrey Huang | 04f948b | 2020-01-07 10:05:25 -0800 | [diff] [blame] | 1094 | ENFORCE_UID(AID_SYSTEM); |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1095 | |
Jeffrey Huang | 04f948b | 2020-01-07 10:05:25 -0800 | [diff] [blame] | 1096 | VLOG("StatsService::getData with Uid %i", callingUid); |
| 1097 | ConfigKey configKey(callingUid, key); |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1098 | // TODO(b/149254662): Since libbinder_ndk uses int8_t instead of uint8_t, |
| 1099 | // there are inconsistencies with internal statsd logic. Instead of |
| 1100 | // modifying lots of files, we create a temporary output array of int8_t and |
| 1101 | // copy its data into output. This is a bad hack, but hopefully |
| 1102 | // libbinder_ndk will transition to using uint8_t soon: progress is tracked |
| 1103 | // in b/144957764. Same applies to StatsService::getMetadata. |
| 1104 | vector<uint8_t> unsignedOutput; |
Olivier Gaillard | 6c75ecd | 2019-02-20 09:57:33 +0000 | [diff] [blame] | 1105 | // The dump latency does not matter here since we do not include the current bucket, we do not |
| 1106 | // need to pull any new data anyhow. |
David Chen | 56ae0d9 | 2018-05-11 16:00:22 -0700 | [diff] [blame] | 1107 | mProcessor->onDumpReport(configKey, getElapsedRealtimeNs(), false /* include_current_bucket*/, |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1108 | true /* erase_data */, GET_DATA_CALLED, FAST, &unsignedOutput); |
| 1109 | *output = vector<int8_t>(unsignedOutput.begin(), unsignedOutput.end()); |
Bookatz | 4f71629 | 2018-04-10 17:15:12 -0700 | [diff] [blame] | 1110 | return Status::ok(); |
yro | 31eb67b | 2017-10-24 13:33:21 -0700 | [diff] [blame] | 1111 | } |
| 1112 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1113 | Status StatsService::getMetadata(vector<int8_t>* output) { |
Jeffrey Huang | 9613a97 | 2020-01-07 10:05:03 -0800 | [diff] [blame] | 1114 | ENFORCE_UID(AID_SYSTEM); |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1115 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1116 | vector<uint8_t> unsignedOutput; |
| 1117 | StatsdStats::getInstance().dumpStats(&unsignedOutput, false); // Don't reset the counters. |
| 1118 | *output = vector<int8_t>(unsignedOutput.begin(), unsignedOutput.end()); |
Bookatz | 4f71629 | 2018-04-10 17:15:12 -0700 | [diff] [blame] | 1119 | return Status::ok(); |
David Chen | 2e8f380 | 2017-11-22 10:56:48 -0800 | [diff] [blame] | 1120 | } |
| 1121 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1122 | Status StatsService::addConfiguration(int64_t key, const vector <int8_t>& config, |
Jeffrey Huang | 94eafe7 | 2020-01-07 15:18:43 -0800 | [diff] [blame] | 1123 | const int32_t callingUid) { |
| 1124 | ENFORCE_UID(AID_SYSTEM); |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1125 | |
Jeffrey Huang | 94eafe7 | 2020-01-07 15:18:43 -0800 | [diff] [blame] | 1126 | if (addConfigurationChecked(callingUid, key, config)) { |
David Chen | 661f791 | 2018-01-22 17:46:24 -0800 | [diff] [blame] | 1127 | return Status::ok(); |
| 1128 | } else { |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1129 | return exception(EX_ILLEGAL_ARGUMENT, "Could not parse malformatted StatsdConfig."); |
David Chen | 661f791 | 2018-01-22 17:46:24 -0800 | [diff] [blame] | 1130 | } |
| 1131 | } |
| 1132 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1133 | bool StatsService::addConfigurationChecked(int uid, int64_t key, const vector<int8_t>& config) { |
David Chen | 9fdd403 | 2018-03-20 14:38:56 -0700 | [diff] [blame] | 1134 | ConfigKey configKey(uid, key); |
| 1135 | StatsdConfig cfg; |
| 1136 | if (config.size() > 0) { // If the config is empty, skip parsing. |
| 1137 | if (!cfg.ParseFromArray(&config[0], config.size())) { |
| 1138 | return false; |
| 1139 | } |
| 1140 | } |
| 1141 | mConfigManager->UpdateConfig(configKey, cfg); |
| 1142 | return true; |
| 1143 | } |
| 1144 | |
Jeffrey Huang | ad21374 | 2019-12-16 13:50:06 -0800 | [diff] [blame] | 1145 | Status StatsService::removeDataFetchOperation(int64_t key, |
| 1146 | const int32_t callingUid) { |
| 1147 | ENFORCE_UID(AID_SYSTEM); |
| 1148 | ConfigKey configKey(callingUid, key); |
Bookatz | 4f71629 | 2018-04-10 17:15:12 -0700 | [diff] [blame] | 1149 | mConfigManager->RemoveConfigReceiver(configKey); |
| 1150 | return Status::ok(); |
David Chen | 661f791 | 2018-01-22 17:46:24 -0800 | [diff] [blame] | 1151 | } |
| 1152 | |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1153 | Status StatsService::setDataFetchOperation(int64_t key, |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1154 | const shared_ptr<IPendingIntentRef>& pir, |
Jeffrey Huang | ad21374 | 2019-12-16 13:50:06 -0800 | [diff] [blame] | 1155 | const int32_t callingUid) { |
| 1156 | ENFORCE_UID(AID_SYSTEM); |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1157 | |
Jeffrey Huang | ad21374 | 2019-12-16 13:50:06 -0800 | [diff] [blame] | 1158 | ConfigKey configKey(callingUid, key); |
| 1159 | mConfigManager->SetConfigReceiver(configKey, pir); |
David Chen | 4894490 | 2018-05-03 10:29:11 -0700 | [diff] [blame] | 1160 | if (StorageManager::hasConfigMetricsReport(configKey)) { |
| 1161 | VLOG("StatsService::setDataFetchOperation marking configKey %s to dump reports on disk", |
| 1162 | configKey.ToString().c_str()); |
| 1163 | mProcessor->noteOnDiskData(configKey); |
| 1164 | } |
Bookatz | 4f71629 | 2018-04-10 17:15:12 -0700 | [diff] [blame] | 1165 | return Status::ok(); |
yro | 31eb67b | 2017-10-24 13:33:21 -0700 | [diff] [blame] | 1166 | } |
| 1167 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1168 | Status StatsService::setActiveConfigsChangedOperation(const shared_ptr<IPendingIntentRef>& pir, |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 1169 | const int32_t callingUid, |
Tej Singh | 2c9ef2a | 2019-01-22 11:33:51 -0800 | [diff] [blame] | 1170 | vector<int64_t>* output) { |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 1171 | ENFORCE_UID(AID_SYSTEM); |
Tej Singh | 2c9ef2a | 2019-01-22 11:33:51 -0800 | [diff] [blame] | 1172 | |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 1173 | mConfigManager->SetActiveConfigsChangedReceiver(callingUid, pir); |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 1174 | if (output != nullptr) { |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 1175 | mProcessor->GetActiveConfigs(callingUid, *output); |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 1176 | } else { |
| 1177 | ALOGW("StatsService::setActiveConfigsChanged output was nullptr"); |
| 1178 | } |
Tej Singh | 2c9ef2a | 2019-01-22 11:33:51 -0800 | [diff] [blame] | 1179 | return Status::ok(); |
| 1180 | } |
| 1181 | |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 1182 | Status StatsService::removeActiveConfigsChangedOperation(const int32_t callingUid) { |
| 1183 | ENFORCE_UID(AID_SYSTEM); |
Tej Singh | 2c9ef2a | 2019-01-22 11:33:51 -0800 | [diff] [blame] | 1184 | |
Jeffrey Huang | 47537a1 | 2020-01-06 15:35:34 -0800 | [diff] [blame] | 1185 | mConfigManager->RemoveActiveConfigsChangedReceiver(callingUid); |
Tej Singh | 2c9ef2a | 2019-01-22 11:33:51 -0800 | [diff] [blame] | 1186 | return Status::ok(); |
| 1187 | } |
| 1188 | |
Jeffrey Huang | 94eafe7 | 2020-01-07 15:18:43 -0800 | [diff] [blame] | 1189 | Status StatsService::removeConfiguration(int64_t key, const int32_t callingUid) { |
| 1190 | ENFORCE_UID(AID_SYSTEM); |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1191 | |
Jeffrey Huang | 94eafe7 | 2020-01-07 15:18:43 -0800 | [diff] [blame] | 1192 | ConfigKey configKey(callingUid, key); |
Bookatz | 4f71629 | 2018-04-10 17:15:12 -0700 | [diff] [blame] | 1193 | mConfigManager->RemoveConfig(configKey); |
Bookatz | 4f71629 | 2018-04-10 17:15:12 -0700 | [diff] [blame] | 1194 | return Status::ok(); |
yro | 31eb67b | 2017-10-24 13:33:21 -0700 | [diff] [blame] | 1195 | } |
| 1196 | |
Bookatz | c697797 | 2018-01-16 16:55:05 -0800 | [diff] [blame] | 1197 | Status StatsService::setBroadcastSubscriber(int64_t configId, |
| 1198 | int64_t subscriberId, |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1199 | const shared_ptr<IPendingIntentRef>& pir, |
Jeffrey Huang | 4f2e6bd | 2020-01-06 16:24:45 -0800 | [diff] [blame] | 1200 | const int32_t callingUid) { |
| 1201 | ENFORCE_UID(AID_SYSTEM); |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1202 | |
Bookatz | c697797 | 2018-01-16 16:55:05 -0800 | [diff] [blame] | 1203 | VLOG("StatsService::setBroadcastSubscriber called."); |
Jeffrey Huang | 4f2e6bd | 2020-01-06 16:24:45 -0800 | [diff] [blame] | 1204 | ConfigKey configKey(callingUid, configId); |
Bookatz | 4f71629 | 2018-04-10 17:15:12 -0700 | [diff] [blame] | 1205 | SubscriberReporter::getInstance() |
Jeffrey Huang | 4f2e6bd | 2020-01-06 16:24:45 -0800 | [diff] [blame] | 1206 | .setBroadcastSubscriber(configKey, subscriberId, pir); |
Bookatz | 4f71629 | 2018-04-10 17:15:12 -0700 | [diff] [blame] | 1207 | return Status::ok(); |
Bookatz | c697797 | 2018-01-16 16:55:05 -0800 | [diff] [blame] | 1208 | } |
| 1209 | |
| 1210 | Status StatsService::unsetBroadcastSubscriber(int64_t configId, |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1211 | int64_t subscriberId, |
Jeffrey Huang | 4f2e6bd | 2020-01-06 16:24:45 -0800 | [diff] [blame] | 1212 | const int32_t callingUid) { |
| 1213 | ENFORCE_UID(AID_SYSTEM); |
Jeff Sharkey | 6b64925 | 2018-04-16 09:50:22 -0600 | [diff] [blame] | 1214 | |
Bookatz | c697797 | 2018-01-16 16:55:05 -0800 | [diff] [blame] | 1215 | VLOG("StatsService::unsetBroadcastSubscriber called."); |
Jeffrey Huang | 4f2e6bd | 2020-01-06 16:24:45 -0800 | [diff] [blame] | 1216 | ConfigKey configKey(callingUid, configId); |
Bookatz | 4f71629 | 2018-04-10 17:15:12 -0700 | [diff] [blame] | 1217 | SubscriberReporter::getInstance() |
| 1218 | .unsetBroadcastSubscriber(configKey, subscriberId); |
| 1219 | return Status::ok(); |
Bookatz | c697797 | 2018-01-16 16:55:05 -0800 | [diff] [blame] | 1220 | } |
| 1221 | |
Jeffrey Huang | d7fda53 | 2020-04-06 18:19:46 -0700 | [diff] [blame] | 1222 | Status StatsService::allPullersFromBootRegistered() { |
| 1223 | ENFORCE_UID(AID_SYSTEM); |
| 1224 | |
| 1225 | VLOG("StatsService::allPullersFromBootRegistered was called"); |
Tej Singh | e678cb7 | 2020-04-14 16:23:30 -0700 | [diff] [blame] | 1226 | mBootCompleteTrigger.markComplete(kAllPullersRegisteredTag); |
Jeffrey Huang | d7fda53 | 2020-04-06 18:19:46 -0700 | [diff] [blame] | 1227 | return Status::ok(); |
| 1228 | } |
| 1229 | |
Tej Singh | 72a70a8 | 2020-02-26 23:46:29 -0800 | [diff] [blame] | 1230 | Status StatsService::registerPullAtomCallback(int32_t uid, int32_t atomTag, int64_t coolDownMillis, |
| 1231 | int64_t timeoutMillis, |
| 1232 | const std::vector<int32_t>& additiveFields, |
| 1233 | const shared_ptr<IPullAtomCallback>& pullerCallback) { |
Tej Singh | 6a5c943 | 2019-10-11 11:07:06 -0700 | [diff] [blame] | 1234 | ENFORCE_UID(AID_SYSTEM); |
Tej Singh | b780251 | 2019-12-04 17:57:04 -0800 | [diff] [blame] | 1235 | VLOG("StatsService::registerPullAtomCallback called."); |
Tej Singh | 72a70a8 | 2020-02-26 23:46:29 -0800 | [diff] [blame] | 1236 | mPullerManager->RegisterPullAtomCallback(uid, atomTag, MillisToNano(coolDownMillis), |
| 1237 | MillisToNano(timeoutMillis), additiveFields, |
Tej Singh | b780251 | 2019-12-04 17:57:04 -0800 | [diff] [blame] | 1238 | pullerCallback); |
| 1239 | return Status::ok(); |
| 1240 | } |
| 1241 | |
Tej Singh | 73597dc | 2020-03-13 18:42:40 -0700 | [diff] [blame] | 1242 | Status StatsService::registerNativePullAtomCallback( |
| 1243 | int32_t atomTag, int64_t coolDownMillis, int64_t timeoutMillis, |
| 1244 | const std::vector<int32_t>& additiveFields, |
| 1245 | const shared_ptr<IPullAtomCallback>& pullerCallback) { |
Tej Singh | 10458ec | 2020-03-17 11:04:02 -0700 | [diff] [blame] | 1246 | if (!checkPermission(kPermissionRegisterPullAtom)) { |
| 1247 | return exception( |
| 1248 | EX_SECURITY, |
| 1249 | StringPrintf("Uid %d does not have the %s permission when registering atom %d", |
| 1250 | AIBinder_getCallingUid(), kPermissionRegisterPullAtom, atomTag)); |
| 1251 | } |
Tej Singh | b780251 | 2019-12-04 17:57:04 -0800 | [diff] [blame] | 1252 | VLOG("StatsService::registerNativePullAtomCallback called."); |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1253 | int32_t uid = AIBinder_getCallingUid(); |
Tej Singh | 73597dc | 2020-03-13 18:42:40 -0700 | [diff] [blame] | 1254 | mPullerManager->RegisterPullAtomCallback(uid, atomTag, MillisToNano(coolDownMillis), |
| 1255 | MillisToNano(timeoutMillis), additiveFields, |
Tej Singh | 6a5c943 | 2019-10-11 11:07:06 -0700 | [diff] [blame] | 1256 | pullerCallback); |
Tej Singh | 5918429 | 2019-10-11 11:07:06 -0700 | [diff] [blame] | 1257 | return Status::ok(); |
| 1258 | } |
| 1259 | |
Tej Singh | fa1c137 | 2019-12-05 20:36:54 -0800 | [diff] [blame] | 1260 | Status StatsService::unregisterPullAtomCallback(int32_t uid, int32_t atomTag) { |
| 1261 | ENFORCE_UID(AID_SYSTEM); |
| 1262 | VLOG("StatsService::unregisterPullAtomCallback called."); |
| 1263 | mPullerManager->UnregisterPullAtomCallback(uid, atomTag); |
| 1264 | return Status::ok(); |
| 1265 | } |
| 1266 | |
Tej Singh | 8f35860 | 2020-01-15 16:05:39 -0800 | [diff] [blame] | 1267 | Status StatsService::unregisterNativePullAtomCallback(int32_t atomTag) { |
Tej Singh | 10458ec | 2020-03-17 11:04:02 -0700 | [diff] [blame] | 1268 | if (!checkPermission(kPermissionRegisterPullAtom)) { |
| 1269 | return exception( |
| 1270 | EX_SECURITY, |
| 1271 | StringPrintf("Uid %d does not have the %s permission when unregistering atom %d", |
| 1272 | AIBinder_getCallingUid(), kPermissionRegisterPullAtom, atomTag)); |
| 1273 | } |
Tej Singh | 8f35860 | 2020-01-15 16:05:39 -0800 | [diff] [blame] | 1274 | VLOG("StatsService::unregisterNativePullAtomCallback called."); |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1275 | int32_t uid = AIBinder_getCallingUid(); |
Tej Singh | 8f35860 | 2020-01-15 16:05:39 -0800 | [diff] [blame] | 1276 | mPullerManager->UnregisterPullAtomCallback(uid, atomTag); |
| 1277 | return Status::ok(); |
| 1278 | } |
| 1279 | |
Jeff Hamilton | fa2f91c | 2019-03-22 00:25:02 -0400 | [diff] [blame] | 1280 | Status StatsService::getRegisteredExperimentIds(std::vector<int64_t>* experimentIdsOut) { |
Jeffrey Huang | 80c9a97 | 2020-01-07 10:04:27 -0800 | [diff] [blame] | 1281 | ENFORCE_UID(AID_SYSTEM); |
Jeff Hamilton | fa2f91c | 2019-03-22 00:25:02 -0400 | [diff] [blame] | 1282 | // TODO: add verifier permission |
| 1283 | |
Jonathan Nguyen | 703c42f | 2020-02-04 15:54:26 -0800 | [diff] [blame] | 1284 | experimentIdsOut->clear(); |
Jeff Hamilton | fa2f91c | 2019-03-22 00:25:02 -0400 | [diff] [blame] | 1285 | // Read the latest train info |
Jonathan Nguyen | 703c42f | 2020-02-04 15:54:26 -0800 | [diff] [blame] | 1286 | vector<InstallTrainInfo> trainInfoList = StorageManager::readAllTrainInfo(); |
| 1287 | if (trainInfoList.empty()) { |
Jeff Hamilton | fa2f91c | 2019-03-22 00:25:02 -0400 | [diff] [blame] | 1288 | // No train info means no experiment IDs, return an empty list |
Jeff Hamilton | fa2f91c | 2019-03-22 00:25:02 -0400 | [diff] [blame] | 1289 | return Status::ok(); |
| 1290 | } |
| 1291 | |
| 1292 | // Copy the experiment IDs to the out vector |
Jonathan Nguyen | 703c42f | 2020-02-04 15:54:26 -0800 | [diff] [blame] | 1293 | for (InstallTrainInfo& trainInfo : trainInfoList) { |
| 1294 | experimentIdsOut->insert(experimentIdsOut->end(), |
| 1295 | trainInfo.experimentIds.begin(), |
| 1296 | trainInfo.experimentIds.end()); |
| 1297 | } |
Chenjie Yu | 6b1667c | 2019-01-18 10:09:33 -0800 | [diff] [blame] | 1298 | return Status::ok(); |
| 1299 | } |
| 1300 | |
Ruchir Rastogi | e449b0c | 2020-02-10 17:40:09 -0800 | [diff] [blame] | 1301 | |
| 1302 | void StatsService::statsCompanionServiceDied(void* cookie) { |
| 1303 | auto thiz = static_cast<StatsService*>(cookie); |
| 1304 | thiz->statsCompanionServiceDiedImpl(); |
| 1305 | } |
| 1306 | |
| 1307 | void StatsService::statsCompanionServiceDiedImpl() { |
Chenjie Yu | aa5b201 | 2018-03-21 13:53:15 -0700 | [diff] [blame] | 1308 | ALOGW("statscompanion service died"); |
Yangster-mac | 892f3d3 | 2018-05-02 14:16:48 -0700 | [diff] [blame] | 1309 | StatsdStats::getInstance().noteSystemServerRestart(getWallClockSec()); |
| 1310 | if (mProcessor != nullptr) { |
Howard Ro | e60992b | 2018-08-30 14:37:29 -0700 | [diff] [blame] | 1311 | ALOGW("Reset statsd upon system server restarts."); |
Tej Singh | f53d445 | 2019-05-09 18:17:59 -0700 | [diff] [blame] | 1312 | int64_t systemServerRestartNs = getElapsedRealtimeNs(); |
Jeffrey Huang | b8f5403 | 2020-03-23 13:42:42 -0700 | [diff] [blame] | 1313 | ProtoOutputStream activeConfigsProto; |
Tej Singh | f53d445 | 2019-05-09 18:17:59 -0700 | [diff] [blame] | 1314 | mProcessor->WriteActiveConfigsToProtoOutputStream(systemServerRestartNs, |
Jeffrey Huang | b8f5403 | 2020-03-23 13:42:42 -0700 | [diff] [blame] | 1315 | STATSCOMPANION_DIED, &activeConfigsProto); |
| 1316 | metadata::StatsMetadataList metadataList; |
| 1317 | mProcessor->WriteMetadataToProto(getWallClockNs(), |
| 1318 | systemServerRestartNs, &metadataList); |
Olivier Gaillard | 6c75ecd | 2019-02-20 09:57:33 +0000 | [diff] [blame] | 1319 | mProcessor->WriteDataToDisk(STATSCOMPANION_DIED, FAST); |
Yangster-mac | 892f3d3 | 2018-05-02 14:16:48 -0700 | [diff] [blame] | 1320 | mProcessor->resetConfigs(); |
Tej Singh | f53d445 | 2019-05-09 18:17:59 -0700 | [diff] [blame] | 1321 | |
| 1322 | std::string serializedActiveConfigs; |
Jeffrey Huang | b8f5403 | 2020-03-23 13:42:42 -0700 | [diff] [blame] | 1323 | if (activeConfigsProto.serializeToString(&serializedActiveConfigs)) { |
Tej Singh | f53d445 | 2019-05-09 18:17:59 -0700 | [diff] [blame] | 1324 | ActiveConfigList activeConfigs; |
| 1325 | if (activeConfigs.ParseFromString(serializedActiveConfigs)) { |
| 1326 | mProcessor->SetConfigsActiveState(activeConfigs, systemServerRestartNs); |
| 1327 | } |
| 1328 | } |
Jeffrey Huang | 475677e | 2020-03-30 19:52:07 -0700 | [diff] [blame] | 1329 | mProcessor->SetMetadataState(metadataList, getWallClockNs(), systemServerRestartNs); |
Yangster-mac | 892f3d3 | 2018-05-02 14:16:48 -0700 | [diff] [blame] | 1330 | } |
Chenjie Yu | aa5b201 | 2018-03-21 13:53:15 -0700 | [diff] [blame] | 1331 | mAnomalyAlarmMonitor->setStatsCompanionService(nullptr); |
| 1332 | mPeriodicAlarmMonitor->setStatsCompanionService(nullptr); |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 1333 | mPullerManager->SetStatsCompanionService(nullptr); |
yro | 31eb67b | 2017-10-24 13:33:21 -0700 | [diff] [blame] | 1334 | } |
| 1335 | |
Yao Chen | ef99c4f | 2017-09-22 16:26:54 -0700 | [diff] [blame] | 1336 | } // namespace statsd |
| 1337 | } // namespace os |
| 1338 | } // namespace android |