/*
|
* Copyright (C) 2017 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
package com.android.server.stats;
|
|
import static android.app.AppOpsManager.OP_FLAGS_ALL_TRUSTED;
|
import static android.content.pm.PackageInfo.REQUESTED_PERMISSION_GRANTED;
|
import static android.content.pm.PermissionInfo.PROTECTION_DANGEROUS;
|
import static android.os.Process.getPidsForCommands;
|
import static android.os.Process.getUidForPid;
|
import static android.os.storage.VolumeInfo.TYPE_PRIVATE;
|
import static android.os.storage.VolumeInfo.TYPE_PUBLIC;
|
|
import static com.android.internal.util.Preconditions.checkNotNull;
|
import static com.android.server.am.MemoryStatUtil.readCmdlineFromProcfs;
|
import static com.android.server.am.MemoryStatUtil.readMemoryStatFromFilesystem;
|
import static com.android.server.am.MemoryStatUtil.readMemoryStatFromProcfs;
|
import static com.android.server.am.MemoryStatUtil.readProcessSystemIonHeapSizesFromDebugfs;
|
import static com.android.server.am.MemoryStatUtil.readRssHighWaterMarkFromProcfs;
|
import static com.android.server.am.MemoryStatUtil.readSystemIonHeapSizeFromDebugfs;
|
|
import android.annotation.NonNull;
|
import android.annotation.Nullable;
|
import android.app.ActivityManagerInternal;
|
import android.app.AlarmManager;
|
import android.app.AlarmManager.OnAlarmListener;
|
import android.app.AppOpsManager;
|
import android.app.AppOpsManager.HistoricalOps;
|
import android.app.AppOpsManager.HistoricalOpsRequest;
|
import android.app.AppOpsManager.HistoricalPackageOps;
|
import android.app.AppOpsManager.HistoricalUidOps;
|
import android.app.ProcessMemoryState;
|
import android.app.StatsManager;
|
import android.bluetooth.BluetoothActivityEnergyInfo;
|
import android.bluetooth.BluetoothAdapter;
|
import android.bluetooth.UidTraffic;
|
import android.content.BroadcastReceiver;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.content.IntentFilter;
|
import android.content.IntentSender;
|
import android.content.pm.ApplicationInfo;
|
import android.content.pm.PackageInfo;
|
import android.content.pm.PackageManager;
|
import android.content.pm.PermissionInfo;
|
import android.content.pm.UserInfo;
|
import android.hardware.biometrics.BiometricsProtoEnums;
|
import android.hardware.face.FaceManager;
|
import android.hardware.fingerprint.FingerprintManager;
|
import android.net.ConnectivityManager;
|
import android.net.INetworkStatsService;
|
import android.net.Network;
|
import android.net.NetworkRequest;
|
import android.net.NetworkStats;
|
import android.net.wifi.IWifiManager;
|
import android.net.wifi.WifiActivityEnergyInfo;
|
import android.os.BatteryStats;
|
import android.os.BatteryStatsInternal;
|
import android.os.Binder;
|
import android.os.Build;
|
import android.os.Bundle;
|
import android.os.CoolingDevice;
|
import android.os.Environment;
|
import android.os.FileUtils;
|
import android.os.Handler;
|
import android.os.HandlerThread;
|
import android.os.IBinder;
|
import android.os.IStatsCompanionService;
|
import android.os.IStatsManager;
|
import android.os.IStoraged;
|
import android.os.IThermalEventListener;
|
import android.os.IThermalService;
|
import android.os.Looper;
|
import android.os.ParcelFileDescriptor;
|
import android.os.Parcelable;
|
import android.os.Process;
|
import android.os.RemoteException;
|
import android.os.ServiceManager;
|
import android.os.StatFs;
|
import android.os.StatsDimensionsValue;
|
import android.os.StatsLogEventWrapper;
|
import android.os.SynchronousResultReceiver;
|
import android.os.SystemClock;
|
import android.os.SystemProperties;
|
import android.os.Temperature;
|
import android.os.UserHandle;
|
import android.os.UserManager;
|
import android.os.storage.DiskInfo;
|
import android.os.storage.StorageManager;
|
import android.os.storage.VolumeInfo;
|
import android.provider.Settings;
|
import android.stats.storage.StorageEnums;
|
import android.telephony.ModemActivityInfo;
|
import android.telephony.TelephonyManager;
|
import android.util.ArrayMap;
|
import android.util.ArraySet;
|
import android.util.Log;
|
import android.util.Slog;
|
import android.util.StatsLog;
|
import android.util.proto.ProtoOutputStream;
|
import android.util.proto.ProtoStream;
|
|
import com.android.internal.annotations.GuardedBy;
|
import com.android.internal.app.procstats.IProcessStats;
|
import com.android.internal.app.procstats.ProcessStats;
|
import com.android.internal.os.BackgroundThread;
|
import com.android.internal.os.BatterySipper;
|
import com.android.internal.os.BatteryStatsHelper;
|
import com.android.internal.os.BinderCallsStats.ExportedCallStat;
|
import com.android.internal.os.KernelCpuSpeedReader;
|
import com.android.internal.os.KernelCpuThreadReader;
|
import com.android.internal.os.KernelCpuThreadReaderDiff;
|
import com.android.internal.os.KernelCpuThreadReaderSettingsObserver;
|
import com.android.internal.os.KernelCpuUidTimeReader.KernelCpuUidActiveTimeReader;
|
import com.android.internal.os.KernelCpuUidTimeReader.KernelCpuUidClusterTimeReader;
|
import com.android.internal.os.KernelCpuUidTimeReader.KernelCpuUidFreqTimeReader;
|
import com.android.internal.os.KernelCpuUidTimeReader.KernelCpuUidUserSysTimeReader;
|
import com.android.internal.os.KernelWakelockReader;
|
import com.android.internal.os.KernelWakelockStats;
|
import com.android.internal.os.LooperStats;
|
import com.android.internal.os.PowerProfile;
|
import com.android.internal.os.ProcessCpuTracker;
|
import com.android.internal.os.StoragedUidIoStatsReader;
|
import com.android.internal.util.DumpUtils;
|
import com.android.server.BinderCallsStatsService;
|
import com.android.server.LocalServices;
|
import com.android.server.SystemService;
|
import com.android.server.SystemServiceManager;
|
import com.android.server.am.MemoryStatUtil.IonAllocations;
|
import com.android.server.am.MemoryStatUtil.MemoryStat;
|
import com.android.server.role.RoleManagerInternal;
|
import com.android.server.storage.DiskStatsFileLogger;
|
import com.android.server.storage.DiskStatsLoggingService;
|
|
import libcore.io.IoUtils;
|
|
import org.json.JSONArray;
|
import org.json.JSONException;
|
import org.json.JSONObject;
|
|
import java.io.File;
|
import java.io.FileDescriptor;
|
import java.io.FileOutputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.PrintWriter;
|
import java.time.Instant;
|
import java.time.temporal.ChronoUnit;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
import java.util.UUID;
|
import java.util.concurrent.CompletableFuture;
|
import java.util.concurrent.TimeUnit;
|
import java.util.concurrent.TimeoutException;
|
|
/**
|
* Helper service for statsd (the native stats management service in cmds/statsd/).
|
* Used for registering and receiving alarms on behalf of statsd.
|
*
|
* @hide
|
*/
|
public class StatsCompanionService extends IStatsCompanionService.Stub {
|
/**
|
* How long to wait on an individual subsystem to return its stats.
|
*/
|
private static final long EXTERNAL_STATS_SYNC_TIMEOUT_MILLIS = 2000;
|
private static final long MILLIS_IN_A_DAY = TimeUnit.DAYS.toMillis(1);
|
|
public static final String RESULT_RECEIVER_CONTROLLER_KEY = "controller_activity";
|
public static final String CONFIG_DIR = "/data/misc/stats-service";
|
|
static final String TAG = "StatsCompanionService";
|
static final boolean DEBUG = false;
|
/**
|
* Hard coded field ids of frameworks/base/cmds/statsd/src/uid_data.proto
|
* to be used in ProtoOutputStream.
|
*/
|
private static final int APPLICATION_INFO_FIELD_ID = 1;
|
private static final int UID_FIELD_ID = 1;
|
private static final int VERSION_FIELD_ID = 2;
|
private static final int VERSION_STRING_FIELD_ID = 3;
|
private static final int PACKAGE_NAME_FIELD_ID = 4;
|
private static final int INSTALLER_FIELD_ID = 5;
|
|
public static final int CODE_DATA_BROADCAST = 1;
|
public static final int CODE_SUBSCRIBER_BROADCAST = 1;
|
public static final int CODE_ACTIVE_CONFIGS_BROADCAST = 1;
|
/**
|
* The last report time is provided with each intent registered to
|
* StatsManager#setFetchReportsOperation. This allows easy de-duping in the receiver if
|
* statsd is requesting the client to retrieve the same statsd data. The last report time
|
* corresponds to the last_report_elapsed_nanos that will provided in the current
|
* ConfigMetricsReport, and this timestamp also corresponds to the
|
* current_report_elapsed_nanos of the most recently obtained ConfigMetricsReport.
|
*/
|
public static final String EXTRA_LAST_REPORT_TIME = "android.app.extra.LAST_REPORT_TIME";
|
public static final int DEATH_THRESHOLD = 10;
|
/**
|
* Which native processes to snapshot memory for.
|
*
|
* <p>Processes are matched by their cmdline in procfs. Example: cat /proc/pid/cmdline returns
|
* /system/bin/statsd for the stats daemon.
|
*/
|
private static final String[] MEMORY_INTERESTING_NATIVE_PROCESSES = new String[]{
|
"/system/bin/statsd", // Stats daemon.
|
"/system/bin/surfaceflinger",
|
"/system/bin/apexd", // APEX daemon.
|
"/system/bin/audioserver",
|
"/system/bin/cameraserver",
|
"/system/bin/drmserver",
|
"/system/bin/healthd",
|
"/system/bin/incidentd",
|
"/system/bin/installd",
|
"/system/bin/lmkd", // Low memory killer daemon.
|
"/system/bin/logd",
|
"media.codec",
|
"media.extractor",
|
"media.metrics",
|
"/system/bin/mediadrmserver",
|
"/system/bin/mediaserver",
|
"/system/bin/performanced",
|
"/system/bin/tombstoned",
|
"/system/bin/traced", // Perfetto.
|
"/system/bin/traced_probes", // Perfetto.
|
"webview_zygote",
|
"zygote",
|
"zygote64",
|
};
|
|
private static final int CPU_TIME_PER_THREAD_FREQ_MAX_NUM_FREQUENCIES = 8;
|
|
static final class CompanionHandler extends Handler {
|
CompanionHandler(Looper looper) {
|
super(looper);
|
}
|
}
|
|
private final Context mContext;
|
private final AlarmManager mAlarmManager;
|
private final INetworkStatsService mNetworkStatsService;
|
@GuardedBy("sStatsdLock")
|
private static IStatsManager sStatsd;
|
private static final Object sStatsdLock = new Object();
|
|
private final OnAlarmListener mAnomalyAlarmListener = new AnomalyAlarmListener();
|
private final OnAlarmListener mPullingAlarmListener = new PullingAlarmListener();
|
private final OnAlarmListener mPeriodicAlarmListener = new PeriodicAlarmListener();
|
private final BroadcastReceiver mAppUpdateReceiver;
|
private final BroadcastReceiver mUserUpdateReceiver;
|
private final ShutdownEventReceiver mShutdownEventReceiver;
|
private final KernelWakelockReader mKernelWakelockReader = new KernelWakelockReader();
|
private final KernelWakelockStats mTmpWakelockStats = new KernelWakelockStats();
|
private IWifiManager mWifiManager = null;
|
private TelephonyManager mTelephony = null;
|
@GuardedBy("sStatsdLock")
|
private final HashSet<Long> mDeathTimeMillis = new HashSet<>();
|
@GuardedBy("sStatsdLock")
|
private final HashMap<Long, String> mDeletedFiles = new HashMap<>();
|
private final CompanionHandler mHandler;
|
|
// Disables throttler on CPU time readers.
|
private KernelCpuUidUserSysTimeReader mCpuUidUserSysTimeReader =
|
new KernelCpuUidUserSysTimeReader(false);
|
private KernelCpuSpeedReader[] mKernelCpuSpeedReaders;
|
private KernelCpuUidFreqTimeReader mCpuUidFreqTimeReader =
|
new KernelCpuUidFreqTimeReader(false);
|
private KernelCpuUidActiveTimeReader mCpuUidActiveTimeReader =
|
new KernelCpuUidActiveTimeReader(false);
|
private KernelCpuUidClusterTimeReader mCpuUidClusterTimeReader =
|
new KernelCpuUidClusterTimeReader(false);
|
private StoragedUidIoStatsReader mStoragedUidIoStatsReader =
|
new StoragedUidIoStatsReader();
|
@Nullable
|
private final KernelCpuThreadReaderDiff mKernelCpuThreadReader;
|
|
private long mDebugElapsedClockPreviousValue = 0;
|
private long mDebugElapsedClockPullCount = 0;
|
private long mDebugFailingElapsedClockPreviousValue = 0;
|
private long mDebugFailingElapsedClockPullCount = 0;
|
private BatteryStatsHelper mBatteryStatsHelper = null;
|
private static final int MAX_BATTERY_STATS_HELPER_FREQUENCY_MS = 1000;
|
private long mBatteryStatsHelperTimestampMs = -MAX_BATTERY_STATS_HELPER_FREQUENCY_MS;
|
|
private static IThermalService sThermalService;
|
private File mBaseDir =
|
new File(SystemServiceManager.ensureSystemDir(), "stats_companion");
|
@GuardedBy("this")
|
ProcessCpuTracker mProcessCpuTracker = null;
|
|
public StatsCompanionService(Context context) {
|
super();
|
mContext = context;
|
mAlarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
|
mNetworkStatsService = INetworkStatsService.Stub.asInterface(
|
ServiceManager.getService(Context.NETWORK_STATS_SERVICE));
|
mBaseDir.mkdirs();
|
mAppUpdateReceiver = new AppUpdateReceiver();
|
mUserUpdateReceiver = new BroadcastReceiver() {
|
@Override
|
public void onReceive(Context context, Intent intent) {
|
synchronized (sStatsdLock) {
|
sStatsd = fetchStatsdService();
|
if (sStatsd == null) {
|
Slog.w(TAG, "Could not access statsd for UserUpdateReceiver");
|
return;
|
}
|
try {
|
// Pull the latest state of UID->app name, version mapping.
|
// Needed since the new user basically has a version of every app.
|
informAllUidsLocked(context);
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Failed to inform statsd latest update of all apps", e);
|
forgetEverythingLocked();
|
}
|
}
|
}
|
};
|
mShutdownEventReceiver = new ShutdownEventReceiver();
|
if (DEBUG) Slog.d(TAG, "Registered receiver for ACTION_PACKAGE_REPLACED and ADDED.");
|
PowerProfile powerProfile = new PowerProfile(context);
|
final int numClusters = powerProfile.getNumCpuClusters();
|
mKernelCpuSpeedReaders = new KernelCpuSpeedReader[numClusters];
|
int firstCpuOfCluster = 0;
|
for (int i = 0; i < numClusters; i++) {
|
final int numSpeedSteps = powerProfile.getNumSpeedStepsInCpuCluster(i);
|
mKernelCpuSpeedReaders[i] = new KernelCpuSpeedReader(firstCpuOfCluster,
|
numSpeedSteps);
|
firstCpuOfCluster += powerProfile.getNumCoresInCpuCluster(i);
|
}
|
|
// Enable push notifications of throttling from vendor thermal
|
// management subsystem via thermalservice.
|
IBinder b = ServiceManager.getService("thermalservice");
|
|
if (b != null) {
|
sThermalService = IThermalService.Stub.asInterface(b);
|
try {
|
sThermalService.registerThermalEventListener(
|
new ThermalEventListener());
|
Slog.i(TAG, "register thermal listener successfully");
|
} catch (RemoteException e) {
|
// Should never happen.
|
Slog.e(TAG, "register thermal listener error");
|
}
|
} else {
|
Slog.e(TAG, "cannot find thermalservice, no throttling push notifications");
|
}
|
|
// Default NetworkRequest should cover all transport types.
|
final NetworkRequest request = new NetworkRequest.Builder().build();
|
final ConnectivityManager connectivityManager =
|
(ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
|
connectivityManager.registerNetworkCallback(request, new ConnectivityStatsCallback());
|
|
HandlerThread handlerThread = new HandlerThread(TAG);
|
handlerThread.start();
|
mHandler = new CompanionHandler(handlerThread.getLooper());
|
|
mKernelCpuThreadReader =
|
KernelCpuThreadReaderSettingsObserver.getSettingsModifiedReader(mContext);
|
}
|
|
@Override
|
public void sendDataBroadcast(IBinder intentSenderBinder, long lastReportTimeNs) {
|
enforceCallingPermission();
|
IntentSender intentSender = new IntentSender(intentSenderBinder);
|
Intent intent = new Intent();
|
intent.putExtra(EXTRA_LAST_REPORT_TIME, lastReportTimeNs);
|
try {
|
intentSender.sendIntent(mContext, CODE_DATA_BROADCAST, intent, null, null);
|
} catch (IntentSender.SendIntentException e) {
|
Slog.w(TAG, "Unable to send using IntentSender");
|
}
|
}
|
|
@Override
|
public void sendActiveConfigsChangedBroadcast(IBinder intentSenderBinder, long[] configIds) {
|
enforceCallingPermission();
|
IntentSender intentSender = new IntentSender(intentSenderBinder);
|
Intent intent = new Intent();
|
intent.putExtra(StatsManager.EXTRA_STATS_ACTIVE_CONFIG_KEYS, configIds);
|
try {
|
intentSender.sendIntent(mContext, CODE_ACTIVE_CONFIGS_BROADCAST, intent, null, null);
|
if (DEBUG) {
|
Slog.d(TAG, "Sent broadcast with config ids " + Arrays.toString(configIds));
|
}
|
} catch (IntentSender.SendIntentException e) {
|
Slog.w(TAG, "Unable to send active configs changed broadcast using IntentSender");
|
}
|
}
|
|
@Override
|
public void sendSubscriberBroadcast(IBinder intentSenderBinder, long configUid, long configKey,
|
long subscriptionId, long subscriptionRuleId, String[] cookies,
|
StatsDimensionsValue dimensionsValue) {
|
enforceCallingPermission();
|
IntentSender intentSender = new IntentSender(intentSenderBinder);
|
Intent intent =
|
new Intent()
|
.putExtra(StatsManager.EXTRA_STATS_CONFIG_UID, configUid)
|
.putExtra(StatsManager.EXTRA_STATS_CONFIG_KEY, configKey)
|
.putExtra(StatsManager.EXTRA_STATS_SUBSCRIPTION_ID, subscriptionId)
|
.putExtra(StatsManager.EXTRA_STATS_SUBSCRIPTION_RULE_ID, subscriptionRuleId)
|
.putExtra(StatsManager.EXTRA_STATS_DIMENSIONS_VALUE, dimensionsValue);
|
|
ArrayList<String> cookieList = new ArrayList<>(cookies.length);
|
for (String cookie : cookies) {
|
cookieList.add(cookie);
|
}
|
intent.putStringArrayListExtra(
|
StatsManager.EXTRA_STATS_BROADCAST_SUBSCRIBER_COOKIES, cookieList);
|
|
if (DEBUG) {
|
Slog.d(TAG,
|
String.format("Statsd sendSubscriberBroadcast with params {%d %d %d %d %s %s}",
|
configUid, configKey, subscriptionId, subscriptionRuleId,
|
Arrays.toString(cookies),
|
dimensionsValue));
|
}
|
try {
|
intentSender.sendIntent(mContext, CODE_SUBSCRIBER_BROADCAST, intent, null, null);
|
} catch (IntentSender.SendIntentException e) {
|
Slog.w(TAG,
|
"Unable to send using IntentSender from uid " + configUid
|
+ "; presumably it had been cancelled.");
|
}
|
}
|
|
private final static int[] toIntArray(List<Integer> list) {
|
int[] ret = new int[list.size()];
|
for (int i = 0; i < ret.length; i++) {
|
ret[i] = list.get(i);
|
}
|
return ret;
|
}
|
|
private final static long[] toLongArray(List<Long> list) {
|
long[] ret = new long[list.size()];
|
for (int i = 0; i < ret.length; i++) {
|
ret[i] = list.get(i);
|
}
|
return ret;
|
}
|
|
// Assumes that sStatsdLock is held.
|
@GuardedBy("sStatsdLock")
|
private final void informAllUidsLocked(Context context) throws RemoteException {
|
UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE);
|
PackageManager pm = context.getPackageManager();
|
final List<UserInfo> users = um.getUsers(true);
|
if (DEBUG) {
|
Slog.d(TAG, "Iterating over " + users.size() + " profiles.");
|
}
|
|
ParcelFileDescriptor[] fds;
|
try {
|
fds = ParcelFileDescriptor.createPipe();
|
} catch (IOException e) {
|
Slog.e(TAG, "Failed to create a pipe to send uid map data.", e);
|
return;
|
}
|
sStatsd.informAllUidData(fds[0]);
|
try {
|
fds[0].close();
|
} catch (IOException e) {
|
Slog.e(TAG, "Failed to close the read side of the pipe.", e);
|
}
|
final ParcelFileDescriptor writeFd = fds[1];
|
BackgroundThread.getHandler().post(() -> {
|
FileOutputStream fout = new ParcelFileDescriptor.AutoCloseOutputStream(writeFd);
|
try {
|
ProtoOutputStream output = new ProtoOutputStream(fout);
|
int numRecords = 0;
|
// Add in all the apps for every user/profile.
|
for (UserInfo profile : users) {
|
List<PackageInfo> pi =
|
pm.getInstalledPackagesAsUser(PackageManager.MATCH_KNOWN_PACKAGES,
|
profile.id);
|
for (int j = 0; j < pi.size(); j++) {
|
if (pi.get(j).applicationInfo != null) {
|
String installer;
|
try {
|
installer = pm.getInstallerPackageName(pi.get(j).packageName);
|
} catch (IllegalArgumentException e) {
|
installer = "";
|
}
|
long applicationInfoToken =
|
output.start(ProtoStream.FIELD_TYPE_MESSAGE
|
| ProtoStream.FIELD_COUNT_REPEATED
|
| APPLICATION_INFO_FIELD_ID);
|
output.write(ProtoStream.FIELD_TYPE_INT32
|
| ProtoStream.FIELD_COUNT_SINGLE | UID_FIELD_ID,
|
pi.get(j).applicationInfo.uid);
|
output.write(ProtoStream.FIELD_TYPE_INT64
|
| ProtoStream.FIELD_COUNT_SINGLE
|
| VERSION_FIELD_ID, pi.get(j).getLongVersionCode());
|
output.write(ProtoStream.FIELD_TYPE_STRING
|
| ProtoStream.FIELD_COUNT_SINGLE | VERSION_STRING_FIELD_ID,
|
pi.get(j).versionName);
|
output.write(ProtoStream.FIELD_TYPE_STRING
|
| ProtoStream.FIELD_COUNT_SINGLE
|
| PACKAGE_NAME_FIELD_ID, pi.get(j).packageName);
|
output.write(ProtoStream.FIELD_TYPE_STRING
|
| ProtoStream.FIELD_COUNT_SINGLE
|
| INSTALLER_FIELD_ID,
|
installer == null ? "" : installer);
|
numRecords++;
|
output.end(applicationInfoToken);
|
}
|
}
|
}
|
output.flush();
|
if (DEBUG) {
|
Slog.d(TAG, "Sent data for " + numRecords + " apps");
|
}
|
} finally {
|
IoUtils.closeQuietly(fout);
|
}
|
});
|
}
|
|
private final static class AppUpdateReceiver extends BroadcastReceiver {
|
@Override
|
public void onReceive(Context context, Intent intent) {
|
/**
|
* App updates actually consist of REMOVE, ADD, and then REPLACE broadcasts. To avoid
|
* waste, we ignore the REMOVE and ADD broadcasts that contain the replacing flag.
|
* If we can't find the value for EXTRA_REPLACING, we default to false.
|
*/
|
if (!intent.getAction().equals(Intent.ACTION_PACKAGE_REPLACED)
|
&& intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)) {
|
return; // Keep only replacing or normal add and remove.
|
}
|
if (DEBUG) Slog.d(TAG, "StatsCompanionService noticed an app was updated.");
|
synchronized (sStatsdLock) {
|
if (sStatsd == null) {
|
Slog.w(TAG, "Could not access statsd to inform it of an app update");
|
return;
|
}
|
try {
|
if (intent.getAction().equals(Intent.ACTION_PACKAGE_REMOVED)) {
|
Bundle b = intent.getExtras();
|
int uid = b.getInt(Intent.EXTRA_UID);
|
boolean replacing = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false);
|
if (!replacing) {
|
// Don't bother sending an update if we're right about to get another
|
// intent for the new version that's added.
|
PackageManager pm = context.getPackageManager();
|
String app = intent.getData().getSchemeSpecificPart();
|
sStatsd.informOnePackageRemoved(app, uid);
|
}
|
} else {
|
PackageManager pm = context.getPackageManager();
|
Bundle b = intent.getExtras();
|
int uid = b.getInt(Intent.EXTRA_UID);
|
String app = intent.getData().getSchemeSpecificPart();
|
PackageInfo pi = pm.getPackageInfo(app, PackageManager.MATCH_ANY_USER);
|
String installer;
|
try {
|
installer = pm.getInstallerPackageName(app);
|
} catch (IllegalArgumentException e) {
|
installer = "";
|
}
|
sStatsd.informOnePackage(app, uid, pi.getLongVersionCode(), pi.versionName,
|
installer == null ? "" : installer);
|
}
|
} catch (Exception e) {
|
Slog.w(TAG, "Failed to inform statsd of an app update", e);
|
}
|
}
|
}
|
}
|
|
public final static class AnomalyAlarmListener implements OnAlarmListener {
|
@Override
|
public void onAlarm() {
|
Slog.i(TAG, "StatsCompanionService believes an anomaly has occurred at time "
|
+ System.currentTimeMillis() + "ms.");
|
synchronized (sStatsdLock) {
|
if (sStatsd == null) {
|
Slog.w(TAG, "Could not access statsd to inform it of anomaly alarm firing");
|
return;
|
}
|
try {
|
// Two-way call to statsd to retain AlarmManager wakelock
|
sStatsd.informAnomalyAlarmFired();
|
} catch (RemoteException e) {
|
Slog.w(TAG, "Failed to inform statsd of anomaly alarm firing", e);
|
}
|
}
|
// AlarmManager releases its own wakelock here.
|
}
|
}
|
|
public final static class PullingAlarmListener implements OnAlarmListener {
|
@Override
|
public void onAlarm() {
|
if (DEBUG) {
|
Slog.d(TAG, "Time to poll something.");
|
}
|
synchronized (sStatsdLock) {
|
if (sStatsd == null) {
|
Slog.w(TAG, "Could not access statsd to inform it of pulling alarm firing.");
|
return;
|
}
|
try {
|
// Two-way call to statsd to retain AlarmManager wakelock
|
sStatsd.informPollAlarmFired();
|
} catch (RemoteException e) {
|
Slog.w(TAG, "Failed to inform statsd of pulling alarm firing.", e);
|
}
|
}
|
}
|
}
|
|
public final static class PeriodicAlarmListener implements OnAlarmListener {
|
@Override
|
public void onAlarm() {
|
if (DEBUG) {
|
Slog.d(TAG, "Time to trigger periodic alarm.");
|
}
|
synchronized (sStatsdLock) {
|
if (sStatsd == null) {
|
Slog.w(TAG, "Could not access statsd to inform it of periodic alarm firing.");
|
return;
|
}
|
try {
|
// Two-way call to statsd to retain AlarmManager wakelock
|
sStatsd.informAlarmForSubscriberTriggeringFired();
|
} catch (RemoteException e) {
|
Slog.w(TAG, "Failed to inform statsd of periodic alarm firing.", e);
|
}
|
}
|
// AlarmManager releases its own wakelock here.
|
}
|
}
|
|
public final static class ShutdownEventReceiver extends BroadcastReceiver {
|
@Override
|
public void onReceive(Context context, Intent intent) {
|
/**
|
* Skip immediately if intent is not relevant to device shutdown.
|
*/
|
if (!intent.getAction().equals(Intent.ACTION_REBOOT)
|
&& !(intent.getAction().equals(Intent.ACTION_SHUTDOWN)
|
&& (intent.getFlags() & Intent.FLAG_RECEIVER_FOREGROUND) != 0)) {
|
return;
|
}
|
|
Slog.i(TAG, "StatsCompanionService noticed a shutdown.");
|
synchronized (sStatsdLock) {
|
if (sStatsd == null) {
|
Slog.w(TAG, "Could not access statsd to inform it of a shutdown event.");
|
return;
|
}
|
try {
|
sStatsd.informDeviceShutdown();
|
} catch (Exception e) {
|
Slog.w(TAG, "Failed to inform statsd of a shutdown event.", e);
|
}
|
}
|
}
|
}
|
|
@Override // Binder call
|
public void setAnomalyAlarm(long timestampMs) {
|
enforceCallingPermission();
|
if (DEBUG) Slog.d(TAG, "Setting anomaly alarm for " + timestampMs);
|
final long callingToken = Binder.clearCallingIdentity();
|
try {
|
// using ELAPSED_REALTIME, not ELAPSED_REALTIME_WAKEUP, so if device is asleep, will
|
// only fire when it awakens.
|
// AlarmManager will automatically cancel any previous mAnomalyAlarmListener alarm.
|
mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME, timestampMs, TAG + ".anomaly",
|
mAnomalyAlarmListener, mHandler);
|
} finally {
|
Binder.restoreCallingIdentity(callingToken);
|
}
|
}
|
|
@Override // Binder call
|
public void cancelAnomalyAlarm() {
|
enforceCallingPermission();
|
if (DEBUG) Slog.d(TAG, "Cancelling anomaly alarm");
|
final long callingToken = Binder.clearCallingIdentity();
|
try {
|
mAlarmManager.cancel(mAnomalyAlarmListener);
|
} finally {
|
Binder.restoreCallingIdentity(callingToken);
|
}
|
}
|
|
@Override // Binder call
|
public void setAlarmForSubscriberTriggering(long timestampMs) {
|
enforceCallingPermission();
|
if (DEBUG) {
|
Slog.d(TAG,
|
"Setting periodic alarm in about " + (timestampMs
|
- SystemClock.elapsedRealtime()));
|
}
|
final long callingToken = Binder.clearCallingIdentity();
|
try {
|
// using ELAPSED_REALTIME, not ELAPSED_REALTIME_WAKEUP, so if device is asleep, will
|
// only fire when it awakens.
|
mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME, timestampMs, TAG + ".periodic",
|
mPeriodicAlarmListener, mHandler);
|
} finally {
|
Binder.restoreCallingIdentity(callingToken);
|
}
|
}
|
|
@Override // Binder call
|
public void cancelAlarmForSubscriberTriggering() {
|
enforceCallingPermission();
|
if (DEBUG) {
|
Slog.d(TAG, "Cancelling periodic alarm");
|
}
|
final long callingToken = Binder.clearCallingIdentity();
|
try {
|
mAlarmManager.cancel(mPeriodicAlarmListener);
|
} finally {
|
Binder.restoreCallingIdentity(callingToken);
|
}
|
}
|
|
@Override // Binder call
|
public void setPullingAlarm(long nextPullTimeMs) {
|
enforceCallingPermission();
|
if (DEBUG) {
|
Slog.d(TAG, "Setting pulling alarm in about "
|
+ (nextPullTimeMs - SystemClock.elapsedRealtime()));
|
}
|
final long callingToken = Binder.clearCallingIdentity();
|
try {
|
// using ELAPSED_REALTIME, not ELAPSED_REALTIME_WAKEUP, so if device is asleep, will
|
// only fire when it awakens.
|
mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME, nextPullTimeMs, TAG + ".pull",
|
mPullingAlarmListener, mHandler);
|
} finally {
|
Binder.restoreCallingIdentity(callingToken);
|
}
|
}
|
|
@Override // Binder call
|
public void cancelPullingAlarm() {
|
enforceCallingPermission();
|
if (DEBUG) {
|
Slog.d(TAG, "Cancelling pulling alarm");
|
}
|
final long callingToken = Binder.clearCallingIdentity();
|
try {
|
mAlarmManager.cancel(mPullingAlarmListener);
|
} finally {
|
Binder.restoreCallingIdentity(callingToken);
|
}
|
}
|
|
private void addNetworkStats(
|
int tag, List<StatsLogEventWrapper> ret, NetworkStats stats, boolean withFGBG) {
|
int size = stats.size();
|
long elapsedNanos = SystemClock.elapsedRealtimeNanos();
|
long wallClockNanos = SystemClock.currentTimeMicro() * 1000L;
|
NetworkStats.Entry entry = new NetworkStats.Entry(); // For recycling
|
for (int j = 0; j < size; j++) {
|
stats.getValues(j, entry);
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tag, elapsedNanos, wallClockNanos);
|
e.writeInt(entry.uid);
|
if (withFGBG) {
|
e.writeInt(entry.set);
|
}
|
e.writeLong(entry.rxBytes);
|
e.writeLong(entry.rxPackets);
|
e.writeLong(entry.txBytes);
|
e.writeLong(entry.txPackets);
|
ret.add(e);
|
}
|
}
|
|
/**
|
* Allows rollups per UID but keeping the set (foreground/background) slicing.
|
* Adapted from groupedByUid in frameworks/base/core/java/android/net/NetworkStats.java
|
*/
|
private NetworkStats rollupNetworkStatsByFGBG(NetworkStats stats) {
|
final NetworkStats ret = new NetworkStats(stats.getElapsedRealtime(), 1);
|
|
final NetworkStats.Entry entry = new NetworkStats.Entry();
|
entry.iface = NetworkStats.IFACE_ALL;
|
entry.tag = NetworkStats.TAG_NONE;
|
entry.metered = NetworkStats.METERED_ALL;
|
entry.roaming = NetworkStats.ROAMING_ALL;
|
|
int size = stats.size();
|
NetworkStats.Entry recycle = new NetworkStats.Entry(); // Used for retrieving values
|
for (int i = 0; i < size; i++) {
|
stats.getValues(i, recycle);
|
|
// Skip specific tags, since already counted in TAG_NONE
|
if (recycle.tag != NetworkStats.TAG_NONE) continue;
|
|
entry.set = recycle.set; // Allows slicing by background/foreground
|
entry.uid = recycle.uid;
|
entry.rxBytes = recycle.rxBytes;
|
entry.rxPackets = recycle.rxPackets;
|
entry.txBytes = recycle.txBytes;
|
entry.txPackets = recycle.txPackets;
|
// Operations purposefully omitted since we don't use them for statsd.
|
ret.combineValues(entry);
|
}
|
return ret;
|
}
|
|
/**
|
* Helper method to extract the Parcelable controller info from a
|
* SynchronousResultReceiver.
|
*/
|
private static <T extends Parcelable> T awaitControllerInfo(
|
@Nullable SynchronousResultReceiver receiver) {
|
if (receiver == null) {
|
return null;
|
}
|
|
try {
|
final SynchronousResultReceiver.Result result =
|
receiver.awaitResult(EXTERNAL_STATS_SYNC_TIMEOUT_MILLIS);
|
if (result.bundle != null) {
|
// This is the final destination for the Bundle.
|
result.bundle.setDefusable(true);
|
|
final T data = result.bundle.getParcelable(
|
RESULT_RECEIVER_CONTROLLER_KEY);
|
if (data != null) {
|
return data;
|
}
|
}
|
Slog.e(TAG, "no controller energy info supplied for " + receiver.getName());
|
} catch (TimeoutException e) {
|
Slog.w(TAG, "timeout reading " + receiver.getName() + " stats");
|
}
|
return null;
|
}
|
|
private void pullKernelWakelock(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
final KernelWakelockStats wakelockStats =
|
mKernelWakelockReader.readKernelWakelockStats(mTmpWakelockStats);
|
for (Map.Entry<String, KernelWakelockStats.Entry> ent : wakelockStats.entrySet()) {
|
String name = ent.getKey();
|
KernelWakelockStats.Entry kws = ent.getValue();
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeString(name);
|
e.writeInt(kws.mCount);
|
e.writeInt(kws.mVersion);
|
e.writeLong(kws.mTotalTime);
|
pulledData.add(e);
|
}
|
}
|
|
private void pullWifiBytesTransfer(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
long token = Binder.clearCallingIdentity();
|
try {
|
// TODO: Consider caching the following call to get BatteryStatsInternal.
|
BatteryStatsInternal bs = LocalServices.getService(BatteryStatsInternal.class);
|
String[] ifaces = bs.getWifiIfaces();
|
if (ifaces.length == 0) {
|
return;
|
}
|
if (mNetworkStatsService == null) {
|
Slog.e(TAG, "NetworkStats Service is not available!");
|
return;
|
}
|
// Combine all the metrics per Uid into one record.
|
NetworkStats stats = mNetworkStatsService.getDetailedUidStats(ifaces).groupedByUid();
|
addNetworkStats(tagId, pulledData, stats, false);
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Pulling netstats for wifi bytes has error", e);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
private void pullWifiBytesTransferByFgBg(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
long token = Binder.clearCallingIdentity();
|
try {
|
BatteryStatsInternal bs = LocalServices.getService(BatteryStatsInternal.class);
|
String[] ifaces = bs.getWifiIfaces();
|
if (ifaces.length == 0) {
|
return;
|
}
|
if (mNetworkStatsService == null) {
|
Slog.e(TAG, "NetworkStats Service is not available!");
|
return;
|
}
|
NetworkStats stats = rollupNetworkStatsByFGBG(
|
mNetworkStatsService.getDetailedUidStats(ifaces));
|
addNetworkStats(tagId, pulledData, stats, true);
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Pulling netstats for wifi bytes w/ fg/bg has error", e);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
private void pullMobileBytesTransfer(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
long token = Binder.clearCallingIdentity();
|
try {
|
BatteryStatsInternal bs = LocalServices.getService(BatteryStatsInternal.class);
|
String[] ifaces = bs.getMobileIfaces();
|
if (ifaces.length == 0) {
|
return;
|
}
|
if (mNetworkStatsService == null) {
|
Slog.e(TAG, "NetworkStats Service is not available!");
|
return;
|
}
|
// Combine all the metrics per Uid into one record.
|
NetworkStats stats = mNetworkStatsService.getDetailedUidStats(ifaces).groupedByUid();
|
addNetworkStats(tagId, pulledData, stats, false);
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Pulling netstats for mobile bytes has error", e);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
private void pullBluetoothBytesTransfer(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
BluetoothActivityEnergyInfo info = fetchBluetoothData();
|
if (info.getUidTraffic() != null) {
|
for (UidTraffic traffic : info.getUidTraffic()) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos,
|
wallClockNanos);
|
e.writeInt(traffic.getUid());
|
e.writeLong(traffic.getRxBytes());
|
e.writeLong(traffic.getTxBytes());
|
pulledData.add(e);
|
}
|
}
|
}
|
|
private void pullMobileBytesTransferByFgBg(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
long token = Binder.clearCallingIdentity();
|
try {
|
BatteryStatsInternal bs = LocalServices.getService(BatteryStatsInternal.class);
|
String[] ifaces = bs.getMobileIfaces();
|
if (ifaces.length == 0) {
|
return;
|
}
|
if (mNetworkStatsService == null) {
|
Slog.e(TAG, "NetworkStats Service is not available!");
|
return;
|
}
|
NetworkStats stats = rollupNetworkStatsByFGBG(
|
mNetworkStatsService.getDetailedUidStats(ifaces));
|
addNetworkStats(tagId, pulledData, stats, true);
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Pulling netstats for mobile bytes w/ fg/bg has error", e);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
private void pullCpuTimePerFreq(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
for (int cluster = 0; cluster < mKernelCpuSpeedReaders.length; cluster++) {
|
long[] clusterTimeMs = mKernelCpuSpeedReaders[cluster].readAbsolute();
|
if (clusterTimeMs != null) {
|
for (int speed = clusterTimeMs.length - 1; speed >= 0; --speed) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos,
|
wallClockNanos);
|
e.writeInt(cluster);
|
e.writeInt(speed);
|
e.writeLong(clusterTimeMs[speed]);
|
pulledData.add(e);
|
}
|
}
|
}
|
}
|
|
private void pullKernelUidCpuTime(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
mCpuUidUserSysTimeReader.readAbsolute((uid, timesUs) -> {
|
long userTimeUs = timesUs[0], systemTimeUs = timesUs[1];
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(uid);
|
e.writeLong(userTimeUs);
|
e.writeLong(systemTimeUs);
|
pulledData.add(e);
|
});
|
}
|
|
private void pullKernelUidCpuFreqTime(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
mCpuUidFreqTimeReader.readAbsolute((uid, cpuFreqTimeMs) -> {
|
for (int freqIndex = 0; freqIndex < cpuFreqTimeMs.length; ++freqIndex) {
|
if (cpuFreqTimeMs[freqIndex] != 0) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos,
|
wallClockNanos);
|
e.writeInt(uid);
|
e.writeInt(freqIndex);
|
e.writeLong(cpuFreqTimeMs[freqIndex]);
|
pulledData.add(e);
|
}
|
}
|
});
|
}
|
|
private void pullKernelUidCpuClusterTime(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
mCpuUidClusterTimeReader.readAbsolute((uid, cpuClusterTimesMs) -> {
|
for (int i = 0; i < cpuClusterTimesMs.length; i++) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos,
|
wallClockNanos);
|
e.writeInt(uid);
|
e.writeInt(i);
|
e.writeLong(cpuClusterTimesMs[i]);
|
pulledData.add(e);
|
}
|
});
|
}
|
|
private void pullKernelUidCpuActiveTime(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
mCpuUidActiveTimeReader.readAbsolute((uid, cpuActiveTimesMs) -> {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(uid);
|
e.writeLong((long) cpuActiveTimesMs);
|
pulledData.add(e);
|
});
|
}
|
|
private void pullWifiActivityInfo(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
long token = Binder.clearCallingIdentity();
|
synchronized (this) {
|
if (mWifiManager == null) {
|
mWifiManager =
|
IWifiManager.Stub.asInterface(
|
ServiceManager.getService(Context.WIFI_SERVICE));
|
}
|
}
|
if (mWifiManager != null) {
|
try {
|
SynchronousResultReceiver wifiReceiver = new SynchronousResultReceiver("wifi");
|
mWifiManager.requestActivityInfo(wifiReceiver);
|
final WifiActivityEnergyInfo wifiInfo = awaitControllerInfo(wifiReceiver);
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos,
|
wallClockNanos);
|
e.writeLong(wifiInfo.getTimeStamp());
|
e.writeInt(wifiInfo.getStackState());
|
e.writeLong(wifiInfo.getControllerTxTimeMillis());
|
e.writeLong(wifiInfo.getControllerRxTimeMillis());
|
e.writeLong(wifiInfo.getControllerIdleTimeMillis());
|
e.writeLong(wifiInfo.getControllerEnergyUsed());
|
pulledData.add(e);
|
} catch (RemoteException e) {
|
Slog.e(TAG,
|
"Pulling wifiManager for wifi controller activity energy info has error",
|
e);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
}
|
|
private void pullModemActivityInfo(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
long token = Binder.clearCallingIdentity();
|
synchronized (this) {
|
if (mTelephony == null) {
|
mTelephony = TelephonyManager.from(mContext);
|
}
|
}
|
if (mTelephony != null) {
|
SynchronousResultReceiver modemReceiver = new SynchronousResultReceiver("telephony");
|
mTelephony.requestModemActivityInfo(modemReceiver);
|
final ModemActivityInfo modemInfo = awaitControllerInfo(modemReceiver);
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeLong(modemInfo.getTimestamp());
|
e.writeLong(modemInfo.getSleepTimeMillis());
|
e.writeLong(modemInfo.getIdleTimeMillis());
|
e.writeLong(modemInfo.getTxTimeMillis()[0]);
|
e.writeLong(modemInfo.getTxTimeMillis()[1]);
|
e.writeLong(modemInfo.getTxTimeMillis()[2]);
|
e.writeLong(modemInfo.getTxTimeMillis()[3]);
|
e.writeLong(modemInfo.getTxTimeMillis()[4]);
|
e.writeLong(modemInfo.getRxTimeMillis());
|
e.writeLong(modemInfo.getEnergyUsed());
|
pulledData.add(e);
|
}
|
}
|
|
private void pullBluetoothActivityInfo(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
BluetoothActivityEnergyInfo info = fetchBluetoothData();
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeLong(info.getTimeStamp());
|
e.writeInt(info.getBluetoothStackState());
|
e.writeLong(info.getControllerTxTimeMillis());
|
e.writeLong(info.getControllerRxTimeMillis());
|
e.writeLong(info.getControllerIdleTimeMillis());
|
e.writeLong(info.getControllerEnergyUsed());
|
pulledData.add(e);
|
}
|
|
private synchronized BluetoothActivityEnergyInfo fetchBluetoothData() {
|
final BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
|
if (adapter != null) {
|
SynchronousResultReceiver bluetoothReceiver = new SynchronousResultReceiver(
|
"bluetooth");
|
adapter.requestControllerActivityEnergyInfo(bluetoothReceiver);
|
return awaitControllerInfo(bluetoothReceiver);
|
} else {
|
Slog.e(TAG, "Failed to get bluetooth adapter!");
|
return null;
|
}
|
}
|
|
private void pullSystemElapsedRealtime(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeLong(SystemClock.elapsedRealtime());
|
pulledData.add(e);
|
}
|
|
private void pullSystemUpTime(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeLong(SystemClock.uptimeMillis());
|
pulledData.add(e);
|
}
|
|
private void pullProcessMemoryState(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
List<ProcessMemoryState> processMemoryStates =
|
LocalServices.getService(
|
ActivityManagerInternal.class).getMemoryStateForProcesses();
|
for (ProcessMemoryState processMemoryState : processMemoryStates) {
|
final MemoryStat memoryStat = readMemoryStatFromFilesystem(processMemoryState.uid,
|
processMemoryState.pid);
|
if (memoryStat == null) {
|
continue;
|
}
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(processMemoryState.uid);
|
e.writeString(processMemoryState.processName);
|
e.writeInt(processMemoryState.oomScore);
|
e.writeLong(memoryStat.pgfault);
|
e.writeLong(memoryStat.pgmajfault);
|
e.writeLong(memoryStat.rssInBytes);
|
e.writeLong(memoryStat.cacheInBytes);
|
e.writeLong(memoryStat.swapInBytes);
|
e.writeLong(0); // unused
|
e.writeLong(memoryStat.startTimeNanos);
|
e.writeInt(anonAndSwapInKilobytes(memoryStat));
|
pulledData.add(e);
|
}
|
}
|
|
private void pullNativeProcessMemoryState(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
final List<String> processNames = Arrays.asList(MEMORY_INTERESTING_NATIVE_PROCESSES);
|
int[] pids = getPidsForCommands(MEMORY_INTERESTING_NATIVE_PROCESSES);
|
for (int i = 0; i < pids.length; i++) {
|
int pid = pids[i];
|
MemoryStat memoryStat = readMemoryStatFromProcfs(pid);
|
if (memoryStat == null) {
|
continue;
|
}
|
int uid = getUidForPid(pid);
|
String processName = readCmdlineFromProcfs(pid);
|
// Sometimes we get here processName that is not included in the whitelist. It comes
|
// from forking the zygote for an app. We can ignore that sample because this process
|
// is collected by ProcessMemoryState.
|
if (!processNames.contains(processName)) {
|
continue;
|
}
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(uid);
|
e.writeString(processName);
|
e.writeLong(memoryStat.pgfault);
|
e.writeLong(memoryStat.pgmajfault);
|
e.writeLong(memoryStat.rssInBytes);
|
e.writeLong(0); // unused
|
e.writeLong(memoryStat.startTimeNanos);
|
e.writeLong(memoryStat.swapInBytes);
|
e.writeInt(anonAndSwapInKilobytes(memoryStat));
|
pulledData.add(e);
|
}
|
}
|
|
private static int anonAndSwapInKilobytes(MemoryStat memoryStat) {
|
return (int) ((memoryStat.anonRssInBytes + memoryStat.swapInBytes) / 1024);
|
}
|
|
private void pullProcessMemoryHighWaterMark(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
List<ProcessMemoryState> managedProcessList =
|
LocalServices.getService(
|
ActivityManagerInternal.class).getMemoryStateForProcesses();
|
for (ProcessMemoryState managedProcess : managedProcessList) {
|
final long rssHighWaterMarkInBytes =
|
readRssHighWaterMarkFromProcfs(managedProcess.pid);
|
if (rssHighWaterMarkInBytes == 0) {
|
continue;
|
}
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(managedProcess.uid);
|
e.writeString(managedProcess.processName);
|
e.writeLong(rssHighWaterMarkInBytes);
|
pulledData.add(e);
|
}
|
int[] pids = getPidsForCommands(MEMORY_INTERESTING_NATIVE_PROCESSES);
|
for (int i = 0; i < pids.length; i++) {
|
final int pid = pids[i];
|
final int uid = getUidForPid(pid);
|
final String processName = readCmdlineFromProcfs(pid);
|
final long rssHighWaterMarkInBytes = readRssHighWaterMarkFromProcfs(pid);
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(uid);
|
e.writeString(processName);
|
e.writeLong(rssHighWaterMarkInBytes);
|
pulledData.add(e);
|
}
|
// Invoke rss_hwm_reset binary to reset RSS HWM counters for all processes.
|
SystemProperties.set("sys.rss_hwm_reset.on", "1");
|
}
|
|
private void pullSystemIonHeapSize(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
final long systemIonHeapSizeInBytes = readSystemIonHeapSizeFromDebugfs();
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeLong(systemIonHeapSizeInBytes);
|
pulledData.add(e);
|
}
|
|
private void pullProcessSystemIonHeapSize(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
List<IonAllocations> result = readProcessSystemIonHeapSizesFromDebugfs();
|
for (IonAllocations allocations : result) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(getUidForPid(allocations.pid));
|
e.writeString(readCmdlineFromProcfs(allocations.pid));
|
e.writeInt((int) (allocations.totalSizeInBytes / 1024));
|
e.writeInt(allocations.count);
|
e.writeInt((int) (allocations.maxSizeInBytes / 1024));
|
pulledData.add(e);
|
}
|
}
|
|
private void pullBinderCallsStats(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
BinderCallsStatsService.Internal binderStats =
|
LocalServices.getService(BinderCallsStatsService.Internal.class);
|
if (binderStats == null) {
|
throw new IllegalStateException("binderStats is null");
|
}
|
|
List<ExportedCallStat> callStats = binderStats.getExportedCallStats();
|
binderStats.reset();
|
for (ExportedCallStat callStat : callStats) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(callStat.workSourceUid);
|
e.writeString(callStat.className);
|
e.writeString(callStat.methodName);
|
e.writeLong(callStat.callCount);
|
e.writeLong(callStat.exceptionCount);
|
e.writeLong(callStat.latencyMicros);
|
e.writeLong(callStat.maxLatencyMicros);
|
e.writeLong(callStat.cpuTimeMicros);
|
e.writeLong(callStat.maxCpuTimeMicros);
|
e.writeLong(callStat.maxReplySizeBytes);
|
e.writeLong(callStat.maxRequestSizeBytes);
|
e.writeLong(callStat.recordedCallCount);
|
e.writeInt(callStat.screenInteractive ? 1 : 0);
|
e.writeInt(callStat.callingUid);
|
pulledData.add(e);
|
}
|
}
|
|
private void pullBinderCallsStatsExceptions(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
BinderCallsStatsService.Internal binderStats =
|
LocalServices.getService(BinderCallsStatsService.Internal.class);
|
if (binderStats == null) {
|
throw new IllegalStateException("binderStats is null");
|
}
|
|
ArrayMap<String, Integer> exceptionStats = binderStats.getExportedExceptionStats();
|
// TODO: decouple binder calls exceptions with the rest of the binder calls data so that we
|
// can reset the exception stats.
|
for (Entry<String, Integer> entry : exceptionStats.entrySet()) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeString(entry.getKey());
|
e.writeInt(entry.getValue());
|
pulledData.add(e);
|
}
|
}
|
|
private void pullLooperStats(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
LooperStats looperStats = LocalServices.getService(LooperStats.class);
|
if (looperStats == null) {
|
throw new IllegalStateException("looperStats null");
|
}
|
|
List<LooperStats.ExportedEntry> entries = looperStats.getEntries();
|
looperStats.reset();
|
for (LooperStats.ExportedEntry entry : entries) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(entry.workSourceUid);
|
e.writeString(entry.handlerClassName);
|
e.writeString(entry.threadName);
|
e.writeString(entry.messageName);
|
e.writeLong(entry.messageCount);
|
e.writeLong(entry.exceptionCount);
|
e.writeLong(entry.recordedMessageCount);
|
e.writeLong(entry.totalLatencyMicros);
|
e.writeLong(entry.cpuUsageMicros);
|
e.writeBoolean(entry.isInteractive);
|
e.writeLong(entry.maxCpuUsageMicros);
|
e.writeLong(entry.maxLatencyMicros);
|
e.writeLong(entry.recordedDelayMessageCount);
|
e.writeLong(entry.delayMillis);
|
e.writeLong(entry.maxDelayMillis);
|
pulledData.add(e);
|
}
|
}
|
|
private void pullDiskStats(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
// Run a quick-and-dirty performance test: write 512 bytes
|
byte[] junk = new byte[512];
|
for (int i = 0; i < junk.length; i++) junk[i] = (byte) i; // Write nonzero bytes
|
|
File tmp = new File(Environment.getDataDirectory(), "system/statsdperftest.tmp");
|
FileOutputStream fos = null;
|
IOException error = null;
|
|
long before = SystemClock.elapsedRealtime();
|
try {
|
fos = new FileOutputStream(tmp);
|
fos.write(junk);
|
} catch (IOException e) {
|
error = e;
|
} finally {
|
try {
|
if (fos != null) fos.close();
|
} catch (IOException e) {
|
// Do nothing.
|
}
|
}
|
|
long latency = SystemClock.elapsedRealtime() - before;
|
if (tmp.exists()) tmp.delete();
|
|
if (error != null) {
|
Slog.e(TAG, "Error performing diskstats latency test");
|
latency = -1;
|
}
|
// File based encryption.
|
boolean fileBased = StorageManager.isFileEncryptedNativeOnly();
|
|
//Recent disk write speed. Binder call to storaged.
|
int writeSpeed = -1;
|
try {
|
IBinder binder = ServiceManager.getService("storaged");
|
if (binder == null) {
|
Slog.e(TAG, "storaged not found");
|
}
|
IStoraged storaged = IStoraged.Stub.asInterface(binder);
|
writeSpeed = storaged.getRecentPerf();
|
} catch (RemoteException e) {
|
Slog.e(TAG, "storaged not found");
|
}
|
|
// Add info pulledData.
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeLong(latency);
|
e.writeBoolean(fileBased);
|
e.writeInt(writeSpeed);
|
pulledData.add(e);
|
}
|
|
private void pullDirectoryUsage(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
StatFs statFsData = new StatFs(Environment.getDataDirectory().getAbsolutePath());
|
StatFs statFsSystem = new StatFs(Environment.getRootDirectory().getAbsolutePath());
|
StatFs statFsCache = new StatFs(Environment.getDownloadCacheDirectory().getAbsolutePath());
|
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.DIRECTORY_USAGE__DIRECTORY__DATA);
|
e.writeLong(statFsData.getAvailableBytes());
|
e.writeLong(statFsData.getTotalBytes());
|
pulledData.add(e);
|
|
e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.DIRECTORY_USAGE__DIRECTORY__CACHE);
|
e.writeLong(statFsCache.getAvailableBytes());
|
e.writeLong(statFsCache.getTotalBytes());
|
pulledData.add(e);
|
|
e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.DIRECTORY_USAGE__DIRECTORY__SYSTEM);
|
e.writeLong(statFsSystem.getAvailableBytes());
|
e.writeLong(statFsSystem.getTotalBytes());
|
pulledData.add(e);
|
}
|
|
private void pullAppSize(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
try {
|
String jsonStr = IoUtils.readFileAsString(DiskStatsLoggingService.DUMPSYS_CACHE_PATH);
|
JSONObject json = new JSONObject(jsonStr);
|
long cache_time = json.optLong(DiskStatsFileLogger.LAST_QUERY_TIMESTAMP_KEY, -1L);
|
JSONArray pkg_names = json.getJSONArray(DiskStatsFileLogger.PACKAGE_NAMES_KEY);
|
JSONArray app_sizes = json.getJSONArray(DiskStatsFileLogger.APP_SIZES_KEY);
|
JSONArray app_data_sizes = json.getJSONArray(DiskStatsFileLogger.APP_DATA_KEY);
|
JSONArray app_cache_sizes = json.getJSONArray(DiskStatsFileLogger.APP_CACHES_KEY);
|
// Sanity check: Ensure all 4 lists have the same length.
|
int length = pkg_names.length();
|
if (app_sizes.length() != length || app_data_sizes.length() != length
|
|| app_cache_sizes.length() != length) {
|
Slog.e(TAG, "formatting error in diskstats cache file!");
|
return;
|
}
|
for (int i = 0; i < length; i++) {
|
StatsLogEventWrapper e =
|
new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeString(pkg_names.getString(i));
|
e.writeLong(app_sizes.optLong(i, -1L));
|
e.writeLong(app_data_sizes.optLong(i, -1L));
|
e.writeLong(app_cache_sizes.optLong(i, -1L));
|
e.writeLong(cache_time);
|
pulledData.add(e);
|
}
|
} catch (IOException | JSONException e) {
|
Slog.e(TAG, "exception reading diskstats cache file", e);
|
}
|
}
|
|
private void pullCategorySize(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
try {
|
String jsonStr = IoUtils.readFileAsString(DiskStatsLoggingService.DUMPSYS_CACHE_PATH);
|
JSONObject json = new JSONObject(jsonStr);
|
long cacheTime = json.optLong(DiskStatsFileLogger.LAST_QUERY_TIMESTAMP_KEY, -1L);
|
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.CATEGORY_SIZE__CATEGORY__APP_SIZE);
|
e.writeLong(json.optLong(DiskStatsFileLogger.APP_SIZE_AGG_KEY, -1L));
|
e.writeLong(cacheTime);
|
pulledData.add(e);
|
|
e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.CATEGORY_SIZE__CATEGORY__APP_DATA_SIZE);
|
e.writeLong(json.optLong(DiskStatsFileLogger.APP_DATA_SIZE_AGG_KEY, -1L));
|
e.writeLong(cacheTime);
|
pulledData.add(e);
|
|
e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.CATEGORY_SIZE__CATEGORY__APP_CACHE_SIZE);
|
e.writeLong(json.optLong(DiskStatsFileLogger.APP_CACHE_AGG_KEY, -1L));
|
e.writeLong(cacheTime);
|
pulledData.add(e);
|
|
e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.CATEGORY_SIZE__CATEGORY__PHOTOS);
|
e.writeLong(json.optLong(DiskStatsFileLogger.PHOTOS_KEY, -1L));
|
e.writeLong(cacheTime);
|
pulledData.add(e);
|
|
e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.CATEGORY_SIZE__CATEGORY__VIDEOS);
|
e.writeLong(json.optLong(DiskStatsFileLogger.VIDEOS_KEY, -1L));
|
e.writeLong(cacheTime);
|
pulledData.add(e);
|
|
e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.CATEGORY_SIZE__CATEGORY__AUDIO);
|
e.writeLong(json.optLong(DiskStatsFileLogger.AUDIO_KEY, -1L));
|
e.writeLong(cacheTime);
|
pulledData.add(e);
|
|
e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.CATEGORY_SIZE__CATEGORY__DOWNLOADS);
|
e.writeLong(json.optLong(DiskStatsFileLogger.DOWNLOADS_KEY, -1L));
|
e.writeLong(cacheTime);
|
pulledData.add(e);
|
|
e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.CATEGORY_SIZE__CATEGORY__SYSTEM);
|
e.writeLong(json.optLong(DiskStatsFileLogger.SYSTEM_KEY, -1L));
|
e.writeLong(cacheTime);
|
pulledData.add(e);
|
|
e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(StatsLog.CATEGORY_SIZE__CATEGORY__OTHER);
|
e.writeLong(json.optLong(DiskStatsFileLogger.MISC_KEY, -1L));
|
e.writeLong(cacheTime);
|
pulledData.add(e);
|
} catch (IOException | JSONException e) {
|
Slog.e(TAG, "exception reading diskstats cache file", e);
|
}
|
}
|
|
private void pullNumBiometricsEnrolled(int modality, int tagId, long elapsedNanos,
|
long wallClockNanos, List<StatsLogEventWrapper> pulledData) {
|
final PackageManager pm = mContext.getPackageManager();
|
FingerprintManager fingerprintManager = null;
|
FaceManager faceManager = null;
|
|
if (pm.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)) {
|
fingerprintManager = mContext.getSystemService(
|
FingerprintManager.class);
|
}
|
if (pm.hasSystemFeature(PackageManager.FEATURE_FACE)) {
|
faceManager = mContext.getSystemService(FaceManager.class);
|
}
|
|
if (modality == BiometricsProtoEnums.MODALITY_FINGERPRINT && fingerprintManager == null) {
|
return;
|
}
|
if (modality == BiometricsProtoEnums.MODALITY_FACE && faceManager == null) {
|
return;
|
}
|
UserManager userManager = mContext.getSystemService(UserManager.class);
|
if (userManager == null) {
|
return;
|
}
|
|
final long token = Binder.clearCallingIdentity();
|
for (UserInfo user : userManager.getUsers()) {
|
final int userId = user.getUserHandle().getIdentifier();
|
int numEnrolled = 0;
|
if (modality == BiometricsProtoEnums.MODALITY_FINGERPRINT) {
|
numEnrolled = fingerprintManager.getEnrolledFingerprints(userId).size();
|
} else if (modality == BiometricsProtoEnums.MODALITY_FACE) {
|
numEnrolled = faceManager.getEnrolledFaces(userId).size();
|
} else {
|
return;
|
}
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(userId);
|
e.writeInt(numEnrolled);
|
pulledData.add(e);
|
}
|
Binder.restoreCallingIdentity(token);
|
}
|
|
// read high watermark for section
|
private long readProcStatsHighWaterMark(int section) {
|
try {
|
File[] files = mBaseDir.listFiles((d, name) -> {
|
return name.toLowerCase().startsWith(String.valueOf(section) + '_');
|
});
|
if (files == null || files.length == 0) {
|
return 0;
|
}
|
if (files.length > 1) {
|
Log.e(TAG, "Only 1 file expected for high water mark. Found " + files.length);
|
}
|
return Long.valueOf(files[0].getName().split("_")[1]);
|
} catch (SecurityException e) {
|
Log.e(TAG, "Failed to get procstats high watermark file.", e);
|
} catch (NumberFormatException e) {
|
Log.e(TAG, "Failed to parse file name.", e);
|
}
|
return 0;
|
}
|
|
private IProcessStats mProcessStats =
|
IProcessStats.Stub.asInterface(ServiceManager.getService(ProcessStats.SERVICE_NAME));
|
|
private void pullProcessStats(int section, int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
synchronized (this) {
|
try {
|
long lastHighWaterMark = readProcStatsHighWaterMark(section);
|
List<ParcelFileDescriptor> statsFiles = new ArrayList<>();
|
long highWaterMark = mProcessStats.getCommittedStats(
|
lastHighWaterMark, section, true, statsFiles);
|
if (statsFiles.size() != 1) {
|
return;
|
}
|
InputStream stream = new ParcelFileDescriptor.AutoCloseInputStream(
|
statsFiles.get(0));
|
int[] len = new int[1];
|
byte[] stats = readFully(stream, len);
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos,
|
wallClockNanos);
|
e.writeStorage(Arrays.copyOf(stats, len[0]));
|
pulledData.add(e);
|
new File(mBaseDir.getAbsolutePath() + "/" + section + "_"
|
+ lastHighWaterMark).delete();
|
new File(
|
mBaseDir.getAbsolutePath() + "/" + section + "_"
|
+ highWaterMark).createNewFile();
|
} catch (IOException e) {
|
Log.e(TAG, "Getting procstats failed: ", e);
|
} catch (RemoteException e) {
|
Log.e(TAG, "Getting procstats failed: ", e);
|
} catch (SecurityException e) {
|
Log.e(TAG, "Getting procstats failed: ", e);
|
}
|
}
|
}
|
|
static byte[] readFully(InputStream stream, int[] outLen) throws IOException {
|
int pos = 0;
|
final int initialAvail = stream.available();
|
byte[] data = new byte[initialAvail > 0 ? (initialAvail + 1) : 16384];
|
while (true) {
|
int amt = stream.read(data, pos, data.length - pos);
|
if (DEBUG) {
|
Slog.i(TAG, "Read " + amt + " bytes at " + pos + " of avail " + data.length);
|
}
|
if (amt < 0) {
|
if (DEBUG) {
|
Slog.i(TAG, "**** FINISHED READING: pos=" + pos + " len=" + data.length);
|
}
|
outLen[0] = pos;
|
return data;
|
}
|
pos += amt;
|
if (pos >= data.length) {
|
byte[] newData = new byte[pos + 16384];
|
if (DEBUG) {
|
Slog.i(TAG, "Copying " + pos + " bytes to new array len " + newData.length);
|
}
|
System.arraycopy(data, 0, newData, 0, pos);
|
data = newData;
|
}
|
}
|
}
|
|
private void pullPowerProfile(
|
int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
PowerProfile powerProfile = new PowerProfile(mContext);
|
checkNotNull(powerProfile);
|
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos,
|
wallClockNanos);
|
ProtoOutputStream proto = new ProtoOutputStream();
|
powerProfile.writeToProto(proto);
|
proto.flush();
|
e.writeStorage(proto.getBytes());
|
pulledData.add(e);
|
}
|
|
private void pullBuildInformation(int tagId,
|
long elapsedNanos, long wallClockNanos, List<StatsLogEventWrapper> pulledData) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeString(Build.FINGERPRINT);
|
e.writeString(Build.BRAND);
|
e.writeString(Build.PRODUCT);
|
e.writeString(Build.DEVICE);
|
e.writeString(Build.VERSION.RELEASE);
|
e.writeString(Build.ID);
|
e.writeString(Build.VERSION.INCREMENTAL);
|
e.writeString(Build.TYPE);
|
e.writeString(Build.TAGS);
|
pulledData.add(e);
|
}
|
|
private BatteryStatsHelper getBatteryStatsHelper() {
|
if (mBatteryStatsHelper == null) {
|
final long callingToken = Binder.clearCallingIdentity();
|
try {
|
// clearCallingIdentity required for BatteryStatsHelper.checkWifiOnly().
|
mBatteryStatsHelper = new BatteryStatsHelper(mContext, false);
|
} finally {
|
Binder.restoreCallingIdentity(callingToken);
|
}
|
mBatteryStatsHelper.create((Bundle) null);
|
}
|
long currentTime = SystemClock.elapsedRealtime();
|
if (currentTime - mBatteryStatsHelperTimestampMs >= MAX_BATTERY_STATS_HELPER_FREQUENCY_MS) {
|
// Load BatteryStats and do all the calculations.
|
mBatteryStatsHelper.refreshStats(BatteryStats.STATS_SINCE_CHARGED, UserHandle.USER_ALL);
|
// Calculations are done so we don't need to save the raw BatteryStats data in RAM.
|
mBatteryStatsHelper.clearStats();
|
mBatteryStatsHelperTimestampMs = currentTime;
|
}
|
return mBatteryStatsHelper;
|
}
|
|
private long milliAmpHrsToNanoAmpSecs(double mAh) {
|
final long MILLI_AMP_HR_TO_NANO_AMP_SECS = 1_000_000L * 3600L;
|
return (long) (mAh * MILLI_AMP_HR_TO_NANO_AMP_SECS + 0.5);
|
}
|
|
private void pullDeviceCalculatedPowerUse(int tagId,
|
long elapsedNanos, final long wallClockNanos, List<StatsLogEventWrapper> pulledData) {
|
BatteryStatsHelper bsHelper = getBatteryStatsHelper();
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeLong(milliAmpHrsToNanoAmpSecs(bsHelper.getComputedPower()));
|
pulledData.add(e);
|
}
|
|
private void pullDeviceCalculatedPowerBlameUid(int tagId,
|
long elapsedNanos, final long wallClockNanos, List<StatsLogEventWrapper> pulledData) {
|
final List<BatterySipper> sippers = getBatteryStatsHelper().getUsageList();
|
if (sippers == null) {
|
return;
|
}
|
for (BatterySipper bs : sippers) {
|
if (bs.drainType != bs.drainType.APP) {
|
continue;
|
}
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(bs.uidObj.getUid());
|
e.writeLong(milliAmpHrsToNanoAmpSecs(bs.totalPowerMah));
|
pulledData.add(e);
|
}
|
}
|
|
private void pullDeviceCalculatedPowerBlameOther(int tagId,
|
long elapsedNanos, final long wallClockNanos, List<StatsLogEventWrapper> pulledData) {
|
final List<BatterySipper> sippers = getBatteryStatsHelper().getUsageList();
|
if (sippers == null) {
|
return;
|
}
|
for (BatterySipper bs : sippers) {
|
if (bs.drainType == bs.drainType.APP) {
|
continue; // This is a separate atom; see pullDeviceCalculatedPowerBlameUid().
|
}
|
if (bs.drainType == bs.drainType.USER) {
|
continue; // This is not supported. We purposefully calculate over USER_ALL.
|
}
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(bs.drainType.ordinal());
|
e.writeLong(milliAmpHrsToNanoAmpSecs(bs.totalPowerMah));
|
pulledData.add(e);
|
}
|
}
|
|
private void pullDiskIo(int tagId, long elapsedNanos, final long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
mStoragedUidIoStatsReader.readAbsolute((uid, fgCharsRead, fgCharsWrite, fgBytesRead,
|
fgBytesWrite, bgCharsRead, bgCharsWrite, bgBytesRead, bgBytesWrite,
|
fgFsync, bgFsync) -> {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos,
|
wallClockNanos);
|
e.writeInt(uid);
|
e.writeLong(fgCharsRead);
|
e.writeLong(fgCharsWrite);
|
e.writeLong(fgBytesRead);
|
e.writeLong(fgBytesWrite);
|
e.writeLong(bgCharsRead);
|
e.writeLong(bgCharsWrite);
|
e.writeLong(bgBytesRead);
|
e.writeLong(bgBytesWrite);
|
e.writeLong(fgFsync);
|
e.writeLong(bgFsync);
|
pulledData.add(e);
|
});
|
}
|
|
private void pullProcessCpuTime(int tagId, long elapsedNanos, final long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
synchronized (this) {
|
if (mProcessCpuTracker == null) {
|
mProcessCpuTracker = new ProcessCpuTracker(false);
|
mProcessCpuTracker.init();
|
}
|
mProcessCpuTracker.update();
|
for (int i = 0; i < mProcessCpuTracker.countStats(); i++) {
|
ProcessCpuTracker.Stats st = mProcessCpuTracker.getStats(i);
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos,
|
wallClockNanos);
|
e.writeInt(st.uid);
|
e.writeString(st.name);
|
e.writeLong(st.base_utime);
|
e.writeLong(st.base_stime);
|
pulledData.add(e);
|
}
|
}
|
}
|
|
private void pullCpuTimePerThreadFreq(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
if (this.mKernelCpuThreadReader == null) {
|
throw new IllegalStateException("mKernelCpuThreadReader is null");
|
}
|
ArrayList<KernelCpuThreadReader.ProcessCpuUsage> processCpuUsages =
|
this.mKernelCpuThreadReader.getProcessCpuUsageDiffed();
|
if (processCpuUsages == null) {
|
throw new IllegalStateException("processCpuUsages is null");
|
}
|
int[] cpuFrequencies = mKernelCpuThreadReader.getCpuFrequenciesKhz();
|
if (cpuFrequencies.length > CPU_TIME_PER_THREAD_FREQ_MAX_NUM_FREQUENCIES) {
|
String message = "Expected maximum " + CPU_TIME_PER_THREAD_FREQ_MAX_NUM_FREQUENCIES
|
+ " frequencies, but got " + cpuFrequencies.length;
|
Slog.w(TAG, message);
|
throw new IllegalStateException(message);
|
}
|
for (int i = 0; i < processCpuUsages.size(); i++) {
|
KernelCpuThreadReader.ProcessCpuUsage processCpuUsage = processCpuUsages.get(i);
|
ArrayList<KernelCpuThreadReader.ThreadCpuUsage> threadCpuUsages =
|
processCpuUsage.threadCpuUsages;
|
for (int j = 0; j < threadCpuUsages.size(); j++) {
|
KernelCpuThreadReader.ThreadCpuUsage threadCpuUsage = threadCpuUsages.get(j);
|
if (threadCpuUsage.usageTimesMillis.length != cpuFrequencies.length) {
|
String message = "Unexpected number of usage times,"
|
+ " expected " + cpuFrequencies.length
|
+ " but got " + threadCpuUsage.usageTimesMillis.length;
|
Slog.w(TAG, message);
|
throw new IllegalStateException(message);
|
}
|
|
StatsLogEventWrapper e =
|
new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(processCpuUsage.uid);
|
e.writeInt(processCpuUsage.processId);
|
e.writeInt(threadCpuUsage.threadId);
|
e.writeString(processCpuUsage.processName);
|
e.writeString(threadCpuUsage.threadName);
|
for (int k = 0; k < CPU_TIME_PER_THREAD_FREQ_MAX_NUM_FREQUENCIES; k++) {
|
if (k < cpuFrequencies.length) {
|
e.writeInt(cpuFrequencies[k]);
|
e.writeInt(threadCpuUsage.usageTimesMillis[k]);
|
} else {
|
// If we have no more frequencies to write, we still must write empty data.
|
// We know that this data is empty (and not just zero) because all
|
// frequencies are expected to be greater than zero
|
e.writeInt(0);
|
e.writeInt(0);
|
}
|
}
|
pulledData.add(e);
|
}
|
}
|
}
|
|
private void pullTemperature(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
long callingToken = Binder.clearCallingIdentity();
|
try {
|
List<Temperature> temperatures = sThermalService.getCurrentTemperatures();
|
for (Temperature temp : temperatures) {
|
StatsLogEventWrapper e =
|
new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(temp.getType());
|
e.writeString(temp.getName());
|
e.writeInt((int) (temp.getValue() * 10));
|
e.writeInt(temp.getStatus());
|
pulledData.add(e);
|
}
|
} catch (RemoteException e) {
|
// Should not happen.
|
Slog.e(TAG, "Disconnected from thermal service. Cannot pull temperatures.");
|
} finally {
|
Binder.restoreCallingIdentity(callingToken);
|
}
|
}
|
|
private void pullCoolingDevices(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
long callingToken = Binder.clearCallingIdentity();
|
try {
|
List<CoolingDevice> devices = sThermalService.getCurrentCoolingDevices();
|
for (CoolingDevice device : devices) {
|
StatsLogEventWrapper e =
|
new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(device.getType());
|
e.writeString(device.getName());
|
e.writeInt((int) (device.getValue()));
|
pulledData.add(e);
|
}
|
} catch (RemoteException e) {
|
// Should not happen.
|
Slog.e(TAG, "Disconnected from thermal service. Cannot pull temperatures.");
|
} finally {
|
Binder.restoreCallingIdentity(callingToken);
|
}
|
}
|
|
private void pullDebugElapsedClock(int tagId,
|
long elapsedNanos, final long wallClockNanos, List<StatsLogEventWrapper> pulledData) {
|
final long elapsedMillis = SystemClock.elapsedRealtime();
|
final long clockDiffMillis = mDebugElapsedClockPreviousValue == 0
|
? 0 : elapsedMillis - mDebugElapsedClockPreviousValue;
|
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeLong(mDebugElapsedClockPullCount);
|
e.writeLong(elapsedMillis);
|
// Log it twice to be able to test multi-value aggregation from ValueMetric.
|
e.writeLong(elapsedMillis);
|
e.writeLong(clockDiffMillis);
|
e.writeInt(1 /* always set */);
|
pulledData.add(e);
|
|
if (mDebugElapsedClockPullCount % 2 == 1) {
|
StatsLogEventWrapper e2 = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e2.writeLong(mDebugElapsedClockPullCount);
|
e2.writeLong(elapsedMillis);
|
// Log it twice to be able to test multi-value aggregation from ValueMetric.
|
e2.writeLong(elapsedMillis);
|
e2.writeLong(clockDiffMillis);
|
e2.writeInt(2 /* set on odd pulls */);
|
pulledData.add(e2);
|
}
|
|
mDebugElapsedClockPullCount++;
|
mDebugElapsedClockPreviousValue = elapsedMillis;
|
}
|
|
private void pullDebugFailingElapsedClock(int tagId,
|
long elapsedNanos, final long wallClockNanos, List<StatsLogEventWrapper> pulledData) {
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
final long elapsedMillis = SystemClock.elapsedRealtime();
|
// Fails every 5 buckets.
|
if (mDebugFailingElapsedClockPullCount++ % 5 == 0) {
|
mDebugFailingElapsedClockPreviousValue = elapsedMillis;
|
throw new RuntimeException("Failing debug elapsed clock");
|
}
|
|
e.writeLong(mDebugFailingElapsedClockPullCount);
|
e.writeLong(elapsedMillis);
|
// Log it twice to be able to test multi-value aggregation from ValueMetric.
|
e.writeLong(elapsedMillis);
|
e.writeLong(mDebugFailingElapsedClockPreviousValue == 0
|
? 0 : elapsedMillis - mDebugFailingElapsedClockPreviousValue);
|
mDebugFailingElapsedClockPreviousValue = elapsedMillis;
|
pulledData.add(e);
|
}
|
|
private void pullDangerousPermissionState(long elapsedNanos, final long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
long token = Binder.clearCallingIdentity();
|
try {
|
PackageManager pm = mContext.getPackageManager();
|
|
List<UserInfo> users = mContext.getSystemService(UserManager.class).getUsers();
|
|
int numUsers = users.size();
|
for (int userNum = 0; userNum < numUsers; userNum++) {
|
UserHandle user = users.get(userNum).getUserHandle();
|
|
List<PackageInfo> pkgs = pm.getInstalledPackagesAsUser(
|
PackageManager.GET_PERMISSIONS, user.getIdentifier());
|
|
int numPkgs = pkgs.size();
|
for (int pkgNum = 0; pkgNum < numPkgs; pkgNum++) {
|
PackageInfo pkg = pkgs.get(pkgNum);
|
|
if (pkg.requestedPermissions == null) {
|
continue;
|
}
|
|
int numPerms = pkg.requestedPermissions.length;
|
for (int permNum = 0; permNum < numPerms; permNum++) {
|
String permName = pkg.requestedPermissions[permNum];
|
|
PermissionInfo permissionInfo;
|
int permissionFlags = 0;
|
try {
|
permissionInfo = pm.getPermissionInfo(permName, 0);
|
permissionFlags =
|
pm.getPermissionFlags(permName, pkg.packageName, user);
|
|
} catch (PackageManager.NameNotFoundException ignored) {
|
continue;
|
}
|
|
if (permissionInfo.getProtection() != PROTECTION_DANGEROUS) {
|
continue;
|
}
|
|
StatsLogEventWrapper e = new StatsLogEventWrapper(
|
StatsLog.DANGEROUS_PERMISSION_STATE, elapsedNanos, wallClockNanos);
|
|
e.writeString(permName);
|
e.writeInt(pkg.applicationInfo.uid);
|
e.writeString(pkg.packageName);
|
e.writeBoolean((pkg.requestedPermissionsFlags[permNum]
|
& REQUESTED_PERMISSION_GRANTED) != 0);
|
e.writeInt(permissionFlags);
|
|
pulledData.add(e);
|
}
|
}
|
}
|
} catch (Throwable t) {
|
Log.e(TAG, "Could not read permissions", t);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
private void pullAppOps(long elapsedNanos, final long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
long token = Binder.clearCallingIdentity();
|
try {
|
AppOpsManager appOps = mContext.getSystemService(AppOpsManager.class);
|
|
CompletableFuture<HistoricalOps> ops = new CompletableFuture<>();
|
HistoricalOpsRequest histOpsRequest =
|
new HistoricalOpsRequest.Builder(
|
Instant.now().minus(1, ChronoUnit.HOURS).toEpochMilli(),
|
Long.MAX_VALUE).build();
|
appOps.getHistoricalOps(histOpsRequest, mContext.getMainExecutor(), ops::complete);
|
|
HistoricalOps histOps = ops.get(EXTERNAL_STATS_SYNC_TIMEOUT_MILLIS,
|
TimeUnit.MILLISECONDS);
|
|
StatsLogEventWrapper e = new StatsLogEventWrapper(StatsLog.APP_OPS, elapsedNanos,
|
wallClockNanos);
|
|
for (int uidIdx = 0; uidIdx < histOps.getUidCount(); uidIdx++) {
|
final HistoricalUidOps uidOps = histOps.getUidOpsAt(uidIdx);
|
final int uid = uidOps.getUid();
|
for (int pkgIdx = 0; pkgIdx < uidOps.getPackageCount(); pkgIdx++) {
|
final HistoricalPackageOps packageOps = uidOps.getPackageOpsAt(pkgIdx);
|
for (int opIdx = 0; opIdx < packageOps.getOpCount(); opIdx++) {
|
final AppOpsManager.HistoricalOp op = packageOps.getOpAt(opIdx);
|
e.writeInt(uid);
|
e.writeString(packageOps.getPackageName());
|
e.writeInt(op.getOpCode());
|
e.writeLong(op.getForegroundAccessCount(OP_FLAGS_ALL_TRUSTED));
|
e.writeLong(op.getBackgroundAccessCount(OP_FLAGS_ALL_TRUSTED));
|
e.writeLong(op.getForegroundRejectCount(OP_FLAGS_ALL_TRUSTED));
|
e.writeLong(op.getBackgroundRejectCount(OP_FLAGS_ALL_TRUSTED));
|
e.writeLong(op.getForegroundAccessDuration(OP_FLAGS_ALL_TRUSTED));
|
e.writeLong(op.getBackgroundAccessDuration(OP_FLAGS_ALL_TRUSTED));
|
pulledData.add(e);
|
}
|
}
|
}
|
} catch (Throwable t) {
|
Log.e(TAG, "Could not read appops", t);
|
} finally {
|
Binder.restoreCallingIdentity(token);
|
}
|
}
|
|
|
/**
|
* Add a RoleHolder atom for each package that holds a role.
|
*
|
* @param elapsedNanos the time since boot
|
* @param wallClockNanos the time on the clock
|
* @param pulledData the data sink to write to
|
*/
|
private void pullRoleHolders(long elapsedNanos, final long wallClockNanos,
|
@NonNull List<StatsLogEventWrapper> pulledData) {
|
long callingToken = Binder.clearCallingIdentity();
|
try {
|
PackageManager pm = mContext.getPackageManager();
|
RoleManagerInternal rmi = LocalServices.getService(RoleManagerInternal.class);
|
|
List<UserInfo> users = mContext.getSystemService(UserManager.class).getUsers();
|
|
int numUsers = users.size();
|
for (int userNum = 0; userNum < numUsers; userNum++) {
|
int userId = users.get(userNum).getUserHandle().getIdentifier();
|
|
ArrayMap<String, ArraySet<String>> roles = rmi.getRolesAndHolders(
|
userId);
|
|
int numRoles = roles.size();
|
for (int roleNum = 0; roleNum < numRoles; roleNum++) {
|
String roleName = roles.keyAt(roleNum);
|
ArraySet<String> holders = roles.valueAt(roleNum);
|
|
int numHolders = holders.size();
|
for (int holderNum = 0; holderNum < numHolders; holderNum++) {
|
String holderName = holders.valueAt(holderNum);
|
|
PackageInfo pkg;
|
try {
|
pkg = pm.getPackageInfoAsUser(holderName, 0, userId);
|
} catch (PackageManager.NameNotFoundException e) {
|
Log.w(TAG, "Role holder " + holderName + " not found");
|
return;
|
}
|
|
StatsLogEventWrapper e = new StatsLogEventWrapper(StatsLog.ROLE_HOLDER,
|
elapsedNanos, wallClockNanos);
|
e.writeInt(pkg.applicationInfo.uid);
|
e.writeString(holderName);
|
e.writeString(roleName);
|
pulledData.add(e);
|
}
|
}
|
}
|
} finally {
|
Binder.restoreCallingIdentity(callingToken);
|
}
|
}
|
|
private void pullTimeZoneDataInfo(int tagId,
|
long elapsedNanos, long wallClockNanos, List<StatsLogEventWrapper> pulledData) {
|
String tzDbVersion = "Unknown";
|
try {
|
tzDbVersion = android.icu.util.TimeZone.getTZDataVersion();
|
} catch (Exception e) {
|
Log.e(TAG, "Getting tzdb version failed: ", e);
|
}
|
|
StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeString(tzDbVersion);
|
pulledData.add(e);
|
}
|
|
private void pullExternalStorageInfo(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
StorageManager storageManager = mContext.getSystemService(StorageManager.class);
|
if (storageManager != null) {
|
List<VolumeInfo> volumes = storageManager.getVolumes();
|
for (VolumeInfo vol : volumes) {
|
final String envState = VolumeInfo.getEnvironmentForState(vol.getState());
|
final DiskInfo diskInfo = vol.getDisk();
|
if (diskInfo != null) {
|
if (envState.equals(Environment.MEDIA_MOUNTED)) {
|
// Get the type of the volume, if it is adoptable or portable.
|
int volumeType = StatsLog.EXTERNAL_STORAGE_INFO__VOLUME_TYPE__OTHER;
|
if (vol.getType() == TYPE_PUBLIC) {
|
volumeType = StatsLog.EXTERNAL_STORAGE_INFO__VOLUME_TYPE__PUBLIC;
|
} else if (vol.getType() == TYPE_PRIVATE) {
|
volumeType = StatsLog.EXTERNAL_STORAGE_INFO__VOLUME_TYPE__PRIVATE;
|
}
|
// Get the type of external storage inserted in the device (sd cards,
|
// usb, etc)
|
int externalStorageType;
|
if (diskInfo.isSd()) {
|
externalStorageType = StorageEnums.SD_CARD;
|
} else if (diskInfo.isUsb()) {
|
externalStorageType = StorageEnums.USB;
|
} else {
|
externalStorageType = StorageEnums.OTHER;
|
}
|
StatsLogEventWrapper e =
|
new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(externalStorageType);
|
e.writeInt(volumeType);
|
e.writeLong(diskInfo.size);
|
pulledData.add(e);
|
}
|
}
|
}
|
}
|
}
|
|
private void pullAppsOnExternalStorageInfo(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
PackageManager pm = mContext.getPackageManager();
|
StorageManager storage = mContext.getSystemService(StorageManager.class);
|
List<ApplicationInfo> apps = pm.getInstalledApplications(/* flags = */ 0);
|
for (ApplicationInfo appInfo : apps) {
|
UUID storageUuid = appInfo.storageUuid;
|
if (storageUuid != null) {
|
VolumeInfo volumeInfo = storage.findVolumeByUuid(appInfo.storageUuid.toString());
|
if (volumeInfo != null) {
|
DiskInfo diskInfo = volumeInfo.getDisk();
|
if (diskInfo != null) {
|
int externalStorageType = -1;
|
if (diskInfo.isSd()) {
|
externalStorageType = StorageEnums.SD_CARD;
|
} else if (diskInfo.isUsb()) {
|
externalStorageType = StorageEnums.USB;
|
} else if (appInfo.isExternal()) {
|
externalStorageType = StorageEnums.OTHER;
|
}
|
// App is installed on external storage.
|
if (externalStorageType != -1) {
|
StatsLogEventWrapper e =
|
new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeInt(externalStorageType);
|
e.writeString(appInfo.packageName);
|
pulledData.add(e);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
private void pullFaceSettings(int tagId, long elapsedNanos, long wallClockNanos,
|
List<StatsLogEventWrapper> pulledData) {
|
long callingToken = Binder.clearCallingIdentity();
|
try {
|
List<UserInfo> users = mContext.getSystemService(UserManager.class).getUsers();
|
int numUsers = users.size();
|
for (int userNum = 0; userNum < numUsers; userNum++) {
|
int userId = users.get(userNum).getUserHandle().getIdentifier();
|
|
StatsLogEventWrapper e =
|
new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
|
e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
|
Settings.Secure.FACE_UNLOCK_KEYGUARD_ENABLED, 1,
|
userId) != 0);
|
e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
|
Settings.Secure.FACE_UNLOCK_DISMISSES_KEYGUARD,
|
0, userId) != 0);
|
e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
|
Settings.Secure.FACE_UNLOCK_ATTENTION_REQUIRED, 1,
|
userId) != 0);
|
e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
|
Settings.Secure.FACE_UNLOCK_APP_ENABLED, 1,
|
userId) != 0);
|
e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
|
Settings.Secure.FACE_UNLOCK_ALWAYS_REQUIRE_CONFIRMATION, 0,
|
userId) != 0);
|
e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
|
Settings.Secure.FACE_UNLOCK_DIVERSITY_REQUIRED, 1,
|
userId) != 0);
|
|
pulledData.add(e);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(callingToken);
|
}
|
}
|
|
/**
|
* Pulls various data.
|
*/
|
@Override // Binder call
|
public StatsLogEventWrapper[] pullData(int tagId) {
|
enforceCallingPermission();
|
if (DEBUG) {
|
Slog.d(TAG, "Pulling " + tagId);
|
}
|
List<StatsLogEventWrapper> ret = new ArrayList<>();
|
long elapsedNanos = SystemClock.elapsedRealtimeNanos();
|
long wallClockNanos = SystemClock.currentTimeMicro() * 1000L;
|
switch (tagId) {
|
case StatsLog.WIFI_BYTES_TRANSFER: {
|
pullWifiBytesTransfer(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.MOBILE_BYTES_TRANSFER: {
|
pullMobileBytesTransfer(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.WIFI_BYTES_TRANSFER_BY_FG_BG: {
|
pullWifiBytesTransferByFgBg(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.MOBILE_BYTES_TRANSFER_BY_FG_BG: {
|
pullMobileBytesTransferByFgBg(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.BLUETOOTH_BYTES_TRANSFER: {
|
pullBluetoothBytesTransfer(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.KERNEL_WAKELOCK: {
|
pullKernelWakelock(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.CPU_TIME_PER_FREQ: {
|
pullCpuTimePerFreq(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.CPU_TIME_PER_UID: {
|
pullKernelUidCpuTime(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.CPU_TIME_PER_UID_FREQ: {
|
pullKernelUidCpuFreqTime(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.CPU_CLUSTER_TIME: {
|
pullKernelUidCpuClusterTime(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.CPU_ACTIVE_TIME: {
|
pullKernelUidCpuActiveTime(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.WIFI_ACTIVITY_INFO: {
|
pullWifiActivityInfo(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.MODEM_ACTIVITY_INFO: {
|
pullModemActivityInfo(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.BLUETOOTH_ACTIVITY_INFO: {
|
pullBluetoothActivityInfo(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.SYSTEM_UPTIME: {
|
pullSystemUpTime(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.SYSTEM_ELAPSED_REALTIME: {
|
pullSystemElapsedRealtime(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.PROCESS_MEMORY_STATE: {
|
pullProcessMemoryState(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.NATIVE_PROCESS_MEMORY_STATE: {
|
pullNativeProcessMemoryState(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.PROCESS_MEMORY_HIGH_WATER_MARK: {
|
pullProcessMemoryHighWaterMark(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.SYSTEM_ION_HEAP_SIZE: {
|
pullSystemIonHeapSize(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.PROCESS_SYSTEM_ION_HEAP_SIZE: {
|
pullProcessSystemIonHeapSize(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.BINDER_CALLS: {
|
pullBinderCallsStats(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.BINDER_CALLS_EXCEPTIONS: {
|
pullBinderCallsStatsExceptions(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.LOOPER_STATS: {
|
pullLooperStats(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.DISK_STATS: {
|
pullDiskStats(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.DIRECTORY_USAGE: {
|
pullDirectoryUsage(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.APP_SIZE: {
|
pullAppSize(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.CATEGORY_SIZE: {
|
pullCategorySize(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.NUM_FINGERPRINTS_ENROLLED: {
|
pullNumBiometricsEnrolled(BiometricsProtoEnums.MODALITY_FINGERPRINT, tagId,
|
elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.NUM_FACES_ENROLLED: {
|
pullNumBiometricsEnrolled(BiometricsProtoEnums.MODALITY_FACE, tagId, elapsedNanos,
|
wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.PROC_STATS: {
|
pullProcessStats(ProcessStats.REPORT_ALL, tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.PROC_STATS_PKG_PROC: {
|
pullProcessStats(ProcessStats.REPORT_PKG_PROC_STATS, tagId, elapsedNanos,
|
wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.DISK_IO: {
|
pullDiskIo(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.POWER_PROFILE: {
|
pullPowerProfile(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.BUILD_INFORMATION: {
|
pullBuildInformation(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.PROCESS_CPU_TIME: {
|
pullProcessCpuTime(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.CPU_TIME_PER_THREAD_FREQ: {
|
pullCpuTimePerThreadFreq(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.DEVICE_CALCULATED_POWER_USE: {
|
pullDeviceCalculatedPowerUse(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.DEVICE_CALCULATED_POWER_BLAME_UID: {
|
pullDeviceCalculatedPowerBlameUid(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.DEVICE_CALCULATED_POWER_BLAME_OTHER: {
|
pullDeviceCalculatedPowerBlameOther(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.TEMPERATURE: {
|
pullTemperature(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.COOLING_DEVICE: {
|
pullCoolingDevices(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.DEBUG_ELAPSED_CLOCK: {
|
pullDebugElapsedClock(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.DEBUG_FAILING_ELAPSED_CLOCK: {
|
pullDebugFailingElapsedClock(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.ROLE_HOLDER: {
|
pullRoleHolders(elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.DANGEROUS_PERMISSION_STATE: {
|
pullDangerousPermissionState(elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.TIME_ZONE_DATA_INFO: {
|
pullTimeZoneDataInfo(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.EXTERNAL_STORAGE_INFO: {
|
pullExternalStorageInfo(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.APPS_ON_EXTERNAL_STORAGE_INFO: {
|
pullAppsOnExternalStorageInfo(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.FACE_SETTINGS: {
|
pullFaceSettings(tagId, elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
case StatsLog.APP_OPS: {
|
pullAppOps(elapsedNanos, wallClockNanos, ret);
|
break;
|
}
|
default:
|
Slog.w(TAG, "No such tagId data as " + tagId);
|
return null;
|
}
|
return ret.toArray(new StatsLogEventWrapper[ret.size()]);
|
}
|
|
@Override // Binder call
|
public void statsdReady() {
|
enforceCallingPermission();
|
if (DEBUG) {
|
Slog.d(TAG, "learned that statsdReady");
|
}
|
sayHiToStatsd(); // tell statsd that we're ready too and link to it
|
mContext.sendBroadcastAsUser(new Intent(StatsManager.ACTION_STATSD_STARTED)
|
.addFlags(Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND),
|
UserHandle.SYSTEM, android.Manifest.permission.DUMP);
|
}
|
|
@Override
|
public void triggerUidSnapshot() {
|
enforceCallingPermission();
|
synchronized (sStatsdLock) {
|
final long token = Binder.clearCallingIdentity();
|
try {
|
informAllUidsLocked(mContext);
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Failed to trigger uid snapshot.", e);
|
} finally {
|
restoreCallingIdentity(token);
|
}
|
}
|
}
|
|
private void enforceCallingPermission() {
|
if (Binder.getCallingPid() == Process.myPid()) {
|
return;
|
}
|
mContext.enforceCallingPermission(android.Manifest.permission.STATSCOMPANION, null);
|
}
|
|
// Lifecycle and related code
|
|
/**
|
* Fetches the statsd IBinder service
|
*/
|
private static IStatsManager fetchStatsdService() {
|
return IStatsManager.Stub.asInterface(ServiceManager.getService("stats"));
|
}
|
|
public static final class Lifecycle extends SystemService {
|
private StatsCompanionService mStatsCompanionService;
|
|
public Lifecycle(Context context) {
|
super(context);
|
}
|
|
@Override
|
public void onStart() {
|
mStatsCompanionService = new StatsCompanionService(getContext());
|
try {
|
publishBinderService(Context.STATS_COMPANION_SERVICE,
|
mStatsCompanionService);
|
if (DEBUG) Slog.d(TAG, "Published " + Context.STATS_COMPANION_SERVICE);
|
} catch (Exception e) {
|
Slog.e(TAG, "Failed to publishBinderService", e);
|
}
|
}
|
|
@Override
|
public void onBootPhase(int phase) {
|
super.onBootPhase(phase);
|
if (phase == PHASE_THIRD_PARTY_APPS_CAN_START) {
|
mStatsCompanionService.systemReady();
|
}
|
}
|
}
|
|
/**
|
* Now that the android system is ready, StatsCompanion is ready too, so inform statsd.
|
*/
|
private void systemReady() {
|
if (DEBUG) Slog.d(TAG, "Learned that systemReady");
|
sayHiToStatsd();
|
}
|
|
/**
|
* Tells statsd that statscompanion is ready. If the binder call returns, link to
|
* statsd.
|
*/
|
private void sayHiToStatsd() {
|
synchronized (sStatsdLock) {
|
if (sStatsd != null) {
|
Slog.e(TAG, "Trying to fetch statsd, but it was already fetched",
|
new IllegalStateException(
|
"sStatsd is not null when being fetched"));
|
return;
|
}
|
sStatsd = fetchStatsdService();
|
if (sStatsd == null) {
|
Slog.i(TAG,
|
"Could not yet find statsd to tell it that StatsCompanion is "
|
+ "alive.");
|
return;
|
}
|
if (DEBUG) Slog.d(TAG, "Saying hi to statsd");
|
try {
|
sStatsd.statsCompanionReady();
|
// If the statsCompanionReady two-way binder call returns, link to statsd.
|
try {
|
sStatsd.asBinder().linkToDeath(new StatsdDeathRecipient(), 0);
|
} catch (RemoteException e) {
|
Slog.e(TAG, "linkToDeath(StatsdDeathRecipient) failed", e);
|
forgetEverythingLocked();
|
}
|
// Setup broadcast receiver for updates.
|
IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_REPLACED);
|
filter.addAction(Intent.ACTION_PACKAGE_ADDED);
|
filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
|
filter.addDataScheme("package");
|
mContext.registerReceiverAsUser(mAppUpdateReceiver, UserHandle.ALL, filter,
|
null,
|
null);
|
|
// Setup receiver for user initialize (which happens once for a new user)
|
// and
|
// if a user is removed.
|
filter = new IntentFilter(Intent.ACTION_USER_INITIALIZE);
|
filter.addAction(Intent.ACTION_USER_REMOVED);
|
mContext.registerReceiverAsUser(mUserUpdateReceiver, UserHandle.ALL,
|
filter, null, null);
|
|
// Setup receiver for device reboots or shutdowns.
|
filter = new IntentFilter(Intent.ACTION_REBOOT);
|
filter.addAction(Intent.ACTION_SHUTDOWN);
|
mContext.registerReceiverAsUser(
|
mShutdownEventReceiver, UserHandle.ALL, filter, null, null);
|
final long token = Binder.clearCallingIdentity();
|
try {
|
// Pull the latest state of UID->app name, version mapping when
|
// statsd starts.
|
informAllUidsLocked(mContext);
|
} finally {
|
restoreCallingIdentity(token);
|
}
|
Slog.i(TAG, "Told statsd that StatsCompanionService is alive.");
|
} catch (RemoteException e) {
|
Slog.e(TAG, "Failed to inform statsd that statscompanion is ready", e);
|
forgetEverythingLocked();
|
}
|
}
|
}
|
|
private class StatsdDeathRecipient implements IBinder.DeathRecipient {
|
@Override
|
public void binderDied() {
|
Slog.i(TAG, "Statsd is dead - erase all my knowledge.");
|
synchronized (sStatsdLock) {
|
long now = SystemClock.elapsedRealtime();
|
for (Long timeMillis : mDeathTimeMillis) {
|
long ageMillis = now - timeMillis;
|
if (ageMillis > MILLIS_IN_A_DAY) {
|
mDeathTimeMillis.remove(timeMillis);
|
}
|
}
|
for (Long timeMillis : mDeletedFiles.keySet()) {
|
long ageMillis = now - timeMillis;
|
if (ageMillis > MILLIS_IN_A_DAY * 7) {
|
mDeletedFiles.remove(timeMillis);
|
}
|
}
|
mDeathTimeMillis.add(now);
|
if (mDeathTimeMillis.size() >= DEATH_THRESHOLD) {
|
mDeathTimeMillis.clear();
|
File[] configs = FileUtils.listFilesOrEmpty(new File(CONFIG_DIR));
|
if (configs.length > 0) {
|
String fileName = configs[0].getName();
|
if (configs[0].delete()) {
|
mDeletedFiles.put(now, fileName);
|
}
|
}
|
}
|
forgetEverythingLocked();
|
}
|
}
|
}
|
|
@GuardedBy("StatsCompanionService.sStatsdLock")
|
private void forgetEverythingLocked() {
|
sStatsd = null;
|
mContext.unregisterReceiver(mAppUpdateReceiver);
|
mContext.unregisterReceiver(mUserUpdateReceiver);
|
mContext.unregisterReceiver(mShutdownEventReceiver);
|
cancelAnomalyAlarm();
|
cancelPullingAlarm();
|
|
BinderCallsStatsService.Internal binderStats =
|
LocalServices.getService(BinderCallsStatsService.Internal.class);
|
if (binderStats != null) {
|
binderStats.reset();
|
}
|
|
LooperStats looperStats = LocalServices.getService(LooperStats.class);
|
if (looperStats != null) {
|
looperStats.reset();
|
}
|
}
|
|
@Override
|
protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
|
if (!DumpUtils.checkDumpPermission(mContext, TAG, writer)) return;
|
|
synchronized (sStatsdLock) {
|
writer.println(
|
"Number of configuration files deleted: " + mDeletedFiles.size());
|
if (mDeletedFiles.size() > 0) {
|
writer.println(" timestamp, deleted file name");
|
}
|
long lastBootMillis =
|
SystemClock.currentThreadTimeMillis() - SystemClock.elapsedRealtime();
|
for (Long elapsedMillis : mDeletedFiles.keySet()) {
|
long deletionMillis = lastBootMillis + elapsedMillis;
|
writer.println(
|
" " + deletionMillis + ", " + mDeletedFiles.get(elapsedMillis));
|
}
|
}
|
}
|
|
// Thermal event received from vendor thermal management subsystem
|
private static final class ThermalEventListener extends IThermalEventListener.Stub {
|
@Override
|
public void notifyThrottling(Temperature temp) {
|
StatsLog.write(StatsLog.THERMAL_THROTTLING_SEVERITY_STATE_CHANGED, temp.getType(),
|
temp.getName(), (int) (temp.getValue() * 10), temp.getStatus());
|
}
|
}
|
|
private static final class ConnectivityStatsCallback extends
|
ConnectivityManager.NetworkCallback {
|
@Override
|
public void onAvailable(Network network) {
|
StatsLog.write(StatsLog.CONNECTIVITY_STATE_CHANGED, network.netId,
|
StatsLog.CONNECTIVITY_STATE_CHANGED__STATE__CONNECTED);
|
}
|
|
@Override
|
public void onLost(Network network) {
|
StatsLog.write(StatsLog.CONNECTIVITY_STATE_CHANGED, network.netId,
|
StatsLog.CONNECTIVITY_STATE_CHANGED__STATE__DISCONNECTED);
|
}
|
}
|
}
|
