Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3ee8e203 authored by Jeffrey Huang's avatar Jeffrey Huang
Browse files

Migrate PullWifiBytesTransfer java puller 

Add threading logic for services.
Copied imports from StatsCompanionService to avoid merge conflicts.

Bug: 145565211
Test: ran adb shell cmd stats pull-source 10000
Change-Id: I888e4b05e9aff517c3c06987ef36056644a9e9be
parent fdd3c7cd

apex/statsd/service/java/com/android/server/stats/StatsCompanionService.java

+52 −29
Original line number Diff line number Diff line
@@ -881,31 +881,6 @@ public class StatsCompanionService extends IStatsCompanionService.Stub { 
        }

    }



    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) {
@@ -2382,149 +2357,180 @@ public class StatsCompanionService extends IStatsCompanionService.Stub { 
        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.PROCESS_MEMORY_HIGH_WATER_MARK: {

                pullProcessMemoryHighWaterMark(tagId, elapsedNanos, wallClockNanos, ret);

                break;

            }



            case StatsLog.PROCESS_MEMORY_SNAPSHOT: {

                pullProcessMemorySnapshot(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;
@@ -2533,73 +2539,90 @@ public class StatsCompanionService extends IStatsCompanionService.Stub { 
                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(StatsLog.DANGEROUS_PERMISSION_STATE, elapsedNanos,

                        wallClockNanos, ret);

                break;

            }



            case StatsLog.DANGEROUS_PERMISSION_STATE_SAMPLED: {

                pullDangerousPermissionState(StatsLog.DANGEROUS_PERMISSION_STATE_SAMPLED,

                        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;

            }



            case StatsLog.NOTIFICATION_REMOTE_VIEWS: {

                pullNotificationStats(NotificationManagerService.REPORT_REMOTE_VIEWS,

                        tagId, elapsedNanos, wallClockNanos, ret);

                break;

            }



            default:

                Slog.w(TAG, "No such tagId data as " + tagId);

                return null;

cmds/statsd/src/external/StatsPullerManager.cpp

+0 −4
Original line number Diff line number Diff line
@@ -59,10 +59,6 @@ namespace statsd { 
const int64_t NO_ALARM_UPDATE = INT64_MAX;



std::map<PullerKey, PullAtomInfo> StatsPullerManager::kAllPullAtomInfo = {

        // wifi_bytes_transfer

        {{.atomTag = android::util::WIFI_BYTES_TRANSFER},

         {.additiveFields = {2, 3, 4, 5},

          .puller = new StatsCompanionServicePuller(android::util::WIFI_BYTES_TRANSFER)}},



        // wifi_bytes_transfer_by_fg_bg

        {{.atomTag = android::util::WIFI_BYTES_TRANSFER_BY_FG_BG},

services/core/java/com/android/server/stats/StatsPullAtomService.java

+262 −7
Original line number Diff line number Diff line
@@ -16,12 +16,166 @@ 


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.THREAD_PRIORITY_BACKGROUND;

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.server.am.MemoryStatUtil.readMemoryStatFromFilesystem;

import static com.android.server.stats.IonMemoryUtil.readProcessSystemIonHeapSizesFromDebugfs;

import static com.android.server.stats.IonMemoryUtil.readSystemIonHeapSizeFromDebugfs;

import static com.android.server.stats.ProcfsMemoryUtil.forEachPid;

import static com.android.server.stats.ProcfsMemoryUtil.readCmdlineFromProcfs;

import static com.android.server.stats.ProcfsMemoryUtil.readMemorySnapshotFromProcfs;



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.INotificationManager;

import android.app.ProcessMemoryState;

import android.app.StatsManager;

import android.app.StatsManager.PullAtomMetadata;

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.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.WifiManager;

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.IPullAtomCallback;

import android.os.IStatsCompanionService;

import android.os.IStatsd;

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.RemoteException;

import android.os.ServiceManager;

import android.os.StatFs;

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.connectivity.WifiActivityEnergyInfo;

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.StatsEvent;

import android.util.StatsLog;

import android.util.proto.ProtoOutputStream;



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.MemoryStat;

import com.android.server.notification.NotificationManagerService;

import com.android.server.role.RoleManagerInternal;

import com.android.server.stats.IonMemoryUtil.IonAllocations;

import com.android.server.stats.ProcfsMemoryUtil.MemorySnapshot;

import com.android.server.storage.DiskStatsFileLogger;

import com.android.server.storage.DiskStatsLoggingService;



import com.google.android.collect.Sets;



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.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.Objects;

import java.util.Set;

import java.util.UUID;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.Executor;

import java.util.concurrent.Executors;

import java.util.concurrent.ThreadLocalRandom;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.TimeoutException;



/**

 * SystemService containing PullAtomCallbacks that are registered with statsd.
@@ -32,16 +186,24 @@ public class StatsPullAtomService extends SystemService { 
    private static final String TAG = "StatsPullAtomService";

    private static final boolean DEBUG = true;



    private final StatsManager mStatsManager;

    private final Object mNetworkStatsLock = new Object();

    @GuardedBy("mNetworkStatsLock")

    private INetworkStatsService mNetworkStatsService;

    private final Object mThermalLock = new Object();

    @GuardedBy("mThermalLock")

    private IThermalService mThermalService;



    private final Context mContext;

    private StatsManager mStatsManager;



    public StatsPullAtomService(Context context) {

        super(context);

        mStatsManager = (StatsManager) context.getSystemService(Context.STATS_MANAGER);

        mContext = context;

    }



    @Override

    public void onStart() {

        // No op.

        mStatsManager = (StatsManager) mContext.getSystemService(Context.STATS_MANAGER);

    }



    @Override
@@ -119,12 +281,105 @@ public class StatsPullAtomService extends SystemService { 
        registerDangerousPermissionStateSampled();

    }



    private void registerWifiBytesTransfer() {

        // No op.

    private INetworkStatsService getINetworkStatsService() {

        synchronized (mNetworkStatsLock) {

            if (mNetworkStatsService == null) {

                mNetworkStatsService = INetworkStatsService.Stub.asInterface(

                        ServiceManager.getService(Context.NETWORK_STATS_SERVICE));

                if (mNetworkStatsService != null) {

                    try {

                        mNetworkStatsService.asBinder().linkToDeath(() -> {

                            synchronized (mNetworkStatsLock) {

                                mNetworkStatsService = null;

                            }

                        }, /* flags */ 0);

                    } catch (RemoteException e) {

                        Slog.e(TAG, "linkToDeath with NetworkStatsService failed", e);

                        mNetworkStatsService = null;

                    }

                }



    private void pullWifiBytesTransfer() {

        // No op.

            }

            return mNetworkStatsService;

        }

    }



    private IThermalService getIThermalService() {

        synchronized (mThermalLock) {

            if (mThermalService == null) {

                mThermalService = IThermalService.Stub.asInterface(

                        ServiceManager.getService(Context.THERMAL_SERVICE));

                if (mThermalService != null) {

                    try {

                        mThermalService.asBinder().linkToDeath(() -> {

                            synchronized (mThermalLock) {

                                mThermalService = null;

                            }

                        }, /* flags */ 0);

                    } catch (RemoteException e) {

                        Slog.e(TAG, "linkToDeath with thermalService failed", e);

                        mThermalService = null;

                    }

                }

            }

            return mThermalService;

        }

    }

    private void registerWifiBytesTransfer() {

        int tagId = StatsLog.WIFI_BYTES_TRANSFER;

        PullAtomMetadata metaData = PullAtomMetadata.newBuilder()

                .setAdditiveFields(new int[] {2, 3, 4, 5}).build();

        mStatsManager.registerPullAtomCallback(

                tagId,

                metaData,

                (atomTag, data) -> pullWifiBytesTransfer(atomTag, data),

                Executors.newSingleThreadExecutor()

        );

    }



    private int pullWifiBytesTransfer(int atomTag, List<StatsEvent> pulledData) {

        INetworkStatsService networkStatsService = getINetworkStatsService();

        if (networkStatsService == null) {

            Slog.e(TAG, "NetworkStats Service is not available!");

            return StatsManager.PULL_SKIP;

        }

        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 StatsManager.PULL_SKIP;

            }

            // Combine all the metrics per Uid into one record.

            NetworkStats stats = networkStatsService.getDetailedUidStats(ifaces).groupedByUid();

            addNetworkStats(atomTag, pulledData, stats, false);

        } catch (RemoteException e) {

            Slog.e(TAG, "Pulling netstats for wifi bytes has error", e);

        } finally {

            Binder.restoreCallingIdentity(token);

        }

        return StatsManager.PULL_SUCCESS;

    }



    private void addNetworkStats(

            int tag, List<StatsEvent> ret, NetworkStats stats, boolean withFGBG) {

        int size = stats.size();

        NetworkStats.Entry entry = new NetworkStats.Entry(); // For recycling

        for (int j = 0; j < size; j++) {

            stats.getValues(j, entry);

            StatsEvent.Builder e = StatsEvent.newBuilder();

            e.setAtomId(tag);

            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.build());

        }

    }



    private void registerWifiBytesTransferBackground() {