1 /*
2  * Copyright (C) 2017 The Android Open Source Project
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 
17 #define DEBUG false  // STOPSHIP if true
18 #include "Log.h"
19 
20 #include "StatsService.h"
21 #include "stats_log_util.h"
22 #include "android-base/stringprintf.h"
23 #include "config/ConfigKey.h"
24 #include "config/ConfigManager.h"
25 #include "guardrail/StatsdStats.h"
26 #include "storage/StorageManager.h"
27 #include "subscriber/SubscriberReporter.h"
28 
29 #include <android-base/file.h>
30 #include <android-base/stringprintf.h>
31 #include <binder/IPCThreadState.h>
32 #include <binder/IServiceManager.h>
33 #include <binder/PermissionController.h>
34 #include <dirent.h>
35 #include <frameworks/base/cmds/statsd/src/statsd_config.pb.h>
36 #include <private/android_filesystem_config.h>
37 #include <utils/Looper.h>
38 #include <utils/String16.h>
39 #include <statslog.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <sys/system_properties.h>
43 #include <unistd.h>
44 
45 using namespace android;
46 
47 using android::base::StringPrintf;
48 
49 namespace android {
50 namespace os {
51 namespace statsd {
52 
53 constexpr const char* kPermissionDump = "android.permission.DUMP";
54 constexpr const char* kPermissionUsage = "android.permission.PACKAGE_USAGE_STATS";
55 
56 constexpr const char* kOpUsage = "android:get_usage_stats";
57 
58 #define STATS_SERVICE_DIR "/data/misc/stats-service"
59 
ok()60 static binder::Status ok() {
61     return binder::Status::ok();
62 }
63 
exception(uint32_t code,const std::string & msg)64 static binder::Status exception(uint32_t code, const std::string& msg) {
65     ALOGE("%s (%d)", msg.c_str(), code);
66     return binder::Status::fromExceptionCode(code, String8(msg.c_str()));
67 }
68 
checkUid(uid_t expectedUid)69 binder::Status checkUid(uid_t expectedUid) {
70     uid_t uid = IPCThreadState::self()->getCallingUid();
71     if (uid == expectedUid || uid == AID_ROOT) {
72         return ok();
73     } else {
74         return exception(binder::Status::EX_SECURITY,
75                 StringPrintf("UID %d is not expected UID %d", uid, expectedUid));
76     }
77 }
78 
checkDumpAndUsageStats(const String16 & packageName)79 binder::Status checkDumpAndUsageStats(const String16& packageName) {
80     pid_t pid = IPCThreadState::self()->getCallingPid();
81     uid_t uid = IPCThreadState::self()->getCallingUid();
82 
83     // Root, system, and shell always have access
84     if (uid == AID_ROOT || uid == AID_SYSTEM || uid == AID_SHELL) {
85         return ok();
86     }
87 
88     // Caller must be granted these permissions
89     if (!checkCallingPermission(String16(kPermissionDump))) {
90         return exception(binder::Status::EX_SECURITY,
91                 StringPrintf("UID %d / PID %d lacks permission %s", uid, pid, kPermissionDump));
92     }
93     if (!checkCallingPermission(String16(kPermissionUsage))) {
94         return exception(binder::Status::EX_SECURITY,
95                 StringPrintf("UID %d / PID %d lacks permission %s", uid, pid, kPermissionUsage));
96     }
97 
98     // Caller must also have usage stats op granted
99     PermissionController pc;
100     switch (pc.noteOp(String16(kOpUsage), uid, packageName)) {
101         case PermissionController::MODE_ALLOWED:
102         case PermissionController::MODE_DEFAULT:
103             return ok();
104         default:
105             return exception(binder::Status::EX_SECURITY,
106                     StringPrintf("UID %d / PID %d lacks app-op %s", uid, pid, kOpUsage));
107     }
108 }
109 
110 #define ENFORCE_UID(uid) {                                        \
111     binder::Status status = checkUid((uid));                      \
112     if (!status.isOk()) {                                         \
113         return status;                                            \
114     }                                                             \
115 }
116 
117 #define ENFORCE_DUMP_AND_USAGE_STATS(packageName) {               \
118     binder::Status status = checkDumpAndUsageStats(packageName);  \
119     if (!status.isOk()) {                                         \
120         return status;                                            \
121     }                                                             \
122 }
123 
StatsService(const sp<Looper> & handlerLooper)124 StatsService::StatsService(const sp<Looper>& handlerLooper)
125     : mAnomalyAlarmMonitor(new AlarmMonitor(MIN_DIFF_TO_UPDATE_REGISTERED_ALARM_SECS,
126        [](const sp<IStatsCompanionService>& sc, int64_t timeMillis) {
127            if (sc != nullptr) {
128                sc->setAnomalyAlarm(timeMillis);
129                StatsdStats::getInstance().noteRegisteredAnomalyAlarmChanged();
130            }
131        },
__anon24fc2e590202(const sp<IStatsCompanionService>& sc) 132        [](const sp<IStatsCompanionService>& sc) {
133            if (sc != nullptr) {
134                sc->cancelAnomalyAlarm();
135                StatsdStats::getInstance().noteRegisteredAnomalyAlarmChanged();
136            }
137        })),
138    mPeriodicAlarmMonitor(new AlarmMonitor(MIN_DIFF_TO_UPDATE_REGISTERED_ALARM_SECS,
__anon24fc2e590302(const sp<IStatsCompanionService>& sc, int64_t timeMillis) 139       [](const sp<IStatsCompanionService>& sc, int64_t timeMillis) {
140            if (sc != nullptr) {
141                sc->setAlarmForSubscriberTriggering(timeMillis);
142                StatsdStats::getInstance().noteRegisteredPeriodicAlarmChanged();
143            }
144       },
__anon24fc2e590402(const sp<IStatsCompanionService>& sc) 145       [](const sp<IStatsCompanionService>& sc) {
146            if (sc != nullptr) {
147                sc->cancelAlarmForSubscriberTriggering();
148                StatsdStats::getInstance().noteRegisteredPeriodicAlarmChanged();
149            }
150 
151       }))  {
152     mUidMap = new UidMap();
153     StatsPuller::SetUidMap(mUidMap);
154     mConfigManager = new ConfigManager();
155     mProcessor = new StatsLogProcessor(mUidMap, mAnomalyAlarmMonitor, mPeriodicAlarmMonitor,
__anon24fc2e590502(const ConfigKey& key) 156                                        getElapsedRealtimeNs(), [this](const ConfigKey& key) {
157         sp<IStatsCompanionService> sc = getStatsCompanionService();
158         auto receiver = mConfigManager->GetConfigReceiver(key);
159         if (sc == nullptr) {
160             VLOG("Could not find StatsCompanionService");
161             return false;
162         } else if (receiver == nullptr) {
163             VLOG("Statscompanion could not find a broadcast receiver for %s",
164                  key.ToString().c_str());
165             return false;
166         } else {
167             sc->sendDataBroadcast(receiver, mProcessor->getLastReportTimeNs(key));
168             return true;
169         }
170     }
171     );
172 
173     mConfigManager->AddListener(mProcessor);
174 
175     init_system_properties();
176 }
177 
~StatsService()178 StatsService::~StatsService() {
179 }
180 
init_system_properties()181 void StatsService::init_system_properties() {
182     mEngBuild = false;
183     const prop_info* buildType = __system_property_find("ro.build.type");
184     if (buildType != NULL) {
185         __system_property_read_callback(buildType, init_build_type_callback, this);
186     }
187 }
188 
init_build_type_callback(void * cookie,const char *,const char * value,uint32_t serial)189 void StatsService::init_build_type_callback(void* cookie, const char* /*name*/, const char* value,
190                                             uint32_t serial) {
191     if (0 == strcmp("eng", value) || 0 == strcmp("userdebug", value)) {
192         reinterpret_cast<StatsService*>(cookie)->mEngBuild = true;
193     }
194 }
195 
196 /**
197  * Implement our own because the default binder implementation isn't
198  * properly handling SHELL_COMMAND_TRANSACTION.
199  */
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)200 status_t StatsService::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
201                                   uint32_t flags) {
202     switch (code) {
203         case SHELL_COMMAND_TRANSACTION: {
204             int in = data.readFileDescriptor();
205             int out = data.readFileDescriptor();
206             int err = data.readFileDescriptor();
207             int argc = data.readInt32();
208             Vector<String8> args;
209             for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
210                 args.add(String8(data.readString16()));
211             }
212             sp<IShellCallback> shellCallback = IShellCallback::asInterface(data.readStrongBinder());
213             sp<IResultReceiver> resultReceiver =
214                     IResultReceiver::asInterface(data.readStrongBinder());
215 
216             FILE* fin = fdopen(in, "r");
217             FILE* fout = fdopen(out, "w");
218             FILE* ferr = fdopen(err, "w");
219 
220             if (fin == NULL || fout == NULL || ferr == NULL) {
221                 resultReceiver->send(NO_MEMORY);
222             } else {
223                 err = command(fin, fout, ferr, args);
224                 resultReceiver->send(err);
225             }
226 
227             if (fin != NULL) {
228                 fflush(fin);
229                 fclose(fin);
230             }
231             if (fout != NULL) {
232                 fflush(fout);
233                 fclose(fout);
234             }
235             if (fout != NULL) {
236                 fflush(ferr);
237                 fclose(ferr);
238             }
239 
240             return NO_ERROR;
241         }
242         default: { return BnStatsManager::onTransact(code, data, reply, flags); }
243     }
244 }
245 
246 /**
247  * Write debugging data about statsd.
248  */
dump(int fd,const Vector<String16> & args)249 status_t StatsService::dump(int fd, const Vector<String16>& args) {
250     if (!checkCallingPermission(String16(kPermissionDump))) {
251         return PERMISSION_DENIED;
252     }
253     FILE* out = fdopen(fd, "w");
254     if (out == NULL) {
255         return NO_MEMORY;  // the fd is already open
256     }
257 
258     bool verbose = false;
259     bool proto = false;
260     if (args.size() > 0 && !args[0].compare(String16("-v"))) {
261         verbose = true;
262     }
263     if (args.size() > 0 && !args[args.size()-1].compare(String16("--proto"))) {
264         proto = true;
265     }
266 
267     dump_impl(out, verbose, proto);
268 
269     fclose(out);
270     return NO_ERROR;
271 }
272 
273 /**
274  * Write debugging data about statsd in text or proto format.
275  */
dump_impl(FILE * out,bool verbose,bool proto)276 void StatsService::dump_impl(FILE* out, bool verbose, bool proto) {
277     if (proto) {
278         vector<uint8_t> data;
279         StatsdStats::getInstance().dumpStats(&data, false); // does not reset statsdStats.
280         for (size_t i = 0; i < data.size(); i ++) {
281             fprintf(out, "%c", data[i]);
282         }
283     } else {
284         StatsdStats::getInstance().dumpStats(out);
285         mProcessor->dumpStates(out, verbose);
286     }
287 }
288 
289 /**
290  * Implementation of the adb shell cmd stats command.
291  */
command(FILE * in,FILE * out,FILE * err,Vector<String8> & args)292 status_t StatsService::command(FILE* in, FILE* out, FILE* err, Vector<String8>& args) {
293     uid_t uid = IPCThreadState::self()->getCallingUid();
294     if (uid != AID_ROOT && uid != AID_SHELL) {
295         return PERMISSION_DENIED;
296     }
297 
298     const int argCount = args.size();
299     if (argCount >= 1) {
300         // adb shell cmd stats config ...
301         if (!args[0].compare(String8("config"))) {
302             return cmd_config(in, out, err, args);
303         }
304 
305         if (!args[0].compare(String8("print-uid-map"))) {
306             return cmd_print_uid_map(out, args);
307         }
308 
309         if (!args[0].compare(String8("dump-report"))) {
310             return cmd_dump_report(out, err, args);
311         }
312 
313         if (!args[0].compare(String8("pull-source")) && args.size() > 1) {
314             return cmd_print_pulled_metrics(out, args);
315         }
316 
317         if (!args[0].compare(String8("send-broadcast"))) {
318             return cmd_trigger_broadcast(out, args);
319         }
320 
321         if (!args[0].compare(String8("print-stats"))) {
322             return cmd_print_stats(out, args);
323         }
324 
325         if (!args[0].compare(String8("meminfo"))) {
326             return cmd_dump_memory_info(out);
327         }
328 
329         if (!args[0].compare(String8("write-to-disk"))) {
330             return cmd_write_data_to_disk(out);
331         }
332 
333         if (!args[0].compare(String8("log-app-breadcrumb"))) {
334             return cmd_log_app_breadcrumb(out, args);
335         }
336 
337         if (!args[0].compare(String8("clear-puller-cache"))) {
338             return cmd_clear_puller_cache(out);
339         }
340 
341         if (!args[0].compare(String8("print-logs"))) {
342             return cmd_print_logs(out, args);
343         }
344     }
345 
346     print_cmd_help(out);
347     return NO_ERROR;
348 }
349 
print_cmd_help(FILE * out)350 void StatsService::print_cmd_help(FILE* out) {
351     fprintf(out,
352             "usage: adb shell cmd stats print-stats-log [tag_required] "
353             "[timestamp_nsec_optional]\n");
354     fprintf(out, "\n");
355     fprintf(out, "\n");
356     fprintf(out, "usage: adb shell cmd stats meminfo\n");
357     fprintf(out, "\n");
358     fprintf(out, "  Prints the malloc debug information. You need to run the following first: \n");
359     fprintf(out, "   # adb shell stop\n");
360     fprintf(out, "   # adb shell setprop libc.debug.malloc.program statsd \n");
361     fprintf(out, "   # adb shell setprop libc.debug.malloc.options backtrace \n");
362     fprintf(out, "   # adb shell start\n");
363     fprintf(out, "\n");
364     fprintf(out, "\n");
365     fprintf(out, "usage: adb shell cmd stats print-uid-map [PKG]\n");
366     fprintf(out, "\n");
367     fprintf(out, "  Prints the UID, app name, version mapping.\n");
368     fprintf(out, "  PKG           Optional package name to print the uids of the package\n");
369     fprintf(out, "\n");
370     fprintf(out, "\n");
371     fprintf(out, "usage: adb shell cmd stats pull-source [int] \n");
372     fprintf(out, "\n");
373     fprintf(out, "  Prints the output of a pulled metrics source (int indicates source)\n");
374     fprintf(out, "\n");
375     fprintf(out, "\n");
376     fprintf(out, "usage: adb shell cmd stats write-to-disk \n");
377     fprintf(out, "\n");
378     fprintf(out, "  Flushes all data on memory to disk.\n");
379     fprintf(out, "\n");
380     fprintf(out, "\n");
381     fprintf(out, "usage: adb shell cmd stats log-app-breadcrumb [UID] LABEL STATE\n");
382     fprintf(out, "  Writes an AppBreadcrumbReported event to the statslog buffer.\n");
383     fprintf(out, "  UID           The uid to use. It is only possible to pass a UID\n");
384     fprintf(out, "                parameter on eng builds. If UID is omitted the calling\n");
385     fprintf(out, "                uid is used.\n");
386     fprintf(out, "  LABEL         Integer in [0, 15], as per atoms.proto.\n");
387     fprintf(out, "  STATE         Integer in [0, 3], as per atoms.proto.\n");
388     fprintf(out, "\n");
389     fprintf(out, "\n");
390     fprintf(out, "usage: adb shell cmd stats config remove [UID] [NAME]\n");
391     fprintf(out, "usage: adb shell cmd stats config update [UID] NAME\n");
392     fprintf(out, "\n");
393     fprintf(out, "  Adds, updates or removes a configuration. The proto should be in\n");
394     fprintf(out, "  wire-encoded protobuf format and passed via stdin. If no UID and name is\n");
395     fprintf(out, "  provided, then all configs will be removed from memory and disk.\n");
396     fprintf(out, "\n");
397     fprintf(out, "  UID           The uid to use. It is only possible to pass the UID\n");
398     fprintf(out, "                parameter on eng builds. If UID is omitted the calling\n");
399     fprintf(out, "                uid is used.\n");
400     fprintf(out, "  NAME          The per-uid name to use\n");
401     fprintf(out, "\n");
402     fprintf(out, "\n              *Note: If both UID and NAME are omitted then all configs will\n");
403     fprintf(out, "\n                     be removed from memory and disk!\n");
404     fprintf(out, "\n");
405     fprintf(out, "usage: adb shell cmd stats dump-report [UID] NAME [--proto]\n");
406     fprintf(out, "  Dump all metric data for a configuration.\n");
407     fprintf(out, "  UID           The uid of the configuration. It is only possible to pass\n");
408     fprintf(out, "                the UID parameter on eng builds. If UID is omitted the\n");
409     fprintf(out, "                calling uid is used.\n");
410     fprintf(out, "  NAME          The name of the configuration\n");
411     fprintf(out, "  --proto       Print proto binary.\n");
412     fprintf(out, "\n");
413     fprintf(out, "\n");
414     fprintf(out, "usage: adb shell cmd stats send-broadcast [UID] NAME\n");
415     fprintf(out, "  Send a broadcast that triggers the subscriber to fetch metrics.\n");
416     fprintf(out, "  UID           The uid of the configuration. It is only possible to pass\n");
417     fprintf(out, "                the UID parameter on eng builds. If UID is omitted the\n");
418     fprintf(out, "                calling uid is used.\n");
419     fprintf(out, "  NAME          The name of the configuration\n");
420     fprintf(out, "\n");
421     fprintf(out, "\n");
422     fprintf(out, "usage: adb shell cmd stats print-stats\n");
423     fprintf(out, "  Prints some basic stats.\n");
424     fprintf(out, "  --proto       Print proto binary instead of string format.\n");
425     fprintf(out, "\n");
426     fprintf(out, "\n");
427     fprintf(out, "usage: adb shell cmd stats clear-puller-cache\n");
428     fprintf(out, "  Clear cached puller data.\n");
429     fprintf(out, "\n");
430     fprintf(out, "usage: adb shell cmd stats print-logs\n");
431     fprintf(out, "      Only works on eng build\n");
432 }
433 
cmd_trigger_broadcast(FILE * out,Vector<String8> & args)434 status_t StatsService::cmd_trigger_broadcast(FILE* out, Vector<String8>& args) {
435     string name;
436     bool good = false;
437     int uid;
438     const int argCount = args.size();
439     if (argCount == 2) {
440         // Automatically pick the UID
441         uid = IPCThreadState::self()->getCallingUid();
442         // TODO: What if this isn't a binder call? Should we fail?
443         name.assign(args[1].c_str(), args[1].size());
444         good = true;
445     } else if (argCount == 3) {
446         // If it's a userdebug or eng build, then the shell user can
447         // impersonate other uids.
448         if (mEngBuild) {
449             const char* s = args[1].c_str();
450             if (*s != '\0') {
451                 char* end = NULL;
452                 uid = strtol(s, &end, 0);
453                 if (*end == '\0') {
454                     name.assign(args[2].c_str(), args[2].size());
455                     good = true;
456                 }
457             }
458         } else {
459             fprintf(out,
460                     "The metrics can only be dumped for other UIDs on eng or userdebug "
461                             "builds.\n");
462         }
463     }
464     if (!good) {
465         print_cmd_help(out);
466         return UNKNOWN_ERROR;
467     }
468     ConfigKey key(uid, StrToInt64(name));
469     auto receiver = mConfigManager->GetConfigReceiver(key);
470     sp<IStatsCompanionService> sc = getStatsCompanionService();
471     if (sc == nullptr) {
472         VLOG("Could not access statsCompanion");
473     } else if (receiver == nullptr) {
474         VLOG("Could not find receiver for %s, %s", args[1].c_str(), args[2].c_str())
475     } else {
476         sc->sendDataBroadcast(receiver, mProcessor->getLastReportTimeNs(key));
477         VLOG("StatsService::trigger broadcast succeeded to %s, %s", args[1].c_str(),
478              args[2].c_str());
479     }
480 
481     return NO_ERROR;
482 }
483 
cmd_config(FILE * in,FILE * out,FILE * err,Vector<String8> & args)484 status_t StatsService::cmd_config(FILE* in, FILE* out, FILE* err, Vector<String8>& args) {
485     const int argCount = args.size();
486     if (argCount >= 2) {
487         if (args[1] == "update" || args[1] == "remove") {
488             bool good = false;
489             int uid = -1;
490             string name;
491 
492             if (argCount == 3) {
493                 // Automatically pick the UID
494                 uid = IPCThreadState::self()->getCallingUid();
495                 // TODO: What if this isn't a binder call? Should we fail?
496                 name.assign(args[2].c_str(), args[2].size());
497                 good = true;
498             } else if (argCount == 4) {
499                 // If it's a userdebug or eng build, then the shell user can
500                 // impersonate other uids.
501                 if (mEngBuild) {
502                     const char* s = args[2].c_str();
503                     if (*s != '\0') {
504                         char* end = NULL;
505                         uid = strtol(s, &end, 0);
506                         if (*end == '\0') {
507                             name.assign(args[3].c_str(), args[3].size());
508                             good = true;
509                         }
510                     }
511                 } else {
512                     fprintf(err,
513                             "The config can only be set for other UIDs on eng or userdebug "
514                             "builds.\n");
515                 }
516             } else if (argCount == 2 && args[1] == "remove") {
517                 good = true;
518             }
519 
520             if (!good) {
521                 // If arg parsing failed, print the help text and return an error.
522                 print_cmd_help(out);
523                 return UNKNOWN_ERROR;
524             }
525 
526             if (args[1] == "update") {
527                 char* endp;
528                 int64_t configID = strtoll(name.c_str(), &endp, 10);
529                 if (endp == name.c_str() || *endp != '\0') {
530                     fprintf(err, "Error parsing config ID.\n");
531                     return UNKNOWN_ERROR;
532                 }
533 
534                 // Read stream into buffer.
535                 string buffer;
536                 if (!android::base::ReadFdToString(fileno(in), &buffer)) {
537                     fprintf(err, "Error reading stream for StatsConfig.\n");
538                     return UNKNOWN_ERROR;
539                 }
540 
541                 // Parse buffer.
542                 StatsdConfig config;
543                 if (!config.ParseFromString(buffer)) {
544                     fprintf(err, "Error parsing proto stream for StatsConfig.\n");
545                     return UNKNOWN_ERROR;
546                 }
547 
548                 // Add / update the config.
549                 mConfigManager->UpdateConfig(ConfigKey(uid, configID), config);
550             } else {
551                 if (argCount == 2) {
552                     cmd_remove_all_configs(out);
553                 } else {
554                     // Remove the config.
555                     mConfigManager->RemoveConfig(ConfigKey(uid, StrToInt64(name)));
556                 }
557             }
558 
559             return NO_ERROR;
560         }
561     }
562     print_cmd_help(out);
563     return UNKNOWN_ERROR;
564 }
565 
cmd_dump_report(FILE * out,FILE * err,const Vector<String8> & args)566 status_t StatsService::cmd_dump_report(FILE* out, FILE* err, const Vector<String8>& args) {
567     if (mProcessor != nullptr) {
568         int argCount = args.size();
569         bool good = false;
570         bool proto = false;
571         int uid;
572         string name;
573         if (!std::strcmp("--proto", args[argCount-1].c_str())) {
574             proto = true;
575             argCount -= 1;
576         }
577         if (argCount == 2) {
578             // Automatically pick the UID
579             uid = IPCThreadState::self()->getCallingUid();
580             // TODO: What if this isn't a binder call? Should we fail?
581             name.assign(args[1].c_str(), args[1].size());
582             good = true;
583         } else if (argCount == 3) {
584             // If it's a userdebug or eng build, then the shell user can
585             // impersonate other uids.
586             if (mEngBuild) {
587                 const char* s = args[1].c_str();
588                 if (*s != '\0') {
589                     char* end = NULL;
590                     uid = strtol(s, &end, 0);
591                     if (*end == '\0') {
592                         name.assign(args[2].c_str(), args[2].size());
593                         good = true;
594                     }
595                 }
596             } else {
597                 fprintf(out,
598                         "The metrics can only be dumped for other UIDs on eng or userdebug "
599                         "builds.\n");
600             }
601         }
602         if (good) {
603             vector<uint8_t> data;
604             mProcessor->onDumpReport(ConfigKey(uid, StrToInt64(name)), getElapsedRealtimeNs(),
605                                      false /* include_current_bucket*/, ADB_DUMP, &data);
606             // TODO: print the returned StatsLogReport to file instead of printing to logcat.
607             if (proto) {
608                 for (size_t i = 0; i < data.size(); i ++) {
609                     fprintf(out, "%c", data[i]);
610                 }
611             } else {
612                 fprintf(out, "Dump report for Config [%d,%s]\n", uid, name.c_str());
613                 fprintf(out, "See the StatsLogReport in logcat...\n");
614             }
615             return android::OK;
616         } else {
617             // If arg parsing failed, print the help text and return an error.
618             print_cmd_help(out);
619             return UNKNOWN_ERROR;
620         }
621     } else {
622         fprintf(out, "Log processor does not exist...\n");
623         return UNKNOWN_ERROR;
624     }
625 }
626 
cmd_print_stats(FILE * out,const Vector<String8> & args)627 status_t StatsService::cmd_print_stats(FILE* out, const Vector<String8>& args) {
628     int argCount = args.size();
629     bool proto = false;
630     if (!std::strcmp("--proto", args[argCount-1].c_str())) {
631         proto = true;
632         argCount -= 1;
633     }
634     StatsdStats& statsdStats = StatsdStats::getInstance();
635     if (proto) {
636         vector<uint8_t> data;
637         statsdStats.dumpStats(&data, false); // does not reset statsdStats.
638         for (size_t i = 0; i < data.size(); i ++) {
639             fprintf(out, "%c", data[i]);
640         }
641 
642     } else {
643         vector<ConfigKey> configs = mConfigManager->GetAllConfigKeys();
644         for (const ConfigKey& key : configs) {
645             fprintf(out, "Config %s uses %zu bytes\n", key.ToString().c_str(),
646                     mProcessor->GetMetricsSize(key));
647         }
648         statsdStats.dumpStats(out);
649     }
650     return NO_ERROR;
651 }
652 
cmd_print_uid_map(FILE * out,const Vector<String8> & args)653 status_t StatsService::cmd_print_uid_map(FILE* out, const Vector<String8>& args) {
654     if (args.size() > 1) {
655         string pkg;
656         pkg.assign(args[1].c_str(), args[1].size());
657         auto uids = mUidMap->getAppUid(pkg);
658         fprintf(out, "%s -> [ ", pkg.c_str());
659         for (const auto& uid : uids) {
660             fprintf(out, "%d ", uid);
661         }
662         fprintf(out, "]\n");
663     } else {
664         mUidMap->printUidMap(out);
665     }
666     return NO_ERROR;
667 }
668 
cmd_write_data_to_disk(FILE * out)669 status_t StatsService::cmd_write_data_to_disk(FILE* out) {
670     fprintf(out, "Writing data to disk\n");
671     mProcessor->WriteDataToDisk(ADB_DUMP);
672     return NO_ERROR;
673 }
674 
cmd_log_app_breadcrumb(FILE * out,const Vector<String8> & args)675 status_t StatsService::cmd_log_app_breadcrumb(FILE* out, const Vector<String8>& args) {
676     bool good = false;
677     int32_t uid;
678     int32_t label;
679     int32_t state;
680     const int argCount = args.size();
681     if (argCount == 3) {
682         // Automatically pick the UID
683         uid = IPCThreadState::self()->getCallingUid();
684         label = atoi(args[1].c_str());
685         state = atoi(args[2].c_str());
686         good = true;
687     } else if (argCount == 4) {
688         uid = atoi(args[1].c_str());
689         // If it's a userdebug or eng build, then the shell user can impersonate other uids.
690         // Otherwise, the uid must match the actual caller's uid.
691         if (mEngBuild || (uid >= 0 && (uid_t)uid == IPCThreadState::self()->getCallingUid())) {
692             label = atoi(args[2].c_str());
693             state = atoi(args[3].c_str());
694             good = true;
695         } else {
696             fprintf(out,
697                     "Selecting a UID for writing AppBreadcrumb can only be done for other UIDs "
698                             "on eng or userdebug builds.\n");
699         }
700     }
701     if (good) {
702         fprintf(out, "Logging AppBreadcrumbReported(%d, %d, %d) to statslog.\n", uid, label, state);
703         android::util::stats_write(android::util::APP_BREADCRUMB_REPORTED, uid, label, state);
704     } else {
705         print_cmd_help(out);
706         return UNKNOWN_ERROR;
707     }
708     return NO_ERROR;
709 }
710 
cmd_print_pulled_metrics(FILE * out,const Vector<String8> & args)711 status_t StatsService::cmd_print_pulled_metrics(FILE* out, const Vector<String8>& args) {
712     int s = atoi(args[1].c_str());
713     vector<shared_ptr<LogEvent> > stats;
714     if (mStatsPullerManager.Pull(s, getElapsedRealtimeNs(), &stats)) {
715         for (const auto& it : stats) {
716             fprintf(out, "Pull from %d: %s\n", s, it->ToString().c_str());
717         }
718         fprintf(out, "Pull from %d: Received %zu elements\n", s, stats.size());
719         return NO_ERROR;
720     }
721     return UNKNOWN_ERROR;
722 }
723 
cmd_remove_all_configs(FILE * out)724 status_t StatsService::cmd_remove_all_configs(FILE* out) {
725     fprintf(out, "Removing all configs...\n");
726     VLOG("StatsService::cmd_remove_all_configs was called");
727     mConfigManager->RemoveAllConfigs();
728     StorageManager::deleteAllFiles(STATS_SERVICE_DIR);
729     return NO_ERROR;
730 }
731 
cmd_dump_memory_info(FILE * out)732 status_t StatsService::cmd_dump_memory_info(FILE* out) {
733     fprintf(out, "meminfo not available.\n");
734     return NO_ERROR;
735 }
736 
cmd_clear_puller_cache(FILE * out)737 status_t StatsService::cmd_clear_puller_cache(FILE* out) {
738     IPCThreadState* ipc = IPCThreadState::self();
739     VLOG("StatsService::cmd_clear_puller_cache with Pid %i, Uid %i",
740             ipc->getCallingPid(), ipc->getCallingUid());
741     if (checkCallingPermission(String16(kPermissionDump))) {
742         int cleared = mStatsPullerManager.ForceClearPullerCache();
743         fprintf(out, "Puller removed %d cached data!\n", cleared);
744         return NO_ERROR;
745     } else {
746         return PERMISSION_DENIED;
747     }
748 }
749 
cmd_print_logs(FILE * out,const Vector<String8> & args)750 status_t StatsService::cmd_print_logs(FILE* out, const Vector<String8>& args) {
751     IPCThreadState* ipc = IPCThreadState::self();
752     VLOG("StatsService::cmd_print_logs with Pid %i, Uid %i", ipc->getCallingPid(),
753          ipc->getCallingUid());
754     if (checkCallingPermission(String16(kPermissionDump))) {
755         bool enabled = true;
756         if (args.size() >= 2) {
757             enabled = atoi(args[1].c_str()) != 0;
758         }
759         mProcessor->setPrintLogs(enabled);
760         return NO_ERROR;
761     } else {
762         return PERMISSION_DENIED;
763     }
764 }
765 
informAllUidData(const vector<int32_t> & uid,const vector<int64_t> & version,const vector<String16> & app)766 Status StatsService::informAllUidData(const vector<int32_t>& uid, const vector<int64_t>& version,
767                                       const vector<String16>& app) {
768     ENFORCE_UID(AID_SYSTEM);
769 
770     VLOG("StatsService::informAllUidData was called");
771     mUidMap->updateMap(getElapsedRealtimeNs(), uid, version, app);
772     VLOG("StatsService::informAllUidData succeeded");
773 
774     return Status::ok();
775 }
776 
informOnePackage(const String16 & app,int32_t uid,int64_t version)777 Status StatsService::informOnePackage(const String16& app, int32_t uid, int64_t version) {
778     ENFORCE_UID(AID_SYSTEM);
779 
780     VLOG("StatsService::informOnePackage was called");
781     mUidMap->updateApp(getElapsedRealtimeNs(), app, uid, version);
782     return Status::ok();
783 }
784 
informOnePackageRemoved(const String16 & app,int32_t uid)785 Status StatsService::informOnePackageRemoved(const String16& app, int32_t uid) {
786     ENFORCE_UID(AID_SYSTEM);
787 
788     VLOG("StatsService::informOnePackageRemoved was called");
789     mUidMap->removeApp(getElapsedRealtimeNs(), app, uid);
790     mConfigManager->RemoveConfigs(uid);
791     return Status::ok();
792 }
793 
informAnomalyAlarmFired()794 Status StatsService::informAnomalyAlarmFired() {
795     ENFORCE_UID(AID_SYSTEM);
796 
797     VLOG("StatsService::informAnomalyAlarmFired was called");
798     int64_t currentTimeSec = getElapsedRealtimeSec();
799     std::unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>> alarmSet =
800             mAnomalyAlarmMonitor->popSoonerThan(static_cast<uint32_t>(currentTimeSec));
801     if (alarmSet.size() > 0) {
802         VLOG("Found an anomaly alarm that fired.");
803         mProcessor->onAnomalyAlarmFired(currentTimeSec * NS_PER_SEC, alarmSet);
804     } else {
805         VLOG("Cannot find an anomaly alarm that fired. Perhaps it was recently cancelled.");
806     }
807     return Status::ok();
808 }
809 
informAlarmForSubscriberTriggeringFired()810 Status StatsService::informAlarmForSubscriberTriggeringFired() {
811     ENFORCE_UID(AID_SYSTEM);
812 
813     VLOG("StatsService::informAlarmForSubscriberTriggeringFired was called");
814     int64_t currentTimeSec = getElapsedRealtimeSec();
815     std::unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>> alarmSet =
816             mPeriodicAlarmMonitor->popSoonerThan(static_cast<uint32_t>(currentTimeSec));
817     if (alarmSet.size() > 0) {
818         VLOG("Found periodic alarm fired.");
819         mProcessor->onPeriodicAlarmFired(currentTimeSec * NS_PER_SEC, alarmSet);
820     } else {
821         ALOGW("Cannot find an periodic alarm that fired. Perhaps it was recently cancelled.");
822     }
823     return Status::ok();
824 }
825 
informPollAlarmFired()826 Status StatsService::informPollAlarmFired() {
827     ENFORCE_UID(AID_SYSTEM);
828 
829     VLOG("StatsService::informPollAlarmFired was called");
830     mProcessor->informPullAlarmFired(getElapsedRealtimeNs());
831     VLOG("StatsService::informPollAlarmFired succeeded");
832     return Status::ok();
833 }
834 
systemRunning()835 Status StatsService::systemRunning() {
836     ENFORCE_UID(AID_SYSTEM);
837 
838     // When system_server is up and running, schedule the dropbox task to run.
839     VLOG("StatsService::systemRunning");
840     sayHiToStatsCompanion();
841     return Status::ok();
842 }
843 
informDeviceShutdown()844 Status StatsService::informDeviceShutdown() {
845     ENFORCE_UID(AID_SYSTEM);
846     VLOG("StatsService::informDeviceShutdown");
847     mProcessor->WriteDataToDisk(DEVICE_SHUTDOWN);
848     return Status::ok();
849 }
850 
sayHiToStatsCompanion()851 void StatsService::sayHiToStatsCompanion() {
852     sp<IStatsCompanionService> statsCompanion = getStatsCompanionService();
853     if (statsCompanion != nullptr) {
854         VLOG("Telling statsCompanion that statsd is ready");
855         statsCompanion->statsdReady();
856     } else {
857         VLOG("Could not access statsCompanion");
858     }
859 }
860 
statsCompanionReady()861 Status StatsService::statsCompanionReady() {
862     ENFORCE_UID(AID_SYSTEM);
863 
864     VLOG("StatsService::statsCompanionReady was called");
865     sp<IStatsCompanionService> statsCompanion = getStatsCompanionService();
866     if (statsCompanion == nullptr) {
867         return Status::fromExceptionCode(
868                 Status::EX_NULL_POINTER,
869                 "statscompanion unavailable despite it contacting statsd!");
870     }
871     VLOG("StatsService::statsCompanionReady linking to statsCompanion.");
872     IInterface::asBinder(statsCompanion)->linkToDeath(this);
873     mStatsPullerManager.SetStatsCompanionService(statsCompanion);
874     mAnomalyAlarmMonitor->setStatsCompanionService(statsCompanion);
875     mPeriodicAlarmMonitor->setStatsCompanionService(statsCompanion);
876     SubscriberReporter::getInstance().setStatsCompanionService(statsCompanion);
877     return Status::ok();
878 }
879 
Startup()880 void StatsService::Startup() {
881     mConfigManager->Startup();
882 }
883 
OnLogEvent(LogEvent * event,bool reconnectionStarts)884 void StatsService::OnLogEvent(LogEvent* event, bool reconnectionStarts) {
885     mProcessor->OnLogEvent(event, reconnectionStarts);
886 }
887 
getData(int64_t key,const String16 & packageName,vector<uint8_t> * output)888 Status StatsService::getData(int64_t key, const String16& packageName, vector<uint8_t>* output) {
889     ENFORCE_DUMP_AND_USAGE_STATS(packageName);
890 
891     IPCThreadState* ipc = IPCThreadState::self();
892     VLOG("StatsService::getData with Pid %i, Uid %i", ipc->getCallingPid(), ipc->getCallingUid());
893     ConfigKey configKey(ipc->getCallingUid(), key);
894     mProcessor->onDumpReport(configKey, getElapsedRealtimeNs(), false /* include_current_bucket*/,
895                              GET_DATA_CALLED, output);
896     return Status::ok();
897 }
898 
getMetadata(const String16 & packageName,vector<uint8_t> * output)899 Status StatsService::getMetadata(const String16& packageName, vector<uint8_t>* output) {
900     ENFORCE_DUMP_AND_USAGE_STATS(packageName);
901 
902     IPCThreadState* ipc = IPCThreadState::self();
903     VLOG("StatsService::getMetadata with Pid %i, Uid %i", ipc->getCallingPid(),
904          ipc->getCallingUid());
905     StatsdStats::getInstance().dumpStats(output, false); // Don't reset the counters.
906     return Status::ok();
907 }
908 
addConfiguration(int64_t key,const vector<uint8_t> & config,const String16 & packageName)909 Status StatsService::addConfiguration(int64_t key, const vector <uint8_t>& config,
910                                       const String16& packageName) {
911     ENFORCE_DUMP_AND_USAGE_STATS(packageName);
912 
913     IPCThreadState* ipc = IPCThreadState::self();
914     if (addConfigurationChecked(ipc->getCallingUid(), key, config)) {
915         return Status::ok();
916     } else {
917         ALOGE("Could not parse malformatted StatsdConfig");
918         return Status::fromExceptionCode(binder::Status::EX_ILLEGAL_ARGUMENT,
919                                          "config does not correspond to a StatsdConfig proto");
920     }
921 }
922 
addConfigurationChecked(int uid,int64_t key,const vector<uint8_t> & config)923 bool StatsService::addConfigurationChecked(int uid, int64_t key, const vector<uint8_t>& config) {
924     ConfigKey configKey(uid, key);
925     StatsdConfig cfg;
926     if (config.size() > 0) {  // If the config is empty, skip parsing.
927         if (!cfg.ParseFromArray(&config[0], config.size())) {
928             return false;
929         }
930     }
931     mConfigManager->UpdateConfig(configKey, cfg);
932     return true;
933 }
934 
removeDataFetchOperation(int64_t key,const String16 & packageName)935 Status StatsService::removeDataFetchOperation(int64_t key, const String16& packageName) {
936     ENFORCE_DUMP_AND_USAGE_STATS(packageName);
937 
938     IPCThreadState* ipc = IPCThreadState::self();
939     ConfigKey configKey(ipc->getCallingUid(), key);
940     mConfigManager->RemoveConfigReceiver(configKey);
941     return Status::ok();
942 }
943 
setDataFetchOperation(int64_t key,const sp<android::IBinder> & intentSender,const String16 & packageName)944 Status StatsService::setDataFetchOperation(int64_t key,
945                                            const sp<android::IBinder>& intentSender,
946                                            const String16& packageName) {
947     ENFORCE_DUMP_AND_USAGE_STATS(packageName);
948 
949     IPCThreadState* ipc = IPCThreadState::self();
950     ConfigKey configKey(ipc->getCallingUid(), key);
951     mConfigManager->SetConfigReceiver(configKey, intentSender);
952     if (StorageManager::hasConfigMetricsReport(configKey)) {
953         VLOG("StatsService::setDataFetchOperation marking configKey %s to dump reports on disk",
954              configKey.ToString().c_str());
955         mProcessor->noteOnDiskData(configKey);
956     }
957     return Status::ok();
958 }
959 
removeConfiguration(int64_t key,const String16 & packageName)960 Status StatsService::removeConfiguration(int64_t key, const String16& packageName) {
961     ENFORCE_DUMP_AND_USAGE_STATS(packageName);
962 
963     IPCThreadState* ipc = IPCThreadState::self();
964     ConfigKey configKey(ipc->getCallingUid(), key);
965     mConfigManager->RemoveConfig(configKey);
966     SubscriberReporter::getInstance().removeConfig(configKey);
967     return Status::ok();
968 }
969 
setBroadcastSubscriber(int64_t configId,int64_t subscriberId,const sp<android::IBinder> & intentSender,const String16 & packageName)970 Status StatsService::setBroadcastSubscriber(int64_t configId,
971                                             int64_t subscriberId,
972                                             const sp<android::IBinder>& intentSender,
973                                             const String16& packageName) {
974     ENFORCE_DUMP_AND_USAGE_STATS(packageName);
975 
976     VLOG("StatsService::setBroadcastSubscriber called.");
977     IPCThreadState* ipc = IPCThreadState::self();
978     ConfigKey configKey(ipc->getCallingUid(), configId);
979     SubscriberReporter::getInstance()
980             .setBroadcastSubscriber(configKey, subscriberId, intentSender);
981     return Status::ok();
982 }
983 
unsetBroadcastSubscriber(int64_t configId,int64_t subscriberId,const String16 & packageName)984 Status StatsService::unsetBroadcastSubscriber(int64_t configId,
985                                               int64_t subscriberId,
986                                               const String16& packageName) {
987     ENFORCE_DUMP_AND_USAGE_STATS(packageName);
988 
989     VLOG("StatsService::unsetBroadcastSubscriber called.");
990     IPCThreadState* ipc = IPCThreadState::self();
991     ConfigKey configKey(ipc->getCallingUid(), configId);
992     SubscriberReporter::getInstance()
993             .unsetBroadcastSubscriber(configKey, subscriberId);
994     return Status::ok();
995 }
996 
sendAppBreadcrumbAtom(int32_t label,int32_t state)997 Status StatsService::sendAppBreadcrumbAtom(int32_t label, int32_t state) {
998     // Permission check not necessary as it's meant for applications to write to
999     // statsd.
1000     android::util::stats_write(util::APP_BREADCRUMB_REPORTED,
1001                                IPCThreadState::self()->getCallingUid(), label,
1002                                state);
1003     return Status::ok();
1004 }
1005 
binderDied(const wp<IBinder> & who)1006 void StatsService::binderDied(const wp <IBinder>& who) {
1007     ALOGW("statscompanion service died");
1008     StatsdStats::getInstance().noteSystemServerRestart(getWallClockSec());
1009     if (mProcessor != nullptr) {
1010         ALOGW("Reset statsd upon system server restars.");
1011         mProcessor->WriteDataToDisk(STATSCOMPANION_DIED);
1012         mProcessor->resetConfigs();
1013     }
1014     mAnomalyAlarmMonitor->setStatsCompanionService(nullptr);
1015     mPeriodicAlarmMonitor->setStatsCompanionService(nullptr);
1016     SubscriberReporter::getInstance().setStatsCompanionService(nullptr);
1017     mStatsPullerManager.SetStatsCompanionService(nullptr);
1018 }
1019 
1020 }  // namespace statsd
1021 }  // namespace os
1022 }  // namespace android
1023