Merge "Add support of AttributionIds and AttributionChains to Discrete registry" into sc-dev am: d5b63b58b5

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/14936972 Change-Id: I7c4dc0d7bc5f84c54bd6dff28524604e79254fc3
2021-06-16 19:26:08 +00:00
parent 386a890ab9 d5b63b58b5
commit cffcf462e6
3 changed files with 82 additions and 34 deletions
--- a/services/core/java/com/android/server/appop/AppOpsService.java
+++ b/services/core/java/com/android/server/appop/AppOpsService.java
@@ -848,7 +848,7 @@ public class AppOpsService extends IAppOpsService.Stub {
            return mAttributionFlags;
        }

-        /** @return attributoin chiang id for the access */
+        /** @return attribution chain id for the access */
        public int getAttributionChainId() {
            return mAttributionChainId;
        }
@@ -912,7 +912,8 @@ public class AppOpsService extends IAppOpsService.Stub {
                    proxyAttributionTag, uidState, flags);

            mHistoricalRegistry.incrementOpAccessedCount(parent.op, parent.uid, parent.packageName,
-                    tag, uidState, flags, accessTime);
+                    tag, uidState, flags, accessTime, AppOpsManager.ATTRIBUTION_FLAGS_NONE,
+                    AppOpsManager.ATTRIBUTION_CHAIN_ID_NONE);
        }

        /**
@@ -1053,9 +1054,9 @@ public class AppOpsService extends IAppOpsService.Stub {
            event.numUnfinishedStarts++;

            if (isStarted) {
-                // TODO: Consider storing the attribution chain flags and id
                mHistoricalRegistry.incrementOpAccessedCount(parent.op, parent.uid,
-                        parent.packageName, tag, uidState, flags, startTime);
+                        parent.packageName, tag, uidState, flags, startTime, attributionFlags,
+                        attributionChainId);
            }
        }

@@ -1112,7 +1113,8 @@ public class AppOpsService extends IAppOpsService.Stub {

                mHistoricalRegistry.increaseOpAccessDuration(parent.op, parent.uid,
                        parent.packageName, tag, event.getUidState(),
-                        event.getFlags(), finishedEvent.getNoteTime(), finishedEvent.getDuration());
+                        event.getFlags(), finishedEvent.getNoteTime(), finishedEvent.getDuration(),
+                        event.getAttributionFlags(), event.getAttributionChainId());

                if (!isPausing) {
                    mInProgressStartOpEventPool.release(event);
@@ -1215,7 +1217,8 @@ public class AppOpsService extends IAppOpsService.Stub {
                event.mStartElapsedTime = SystemClock.elapsedRealtime();
                event.mStartTime = startTime;
                mHistoricalRegistry.incrementOpAccessedCount(parent.op, parent.uid,
-                        parent.packageName, tag, event.mUidState, event.mFlags, startTime);
+                        parent.packageName, tag, event.mUidState, event.mFlags, startTime,
+                        event.getAttributionFlags(), event.getAttributionChainId());
                if (shouldSendActive) {
                    scheduleOpActiveChangedIfNeededLocked(parent.op, parent.uid, parent.packageName,
                            tag, true, event.getAttributionFlags(), event.getAttributionChainId());
--- a/services/core/java/com/android/server/appop/DiscreteRegistry.java
+++ b/services/core/java/com/android/server/appop/DiscreteRegistry.java
@@ -26,6 +26,7 @@ import static android.app.AppOpsManager.OP_FINE_LOCATION;
 import static android.app.AppOpsManager.OP_FLAGS_ALL;
 import static android.app.AppOpsManager.OP_FLAG_SELF;
 import static android.app.AppOpsManager.OP_FLAG_TRUSTED_PROXIED;
+import static android.app.AppOpsManager.OP_FLAG_TRUSTED_PROXY;
 import static android.app.AppOpsManager.OP_NONE;
 import static android.app.AppOpsManager.OP_PHONE_CALL_CAMERA;
 import static android.app.AppOpsManager.OP_PHONE_CALL_MICROPHONE;
@@ -156,8 +157,11 @@ final class DiscreteRegistry {
    private static final String ATTR_NOTE_DURATION = "nd";
    private static final String ATTR_UID_STATE = "us";
    private static final String ATTR_FLAGS = "f";
+    private static final String ATTR_ATTRIBUTION_FLAGS = "af";
+    private static final String ATTR_CHAIN_ID = "ci";

-    private static final int OP_FLAGS_DISCRETE = OP_FLAG_SELF | OP_FLAG_TRUSTED_PROXIED;
+    private static final int OP_FLAGS_DISCRETE = OP_FLAG_SELF | OP_FLAG_TRUSTED_PROXIED
+            | OP_FLAG_TRUSTED_PROXY;

    // Lock for read/write access to on disk state
    private final Object mOnDiskLock = new Object();
@@ -227,13 +231,14 @@ final class DiscreteRegistry {

    void recordDiscreteAccess(int uid, String packageName, int op, @Nullable String attributionTag,
            @AppOpsManager.OpFlags int flags, @AppOpsManager.UidState int uidState, long accessTime,
-            long accessDuration) {
+            long accessDuration, @AppOpsManager.AttributionFlags int attributionFlags,
+            int attributionChainId) {
        if (!isDiscreteOp(op, flags)) {
            return;
        }
        synchronized (mInMemoryLock) {
            mDiscreteOps.addDiscreteAccess(op, uid, packageName, attributionTag, flags, uidState,
-                    accessTime, accessDuration);
+                    accessTime, accessDuration, attributionFlags, attributionChainId);
        }
    }

@@ -383,9 +388,10 @@ final class DiscreteRegistry {

        void addDiscreteAccess(int op, int uid, @NonNull String packageName,
                @Nullable String attributionTag, @AppOpsManager.OpFlags int flags,
-                @AppOpsManager.UidState int uidState, long accessTime, long accessDuration) {
+                @AppOpsManager.UidState int uidState, long accessTime, long accessDuration,
+                @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
            getOrCreateDiscreteUidOps(uid).addDiscreteAccess(op, packageName, attributionTag, flags,
-                    uidState, accessTime, accessDuration);
+                    uidState, accessTime, accessDuration, attributionFlags, attributionChainId);
        }

        private void filter(long beginTimeMillis, long endTimeMillis,
@@ -613,9 +619,10 @@ final class DiscreteRegistry {

        void addDiscreteAccess(int op, @NonNull String packageName, @Nullable String attributionTag,
                @AppOpsManager.OpFlags int flags, @AppOpsManager.UidState int uidState,
-                long accessTime, long accessDuration) {
+                long accessTime, long accessDuration,
+                @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
            getOrCreateDiscretePackageOps(packageName).addDiscreteAccess(op, attributionTag, flags,
-                    uidState, accessTime, accessDuration);
+                    uidState, accessTime, accessDuration, attributionFlags, attributionChainId);
        }

        private DiscretePackageOps getOrCreateDiscretePackageOps(String packageName) {
@@ -680,9 +687,10 @@ final class DiscreteRegistry {

        void addDiscreteAccess(int op, @Nullable String attributionTag,
                @AppOpsManager.OpFlags int flags, @AppOpsManager.UidState int uidState,
-                long accessTime, long accessDuration) {
+                long accessTime, long accessDuration,
+                @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
            getOrCreateDiscreteOp(op).addDiscreteAccess(attributionTag, flags, uidState, accessTime,
-                    accessDuration);
+                    accessDuration, attributionFlags, attributionChainId);
        }

        void merge(DiscretePackageOps other) {
@@ -823,37 +831,39 @@ final class DiscreteRegistry {
                for (int j = 0; j < n; j++) {
                    DiscreteOpEvent event = list.get(j);
                    list.set(j, new DiscreteOpEvent(event.mNoteTime - offset, event.mNoteDuration,
-                            event.mUidState, event.mOpFlag));
+                            event.mUidState, event.mOpFlag, event.mAttributionFlags,
+                            event.mAttributionChainId));
                }
            }
        }

        void addDiscreteAccess(@Nullable String attributionTag,
                @AppOpsManager.OpFlags int flags, @AppOpsManager.UidState int uidState,
-                long accessTime, long accessDuration) {
+                long accessTime, long accessDuration,
+                @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
            List<DiscreteOpEvent> attributedOps = getOrCreateDiscreteOpEventsList(
                    attributionTag);
-            accessTime = accessTime / sDiscreteHistoryQuantization * sDiscreteHistoryQuantization;
-            accessDuration = accessDuration == -1 ? -1
-                    : (accessDuration + sDiscreteHistoryQuantization - 1)
-                            / sDiscreteHistoryQuantization * sDiscreteHistoryQuantization;

            int nAttributedOps = attributedOps.size();
            int i = nAttributedOps;
            for (; i > 0; i--) {
                DiscreteOpEvent previousOp = attributedOps.get(i - 1);
-                if (previousOp.mNoteTime < accessTime) {
+                if (discretizeTimeStamp(previousOp.mNoteTime) < discretizeTimeStamp(accessTime)) {
                    break;
                }
-                if (previousOp.mOpFlag == flags && previousOp.mUidState == uidState) {
-                    if (accessDuration != previousOp.mNoteDuration) {
+                if (previousOp.mOpFlag == flags && previousOp.mUidState == uidState
+                        && previousOp.mAttributionFlags == attributionFlags
+                        && previousOp.mAttributionChainId == attributionChainId) {
+                    if (discretizeDuration(accessDuration) != discretizeDuration(
+                            previousOp.mNoteDuration)) {
                        break;
                    } else {
                        return;
                    }
                }
            }
-            attributedOps.add(i, new DiscreteOpEvent(accessTime, accessDuration, uidState, flags));
+            attributedOps.add(i, new DiscreteOpEvent(accessTime, accessDuration, uidState, flags,
+                    attributionFlags, attributionChainId));
        }

        private List<DiscreteOpEvent> getOrCreateDiscreteOpEventsList(String attributionTag) {
@@ -875,7 +885,8 @@ final class DiscreteRegistry {
                for (int j = 0; j < nEvents; j++) {
                    DiscreteOpEvent event = events.get(j);
                    result.addDiscreteAccess(op, uid, packageName, tag, event.mUidState,
-                            event.mOpFlag, event.mNoteTime, event.mNoteDuration);
+                            event.mOpFlag, discretizeTimeStamp(event.mNoteTime),
+                            discretizeDuration(event.mNoteDuration));
                }
            }
        }
@@ -932,11 +943,15 @@ final class DiscreteRegistry {
                                    -1);
                            int uidState = parser.getAttributeInt(null, ATTR_UID_STATE);
                            int opFlags = parser.getAttributeInt(null, ATTR_FLAGS);
+                            int attributionFlags = parser.getAttributeInt(null,
+                                    ATTR_ATTRIBUTION_FLAGS, AppOpsManager.ATTRIBUTION_FLAGS_NONE);
+                            int attributionChainId = parser.getAttributeInt(null, ATTR_CHAIN_ID,
+                                    AppOpsManager.ATTRIBUTION_CHAIN_ID_NONE);
                            if (noteTime + noteDuration < beginTimeMillis) {
                                continue;
                            }
                            DiscreteOpEvent event = new DiscreteOpEvent(noteTime, noteDuration,
-                                    uidState, opFlags);
+                                    uidState, opFlags, attributionFlags, attributionChainId);
                            events.add(event);
                        }
                    }
@@ -952,13 +967,18 @@ final class DiscreteRegistry {
        final long mNoteDuration;
        final @AppOpsManager.UidState int mUidState;
        final @AppOpsManager.OpFlags int mOpFlag;
+        final @AppOpsManager.AttributionFlags int mAttributionFlags;
+        final int mAttributionChainId;

        DiscreteOpEvent(long noteTime, long noteDuration, @AppOpsManager.UidState int uidState,
-                @AppOpsManager.OpFlags int opFlag) {
+                @AppOpsManager.OpFlags int opFlag,
+                @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
            mNoteTime = noteTime;
            mNoteDuration = noteDuration;
            mUidState = uidState;
            mOpFlag = opFlag;
+            mAttributionFlags = attributionFlags;
+            mAttributionChainId = attributionChainId;
        }

        private void dump(@NonNull PrintWriter pw, @NonNull SimpleDateFormat sdf,
@@ -969,13 +989,19 @@ final class DiscreteRegistry {
            pw.print("-");
            pw.print(flagsToString(mOpFlag));
            pw.print("] at ");
-            date.setTime(mNoteTime);
+            date.setTime(discretizeTimeStamp(mNoteTime));
            pw.print(sdf.format(date));
            if (mNoteDuration != -1) {
                pw.print(" for ");
-                pw.print(mNoteDuration);
+                pw.print(discretizeDuration(mNoteDuration));
                pw.print(" milliseconds ");
            }
+            if (mAttributionFlags != AppOpsManager.ATTRIBUTION_FLAGS_NONE) {
+                pw.print(" attribution flags=");
+                pw.print(mAttributionFlags);
+                pw.print(" with chainId=");
+                pw.print(mAttributionChainId);
+            }
            pw.println();
        }

@@ -984,6 +1010,12 @@ final class DiscreteRegistry {
            if (mNoteDuration != -1) {
                out.attributeLong(null, ATTR_NOTE_DURATION, mNoteDuration);
            }
+            if (mAttributionFlags != AppOpsManager.ATTRIBUTION_FLAGS_NONE) {
+                out.attributeInt(null, ATTR_ATTRIBUTION_FLAGS, mAttributionFlags);
+            }
+            if (mAttributionChainId != AppOpsManager.ATTRIBUTION_CHAIN_ID_NONE) {
+                out.attributeInt(null, ATTR_CHAIN_ID, mAttributionChainId);
+            }
            out.attributeInt(null, ATTR_UID_STATE, mUidState);
            out.attributeInt(null, ATTR_FLAGS, mOpFlag);
        }
@@ -1055,6 +1087,16 @@ final class DiscreteRegistry {
        return true;
    }

+    private static long discretizeTimeStamp(long timeStamp) {
+        return timeStamp / sDiscreteHistoryQuantization * sDiscreteHistoryQuantization;
+
+    }
+
+    private static long discretizeDuration(long duration) {
+        return duration == -1 ? -1 : (duration + sDiscreteHistoryQuantization - 1)
+                        / sDiscreteHistoryQuantization * sDiscreteHistoryQuantization;
+    }
+
    void setDebugMode(boolean debugMode) {
        this.mDebugMode = debugMode;
    }
--- a/services/core/java/com/android/server/appop/HistoricalRegistry.java
+++ b/services/core/java/com/android/server/appop/HistoricalRegistry.java
@@ -487,7 +487,8 @@ final class HistoricalRegistry {

    void incrementOpAccessedCount(int op, int uid, @NonNull String packageName,
            @Nullable String attributionTag, @UidState int uidState, @OpFlags int flags,
-            long accessTime) {
+            long accessTime, @AppOpsManager.AttributionFlags int attributionFlags,
+            int attributionChainId) {
        synchronized (mInMemoryLock) {
            if (mMode == AppOpsManager.HISTORICAL_MODE_ENABLED_ACTIVE) {
                if (!isPersistenceInitializedMLocked()) {
@@ -499,7 +500,7 @@ final class HistoricalRegistry {
                        attributionTag, uidState, flags, 1);

                mDiscreteRegistry.recordDiscreteAccess(uid, packageName, op, attributionTag,
-                        flags, uidState, accessTime, -1);
+                        flags, uidState, accessTime, -1, attributionFlags, attributionChainId);
            }
        }
    }
@@ -521,7 +522,8 @@ final class HistoricalRegistry {

    void increaseOpAccessDuration(int op, int uid, @NonNull String packageName,
            @Nullable String attributionTag, @UidState int uidState, @OpFlags int flags,
-            long eventStartTime, long increment) {
+            long eventStartTime, long increment,
+            @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
        synchronized (mInMemoryLock) {
            if (mMode == AppOpsManager.HISTORICAL_MODE_ENABLED_ACTIVE) {
                if (!isPersistenceInitializedMLocked()) {
@@ -532,7 +534,8 @@ final class HistoricalRegistry {
                        System.currentTimeMillis()).increaseAccessDuration(op, uid, packageName,
                        attributionTag, uidState, flags, increment);
                mDiscreteRegistry.recordDiscreteAccess(uid, packageName, op, attributionTag,
-                        flags, uidState, eventStartTime, increment);
+                        flags, uidState, eventStartTime, increment, attributionFlags,
+                        attributionChainId);
            }
        }
    }