BroadcastQueue: factor out historical broadcasts. (5b2df738) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/am/BroadcastHistory.java

0 → 100644

+224 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.am;

		import android.app.ActivityManager;
		import android.content.Intent;
		import android.os.Bundle;
		import android.util.TimeUtils;
		import android.util.proto.ProtoOutputStream;

		import java.io.PrintWriter;
		import java.text.SimpleDateFormat;
		import java.util.Date;

		/**
		* Collection of recent historical broadcasts that are available to be dumped
		* for debugging purposes. Automatically trims itself over time.
		*/
		public class BroadcastHistory {
		static final int MAX_BROADCAST_HISTORY = ActivityManager.isLowRamDeviceStatic() ? 10 : 50;
		static final int MAX_BROADCAST_SUMMARY_HISTORY
		= ActivityManager.isLowRamDeviceStatic() ? 25 : 300;

		/**
		* Historical data of past broadcasts, for debugging. This is a ring buffer
		* whose last element is at mHistoryNext.
		*/
		final BroadcastRecord[] mBroadcastHistory = new BroadcastRecord[MAX_BROADCAST_HISTORY];
		int mHistoryNext = 0;

		/**
		* Summary of historical data of past broadcasts, for debugging. This is a
		* ring buffer whose last element is at mSummaryHistoryNext.
		*/
		final Intent[] mBroadcastSummaryHistory = new Intent[MAX_BROADCAST_SUMMARY_HISTORY];
		int mSummaryHistoryNext = 0;

		/**
		* Various milestone timestamps of entries in the mBroadcastSummaryHistory ring
		* buffer, also tracked via the mSummaryHistoryNext index. These are all in wall
		* clock time, not elapsed.
		*/
		final long[] mSummaryHistoryEnqueueTime = new long[MAX_BROADCAST_SUMMARY_HISTORY];
		final long[] mSummaryHistoryDispatchTime = new long[MAX_BROADCAST_SUMMARY_HISTORY];
		final long[] mSummaryHistoryFinishTime = new long[MAX_BROADCAST_SUMMARY_HISTORY];

		public void addBroadcastToHistoryLocked(BroadcastRecord original) {
		// Note sometimes (only for sticky broadcasts?) we reuse BroadcastRecords,
		// So don't change the incoming record directly.
		final BroadcastRecord historyRecord = original.maybeStripForHistory();

		mBroadcastHistory[mHistoryNext] = historyRecord;
		mHistoryNext = ringAdvance(mHistoryNext, 1, MAX_BROADCAST_HISTORY);

		mBroadcastSummaryHistory[mSummaryHistoryNext] = historyRecord.intent;
		mSummaryHistoryEnqueueTime[mSummaryHistoryNext] = historyRecord.enqueueClockTime;
		mSummaryHistoryDispatchTime[mSummaryHistoryNext] = historyRecord.dispatchClockTime;
		mSummaryHistoryFinishTime[mSummaryHistoryNext] = System.currentTimeMillis();
		mSummaryHistoryNext = ringAdvance(mSummaryHistoryNext, 1, MAX_BROADCAST_SUMMARY_HISTORY);
		}

		private final int ringAdvance(int x, final int increment, final int ringSize) {
		x += increment;
		if (x < 0) return (ringSize - 1);
		else if (x >= ringSize) return 0;
		else return x;
		}

		public void dumpDebug(ProtoOutputStream proto) {
		int lastIndex = mHistoryNext;
		int ringIndex = lastIndex;
		do {
		// increasing index = more recent entry, and we want to print the most
		// recent first and work backwards, so we roll through the ring backwards.
		ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_HISTORY);
		BroadcastRecord r = mBroadcastHistory[ringIndex];
		if (r != null) {
		r.dumpDebug(proto, BroadcastQueueProto.HISTORICAL_BROADCASTS);
		}
		} while (ringIndex != lastIndex);

		lastIndex = ringIndex = mSummaryHistoryNext;
		do {
		ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_SUMMARY_HISTORY);
		Intent intent = mBroadcastSummaryHistory[ringIndex];
		if (intent == null) {
		continue;
		}
		long summaryToken = proto.start(BroadcastQueueProto.HISTORICAL_BROADCASTS_SUMMARY);
		intent.dumpDebug(proto, BroadcastQueueProto.BroadcastSummary.INTENT,
		false, true, true, false);
		proto.write(BroadcastQueueProto.BroadcastSummary.ENQUEUE_CLOCK_TIME_MS,
		mSummaryHistoryEnqueueTime[ringIndex]);
		proto.write(BroadcastQueueProto.BroadcastSummary.DISPATCH_CLOCK_TIME_MS,
		mSummaryHistoryDispatchTime[ringIndex]);
		proto.write(BroadcastQueueProto.BroadcastSummary.FINISH_CLOCK_TIME_MS,
		mSummaryHistoryFinishTime[ringIndex]);
		proto.end(summaryToken);
		} while (ringIndex != lastIndex);
		}

		public boolean dumpLocked(PrintWriter pw, String dumpPackage, String queueName,
		SimpleDateFormat sdf, boolean dumpAll, boolean needSep) {
		int i;
		boolean printed = false;

		i = -1;
		int lastIndex = mHistoryNext;
		int ringIndex = lastIndex;
		do {
		// increasing index = more recent entry, and we want to print the most
		// recent first and work backwards, so we roll through the ring backwards.
		ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_HISTORY);
		BroadcastRecord r = mBroadcastHistory[ringIndex];
		if (r == null) {
		continue;
		}

		i++; // genuine record of some sort even if we're filtering it out
		if (dumpPackage != null && !dumpPackage.equals(r.callerPackage)) {
		continue;
		}
		if (!printed) {
		if (needSep) {
		pw.println();
		}
		needSep = true;
		pw.println(" Historical broadcasts [" + queueName + "]:");
		printed = true;
		}
		if (dumpAll) {
		pw.print(" Historical Broadcast " + queueName + " #");
		pw.print(i); pw.println(":");
		r.dump(pw, " ", sdf);
		} else {
		pw.print(" #"); pw.print(i); pw.print(": "); pw.println(r);
		pw.print(" ");
		pw.println(r.intent.toShortString(false, true, true, false));
		if (r.targetComp != null && r.targetComp != r.intent.getComponent()) {
		pw.print(" targetComp: "); pw.println(r.targetComp.toShortString());
		}
		Bundle bundle = r.intent.getExtras();
		if (bundle != null) {
		pw.print(" extras: "); pw.println(bundle.toString());
		}
		}
		} while (ringIndex != lastIndex);

		if (dumpPackage == null) {
		lastIndex = ringIndex = mSummaryHistoryNext;
		if (dumpAll) {
		printed = false;
		i = -1;
		} else {
		// roll over the 'i' full dumps that have already been issued
		for (int j = i;
		j > 0 && ringIndex != lastIndex;) {
		ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_SUMMARY_HISTORY);
		BroadcastRecord r = mBroadcastHistory[ringIndex];
		if (r == null) {
		continue;
		}
		j--;
		}
		}
		// done skipping; dump the remainder of the ring. 'i' is still the ordinal within
		// the overall broadcast history.
		do {
		ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_SUMMARY_HISTORY);
		Intent intent = mBroadcastSummaryHistory[ringIndex];
		if (intent == null) {
		continue;
		}
		if (!printed) {
		if (needSep) {
		pw.println();
		}
		needSep = true;
		pw.println(" Historical broadcasts summary [" + queueName + "]:");
		printed = true;
		}
		if (!dumpAll && i >= 50) {
		pw.println(" ...");
		break;
		}
		i++;
		pw.print(" #"); pw.print(i); pw.print(": ");
		pw.println(intent.toShortString(false, true, true, false));
		pw.print(" ");
		TimeUtils.formatDuration(mSummaryHistoryDispatchTime[ringIndex]
		- mSummaryHistoryEnqueueTime[ringIndex], pw);
		pw.print(" dispatch ");
		TimeUtils.formatDuration(mSummaryHistoryFinishTime[ringIndex]
		- mSummaryHistoryDispatchTime[ringIndex], pw);
		pw.println(" finish");
		pw.print(" enq=");
		pw.print(sdf.format(new Date(mSummaryHistoryEnqueueTime[ringIndex])));
		pw.print(" disp=");
		pw.print(sdf.format(new Date(mSummaryHistoryDispatchTime[ringIndex])));
		pw.print(" fin=");
		pw.println(sdf.format(new Date(mSummaryHistoryFinishTime[ringIndex])));
		Bundle bundle = intent.getExtras();
		if (bundle != null) {
		pw.print(" extras: "); pw.println(bundle.toString());
		}
		} while (ringIndex != lastIndex);
		}
		return needSep;
		}
		}

services/core/java/com/android/server/am/BroadcastQueue.java

+3 −1

Original line number	Diff line number	Diff line
		@@ -41,16 +41,18 @@ public abstract class BroadcastQueue {
		final @NonNull Handler mHandler;
		final @NonNull BroadcastConstants mConstants;
		final @NonNull BroadcastSkipPolicy mSkipPolicy;
		final @NonNull BroadcastHistory mHistory;
		final @NonNull String mQueueName;

		BroadcastQueue(@NonNull ActivityManagerService service, @NonNull Handler handler,
		@NonNull String name, @NonNull BroadcastConstants constants,
		@NonNull BroadcastSkipPolicy skipPolicy) {
		@NonNull BroadcastSkipPolicy skipPolicy, @NonNull BroadcastHistory history) {
		mService = Objects.requireNonNull(service);
		mHandler = Objects.requireNonNull(handler);
		mQueueName = Objects.requireNonNull(name);
		mConstants = Objects.requireNonNull(constants);
		mSkipPolicy = Objects.requireNonNull(skipPolicy);
		mHistory = Objects.requireNonNull(history);
		}

		void start(@NonNull ContentResolver resolver) {

services/core/java/com/android/server/am/BroadcastQueueImpl.java

+6 −189

Original line number	Diff line number	Diff line
		@@ -73,7 +73,6 @@ import android.text.TextUtils;
		import android.util.EventLog;
		import android.util.Slog;
		import android.util.SparseIntArray;
		import android.util.TimeUtils;
		import android.util.proto.ProtoOutputStream;

		import com.android.internal.os.TimeoutRecord;
		@@ -85,7 +84,6 @@ import java.io.FileDescriptor;
		import java.io.PrintWriter;
		import java.text.SimpleDateFormat;
		import java.util.ArrayList;
		import java.util.Date;
		import java.util.Set;
		import java.util.function.BooleanSupplier;

		@@ -100,10 +98,6 @@ public class BroadcastQueueImpl extends BroadcastQueue {
		private static final String TAG_MU = TAG + POSTFIX_MU;
		private static final String TAG_BROADCAST = TAG + POSTFIX_BROADCAST;

		static final int MAX_BROADCAST_HISTORY = ActivityManager.isLowRamDeviceStatic() ? 10 : 50;
		static final int MAX_BROADCAST_SUMMARY_HISTORY
		= ActivityManager.isLowRamDeviceStatic() ? 25 : 300;

		/**
		* If true, we can delay broadcasts while waiting services to finish in the previous
		* receiver's process.
		@@ -133,29 +127,6 @@ public class BroadcastQueueImpl extends BroadcastQueue {
		final SparseIntArray mSplitRefcounts = new SparseIntArray();
		private int mNextToken = 0;

		/**
		* Historical data of past broadcasts, for debugging. This is a ring buffer
		* whose last element is at mHistoryNext.
		*/
		final BroadcastRecord[] mBroadcastHistory = new BroadcastRecord[MAX_BROADCAST_HISTORY];
		int mHistoryNext = 0;

		/**
		* Summary of historical data of past broadcasts, for debugging. This is a
		* ring buffer whose last element is at mSummaryHistoryNext.
		*/
		final Intent[] mBroadcastSummaryHistory = new Intent[MAX_BROADCAST_SUMMARY_HISTORY];
		int mSummaryHistoryNext = 0;

		/**
		* Various milestone timestamps of entries in the mBroadcastSummaryHistory ring
		* buffer, also tracked via the mSummaryHistoryNext index. These are all in wall
		* clock time, not elapsed.
		*/
		final long[] mSummaryHistoryEnqueueTime = new long[MAX_BROADCAST_SUMMARY_HISTORY];
		final long[] mSummaryHistoryDispatchTime = new long[MAX_BROADCAST_SUMMARY_HISTORY];
		final long[] mSummaryHistoryFinishTime = new long[MAX_BROADCAST_SUMMARY_HISTORY];

		/**
		* Set when we current have a BROADCAST_INTENT_MSG in flight.
		*/
		@@ -214,13 +185,13 @@ public class BroadcastQueueImpl extends BroadcastQueue {
		BroadcastQueueImpl(ActivityManagerService service, Handler handler,
		String name, BroadcastConstants constants, boolean allowDelayBehindServices) {
		this(service, handler, name, constants, new BroadcastSkipPolicy(service),
		allowDelayBehindServices);
		new BroadcastHistory(), allowDelayBehindServices);
		}

		BroadcastQueueImpl(ActivityManagerService service, Handler handler,
		String name, BroadcastConstants constants, BroadcastSkipPolicy skipPolicy,
		boolean allowDelayBehindServices) {
		super(service, handler, name, constants, skipPolicy);
		BroadcastHistory history, boolean allowDelayBehindServices) {
		super(service, handler, name, constants, skipPolicy, history);
		mHandler = new BroadcastHandler(handler.getLooper());
		mDelayBehindServices = allowDelayBehindServices;
		mDispatcher = new BroadcastDispatcher(this, mConstants, mHandler, mService);
		@@ -1685,13 +1656,6 @@ public class BroadcastQueueImpl extends BroadcastQueue {
		}
		}

		private final int ringAdvance(int x, final int increment, final int ringSize) {
		x += increment;
		if (x < 0) return (ringSize - 1);
		else if (x >= ringSize) return 0;
		else return x;
		}

		private final void addBroadcastToHistoryLocked(BroadcastRecord original) {
		if (original.callingUid < 0) {
		// This was from a registerReceiver() call; ignore it.
		@@ -1712,18 +1676,7 @@ public class BroadcastQueueImpl extends BroadcastQueue {
		original.callingUid, 0, callerPackage).sendToTarget();
		}

		// Note sometimes (only for sticky broadcasts?) we reuse BroadcastRecords,
		// So don't change the incoming record directly.
		final BroadcastRecord historyRecord = original.maybeStripForHistory();

		mBroadcastHistory[mHistoryNext] = historyRecord;
		mHistoryNext = ringAdvance(mHistoryNext, 1, MAX_BROADCAST_HISTORY);

		mBroadcastSummaryHistory[mSummaryHistoryNext] = historyRecord.intent;
		mSummaryHistoryEnqueueTime[mSummaryHistoryNext] = historyRecord.enqueueClockTime;
		mSummaryHistoryDispatchTime[mSummaryHistoryNext] = historyRecord.dispatchClockTime;
		mSummaryHistoryFinishTime[mSummaryHistoryNext] = System.currentTimeMillis();
		mSummaryHistoryNext = ringAdvance(mSummaryHistoryNext, 1, MAX_BROADCAST_SUMMARY_HISTORY);
		mHistory.addBroadcastToHistoryLocked(original);
		}

		public boolean cleanupDisabledPackageReceiversLocked(
		@@ -1871,37 +1824,7 @@ public class BroadcastQueueImpl extends BroadcastQueue {
		if (mPendingBroadcast != null) {
		mPendingBroadcast.dumpDebug(proto, BroadcastQueueProto.PENDING_BROADCAST);
		}

		int lastIndex = mHistoryNext;
		int ringIndex = lastIndex;
		do {
		// increasing index = more recent entry, and we want to print the most
		// recent first and work backwards, so we roll through the ring backwards.
		ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_HISTORY);
		BroadcastRecord r = mBroadcastHistory[ringIndex];
		if (r != null) {
		r.dumpDebug(proto, BroadcastQueueProto.HISTORICAL_BROADCASTS);
		}
		} while (ringIndex != lastIndex);

		lastIndex = ringIndex = mSummaryHistoryNext;
		do {
		ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_SUMMARY_HISTORY);
		Intent intent = mBroadcastSummaryHistory[ringIndex];
		if (intent == null) {
		continue;
		}
		long summaryToken = proto.start(BroadcastQueueProto.HISTORICAL_BROADCASTS_SUMMARY);
		intent.dumpDebug(proto, BroadcastQueueProto.BroadcastSummary.INTENT,
		false, true, true, false);
		proto.write(BroadcastQueueProto.BroadcastSummary.ENQUEUE_CLOCK_TIME_MS,
		mSummaryHistoryEnqueueTime[ringIndex]);
		proto.write(BroadcastQueueProto.BroadcastSummary.DISPATCH_CLOCK_TIME_MS,
		mSummaryHistoryDispatchTime[ringIndex]);
		proto.write(BroadcastQueueProto.BroadcastSummary.FINISH_CLOCK_TIME_MS,
		mSummaryHistoryFinishTime[ringIndex]);
		proto.end(summaryToken);
		} while (ringIndex != lastIndex);
		mHistory.dumpDebug(proto);
		proto.end(token);
		}

		@@ -1942,114 +1865,8 @@ public class BroadcastQueueImpl extends BroadcastQueue {
		needSep = true;
		}
		}

		mConstants.dump(pw);

		int i;
		boolean printed = false;

		i = -1;
		int lastIndex = mHistoryNext;
		int ringIndex = lastIndex;
		do {
		// increasing index = more recent entry, and we want to print the most
		// recent first and work backwards, so we roll through the ring backwards.
		ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_HISTORY);
		BroadcastRecord r = mBroadcastHistory[ringIndex];
		if (r == null) {
		continue;
		}

		i++; // genuine record of some sort even if we're filtering it out
		if (dumpPackage != null && !dumpPackage.equals(r.callerPackage)) {
		continue;
		}
		if (!printed) {
		if (needSep) {
		pw.println();
		}
		needSep = true;
		pw.println(" Historical broadcasts [" + mQueueName + "]:");
		printed = true;
		}
		if (dumpAll) {
		pw.print(" Historical Broadcast " + mQueueName + " #");
		pw.print(i); pw.println(":");
		r.dump(pw, " ", sdf);
		} else {
		pw.print(" #"); pw.print(i); pw.print(": "); pw.println(r);
		pw.print(" ");
		pw.println(r.intent.toShortString(false, true, true, false));
		if (r.targetComp != null && r.targetComp != r.intent.getComponent()) {
		pw.print(" targetComp: "); pw.println(r.targetComp.toShortString());
		}
		Bundle bundle = r.intent.getExtras();
		if (bundle != null) {
		pw.print(" extras: "); pw.println(bundle.toString());
		}
		}
		} while (ringIndex != lastIndex);

		if (dumpPackage == null) {
		lastIndex = ringIndex = mSummaryHistoryNext;
		if (dumpAll) {
		printed = false;
		i = -1;
		} else {
		// roll over the 'i' full dumps that have already been issued
		for (int j = i;
		j > 0 && ringIndex != lastIndex;) {
		ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_SUMMARY_HISTORY);
		BroadcastRecord r = mBroadcastHistory[ringIndex];
		if (r == null) {
		continue;
		}
		j--;
		}
		}
		// done skipping; dump the remainder of the ring. 'i' is still the ordinal within
		// the overall broadcast history.
		do {
		ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_SUMMARY_HISTORY);
		Intent intent = mBroadcastSummaryHistory[ringIndex];
		if (intent == null) {
		continue;
		}
		if (!printed) {
		if (needSep) {
		pw.println();
		}
		needSep = true;
		pw.println(" Historical broadcasts summary [" + mQueueName + "]:");
		printed = true;
		}
		if (!dumpAll && i >= 50) {
		pw.println(" ...");
		break;
		}
		i++;
		pw.print(" #"); pw.print(i); pw.print(": ");
		pw.println(intent.toShortString(false, true, true, false));
		pw.print(" ");
		TimeUtils.formatDuration(mSummaryHistoryDispatchTime[ringIndex]
		- mSummaryHistoryEnqueueTime[ringIndex], pw);
		pw.print(" dispatch ");
		TimeUtils.formatDuration(mSummaryHistoryFinishTime[ringIndex]
		- mSummaryHistoryDispatchTime[ringIndex], pw);
		pw.println(" finish");
		pw.print(" enq=");
		pw.print(sdf.format(new Date(mSummaryHistoryEnqueueTime[ringIndex])));
		pw.print(" disp=");
		pw.print(sdf.format(new Date(mSummaryHistoryDispatchTime[ringIndex])));
		pw.print(" fin=");
		pw.println(sdf.format(new Date(mSummaryHistoryFinishTime[ringIndex])));
		Bundle bundle = intent.getExtras();
		if (bundle != null) {
		pw.print(" extras: "); pw.println(bundle.toString());
		}
		} while (ringIndex != lastIndex);
		}

		needSep = mHistory.dumpLocked(pw, dumpPackage, mQueueName, sdf, dumpAll, needSep);
		return needSep;
		}
		}

services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueTest.java

+5 −1

Original line number	Diff line number	Diff line
		@@ -168,10 +168,14 @@ public class BroadcastQueueTest {
		return false;
		}
		};
		final BroadcastHistory emptyHistory = new BroadcastHistory() {
		public void addBroadcastToHistoryLocked(BroadcastRecord original) {
		}
		};

		if (mImpl == Impl.DEFAULT) {
		mQueue = new BroadcastQueueImpl(mAms, mHandlerThread.getThreadHandler(), TAG,
		constants, emptySkipPolicy, false);
		constants, emptySkipPolicy, emptyHistory, false);
		} else {
		throw new UnsupportedOperationException();
		}