diff options
Diffstat (limited to 'cmds')
36 files changed, 1072 insertions, 161 deletions
diff --git a/cmds/app_process/Android.bp b/cmds/app_process/Android.bp index 8be95e4659b4..07221f97c72b 100644 --- a/cmds/app_process/Android.bp +++ b/cmds/app_process/Android.bp @@ -5,11 +5,13 @@ cc_binary { multilib: { lib32: { - version_script: ":art_sigchain_version_script32.txt", + // TODO(b/142944043): Remove version script when libsigchain is a DSO. + version_script: "version-script32.txt", suffix: "32", }, lib64: { - version_script: ":art_sigchain_version_script64.txt", + // TODO(b/142944043): Remove version script when libsigchain is a DSO. + version_script: "version-script64.txt", suffix: "64", }, }, diff --git a/cmds/app_process/version-script32.txt b/cmds/app_process/version-script32.txt new file mode 100644 index 000000000000..70810e0b7173 --- /dev/null +++ b/cmds/app_process/version-script32.txt @@ -0,0 +1,15 @@ +{ +global: + EnsureFrontOfChain; + AddSpecialSignalHandlerFn; + RemoveSpecialSignalHandlerFn; + SkipAddSignalHandler; + bsd_signal; + sigaction; + sigaction64; + signal; + sigprocmask; + sigprocmask64; +local: + *; +}; diff --git a/cmds/app_process/version-script64.txt b/cmds/app_process/version-script64.txt new file mode 100644 index 000000000000..7bcd76b50f87 --- /dev/null +++ b/cmds/app_process/version-script64.txt @@ -0,0 +1,14 @@ +{ +global: + EnsureFrontOfChain; + AddSpecialSignalHandlerFn; + RemoveSpecialSignalHandlerFn; + SkipAddSignalHandler; + sigaction; + sigaction64; + signal; + sigprocmask; + sigprocmask64; +local: + *; +}; diff --git a/cmds/bootanimation/Android.bp b/cmds/bootanimation/Android.bp index 3e5877b05708..c60d08b2bda1 100644 --- a/cmds/bootanimation/Android.bp +++ b/cmds/bootanimation/Android.bp @@ -28,6 +28,8 @@ cc_binary { name: "bootanimation", defaults: ["bootanimation_defaults"], + header_libs: ["jni_headers"], + shared_libs: [ "libOpenSLES", "libbootanimation", diff --git a/cmds/bootanimation/bootanim.rc b/cmds/bootanimation/bootanim.rc index 9f4f314a4324..ad4de0ab737a 100644 --- a/cmds/bootanimation/bootanim.rc +++ b/cmds/bootanimation/bootanim.rc @@ -5,4 +5,4 @@ service bootanim /system/bin/bootanimation disabled oneshot ioprio rt 0 - writepid /dev/stune/top-app/tasks + task_profiles MaxPerformance diff --git a/cmds/device_config/Android.bp b/cmds/device_config/Android.bp new file mode 100644 index 000000000000..67e014a20506 --- /dev/null +++ b/cmds/device_config/Android.bp @@ -0,0 +1,7 @@ +// Copyright 2018 The Android Open Source Project +// + +sh_binary { + name: "device_config", + src: "device_config", +} diff --git a/cmds/device_config/Android.mk b/cmds/device_config/Android.mk deleted file mode 100644 index 4041e01927df..000000000000 --- a/cmds/device_config/Android.mk +++ /dev/null @@ -1,10 +0,0 @@ -# Copyright 2018 The Android Open Source Project -# -LOCAL_PATH:= $(call my-dir) - -include $(CLEAR_VARS) -LOCAL_MODULE := device_config -LOCAL_SRC_FILES := device_config -LOCAL_MODULE_CLASS := EXECUTABLES -LOCAL_MODULE_TAGS := optional -include $(BUILD_PREBUILT) diff --git a/cmds/idmap2/Android.bp b/cmds/idmap2/Android.bp index 4c77ba402595..4e57e884ee3e 100644 --- a/cmds/idmap2/Android.bp +++ b/cmds/idmap2/Android.bp @@ -23,9 +23,16 @@ cc_defaults { "misc-*", "readability-*", ], + tidy_checks_as_errors: [ + "modernize-*", + "-modernize-avoid-c-arrays", + "-modernize-use-trailing-return-type", + "android-*", + "misc-*", + "readability-*", + ], tidy_flags: [ "-system-headers", - "-warnings-as-errors=*", ], } diff --git a/cmds/idmap2/idmap2/Create.cpp b/cmds/idmap2/idmap2/Create.cpp index bb8d92737563..f482191b09a8 100644 --- a/cmds/idmap2/idmap2/Create.cpp +++ b/cmds/idmap2/idmap2/Create.cpp @@ -50,7 +50,7 @@ Result<Unit> Create(const std::vector<std::string>& args) { std::string overlay_apk_path; std::string idmap_path; std::vector<std::string> policies; - bool ignore_overlayable; + bool ignore_overlayable = false; const CommandLineOptions opts = CommandLineOptions("idmap2 create") diff --git a/cmds/idmap2/idmap2/Dump.cpp b/cmds/idmap2/idmap2/Dump.cpp index 8716bf313ed0..47f442aab235 100644 --- a/cmds/idmap2/idmap2/Dump.cpp +++ b/cmds/idmap2/idmap2/Dump.cpp @@ -39,7 +39,7 @@ using android::idmap2::Unit; Result<Unit> Dump(const std::vector<std::string>& args) { SYSTRACE << "Dump " << args; std::string idmap_path; - bool verbose; + bool verbose = false; const CommandLineOptions opts = CommandLineOptions("idmap2 dump") diff --git a/cmds/idmap2/idmap2d/Idmap2Service.cpp b/cmds/idmap2/idmap2d/Idmap2Service.cpp index 8ee79f61520a..d7237763a2e5 100644 --- a/cmds/idmap2/idmap2d/Idmap2Service.cpp +++ b/cmds/idmap2/idmap2d/Idmap2Service.cpp @@ -113,10 +113,10 @@ Status Idmap2Service::verifyIdmap(const std::string& overlay_apk_path, Status Idmap2Service::createIdmap(const std::string& target_apk_path, const std::string& overlay_apk_path, int32_t fulfilled_policies, bool enforce_overlayable, int32_t user_id ATTRIBUTE_UNUSED, - std::unique_ptr<std::string>* _aidl_return) { + std::optional<std::string>* _aidl_return) { assert(_aidl_return); SYSTRACE << "Idmap2Service::createIdmap " << target_apk_path << " " << overlay_apk_path; - _aidl_return->reset(nullptr); + _aidl_return->reset(); const PolicyBitmask policy_bitmask = ConvertAidlArgToPolicyBitmask(fulfilled_policies); @@ -155,7 +155,7 @@ Status Idmap2Service::createIdmap(const std::string& target_apk_path, return error("failed to write to idmap path " + idmap_path); } - *_aidl_return = std::make_unique<std::string>(idmap_path); + *_aidl_return = idmap_path; return ok(); } diff --git a/cmds/idmap2/idmap2d/Idmap2Service.h b/cmds/idmap2/idmap2d/Idmap2Service.h index 1aab0598449b..73a236a961af 100644 --- a/cmds/idmap2/idmap2d/Idmap2Service.h +++ b/cmds/idmap2/idmap2d/Idmap2Service.h @@ -20,7 +20,7 @@ #include <android-base/unique_fd.h> #include <binder/BinderService.h> -#include <memory> +#include <optional> #include <string> #include "android/os/BnIdmap2.h" @@ -45,7 +45,7 @@ class Idmap2Service : public BinderService<Idmap2Service>, public BnIdmap2 { binder::Status createIdmap(const std::string& target_apk_path, const std::string& overlay_apk_path, int32_t fulfilled_policies, bool enforce_overlayable, int32_t user_id, - std::unique_ptr<std::string>* _aidl_return); + std::optional<std::string>* _aidl_return); }; } // namespace android::os diff --git a/cmds/idmap2/tests/Idmap2BinaryTests.cpp b/cmds/idmap2/tests/Idmap2BinaryTests.cpp index 8a48f4b8e6d5..499eb99af290 100644 --- a/cmds/idmap2/tests/Idmap2BinaryTests.cpp +++ b/cmds/idmap2/tests/Idmap2BinaryTests.cpp @@ -131,7 +131,6 @@ TEST_F(Idmap2BinaryTests, Dump) { ASSERT_NE(result->stdout.find("0x7f02000c -> 0x7f020000 string/str1"), std::string::npos); ASSERT_NE(result->stdout.find("0x7f02000e -> 0x7f020001 string/str3"), std::string::npos); ASSERT_NE(result->stdout.find("0x7f02000f -> 0x7f020002 string/str4"), std::string::npos); - ASSERT_EQ(result->stdout.find("00000210: 007f target package id"), std::string::npos); // clang-format off result = ExecuteBinary({"idmap2", diff --git a/cmds/incident/main.cpp b/cmds/incident/main.cpp index eb2b98a666b9..d6c6c39dd1d8 100644 --- a/cmds/incident/main.cpp +++ b/cmds/incident/main.cpp @@ -52,9 +52,13 @@ public: virtual Status onReportServiceStatus(const String16& service, int32_t status); virtual Status onReportFinished(); virtual Status onReportFailed(); + + int getExitCodeOrElse(int defaultCode); + private: + int mExitCode; }; -StatusListener::StatusListener() +StatusListener::StatusListener(): mExitCode(-1) { } @@ -89,7 +93,7 @@ StatusListener::onReportFinished() { fprintf(stderr, "done\n"); ALOGD("done\n"); - exit(0); + mExitCode = 0; return Status::ok(); } @@ -98,10 +102,15 @@ StatusListener::onReportFailed() { fprintf(stderr, "failed\n"); ALOGD("failed\n"); - exit(1); + mExitCode = 1; return Status::ok(); } +int +StatusListener::getExitCodeOrElse(int defaultCode) { + return mExitCode == -1 ? defaultCode : mExitCode; +} + // ================================================================================ static void section_list(FILE* out) { IncidentSection sections[INCIDENT_SECTION_COUNT]; @@ -201,20 +210,13 @@ parse_receiver_arg(const string& arg, string* pkg, string* cls) static int stream_output(const int read_fd, const int write_fd) { while (true) { - uint8_t buf[4096]; - ssize_t amt = TEMP_FAILURE_RETRY(read(read_fd, buf, sizeof(buf))); + int amt = splice(read_fd, NULL, write_fd, NULL, 4096, 0); if (amt < 0) { - break; - } else if (amt == 0) { - break; - } - - ssize_t wamt = TEMP_FAILURE_RETRY(write(write_fd, buf, amt)); - if (wamt != amt) { return errno; + } else if (amt == 0) { + return 0; } } - return 0; } // ================================================================================ @@ -384,7 +386,7 @@ main(int argc, char** argv) // Wait for the result and print out the data they send. //IPCThreadState::self()->joinThreadPool(); - return stream_output(fds[0], STDOUT_FILENO); + return listener->getExitCodeOrElse(stream_output(fds[0], STDOUT_FILENO)); } else if (destination == DEST_DUMPSTATE) { // Call into the service sp<StatusListener> listener(new StatusListener()); @@ -393,7 +395,7 @@ main(int argc, char** argv) fprintf(stderr, "reportIncident returned \"%s\"\n", status.toString8().string()); return 1; } - return stream_output(fds[0], STDOUT_FILENO); + return listener->getExitCodeOrElse(stream_output(fds[0], STDOUT_FILENO)); } else { status = service->reportIncident(args); if (!status.isOk()) { diff --git a/cmds/incidentd/src/Section.cpp b/cmds/incidentd/src/Section.cpp index f476fcf91bd5..1cc761fa359f 100644 --- a/cmds/incidentd/src/Section.cpp +++ b/cmds/incidentd/src/Section.cpp @@ -512,8 +512,8 @@ status_t LogSection::BlockingCall(int pipeWriteFd) const { // Open log buffer and getting logs since last retrieved time if any. unique_ptr<logger_list, void (*)(logger_list*)> loggers( gLastLogsRetrieved.find(mLogID) == gLastLogsRetrieved.end() - ? android_logger_list_alloc(ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 0, 0) - : android_logger_list_alloc_time(ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, + ? android_logger_list_alloc(ANDROID_LOG_NONBLOCK, 0, 0) + : android_logger_list_alloc_time(ANDROID_LOG_NONBLOCK, gLastLogsRetrieved[mLogID], 0), android_logger_list_free); diff --git a/cmds/screencap/screencap.cpp b/cmds/screencap/screencap.cpp index 0bb1af13643c..4410f1c4570c 100644 --- a/cmds/screencap/screencap.cpp +++ b/cmds/screencap/screencap.cpp @@ -24,6 +24,7 @@ #include <linux/fb.h> #include <sys/ioctl.h> #include <sys/mman.h> +#include <sys/wait.h> #include <binder/ProcessState.h> @@ -99,11 +100,38 @@ static uint32_t dataSpaceToInt(ui::Dataspace d) } static status_t notifyMediaScanner(const char* fileName) { - String8 cmd("am broadcast -a android.intent.action.MEDIA_SCANNER_SCAN_FILE -d file://"); - cmd.append(fileName); - cmd.append(" > /dev/null"); - int result = system(cmd.string()); - if (result < 0) { + std::string filePath("file://"); + filePath.append(fileName); + char *cmd[] = { + (char*) "am", + (char*) "broadcast", + (char*) "am", + (char*) "android.intent.action.MEDIA_SCANNER_SCAN_FILE", + (char*) "-d", + &filePath[0], + nullptr + }; + + int status; + int pid = fork(); + if (pid < 0){ + fprintf(stderr, "Unable to fork in order to send intent for media scanner.\n"); + return UNKNOWN_ERROR; + } + if (pid == 0){ + int fd = open("/dev/null", O_WRONLY); + if (fd < 0){ + fprintf(stderr, "Unable to open /dev/null for media scanner stdout redirection.\n"); + exit(1); + } + dup2(fd, 1); + int result = execvp(cmd[0], cmd); + close(fd); + exit(result); + } + wait(&status); + + if (status < 0) { fprintf(stderr, "Unable to broadcast intent for media scanner.\n"); return UNKNOWN_ERROR; } diff --git a/cmds/statsd/Android.bp b/cmds/statsd/Android.bp index 88db89dbd279..24fbf21f463f 100644 --- a/cmds/statsd/Android.bp +++ b/cmds/statsd/Android.bp @@ -50,6 +50,7 @@ cc_defaults { srcs: [ ":statsd_aidl", + ":ICarStatsService.aidl", "src/active_config_list.proto", "src/statsd_config.proto", "src/uid_data.proto", @@ -69,6 +70,7 @@ cc_defaults { "src/config/ConfigKey.cpp", "src/config/ConfigListener.cpp", "src/config/ConfigManager.cpp", + "src/external/CarStatsPuller.cpp", "src/external/GpuStatsPuller.cpp", "src/external/Perfetto.cpp", "src/external/StatsPuller.cpp", @@ -380,7 +382,7 @@ cc_benchmark { // ==== java proto device library (for test only) ============================== java_library { name: "statsdprotolite", - sdk_version: "core_platform", + sdk_version: "core_current", proto: { type: "lite", include_dirs: ["external/protobuf/src"], diff --git a/cmds/statsd/src/StatsLogProcessor.cpp b/cmds/statsd/src/StatsLogProcessor.cpp index c9e026bf231c..af4f67501ec6 100644 --- a/cmds/statsd/src/StatsLogProcessor.cpp +++ b/cmds/statsd/src/StatsLogProcessor.cpp @@ -320,11 +320,6 @@ void StatsLogProcessor::OnConfigUpdatedLocked( mAnomalyAlarmMonitor, mPeriodicAlarmMonitor); if (newMetricsManager->isConfigValid()) { mUidMap->OnConfigUpdated(key); - if (newMetricsManager->shouldAddUidMapListener()) { - // We have to add listener after the MetricsManager is constructed because it's - // not safe to create wp or sp from this pointer inside its constructor. - mUidMap->addListener(newMetricsManager.get()); - } newMetricsManager->refreshTtl(timestampNs); mMetricsManagers[key] = newMetricsManager; VLOG("StatsdConfig valid"); @@ -743,6 +738,32 @@ int64_t StatsLogProcessor::getLastReportTimeNs(const ConfigKey& key) { } } +void StatsLogProcessor::notifyAppUpgrade(const int64_t& eventTimeNs, const string& apk, + const int uid, const int64_t version) { + std::lock_guard<std::mutex> lock(mMetricsMutex); + ALOGW("Received app upgrade"); + for (auto it : mMetricsManagers) { + it.second->notifyAppUpgrade(eventTimeNs, apk, uid, version); + } +} + +void StatsLogProcessor::notifyAppRemoved(const int64_t& eventTimeNs, const string& apk, + const int uid) { + std::lock_guard<std::mutex> lock(mMetricsMutex); + ALOGW("Received app removed"); + for (auto it : mMetricsManagers) { + it.second->notifyAppRemoved(eventTimeNs, apk, uid); + } +} + +void StatsLogProcessor::onUidMapReceived(const int64_t& eventTimeNs) { + std::lock_guard<std::mutex> lock(mMetricsMutex); + ALOGW("Received uid map"); + for (auto it : mMetricsManagers) { + it.second->onUidMapReceived(eventTimeNs); + } +} + void StatsLogProcessor::noteOnDiskData(const ConfigKey& key) { std::lock_guard<std::mutex> lock(mMetricsMutex); mOnDiskDataConfigs.insert(key); diff --git a/cmds/statsd/src/StatsLogProcessor.h b/cmds/statsd/src/StatsLogProcessor.h index 313e16d19b62..0d2b33ee0ce1 100644 --- a/cmds/statsd/src/StatsLogProcessor.h +++ b/cmds/statsd/src/StatsLogProcessor.h @@ -32,7 +32,7 @@ namespace os { namespace statsd { -class StatsLogProcessor : public ConfigListener { +class StatsLogProcessor : public ConfigListener, public virtual PackageInfoListener { public: StatsLogProcessor(const sp<UidMap>& uidMap, const sp<StatsPullerManager>& pullerManager, const sp<AlarmMonitor>& anomalyAlarmMonitor, @@ -91,6 +91,16 @@ public: /* Sets the active status/ttl for all configs and metrics to the status in ActiveConfigList. */ void SetConfigsActiveState(const ActiveConfigList& activeConfigList, int64_t currentTimeNs); + /* Notify all MetricsManagers of app upgrades */ + void notifyAppUpgrade(const int64_t& eventTimeNs, const string& apk, const int uid, + const int64_t version) override; + + /* Notify all MetricsManagers of app removals */ + void notifyAppRemoved(const int64_t& eventTimeNs, const string& apk, const int uid) override; + + /* Notify all MetricsManagers of uid map snapshots received */ + void onUidMapReceived(const int64_t& eventTimeNs) override; + // Reset all configs. void resetConfigs(); diff --git a/cmds/statsd/src/StatsService.cpp b/cmds/statsd/src/StatsService.cpp index d6c1380fa253..cb497fc4a79a 100644 --- a/cmds/statsd/src/StatsService.cpp +++ b/cmds/statsd/src/StatsService.cpp @@ -200,6 +200,7 @@ StatsService::StatsService(const sp<Looper>& handlerLooper, shared_ptr<LogEventQ } }); + mUidMap->setListener(mProcessor); mConfigManager->AddListener(mProcessor); init_system_properties(); @@ -266,7 +267,9 @@ status_t StatsService::onTransact(uint32_t code, const Parcel& data, Parcel* rep IResultReceiver::asInterface(data.readStrongBinder()); err = command(in, out, err, args, resultReceiver); - resultReceiver->send(err); + if (resultReceiver != nullptr) { + resultReceiver->send(err); + } return NO_ERROR; } default: { return BnStatsManager::onTransact(code, data, reply, flags); } @@ -411,13 +414,20 @@ status_t StatsService::command(int in, int out, int err, Vector<String8>& args, return cmd_trigger_active_config_broadcast(out, args); } if (!args[0].compare(String8("data-subscribe"))) { - if (mShellSubscriber == nullptr) { - mShellSubscriber = new ShellSubscriber(mUidMap, mPullerManager); + { + std::lock_guard<std::mutex> lock(mShellSubscriberMutex); + if (mShellSubscriber == nullptr) { + mShellSubscriber = new ShellSubscriber(mUidMap, mPullerManager); + } } int timeoutSec = -1; if (argCount >= 2) { timeoutSec = atoi(args[1].c_str()); } + if (resultReceiver == nullptr) { + ALOGI("Null resultReceiver given, no subscription will be started"); + return UNEXPECTED_NULL; + } mShellSubscriber->startNewSubscription(in, out, resultReceiver, timeoutSec); return NO_ERROR; } @@ -1385,7 +1395,10 @@ Status StatsService::sendBinaryPushStateChangedAtom(const android::String16& tra Status StatsService::sendWatchdogRollbackOccurredAtom(const int32_t rollbackTypeIn, const android::String16& packageNameIn, - const int64_t packageVersionCodeIn) { + const int64_t packageVersionCodeIn, + const int32_t rollbackReasonIn, + const android::String16& + failingPackageNameIn) { // Note: We skip the usage stats op check here since we do not have a package name. // This is ok since we are overloading the usage_stats permission. // This method only sends data, it does not receive it. @@ -1407,7 +1420,8 @@ Status StatsService::sendWatchdogRollbackOccurredAtom(const int32_t rollbackType } android::util::stats_write(android::util::WATCHDOG_ROLLBACK_OCCURRED, - rollbackTypeIn, String8(packageNameIn).string(), packageVersionCodeIn); + rollbackTypeIn, String8(packageNameIn).string(), packageVersionCodeIn, + rollbackReasonIn, String8(failingPackageNameIn).string()); // Fast return to save disk read. if (rollbackTypeIn != android::util::WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_SUCCESS diff --git a/cmds/statsd/src/StatsService.h b/cmds/statsd/src/StatsService.h index dba2502eeae7..f6ac6360723b 100644 --- a/cmds/statsd/src/StatsService.h +++ b/cmds/statsd/src/StatsService.h @@ -199,7 +199,9 @@ public: virtual Status sendWatchdogRollbackOccurredAtom( const int32_t rollbackTypeIn, const android::String16& packageNameIn, - const int64_t packageVersionCodeIn) override; + const int64_t packageVersionCodeIn, + const int32_t rollbackReasonIn, + const android::String16& failingPackageNameIn) override; /** * Binder call to get registered experiment IDs. @@ -376,6 +378,10 @@ private: sp<ShellSubscriber> mShellSubscriber; + /** + * Mutex for setting the shell subscriber + */ + mutable mutex mShellSubscriberMutex; std::shared_ptr<LogEventQueue> mEventQueue; FRIEND_TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart); diff --git a/cmds/statsd/src/atoms.proto b/cmds/statsd/src/atoms.proto index 6cd34aecaa0f..c8f2efab3783 100644 --- a/cmds/statsd/src/atoms.proto +++ b/cmds/statsd/src/atoms.proto @@ -41,6 +41,7 @@ import "frameworks/base/core/proto/android/server/location/enums.proto"; import "frameworks/base/core/proto/android/service/procstats_enum.proto"; import "frameworks/base/core/proto/android/service/usb.proto"; import "frameworks/base/core/proto/android/stats/connectivity/network_stack.proto"; +import "frameworks/base/core/proto/android/stats/connectivity/tethering.proto"; import "frameworks/base/core/proto/android/stats/dnsresolver/dns_resolver.proto"; import "frameworks/base/core/proto/android/stats/devicepolicy/device_policy.proto"; import "frameworks/base/core/proto/android/stats/devicepolicy/device_policy_enums.proto"; @@ -149,8 +150,10 @@ message Atom { HardwareFailed hardware_failed = 72; PhysicalDropDetected physical_drop_detected = 73; ChargeCyclesReported charge_cycles_reported = 74; - MobileConnectionStateChanged mobile_connection_state_changed = 75; - MobileRadioTechnologyChanged mobile_radio_technology_changed = 76; + MobileConnectionStateChanged mobile_connection_state_changed = + 75 [(log_from_module) = "telephony"]; + MobileRadioTechnologyChanged mobile_radio_technology_changed = + 76 [(log_from_module) = "telephony"]; UsbDeviceAttached usb_device_attached = 77; AppCrashOccurred app_crash_occurred = 78; ANROccurred anr_occurred = 79; @@ -351,15 +354,22 @@ message Atom { 228 [(allow_from_any_uid) = true]; PerfettoUploaded perfetto_uploaded = 229 [(log_from_module) = "perfetto"]; + VmsClientConnectionStateChanged vms_client_connection_state_changed = 230; BootTimeEventDuration boot_time_event_duration_reported = 239; BootTimeEventElapsedTime boot_time_event_elapsed_time_reported = 240; BootTimeEventUtcTime boot_time_event_utc_time_reported = 241; BootTimeEventErrorCode boot_time_event_error_code_reported = 242; - UserspaceRebootReported userspace_reboot_reported = 243; + UserspaceRebootReported userspace_reboot_reported = 243 [(log_from_module) = "framework"]; + SnapshotMergeReported snapshot_merge_reported = 255; + NetworkIpProvisioningReported network_ip_provisioning_reported = 290 [(log_from_module) = "network_stack"]; + NetworkDhcpRenewReported network_dhcp_renew_reported = 291 [(log_from_module) = "network_stack"]; + NetworkValidationReported network_validation_reported = 292 [(log_from_module) = "network_stack"]; + NetworkStackQuirkReported network_stack_quirk_reported = 293 [(log_from_module) = "network_stack"]; + NetworkTetheringReported network_tethering_reported = 303 [(log_from_module) = "network_tethering"]; } // Pulled events will start at field 10000. - // Next: 10062 + // Next: 10080 oneof pulled { WifiBytesTransfer wifi_bytes_transfer = 10000; WifiBytesTransferByFgBg wifi_bytes_transfer_by_fg_bg = 10001; @@ -423,6 +433,13 @@ message Atom { CoolingDevice cooling_device = 10059; AppOps app_ops = 10060; ProcessSystemIonHeapSize process_system_ion_heap_size = 10061; + VmsClientStats vms_client_stats = 10065; + NotificationRemoteViews notification_remote_views = 10066; + VoiceCallSession voice_call_session = 10076 [(log_from_module) = "telephony"]; + VoiceCallRatUsage voice_call_rat_usage = 10077 [(log_from_module) = "telephony"]; + SimSlotState sim_slot_state = 10078 [(log_from_module) = "telephony"]; + SupportedRadioAccessFamily supported_radio_access_family = + 10079 [(log_from_module) = "telephony"]; } // DO NOT USE field numbers above 100,000 in AOSP. @@ -1527,7 +1544,7 @@ message BluetoothEnabledStateChanged { * Logged from: * packages/apps/Bluetooth/src/com/android/bluetooth/btservice/RemoteDevices.java * - * Next Tag: 5 + * Next Tag: 6 */ message BluetoothConnectionStateChanged { // The state of the connection. @@ -1549,6 +1566,15 @@ message BluetoothConnectionStateChanged { // Size: 32 byte // Default: null or empty if the device identifier is not known optional bytes new_obfuscated_id = 4 [(android.os.statsd.log_mode) = MODE_BYTES]; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 5; } /** @@ -1557,7 +1583,7 @@ message BluetoothConnectionStateChanged { * Logged from: * packages/apps/Bluetooth/src/com/android/bluetooth/btservice/AdapterProperties.java * - * Next Tag: 3 + * Next Tag: 4 */ message BluetoothAclConnectionStateChanged { // An identifier that can be used to match events for this device. @@ -1570,6 +1596,15 @@ message BluetoothAclConnectionStateChanged { // The state of the connection. // Eg: CONNECTING, CONNECTED, DISCONNECTING, DISCONNECTED. optional android.bluetooth.ConnectionStateEnum state = 2; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 3; } /** @@ -1579,7 +1614,7 @@ message BluetoothAclConnectionStateChanged { * packages/apps/Bluetooth/src/com/android/bluetooth/hfp/HeadsetStateMachine.java * packages/apps/Bluetooth/src/com/android/bluetooth/hfp/HeadsetClientStateMachine.java * - * Next Tag: 4 + * Next Tag: 5 */ message BluetoothScoConnectionStateChanged { // An identifier that can be used to match events for this device. @@ -1595,6 +1630,15 @@ message BluetoothScoConnectionStateChanged { // Codec used for this SCO connection // Default: UNKNOWN optional android.bluetooth.hfp.ScoCodec codec = 3; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 4; } /** @@ -1616,6 +1660,15 @@ message BluetoothActiveDeviceChanged { // Size: 32 byte // Default: null or empty if there is no active device for this profile optional bytes obfuscated_id = 2 [(android.os.statsd.log_mode) = MODE_BYTES]; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 3; } // Logs when there is an event affecting Bluetooth device's link layer connection. @@ -1699,6 +1752,15 @@ message BluetoothLinkLayerConnectionEvent { // HCI reason code associated with this event // Default: STATUS_UNKNOWN optional android.bluetooth.hci.StatusEnum reason_code = 9; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 10; } /** @@ -1719,6 +1781,19 @@ message WatchdogRollbackOccurred { optional string package_name = 2; optional int32 package_version_code = 3; + + enum RollbackReasonType { + REASON_UNKNOWN = 0; + REASON_NATIVE_CRASH = 1; + REASON_EXPLICIT_HEALTH_CHECK = 2; + REASON_APP_CRASH = 3; + REASON_APP_NOT_RESPONDING = 4; + } + optional RollbackReasonType rollback_reason = 4; + + // Set by RollbackPackageHealthObserver to be the package that is failing when a rollback + // is initiated. Empty if the package is unknown. + optional string failing_package_name = 5; } /** @@ -1741,6 +1816,15 @@ message BluetoothA2dpPlaybackStateChanged { // Current audio coding mode // Default: AUDIO_CODING_MODE_UNKNOWN optional android.bluetooth.a2dp.AudioCodingModeEnum audio_coding_mode = 3; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 4; } /** @@ -1779,6 +1863,15 @@ message BluetoothA2dpCodecConfigChanged { optional int64 codec_specific_2 = 8; optional int64 codec_specific_3 = 9; optional int64 codec_specific_4 = 10; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 11; } /** @@ -1821,6 +1914,15 @@ message BluetoothA2dpCodecCapabilityChanged { optional int64 codec_specific_2 = 8; optional int64 codec_specific_3 = 9; optional int64 codec_specific_4 = 10; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 11; } /** @@ -1844,6 +1946,15 @@ message BluetoothA2dpAudioUnderrunReported { // Number of bytes of PCM data that could not be read from the source // Default: 0 optional int32 num_missing_pcm_bytes = 3; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 4; } /** @@ -1874,6 +1985,15 @@ message BluetoothA2dpAudioOverrunReported { // Number of encoded bytes dropped in this event // Default: 0 optional int32 num_dropped_encoded_bytes = 5; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 6; } /** @@ -1905,6 +2025,15 @@ message BluetoothDeviceRssiReported { // Units: dBm // Invalid when an out of range value is reported optional int32 rssi = 4; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 5; } /** @@ -1932,6 +2061,15 @@ message BluetoothDeviceFailedContactCounterReported { // Range: uint16_t, 0-0xFFFF // Default: 0xFFFFF optional int32 failed_contact_counter = 4; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 5; } /** @@ -1959,6 +2097,15 @@ message BluetoothDeviceTxPowerLevelReported { // Units: dBm // Invalid when an out of range value is reported optional int32 transmit_power_level = 4; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 5; } /** @@ -2088,6 +2235,15 @@ message BluetoothDeviceInfoReported { optional string hardware_version = 6; // Software version of this device optional string software_version = 7; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 8; } /** @@ -2141,6 +2297,15 @@ message BluetoothSdpAttributeReported { optional int32 attribute_id = 3; // Attribute value for the particular attribute optional bytes attribute_value = 4 [(android.os.statsd.log_mode) = MODE_BYTES]; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 5; } /** @@ -2173,6 +2338,15 @@ message BluetoothBondStateChanged { // Unbond Reason // Default: UNBOND_REASON_UNKNOWN optional android.bluetooth.UnbondReasonEnum unbond_reason = 6; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 7; } /** @@ -2208,6 +2382,15 @@ message BluetoothClassicPairingEventReported { // A status value related to this specific event // Default: 0 optional int64 event_value = 7; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 8; } /** @@ -2233,6 +2416,15 @@ message BluetoothSmpPairingEventReported { // SMP failure reason code // Default: PAIRING_FAIL_REASON_DEFAULT optional android.bluetooth.smp.PairingFailReasonEnum smp_fail_reason = 4; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 5; } /** @@ -2271,6 +2463,15 @@ message BluetoothSocketConnectionStateChanged { optional int32 server_port = 8; // Whether this is a server listener socket optional android.bluetooth.SocketRoleEnum is_server = 9; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 10; } /** @@ -2294,6 +2495,15 @@ message BluetoothClassOfDeviceReported { // Also defined in: https://developer.android.com/reference/android/bluetooth/BluetoothClass // Default: 0 optional int32 class_of_device = 2; + // An identifier that can be used to match events for this device. + // The incremental identifier is locally generated and guaranteed not derived + // from any globally unique hardware id. + // For paired devices, it stays consistent between Bluetooth toggling for the + // same remote device. + // For unpaired devices, it stays consistent within the same Bluetooth adapter + // session for the same remote device. + // Default: 0 if the device's metric id is unknown. + optional int32 metric_id = 3; } /** @@ -3744,6 +3954,33 @@ message RoleRequestResultReported { } /** + * Logs when a Vehicle Maps Service client's connection state has changed + * + * Logged from: + * packages/services/Car/service/src/com/android/car/stats/VmsClientLog.java + */ +message VmsClientConnectionStateChanged { + // The UID of the VMS client app + optional int32 uid = 1 [(is_uid) = true]; + + enum State { + UNKNOWN = 0; + // Attempting to connect to the client + CONNECTING = 1; + // Client connection established + CONNECTED = 2; + // Client connection closed unexpectedly + DISCONNECTED = 3; + // Client connection closed by VMS + TERMINATED = 4; + // Error establishing the client connection + CONNECTION_ERROR = 5; + } + + optional State state = 2; +} + +/** * Represents boot time event with duration in ms. * * Logged from: bootstat and various system server components. Check each enums for details. @@ -3947,6 +4184,52 @@ message BootTimeEventErrorCode { optional int32 error_code = 2; } +/** + * Collects Virtual A/B statistics related to the use of dm-snapshot performed + * after an OTA. + * + * Logged from: + * - system/core/fs_mgr/libsnapshot/snapshot.cpp + * - system/core/fs_mgr/libsnapshot/snapshotctl.cpp + */ +message SnapshotMergeReported { + // Keep in sync with + // system/core/fs_mgr/libsnapshot/android/snapshot/snapshot.proto + enum UpdateState { + // No update or merge is in progress. + NONE = 0; + // An update is applying; snapshots may already exist. + INITIATED = 1; + // An update is pending, but has not been successfully booted yet. + UNVERIFIED = 2; + // The kernel is merging in the background. + MERGING = 3; + // Post-merge cleanup steps could not be completed due to a transient + // error, but the next reboot will finish any pending operations. + MERGE_NEEDS_REBOOT = 4; + // Merging is complete, and needs to be acknowledged. + MERGE_COMPLETED = 5; + // Merging failed due to an unrecoverable error. + MERGE_FAILED = 6; + // The update was implicitly cancelled, either by a rollback or a flash + // operation via fastboot. This state can only be returned by WaitForMerge. + CANCELLED = 7; + }; + + // Status of the update after the merge attempts. + optional UpdateState final_state = 1; + + // Time to complete a merge operation in milliseconds. + // A negative value corresponds to the case in which the merge operation + // was interrupted and resumed (e.g. in case of a system reboot during the + // merge). + optional int64 duration_millis = 2; + + // Number of reboots that occurred after issuing and before completing the + // merge of all the snapshot devices. + optional int32 intermediate_reboots = 3; +} + ////////////////////////////////////////////////////////////////////// // Pulled atoms below this line // ////////////////////////////////////////////////////////////////////// @@ -4961,6 +5244,24 @@ message ProcStatsPkgProc { optional ProcessStatsSectionProto proc_stats_section = 1; } +// Next Tag: 2 +message PackageRemoteViewInfoProto { + optional string package_name = 1; + // add per-package additional info here (like channels) +} + +// Next Tag: 2 +message NotificationRemoteViewsProto { + repeated PackageRemoteViewInfoProto package_remote_view_info = 1; +} + +/** + * Pulled from NotificationManagerService.java + */ +message NotificationRemoteViews { + optional NotificationRemoteViewsProto notification_remote_views = 1; +} + message PowerProfileProto { optional double cpu_suspend = 1; @@ -5554,6 +5855,24 @@ message AppCompacted { } /** + * Logs when a Tethering event occurs. + * + */ +message NetworkTetheringReported { + // tethering error code + optional android.stats.connectivity.ErrorCode error_code = 1; + + // tethering downstream type + optional android.stats.connectivity.DownstreamType downstream_type = 2; + + // transport type of upstream network + optional android.stats.connectivity.UpstreamType upstream_type = 3; + + // The user type of Tethering + optional android.stats.connectivity.UserType user_type= 4; +} + +/** * Logs a DNS lookup operation initiated by the system resolver on behalf of an application * invoking native APIs such as getaddrinfo() or Java APIs such as Network#getAllByName(). * @@ -5591,14 +5910,180 @@ message NetworkDnsEventReported { } /** + * logs the CapportApiData info + * Logged from: + * packages/modules/NetworkStack/src/com/android/server/connectivity/NetworkMonitor.java + */ +message CapportApiData { + // The TTL of the network connection provided by captive portal + optional int32 remaining_ttl_secs = 1; + + // The limit traffic data of the network connection provided by captive portal + optional int32 remaining_bytes = 2; + + // Is portal url option included in the DHCP packet (Yes, No) + optional bool has_portal_url = 3; + + // Is venue info (e.g. store info, maps, flight status) included (Yes, No) + optional bool has_venue_info = 4; +} + +/** + * logs a network Probe Event + * Logged from: + * packages/modules/NetworkStack/src/com/android/server/connectivity/NetworkMonitor.java + */ +message ProbeEvent { + // The probe type (http or https, or captive portal API...) + optional android.stats.connectivity.ProbeType probe_type = 1; + + // The latency in microseconds of the probe event + optional int32 latency_micros = 2; + + // The result of the probe event + optional android.stats.connectivity.ProbeResult probe_result = 3; + + // The CaptivePortal API info + optional CapportApiData capport_api_data = 4; +} + +/** + * log each ProbeEvent in ProbeEvents + * Logged from: + * packages/modules/NetworkStack/src/com/android/server/connectivity/NetworkMonitor.java + */ +message ProbeEvents { + // Record probe event during the validation + repeated ProbeEvent probe_event = 1; +} + +/** + * The DHCP (Dynamic Host Configuration Protocol) session info + * Logged from: + * packages/modules/NetworkStack/src/android/net/dhcp/DhcpClient.java + */ +message DhcpSession { + // The DHCP Feature(s) enabled in this session + repeated android.stats.connectivity.DhcpFeature used_features = 1; + + // The discover packet (re)transmit count + optional int32 discover_count = 2; + + // The request packet (re)transmit count + optional int32 request_count = 3; + + // The IPv4 address conflict count + // (only be meaningful when duplicate address detection is enabled) + optional int32 conflict_count = 4; + + // The DHCP packet parsing error code in this session + // (defined in android.net.metrics.DhcpErrorEvent) + repeated android.stats.connectivity.DhcpErrorCode error_code = 5; + + // The result of DHCP hostname transliteration + optional android.stats.connectivity.HostnameTransResult ht_result = 6; +} + +/** + * Logs Network IP provisioning event + * Logged from: + * packages/modules/NetworkStack/src/com/android/networkstack/metrics/NetworkIpProvisioningMetrics.java + */ +message NetworkIpProvisioningReported { + // Transport type (WIFI, CELLULAR, BLUETOOTH, ..) + optional android.stats.connectivity.TransportType transport_type = 1; + + // The latency in microseconds of IP Provisioning over IPV4 + optional int32 ipv4_latency_micros = 2; + + // The latency in microseconds of IP Provisioning over IPV6 + optional int32 ipv6_latency_micros = 3; + + // The time duration between provisioning start and end (success or failure) + optional int64 provisioning_duration_micros = 4; + + // The specific disconnect reason for this IP provisioning + optional android.stats.connectivity.DisconnectCode disconnect_code = 5; + + // Log DHCP session info (Only valid for IPv4) + optional DhcpSession dhcp_session = 6 [(log_mode) = MODE_BYTES]; + + // The random number between 0 ~ 999 for sampling + optional int32 random_number = 7; +} + +/** + * Logs Network DHCP Renew event + * Logged from: + * packages/modules/NetworkStack/src/android/net/dhcp/DhcpClient.java + */ +message NetworkDhcpRenewReported { + // Transport type (WIFI, CELLULAR, BLUETOOTH, ..) + optional android.stats.connectivity.TransportType transport_type = 1; + + // The request packet (re)transmit count + optional int32 request_count = 2; + + // The latency in microseconds of DHCP Renew + optional int32 latency_micros = 3; + + // The DHCP error code is defined in android.net.metrics.DhcpErrorEvent + optional android.stats.connectivity.DhcpErrorCode error_code = 4; + + // The result of DHCP renew + optional android.stats.connectivity.DhcpRenewResult renew_result = 5; + + // The random number between 0 ~ 999 for sampling + optional int32 random_number = 6; +} + +/** + * Logs Network Validation event + * Logged from: + * packages/modules/NetworkStack/src/com/android/server/connectivity/NetworkMonitor.java + */ +message NetworkValidationReported { + // Transport type (WIFI, CELLULAR, BLUETOOTH, ..) + optional android.stats.connectivity.TransportType transport_type = 1; + + // Record each probe event + optional ProbeEvents probe_events = 2 [(log_mode) = MODE_BYTES]; + + // The result of the network validation + optional android.stats.connectivity.ValidationResult validation_result = 3; + + // The latency in microseconds of network validation + optional int32 latency_micros = 4; + + // The validation index (the first validation attempt or second, third...) + optional int32 validation_index = 5; + + // The random number between 0 ~ 999 for sampling + optional int32 random_number = 6; +} + +/** + * Logs NetworkStack Quirk event + * Logged from: + * packages/modules/NetworkStack/src/com/android/networkstack/ + */ +message NetworkStackQuirkReported { + // Transport type (WIFI, CELLULAR, BLUETOOTH, ..) + optional android.stats.connectivity.TransportType transport_type = 1; + + // Record each Quirk event + optional android.stats.connectivity.NetworkQuirkEvent event = 2; +} + +/** * Logs when a data stall event occurs. * * Log from: - * frameworks/base/services/core/java/com/android/server/connectivity/NetworkMonitor.java + * packages/modules/NetworkStack/src/com/android/server/connectivity/NetworkMonitor.java */ message DataStallEvent { // Data stall evaluation type. - // See frameworks/base/services/core/java/com/android/server/connectivity/NetworkMonitor.java + // See packages/modules/NetworkStack/src/com/android/server/connectivity/NetworkMonitor.java // Refer to the definition of DATA_STALL_EVALUATION_TYPE_*. optional int32 evaluation_type = 1; // See definition in data_stall_event.proto. @@ -5611,6 +6096,10 @@ message DataStallEvent { optional com.android.server.connectivity.CellularData cell_info = 5 [(log_mode) = MODE_BYTES]; // See definition in data_stall_event.proto. optional com.android.server.connectivity.DnsEvent dns_event = 6 [(log_mode) = MODE_BYTES]; + // The tcp packets fail rate from the latest tcp polling. + optional int32 tcp_fail_rate = 7; + // Number of packets sent since the last received packet. + optional int32 tcp_sent_since_last_recv = 8; } /* @@ -7093,7 +7582,6 @@ message AppCompatibilityChangeReported { // Where it was logged from. optional Source source = 4; - } /** @@ -7131,6 +7619,35 @@ message PerfettoUploaded { } /** + * Pulls client metrics on data transferred via Vehicle Maps Service. + * Metrics are keyed by uid + layer. + * + * Pulled from: + * packages/services/Car/service/src/com/android/car/stats/CarStatsService.java + */ +message VmsClientStats { + // UID of the VMS client app + optional int32 uid = 1 [(is_uid) = true]; + + // VMS layer definition + optional int32 layer_type = 2; + optional int32 layer_channel = 3; + optional int32 layer_version = 4; + + // Bytes and packets sent by the client for the layer + optional int64 tx_bytes = 5; + optional int64 tx_packets = 6; + + // Bytes and packets received by the client for the layer + optional int64 rx_bytes = 7; + optional int64 rx_packets = 8; + + // Bytes and packets dropped due to client error + optional int64 dropped_bytes = 9; + optional int64 dropped_packets = 10; +} + +/** * Information about an OTA update attempt by update_engine. * Logged from platform/system/update_engine/metrics_reporter_android.cc */ @@ -7236,3 +7753,153 @@ message UserspaceRebootReported { // State of primary user's encryption storage at the moment boot completed. Always set. optional UserEncryptionState user_encryption_state = 3; } + +/** + * Pulls information for a single voice call. + * + * Each pull creates multiple atoms, one for each call. The sequence is randomized when pulled. + * + * Pulled from: + * frameworks/opt/telephony/src/java/com/android/internal/telephony/metrics/MetricsCollector.java + */ +message VoiceCallSession { + // Bearer (IMS or CS) when the call started. + optional android.telephony.CallBearerEnum bearer_at_start = 1; + + // Bearer (IMS or CS) when the call ended. + // The bearer may change during the call, e.g. due to SRVCC. + optional android.telephony.CallBearerEnum bearer_at_end = 2; + + // Direction of the call (incoming or outgoing). + optional android.telephony.CallDirectionEnum direction = 3; + + // Time spent setting up the call. + optional android.telephony.CallSetupDurationEnum setup_duration = 4; + + // Whether the call ended before the setup was completed. + optional bool setup_failed = 5; + + // IMS reason code or CS disconnect cause. + // For IMS, see: frameworks/base/telephony/java/android/telephony/ims/ImsReasonInfo.java + // For CS, see: frameworks/base/telephony/java/android/telephony/DisconnectCause.java + optional int32 disconnect_reason_code = 6; + + // IMS extra code or CS precise disconnect cause. + // For IMS, this code is vendor-specific + // For CS, see: frameworks/base/telephony/java/android/telephony/PreciseDisconnectCause.java + optional int32 disconnect_extra_code = 7; + + // IMS extra message or CS vendor cause. + optional string disconnect_extra_message = 8; + + // Radio access technology (RAT) used when call started. + optional android.telephony.NetworkTypeEnum rat_at_start = 9; + + // Radio access technology (RAT) used when call terminated. + optional android.telephony.NetworkTypeEnum rat_at_end = 10; + + // Number of times RAT changed during the call. + optional int64 rat_switch_count = 11; + + // A bitmask of all codecs used during the call. + // See: frameworks/opt/telephony/src/java/com/android/internal/telephony/metrics/VoiceCallSessionStats.java + optional int64 codec_bitmask = 12; + + // Number of other calls going on during call setup, for the same SIM slot. + optional int32 concurrent_call_count_at_start = 13; + + // Number of other calls going on during call termination, for the same SIM slot. + optional int32 concurrent_call_count_at_end = 14; + + // Index of the SIM is used, 0 for single-SIM devices. + optional int32 sim_slot_index = 15; + + // Whether the device was in multi-SIM mode (with multiple active SIM profiles). + optional bool is_multi_sim = 16; + + // Whether the call was made with an eSIM profile. + optional bool is_esim = 17; + + // Carrier ID of the SIM card. + // See https://source.android.com/devices/tech/config/carrierid. + optional int32 carrier_id = 18; + + // Whether an SRVCC has been completed successfully for this call. + optional bool srvcc_completed = 19; + + // Number of SRVCC failures. + optional int64 srvcc_failure_count = 20; + + // Number of SRVCC cancellations. + optional int64 srvcc_cancellation_count = 21; + + // Whether the Real-Time Text (RTT) was ever used in the call (rather than whether RTT was + // enabled in the dialer's settings). + optional bool rtt_enabled = 22; + + // Whether this was an emergency call. + optional bool is_emergency = 23; + + // Whether the call was performed while roaming. + optional bool is_roaming = 24; + + // A random number used as the dimension field to pull multiple atoms. + optional int32 dimension = 25; +} + +/** + * Pulls voice call radio access technology (RAT) usage. + * + * Each pull creates multiple atoms, one for each carrier/RAT, the order of which is irrelevant to + * time. The atom will be skipped if not enough data is available. + * + * Pulled from: + * frameworks/opt/telephony/src/java/com/android/internal/telephony/metrics/MetricsCollector.java + */ +message VoiceCallRatUsage { + // Carrier ID (https://source.android.com/devices/tech/config/carrierid). + optional int32 carrier_id = 1; + + // Radio access technology. + optional android.telephony.NetworkTypeEnum rat = 2; + + // Total duration that voice calls spent on this carrier and RAT. + optional int64 total_duration_seconds = 3; + + // Total number of calls using this carrier and RAT. + // A call is counted once even if it used the RAT multiple times. + optional int64 call_count = 4; +} + +/** + * Pulls the number of active SIM slots and SIMs/eSIM profiles. + * + * Pulled from: + * frameworks/opt/telephony/src/java/com/android/internal/telephony/metrics/MetricsCollector.java + */ +message SimSlotState { + // Number of active SIM slots (both physical and eSIM profiles) in the device. + optional int32 active_slot_count = 1; + + // Number of SIM cards (both physical and active eSIM profiles). + // This number is always equal to or less than the number of active SIM slots. + optional int32 sim_count = 2; + + // Number of active eSIM profiles. + // This number is always equal to or less than the number of SIMs. + optional int32 esim_count = 3; +} + +/** + * Pulls supported cellular radio access technologies. + * + * This atom reports the capabilities of the device, rather than the network it has access to. + * + * Pulled from: + * frameworks/opt/telephony/src/java/com/android/internal/telephony/metrics/MetricsCollector.java + */ +message SupportedRadioAccessFamily { + // A bitmask of supported radio technologies. + // See android.telephony.TelephonyManager.NetworkTypeBitMask. + optional int64 network_type_bitmask = 1; +} diff --git a/cmds/statsd/src/external/CarStatsPuller.cpp b/cmds/statsd/src/external/CarStatsPuller.cpp new file mode 100644 index 000000000000..70c0456b5eb4 --- /dev/null +++ b/cmds/statsd/src/external/CarStatsPuller.cpp @@ -0,0 +1,96 @@ +/* + * Copyright 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define DEBUG false +#include "Log.h" + +#include <binder/IServiceManager.h> +#include <com/android/internal/car/ICarStatsService.h> + +#include "CarStatsPuller.h" +#include "logd/LogEvent.h" +#include "stats_log_util.h" + +using android::binder::Status; +using com::android::internal::car::ICarStatsService; + +namespace android { +namespace os { +namespace statsd { + +static std::mutex gCarStatsMutex; +static sp<ICarStatsService> gCarStats = nullptr; + +class CarStatsDeathRecipient : public android::IBinder::DeathRecipient { + public: + CarStatsDeathRecipient() = default; + ~CarStatsDeathRecipient() override = default; + + // android::IBinder::DeathRecipient override: + void binderDied(const android::wp<android::IBinder>& /* who */) override { + ALOGE("Car service has died"); + std::lock_guard<std::mutex> lock(gCarStatsMutex); + if (gCarStats) { + sp<IBinder> binder = IInterface::asBinder(gCarStats); + binder->unlinkToDeath(this); + gCarStats = nullptr; + } + } +}; + +static sp<CarStatsDeathRecipient> gDeathRecipient = new CarStatsDeathRecipient(); + +static sp<ICarStatsService> getCarService() { + std::lock_guard<std::mutex> lock(gCarStatsMutex); + if (!gCarStats) { + const sp<IBinder> binder = defaultServiceManager()->checkService(String16("car_stats")); + if (!binder) { + ALOGW("Car service is unavailable"); + return nullptr; + } + gCarStats = interface_cast<ICarStatsService>(binder); + binder->linkToDeath(gDeathRecipient); + } + return gCarStats; +} + +CarStatsPuller::CarStatsPuller(const int tagId) : StatsPuller(tagId) { +} + +bool CarStatsPuller::PullInternal(std::vector<std::shared_ptr<LogEvent>>* data) { + const sp<ICarStatsService> carService = getCarService(); + if (!carService) { + return false; + } + + vector<StatsLogEventWrapper> returned_value; + Status status = carService->pullData(mTagId, &returned_value); + if (!status.isOk()) { + ALOGW("CarStatsPuller::pull failed for %d", mTagId); + return false; + } + + data->clear(); + for (const StatsLogEventWrapper& it : returned_value) { + LogEvent::createLogEvents(it, *data); + } + VLOG("CarStatsPuller::pull succeeded for %d", mTagId); + return true; +} + +} // namespace statsd +} // namespace os +} // namespace android diff --git a/cmds/statsd/src/external/CarStatsPuller.h b/cmds/statsd/src/external/CarStatsPuller.h new file mode 100644 index 000000000000..ca0f1a9c9a17 --- /dev/null +++ b/cmds/statsd/src/external/CarStatsPuller.h @@ -0,0 +1,36 @@ +/* + * Copyright 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include "StatsPuller.h" + +namespace android { +namespace os { +namespace statsd { + +/** + * Pull atoms from CarService. + */ +class CarStatsPuller : public StatsPuller { +public: + explicit CarStatsPuller(const int tagId); + bool PullInternal(std::vector<std::shared_ptr<LogEvent>>* data) override; +}; + +} // namespace statsd +} // namespace os +} // namespace android diff --git a/cmds/statsd/src/external/StatsPullerManager.cpp b/cmds/statsd/src/external/StatsPullerManager.cpp index 69e6a11b9ad7..1c9d7763bc83 100644 --- a/cmds/statsd/src/external/StatsPullerManager.cpp +++ b/cmds/statsd/src/external/StatsPullerManager.cpp @@ -27,6 +27,7 @@ #include "../logd/LogEvent.h" #include "../stats_log_util.h" #include "../statscompanion_util.h" +#include "CarStatsPuller.h" #include "GpuStatsPuller.h" #include "PowerStatsPuller.h" #include "ResourceHealthManagerPuller.h" @@ -267,6 +268,13 @@ std::map<int, PullAtomInfo> StatsPullerManager::kAllPullAtomInfo = { // App ops {android::util::APP_OPS, {.puller = new StatsCompanionServicePuller(android::util::APP_OPS)}}, + // VmsClientStats + {android::util::VMS_CLIENT_STATS, + {.additiveFields = {5, 6, 7, 8, 9, 10}, + .puller = new CarStatsPuller(android::util::VMS_CLIENT_STATS)}}, + // NotiifcationRemoteViews. + {android::util::NOTIFICATION_REMOTE_VIEWS, + {.puller = new StatsCompanionServicePuller(android::util::NOTIFICATION_REMOTE_VIEWS)}}, }; StatsPullerManager::StatsPullerManager() : mNextPullTimeNs(NO_ALARM_UPDATE) { diff --git a/cmds/statsd/src/metrics/MetricProducer.h b/cmds/statsd/src/metrics/MetricProducer.h index 09ad2903fa4c..a0c82246d3e0 100644 --- a/cmds/statsd/src/metrics/MetricProducer.h +++ b/cmds/statsd/src/metrics/MetricProducer.h @@ -73,7 +73,7 @@ enum DumpLatency { // writing the report to dropbox. MetricProducers should respond to package changes as required in // PackageInfoListener, but if none of the metrics are slicing by package name, then the update can // be a no-op. -class MetricProducer : public virtual PackageInfoListener { +class MetricProducer : public virtual android::RefBase { public: MetricProducer(const int64_t& metricId, const ConfigKey& key, const int64_t timeBaseNs, const int conditionIndex, const sp<ConditionWizard>& wizard) @@ -105,8 +105,8 @@ public: * the flush again when the end timestamp is forced to be now, and then after flushing, update * the start timestamp to be now. */ - void notifyAppUpgrade(const int64_t& eventTimeNs, const string& apk, const int uid, - const int64_t version) override { + virtual void notifyAppUpgrade(const int64_t& eventTimeNs, const string& apk, const int uid, + const int64_t version) { std::lock_guard<std::mutex> lock(mMutex); if (eventTimeNs > getCurrentBucketEndTimeNs()) { @@ -119,16 +119,11 @@ public: // is a partial bucket and can merge it with the previous bucket. }; - void notifyAppRemoved(const int64_t& eventTimeNs, const string& apk, const int uid) override{ + void notifyAppRemoved(const int64_t& eventTimeNs, const string& apk, const int uid) { // Force buckets to split on removal also. notifyAppUpgrade(eventTimeNs, apk, uid, 0); }; - void onUidMapReceived(const int64_t& eventTimeNs) override{ - // Purposefully don't flush partial buckets on a new snapshot. - // This occurs if a new user is added/removed or statsd crashes. - }; - // Consume the parsed stats log entry that already matched the "what" of the metric. void onMatchedLogEvent(const size_t matcherIndex, const LogEvent& event) { std::lock_guard<std::mutex> lock(mMutex); diff --git a/cmds/statsd/src/metrics/MetricsManager.cpp b/cmds/statsd/src/metrics/MetricsManager.cpp index 7b7d0cac0d30..760e800455f0 100644 --- a/cmds/statsd/src/metrics/MetricsManager.cpp +++ b/cmds/statsd/src/metrics/MetricsManager.cpp @@ -175,6 +175,10 @@ bool MetricsManager::isConfigValid() const { void MetricsManager::notifyAppUpgrade(const int64_t& eventTimeNs, const string& apk, const int uid, const int64_t version) { + // Inform all metric producers. + for (auto it : mAllMetricProducers) { + it->notifyAppUpgrade(eventTimeNs, apk, uid, version); + } // check if we care this package if (std::find(mAllowedPkg.begin(), mAllowedPkg.end(), apk) == mAllowedPkg.end()) { return; @@ -186,6 +190,10 @@ void MetricsManager::notifyAppUpgrade(const int64_t& eventTimeNs, const string& void MetricsManager::notifyAppRemoved(const int64_t& eventTimeNs, const string& apk, const int uid) { + // Inform all metric producers. + for (auto it : mAllMetricProducers) { + it->notifyAppRemoved(eventTimeNs, apk, uid); + } // check if we care this package if (std::find(mAllowedPkg.begin(), mAllowedPkg.end(), apk) == mAllowedPkg.end()) { return; @@ -196,6 +204,9 @@ void MetricsManager::notifyAppRemoved(const int64_t& eventTimeNs, const string& } void MetricsManager::onUidMapReceived(const int64_t& eventTimeNs) { + // Purposefully don't inform metric producers on a new snapshot + // because we don't need to flush partial buckets. + // This occurs if a new user is added/removed or statsd crashes. if (mAllowedPkg.size() == 0) { return; } diff --git a/cmds/statsd/src/metrics/MetricsManager.h b/cmds/statsd/src/metrics/MetricsManager.h index 8efca1e10de5..34d47d426235 100644 --- a/cmds/statsd/src/metrics/MetricsManager.h +++ b/cmds/statsd/src/metrics/MetricsManager.h @@ -35,7 +35,7 @@ namespace os { namespace statsd { // A MetricsManager is responsible for managing metrics from one single config source. -class MetricsManager : public PackageInfoListener { +class MetricsManager : public virtual android::RefBase { public: MetricsManager(const ConfigKey& configKey, const StatsdConfig& config, const int64_t timeBaseNs, const int64_t currentTimeNs, const sp<UidMap>& uidMap, @@ -63,15 +63,11 @@ public: unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>>& alarmSet); void notifyAppUpgrade(const int64_t& eventTimeNs, const string& apk, const int uid, - const int64_t version) override; + const int64_t version); - void notifyAppRemoved(const int64_t& eventTimeNs, const string& apk, const int uid) override; + void notifyAppRemoved(const int64_t& eventTimeNs, const string& apk, const int uid); - void onUidMapReceived(const int64_t& eventTimeNs) override; - - bool shouldAddUidMapListener() const { - return !mAllowedPkg.empty(); - } + void onUidMapReceived(const int64_t& eventTimeNs); bool shouldWriteToDisk() const { return mNoReportMetricIds.size() != mAllMetricProducers.size(); diff --git a/cmds/statsd/src/metrics/metrics_manager_util.cpp b/cmds/statsd/src/metrics/metrics_manager_util.cpp index 46442b57126c..f5f2479f4faa 100644 --- a/cmds/statsd/src/metrics/metrics_manager_util.cpp +++ b/cmds/statsd/src/metrics/metrics_manager_util.cpp @@ -286,7 +286,7 @@ bool initConditions(const ConfigKey& key, const StatsdConfig& config, } bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t timeBaseTimeNs, - const int64_t currentTimeNs, UidMap& uidMap, + const int64_t currentTimeNs, const sp<StatsPullerManager>& pullerManager, const unordered_map<int64_t, int>& logTrackerMap, const unordered_map<int64_t, int>& conditionTrackerMap, @@ -600,9 +600,6 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t } noReportMetricIds.insert(no_report_metric); } - for (const auto& it : allMetricProducers) { - uidMap.addListener(it); - } return true; } @@ -807,7 +804,7 @@ bool initStatsdConfig(const ConfigKey& key, const StatsdConfig& config, UidMap& return false; } - if (!initMetrics(key, config, timeBaseNs, currentTimeNs, uidMap, pullerManager, logTrackerMap, + if (!initMetrics(key, config, timeBaseNs, currentTimeNs, pullerManager, logTrackerMap, conditionTrackerMap, allAtomMatchers, allConditionTrackers, allMetricProducers, conditionToMetricMap, trackerToMetricMap, metricProducerMap, noReportMetricIds)) { diff --git a/cmds/statsd/src/packages/UidMap.cpp b/cmds/statsd/src/packages/UidMap.cpp index d4b57dd68134..7e63bbff2d0a 100644 --- a/cmds/statsd/src/packages/UidMap.cpp +++ b/cmds/statsd/src/packages/UidMap.cpp @@ -119,7 +119,7 @@ int64_t UidMap::getAppVersion(int uid, const string& packageName) const { void UidMap::updateMap(const int64_t& timestamp, const vector<int32_t>& uid, const vector<int64_t>& versionCode, const vector<String16>& versionString, const vector<String16>& packageName, const vector<String16>& installer) { - vector<wp<PackageInfoListener>> broadcastList; + wp<PackageInfoListener> broadcast = NULL; { lock_guard<mutex> lock(mMutex); // Exclusively lock for updates. @@ -150,25 +150,22 @@ void UidMap::updateMap(const int64_t& timestamp, const vector<int32_t>& uid, ensureBytesUsedBelowLimit(); StatsdStats::getInstance().setCurrentUidMapMemory(mBytesUsed); - getListenerListCopyLocked(&broadcastList); + broadcast = mSubscriber; } // To avoid invoking callback while holding the internal lock. we get a copy of the listener - // list and invoke the callback. It's still possible that after we copy the list, a - // listener removes itself before we call it. It's then the listener's job to handle it (expect - // the callback to be called after listener is removed, and the listener should properly - // ignore it). - for (const auto& weakPtr : broadcastList) { - auto strongPtr = weakPtr.promote(); - if (strongPtr != NULL) { - strongPtr->onUidMapReceived(timestamp); - } + // and invoke the callback. It's still possible that after we copy the listener, it removes + // itself before we call it. It's then the listener's job to handle it (expect the callback to + // be called after listener is removed, and the listener should properly ignore it). + auto strongPtr = broadcast.promote(); + if (strongPtr != NULL) { + strongPtr->onUidMapReceived(timestamp); } } void UidMap::updateApp(const int64_t& timestamp, const String16& app_16, const int32_t& uid, const int64_t& versionCode, const String16& versionString, const String16& installer) { - vector<wp<PackageInfoListener>> broadcastList; + wp<PackageInfoListener> broadcast = NULL; string appName = string(String8(app_16).string()); { lock_guard<mutex> lock(mMutex); @@ -195,7 +192,7 @@ void UidMap::updateApp(const int64_t& timestamp, const String16& app_16, const i // for the first time, then we don't notify the listeners. // It's also OK to split again if we're forming a partial bucket after re-installing an // app after deletion. - getListenerListCopyLocked(&broadcastList); + broadcast = mSubscriber; } mChanges.emplace_back(false, timestamp, appName, uid, versionCode, newVersionString, prevVersion, prevVersionString); @@ -205,11 +202,9 @@ void UidMap::updateApp(const int64_t& timestamp, const String16& app_16, const i StatsdStats::getInstance().setUidMapChanges(mChanges.size()); } - for (const auto& weakPtr : broadcastList) { - auto strongPtr = weakPtr.promote(); - if (strongPtr != NULL) { - strongPtr->notifyAppUpgrade(timestamp, appName, uid, versionCode); - } + auto strongPtr = broadcast.promote(); + if (strongPtr != NULL) { + strongPtr->notifyAppUpgrade(timestamp, appName, uid, versionCode); } } @@ -230,21 +225,8 @@ void UidMap::ensureBytesUsedBelowLimit() { } } -void UidMap::getListenerListCopyLocked(vector<wp<PackageInfoListener>>* output) { - for (auto weakIt = mSubscribers.begin(); weakIt != mSubscribers.end();) { - auto strongPtr = weakIt->promote(); - if (strongPtr != NULL) { - output->push_back(*weakIt); - weakIt++; - } else { - weakIt = mSubscribers.erase(weakIt); - VLOG("The UidMap listener is gone, remove it now"); - } - } -} - void UidMap::removeApp(const int64_t& timestamp, const String16& app_16, const int32_t& uid) { - vector<wp<PackageInfoListener>> broadcastList; + wp<PackageInfoListener> broadcast = NULL; string app = string(String8(app_16).string()); { lock_guard<mutex> lock(mMutex); @@ -271,25 +253,18 @@ void UidMap::removeApp(const int64_t& timestamp, const String16& app_16, const i ensureBytesUsedBelowLimit(); StatsdStats::getInstance().setCurrentUidMapMemory(mBytesUsed); StatsdStats::getInstance().setUidMapChanges(mChanges.size()); - getListenerListCopyLocked(&broadcastList); + broadcast = mSubscriber; } - for (const auto& weakPtr : broadcastList) { - auto strongPtr = weakPtr.promote(); - if (strongPtr != NULL) { - strongPtr->notifyAppRemoved(timestamp, app, uid); - } + auto strongPtr = broadcast.promote(); + if (strongPtr != NULL) { + strongPtr->notifyAppRemoved(timestamp, app, uid); } } -void UidMap::addListener(wp<PackageInfoListener> producer) { - lock_guard<mutex> lock(mMutex); // Lock for updates - mSubscribers.insert(producer); -} - -void UidMap::removeListener(wp<PackageInfoListener> producer) { +void UidMap::setListener(wp<PackageInfoListener> listener) { lock_guard<mutex> lock(mMutex); // Lock for updates - mSubscribers.erase(producer); + mSubscriber = listener; } void UidMap::assignIsolatedUid(int isolatedUid, int parentUid) { diff --git a/cmds/statsd/src/packages/UidMap.h b/cmds/statsd/src/packages/UidMap.h index a7c5fb27375c..2d3f6ee9c2e8 100644 --- a/cmds/statsd/src/packages/UidMap.h +++ b/cmds/statsd/src/packages/UidMap.h @@ -118,12 +118,10 @@ public: // adb shell cmd stats print-uid-map void printUidMap(int outFd) const; - // Commands for indicating to the map that a producer should be notified if an app is updated. - // This allows the metric producer to distinguish when the same uid or app represents a - // different version of an app. - void addListener(wp<PackageInfoListener> producer); - // Remove the listener from the set of metric producers that subscribe to updates. - void removeListener(wp<PackageInfoListener> producer); + // Command for indicating to the map that StatsLogProcessor should be notified if an app is + // updated. This allows metric producers and managers to distinguish when the same uid or app + // represents a different version of an app. + void setListener(wp<PackageInfoListener> listener); // Informs uid map that a config is added/updated. Used for keeping mConfigKeys up to date. void OnConfigUpdated(const ConfigKey& key); @@ -167,8 +165,6 @@ private: std::set<string> getAppNamesFromUidLocked(const int32_t& uid, bool returnNormalized) const; string normalizeAppName(const string& appName) const; - void getListenerListCopyLocked(std::vector<wp<PackageInfoListener>>* output); - void writeUidMapSnapshotLocked(int64_t timestamp, bool includeVersionStrings, bool includeInstaller, const std::set<int32_t>& interestingUids, std::set<string>* str_set, ProtoOutputStream* proto); @@ -195,8 +191,8 @@ private: // Store which uid and apps represent deleted ones. std::list<std::pair<int, string>> mDeletedApps; - // Metric producers that should be notified if there's an upgrade in any app. - set<wp<PackageInfoListener>> mSubscribers; + // Notify StatsLogProcessor if there's an upgrade/removal in any app. + wp<PackageInfoListener> mSubscriber; // Mapping of config keys we're aware of to the epoch time they last received an update. This // lets us know it's safe to delete events older than the oldest update. The value is nanosec. diff --git a/cmds/statsd/statsd.rc b/cmds/statsd/statsd.rc index a98ecd586b42..b87a48309e18 100644 --- a/cmds/statsd/statsd.rc +++ b/cmds/statsd/statsd.rc @@ -22,9 +22,3 @@ service statsd /system/bin/statsd on property:ro.statsd.enable=false stop statsd -on post-fs-data - # Create directory for statsd - mkdir /data/misc/stats-data/ 0770 statsd system - mkdir /data/misc/stats-service/ 0770 statsd system - mkdir /data/misc/stats-active-metric/ 0770 statsd system - mkdir /data/misc/train-info/ 0770 statsd system diff --git a/cmds/statsd/tests/e2e/PartialBucket_e2e_test.cpp b/cmds/statsd/tests/e2e/PartialBucket_e2e_test.cpp index 309d251e4a89..0bc3ebb81ce6 100644 --- a/cmds/statsd/tests/e2e/PartialBucket_e2e_test.cpp +++ b/cmds/statsd/tests/e2e/PartialBucket_e2e_test.cpp @@ -162,7 +162,10 @@ TEST(PartialBucketE2eTest, TestCountMetricSplitOnUpgrade) { ConfigMetricsReport report = GetReports(service.mProcessor, start + 4); backfillStartEndTimestamp(&report); - EXPECT_EQ(1, report.metrics_size()); + + ASSERT_EQ(1, report.metrics_size()); + ASSERT_EQ(1, report.metrics(0).count_metrics().data_size()); + ASSERT_EQ(1, report.metrics(0).count_metrics().data(0).bucket_info_size()); EXPECT_TRUE(report.metrics(0).count_metrics().data(0).bucket_info(0). has_start_bucket_elapsed_nanos()); EXPECT_TRUE(report.metrics(0).count_metrics().data(0).bucket_info(0). @@ -186,7 +189,10 @@ TEST(PartialBucketE2eTest, TestCountMetricSplitOnRemoval) { ConfigMetricsReport report = GetReports(service.mProcessor, start + 4); backfillStartEndTimestamp(&report); - EXPECT_EQ(1, report.metrics_size()); + + ASSERT_EQ(1, report.metrics_size()); + ASSERT_EQ(1, report.metrics(0).count_metrics().data_size()); + ASSERT_EQ(1, report.metrics(0).count_metrics().data(0).bucket_info_size()); EXPECT_TRUE(report.metrics(0).count_metrics().data(0).bucket_info(0). has_start_bucket_elapsed_nanos()); EXPECT_TRUE(report.metrics(0).count_metrics().data(0).bucket_info(0). @@ -228,8 +234,9 @@ TEST(PartialBucketE2eTest, TestValueMetricWithMinPartialBucket) { ConfigMetricsReport report = GetReports(service.mProcessor, 5 * 60 * NS_PER_SEC + start + 100 * NS_PER_SEC, true); backfillStartEndTimestamp(&report); - EXPECT_EQ(1, report.metrics_size()); - EXPECT_EQ(1, report.metrics(0).value_metrics().skipped_size()); + + ASSERT_EQ(1, report.metrics_size()); + ASSERT_EQ(1, report.metrics(0).value_metrics().skipped_size()); EXPECT_TRUE(report.metrics(0).value_metrics().skipped(0).has_start_bucket_elapsed_nanos()); // Can't test the start time since it will be based on the actual time when the pulling occurs. EXPECT_EQ(MillisToNano(NanoToMillis(endSkipped)), @@ -270,8 +277,8 @@ TEST(PartialBucketE2eTest, TestGaugeMetricWithMinPartialBucket) { ConfigMetricsReport report = GetReports(service.mProcessor, 5 * 60 * NS_PER_SEC + start + 100 * NS_PER_SEC, true); backfillStartEndTimestamp(&report); - EXPECT_EQ(1, report.metrics_size()); - EXPECT_EQ(1, report.metrics(0).gauge_metrics().skipped_size()); + ASSERT_EQ(1, report.metrics_size()); + ASSERT_EQ(1, report.metrics(0).gauge_metrics().skipped_size()); // Can't test the start time since it will be based on the actual time when the pulling occurs. EXPECT_TRUE(report.metrics(0).gauge_metrics().skipped(0).has_start_bucket_elapsed_nanos()); EXPECT_EQ(MillisToNano(NanoToMillis(endSkipped)), diff --git a/cmds/svc/src/com/android/commands/svc/PowerCommand.java b/cmds/svc/src/com/android/commands/svc/PowerCommand.java index 3180b77f5700..957ebfbef799 100644 --- a/cmds/svc/src/com/android/commands/svc/PowerCommand.java +++ b/cmds/svc/src/com/android/commands/svc/PowerCommand.java @@ -24,6 +24,7 @@ import android.os.RemoteException; import android.os.ServiceManager; import android.os.SystemClock; import android.os.SystemProperties; +import android.sysprop.InitProperties; public class PowerCommand extends Svc.Command { private static final int FORCE_SUSPEND_DELAY_DEFAULT_MILLIS = 0; @@ -103,6 +104,8 @@ public class PowerCommand extends Svc.Command { pm.reboot(false, mode, true); } catch (RemoteException e) { maybeLogRemoteException("Failed to reboot."); + } catch (Exception e) { + System.err.println("Failed to reboot: " + e.getMessage()); } return; } else if ("shutdown".equals(args[1])) { @@ -138,7 +141,9 @@ public class PowerCommand extends Svc.Command { // if it is already in shutdown flow. private void maybeLogRemoteException(String msg) { String powerProp = SystemProperties.get("sys.powerctl"); - if (powerProp.isEmpty()) { + // Also check if userspace reboot is ongoing, since in case of userspace reboot value of the + // sys.powerctl property will be reset. + if (powerProp.isEmpty() && !InitProperties.userspace_reboot_in_progress().orElse(false)) { System.err.println(msg); } } diff --git a/cmds/telecom/src/com/android/commands/telecom/Telecom.java b/cmds/telecom/src/com/android/commands/telecom/Telecom.java index 97074050448e..35f4add46d77 100644 --- a/cmds/telecom/src/com/android/commands/telecom/Telecom.java +++ b/cmds/telecom/src/com/android/commands/telecom/Telecom.java @@ -64,6 +64,8 @@ public final class Telecom extends BaseCommand { private static final String COMMAND_UNREGISTER_PHONE_ACCOUNT = "unregister-phone-account"; private static final String COMMAND_SET_DEFAULT_DIALER = "set-default-dialer"; private static final String COMMAND_GET_DEFAULT_DIALER = "get-default-dialer"; + private static final String COMMAND_STOP_BLOCK_SUPPRESSION = "stop-block-suppression"; + /** * Change the system dialer package name if a package name was specified, * Example: adb shell telecom set-system-dialer <PACKAGE> @@ -111,6 +113,8 @@ public final class Telecom extends BaseCommand { + "usage: telecom set-sim-count <COUNT>\n" + "usage: telecom get-sim-config\n" + "usage: telecom get-max-phones\n" + + "usage: telecom stop-block-suppression: Stop suppressing the blocked number" + + " provider after a call to emergency services.\n" + "usage: telecom set-emer-phone-account-filter <PACKAGE>\n" + "\n" + "telecom set-phone-account-enabled: Enables the given phone account, if it has" @@ -203,6 +207,9 @@ public final class Telecom extends BaseCommand { case COMMAND_UNREGISTER_PHONE_ACCOUNT: runUnregisterPhoneAccount(); break; + case COMMAND_STOP_BLOCK_SUPPRESSION: + runStopBlockSuppression(); + break; case COMMAND_SET_DEFAULT_DIALER: runSetDefaultDialer(); break; @@ -320,8 +327,13 @@ public final class Telecom extends BaseCommand { System.out.println("Success - " + handle + " unregistered."); } + private void runStopBlockSuppression() throws RemoteException { + mTelecomService.stopBlockSuppression(); + } + private void runSetDefaultDialer() throws RemoteException { - final String packageName = nextArgRequired(); + String packageName = nextArg(); + if ("default".equals(packageName)) packageName = null; mTelecomService.setTestDefaultDialer(packageName); System.out.println("Success - " + packageName + " set as override default dialer."); } diff --git a/cmds/uiautomator/library/Android.bp b/cmds/uiautomator/library/Android.bp index 3a260639de0f..c33d31f576a3 100644 --- a/cmds/uiautomator/library/Android.bp +++ b/cmds/uiautomator/library/Android.bp @@ -28,9 +28,6 @@ droiddoc { installable: false, args: "-stubpackages com.android.uiautomator.core:" + "com.android.uiautomator.testrunner", - api_tag_name: "UIAUTOMATOR", - api_filename: "uiautomator_api.txt", - removed_api_filename: "uiautomator_removed_api.txt", check_api: { current: { |