Consolidate freezer routines
Consolidate freezer routines used by the ActivityManagerService into a
new, single Freezer class. ActivityManagerService.Injector provides a
Freezer to ActivityManagerService; this instance is used everywhere in
the ActivityManager code.
There is no change to behavior if the default Freezer instance (as
created by the default Injector) is used. However, the injector can
supply a mocked Freezer (or a Freezer subclass) for testing.
Test: atest
* FrameworksServicesTests:com.android.server.am
* FrameworksMockingServicesTests:com.android.server.am
Flag: EXEMPT refactor
Bug: 326315985
Change-Id: I9da0b3dc0f52b1e1573e56b3cbfaebc74f830f42
diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java
index cf0befa..33f33fb 100644
--- a/services/core/java/com/android/server/am/ActivityManagerService.java
+++ b/services/core/java/com/android/server/am/ActivityManagerService.java
@@ -1716,6 +1716,12 @@
*/
@Nullable volatile ContentCaptureManagerInternal mContentCaptureService;
+ /**
+ * The interface to the freezer.
+ */
+ @NonNull
+ private final Freezer mFreezer;
+
/*
* The default duration for the binder heavy hitter auto sampler
*/
@@ -2506,6 +2512,7 @@
@Nullable UserController userController) {
mInjector = injector;
mContext = mInjector.getContext();
+ mFreezer = injector.getFreezer();
mUiContext = null;
mAppErrors = injector.getAppErrors();
mPackageWatchdog = null;
@@ -2555,6 +2562,7 @@
LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
mInjector = new Injector(systemContext);
mContext = systemContext;
+ mFreezer = mInjector.getFreezer();
mFactoryTest = FactoryTest.getMode();
mSystemThread = ActivityThread.currentActivityThread();
@@ -20919,6 +20927,11 @@
public IntentFirewall getIntentFirewall() {
return null;
}
+
+ /** @return the default Freezer. */
+ public Freezer getFreezer() {
+ return new Freezer();
+ }
}
@Override
@@ -21022,7 +21035,7 @@
final long token = Binder.clearCallingIdentity();
try {
- return CachedAppOptimizer.isFreezerSupported();
+ return mFreezer.isFreezerSupported();
} finally {
Binder.restoreCallingIdentity(token);
}
@@ -21177,4 +21190,9 @@
void clearPendingTopAppLocked() {
mPendingStartActivityUids.clear();
}
+
+ @NonNull
+ Freezer getFreezer() {
+ return mFreezer;
+ }
}
diff --git a/services/core/java/com/android/server/am/CachedAppOptimizer.java b/services/core/java/com/android/server/am/CachedAppOptimizer.java
index 1c4ffbb..11e8353 100644
--- a/services/core/java/com/android/server/am/CachedAppOptimizer.java
+++ b/services/core/java/com/android/server/am/CachedAppOptimizer.java
@@ -664,6 +664,8 @@
private final ProcessDependencies mProcessDependencies;
private final ProcLocksReader mProcLocksReader;
+ private final Freezer mFreezer;
+
public CachedAppOptimizer(ActivityManagerService am) {
this(am, null, new DefaultProcessDependencies());
}
@@ -680,6 +682,7 @@
mTestCallback = callback;
mSettingsObserver = new SettingsContentObserver();
mProcLocksReader = new ProcLocksReader();
+ mFreezer = mAm.getFreezer();
}
/**
@@ -1050,89 +1053,6 @@
}
/**
- * Informs binder that a process is about to be frozen. If freezer is enabled on a process via
- * this method, this method will synchronously dispatch all pending transactions to the
- * specified pid. This method will not add significant latencies when unfreezing.
- * After freezing binder calls, binder will block all transaction to the frozen pid, and return
- * an error to the sending process.
- *
- * @param pid the target pid for which binder transactions are to be frozen
- * @param freeze specifies whether to flush transactions and then freeze (true) or unfreeze
- * binder for the specificed pid.
- * @param timeoutMs the timeout in milliseconds to wait for the binder interface to freeze
- * before giving up.
- *
- * @throws RuntimeException in case a flush/freeze operation could not complete successfully.
- * @return 0 if success, or -EAGAIN indicating there's pending transaction.
- */
- public static native int freezeBinder(int pid, boolean freeze, int timeoutMs);
-
- /**
- * Retrieves binder freeze info about a process.
- * @param pid the pid for which binder freeze info is to be retrieved.
- *
- * @throws RuntimeException if the operation could not complete successfully.
- * @return a bit field reporting the binder freeze info for the process.
- */
- private static native int getBinderFreezeInfo(int pid);
-
- /**
- * Returns the path to be checked to verify whether the freezer is supported by this system.
- * @return absolute path to the file
- */
- private static native String getFreezerCheckPath();
-
- /**
- * Check if task_profiles.json includes valid freezer profiles and actions
- * @return false if there are invalid profiles or actions
- */
- private static native boolean isFreezerProfileValid();
-
- /**
- * Determines whether the freezer is supported by this system
- */
- public static boolean isFreezerSupported() {
- boolean supported = false;
- FileReader fr = null;
-
- try {
- String path = getFreezerCheckPath();
- Slog.d(TAG_AM, "Checking cgroup freezer: " + path);
- fr = new FileReader(path);
- char state = (char) fr.read();
-
- if (state == '1' || state == '0') {
- // Also check freezer binder ioctl
- Slog.d(TAG_AM, "Checking binder freezer ioctl");
- getBinderFreezeInfo(Process.myPid());
-
- // Check if task_profiles.json contains invalid profiles
- Slog.d(TAG_AM, "Checking freezer profiles");
- supported = isFreezerProfileValid();
- } else {
- Slog.e(TAG_AM, "Unexpected value in cgroup.freeze");
- }
- } catch (java.io.FileNotFoundException e) {
- Slog.w(TAG_AM, "File cgroup.freeze not present");
- } catch (RuntimeException e) {
- Slog.w(TAG_AM, "Unable to read freezer info");
- } catch (Exception e) {
- Slog.w(TAG_AM, "Unable to read cgroup.freeze: " + e.toString());
- }
-
- if (fr != null) {
- try {
- fr.close();
- } catch (java.io.IOException e) {
- Slog.e(TAG_AM, "Exception closing cgroup.freeze: " + e.toString());
- }
- }
-
- Slog.d(TAG_AM, "Freezer supported: " + supported);
- return supported;
- }
-
- /**
* Reads the flag value from DeviceConfig to determine whether app freezer
* should be enabled, and starts the freeze/compaction thread if needed.
*/
@@ -1146,7 +1066,7 @@
} else if ("enabled".equals(configOverride)
|| DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER_NATIVE_BOOT,
KEY_USE_FREEZER, DEFAULT_USE_FREEZER)) {
- mUseFreezer = isFreezerSupported();
+ mUseFreezer = mFreezer.isFreezerSupported();
updateFreezerDebounceTimeout();
updateFreezerExemptInstPkg();
} else {
@@ -1528,7 +1448,7 @@
boolean processKilled = false;
try {
- int freezeInfo = getBinderFreezeInfo(pid);
+ int freezeInfo = mFreezer.getBinderFreezeInfo(pid);
if ((freezeInfo & SYNC_RECEIVED_WHILE_FROZEN) != 0) {
Slog.d(TAG_AM, "pid " + pid + " " + app.processName
@@ -1562,7 +1482,7 @@
long freezeTime = opt.getFreezeUnfreezeTime();
try {
- freezeBinder(pid, false, FREEZE_BINDER_TIMEOUT_MS);
+ mFreezer.freezeBinder(pid, false, FREEZE_BINDER_TIMEOUT_MS);
} catch (RuntimeException e) {
Slog.e(TAG_AM, "Unable to unfreeze binder for " + pid + " " + app.processName
+ ". Killing it");
@@ -1574,7 +1494,7 @@
try {
traceAppFreeze(app.processName, pid, reason);
- Process.setProcessFrozen(pid, app.uid, false);
+ mFreezer.setProcessFrozen(pid, app.uid, false);
opt.setFreezeUnfreezeTime(SystemClock.uptimeMillis());
opt.setFrozen(false);
@@ -1617,7 +1537,7 @@
}
Slog.d(TAG_AM, "quick sync unfreeze " + pid + " for " + reason);
try {
- freezeBinder(pid, false, FREEZE_BINDER_TIMEOUT_MS);
+ mFreezer.freezeBinder(pid, false, FREEZE_BINDER_TIMEOUT_MS);
} catch (RuntimeException e) {
Slog.e(TAG_AM, "Unable to quick unfreeze binder for " + pid);
return;
@@ -1625,7 +1545,7 @@
try {
traceAppFreeze(app.processName, pid, reason);
- Process.setProcessFrozen(pid, app.uid, false);
+ mFreezer.setProcessFrozen(pid, app.uid, false);
} catch (Exception e) {
Slog.e(TAG_AM, "Unable to quick unfreeze " + pid);
}
@@ -2394,7 +2314,7 @@
// Freeze binder interface before the process, to flush any
// transactions that might be pending.
try {
- if (freezeBinder(pid, true, FREEZE_BINDER_TIMEOUT_MS) != 0) {
+ if (mFreezer.freezeBinder(pid, true, FREEZE_BINDER_TIMEOUT_MS) != 0) {
handleBinderFreezerFailure(proc, "outstanding txns");
return;
}
@@ -2413,7 +2333,7 @@
try {
traceAppFreeze(proc.processName, pid, -1);
- Process.setProcessFrozen(pid, proc.uid, true);
+ mFreezer.setProcessFrozen(pid, proc.uid, true);
opt.setFreezeUnfreezeTime(SystemClock.uptimeMillis());
opt.setFrozen(true);
opt.setHasCollectedFrozenPSS(false);
@@ -2452,7 +2372,7 @@
try {
// post-check to prevent races
- int freezeInfo = getBinderFreezeInfo(pid);
+ int freezeInfo = mFreezer.getBinderFreezeInfo(pid);
if ((freezeInfo & TXNS_PENDING_WHILE_FROZEN) != 0) {
synchronized (mProcLock) {
@@ -2620,6 +2540,22 @@
}
/**
+ * Freeze or unfreeze a process. This should only be used for testing.
+ */
+ @VisibleForTesting
+ void forceFreezeForTest(ProcessRecord proc, boolean freeze) {
+ synchronized (mAm) {
+ synchronized (mProcLock) {
+ if (freeze) {
+ forceFreezeAppAsyncLSP(proc);
+ } else {
+ unfreezeAppInternalLSP(proc, UNFREEZE_REASON_NONE, true);
+ }
+ }
+ }
+ }
+
+ /**
* Sending binder transactions to frozen apps most likely indicates there's a bug. Log it and
* kill the frozen apps if they 1) receive sync binder transactions while frozen, or 2) miss
* async binder transactions due to kernel binder buffer running out.
@@ -2660,7 +2596,7 @@
for (int i = 0; i < pids.size(); i++) {
int current = pids.get(i);
try {
- int freezeInfo = getBinderFreezeInfo(current);
+ int freezeInfo = mFreezer.getBinderFreezeInfo(current);
if ((freezeInfo & SYNC_RECEIVED_WHILE_FROZEN) != 0) {
killProcess(current, "Sync transaction while frozen",
diff --git a/services/core/java/com/android/server/am/Freezer.java b/services/core/java/com/android/server/am/Freezer.java
new file mode 100644
index 0000000..3b3cf55
--- /dev/null
+++ b/services/core/java/com/android/server/am/Freezer.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2024 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 static com.android.server.am.ActivityManagerDebugConfig.TAG_AM;
+
+import android.os.Process;
+
+/**
+ * A collection of interfaces to manage the freezer. All access to the freezer goes through an
+ * instance of this class. The class can be overridden for testing.
+ *
+ * Methods may be called without external synchronization. Multiple instances of this class can be
+ * used concurrently.
+ */
+class Freezer {
+
+ /**
+ * Freeze or unfreeze the specified process.
+ *
+ * @param pid Identifier of the process to freeze or unfreeze.
+ * @param uid Identifier of the user the process is running under.
+ * @param frozen Specify whether to free (true) or unfreeze (false).
+ */
+ public void setProcessFrozen(int pid, int uid, boolean frozen) {
+ Process.setProcessFrozen(pid, uid, frozen);
+ }
+
+ /**
+ * Informs binder that a process is about to be frozen. If freezer is enabled on a process via
+ * this method, this method will synchronously dispatch all pending transactions to the
+ * specified pid. This method will not add significant latencies when unfreezing.
+ * After freezing binder calls, binder will block all transaction to the frozen pid, and return
+ * an error to the sending process.
+ *
+ * @param pid the target pid for which binder transactions are to be frozen
+ * @param freeze specifies whether to flush transactions and then freeze (true) or unfreeze
+ * binder for the specified pid.
+ * @param timeoutMs the timeout in milliseconds to wait for the binder interface to freeze
+ * before giving up.
+ *
+ * @throws RuntimeException in case a flush/freeze operation could not complete successfully.
+ * @return 0 if success, or -EAGAIN indicating there's pending transaction.
+ */
+ public int freezeBinder(int pid, boolean freeze, int timeoutMs) {
+ return nativeFreezeBinder(pid, freeze, timeoutMs);
+ }
+
+ /**
+ * Retrieves binder freeze info about a process.
+ * @param pid the pid for which binder freeze info is to be retrieved.
+ *
+ * @throws RuntimeException if the operation could not complete successfully.
+ * @return a bit field reporting the binder freeze info for the process.
+ */
+ public int getBinderFreezeInfo(int pid) {
+ return nativeGetBinderFreezeInfo(pid);
+ }
+
+ /**
+ * Determines whether the freezer is supported by this system.
+ * @return true if the freezer is supported.
+ */
+ public boolean isFreezerSupported() {
+ return nativeIsFreezerSupported();
+ }
+
+ // Native methods
+
+ /**
+ * Informs binder that a process is about to be frozen. If freezer is enabled on a process via
+ * this method, this method will synchronously dispatch all pending transactions to the
+ * specified pid. This method will not add significant latencies when unfreezing.
+ * After freezing binder calls, binder will block all transaction to the frozen pid, and return
+ * an error to the sending process.
+ *
+ * @param pid the target pid for which binder transactions are to be frozen
+ * @param freeze specifies whether to flush transactions and then freeze (true) or unfreeze
+ * binder for the specified pid.
+ * @param timeoutMs the timeout in milliseconds to wait for the binder interface to freeze
+ * before giving up.
+ *
+ * @throws RuntimeException in case a flush/freeze operation could not complete successfully.
+ * @return 0 if success, or -EAGAIN indicating there's pending transaction.
+ */
+ private static native int nativeFreezeBinder(int pid, boolean freeze, int timeoutMs);
+
+ /**
+ * Retrieves binder freeze info about a process.
+ * @param pid the pid for which binder freeze info is to be retrieved.
+ *
+ * @throws RuntimeException if the operation could not complete successfully.
+ * @return a bit field reporting the binder freeze info for the process.
+ */
+ private static native int nativeGetBinderFreezeInfo(int pid);
+
+ /**
+ * Return 0 if the freezer is supported on this platform and -1 otherwise.
+ */
+ private static native boolean nativeIsFreezerSupported();
+}
diff --git a/services/core/java/com/android/server/am/ProcessList.java b/services/core/java/com/android/server/am/ProcessList.java
index 726e827..bb0c24b 100644
--- a/services/core/java/com/android/server/am/ProcessList.java
+++ b/services/core/java/com/android/server/am/ProcessList.java
@@ -3005,7 +3005,7 @@
return freezePackageCgroup(packageUID, false);
}
- private static void freezeBinderAndPackageCgroup(List<Pair<ProcessRecord, Boolean>> procs,
+ private void freezeBinderAndPackageCgroup(List<Pair<ProcessRecord, Boolean>> procs,
int packageUID) {
// Freeze all binder processes under the target UID (whose cgroup is about to be frozen).
// Since we're going to kill these, we don't need to unfreze them later.
@@ -3019,7 +3019,7 @@
try {
int rc;
do {
- rc = CachedAppOptimizer.freezeBinder(pid, true, 10 /* timeout_ms */);
+ rc = mService.getFreezer().freezeBinder(pid, true, 10 /* timeout_ms */);
} while (rc == -EAGAIN && nRetries++ < 1);
if (rc != 0) Slog.e(TAG, "Unable to freeze binder for " + pid + ": " + rc);
} catch (RuntimeException e) {
diff --git a/services/core/jni/Android.bp b/services/core/jni/Android.bp
index 9fa1a53..f1e94de 100644
--- a/services/core/jni/Android.bp
+++ b/services/core/jni/Android.bp
@@ -79,6 +79,7 @@
"com_android_server_wm_TaskFpsCallbackController.cpp",
"onload.cpp",
":lib_cachedAppOptimizer_native",
+ ":lib_freezer_native",
":lib_gameManagerService_native",
":lib_oomConnection_native",
":lib_anrTimer_native",
@@ -241,6 +242,13 @@
}
filegroup {
+ name: "lib_freezer_native",
+ srcs: [
+ "com_android_server_am_Freezer.cpp",
+ ],
+}
+
+filegroup {
name: "lib_gameManagerService_native",
srcs: [
"com_android_server_app_GameManagerService.cpp",
diff --git a/services/core/jni/com_android_server_am_CachedAppOptimizer.cpp b/services/core/jni/com_android_server_am_CachedAppOptimizer.cpp
index 95e7b19..a91fd08 100644
--- a/services/core/jni/com_android_server_am_CachedAppOptimizer.cpp
+++ b/services/core/jni/com_android_server_am_CachedAppOptimizer.cpp
@@ -24,7 +24,6 @@
#include <android-base/stringprintf.h>
#include <android-base/unique_fd.h>
#include <android_runtime/AndroidRuntime.h>
-#include <binder/IPCThreadState.h>
#include <cutils/compiler.h>
#include <dirent.h>
#include <jni.h>
@@ -34,7 +33,6 @@
#include <meminfo/procmeminfo.h>
#include <meminfo/sysmeminfo.h>
#include <nativehelper/JNIHelp.h>
-#include <processgroup/processgroup.h>
#include <stddef.h>
#include <stdio.h>
#include <sys/mman.h>
@@ -63,10 +61,6 @@
using VmaToAdviseFunc = std::function<int(const Vma&)>;
using android::base::unique_fd;
-#define SYNC_RECEIVED_WHILE_FROZEN (1)
-#define ASYNC_RECEIVED_WHILE_FROZEN (2)
-#define TXNS_PENDING_WHILE_FROZEN (4)
-
#define MAX_RW_COUNT (INT_MAX & kPageMask)
// Defines the maximum amount of VMAs we can send per process_madvise syscall.
@@ -527,58 +521,6 @@
compactProcessOrFallback(pid, compactionFlags);
}
-static jint com_android_server_am_CachedAppOptimizer_freezeBinder(JNIEnv* env, jobject clazz,
- jint pid, jboolean freeze,
- jint timeout_ms) {
- jint retVal = IPCThreadState::freeze(pid, freeze, timeout_ms);
- if (retVal != 0 && retVal != -EAGAIN) {
- jniThrowException(env, "java/lang/RuntimeException", "Unable to freeze/unfreeze binder");
- }
-
- return retVal;
-}
-
-static jint com_android_server_am_CachedAppOptimizer_getBinderFreezeInfo(JNIEnv *env,
- jobject clazz, jint pid) {
- uint32_t syncReceived = 0, asyncReceived = 0;
-
- int error = IPCThreadState::getProcessFreezeInfo(pid, &syncReceived, &asyncReceived);
-
- if (error < 0) {
- jniThrowException(env, "java/lang/RuntimeException", strerror(error));
- }
-
- jint retVal = 0;
-
- // bit 0 of sync_recv goes to bit 0 of retVal
- retVal |= syncReceived & SYNC_RECEIVED_WHILE_FROZEN;
- // bit 0 of async_recv goes to bit 1 of retVal
- retVal |= (asyncReceived << 1) & ASYNC_RECEIVED_WHILE_FROZEN;
- // bit 1 of sync_recv goes to bit 2 of retVal
- retVal |= (syncReceived << 1) & TXNS_PENDING_WHILE_FROZEN;
-
- return retVal;
-}
-
-static jstring com_android_server_am_CachedAppOptimizer_getFreezerCheckPath(JNIEnv* env,
- jobject clazz) {
- std::string path;
-
- if (!getAttributePathForTask("FreezerState", getpid(), &path)) {
- path = "";
- }
-
- return env->NewStringUTF(path.c_str());
-}
-
-static jboolean com_android_server_am_CachedAppOptimizer_isFreezerProfileValid(JNIEnv* env) {
- uid_t uid = getuid();
- pid_t pid = getpid();
-
- return isProfileValidForProcess("Frozen", uid, pid) &&
- isProfileValidForProcess("Unfrozen", uid, pid);
-}
-
static const JNINativeMethod sMethods[] = {
/* name, signature, funcPtr */
{"cancelCompaction", "()V",
@@ -592,13 +534,7 @@
(void*)com_android_server_am_CachedAppOptimizer_getMemoryFreedCompaction},
{"compactSystem", "()V", (void*)com_android_server_am_CachedAppOptimizer_compactSystem},
{"compactProcess", "(II)V", (void*)com_android_server_am_CachedAppOptimizer_compactProcess},
- {"freezeBinder", "(IZI)I", (void*)com_android_server_am_CachedAppOptimizer_freezeBinder},
- {"getBinderFreezeInfo", "(I)I",
- (void*)com_android_server_am_CachedAppOptimizer_getBinderFreezeInfo},
- {"getFreezerCheckPath", "()Ljava/lang/String;",
- (void*)com_android_server_am_CachedAppOptimizer_getFreezerCheckPath},
- {"isFreezerProfileValid", "()Z",
- (void*)com_android_server_am_CachedAppOptimizer_isFreezerProfileValid}};
+};
int register_android_server_am_CachedAppOptimizer(JNIEnv* env)
{
diff --git a/services/core/jni/com_android_server_am_Freezer.cpp b/services/core/jni/com_android_server_am_Freezer.cpp
new file mode 100644
index 0000000..8148728
--- /dev/null
+++ b/services/core/jni/com_android_server_am_Freezer.cpp
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "Freezer"
+//#define LOG_NDEBUG 0
+#define ATRACE_TAG ATRACE_TAG_ACTIVITY_MANAGER
+
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <binder/IPCThreadState.h>
+#include <nativehelper/JNIHelp.h>
+#include <processgroup/processgroup.h>
+
+namespace android {
+namespace {
+
+// Binder status bit flags.
+static const int SYNC_RECEIVED_WHILE_FROZEN = 1;
+static const int ASYNC_RECEIVED_WHILE_FROZEN = 2;
+static const int TXNS_PENDING_WHILE_FROZEN = 4;
+
+jint freezeBinder(JNIEnv* env, jobject, jint pid, jboolean freeze, jint timeout_ms) {
+ jint retVal = IPCThreadState::freeze(pid, freeze, timeout_ms);
+ if (retVal != 0 && retVal != -EAGAIN) {
+ jniThrowException(env, "java/lang/RuntimeException", "Unable to freeze/unfreeze binder");
+ }
+
+ return retVal;
+}
+
+jint getBinderFreezeInfo(JNIEnv *env, jobject, jint pid) {
+ uint32_t syncReceived = 0, asyncReceived = 0;
+
+ int error = IPCThreadState::getProcessFreezeInfo(pid, &syncReceived, &asyncReceived);
+
+ if (error < 0) {
+ jniThrowException(env, "java/lang/RuntimeException", strerror(error));
+ }
+
+ jint retVal = 0;
+
+ // bit 0 of sync_recv goes to bit 0 of retVal
+ retVal |= syncReceived & SYNC_RECEIVED_WHILE_FROZEN;
+ // bit 0 of async_recv goes to bit 1 of retVal
+ retVal |= (asyncReceived << 1) & ASYNC_RECEIVED_WHILE_FROZEN;
+ // bit 1 of sync_recv goes to bit 2 of retVal
+ retVal |= (syncReceived << 1) & TXNS_PENDING_WHILE_FROZEN;
+
+ return retVal;
+}
+
+bool isFreezerSupported(JNIEnv *env, jclass) {
+ std::string path;
+ if (!getAttributePathForTask("FreezerState", getpid(), &path)) {
+ ALOGI("No attribute for FreezerState");
+ return false;
+ }
+ base::unique_fd fid(open(path.c_str(), O_RDONLY));
+ if (fid < 0) {
+ ALOGI("Cannot open freezer path \"%s\": %s", path.c_str(), strerror(errno));
+ return false;
+ }
+
+ char state;
+ if (::read(fid, &state, 1) != 1) {
+ ALOGI("Failed to read freezer state: %s", strerror(errno));
+ return false;
+ }
+ if (state != '1' && state != '0') {
+ ALOGE("Unexpected value in cgroup.freeze: %d", state);
+ return false;
+ }
+
+ uid_t uid = getuid();
+ pid_t pid = getpid();
+
+ uint32_t syncReceived = 0, asyncReceived = 0;
+ int error = IPCThreadState::getProcessFreezeInfo(pid, &syncReceived, &asyncReceived);
+ if (error < 0) {
+ ALOGE("Unable to read freezer info: %s", strerror(errno));
+ return false;
+ }
+
+ if (!isProfileValidForProcess("Frozen", uid, pid)
+ || !isProfileValidForProcess("Unfrozen", uid, pid)) {
+ ALOGE("Missing freezer profiles");
+ return false;
+ }
+
+ return true;
+}
+
+static const JNINativeMethod sMethods[] = {
+ {"nativeIsFreezerSupported", "()Z", (void*) isFreezerSupported },
+ {"nativeFreezeBinder", "(IZI)I", (void*) freezeBinder },
+ {"nativeGetBinderFreezeInfo", "(I)I", (void*) getBinderFreezeInfo },
+};
+
+} // end of anonymous namespace
+
+int register_android_server_am_Freezer(JNIEnv* env)
+{
+ char const *className = "com/android/server/am/Freezer";
+ return jniRegisterNativeMethods(env, className, sMethods, NELEM(sMethods));
+}
+
+} // end of namespace android
diff --git a/services/core/jni/onload.cpp b/services/core/jni/onload.cpp
index 314ff9d..3c55d18 100644
--- a/services/core/jni/onload.cpp
+++ b/services/core/jni/onload.cpp
@@ -54,6 +54,7 @@
int register_android_hardware_display_DisplayViewport(JNIEnv* env);
int register_android_server_am_OomConnection(JNIEnv* env);
int register_android_server_am_CachedAppOptimizer(JNIEnv* env);
+int register_android_server_am_Freezer(JNIEnv* env);
int register_android_server_am_LowMemDetector(JNIEnv* env);
int register_android_server_utils_AnrTimer(JNIEnv *env);
int register_com_android_server_soundtrigger_middleware_AudioSessionProviderImpl(JNIEnv* env);
@@ -118,6 +119,7 @@
register_android_hardware_display_DisplayViewport(env);
register_android_server_am_OomConnection(env);
register_android_server_am_CachedAppOptimizer(env);
+ register_android_server_am_Freezer(env);
register_android_server_am_LowMemDetector(env);
register_android_server_utils_AnrTimer(env);
register_com_android_server_soundtrigger_middleware_AudioSessionProviderImpl(env);
diff --git a/services/tests/mockingservicestests/jni/Android.bp b/services/tests/mockingservicestests/jni/Android.bp
index 1eb9888..00543a8 100644
--- a/services/tests/mockingservicestests/jni/Android.bp
+++ b/services/tests/mockingservicestests/jni/Android.bp
@@ -21,6 +21,7 @@
srcs: [
":lib_cachedAppOptimizer_native",
+ ":lib_freezer_native",
":lib_gameManagerService_native",
":lib_oomConnection_native",
"onload.cpp",
diff --git a/services/tests/mockingservicestests/jni/onload.cpp b/services/tests/mockingservicestests/jni/onload.cpp
index fb91051..cb246d1 100644
--- a/services/tests/mockingservicestests/jni/onload.cpp
+++ b/services/tests/mockingservicestests/jni/onload.cpp
@@ -25,6 +25,7 @@
namespace android {
int register_android_server_am_CachedAppOptimizer(JNIEnv* env);
+int register_android_server_am_Freezer(JNIEnv* env);
int register_android_server_app_GameManagerService(JNIEnv* env);
int register_android_server_am_OomConnection(JNIEnv* env);
};
@@ -42,8 +43,8 @@
}
ALOG_ASSERT(env, "Could not retrieve the env!");
register_android_server_am_CachedAppOptimizer(env);
+ register_android_server_am_Freezer(env);
register_android_server_app_GameManagerService(env);
register_android_server_am_OomConnection(env);
return JNI_VERSION_1_4;
}
-
diff --git a/services/tests/mockingservicestests/src/com/android/server/am/CachedAppOptimizerTest.java b/services/tests/mockingservicestests/src/com/android/server/am/CachedAppOptimizerTest.java
index 03439e55..32ff569 100644
--- a/services/tests/mockingservicestests/src/com/android/server/am/CachedAppOptimizerTest.java
+++ b/services/tests/mockingservicestests/src/com/android/server/am/CachedAppOptimizerTest.java
@@ -22,8 +22,16 @@
import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.anyInt;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
import android.content.ComponentName;
import android.content.Context;
@@ -33,12 +41,14 @@
import android.os.HandlerThread;
import android.os.MessageQueue;
import android.os.Process;
+import android.os.SystemClock;
import android.platform.test.annotations.Presubmit;
import android.provider.DeviceConfig;
import android.text.TextUtils;
import androidx.test.platform.app.InstrumentationRegistry;
+import com.android.internal.annotations.GuardedBy;
import com.android.modules.utils.testing.ExtendedMockitoRule;
import com.android.modules.utils.testing.TestableDeviceConfig;
import com.android.server.LocalServices;
@@ -55,9 +65,11 @@
import java.io.File;
import java.io.IOException;
+import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
/**
@@ -79,12 +91,17 @@
private CountDownLatch mCountDown;
private ActivityManagerService mAms;
private Context mContext;
+ private TestFreezer mFreezer;
+ private CountDownLatch mFreezeCounter;
private TestInjector mInjector;
private TestProcessDependencies mProcessDependencies;
@Mock
private PackageManagerInternal mPackageManagerInt;
+ // Control whether the freezer mock reports that freezing is enabled or not.
+ private boolean mUseFreezer;
+
@Rule
public final ApplicationExitInfoTest.ServiceThreadRule
mServiceThreadRule = new ApplicationExitInfoTest.ServiceThreadRule();
@@ -103,9 +120,12 @@
true /* allowIo */);
mThread.start();
mContext = InstrumentationRegistry.getInstrumentation().getContext();
+
+ mUseFreezer = false;
+ mFreezer = new TestFreezer();
+
mInjector = new TestInjector(mContext);
- mAms = new ActivityManagerService(
- new TestInjector(mContext), mServiceThreadRule.getThread());
+ mAms = new ActivityManagerService(mInjector, mServiceThreadRule.getThread());
doReturn(new ComponentName("", "")).when(mPackageManagerInt).getSystemUiServiceComponent();
mProcessDependencies = new TestProcessDependencies();
mCachedAppOptimizerUnderTest = new CachedAppOptimizer(mAms,
@@ -126,6 +146,7 @@
mHandlerThread.quit();
mThread.quit();
mCountDown = null;
+ mFreezeCounter = null;
}
private ProcessRecord makeProcessRecord(int pid, int uid, int packageUid, String processName,
@@ -179,7 +200,7 @@
assertThat(mCachedAppOptimizerUnderTest.mProcStateThrottle)
.containsExactlyElementsIn(expected);
- Assume.assumeTrue(mCachedAppOptimizerUnderTest.isFreezerSupported());
+ Assume.assumeTrue(mAms.isAppFreezerSupported());
assertThat(mCachedAppOptimizerUnderTest.useFreezer()).isEqualTo(
CachedAppOptimizer.DEFAULT_USE_FREEZER);
}
@@ -265,8 +286,8 @@
CachedAppOptimizer.DEFAULT_COMPACT_FULL_RSS_THROTTLE_KB + 1);
assertThat(mCachedAppOptimizerUnderTest.mProcStateThrottle).containsExactly(1, 2, 3);
- Assume.assumeTrue(CachedAppOptimizer.isFreezerSupported());
- if (CachedAppOptimizer.isFreezerSupported()) {
+ Assume.assumeTrue(mAms.isAppFreezerSupported());
+ if (mAms.isAppFreezerSupported()) {
if (CachedAppOptimizer.DEFAULT_USE_FREEZER) {
assertThat(mCachedAppOptimizerUnderTest.useFreezer()).isFalse();
} else {
@@ -300,7 +321,7 @@
@Test
public void useFreeze_doesNotListenToDeviceConfigChanges() throws InterruptedException {
- Assume.assumeTrue(CachedAppOptimizer.isFreezerSupported());
+ Assume.assumeTrue(mAms.isAppFreezerSupported());
assertThat(mCachedAppOptimizerUnderTest.useFreezer()).isFalse();
@@ -353,7 +374,7 @@
@Test
public void useFreeze_listensToDeviceConfigChangesBadValues() throws InterruptedException {
- Assume.assumeTrue(CachedAppOptimizer.isFreezerSupported());
+ Assume.assumeTrue(mAms.isAppFreezerSupported());
assertThat(mCachedAppOptimizerUnderTest.useFreezer()).isFalse();
// When we push an invalid flag value...
@@ -982,6 +1003,40 @@
}
}
+ @Test
+ public void testFreezerDelegator() throws Exception {
+ mUseFreezer = true;
+ mProcessDependencies.setRss(new long[] {
+ 0 /*total_rss*/,
+ 0 /*file*/,
+ 0 /*anon*/,
+ 0 /*swap*/,
+ 0 /*shmem*/
+ });
+
+ // Force the system to use the freezer
+ DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER_NATIVE_BOOT,
+ CachedAppOptimizer.KEY_USE_FREEZER, "true", false);
+ mCachedAppOptimizerUnderTest.init();
+ initActivityManagerService();
+
+ assertTrue(mAms.isAppFreezerSupported());
+ assertThat(mCachedAppOptimizerUnderTest.useFreezer()).isTrue();
+
+ int pid = 10000;
+ int uid = 2;
+ int pkgUid = 3;
+ ProcessRecord app = makeProcessRecord(pid, uid, pkgUid, "p1", "app1");
+
+ mFreezeCounter = new CountDownLatch(1);
+ mCachedAppOptimizerUnderTest.forceFreezeForTest(app, true);
+ assertTrue(mFreezeCounter.await(5, TimeUnit.SECONDS));
+
+ mFreezeCounter = new CountDownLatch(1);
+ mCachedAppOptimizerUnderTest.forceFreezeForTest(app, false);
+ assertTrue(mFreezeCounter.await(5, TimeUnit.SECONDS));
+ }
+
private void setFlag(String key, String value, boolean defaultValue) throws Exception {
mCountDown = new CountDownLatch(1);
DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, key, value, defaultValue);
@@ -1042,6 +1097,11 @@
public Handler getUiHandler(ActivityManagerService service) {
return mHandler;
}
+
+ @Override
+ public Freezer getFreezer() {
+ return mFreezer;
+ }
}
// Test implementation for ProcessDependencies.
@@ -1069,4 +1129,27 @@
mRssAfterCompaction = newValues;
}
}
+
+ // Intercept Freezer calls.
+ private class TestFreezer extends Freezer {
+ @Override
+ public void setProcessFrozen(int pid, int uid, boolean frozen) {
+ mFreezeCounter.countDown();
+ }
+
+ @Override
+ public int freezeBinder(int pid, boolean freeze, int timeoutMs) {
+ return 0;
+ }
+
+ @Override
+ public int getBinderFreezeInfo(int pid) {
+ return 0;
+ }
+
+ @Override
+ public boolean isFreezerSupported() {
+ return mUseFreezer;
+ }
+ }
}
diff --git a/services/tests/servicestests/jni/Android.bp b/services/tests/servicestests/jni/Android.bp
index c30e4eb..0a31037 100644
--- a/services/tests/servicestests/jni/Android.bp
+++ b/services/tests/servicestests/jni/Android.bp
@@ -21,6 +21,7 @@
srcs: [
":lib_cachedAppOptimizer_native",
+ ":lib_freezer_native",
":lib_gameManagerService_native",
":lib_oomConnection_native",
":lib_anrTimer_native",
